算法1_为如何判断凑出来的数是否为无限个-优快云博客

博客围绕几个算法问题展开。一是求1 - Max内素数，Max很大时传统方法速度慢；二是包子凑数问题，需计算凑不出的包子数目；三是对局匹配问题，要算出系统无法匹配对局时最多同时在线的用户数，还涉及火车站开饭店的树型动态规划问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1求1-Max内的素数，Max很大，传统的方法无法实现高速度。不妨试一试下面这个算法。

	int dp[N]={1,1,0};
	    for(long long i = 2 ; i < N ; i ++)
	    {
	    	
	        if(dp[i])continue;
	        prim[tot++]=i;
	        for(long long  j = i ; j * i < N ; j ++){
	            dp[i*j] = 1;
	        }
	    }

2包子凑数

小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。

每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。

当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。

小明想知道一共有多少种数目是包子大叔凑不出来的。

输入

第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)

输出

一个整数代表答案。如果凑不出的数目有无限多个，输出INF。

例如，
输入：
2
4
5

程序应该输出：
6

再例如，
输入：
2
4
6

程序应该输出：
INF

样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include
不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

题解：这一题难点有2,1为能否算出所以的能凑成的数（以10000为最大界限，因为Ai最大为100，N也才为100,10000足够代表所以的数了），2为如何判断凑出来的数是否为无限个。
第一个难点用递推可以解决。第二个难点在于思想，比如有三个数，2,6,9，如果能找到连续的两个数能用着三个数组成，那么这两个数后面的数都能被组成，只要不断在那两个数上加2就行。
具体代码如下：

	#include<iostream>
	using namespace std;
	int main()
	{
		int n;
		cin>>n;
		int dp[20000]={0};
		int a[101];
		int i,j;
		for(i=0;i<n;i++)
			cin>>a[i];
		dp[0]=1;
		for(i=0;i<n;i++)
			for(j=0;j<10001;j++)
				if(dp[j])
					dp[j+a[i]]=1;
	//	for(i=0;i<100;i++)
	//		cout<<dp[i]<<" "<<endl;
		int flag=0,num=0;
		for(i=a[n-1];i<10001;i++)
		{
			if(dp[i]==1)
				num++;
			if(dp[i]==0)
				num=0;
			if(num==a[0])
			{
				flag=1;
				break;
			}
		}
		if(flag==0)
			cout<<"INF"<<endl;
		else{
			num=0;
			for(i=0;i<10001;i++)
				if(dp[i]==0)
					num++;
			cout<<num<<endl;
		}	
		return 0;
	}

对局匹配

问题描述
　　小明喜欢在一个围棋网站上找别人在线对弈。这个网站上所有注册用户都有一个积分，代表他的围棋水平。

小明发现网站的自动对局系统在匹配对手时，只会将积分差恰好是K的两名用户匹配在一起。如果两人分差小于或大于K，系统都不会将他们匹配。

现在小明知道这个网站总共有N名用户，以及他们的积分分别是A1, A2, … AN。

小明想了解最多可能有多少名用户同时在线寻找对手，但是系统却一场对局都匹配不起来(任意两名用户积分差不等于K)？
输入格式
　　第一行包含两个个整数N和K。
　　第二行包含N个整数A1, A2, … AN。

对于30%的数据，1 <= N <= 10
　　对于100%的数据，1 <= N <= 100000, 0 <= Ai <= 100000, 0 <= K <= 100000
输出格式
　　一个整数，代表答案。
样例输入
10 0
1 4 2 8 5 7 1 4 2 8
样例输出
6
题目中只有积分差为k的才不能同时选，那么也就是和当前状态下只有差为k的才能产生相互影响，别的就没有一点影响了，那么我们把能够相互影响的找出来，在每一组相互影响的里面找到最大值，在将每组的最大值加起来，就是最终的结果

在一组相互影响的里面，当前状态j只有两种，一种是选这个，另一种是不选这个，如果选的话dp[j] = dp[j-2] + cnt[j] （cnt表示积分为j的数量），不选择的话：dp[j] = dp[j-1]，那么最终的状态转移方程为dp[j] = max(dp[j-1],dp[j-2] + cnt[j])

		#include <iostream>
		#include <cstdio>
		#include <cstring>
		#include <vector>
		#include <cmath>
		#include <algorithm>
		#define INF 0x3f3f3f3f
		#define ll long long
		using namespace std;
		
		
		const int MAXN = 101000;
		int a[MAXN],num[MAXN],n,k;//a是输入进来的积分，num是过滤重复后的积分，
		int cnt[MAXN];//一个桶，记录每种积分有多少人；
		int dp[MAXN];  //dp[i][0]:表示不选当前分数的情况  dp[i][1]:选择当前分数的情况
		bool vis[MAXN];//VIS表示是否已经分组了。
		int main()
		{
		    int max_num = 0;
		    memset(cnt,0,sizeof(cnt));
		    memset(dp,0,sizeof(dp));
		    memset(vis,false,sizeof(vis));
		    scanf("%d%d",&n,&k);
		    for(int i =1 ;i <= n;i ++)
		    {
		        scanf("%d",&a[i]);
		        cnt[a[i]] ++;
		        max_num = a[i] > max_num?a[i]:max_num;
		    }
		    if(k == 0)
		    {
		        int ans = 0;
		        for(int i = 0;i <= max_num;i ++)
		            if(cnt[i])
		                ans ++;
		        printf("%d\n",ans);
		    }
		    else
		    {
		        int ans = 0;
		        sort(a+1,a+1+n);
		        int index = 0;
		        num[index++] = a[1]; //得到不重复的输入序列，0~index    他们分别对应的个数为cnt[num[i]]
		        for(int i = 2;i <= n;i ++)
		        {
		            if(num[index-1] != a[i])
		                num[index++] = a[i];
		        }
		        int pos,temp[MAXN];
		        for(int i = 0;i < index;i ++)
		        {
		            pos = 0;
		            if(vis[num[i]] == false)
		            {
		                int p = num[i];
		                while(1)   //从这个元素向后寻找相差大小等于k的一系列数组
		                {
		                    temp[pos++] = p;   vis[p] = true;
		                    if(cnt[p + k] == 0) break;   //不存在这个数了
		                    p = p + k;    //temp里面存储的是当前对应位置上的数字
		                }
		            }
		            if(pos == 1)
		                ans += cnt[temp[0]];
		            else if(pos >= 2)
		            {
		                dp[0] = cnt[temp[0]],dp[1] = max(dp[0],cnt[temp[1]]);
		                for(int j = 2;j < pos;j ++)
		                    dp[j] = max(dp[j-1],dp[j-2] + cnt[temp[j]]);
		                ans += dp[pos-1];
		            }
		        }
		        printf("%d\n",ans);
		
		    }
		}

CJOJ 2171 火车站开饭店（树型动态规划）
Description
政府邀请了你在火车站开饭店，但不允许同时在两个相连的火车站开。任意两个火车站有且只有一条路径，每个火车站最多有 50 个和它相连接的火车站。
告诉你每个火车站的利润，问你可以获得的最大利润为多少？
例如下图是火车站网络：

F[i][0]表示这个点不取， F[i][1]表示这个点不取，这点取，他的孩子一定不能取，如果这个点不取（为孩子不取之和），他的孩子有取和不取两种情况，每次都取最大那个就行，最大之和就是这点结果。

			#include<iostream>
			#include<cstdio>
			#include<cstdlib>
			#include<cstring>
			#include<algorithm>
			#include<vector>
			using namespace std;
			
			const int maxN=100001;
			const int inf=2147483647;
			
			int n;
			int Value[maxN];
			vector<int> E[maxN];
			int F[maxN][5]={0};
			bool vis[maxN]={0};
			
			void dfs(int u);
			
			int main()
			{
			    int u,v;
			    cin>>n;
			    for (int i=1;i<=n;i++)
			        scanf("%d",&Value[i]);
			    for (int i=1;i<n;i++)
			    {
			        scanf("%d%d",&u,&v);
			        E[u].push_back(v);
			        E[v].push_back(u);
			    }
			    dfs(1);
			    cout<<max(F[1][1],F[1][0])<<endl;
			    return 0;
			}
			
			void dfs(int u)
			{
			    vis[u]=1;
			    F[u][1]=Value[u];
			    F[u][0]=0;
			    for (int i=0;i<E[u].size();i++)
			    {
			        int v=E[u][i];
			        if (vis[v]==0)
			        {
			            dfs(v);
			            F[u][1]+=F[v][0];
			            F[u][0]+=max(F[v][1],F[v][0]);
			        }
			    }
			    return;
			}