HDU 4407 Sum （容斥原理）

          这题难点就是看出来用容斥原理做，可以先分析时间复杂度大致确定用我已知的数据结构做不了。。。我们会发现刚开始数据是1-n，如果不做任何修改的话，只查询的话的确可以用容斥原理做，就是把p质分解，然后没有p质因数的元素就是与p互质的元素，于是就很容易用容斥原理做了。但是有了修改操作，我们发现一旦做出了修改就没办法用上述方法做了。但是仔细考虑发现修改次数最多不会超过1000，于是我们可以先用容斥原理算出未修改前的，再分别判断修改过的。。。于是时间复杂度就满足要求了。。。

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<cmath>

#define LL long long
#define CLR(a, b) memset(a, b, sizeof(a))
#define eps 1e-9

using namespace std;

const int N = 444444;

vector<int> hav;
int chg[1111], ind[1111];
bool isp[N];
int p[N], cnt, ind_num;

void getp()
{
    CLR(isp, 0);
    int i, j;cnt = 0;
    isp[0] = isp[1] = 1;
    for(i = 2; i < N; i ++)
    {
        if(!isp[i])
        {
            p[cnt ++] = i;
            if(i <= 1111)for(j = i * i; j < N; j += i) isp[j] = 1;
        }
    }
}

void get_hav(int h)
{
    int i;
    hav.clear();
    for(i = 0; i < cnt && h > 1; i ++)
    {
        if(h % p[i] == 0)
        {
            h /= p[i];
            int s = hav.size();
            if( s == 0 || hav[s - 1] != p[i])hav.push_back(p[i]);
            i --;
        }
    }
    if(h != 1) hav.push_back(h);
}

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

int main()
{
    //freopen("input.txt", "r", stdin);
    int n, m, t, i, j;
    int k, l, r, f, p;
    LL ans;
    getp();
    scanf("%d", &t);
    while(t --)
    {
        scanf("%d%d", &n, &m);
        ind_num = 0;
        for(i = 0; i < m; i ++)
        {
            scanf("%d", &f);
            if(f == 1)
            {
                scanf("%d%d%d", &l, &r, &p);
                ans = 0;
                get_hav(p);
                int s = hav.size(), t, f;
                for(j = 1; j < (1 << s); j ++)
                {
                    t = 0;f = 1;
                    for(k = 0; k < s; k ++)
                    {
                        if((1 << k) & j)
                        {
                            t ++;
                            f *= hav[k];
                        }
                    }
                    LL num = r / f - (l - 1) / f;
                    LL ca = num * (num + 1) / 2 * f + ((l - 1) / f) * f * num;
                    if(t & 1) ans += ca;
                    else ans -= ca;
                }
                ans = ((LL)l + r) * (r - l + 1) / 2 - ans;
                for(j = 0; j < ind_num; j ++)
                {
                    if(ind[j] >= l && ind[j] <= r)
                    {
                        if(gcd(p, ind[j]) == 1) ans -= ind[j];
                        if(gcd(p, chg[j]) == 1) ans += chg[j];
                    }
                }
                printf("%I64d\n", ans);
            }
            else
            {
                int flag = 0;
                scanf("%d%d", &l, &r);
                for(j = 0; j < ind_num; j ++)
                {
                    if(ind[j] == l)
                    {
                        flag = 1;
                        chg[j] = r;
                        break;
                    }
                }
                if(!flag)
                {
                    chg[ind_num] = r;
                    ind[ind_num ++] = l;
                }
            }
        }
    }
}