容斥定理 | 初步

容斥定理：http://www.cppblog.com/vici/archive/2011/09/05/155103.html

玲珑杯 1138 - 震惊，99%+的中国人都会算错的问题

DESCRIPTION

众所周知zhu是一个大厨，zhu一直有自己独特的咸鱼制作技巧.
tang是一个咸鱼供应商，他告诉zhu在他那里面有$N$条咸鱼（标号从1到N）可以被用来制作.

每条咸鱼都有一个咸鱼值 $K_i$ ，初始时所有 $K_i$ 都是 $0$ .
zhu是一个特别的人，他有 $M$ 个咸数（咸鱼数字）, 对于每个咸数 $x$ ，他都会让所有满足标号是 $x$ 倍数的咸鱼的咸鱼值异或上 $1$ .
zhu现在想知道经过了这 $M$ 个咸数的筛选之后，最终有多少条的咸鱼的咸鱼值是 $1$ ?

INPUT

输入的第一行包含一个整数 $T(1\le T\le 1000)$

，表示有 $T$ 组数据.对于每组数据：输入第一行只有两个整数 $N(1\le N\le {10}^9)$ , $M(1\le M\le 15)$ .接下来一行有 $M$ 个整数，依次对应zhu的每个咸数( $1\le 咸数\le 2\ast {10}^5$ ).

容易发现，对于输入的m个数的倍数会有重合，所以要用到容斥定理。

设x,y的倍数为m,那么m的倍数重复出现的次数为n/m，这里x标记一次之后，y又重复标记了一次，两个数做减法运算，所以要减去2*(n/m)*(1<<(2-1));

在看x,y,z三个数的情况,假设gcd(x,y,z)=m,那么m的倍数出现的次数为n/gcd(x,y,z),其中gcd(x,y,z)=gcd( gcd(x,y),z)。对于三个数用加法运算，x,y分别标记一次，gcd(x,y)标记一次，gcd(gcd(x,y),z )再标记了一次，所以要加上 n/m*(1<<(3-1));

以此类推。

#include <iostream>
#include <stdio.h>
#include <string.h>
#define LL long long

using namespace std;

const int ma=150;
LL a[ma],cnt;
int m,n;

LL work(LL a,LL b)
{
    LL c;
    while(b>0)
    {
        c=a;
        a=b;
        b=c%b;
    }
    return a;
}

void DFS(int num,LL gcd,int c)
{
    gcd=a[num]/work(gcd,a[num])*gcd;
    if(c&1) cnt+=n/gcd*(1<<(c-1));
    else cnt-=n/gcd*(1<<(c-1));

    for(int i=num+1; i<m; ++i)
        DFS(i,gcd,c+1);
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0; i<m; ++i)
            scanf("%lld",&a[i]);

        cnt=0;
        for(int i=0; i<m; ++i)
        {
            DFS(i,a[i],1);
        }

        printf("%lld\n",cnt);
    }
    return 0;
}

HDU 4135 Co-prime

就是让你求(a,b)区间于n互质的数的个数.

分析：我们可以先转化下：用(1,b)区间与n互质的数的个数减去(1,a-1)区间与n互质的数的个数,那么现在就转化成求(1,m)区间于n互质的数的个数,如果要求的是(1,n)区间与n互质的数的个数的话，我们直接求出n的欧拉函数值即可，可是这里是行不通的!我们不妨换一种思路：就是求出(1,m)区间与n不互质的数的个数，假设为num，那么我们的答案就是：m-num!现在的关键就是：怎样用一种最快的方法求出(1,m)区间与n不互质的数的个数？方法实现：我们先求出n的质因子(因为任何一个数都可以分解成若干个质数相乘的),如何尽快地求出n的质因子呢？我们这里又涉及两个好的算法了!第一个：用于每次只能求出一个数的质因子,适用于题目中给的n的个数不是很多，但是n又特别大的;(http://www.cnblogs.com/jiangjing/archive/2013/06/03/3115399.html)第二个：一次求出1~n的所有数的质因子,适用于题目中给的n个数比较多的，但是n不是很大的。(http://www.cnblogs.com/jiangjing/archive/2013/06/01/3112035.html)本题适用第一个算法！举一组实例吧:假设m=12,n=30.

第一步：求出n的质因子：2,3,5；

第二步：(1,m)中是n的因子的倍数当然就不互质了(2,4,6,8,10)->n/2  6个,(3,6,9,12)->n/3  4个,(5,10)->n/5  2个。

如果是粗心的同学就把它们全部加起来就是：6+4+2=12个了，那你就大错特错了,里面明显出现了重复的,我们现在要处理的就是如何去掉那些重复的了！

第三步：这里就需要用到容斥原理了，公式就是：n/2+n/3+n/5-n/(2*3)-n/(2*5)-n/(3*5)+n/(2*3*5).

第四步:我们该如何实现呢？我在网上看到有几种实现方法：dfs(深搜)，队列数组，位运算三种方法都可以！上述公式有一个特点：n除以奇数个数相乘的时候是加，n除以偶数个数相乘的时候是减。我这里就写下用队列数组如何实现吧：我们可以把第一个元素设为-1然后具体看代码如何实现吧！

同种类型的题目：hdu 2841    hdu1695 （转自 ：左右不离~生如夏花）

#include <iostream>
#include <stdio.h>
#include <string.h>
#define LL long long

using namespace std;

const int ma=100005;
LL a[ma];
LL A,B,cnta,cntb,n;
int num;

void work() ///求n的质因数
{
    num=0;
    LL i;
    for(i=2; i*i<=n; i++)
    {
        if(n%i==0)
        {
            a[num++]=i;
            while(n%i==0)
                n=n/i;
        }
    }
    if(n>1)
        a[num++]=n;
}

LL get_gcd(LL x,LL y)
{
    LL c;
    while(y>0)
    {
        c=x;
        x=y;
        y=c%y;
    }
    return x;
}

void DFS(int id,LL gcd,int c) ///计算与n不互质的个数
{
    gcd=a[id]/get_gcd(a[id],gcd)*gcd;
    if(c&1)
    {
        cnta+=A/gcd;
        cntb+=B/gcd;
    }
    else
    {
        cnta-=A/gcd;
        cntb-=B/gcd;
    }

    for(int i=id+1; i<num; ++i)
        DFS(i,gcd,c+1);
}

int main()
{
    int t,cas=0;
    scanf("%d",&t);
    while(cas<t)
    {
        cas++;
        scanf("%lld%lld%lld",&A,&B,&n);
        A=A-1;
        work();
        cnta=cntb=0;

        for(int i=0; i<num; ++i)
            DFS(i,a[i],1);

        printf("Case #%d: %lld\n",cas,B-cntb-(A-cnta));
    }


    return 0;
}

还有一种用数组实现的方法：

#include<iostream>
#include<string.h>
#define LL long long
using namespace std;
LL a[1000],num;
void init(LL n)//求一个数的质因子
{
    LL i;
    num=0;
    for(i=2;i*i<=n;i++)
    {
        if(n%i==0)
        {
            a[num++]=i;
            while(n%i==0)
                n=n/i;
        }
    }
    if(n>1)//这里要记得
        a[num++]=n;
}
LL haha(LL m)//用队列数组实现容斥原理
{
    LL que[10000],i,j,k,t=0,sum=0;
    que[t++]=-1;
    for(i=0;i<num;i++)
    {
        k=t;
        for(j=0;j<k;j++)
           que[t++]=que[j]*a[i]*(-1);
    }
    for(i=1;i<t;i++)
        sum=sum+m/que[i];
    return sum;
}
int main()
{
    LL T,x,y,n,i,sum;
    while(scanf("%I64d",&T)!=EOF)
    {
        for(i=1;i<=T;i++)
        {
           scanf("%I64d%I64d%I64d",&x,&y,&n);
           init(n);
           sum=y-haha(y)-(x-1-haha(x-1));
           printf("Case #%I64d: ",i);
           printf("%I64d\n",sum);
        }
    }
    return 0;
}