網上找來方便自己看，理解。

容斥原理：在計數時，必須注意無一重複，無一遺漏。為了使重疊部分不被重複計算，人們研究出一種新的計數方法，這種方法的基本思想是：先不考慮重疊的情況，把包含於某內容中的所有物件的數目先計算出來，然後再把計數時重複計算的數目排斥出去，使得計算的結果既無遺漏又無重複，這種計數的方法稱為容斥原理。

也可表示為 設S為有限集,    ,則 由於 所以 兩個集合的容斥關係公式：A∪B =|A∪B| = |A|+|B| - |A∩B |(∩：重合的部分） 三個集合的容斥關係公式：|A∪B∪C| = |A|+|B|+|C| - |A∩B| - |B∩C| - |C∩A| + |A∩B∩C| 詳細推理如下： 1、 等式右邊改造 = {[（A+B - A∩B）+C - B∩C] - C∩A }+ A∩B∩C 2、維恩圖分塊標記如右圖圖：1245構成A，2356構成B，4567構成C 3、等式右邊（）裡指的是下圖的1+2+3+4+5+6六部分： 那麼A∪B∪C還缺部分7。 4、等式右邊[]號裡+C（4+5+6+7）後，相當於A∪B∪C多加了4+5+6三部分， 減去B∩C（即5+6兩部分）後，還多加了部分4。 5、等式右邊{}裡減去C∩A （即4+5兩部分）後，A∪B∪C又多減了部分5， 則加上A∩B∩C（即5）剛好是A∪B∪C。

常用方法有兩種：遞迴法和二進位制列舉法。

遞迴法是利用dfs的思想進行搜尋，檢索每一種方案進行容斥。

二進位制列舉的方法最大的好處是能夠枚舉出所有元素組合的不同集合。假設一個集合的元素有m個，則對於m長的二進

制數來說就有m個1或0的位置，對於每一個1就對應一個元素。

整個二進位制列舉完就是所有子集，從0到2^m就行。[0, 2^m)

以hdu 1796為例：

題意：給定一個數n，數列m個數，求這小於n的數中，有多少個數滿足能被這m個數中任意一個數整除。

思路：1~n之間有多少個能被x整除的數，公式為n/x，題目中要求小於n,所以(n-1)/x。

可以遞迴法求，需要儲存中間重疊x次的最小公倍數lcm,符合題意的數有(n-1)/lcm個，利用

k表示重疊的次數進

行或者加上，或者減去。

也可以用二進位制列舉法，將符合條件的m個數，看作m位，每位是0或者是1，那麼一共有2^m種狀態，只要判斷一下每

一個狀態有多少個1，也就是有多少個數（重疊多少次）,記為k，每一個1代表哪幾個具體的數，求這幾個數的最小

公倍數，然後(n-1)/lcm,  利用k的值來判斷應該減去還是加上即可。

遞迴版本：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int num[25];
int ans,tot,n,m;
void dfs(int pos,int pre_lcm,int k)
{
    for(int i=pos+1;i<tot;++i)
    {
        //int lcm=(num[i]*pre_lcm)/gcd(num[i],pre_lcm);
        int lcm = pre_lcm/__gcd(num[i], pre_lcm)*num[i];
        if(k&1) ans+=(n-1)/lcm;
        else ans-=(n-1)/lcm;
        dfs(i,lcm,k+1);
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        ans=0,tot=1;
        memset(num,0,sizeof(num));
        for(int i=1;i<=m;++i)
        {
            int x;
            scanf("%d",&x);
            if(x>0&&x<n) num[tot++]=x;
        }
        dfs(0,1,1);
        printf("%d\n",ans);
    }
    return 0;
}

二進位制版本：

#include <bits/stdc++.h>
using namespace std;
int n, m, x, k, tot;
int up, t, pos, lcm, ans;
int num[25];
int main()
{
    while(~scanf("%d %d", &n, &m))
    {
        tot = 1; ans = 0;
        for(int i = 1; i <= m; ++i)
        {
            scanf("%d", &x);
            if(x > 0 && x < n) num[tot++] = x;
        }
         up = (1<<(tot-1));
        for(int i = 1; i < up; ++i)
        {
            t = i, k = 0, pos = 1; lcm = 1;
            while(t)
            {
                if(t&1)
                {
                    lcm = num[pos]/__gcd(lcm, num[pos])*lcm;
                    ++k;
                }
                t >>= 1; ++pos;
            }
            if(k&1) ans += (n-1)/lcm;
            else ans -= (n-1)/lcm;
        }
        printf("%d\n", ans);
    }
    return 0;
}

對於容斥原理我們可以利用數學歸納法證明： 證明：當    時，等式成立(證明略)。 假設    時結論成立，則當    時， 所以當    時，結論仍成立。因此對任意    ，均可使所證等式成立。[1]

LL Q[100010],factor[110],num;
//Q陣列存放的就是右邊邊各項的因子數以及正負情況，factor[]存放對應物件的數目，num為有幾個物件
void Divid(LL n)  //n的素因子分解,得到每項素因子的個數
{
    num = 0;
    for(LL i = 2; i*i <= n; ++i)
    {
        if(n%i==0)
        {
            while(n%i==0)
                n /= i;
            factor[num++] = i;
        }
    }
    if(n != 1)
        factor[num++] = n;
}
LL solve(LL n)  //容斥定理，求
{
    LL k,t,ans;
    t = ans = 0;
    Q[t++] = -1;
    for(LL i = 0; i < num; ++i)
    {
        k = t;
        for(LL j = 0; j < k; ++j)
            Q[t++] = -1*Q[j]*factor[i];
    }
    //A∪B∪C = A+B+C - A∩B - B∩C - C∩A + A∩B∩C
    //Q陣列存放的就是A∪B∪C右邊邊各項的因子數以及正負情況。
    for(LL i = 1; i < t; ++i)
        ans += n/Q[i];
    //n/Q[i]累加起來就是A∪B∪C
    return ans;
}

例題：給定r，n求[1，r]內與n互素的個數有多少個？

思路：直接求解問題就是比較複雜的。所以我們還是研究這個問題是逆問題。也就是說求gcd(k，n) >= 2，在1 - n之間k有多少個 。那麼我們就可以列舉n的素因子來進行求解。

int solve(int r, int n) { vector<int>p; for (int i = 2; i * i <= n; ++i){ if (n % i == 0){ p.push_back(i); while (n % i == 0) n /= i; } } if (n > 1) p.push_back(n); int sum = 0; for (int S = 1; S < (1 << p.size()); ++S){ int mult = 1, bits = 0; for (int i = 0; i < p.size(); ++i){ if (S & (1 << i)){ ++bits; mult *= p[i]; } } int cur = r / mult; if (bits % 2 == 1) sum += cur; else sum -= cur; } return r - sum; }