容斥专题三

最新推荐文章于 2022-05-29 23:25:03 发布
最新推荐文章于 2022-05-29 23:25:03 发布
阅读量1k 收藏 1
点赞数
分类专栏： 数学 文章标签： 容斥原理 专题 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shengtao96/article/details/52612503
版权
本文总结了容斥原理在算法竞赛中的应用，通过多个题目详细解析了如何利用容斥原理解决组合计数、棋盘放置、圆环相交、石子跳跃等问题。文章介绍了如何优化复杂度，以及在不同场景下的解题思路，如利用高精度、同余方程、DFS搜索等方法。
摘要由CSDN通过智能技术生成

抱歉，抱歉，前两周忙着打网络赛，结果容斥专题断了整整两周。最后一个专题，总结性专题，现在继续。

第一题SGU-476

题意：3n个人，组成n个三人组，而且必须满足k组条件，每组条件表示a编号为a,b,c的三人不可以一个队。

分析：是容斥原理，用所有情况减去不能出现的情况，就是答案。对于不能出现的情况，对于条件的组数进行容斥，如果多组情况中有相同的成员编号那么就是不可能出现的,为0。这样的话，代码还是很好写的，而且用dfs的写法，还可以进行剪枝。

观察数据范围，发现答案很大，必须使用高精度。使用高精度打表的时候发现复杂度很高，预处理处理不出来，一个是高精度的模版不行(果断换掉)，还有就是简化打表公式。对于没有条件的3n个人，方案数是 (3n)!6n∗n! ，知道通项，很方便的得到递推式 n0=1,ni=ni−1∗(3n−1)∗(3n−2)2 ，这样打表很显然快很多。

但是这样的话，对于极限情况还是很慢，因为进行了多次大数相加（大约为1000的复杂度），递归深度是20，那么总的复杂度就是 1000∗220=109 ，极限情况是会TLE的。

之后，我考虑对于每一组具有相同有效条件数的搜索，它的方案数和符号都是一样的，那么我可以先将他们累积起来，再直接进行一次大数乘法和一次大数加法。这样的话，将时间复杂度优化到了10^6（常数可能有点大），就可以过了。

#include <map>
#include <set>
#include <ctime>
#include <stack>
#include <cmath>
#include <queue>
#include <bitset>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <fstream>
#include <cstdlib>
#include <sstream>
#include <cstring>
#include <iostream>
#include <algorithm>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;
#define   maxn          1000000+10
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   clr(x,y)      memset(x,y,sizeof(x))
#define   rep(i,n)      for(int i=0;i<(n);i++)
#define   repf(i,a,b)   for(int i=(a);i<=(b);i++)
#define   pii           pair<int,int>
#define   mp            make_pair
#define   FI            first
#define   SE            second
#define   IT            iterator
#define   PB            push_back
#define   Times         10

typedef   long long     ll;
typedef   unsigned long long ull;
typedef   long double   ld;

const double eps   = 1e-10;
const double  pi   = acos(-1.0);
const  ll    mod   = 1e9+7;
const  int   inf   = 0x3f3f3f3f;
const  ll    INF   = (ll)1e18+300;
const double delta = 0.98;

inline void RI(int& x)
{
    x=0;
    char c=getchar();
    while(!((c>='0'&&c<='9')||c=='-'))c=getchar();
    bool flag=1;
    if(c=='-')
    {
        flag=0;
    }
    while(c<='9'&&c>='0')
    {
        x=x*10+c-'0';
        c=getchar();
    }
    if(!flag)x=-x;
}

//--------------------------------------------------
int compare(string str1,string str2)  
{  
    if(str1.length()>str2.length()) return 1;  
    else if(str1.length()<str2.length())  return -1;  
    else return str1.compare(str2);  
}  
string add(string str1,string str2)
{  
    string str;  

    int len1=str1.length();  
    int len2=str2.length();  
    if(len1<len2)  
    {  
        for(int i=1;i<=len2-len1;i++)  
           str1="0"+str1;  
    }  
    else  
    {  
        for(int i=1;i<=len1-len2;i++)  
           str2="0"+str2;  
    }  
    len1=str1.length();  
    int cf=0;  
    int temp;  
    for(int i=len1-1;i>=0;i--)  
    {  
        temp=str1[i]-'0'+str2[i]-'0'+cf;  
        cf=temp/10;  
        temp%=10;  
        str=char(temp+'0')+str;  
    }  
    if(cf!=0)  str=char(cf+'0')+str;  
    return str;  
}  
string sub(string str1,string str2)
{  
    string str;  
    int tmp=str1.length()-str2.length();  
    int cf=0;  
    for(int i=str2.length()-1;i>=0;i--)  
    {  
        if(str1[tmp+i]<str2[i]+cf)  
        {  
            str=char(str1[tmp+i]-str2[i]-cf+'0'+10)+str;  
            cf=1;  
        }  
        else  
        {  
            str=char(str1[tmp+i]-str2[i]-cf+'0')+str;  
            cf=0;  
        }  
    }  
    for(int i=tmp-1;i>=0;i--)  
    {  
        if(str1[i]-cf>='0')  
        {  
            str=char(str1[i]-cf)+str;  
            cf=0;  
        }  
        else  
        {  
            str=char(str1[i]-cf+10)+str;  
            cf=1;  
        }  
    }  
    str.erase(0,str.find_first_not_of('0')); 
    return str;  
}  
string mul(string str1,string str2)  
{  
    string str;  
    int len1=str1.length();  
    int len2=str2.length();  
    string tempstr;  
    for(int i=len2-1;i>=0;i--)  
    {  
        tempstr="";  
        int temp=str2[i]-'0';  
        int t=0;  
        int cf=0;  
        if(temp!=0)  
        {  
            for(int j=1;j<=len2-1-i;j++)  
              tempstr+="0";  
            for(int j=len1-1;j>=0;j--)  
            {  
                t=(temp*(str1[j]-'0')+cf)%10;  
                cf=(temp*(str1[j]-'0')+cf)/10;  
                tempstr=char(t+'0')+tempstr;  
            }  
            if(cf!=0) tempstr=char(cf+'0')+tempstr;  
        }  
        str=add(str,tempstr);  
    }  
    str.erase(0,str.find_first_not_of('0'));  
    return str;  
}  

void div(string str1,string str2,string &quotient,string &residue)  
{  
    quotient=residue="";
    if(str2=="0")
    {  
        quotient=residue="ERROR";  
        return;  
    }  
    if(str1=="0")
    {  
        quotient=residue="0";  
        return;  
    }  
    int res=compare(str1,str2);  
    if(res<0)  
    {  
        quotient="0";  
        residue=str1;  
        return;  
    }  
    else if(res==0)  
    {  
        quotient="1";  
        residue="0";  
        return;  
    }  
    else  
    {  
        int len1=str1.length();  
        int len2=str2.length();  
        string tempstr;  
        tempstr.append(str1,0,len2-1);  
        for(int i=len2-1;i<len1;i++)  
        {  
            tempstr=tempstr+str1[i];  
            tempstr.erase(0,tempstr.find_first_not_of('0'));  
            if(tempstr.empty())  
              tempstr="0";  
            for(char ch='9';ch>='0';ch--)
            {  
                string str,tmp;  
                str=str+ch;  
                tmp=mul(str2,str);  
                if(compare(tmp,tempstr)<=0) 
                {  
                    quotient=quotient+ch;  
                    tempstr=sub(tempstr,tmp);  
                    break;  
                }  
            }  
        }  
        residue=tempstr;  
    }  
    quotient.erase(0,quotient.find_first_not_of('0'));  
    if(quotient.empty()) quotient="0";  
}  
string dat[1000+10];
string ans,ant;
int tri[20+10][3];
int nun[20+10];
int vis[3000+10];
int n,k;
string Multiply(string s,int x)
{  
    reverse(s.begin(),s.end());  
    int cmp=0;  
    for(int i=0;i<s.size();i++)  
    {  
        cmp=(s[i]-'0')*x+cmp;  
        s[i]=(cmp%10+'0');  
        cmp/=10;  
    }  
    while(cmp)  
    {  
        s+=(cmp%10+'0');  
        cmp/=10;  
    }  
    reverse(s.begin(),s.end());  
    s.erase(0,s.find_first_not_of('0'));
    return s;  
}  
void init(){
    dat[0]="1";
    for(int i=1;i<=1000;i++)
        dat[i]=Multiply(dat[i-1],(3*i-2)*(3*i-1)/2);
}
void dfs(int len,int num){
    if(len==k){
        if(num)nun[num]++;
        return ;
    }
    dfs(len+1,num);
    for(int i=0;i<3;i++)
        if(vis[tri[len][i]])return ;
    for(int i=0;i<3;i++)
        vis[tri[len][i]]=1;
    dfs(len+1,num+1);
    for(int i=0;i<3;i++)
        vis[tri[len][i]]=0;
}
int main(){
    //freopen("d:\\acm\\in.in","r",stdin);
    init();
    while(~scanf("%d %d",&n,&k)){
        ans=dat[n];
        ant="0";
        for(int i=0;i<k;i++)
            for(int j=0;j<3;j++)
                scanf("%d",&tri[i][j]);
        clr(vis,0);
        clr(nun,0);
        dfs(0,0);
        for(int i=1;i<=k;i++)
            if(nun[i]){
                if(i&1)ant=add(ant,Multiply(dat[n-i],nun[i]));
                else ans=add(ans,Multiply(dat[n-i],nun[i]));
            }
        string anw=sub(ans,ant);
        if(anw.size())cout<<sub(ans,ant)<<endl;
        else puts("0");
    }
    return 0;
}

第二题uva-10325

分析：容斥的简单题目，看前面的专题。某个区间中不能被集合连任何一个数整除的数的个数?

#include <map>
#include <set>
#include <ctime>
#include <stack>
#include <cmath>
#include <queue>
#include <bitset>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <fstream>
#include <cstdlib>
#include <sstream>
#include <cstring>
#include <iostream>
#include <algorithm>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;
#define   maxn          300+10
#define   SIZE          10000+5
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   clr(x,y)      memset(x,y,sizeof(x))
#define   rep(i,n)      for(int i=0;i<(n);i++)
#define   repf(i,a,b)   for(int i=(a);i<=(b);i++)
#define   pii           pair<int,int>
#define   mp            make_pair
#define   FI            first
#define   SE            second
#define   IT            iterator
#define   PB            push_back
#define   Times         10

typedef   long long     ll;
typedef   unsigned long long ull;
typedef   long double   ld;

const double eps   = 1e-10;
const double  pi   = acos(-1.0);
const  ll    mod   = 1e9+7;
const  int   inf   = 0x3f3f3f3f;
const  ll    INF   = (ll)1e18+300;
const double delta = 0.98;

inline void RI(int& x)
{
    x=0;
    char c=getchar();
    while(!((c>='0'&&c<='9')||c=='-'))c=getchar();
    bool flag=1;
    if(c=='-')
    {
        flag=0;
    }
    while(c<='9'&&c>='0')
    {
        x=x*10+c-'0';
        c=getchar();
    }
    if(!flag)x=-x;
}

//--------------------------------------------------

int dat[20];
int n,m;
ll lcm(ll a,ll b){
    return a/__gcd(a,b)*b;
}
ll solve(){
    ll ans=0;
    for(int i=1;i<(1<<m);i++){
        ll t=1,num=0;
        for(int j=0;j<m;j++)
            if(i&(1<<j)){
                t=lcm(t,dat[j]);
                num++;
            }
        if(num&1)ans+=n/t;
        else ans-=n/t;
    }
    return n-ans;
}
int main(){
    //freopen("d:\\acm\\in.in","r",stdin);
    while(~scanf("%d %d",&n,&m)){
        for(int i=0;i<m;i++)
            s
最低0.47元/天 解锁文章
shengtao96
关注
专栏目录
【专题总结】容斥原理（持续更新）
TRiddle的博客
07-10 5476
差强人意的专题总结。
容斥专题总结
denghu0527的博客
08-24 205
容斥专题总结 A:How many integers can you find 过于水，但是有细节 \[\ \] \[\ \] B: Eddy's爱好 枚举k的值，直接开k次方根，为了防止爆精度，我手写了一下 然后就是对于因数容斥，或者是直接套莫比乌斯系数 const int N=4e5+10; const ll INF=(1ll<<62)-1; ll n; ll qs...
容斥原理专题
dukig的博客
04-30 231
原理在第三行最后一列 hdoj1465 设n个装错，n-1,n-2.. #include<iostream> #include<algorithm> #include<cstdio> #include<cstring> using namespace std; int f[21]; void init(){ for(int i = 2;...
python：
qq_70079028的博客
05-29 1032
查找在[m,n]范围内是否有同时满足下列条件的正整数： （1）对3取余等于1，对7取余等于2，对11取余等于3 （2）是一个素数 例如区间【700, 800】内有751满足条件。区间【1200,1300】内有1213满足条件，区间【2100，2200】内有2137满足条件。 如果一个区间内有多个数据满足条件，输出最小的那个。如果没有任何数据满足条件，输出“none” 输入：两个正整数m和n，表示闭区间[m,n]，题目保证：1≤m≤n≤100,000,000，两个数据之间用空格隔开。输出：一行。如果找到
运算符和变量
oklying的博客
03-03 325
运算符和变量 变量 内存大小 # 位(bit) # 1字节(byte) = 8位 # 1kb = 1024字节 # 1Mb = 1024kb # 1G = 1024Mb # 1T = 1024G 定义变量和重新给变量赋值的底层原理： 定义变量的时候会先根据数据去申请内存，内存申请多大看数据需要多大。然后将数据保存对应的内存中，最后将内存空间和变量进行关联。重新给变量赋值的时候，会重新根据新的数据申请新的内存，然后将新的数据存储到新的内存中，最后将新的内存空间和原
奥数训练专题——容斥原理2.doc
10-10
奥数训练专题——容斥原理2.doc
容斥原理/莫比乌斯反演/欧拉函数/线性筛专题
Qianyri的博客
08-08 1038
欧拉函数 线性筛 杜教筛 莫比乌斯反演 容斥原理 HDU2588 GCD 欧拉函数 给定N,M,求1&lt;=X&lt;=N 且gcd(X,N)&gt;=M条件下X的个数 #include&lt;bits/stdc++.h&gt; using namespace std; int euler(int n) { int ans=n; for(int i=2;i*i&...
容斥原理专题一
shengtao96的专栏
09-08 2123
抱歉，很久没有更新博客了。这几天集中刷了容斥原理的题目，于是就来写博客巩固下。容斥原理，我想大家在高中都或多或少的学过。虽然知道原理内容，但是用来解题的话，还是有点小障碍的，特别是不知道怎么写代码。如果读者连最基本的容斥原理都不理解的话，或者理解不深入、不知道容斥原理用来解决什么问题的话，请下载这篇PDF详细研读，相信会有收获：http://pan.baidu.com/s/1hrISIjy 密码:
5:综合-3
weixin_51447387的博客
12-04 392
5:综合-3 时间限制: 1 S | 内存限制: 8192 KB Accept: 33 | Submit: 98 [提交] [讨论版] 描述 统计m以内（小于等于m）同时满足以下三个条件的数字的总个数：1、是正整数；2、是完全平方数；3、各位数字上没有相同的数字。 输入 一个正整数n，表示有n组案例。 每组案例由一个正整数m构成（m可能有点大）。 输出 针对每组案例，输出m以内（小于等于m）同时满足以下三个条件的数字的总个数：1、是正整数；2、是完全平方数；3、各位数字上没有相同的数字（例如171，由于有两
HDU 1695（数论，筛选+素因子分解+容斥）
AI蜗牛之家
05-20 913
题意：已知给定k,x,y求 1 用到了欧拉函数,素因子分解,筛选法,组合数学上的容斥原理等,不失为一道好题!!! 大体思路： 有一个小小的变形:在[1...b/k]中选x,在[1....d/k]中选y,使gcd(x,y)=k,求不重复的对数 我们让d>=b;　　然后在[1....d/k]进行枚举,对于每一个i,我们只要在1...min(i-1,b)中找到与i互质数,记录个数
千锋教育python2104期总结day3
m0_60055750的博客
07-14 352
千锋教育python2104期总结 第二次总结: 运算符与分支 目录 1.数学运算符 2.比较运算符 3.逻辑运算符 4.赋值运算符 5.分支结构 6.作业 正文 1. 数学运算符 1.数学运算符包括: +, -, *, /, %(求余), //(整除), **(幂运算) 2.% - 取余数, print(5%2) print(16%2) 应用:判断一个数十分能够被另一个数整除 print(15%5) 应用:取低位(对10或10的幂次方取余) num=2398 print(num%10) print
POJ1091 跳蚤 素因子分解+容斥原理
AC_Gibson的专栏
06-17 2361
题目链接：http://poj.org/problem?id=1091 分析：我们假设卡片上的标号分别是a1,a2,...,an,M，跳蚤跳对应标号的卡片的次数分别为x1,x2,...,xn,xn+1，那么要满足已知条件只需满足方程a1*x1+a2*x2+...+an*xn+M*xn+1=1有解，即gcd(a1,a2,...,an,m)=1，接下来对M进行质因子分解，然后排除公共因子非1
ACM-ICPC 2018 沈阳赛区网络预赛-G Spare Tire 素因子分解+容斥
人生如戏
09-09 245
A sequence of integer {an} can be expressed as: Now there are two integers n and m. I'm a pretty girl. I want to find all b1,b2,b3⋯bpthat 1≤bi​≤n and bi is relatively-prime with the integer m. An...
26 分解质因子 容斥 数学公式
qq_39792342的博客
09-10 496
15.41% 1000ms 131072K A sequence of integer {an}\lbrace a_n \rbrace{an​} can be expressed as:   an={0,n=02,n=13an−1−an−22+n+1,n&gt;1\displaystyle a_n = \left\{ \begin{array}{lr} 0, &amp; n=0\\ 2, ...
51Nod 1678 - lyk与gcd（分解因子+容斥）
weixin_30955341的博客
09-02 85
题目链接 https://www.51nod.com/onlineJudge/questionCode.html#!problemId=1678 【题目描述】 这天，lyk又和gcd杠上了。 它拥有一个nn个数的数列，它想实现两种操作。 1：将 aiai 改为 bb 2：给定一个数i，求所有 gcd(i,j)=1gcd(i,j)=1 时的...
算法【凑数问题】
命z的博客
03-18 2767
用两个正整数 ( a, b)来凑正整数c，即ax + by = c 。 x，y为整数 那么那些数凑的出来？那些数凑不出来呢？ 分别讨论 x，y，c 的情况，进行分析。 （1）当a，b互质的（ gcd(a, b) = 1） （x，y为整数）无论 c 为何值，都有整数 x，y 能把 c 凑出来 （x，y为非负整数）凑不出来的 c 的个数有限，且最大凑不出来的 c = a * b - a - b （...
输入正整数m和n，m<n。从m~n中找出同时满足：用3整除余2，用5整除余3和用7整除余2的所有整数。...
desert0705的博客
06-18 3527
代码： 1 import java.util.*; 2 public class Main { 3 public static void main (String [] args) { 4 Scanner s=new Scanner(System.in); 5 int m=s.nextInt(); 6 ...
查找在[m,n]范围内是否有同时满足下列条件的正整数： （1）对5取余等于1，对7取余等于3，对11取余等于5 （2）是一个素数
最新发布
05-17
这是一个典型的搜索问题，可以使用暴力枚举法解决。 首先，我们可以从m到n遍历每个正整数，判断其是否满足条件（1），如果满足，则再判断其是否为素数。对于判断素数，可以使用试除法或者筛法进行判断。 下面是一份Python代码，用于实现上述算法： ```python def is_prime(n): if n < 2: return False for i in range(2, int(n**0.5) + 1): if n % i == 0: return False return True def search(m, n): for i in range(m, n + 1): if i % 5 == 1 and i % 7 == 3 and i % 11 == 5: if is_prime(i): return i return -1 m = 1 n = 1000 ans = search(m, n) if ans == -1: print("在[%d,%d]范围内没有找到符合条件的正整数。" % (m, n)) else: print("在[%d,%d]范围内找到了符合条件的正整数：%d。" % (m, n, ans)) ``` 其中，`is_prime()`函数用于判断一个数是否为素数，`search()`函数用于在[m,n]范围内查找符合条件的正整数。如果找到了符合条件的正整数，则返回该数；否则返回-1。 在这个例子中，我们查找了[1,1000]范围内是否有同时满足对5取余等于1，对7取余等于3，对11取余等于5，并且是一个素数的正整数。运行上述代码，得到输出结果： ``` 在[1,1000]范围内找到了符合条件的正整数：541。 ``` 因此，我们可以得出结论，在[1,1000]范围内，符合条件的正整数为541。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值