容斥原理求1~r中有多少个数与n互素

容斥原理求1到n与n互质：

首先处理出n的所有素因子

然后对于每个素因子，他们的倍数都是与n不互质的，记录下这个数量。但是这个数量中有重复的，也就是说如果一个数同时是两个素因数的倍数，他就被算了两次，此时要把数量减1。同样3个素因数得倍数被多减了 ，要加回来，以此类推下去。

以下内容转载自：点击打开链接

对于这个问题由容斥原理，我们有3种写法，其实效率差不多。分别是：dfs，队列数组，位运算。

先说说位运算吧：

用二进制1,0来表示第几个素因子是否被用到,如m=3，三个因子是2,3,5，则i=3时二进制是011，表示第2、3个

因子被用到

[cpp]  view plain copy

1. LL Solve(LL n,LL r)  
2. {  
3.     vector<LL> p;  
4.     for(LL i=2; i*i<=n; i++)  
5.     {  
6.         if(n%i==0)  
7.         {  
8.             p.push_back(i);  
9.             while(n%i==0) n/=i;  
10.         }  
11.     }  
12.     if(n>1)  
13.         p.push_back(n);  
14.     LL ans=0;  
15.     for(LL msk=1; msk<(1<<p.size()); msk++)  
16.     {  
17.         LL multi=1,bits=0;  
18.         for(LL i=0; i<p.size(); i++)  
19.         {  
20.             if(msk&(1<<i))  //判断第几个因子目前被用到  
21.             {  
22.                 ++bits;  
23.                 multi*=p[i];  
24.             }  
25.         }  
26.         LL cur=r/multi;  
27.         if(bits&1) ans+=cur;  
28.         else       ans-=cur;  
29.     }  
30.     return r-ans;  
31. }  

然后就是dfs的实现：

[cpp]  view plain copy

1. void Solve(LL n)  
2. {  
3.     p.clear();  
4.     for(LL i=2; i*i<=n; i++)  
5.     {  
6.         if(n%i==0)  
7.         {  
8.             p.push_back(i);  
9.             while(n%i==0) n/=i;  
10.         }  
11.     }  
12.     if(n>1)  
13.         p.push_back(n);  
14. }  
15.   
16. void dfs(LL k,LL t,LL s,LL n)  
17. {  
18.     if(k==p.size())  
19.     {  
20.         if(t&1) ans-=n/s;  
21.         else    ans+=n/s;  
22.         return;  
23.     }  
24.     dfs(k+1,t,s,n);  
25.     dfs(k+1,t+1,s*p[k],n);  
26. }  
27.   
28. //主函数内是：  
29. dfs(0,0,1,r);  

经典题目：HDU4135，HDU2841，HDU1695，HDU3501