hdu4407Sum(容斥原理)

http://acm.hdu.edu.cn/showproblem.php?pid=4407

Sum

Time Limit: 2000/1000 MS (Java/Others)     Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1551    Accepted Submission(s): 232

Problem Description

XXX is puzzled with the question below:

1, 2, 3, ..., n (1<=n<=400000) are placed in a line. There are m (1<=m<=1000) operations of two kinds.

Operation
1: among the x-th number to the y-th number (inclusive), get the sum of
the numbers which are co-prime with p( 1 <=p <= 400000).
Operation 2: change the x-th number to c( 1 <=c <= 400000).

For each operation, XXX will spend a lot of time to treat it. So he wants to ask you to help him.

 

Input

There are several test cases.
The first line in the input is an integer indicating the number of test cases.
For each case, the first line begins with two integers --- the above mentioned n and m.
Each the following m lines contains an operation.
Operation 1 is in this format: "1 x y p".
Operation 2 is in this format: "2 x c".

 

Output

For each operation 1, output a single integer in one line representing the result.

 

SampleInput

1
3 3
2 2 3
1 1 3 4
1 2 3 6

 

SampleOutput

7
0

给定一个数x可以表示成p = p₁^i₁p₂^i₂...p_n^i_n;要求x,x+1,x+2,...y与x互质的数的和，等价于求x,x+1,x+2,...y与p=p₁p₂...p_n互质。(p1,p2,...,pn为素数)

x,x+1,x+2,...y与p互质直接求不好求，所以可以反过来求，先求出与x不互质的数的和sum，然后ans=总的和-sum。

sum[[x,x+1,x+2,...y]与p不互质]=sum[[1,2,...y]与p不互质] - sum[[1,2,x-1]与p不互质]，

考虑p的素因子pi，则[1..y]中与pi不互质的数的个数是[y/pi].

然而，如果我们单纯将所有结果相加，有些数就会被统计多次（被好几个素因子整除）。所以，我们要运用容斥原理来解决。

aaarticlea/png;base64,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" alt="" />

http://zh.wikipedia.org/wiki/容斥原理

比如要求[1,2,...,10]和10不互质的和，10=2*5，与2不互质的有2,4,6,8,10,与5不互质的有5,10;但还要减去与2*5不互质10;每个与pi不互质的是一个等差数列，

所以等差数列求和即可。

(因为m最多1000，所以修改的数不多，所以后面对修改的数单独处理就ok了。)

第一步要求x的所有因子。

第二步运用容斥原理，奇数项加，偶数项减。

再枚举修改的值就差不多了。

n<=400000,所以ans可能会超int

 int size;//因子个数
 int yinzi[];
 void get_yinzi(int n)
 {
     size = ;
     if (!(n & ))//为偶数
     {
         yinzi[size++] = ;
         while (n /= , !(n & ));
     }
     int i, sqrtn = (sqrt(1.0 * n) + 0.5);
     for (i = ; i <= sqrtn; i += )
     {
         if (n % i == )
         {
             yinzi[size++] = i;
             while (n /= i, n % i == );
         }
         if (n == )
             return;
     }
     if (n > )
         yinzi[size++] = n;
 }

//详见大牛博客http://www.cnblogs.com/xin-hua/p/3213050.html
 1 #define llt long long int
 llt solve(int r)//容斥原理，二进制法，总共有2size-1项
 {
     llt sum = ;
     int bits;//1的个数，奇数加，偶数减
     int pi;//
     int i, j =  << size, t;
     int k;//选中的第几个因子
     for (i = ; i < j; i++)//看i的二进制表示，假设size=4,i=1011,表示yinzi[3]∩yinzi[1]∩yinzi[0]即pi = yinzi[3]*yinzi[1]*yinzi[0]
     {
         pi = ;
         t = i;
         k = bits = ;
         while (t)
         {
             if (t & )
             {
                 pi *= yinzi[k];
                 bits++;
             }
             k++;
             t >>= ;
         }
         t = r / pi;
         if (bits & )//等差数列求和
             sum += 1ll * (pi + pi * t) * t / ;
         else
             sum -= 1ll * (pi + pi * t) * t / ;
     }
     return sum;
 }

 int gcd(int a, int b)
 {
     return b ? gcd (b, a % b) : a;
 }

 llt sum(int n)
 {
     return 1ll * ( + n) * n / ;
 }
 map<int, int> mp;//使用map对修改的数进行操作
 map<int,int>::iterator it;
 int main()
 {
     int tests, n, m, i, op, x, y, p, c;
     llt ans;
     scanf("%d", &tests);
     while (tests--)
     {
         mp.clear();
         scanf("%d%d", &n, &m);
         while (m--)
         {
             scanf("%d", &op);
             if (op == )
             {
                 ans = ;
                 scanf("%d%d%d", &x, &y, &p);
                 if (x > y)
                     swap(x, y);
                 get_yinzi(p);
                 for (it = mp.begin(); it != mp.end(); it++)
                 {
                     if (it->first != it->second && it->first >= x && it->first <= y)
                     {
                         ans -= gcd(it->first, p) ==  ? it->first : ;
                         ans += gcd(it->second, p) ==  ? it->second : ;
                     }
                 }
                 printf("%I64d\n", ans + sum(y) - sum(x - ) - solve(y) + solve(x - ));
             }
             else
             {
                 scanf("%d%d", &x, &c);
                 mp[x] = c;
             }
         }
     }
     return ;
 }