[数论专题]容斥原理练习（持续更新）

最新推荐文章于 2021-10-26 17:34:42 发布
最新推荐文章于 2021-10-26 17:34:42 发布
阅读量521 收藏 3
点赞数
分类专栏： 数论 组合数学 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nagisa2019/article/details/106865224
版权

参考大佬博客：https://www.cnblogs.com/linyujun/p/5210410.html

目录

HDU - 1465 不容易系列之一

这道应该第一反应是排错问题，可以用排错问题的公式。但是，也可以用容斥原理来想。
总的方案数为n!。
假设一定有1封信（指定的，非任意）放对，则有 ( n − 1 ) ! (n-1)! (n−1)!种方案。
假设一定有2封信（指定的，非任意）放对，则有 ( n − 2 ) ! (n-2)! (n−2)!种方案。
假设一定有3封信（指定的，非任意）放对，则有 ( n − 3 ) ! (n-3)! (n−3)!种方案。
……
假设一定有n封信放对，则有 0 ! 0! 0!种方案。
之后，我们给每一项乘上组合数，就可以变成任意的1、2、……、n封信。这时候，会想到全部加起来就是不合理方案数了，但是，这里面其实有重复，所以我们需要去重。
参考wiki：https://oi-wiki.org/math/inclusion-exclusion-principle/
C n 1 ( n − 1 ) ! C^1_n(n-1)! Cn1​(n−1)!可以理解为上面wiki中的|A|+|B|+|C|……，也就是A信件放对、B信件放对、C信件放对……的情况总和，但是再A信件放对的情况中，也含有B信件放对的情况。所以，我们需要减去的是A和B信件都放对的情况，也就是(n-2)!，相同的其他的C、D等的和A组合，以及他们之间的组合都要算进去，因此就变成了要 − C n 2 ( n − 2 ) ! -C^2_n(n-2)! −Cn2​(n−2)!，但是这减去的里面，又有A、B、C放对的情况被多减去了一次，因此，需要 + C n 3 ( n − 3 ) ! +C^3_n(n-3)! +Cn3​(n−3)!补上，然后又重复了Orz……一直套娃到最后，结果不符合题意的结果就是：
∑ 1 n ( − 1 ) n − 1 C n i ( n − i ) ! \sum_1^n(-1)^{n-1}C_n^i(n-i)! ∑1n​(−1)n−1Cni​(n−i)!
容斥一下，结果就是 n ! − ∑ 1 n ( − 1 ) n − 1 C n i ( n − i ) ! n!-\sum_1^n(-1)^{n-1}C_n^i(n-i)! n!−∑1n​(−1)n−1Cni​(n−i)!
编程实现就打表套就是了。

#include <iostream>
#include <map>
#include <ctime>
#include <vector>
#include <climits>
#include <algorithm>
#include <random>
#include <cstring>
#include <cstdio>
#include <map>
#include <set>
#include <bitset> 
#include <queue>
#define inf 0x3f3f3f3f
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#define rep(i, a, n) for(register int i = a; i <= n; ++ i)
#define per(i, a, n) for(register int i = n; i >= a; -- i)
#define ONLINE_JUDGE
using namespace std;
typedef long long ll;
const int mod=1e9+7;
template<typename T>void write(T x)
{
    if(x<0)
    {
        putchar('-');
        x=-x;
    }
    if(x>9)
    {
        write(x/10);
    }
    putchar(x%10+'0');
}
 
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
ll gcd(ll a,ll b){return b==0?a:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;};
ll ksm(ll a,ll n){//看是否要mod 
	ll ans=1;
	while(n){
		if(n&1) ans=(ans*a)%mod;
		a=a*a%mod;
		n>>=1;
	}
	return ans%mod;
}
//==============================================================
ll fac[25];
void init(){
    fac[0]=1;
    rep(i,1,20){
        fac[i]=fac[i-1]*i*1LL;
    }
}
int n;

int main()
{
	#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
	freopen("out.txt","w",stdout);
	#endif
	//===========================================================
    init();
    while (~scanf("%d",&n))
    {
        ll ans=0;
        int sig=1;
        rep(i,2,n){
            ans+=sig*(fac[n]/fac[i]);
            sig*=-1;
        }
        write(ans),putchar('\n');
    }
    
	//===========================================================
	return 0;
}

UVALive - 7040 Color

从m种颜色挑k种，组合数 C m k C^k_m Cmk​没毛病。由于一定要用上k种颜色，直接求是不行的，考虑容斥。若不考虑全部用上，则有 C n k k ∗ ( k − 1 ) n − 1 C^k_nk*(k-1)^{n-1} Cnk​k∗(k−1)n−1种方案，需要去除不合理方案。这里不合理的方案是只使用了k-1、k-2、……、1种颜色，若只使用了其中的k-1种，则方案数为 C k k − 1 ∗ ( k − 1 ) ∗ ( k − 2 ) n − 1 C_k^{k-1}*(k-1)*(k-2)^{n-1} Ckk−1​∗(k−1)∗(k−2)n−1，和上面一样，有多减去的，所以，需要补上，套娃，……最后结果为:
C m k ∗ ( k ∗ ( k − 1 ) n − 1 − ∑ i = 1 k ( − 1 ) i C k i ( k − i ) ∗ ( k − i − 1 ) n − 1 ) C^k_m*(k*(k-1)^{n-1}-\sum_{i=1}^k(-1)^iC_k^i(k-i)*(k-i-1)^{n-1}) Cmk​∗(k∗(k−1)n−1−∑i=1k​(−1)iCki​(k−i)∗(k−i−1)n−1)，由于m的范围较大，所以只能直接算。而内层的 C k i C_k^i Cki​可以打表解决。
注意：因为有减法，所以需要+mod之后再%mod

#include <iostream>
#include <map>
#include <ctime>
#include <vector>
#include <climits>
#include <algorithm>
#include <random>
#include <cstring>
#include <cstdio>
#include <map>
#include <set>
#include <bitset> 
#include <queue>
#define inf 0x3f3f3f3f
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#define rep(i, a, n) for(register ll i = a; i <= n; ++ i)
#define per(i, a, n) for(register ll i = n; i >= a; -- i)
#define ONLINE_JUDGE
using namespace std;
typedef long long ll;
const int mod=1e9+7;
template<typename T>void write(T x)
{
    if(x<0)
    {
        putchar('-');
        x=-x;
    }
    if(x>9)
    {
        write(x/10);
    }
    putchar(x%10+'0');
}
 
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
ll gcd(ll a,ll b){return b==0?a:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;};
ll ksm(ll a,ll n){//看是否要mod 
	ll ans=1;
	while(n){
		if(n&1) ans=(ans*a)%mod;
		a=a*a%mod;
		n>>=1;
	}
	return ans%mod;
}
//==============================================================
#define int ll

ll t;
const int maxn=1e6+10;
ll fac[maxn];
ll finv[maxn];
void init(){//阶乘和阶乘逆元打表
    int lim=1e6+5;
    fac[0]=1;
    rep(i,1,lim){
        fac[i]=(fac[i-1]*i)%mod;
    }
    finv[lim]=ksm(fac[lim],mod-2)%mod;
    per(i,0,lim-1){
        finv[i]=((finv[i+1]%mod)*((i+1)%mod))%mod;
    }
}
ll n,m,k;
inline ll C(ll n,ll m){//O(m)求大范围组合数
    ll t1=1;
    rep(i,n-m+1,n){
        t1=(t1*i)%mod;
    }
    return ((t1%mod)*(finv[m]%mod))%mod;
}
inline ll c(ll n,ll m){//O(1)求小范围组合数
    if(m<0||m>n) return 0;
    return ((fac[n]*finv[n-m])%mod*finv[m])%mod;
}

signed main()
{
	#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
	freopen("out.txt","w",stdout);
	#endif
	//===========================================================
	read(t);
    ll kase=0;
    init();
    while(t--){
        read(n),read(m),read(k);
        ll ans=k*ksm(k-1,n-1)%mod;
        ll sig=-1;
        rep(i,1,k-1){
            //cout<<ans<<" "<<(c(k,k-i)*(k-i)%mod*(ksm(k-i-1,n-1)%mod)%mod)<<endl;
            ans=(ans+sig*(c(k,k-i)*(k-i)%mod*(ksm(k-i-1,n-1)%mod)%mod)%mod+mod)%mod;//代式子
            sig=-sig;
        }
        ans=(C(m,k)%mod*ans+mod)%mod;
        printf("Case #%d: %lld\n",++kase,(ans%mod));
    }
	//===========================================================
	return 0;
}

HDU - 4135 Co-prime

这道题涉及到素数分解和容斥原理的实现。
听说容斥原理的实现分为dfs、队列数组和二进制，这我还不是很了解。这里就用了队列数组。
原题目是求[a,b]范围内和n互质的数的数目，我们可以考虑容斥，求不和n互质的。如果直接对[a,b]范围是比较麻烦的，所以考虑用前缀和思想：[1,a-1]范围和[1,b]范围，然后两个一减就好了。
对于一个数x，求[1,x]范围内和n不互质的数：
可以把n进行素数分解为p1、p2、……、pn，然后，求再[1,x]范围内，p1、p2、……、pn的倍数的个数。因为起点是1，所以，数目就是x/p1、x/p2、x/p3、……、x/pn。和上面一样，减去x/p1和x/p2的时候会有重复，所以，还是套娃Orz。关于+和-的处理，可以采用上面说到的队列数组。具体看代码：

#include <iostream>
#include <map>
#include <ctime>
#include <vector>
#include <climits>
#include <algorithm>
#include <random>
#include <cstring>
#include <cstdio>
#include <map>
#include <set>
#include <bitset> 
#include <queue>
#define inf 0x3f3f3f3f
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#define rep(i, a, n) for(register ll i = a; i <= n; ++ i)
#define per(i, a, n) for(register ll i = n; i >= a; -- i)
#define ONLINE_JUDGE
using namespace std;
typedef long long ll;
const int mod=1e9+7;
template<typename T>void write(T x)
{
    if(x<0)
    {
        putchar('-');
        x=-x;
    }
    if(x>9)
    {
        write(x/10);
    }
    putchar(x%10+'0');
}
 
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
ll gcd(ll a,ll b){return b==0?a:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;};
ll ksm(ll a,ll n){//看是否要mod 
	ll ans=1;
	while(n){
		if(n&1) ans=(ans*a)%mod;
		a=a*a%mod;
		n>>=1;
	}
	return ans%mod;
}
//==============================================================
const int maxn=1e6+10;
ll a,b,n,t;
ll primes[maxn],que[maxn];
ll front,tot;
void init(){
	memset(primes,0,sizeof(primes));
	memset(que,0,sizeof(que));
	front=0,tot=0;
	for(int i=2;i*i<=n;++i){//对n素数分解
		if(n%i==0){
			primes[tot++]=i;
			while(n%i==0) n/=i;
		}
	}
	if(n!=1) primes[tot++]=n;//这步不要忘记
	que[front++]=-1;
	rep(i,0,tot-1){//队列数组建立
		ll k=front;
		for(ll j=0;j<k;++j){
			que[front++]=que[j]*primes[i]*(-1);
		}
	}
}

ll solve(){//求不和n互质的，容斥原理
	ll res1=0,res2=0;
	rep(i,1,front-1){
		res1+=(a-1)/que[i];
	}
	rep(i,1,front-1){
		res2+=b/que[i];
	}
	//cerr<<res1<<" "<<res2<<endl;
	return res2-res1;
}

int main()
{
	#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
	freopen("out.txt","w",stdout);
	#endif
	//===========================================================
	read(t);
	ll kase=0;
	while(t--){
		read(a),read(b),read(n);
		init();//对n进行素数分解。
		printf("Case #%lld: %lld\n",++kase,(b-a+1)-solve());//容斥求对立事件
	}
	//===========================================================
	return 0;
}

HDU - 1695 GCD

听说这道题的正解的莫比乌斯反演，但容斥也能做，不过估计是数据水卡过去的。
原题是：再[1,b]和[1,d]区间内，分别找两个数x,y,使得gcd(x,y)=k，问一共有多少对x、y满足条件。根据gcd形式：
gcd(x,y)=k，则gcd(x/k,y/k)=1,证明可以素数分解看下。
然后，问题就变成了再[1,b/k]和[1,d/k]范围内分别找两个数p,q，使得p、q互质。
根据上一道题的经验，直接求素数比较难，所以，求个对立事件，不互质的数。
这里我们先假设d/k>b/k，题目给的不是就swap一下。
枚举x,y两个肯定不行，但我们可以枚举其中一个，枚举y。对于y，我们还需要分类讨论：
若y<=b/k，就是我们选定y为一个定值 y i y_i yi​，那么，我们要求和几个x(的范围为[1,b/k])和他互质，其实就相当于求在<= y i y_i yi​范围内有几个数和yi互质(为什么不考虑 [ y i , b / k ] [y_i,b/k] [yi​,b/k]范围的呢？是为了避免等会再枚举 y j y_j yj​( y i y_i yi​< y j y_j yj​<=d/k)的时候和现在的重复)。可以用欧拉函数求前缀和。
若y>b/k，我们换个角度看问题：就是假设现在y= y k y_k yk​( y k > b / k y_k>b/k yk​>b/k)，求在b/k范围内有几个数和它互质，就和第三题一样了。
这里有个小优化，欧拉函数需要打素数表，所以，我们在分解素数的时候可以利用素数表来分解。
另外，注意特判。

#include <iostream>
#include <map>
#include <ctime>
#include <vector>
#include <climits>
#include <algorithm>
#include <random>
#include <cstring>
#include <cstdio>
#include <map>
#include <set>
#include <bitset> 
#include <queue>
#define int ll
#define inf 0x3f3f3f3f
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#define rep(i, a, n) for(register ll i = a; i <= n; ++ i)
#define per(i, a, n) for(register ll i = n; i >= a; -- i)
#define ONLINE_JUDGE
using namespace std;
typedef long long ll;
const int mod=1e9+7;
template<typename T>void write(T x)
{
    if(x<0)
    {
        putchar('-');
        x=-x;
    }
    if(x>9)
    {
        write(x/10);
    }
    putchar(x%10+'0');
}
 
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
ll gcd(ll a,ll b){return b==0?a:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;};
ll ksm(ll a,ll n){//看是否要mod 
	ll ans=1;
	while(n){
		if(n&1) ans=(ans*a)%mod;
		a=a*a%mod;
		n>>=1;
	}
	return ans%mod;
}
//==============================================================
const int maxn=1e5+100;
vector<ll> factor;
ll prime[maxn],tot;
ll vis[maxn];
ll eular[maxn];
ll t;
ll a,b,c,d,k;
inline void init(){//欧拉函数加前缀和
    eular[1]=1;
    for(ll i=2;i<maxn;i++){
        if(!vis[i]) prime[tot++]=i,eular[i]=i-1;
        for(int j=0;j<tot&&prime[j]*i<maxn;j++){
            vis[i*prime[j]]=1;
            if(i%prime[j]==0){
                eular[i*prime[j]]=eular[i]*prime[j];
                break;
            }
            else{
                eular[i*prime[j]]=eular[i]*(prime[j]-1);
            }
        }
    }
    rep(i,1,maxn-1){
        eular[i]+=eular[i-1];
    }
}
ll que[maxn],front;
void predeal(ll n){//分解素数，创建队列数组
    factor.clear();
	//memset(que,0,sizeof(que));
	front=0;
	for(int i=0;prime[i]<=n/prime[i];++i){
        if(n%prime[i]==0){
            factor.push_back(prime[i]);
            while(n%prime[i]==0) n/=prime[i];
        }
    }
	if(n!=1) factor.push_back(n);
	que[front++]=-1;
	rep(i,0,factor.size()-1){
		ll k=front;
		for(ll j=0;j<k;++j){
			que[front++]=que[j]*factor[i]*(-1);
		}
	}
}
inline ll solve(ll b,ll x){//求不互质的数
    predeal(x);
    ll res=0;
    rep(i,1,front-1){
        res+=b/que[i];
    }
    //cerr<<res<<endl;
    return b-res;
}

signed main()
{
	#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
	freopen("out.txt","w",stdout);
	#endif
	//===========================================================
	read(t);
    int kase=0;
    init();
    while(t--){
        read(a),read(b),read(c),read(d),read(k);
        if(!k||b<k||d<k){
            printf("Case %d: %lld\n",++kase,0);
            continue;
        }
        b/=k,d/=k;
        if(d<b) swap(b,d);
        ll ans=eular[b];
        //cerr<<b<<" "<<ans<<endl;
        rep(i,b+1,d){
            ans+=solve(b,i);
        }
        printf("Case %d: %lld\n",++kase,ans);
    }
	//===========================================================
	return 0;
}
nagisa-kun
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
容斥原理练习题
路转溪桥忽见
06-07 1756
1. bzoj 2393&nefu 1795 Cirno的完美算数教室 http://acm.nefu.edu.cn/JudgeOnline/problemShow.php?problem_id=1795 Description Cirno发现了一种baka数，这种数只含有2和9两种数字 现在Cirno想知道一个区间中有多少个数能被baka数整除 但是Cirno这么天才的妖精才不屑去数啦 ...
容斥原理习题
Tabris的博客
02-11 1399
练习题目VJ:https://vjudge.net/contest/77876#overviewHDU 1796 How many integers can you find戳这里HDU 1685 Booksort这题应该是整错了 不是容斥原理,看题解都是IDA*搜索HDU 2204 Eddy’s爱好戳这里HDU 4407 Sum对于替换的先不管 最后暴力处理即可, 不替换的时候可
容斥原理练习
weixin_30572613的博客
05-18 97
A. HDU 4135 求 \([A,B]\) 中有多少个数与 \(N\) 互质。 \(A,B\le 10^{15},N\le 10^9\) 解 \(O(\sqrt n)\) 找出 \(n\) 的所有质因子，然后指数级容斥。可以证明质因子个数不会超过15个。 B. HDU 4059 \(T\le 1000\) 组询问，给定 \(n\) ，求与 \(n\) 互质的数的四次方和。 解 \(O(\sqr...
容斥原理练习记录
GeN的博客
07-31 331
HDU 1796 How many integers can you find 题意 给你一个集合n，里面有1–n-1的整数，再给你一个集合m，里面有m个非负整数。 求集合n中能被集合m中某个数整除的数的个数。 解 很明显就是枚举因子的容斥，但是注意如果有两个因子6和9，那不能用他们相乘来容斥，应该取LCM。 正常情况下，应该是找素因子来容斥的。 这题m集合中可能会有0，要特判。...
容斥原理总结及练习题
_Alexander的博客
03-23 827
容斥原理其实就一个公式 奇加偶减
C++基础数论—————容斥原理
C2020lax的博客
03-18 2703
前言： 温馨提示，此篇博客将涉及排列组合（链接）。 概念： 在计数时，必须注意没有重复，没有遗漏。为了使重叠部分不被重复计算，人们研究出一种新的计数方法，这种方法的基本思想是：先不考虑重叠的情况，把包含于某内容中的所有对象的数目先计算出来，然后再把计数时重复计算的数目排斥出去，使得计算的结果既无遗漏又无重复，这种计数的方法称为容斥原理。 好了，我们理解...
数论（2）——容斥原理
小狮子
08-27 476
容斥原理是一种重要的组合数学方法，可以让你求解任意大小的集合，或者计算复合事件的概率。 前置技能：莫比乌斯反演（懵逼钨丝） 注：1）.d是n的约数 2） 在线性筛模板里处理莫比乌斯函数即可 int mobi[N]={0,1},num[N],prim[N],cnt=0; void set() { for(int i=0;i&lt;N;i++) num[i]=1; for(in...
容斥原理+拓展
10-25
### 容斥原理及其扩展应用 #### 一、容斥原理概述 容斥原理是一种用于计算有限个集合的并集的元素数量的重要方法。它的基本形式可以表示为： \[ |A_1 \cup A_2 \cup \ldots \cup A_n| = \sum_{i=1}^n |A_i| - \...
容斥原理与莫比乌斯函数.md
08-09
容斥原理与莫比乌斯函数.md
诸多素数问题与容斥原理.pdf
08-12
标题“诸多素数问题与容斥原理.pdf”和描述中的“李扩继 诸多素数问题与容斥原理.pdf”揭示了文档内容的重点，即对素数问题的研究以及容斥原理的应用。文档内容围绕素数筛法、欧拉函数及其推广、容斥原理等数学概念...
容斥原理简单的入门题总结
lajiyuan的博客
09-12 4068
容斥原理 这里对容斥原理进行简单的总结，容斥原理主要用于求n个数能组成的乘积种类数，从这之中我们就可以引申出容斥原理的很多用法，对于给定数字求组合种类的题目，我们就要想到用lcm去运算，对于给定数求互质/不互质时，我们就要想到对给定的数进行质因数分解。下面给出一些容斥原理的入门题。 容斥原理第一题 HDU-2204- Eddy’s爱好 题意就是给出一个数n，问1-n中有多少个数可以表...
数论+容斥原理 --hdu 上的几题
UntilTheEnd的专栏
09-24 717
hdu 2841 ：此题题意是从（0,0）点
容斥原理汇总
weixin_30530523的博客
02-03 144
对容斥原理的描述 容斥原理是一种重要的组合数学方法，可以让你求解任意大小的集合，或者计算复合事件的概率。 描述 容斥原理可以描述如下： 要计算几个集合并集的大小，我们要先将所有单个集合的大小计算出来，然后减去所有两个集合相交的部分，再加回所有三个集合相交的部分，再减去所有四个集合相交的部分，依此类推，一直计算到所有集合相交的部分。 对于实际问题的应用 ...
【模板题】容斥原理
一只快乐的小蒟蒻~
10-26 243
【题目描述】 给定一个整数nnn和mmm个不同的质数p1,p2,…,pmp_1,p_2,…,p_mp1​,p2​,…,pm​。 请你求出1∼n1∼n1∼n中能被p1,p2,…,pmp_1,p_2,…,p_mp1​,p2​,…,pm​中的至少一个数整除的整数有多少个。 【输入格式】 第一行包含整数nnn和mmm。 第二行包含mmm个质数。 【输出格式】 输出一个整数，表示满足条件的整数的个数。 【数据范围】 1≤m≤161≤m≤161≤m≤16 1≤n,pi≤1091≤n,p_i≤10^91≤n,pi​≤10
容斥原理公式
csdn_muxin的博客
02-20 5439
简介 在计数时，必须注意没有重复，没有遗漏。为了使重叠部分不被重复计算，人们研究出一种新的计数方法，这种方法的基本思想是：先不考虑重叠的情况，把包含于某内容中的所有对象的数目先计算出来，然后再把计数时重复计算的数目排斥出去，使得计算的结果既无遗漏又无重复，这种计数的方法称为容斥原理。 定义 如果被计数的事物有A、B、C三类，那么，A类和B类和C类元素个数总和= A类元素个数+ B类元素个数+...
cf449D. Jzzhu and Numbers(容斥原理 高维前缀和)
weixin_34245169的博客
11-06 153
题意 题目链接 给出\(n\)个数，问任意选几个数，它们\(\&amp;\)起来等于\(0\)的方案数 Sol 正解居然是容斥原理Orz，然而本蒟蒻完全想不到。。 考虑每一种方案 答案=任意一种方案 - 至少有\(1\)位为\(1\)的方案 + 至少有两位为\(1\)的方案 - 至少有三位为\(1\)的方案 至少有\(i\)位为\(1\)的方案可以dp算，设\(f[x]\)表示满足\(f[x] =...
Codeforces.449D.Jzzhu and Numbers(容斥 高维前缀和)
weixin_30693183的博客
12-05 93
题目链接 \(Description\) 给定\(n\)个正整数\(a_i\)。求有多少个子序列\(a_{i_1},a_{i_2},...,a_{i_k}\)，满足\(a_{i_1},a_{i_2},...,a_{i_k}\) \(and\)起来为\(0\)。 \(n\leq10^6,\quad 0\leq a_i\leq10^6\)。 \(Solution\) 这个数据范围。。考虑按位容斥： 令...
(学习笔记)有关容斥原理的一些公式
weixin_30413739的博客
12-03 571
容斥 容斥原理的一般化： 　　对于两个关于集合的函数\(f(S)\)和\(g(S)\)，若 \[ f(S)=\sum\limits_{T\subseteq S}g(T) \] 　　那么有 \[ g(S)=\sum\limits_{T\subseteq S}(-1)^{\left |S\right |-\left |T \right |}f(T) \] 　　类似的形式有 \[ f(S)=\sum\l...
容斥原理详解与应用：卷积、莫比乌斯反演
容斥原理及其拓展应用包括但不限于加权形式、卷积、莫比乌斯反演和积性函数前缀和，这些工具在处理组合优化、数论问题以及计数问题时都非常有用。在编程竞赛或实际开发中，理解和掌握这些概念可以帮助我们解决复杂的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值