容斥小结

最新推荐文章于 2021-03-05 16:41:49 发布
最新推荐文章于 2021-03-05 16:41:49 发布
阅读量73 收藏
点赞数
原文链接：http://www.cnblogs.com/dengyixuan/p/8818624.html
版权

本篇小结大部分都是广义容斥原理，你可以看看这篇容斥原理小结,shadow;

bzoj3622
  • 考虑糖果比药片大的对数比药片比糖果大的对数不太好考虑，我们先只考虑糖果比药片多的对数
  • 显然先排序，对每个糖果处理一个\(num\)表示有\(num\)个药片它小，设\(dp[i][j]\)表示考虑前i个，有j对符合条件，转移方程\[dp[i][j]=dp[i-1][j]+dp[i-1][j-1]*max(0,num[i]-j+1)\],第一项代表不选第i个，第二项代表选，前面有\(max(0,num[i]-j+1)\)个可以与他配对
  • 然后令\(ans[i]=dp[n][i]*(n-i)!\),没有配对的就直接阶乘乱放
  • 显然会算重，直接二项式定理容斥就行了
#include<bits/stdc++.h>
using namespace std;
typedef int sign;
typedef long long ll;
#define For(i,a,b) for(register sign i=(sign)a;i<=(sign)b;++i)
#define Fordown(i,a,b) for(register sign i=(sign)a;i>=(sign)b;--i)
const int N=2000+5;
bool cmax(sign &a,sign b){return (a<b)?a=b,1:0;}
bool cmin(sign &a,sign b){return (a>b)?a=b,1:0;}
template<typename T>T read()
{
  T ans=0,f=1;
  char ch=getchar();
  while(!isdigit(ch)&&ch!='-')ch=getchar();
  if(ch=='-')f=-1,ch=getchar();
  while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch-'0'),ch=getchar();
  return ans*f;
}
template<typename T>void write(T x,char y)
{
  if(x==0)
  {
      putchar('0');putchar(y);
      return;
  }
  if(x<0)
  {
      putchar('-');
      x=-x;
  }
  static char wr[20];
  int top=0;
  for(;x;x/=10)wr[++top]=x%10+'0';
  while(top)putchar(wr[top--]);
  putchar(y);
}
void file()
{
  #ifndef ONLINE_JUDGE
      freopen("3622.in","r",stdin);
      freopen("3622.out","w",stdout);
  #endif
}
const int mo=1e9+9;
int n,k;
int a[N],b[N];
void input()
{
    n=read<int>(),k=read<int>();
    k=(n+k)>>1;
    For(i,1,n)a[i]=read<int>();
    For(i,1,n)b[i]=read<int>();
}
int num[N],dp[N][N],ans[N];
void add(int &a,int b)
{
    a+=b;if(a>=mo)a-=mo;
}
int C[N][N],mc[N];
void init(int maxn)
{
    For(i,0,maxn)C[i][0]=C[i][i]=1;
    For(i,2,maxn)For(j,1,i-1)C[i][j]=(C[i-1][j-1]+C[i-1][j])%mo;
    mc[0]=1;For(i,1,maxn)mc[i]=1ll*mc[i-1]*i%mo;
}
void work()
{
    int pos=0;
    sort(a+1,a+n+1);
    sort(b+1,b+n+1);
    For(i,1,n)
    {
        while(pos<n&&b[pos+1]<a[i])++pos;
        num[i]=pos;
        
    }
    dp[0][0]=1;
    For(i,1,n)For(j,0,i)
    {
        dp[i][j]=dp[i-1][j];
        if(j)add(dp[i][j],1ll*dp[i-1][j-1]*max(num[i]-j+1,0)%mo);
    }
    Fordown(i,n,k)
    {
        ans[i]=1ll*dp[n][i]*mc[n-i]%mo;
        For(j,i+1,n)add(ans[i],mo-1ll*ans[j]*C[j][i]%mo);
    }
    write(ans[k],'\n');
}
int main()
{
    file();
    input();
    init(max(n,k));
    work();
    return 0;
}
bzoj4361
  • 先设\(dp[i][j]\)表示到第i位，最长不降子序列长为j的方案数，本来是\(n^2\)的，用\(BIT\)优化一下
  • \(f[i]\)表示最长非降子序列长为j的方案之和，\(f[i]=\sum_{j=i}^{n}dp[j][i]*(j-i)!\),删去的元素顺序随意
  • 算重，因为有些数列删到\(i+1\)时就已经满足要求，但我们还是把他删到了\(i\)，所以容斥为\(ans=\sum_{i=n}^{1}f[i]*(n-i)!-f[i+1]*(n-i-1)!*(i+1)\)，就是枚举是\(i+1\)的方案中删掉了哪一个数而非法的
#include<bits/stdc++.h>
using namespace std;
typedef int sign;
typedef long long ll;
#define For(i,a,b) for(register sign i=(sign)a;i<=(sign)b;++i)
#define Fordown(i,a,b) for(register sign i=(sign)a;i>=(sign)b;--i)
const int N=2e3+5;
bool cmax(sign &a,sign b){return (a<b)?a=b,1:0;}
bool cmin(sign &a,sign b){return (a>b)?a=b,1:0;}
template<typename T>T read()
{
  T ans=0,f=1;
  char ch=getchar();
  while(!isdigit(ch)&&ch!='-')ch=getchar();
  if(ch=='-')f=-1,ch=getchar();
  while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch-'0'),ch=getchar();
  return ans*f;
}
template<typename T>void write(T x,char y)
{
  if(x==0)
  {
      putchar('0');putchar(y);
      return;
  }
  if(x<0)
  {
      putchar('-');
      x=-x;
  }
  static char wr[20];
  int top=0;
  for(;x;x/=10)wr[++top]=x%10+'0';
  while(top)putchar(wr[top--]);
  putchar(y);
}
void file()
{
  #ifndef ONLINE_JUDGE
      freopen("4361.in","r",stdin);
      freopen("4361.out","w",stdout);
  #endif
}
int n,a[N];
void input()
{
    n=read<int>();
    For(i,1,n)a[i]=read<int>();
}
const int mo=1e9+7;
int dp[N][N];
void add(int &x,int y)
{
    x+=y;if(x>=mo)x-=mo;
}
struct BIT
{
    int sum[N];
    void update(int x,int v)
    {
        for(;x<=n;x+=x&-x)add(sum[x],v);
    }
    int cal(int x)
    {
        int res=0;
        for(;x;x-=x&-x)add(res,sum[x]);
        return res;
    }
}s[N];
int mc[N],ans;
int f[N],q[N],top;
void init()
{
    For(i,1,n)q[i]=a[i];
    sort(q+1,q+n+1);
    top=unique(q+1,q+n+1)-q-1;
    For(i,1,n)a[i]=lower_bound(q+1,q+top+1,a[i])-q;
    mc[0]=1;For(i,1,n)mc[i]=1ll*mc[i-1]*i%mo;
}
void work()
{
    For(i,1,n)
    {
        Fordown(j,n,2)
        {
            add(dp[i][j],s[j-1].cal(a[i]));
            s[j].update(a[i],dp[i][j]);
            add(f[j],dp[i][j]);
        }
        dp[i][1]=1;s[1].update(a[i],dp[i][1]);
        f[1]++;
    }
    //For(i,1,n)For(j,1,n)write(dp[i][j],j==n?'\n':' ');
    Fordown(i,n,1)
    {
        add(ans,1ll*f[i]*mc[n-i]%mo);
        add(ans,mo-1ll*f[i+1]*mc[n-i-1]%mo*(i+1)%mo);
    }
    write(ans,'\n');
}
int main()
{
    file();
    input();
    init();
    work();
    return 0;
}
bzoj4710
  • 一开始疯狂考虑同一种特产算重的情况，思路完全错误了
  • 因为所有人都要有，所以我们枚举有几个人分到了特产，设\(f[i]\)表示有i个人分到了特产，那么\(f[i]=\prod_{j=1}^{m}C[a[j]+i-1][i-1]\)，然后直接二项式容斥就行了
#include<bits/stdc++.h>
using namespace std;
typedef int sign;
typedef long long ll;
#define For(i,a,b) for(register sign i=(sign)a;i<=(sign)b;++i)
#define Fordown(i,a,b) for(register sign i=(sign)a;i>=(sign)b;--i)
const int N=1000+5;
template<typename T>bool cmax(T &a,T b){return (a<b)?a=b,1:0;}
template<typename T>bool cmin(T &a,T b){return (a>b)?a=b,1:0;}
template<typename T>T read()
{
  T ans=0,f=1;
  char ch=getchar();
  while(!isdigit(ch)&&ch!='-')ch=getchar();
  if(ch=='-')f=-1,ch=getchar();
  while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch-'0'),ch=getchar();
  return ans*f;
}
template<typename T>void write(T x,char y)
{
  if(x==0)
  {
      putchar('0');putchar(y);
      return;
  }
  if(x<0)
  {
      putchar('-');
      x=-x;
  }
  static char wr[20];
  int top=0;
  for(;x;x/=10)wr[++top]=x%10+'0';
  while(top)putchar(wr[top--]);
  putchar(y);
}
void file()
{
  #ifndef ONLINE_JUDGE
      freopen("4710.in","r",stdin);
      freopen("4710.out","w",stdout);
  #endif
}
const int mo=1e9+7;
int n,m,a[N];
void input()
{
    n=read<int>(),m=read<int>();
    For(i,1,m)a[i]=read<int>();
}
int ans;
int C[2005][2005];
const int maxn=2e3;
void work()
{
    For(i,0,maxn)C[i][0]=C[i][i]=1;
    For(i,2,maxn)For(j,1,i-1)C[i][j]=(C[i-1][j-1]+C[i-1][j])%mo;
    int sum;
    For(i,1,n)
    {
        sum=1;
        For(j,1,m)sum=1ll*sum*C[a[j]+i-1][i-1]%mo;
        if((n-i)&1)ans=(ans-1ll*sum*C[n][i]%mo+mo)%mo;
        else ans=(ans+1ll*sum*C[n][i]%mo)%mo;
    }
    write(ans,'\n');
}
int main()
{
    file();
    input();
    work();
    return 0;
}
bzoj
  • 设\(f[i]\)强制选择i个相同元素的方案数，\(f[i]={a\choose b}*(2^{2^{n-i}}-1)\),注意计算上面指数要\(\%(mod-1)\)，（WA了半天）,剩下就是个二项式容斥了
#include<bits/stdc++.h>
using namespace std;
typedef int sign;
typedef long long ll;
#define For(i,a,b) for(register sign i=(sign)a;i<=(sign)b;++i)
#define Fordown(i,a,b) for(register sign i=(sign)a;i>=(sign)b;--i)
const int N=1e6+5;
template<typename T>bool cmax(T &a,T b){return (a<b)?a=b,1:0;}
template<typename T>bool cmin(T &a,T b){return (a>b)?a=b,1:0;}
template<typename T>T read()
{
  T ans=0,f=1;
  char ch=getchar();
  while(!isdigit(ch)&&ch!='-')ch=getchar();
  if(ch=='-')f=-1,ch=getchar();
  while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch-'0'),ch=getchar();
  return ans*f;
}
template<typename T>void write(T x,char y)
{
  if(x==0)
  {
      putchar('0');putchar(y);
      return;
  }
  if(x<0)
  {
      putchar('-');
      x=-x;
  }
  static char wr[20];
  int top=0;
  for(;x;x/=10)wr[++top]=x%10+'0';
  while(top)putchar(wr[top--]);
  putchar(y);
}
void file()
{
  #ifndef ONLINE_JUDGE
      freopen("2839.in","r",stdin);
      freopen("2839.out","w",stdout);
  #endif
}
const int mo=1e9+7;
int n,k;
void input()
{
    n=read<int>(),k=read<int>();
}
int pw[N],f[N],mc[N],inv[N];
ll power(ll x,int y)
{
    ll res=1;
    for(;y;x=x*x%mo,y>>=1)if(y&1)res=res*x%mo;
    return res;
}
int C(int n,int m)
{
    return 1ll*mc[n]*inv[m]%mo*inv[n-m]%mo;
}
void work()
{
    pw[0]=1;For(i,1,n)pw[i]=1ll*(pw[i-1]<<1)%mo;
    For(i,1,n)pw[i]=power(2,pw[i])-1;
    mc[0]=1;For(i,1,n)mc[i]=1ll*mc[i-1]*i%mo;
    inv[0]=1;inv[n]=power(mc[n],mo-2);
    Fordown(i,n-1,1)inv[i]=1ll*inv[i+1]*(i+1)%mo;
    For(i,k,n)f[i]=1ll*C(n,i)*pw[n-i]%mo;
    For(i,k+1,n)f[k]=(f[k]+1ll*f[i]*C(i,k)%mo*(((i-k)&1)?-1:1)%mo+mo)%mo;
    write(f[k],'\n');
}
int main()
{
    file();
    input();
    work();
    return 0;
}
bzoj 4767
  • 首先解个方程，两个解就是两种方式所需要的步数，对于每个障碍点也算出两种方式所需要的步数，然后将解排序，用每个点的方案减去前面所有可以到达它的障碍点到它的方案即可。
#include<bits/stdc++.h>
using namespace std;
typedef int sign;
typedef long long ll;
#define For(i,a,b) for(register sign i=(sign)a;i<=(sign)b;++i)
#define Fordown(i,a,b) for(register sign i=(sign)a;i>=(sign)b;--i)
const int N=500+5;
template<typename T>bool cmax(T &a,T b){return (a<b)?a=b,1:0;}
template<typename T>bool cmin(T &a,T b){return (a>b)?a=b,1:0;}
template<typename T>T read()
{
  T ans=0,f=1;
  char ch=getchar();
  while(!isdigit(ch)&&ch!='-')ch=getchar();
  if(ch=='-')f=-1,ch=getchar();
  while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch-'0'),ch=getchar();
  return ans*f;
}
template<typename T>void write(T x,char y)
{
  if(x==0)
  {
      putchar('0');putchar(y);
      return;
  }
  if(x<0)
  {
      putchar('-');
      x=-x;
  }
  static char wr[20];
  int top=0;
  for(;x;x/=10)wr[++top]=x%10+'0';
  while(top)putchar(wr[top--]);
  putchar(y);
}
void file()
{
  #ifndef ONLINE_JUDGE
      freopen("4767.in","r",stdin);
      freopen("4767.out","w",stdout);
  #endif
}
int A,B,n;
int ax,bx,ay,by;
void input()
{
    A=read<int>(),B=read<int>();n=read<int>();
    ax=read<int>(),ay=read<int>(),bx=read<int>(),by=read<int>();
}
void cal(int x1,int y1,int x2,int y2,int &t1,int &t2)
{
    int x=x2-x1,y=y2-y1;
    int temp=x*by-y*bx;
    int res=by*ax-ay*bx;
    if(temp%res!=0)t1=t2=-1;
    else
    {
        t1=temp/res;
        if(bx)
        {
            temp=x-ax*t1;
            if(temp%bx==0)t2=temp/bx;
            else t1=t2=-1;
        }
        else if(by)
        {
            temp=y-ay*t1;
            if(temp%by==0)t2=temp/by;
            else t1=t2=-1;
        }
    }
}
const int mo=1e9+7;
const int maxn=5e5;
int inv[maxn+5],mc[maxn+5];
ll power(ll x,int y)
{
    ll res=1;
    for(;y;x=x*x%mo,y>>=1)if(y&1)res=res*x%mo;
    return res;
}
void init()
{
    mc[0]=1;For(i,1,maxn)mc[i]=1ll*mc[i-1]*i%mo;
    inv[0]=1;inv[maxn]=power(mc[maxn],mo-2);
    Fordown(i,maxn-1,1)inv[i]=1ll*inv[i+1]*(i+1)%mo;
}
int C(int x,int y)
{
    if(x<y)return 0;
    return 1ll*mc[x]*inv[y]%mo*inv[x-y]%mo; 
}
int ans;
typedef pair<int,int> pii;
pii q[N];
int tot;
#define mk make_pair
#define fir first
#define sec second
void add(int &a,int b)
{
    a+=b;if(a>=mo)a-=mo;
}
int path(int i,int j)
{
    int x=q[j].fir-q[i].fir ,y=q[j].sec-q[i].sec;
    if(x<0||y<0)return 0;
    return C(x+y,y);
}
int dp[N];
void work()
{
    int t1,t2;
    cal(0,0,A,B,t1,t2);
    if(t1<0||t2<0){puts("0");return;}
    A=t1,B=t2;
    q[++tot]=mk(t1,t2);
    int x,y;
    For(i,1,n)
    {
        x=read<int>(),y=read<int>();
        cal(0,0,x,y,t1,t2);
        if(t1>=0&&t2>=0&&t1<=A&&t2<=B)q[++tot]=mk(t1,t2);
    }
    sort(q+1,q+tot+1);
    For(i,1,tot)
    {
        dp[i]=C(q[i].fir+q[i].sec,q[i].fir);
        For(j,1,i-1)add(dp[i],mo-1ll*dp[j]*path(j,i)%mo);
    }
    write(dp[tot],'\n');
}
int main()
{
    file();
    input();
    init();
    work();
    return 0;
}

转载于:https://www.cnblogs.com/dengyixuan/p/8818624.html

weixin_30651273
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
uva 11806 - Cheerleaders(容斥原理)
不慌不忙、不急不躁
05-14 1650
题目链接：uva 11806 - Cheerleaders 题目大意：在一个m行n列的矩阵网里放k个石子，问有多少种画法？每个格子最多放一个石子，所有石子必须用完，并且在第一行、最后一行、第一列和最后一列都得有石子。 解题思路：容斥原理，我们可以先求说在m∗n的矩阵上放k个石子的种数C(nmk),减掉四条边界不放的情况就是答案了。所以枚举16种状态，用二进制数表示说四条边中那些边是不放
【学习小结】min−max 容斥（反演）
执子之手,与子偕老
01-27 473
最基本的min-max 容斥（见下方博客前端） 主要用来处理期望问题 几道例题 bzoj 4036 按位或 loj PKUSC 随机游走 还有一类简化lcm到gcd 51Nod1355：斐波那契的最小公倍数 kth min-max 容斥from zjp-shadow 例题很好！ 就是把第k大的也可以反演， 积累容斥的时候推系数的通用思路：看最后要贡献的是那一部分，然后把所有的贡献的式子列出来，最...
中石油训练赛 - Insertion Order(二叉搜索树+构造)
Falcon的博客
09-28 621
题目大意：构造出一个长度为 n 的排列，使得按照这个顺序构造出的二叉搜索树的高度为 k 题目分析：知道 n 的大小后不难算出其可以构造的二叉搜索树高度的可行范围，下限是一棵满二叉树，这个利用倍增很快就能找到，上限就是 n ，当且仅当这棵树退化为一条链时达到，如果在这个范围内是一定有解且可以构造的 考虑如何构造答案，首先我们先构造一棵有 n 个节点，高度为 k 的树，只需要先用 dfs 固定出一条长度为 k 的链保证其高度至少为 k ，然后再用 bfs 逐层加点即可，当构造出整棵树后，递归对其赋值即可..
Min-Max容斥小结
a_forever_dream的博客
03-05 449
介绍 对于一个集合 U={a1,a2,a3,...,an}U=\{a_1,a_2,a_3,...,a_n\}U={a1​,a2​,a3​,...,an​}，我想要知道其中的 max⁡\maxmax，但是很不好求，那么就可以通过Min-Max容斥转化为求出它所有子集中的 min⁡\minmin。 正题 一切的魔术来源于这个简单的式子： max⁡{U}=∑S⊆U(−1)∣S∣+1min⁡{S} \max\{U\}=\sum_{S\subseteq U} (-1)^{|S|+1} \min\{S\} max{U}
min-max容斥小结
curry的博客
08-19 326
..
容斥原理小结
Miracle_ma的专栏
11-23 742
数学修养过低，努力学习 POJ 3370 题意：给你一些数，让你取其中几个，模c得0，输出取的数的序号，不行的话输出no 题解：这题就是典型的鸽巢原理，构造序列a1，a1+a2，a1+a2+a3，........a1+a2+...+an 这样n个数的序列，然后都模c，看有没有相等的两个数，因为如果sumi==sumj，那么ai+1+ai+2+......+aj就能模c得0，如果有sumj=
容斥原理
yiyiyizqy的博客
08-08 310
容斥原理 基本概念：     在计数时，必须注意没有重复，没有遗漏。为了使重叠部分不被重复计算，人们研究出一种新的计数方法，这种方法的基本思想是：先不考虑重叠的情况，把包含于某内容中的所有对象的数目先计算出来，然后再把计数时重复计算的数目排斥出去，使得计算的结果既无遗漏又无重复，这种计数的方法称为容斥原理。         ——摘自百度百科 关于∩（与）∪（并）：    
鸽巢原理和容斥原理小结
weixin_30951389的博客
07-07 277
一、鸽巢原理 内容回顾： 1、若有n个笼子和n+1只鸽子，所有的鸽子都被关在鸽笼里，那么至少有一个笼子有至少2只鸽子。 2、若有n个笼子和kn+1只鸽子，所有的鸽子都被关在鸽笼里，那么至少有一个笼子有至少k+1只鸽子。 鸽巢原理主要在于能否抽象出它的模型，同时在应用其中，例如： 1.如果将1，2……10随机地摆放一圈，则必有相邻的三个数之和至少是17。 2.证明有理数a/b展开的十进制...
【学习小结】反演，容斥，组合计数
执子之手,与子偕老
01-28 425
推数学式子的时候不仅要从组合意义上把式子的意义完完全全理解，还要从实际问题的边界条件出发检验式子的正确性！所有组合计数题一定要把式子一遍推正确，因为根本没法再调试找到错误，太浪费时间了！ 关于反演的本质： 变换和逆变换：f=A∗g,g=B∗f且AB=I（A,B互为逆矩阵） f = A * g , g = B * f 且 AB = I （A,B互为逆矩阵）f=A∗g,g=B∗f且AB=I（A,B互为...
容斥原理+拓展
10-25
关于容斥原理的非常详细的讲解，+卷积+莫比乌斯反演+积性函数前缀和+集合卷积变换
容斥原理与鸽巢原理ppt
08-15
容斥原理与鸽巢原理。在求解计数问题时,用间接的方法往往比直接容易,本课件将介绍常用的间接计数方法: 容斥原理与鸽巢原理.
容斥原理与莫比乌斯函数.md
08-09
容斥原理与莫比乌斯函数.md
容斥原理理论和鸽巢原理
05-29
非常难的一个算法，好好努力吧！快快来下载啊！
容斥原理解决被毁坏的玉米地问题
04-03
组合论作业 C语言源代码 运用组合论中的容斥原理解决被毁坏的玉米地问题
国内移动端APP月活跃（MAU）Top5000 数据整理
06-16
国内移动端APP月活跃（MAU）Top5000 时间范围：2020年-2022年 具有一定参考价值 csv格式
和平巨魔跨进成免费.ipa
最新发布
06-16
和平巨魔跨进成免费.ipa
数据库管理工具:dbeaver-ce-23.0.4-macos-aarch64.dmg
06-16
1.DBeaver是一款通用数据库工具，专为开发人员和数据库管理员设计。 2.DBeaver支持多种数据库系统，包括但不限于MySQL、PostgreSQL、Oracle、DB2、MSSQL、Sybase、Mimer、HSQLDB、Derby、SQLite等，几乎涵盖了市场上所有的主流数据库。 3.支持的操作系统：包括Windows（2000/XP/2003/Vista/7/10/11）、Linux、Mac OS、Solaris、AIX、HPUX等。 4.主要特性： 数据库管理：支持数据库元数据浏览、元数据编辑（包括表、列、键、索引等）、SQL语句和脚本的执行、数据导入导出等。 用户界面：提供图形界面来查看数据库结构、执行SQL查询和脚本、浏览和导出数据，以及处理BLOB/CLOB数据等。用户界面设计简洁明了，易于使用。 高级功能：除了基本的数据库管理功能外，DBeaver还提供了一些高级功能，如数据库版本控制（可与Git、SVN等版本控制系统集成）、数据分析和可视化工具（如图表、统计信息和数据报告）、SQL代码自动补全等。
【课件】8.4.1简单选择排序.pdf
06-16
【课件】8.4.1简单选择排序
容斥原理matlab
09-03
容斥原理是一种计数方法，用于解决集合中某些对象的数目的问题。它的基本思想是先计算包含于某个内容中的所有对象的数目，然后排除重复计算的对象，以确保计数结果既不遗漏又没有重复。在容斥原理的应用中，通常需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值