离散数学：容斥原理

这题答案有点问题，并不能满分通过，想满分的移步吧，只提供一个思路，思路是没问题的

提示：求两个整数a, b的最小公倍数lcm(a,b)，可以利用a, b的最大公约数gcd(a,b)来完成，即lcm(a, b) = a*b/gcd(a, b)

gcd可以这样写：

int gcd(int a, int b)

{

return a ? gcd(b % a, a) : b;

}

样例输入1

100 2

2

3

样例输出1

67

样例输入2

100 3

2

5

7

样例输出2

66

题目要求：注意程序的时间复杂度，本题目限时1秒。

如果这只是个普通的大一C语言题，那么我想大部分人的处理做法如下：

#include<stdio.h>
#include<malloc.h>
int main(){
	int n,m,t;
	int *p;//用来存储m个数据，因为m为变量所以用指针不用数组
	int i,j;//for循环的变量
	int number = 0;//用来存储最后统计的个数
	scanf("%d %d",&n,&m);
	p = (int *)malloc(sizeof(int) * m);
	for(i=0;i<m;i++){
		scanf("%d",&t);
		*(p+i) = t;
	}

	for(i=0;i<n;i++){
		for(j=0;j<m;j++){
			if(i % *(p+j) == 0){
				number++;
				break;
			}
		}
	}

	printf("%d\n",number);
	return 0;
}

这种做法思路和代码都很简单直接，可以说与上个推理题是一样的，都是采用暴力循环的方式来解决，这里程序至少执行外部的N次循环，内部循环肯定也会被执行数次，这样下来就出问题了，上个推理题暴力循环了一百万种可能，这个题如果取题目给出的范围的极限值n=10^9，那么这个数就是一亿，执行的话可能就是数亿次，这段代码就会没有意义了，别说一秒，电脑肯定直接炸

下边来说说我的做法，这个题我不保证自己是对的，里边有很多问题，宿舍也只有大佬做出来了，而我们的答案范围小的时候是一样的，范围一旦大了就会不同了，看了半天谁也看不出问题，并且我的代码里有个for循环遍历，正过来反过去答案居然会是两个结果，大佬也没搞明白是为什么，有想明白的可以私信我
　　我的思路是大佬给的，自己只是简单地找了找规律翻译成了C代码而已，所以我们在思路上是一致的，也就是通过数学上的找集合的子集的方式，找到所有的序列，然后找到每个序列对应的最小公倍数，再由n/最小公倍数得到一个结果的方式来累加出最后的结果。
　　用这种方式，不论n取多大，我们都可以把循环的次数缩减到2^{m次，而m的范围是1≤m≤15，也就是这个程序最多也就循环2}15=32768次，如果像题目给的样例那样的话效果肯定感觉不出来，但如果比之上亿次的范围效率就提高了很多
　　另外，我们觉得老师题目中给出的找最小公倍数与最大公约数的方法并没有考虑到数足够大的情况，所以会超出int类型的数值范围，造成溢出，例如下边是我们的测试数据
　　
　　这里的m是前15个素数，然后每个数前加了个100，这样找到的最小公倍数就会非常的大，所以我把程序中相对应的一些位置的变量的类型改为了long，学了4年计算机，这还是头一回用到这种数据类型
　　下边是大佬查到的资料，也是给我们思路的一张图
　　
　　这里说一下，所有的序列其实不用如图上所说的去找第一个0，然后后边变为1什么的，那么啰嗦，自己列举m=2，3的情况就可以看出所有的序列就是2^m减去全为0的那个序列。也就是所有子集排除掉空集的情况，另外还要注意正负号的问题（与序列中1的个数有关），并且序列中的1，只是代表该位置的数而已（这句话我可能表述的不是很到位，自己看着上边生成组合那张图理解一下就明白了，或者看一下我的演算过程）下边给出我自己做题前的演算纸，自己下载了放到本地调好方向再看吧

　　终于到代码了，这里我测试时的代码只是注释掉了，并没有删除，可以不用管，又想测试的可以打开注释看测试输出结果是什么

#include<stdio.h>
#include<malloc.h>
#include<math.h>

long gcd(int a, int b);
long lcm(int a, int b);
int dic(int a,int *p11,int m);
int main(){
	long n,y,x;
	int m,t;
	int *p;//用来存储m个数据，因为m为变量所以用指针不用数组
	int i,j,k;//for循环的变量
	long number = 0;//最后的输出结果
	int num;//统计1的个数的变量
	scanf("%lld %d",&n,&m);

	p = (int *)malloc(sizeof(int) * m);
	for(i=0;i<m;i++){
		scanf("%d",&t);
		*(p+i) = t;
	}
	
	for(i=1;i<pow(2,m);i++){
		int *p11;//p1的指针元素
		p11 = (int *)malloc(sizeof(int) * (m+1));//第0号下标位置存储序列中1的个数
		dic(i,p11,m);//i是十进制数，要把i转换成二进制

		//对得到的字典序列直接操作，不再去另写一个for循环控制，这里是第一次写没发现，要找的序列就是字典减去全是0的序列，又费力的自己去生成了一遍，没用的 
		/*t = m+1;//注意临界值
		j = -1;
		do{
			t--;
			j++;
		}while(*(p11+t) == 1 && t>0);

		for(k=0;k<j;k++){
			*(p11+m-k) = 0;
		}
		
		*(p11+m-k) = 1;*/
		
		x = 1;
		num = 0;
		//找到每一个1的位置，这个for循环 跟下面紧邻的 按说是一样的，但是结果会不同，想不明白，有想明白的请告诉我一声 
		/*for(k=1;k<m+1;k++){
			printf("%d ",*(p11+k));
			if(*(p11+k) == 1){
				//找最小公倍数
				num++;
				x = lcm(x, *(p+k-1));
				//printf("k=%d ",*(p+k-1));
			}
		}*/

		for(k=m;k>0;k--){
			//printf("%d ",*(p11+k));
			if(*(p11+k) == 1){
				//找最小公倍数
				num++;
				x = lcm(x, *(p+k-1));
				//printf("k=%d ",*(p+k-1));
			}
		}

		*(p11+0) = num;//在这里写入1的数量
		//printf("aa=%d ",num);
		//printf("x=%lld ",x);
		//printf("i0=%lld n=%lld x=%lld ",*(p11+0),n,x);
		if(*(p11+0) % 2 == 0){
			y = n/x;
			y = -y;
		}else{
			y = n/x;
		}
		//y = pow(-1,*(p11+0)+1) * (n / x);//这里1的个数已经改变了
		//printf("y=%lld\n",y);
		number += y;
		
	}

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

long lcm(int a, int b){
	return a*b/gcd(a, b);
}

long gcd(int a, int b){
    return a ? gcd(b % a, a) : b;
}

int dic(int a,int *p11,int m){
	//该方法中统计1的个数没用了， 在主方法里统计了 
	int i,j,k;
	//int num = 0;
	//先把P11所有位置置为0 
	for(i=0;i<m+1;i++){
		*(p11+i) = 0;
	}

	//再将对应位置替换为0或者
	for(k=m;a!=0;k--){
		j = a % 2;
       *(p11+k) = j;//?
        a = a / 2;
		//if(j == 1){
		//	num++;//正常累加
		//}
    }

	//*(p11+0) = num;
	//字典生成正常
	/*for(i=0;i<m+1;i++){
		printf("%d ",*(p11+i));
	}
	printf("\n");*/
	return 0;
}

最后说一下运行吧，因为写的时候要多次运行，有时候还输入多行数据，很麻烦，大佬就想到了Linux下的管道命令，在我的Windows环境下也可以实现，确实要快很多，每次只要编译一下，按一下键盘的上箭头敲一下回车就可以了，最多改一下aaa文件夹里的m值，截图中的命令分别是在控制台直接输出结果和将结果输出到文件中

后来发现个挺不错的容斥原理的文章，主要是图画的挺清晰的，给个链接