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

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.

Sample Input
1
3 3
2 2 3
1 1 3 4
1 2 3 6

Sample Output
7
0

Source
2012 ACM/ICPC Asia Regional Jinhua Online

題意：給定n和m，m個操作，操作有以下兩種型別：
1. 1 x y p 計算[x,y]內與p互質的數的總和
2. 2 x c 將第x個數改為c（最多1000次）
輸出操作1所求的和

分析：求[x,y]內與p互質的數，這裡和 hdu4315(http://blog.csdn.net/feng_zhiyu/article/details/76176070) 類似 對p分解，求出其素因子並儲存
設 p 的素因子是{P1,P2,…,Pk}，於是與 p 不互質的數的素因子集合可以表示成 {P1} U {P2} U … U {Pk}。
那麼與 p 不互質的數的集合可以表示成 W = { P1的倍數 } U { P2的倍數 } U … U { Pk的倍數 }。
其中，{ Pk的倍數 } = { Pk*1 } + { Pk*2 } + … + { Pk*Mk } ( Pk*Mk<=n && Pk*(Mk+1)>n )。
從而，ans = sum{ W }。
於是可以通過容斥原理，求得問題的解。
舉個簡單的例子，假如 k=2，則 ans = 【sum{ P1的倍數 } + sum{ P2的倍數 } - sum{ P1*P2的倍數 }】。其中，某個sum{ }可以通過等差公式求得。
第二種操作 直接一一判斷

打算把容斥原理的三種方法都用一遍，但開始我用佇列的時候TLE了，發現有一個地方寫錯了，改了過來變成了WA。。 感覺沒問題。。 dfs也有點問題。。 先放上來。。。

#include<cstdio>
#include<map>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const LL N=1e6+5;
LL vec[N];
map<LL,LL>mp;
LL n,m,cnt;
void is_sfactor(LL n)///求n的素因子
{
    cnt=0;
    for(LL i=2; i*i<=n; i++)
    {
        if(n%i==0)
        {
            n/=i;
            vec[cnt++]=i;
            while(n%i==0)
                n/=i;
        }
    }
    if(n>1) vec[cnt++]=n;
}
LL gcd(LL a,LL b)
{
    return b==0?a:gcd(b,a%b);
}
LL que[N];
LL solve(LL x,LL p)///求[1,x]內與p互質的數
{
    LL ans=x*(1+x)/2;//先求出總和
    LL len=cnt;
    /*LL k,front=0,T;
    que[front++]=-1;
    for(LL i=0; i<len; i++)
    {
        k=front;
        for(LL j=0; j<k; j++)
            que[front++]=que[j]*vec[i]*(-1);
    }
    for(LL i=1; i<front; i++)
    {
        T=(x/que[i])*(que[i]+(x/que[i])*que[i])/2;
        if(que[i]<0)
            ans+=T;
        else ans-=T;
    }*/
    for(LL i=1; i<(1<<len); i++)///二進位制位實現容斥
    {
        LL num=0;
        LL k=1;
        for(LL j=0; j<len; j++)
            if(i&(1<<j))
            {
                num++;
                k*=vec[j];
            }
        k=(x/k)*(k+(x/k)*k)/2;
        if(num&1) ans-=k;///  奇數的 是不互質的數
        else ans+=k;  //加上重複減去的
    }
    return ans;
}
LL query(LL ans,LL x,LL y,LL p)
{
    map<LL,LL>::iterator it;
    for(it=mp.begin(); it!=mp.end(); it++)
    {
        LL g1=it->first,g2=it->second;
        if(it->first>=x&&it->first<=y) ///必須滿足在查詢的區間內
        {
            if(gcd(g1,p)==1) ans-=g1; ///原來被修改的數
            if(gcd(g2,p)==1) ans+=g2;  ///修改後的數
        }
    }
    return ans;
}
int main()
{
    LL T;
    scanf("%d",&T);
    while(T--)
    {
        mp.clear();
        scanf("%lld%lld",&n,&m);
        while(m--)
        {
            LL type,x,y,p,c;
            scanf("%lld",&type);
            if(type==1)
            {
                scanf("%lld%lld%lld",&x,&y,&p);
                is_sfactor(p);
                LL ans=solve(y,p)-solve(x-1,p);
                //         printf("%LLd\n",ans);
                printf("%lld\n",query(ans,x,y,p));
            }
            else
            {
                scanf("%lld%lld",&x,&c);
                mp[x]=c;
            }
        }
    }
    return 0;
}