BestCoder Round #78 (div.2)_B_ CA Loves GCD

CA Loves GCD
Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 707    Accepted Submission(s): 245
 
By YJQ 우 리 는 dp [i] [j] 를 명령 합 니 다. 앞의 i 개 수 중에서 몇 개의 숫자 를 선택 하여 gcd 를 j 로 하 는 방안 수 를 선택 하 십시오. 따라서 i + 1 개의 숫자 가 선택 되 었 는 지 여 부 를 매 거 져 서 옮 기 면 됩 니 다.
영제 i + 1 개 수 는 v 입 니 다. dp [i] [j] 를 고려 할 때 우 리 는 $dp [i + 1] [j] + = dp [i] j, dp [i + 1] [gcd (j, v)] + = dp [i] j 를 명령 합 니 다.
복잡 도 O (N * MaxV) MaxV 는 나타 난 수의 최대 값 이다.
사실 O (MaxV * log (MaxV) 의 방법 이 있 습 니 다. 우 리 는 f [i] 를 기억 하여 이 숫자 에서 몇 개의 수 를 선택 하여 그들의 gcd 를 i 의 배수 로 하 는 방안 수 를 표시 합 니 다.만약 에 K 개의 수가 i 의 배수 라면 f [i] = 2 ^ K - 1 은 g [i] 로 이 숫자 에서 몇 개의 수 를 선택 하여 그들의 gcd 를 i 의 방안 수 라 고 표시 하면 g [i] = f [i] - g [j] (모든 j 에 대한 i 의 배수).
조화 급수 에서 복잡 도 를 O (MaxV * log (MaxV) 로 얻 을 수 있다.Problem Description
CA is a fine comrade who loves the party and people; inevitably she loves GCD (greatest common divisor) too.
Now, there are
N different numbers. Each time, CA will select several numbers (at least one), and find the GCD of these numbers. In order to have fun, CA will try every selection. After that, she wants to know the sum of all GCDs.
If and only if there is a number exists in a selection, but does not exist in another one, we think these two selections are different from each other.
 
Input
First line contains
T denoting the number of testcases.
T testcases follow. Each testcase contains a integer in the first time, denoting
N , the number of the numbers CA have. The second line is
N numbers.
We guarantee that all numbers in the test are in the range [1,1000].
1≤T≤50
 
Output
T lines, each line prints the sum of GCDs mod
100000007 .
 
Sample Input

   
   
   
   

    
    
    
    2
2
2 4
3
1 2 3
   
   
   
   

 
Sample Output

   
   
   
   

    
    
    
    8
10
   
   
   
   

 
Source
BestCoder Round #78 (div.2)
 
Recommend
wange2014   |   We have carefully selected several similar problems for you:   5659  5658  5657  5654  5653
복잡 도 O (N * MaxV) 의 방법:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
using namespace std;
LL dp[1010][1010];//dp[i][j]    i  
                 // ，           gcd j    
int A[1010];
int gcd[1010][1010];
const LL MOD=1e8+7;
int __gcd(int x,int y)
{
    return (x!=0)?__gcd(y%x,x):y;
}
int main()
{
    int n,t;

    cin>>t;
    for(int i=1;i<=1000;i++)
    {
        for(int j=1;j<=1000;j++)
        {
            gcd[i][j]=__gcd(i,j);
        }
    }
    while(t--)
    {
        cin>>n;
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++)
        {
            scanf("%d",&A[i]);
        }
        sort(A,A+n);//               ；
        for(int i=0;i<n;i++)
        {
            for(int j=1;j<=A[i];j++)
            {
                (dp[i+1][j]+=dp[i][j])%=MOD;
                (dp[i+1][gcd[j][A[i]]]+=dp[i][j])%=MOD;
            }
            dp[i+1][A[i]]++;
        }
        LL ans=0;
        for(int i=1;i<=1000;i++)
            (ans+=dp[n][i]*i)%=MOD;
        printf("%I64d
",ans);
    }
    return 0;
}

O (MaxV * log (MaxV) 의 방법:

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
#include <queue>
#include <stack>
#define LL long long
using namespace std;
LL dp[1005];
LL cnt[1005];
const LL MOD=1e8+7;
LL power(LL x,LL n)
{
    LL ans=1;
    while(n)
    {
        if(n&1)
        {
            (ans*=x)%=MOD;
        }
        n>>=1;
        (x*=x)%=MOD;
    }
    return ans;
}
int main()
{
    int x;
    int t,n;
    int maxn;
    scanf("%d",&t);
    while(t--)
    {
        memset(dp,0,sizeof(dp));
        memset(cnt,0,sizeof(cnt));
        maxn=0;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d",&x);
            maxn=max(x,maxn);
            cnt[x]++;
        }
        LL ans=0,c;
        for(int i=maxn;i>=1;i--)
        {
            c=0;
            for(int j=i;j<=maxn;j+=i)
            {
                c+=cnt[j];
                (dp[i]=dp[i]-dp[j]+MOD)%=MOD;
            }
            (dp[i]+=(power(2,c)-1)%MOD)%=MOD;
            (ans+=i*dp[i])%=MOD;
        }
        printf("%I64d
",ans);
    }
    return 0;
}