拯救阿拉德大陆--竞码编程H-20‘

H. 试题H：拯救阿拉德大陆 20’
描述
阿拉德大陆是冒险家们活动的主要区域，地下城与勇士的冒险故事也主要发生在这片广袤的土地…
阿拉德大陆的文明之光最初是由精灵和人类共同创造的，但是后来由于双方关系破裂，精灵逐渐从阿拉德大陆上…
目前阿拉德大陆上主要分布着以下势力:德洛斯帝国、贝尔玛尔公国、虛祖、班图、暗精灵王国等。
德洛斯帝国的前身是强大的佩鲁斯帝国。当年，因为混沌之神奥兹玛的报复，帝国在血之诅咒蔓延下灭亡了。经过长时间的累积，帝国的后裔们重新建立起新的军事强国一 德洛斯帝国，并且继承了佩鲁斯的野心，意图再次统一整片大陆。
贝尔玛尔公国距今已有500500多年的历史，那里幅员辽阔、土地肥沃。公国现任女王为斯卡迪，但是实际上权利都掌握在33位议员手里。目前，公国正被被德洛斯帝国占领中。
拥有超过20002000年历史的文明古国虚祖，虽然土地面积不大，却是个不容小觑的国家;那里几乎人人习武，而且素喃工坊制作的武器也是天下一绝。
班图族是居住在斯特鲁山脉北部边界所有部族的总称。如今它已被分裂成几个小部族，分别是沃克族、库尼族和图卢斯族。这些部族间的关系虽不和睦，但是每隔3030年，冰龙斯卡萨苏醒后，各部族间仍是会齐心协力地翻越山岭。
与其他势力不同，暗精灵王国是建在地底洞穴的国家。暗精灵们因为天生的戒备心，所以国家实施的是与世隔绝的政策。但是由于一次瘟疫的横行， 暗精灵与邻国贝尔玛尔公国关系恶化，战争一触即发。
…
现在的阿拉德大陆混战不断、瘟疫横行，可以说是处于一个动荡不安、满目疮痍的黑暗时期。生活在水深火热的人们急切地期盼着英雄的到来,他们希望真正的勇士能够赶走灾难，为阿拉德大陆带来久违的和平…
此时一批勇士也随之而来,但其能力也是参差不齐，我们需要挑选出最优秀的勇士来守护这片大陆。每位勇士都有属于自己的编号，而我们现在有四张卡片里面分别标记了一个号码， 当勇士的编号为其中某-张卡片中号码的倍数时说明该勇士是优秀的。
目前有nn名勇士(编号1 - n1−n)并且告诉你卡片内的号码，请你计算出能挑选出多少位勇士

输入
第一个行读入一个正整数nn

第二行读入四个正整数a, b, c, da,b,c,d分别表示四张卡片内的号码

输出

本来以为自己稳过的题，没想到因为特殊样例炸了，今天来说说这个题，以下代码有些函数是我自己用的。
因为之有4个整数有限制，所以这个题也是归为一个水题（啊我好菜）；

#include
# include 
# include 
#include 
#include
#include
using namespace std;
int t[4][2]={{0,-1},{-1,0},{1,0},{0,1}};//字典序最小 
//char a[7][10]={"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
long long gcd(long long n,long long m){
	return m==0?n:gcd(m,n%m);
}
long long lcm(long long a, long long b) {
  return a / gcd(a, b) * b;
}
#define oo 1000000010
#define pi 3.14159265358979
//#define mod 1000000007
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
/*struct node{
	int x,y,ts;
}s,ns;*/
//int a[33],b[33];
struct node{
	int num;
	int idx;
};
int run(int y){
	if(y%400==0){
		return 1;
	}
	if(y%100!=0&&y%4==0){
		return 1;
	}
	return 0;
}
long long  qpow(long long  x,long long  n){//快速幂 
    long long  ans=1;
	while(n){
		if(n&1){
			ans=x*ans;
		}
		n=n>>1;
		x*=x;
	
	}
	return ans;
}
long long  qcpow(long long  a,long long  b){//快速乘 
     long long  ans=0;
	while(b){
		if(b&1){
			ans=(a+ans);
		}
		b=b>>1;
		a=(a+a)%1000000007;
		
	}
	return ans%1000000007;
}
long long lj(long long n){
	long long sum=0 ;
	for(int i=0;i<=n;i++){
		sum+=i;
	}
	return sum;
}
long long jc(long long n,long long cnt){
	long long sum=1;
	while(cnt--){
		sum*=n;
		n-=1;
	}
	if(sum==1){
		return 0;
	}
	return sum;
}
int fa[1000*1100];
int find(int u){
	int tu=u;
	while(fa[tu]!=tu){
		tu=fa[tu];
	}
	return tu;
}
string s2S(int s){
	stringstream ss;
	string str;
	if(s<10){
	ss<<'0';
	}
	ss<<s;
	ss>>str;
	return str;
}
void s2i(string &s,int &num){
	stringstream ss;
	ss<<s;
	ss>>num;
}
void wys(int x){//位运算此次出现32位的2进制 
	for(int i=0;i<32;i++){
		printf("%d",(x>>(31-i))&1);
	} 
}
int combin(int x, int y){
	int tx=find(x);
	int ty=find(y);
	if(tx==ty){
		return 0;
	}
	else {
		fa[tx]=ty;
		return 1;
	}
}
int flag[100010];
int prime[100010]; 
void pri(){
	int t=0;
	flag[0]=1;
	flag[1]=1;
	for(int i=2;i<10000;i++){
		if(!flag[i]){
			prime[++t]=i;
		//	cout<
		}
		for(int j=1;j<=t&&i*prime[j]<=10000;j++){
		flag[i*prime[j]]=1;
		if(i%prime[j]==0){
			break;
		}
		}
	}
}

//int dir[4]={1,-1,2,-2};
//int dir[6]={1,2,3,-1,-2,-3};
int dir[4][2]={0,1,1,0,0,-1,-1,0};
string str="012345678";
void bfs(){
	
	
}

//long long ans=0;

int dp1(){
		int n,k;
	int d[100][100];
	cin>>n>>k;
	int v[n+10],w[n+10];
	for(int i=1;i<=n;i++){
		cin>>w[i];
		cin>>v[i];
	} 
	for(int i=0;i<=n;i++){
		for(int j=0;j<n;j++){
			d[i][j]=0;
		}
	} 
	for(int i=1;i<=n;i++){
		for(int j=1;j<=k;j++){
			if(j<w[i]){
				d[i][j]=d[i-1][j];
			}	
			else {
				if(d[i-1][j]>d[i-1][j-w[i]]+v[i]){
					d[i][j]=d[i-1][j];
				}
				else {
					d[i][j]=d[i-1][j-w[i]]+v[i];
				}
			}
		}
		
	}
	return d[n][k];
}
int day[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};

int solve(const string &str){
	if(str.rfind('A')-str.find('A')==2&&str.rfind('2')-str.find('2')==3&&str.rfind('3')-str.find('3')==4&&str.rfind('4')-str.find('4')==5){
	return 1;
	}
	return 0;
}
int prim[23]={3,5,7,11,13,19,23,29,31,37,41,53,59,61,67,71,97,101,127,197,211,431};
struct M{//矩阵快速幂 
	long long data[2][2];
	M(){
		memset(data,0,sizeof(data));
	} 
};
M* mul(M *a,M *b){
	M *ans=new M();
	ans->data[0][0]=a->data[0][0]*b->data[0][0]+a->data[0][1]*b->data[1][0];
	ans->data[0][1]=a->data[0][0]*b->data[0][1]+a->data[0][1]*b->data[1][1];
	ans->data[1][0]=a->data[1][0]*b->data[0][0]+a->data[1][1]*b->data[1][0];
	ans->data[1][1]=a->data[1][0]*b->data[0][1]+a->data[1][1]*b->data[1][1];
	return ans;
}
M* qpow(M *m,long long n){
	M *E=new M();
	E->data[0][0]=1;
	E->data[1][1]=1;
	while(n!=0){
		if(n&1){
			E=mul(E,m);
		}
		m=mul(m,m);
		n=n>>1;
	}
	return E;
} 
string rev(string s){
	string ans;
	for(int i=s.size()-1;i>=0;i--){
		ans+=s[i];
	}
	return ans;
}
int lca(string s1,string s2){
	int len=s1.size();
	int dp[len+5][len+5];
	for(int i=0;i<len;i++){
		if(s1[0]==s2[i]){
			dp[0][i]=1;
		}
		else {
			if(i==0){
				dp[0][i]=0;
			}
			else {
				dp[0][i]=dp[0][i-1];
			}
		}
		
	}
	for(int i=0;i<len;i++){
		if(s1[i]==s2[0]){
			dp[i][0]=1;
		}
		else {
			if(i==0){
				dp[i][0]=0;
			}
			else {
				dp[i][0]=dp[i-1][0];
			}
		}
		
	}
	for(int i=1;i<len;i++){
		for(int j=1;j<len;j++){
			if(s1[i]==s2[j]){
				dp[i][j]=dp[i-1][j-1]+1;
			}
			else {
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
			} 
		}
	}
	for(int i=0;i<len;i++){
		for(int j=0;j<len;j++){
			cout<<dp[i][j]<<" ";
		}
		cout<<endl;
	}
	return dp[len-1][len-1];
}
int n,m,x,y;
char a[1010][1010];

int sum=0; 
void dfs(int x,int y){ 

}
struct jx{
int h;
int d;
int x;
};
bool cmp(jx a,jx b){
	if(a.h>b.h){
		return 0;
	}
	else if(a.h<b.h){
		return 1;
	}
	else {
		if(a.d>b.d){
			return 0;
		}
		else if(a.d<b.d){
			return 1;
		}
		else {
			if(a.x>b.x){
				return 0;
			}
			else {
			return 1;
			}
		}
	}
}
int main(int argc, char** argv){
	long long n, a, b, c, d;
	cin >> n >> a >> b >> c >> d;
		long long ans = 0;
	ans += n / a + n / b + n / c + n / d;//用n除以出现 n以内所有倍数个数
		long long e = lcm(a, b), f = lcm(a, c), g = lcm(a, d);
		long long h = lcm(b, c), i = lcm(b, d);
		long long j = lcm(c, d);
	//cout<
	ans -= n / e + n / f + n / g + n / h + n / i + n / j;
		long long k = lcm(e, c), l = lcm(e, d), m = lcm(f, d), o = lcm(h, d);
	//cout<
	ans += n / k + n / l + n / m + n / o;
		long long p = lcm(e, j);
	//cout<
	ans -= n / p;
	cout << ans << endl;
 	return 0;	
}

最后希望自己努力把 一场蓝桥杯模拟赛的基础我才打了第50名，路还长，自己加油。这其实就是容斥原理。