zoj.3868.GCD Expectation(数学推导>>容斥原理）

GCD Expectation

---

Time Limit: 4 Seconds                                     Memory Limit: 262144 KB                            

---

Edward has a set of n integers {a₁, a₂,...,a_n}. He randomly picks a nonempty subset {x₁, x₂,…,x_m} (each nonempty subset has equal probability to be picked), and would like to know the expectation of [gcd(x₁, x₂,…,x_m)]^k.

Note that gcd(x₁, x₂,…,x_m) is the greatest common divisor of {x₁, x₂,…,x_m}.

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains two integers n, k (1 ≤ n, k ≤ 10⁶). The second line contains n integers a₁, a₂,…,a_n (1 ≤ a_i ≤ 10⁶).

The sum of values max{a_i} for all the test cases does not exceed 2000000.

Output

For each case, if the expectation is E, output a single integer denotes E · (2ⁿ - 1) modulo 998244353.

Sample Input

1
5 1
1 2 3 4 5

Sample Output

42

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <stack>
 #include <queue>
 #include<map>
 #include <set>
 #include <vector>
 #include <math.h>
 using namespace std;
 #define ls 2*i
 #define rs 2*i+1
 #define up(i,x,y) for(i=x;i<=y;i++)
 #define down(i,x,y) for(i=x;i>=y;i--)
 #define mem(a,x) memset(a,x,sizeof(a))
 #define w(a) while(a)
 #define LL long long
 const double pi = acos(-1.0);
 #define Len 1000005
 #define mod 998244353
 const LL inf = <<;
 LL t,n,k;
 LL a[Len];
 LL two[Len],fun[Len],cnt[Len],vis[Len],maxn;
 LL power(LL x, LL y)
 {
     LL ans = ;
     w(y)
     {
         if(y&) ans=(ans*x)%mod;
         x=(x*x)%mod;
         y/=;
     }
     return ans;
 }
 int main()
 {
     LL i,j;
     scanf("%lld",&t);
     two[] = ;
     up(i,,Len-) two[i] = (two[i-]*)%mod;
     w(t--)
     {
         mem(cnt,);
         mem(vis,);
         scanf("%lld%lld",&n,&k);
         maxn = ;
         up(i,,n-)
         {
             scanf("%lld",&a[i]);
             if(!vis[a[i]])
             {
                 vis[a[i]] = ;
                 cnt[a[i]] = ;
             }
             else cnt[a[i]]++;
             maxn = max(maxn,a[i]);
         }
         fun[] = ;
         up(i,,maxn) fun[i] = power(i,k);
         up(i,,maxn)
         {
             for(j = i+i; j<=maxn; j+=i) fun[j]=(fun[j]-fun[i])%mod;
         }
         LL ans = (two[n]-)*fun[]%mod;
         up(i,,maxn)
         {
             LL cc = ;
             for(j = i; j<=maxn; j+=i)
             {
                 if(vis[j]) cc+=cnt[j];
             }
             LL tem = (two[cc]-)*fun[i]%mod;
             ans = (ans+tem)%mod;
         }
         printf("%lld\n",(ans+mod)%mod);
     }
     return ;
 }

对于N的序列，肯定有2^N-1个非空子集，其中其最大的GCD不会大于原序列的max，那么我们用数组fun来记录其期望
例如题目中的，期望为1的有26个，期望为2的有2个，期望为3,4,5的都只有1个
我们可以拆分来算，首先对于1，期望为1,1的倍数有5个，那么这五个的全部非空子集为2^5-1种，得到S=(2^5-1)*1;
对于2,2的期望应该是2，但是在期望为1的时候所有的子集中，我们重复计算了2的期望，多以我们应该减去重复计算的期望数，
现在2的期望应该作1算，那么对于2的倍数，有两个，2,4，其组成的非空子集有2^2-1个，所以得到S+=(2^2-1)*1
对于3,4,5同理；