CCF 难题汇总（2013-2019 持续更新）

最新推荐文章于 2022-02-26 21:05:57 发布

WALL-SQ

最新推荐文章于 2022-02-26 21:05:57 发布

阅读量276

点赞数 1

本文链接：https://blog.csdn.net/qq_39304630/article/details/100597518

版权

试题编号：	201312-4
试题名称：	有趣的数
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　我们把一个数称为有趣的，当且仅当：　　1. 它的数字只包含0, 1, 2, 3，且这四个数字都出现过至少一次。　　2. 所有的0都出现在所有的1之前，而所有的2都出现在所有的3之前。　　3. 最高位数字不为0。　　因此，符合我们定义的最小的有趣的数是2013。除此以外，4位的有趣的数还有两个：2031和2301。　　请计算恰好有n位的有趣的数的个数。由于答案可能非常大，只需要输出答案除以1000000007的余数。输入格式　　输入只有一行，包括恰好一个正整数n (4 ≤ n ≤ 1000)。输出格式　　输出只有一行，包括恰好n 位的整数中有趣的数的个数除以1000000007的余数。样例输入 4 样例输出 3

很考验谨慎的一道难题。

整体思路过程：首先由题目条件我们可以知道

A.所有数的第一位只能是2

B.结尾的数字只能是1或3

题目要求我们对每一个串都要知道前面出现了哪些数，如果出现了1，则后面不再有0，如果出现了3，则后面不再有2，因此我们势必要记录前面有的数的状态。

那么到底应该记录什么状态呢？状态的迁移又该是什么样的呢?

首先如果我们需要知道4个数字的存在状态，易知其中有2^4=16个（二进制0和1表示是否存在），但是其中很多状态是不合法的，对此我们重新梳理一下状态，从题意出发思考状态（一开始的分析已知，第一位一定是2，所以所有状态内必须包含2）：

状态0：只有2的状态

状态1：只有0和2的状态

状态2：只有2和3的状态

状态3：只有0 1 2的状态

状态4：只有0 2 3的状态

状态5：有0 1 2 3的状态

于是我们设置状态dp[i][j][k]，表示了第i位上为j，从第一位到第i位的状态为k时的方案数，转移中没有必要对不合法的状态进行转移（例如j=0,k=0,即当前位为0，状态上却说当前只有2）。

上述分析B告诉我们最终答案就是dp[n][1][5]+dp[n][3][5]（当然不要忘了过程和答案取模）

剩下的工作就是对第i位为j时，讨论从第一位到第i-1位的串的状态以及第i-1位的取值了，依旧要注意不合法的情况。

易错点类似于：若前面i-1位的状态为有0 2 3，那么第i-1位只能取0和3，若取2，为了满足有状态中有3的要求，2的前面会有3，直接与题意不符，属于不合法的状态，细心即可。。。

#include<iostream>
using namespace std;
typedef long long LL;
LL dp[1010][4][6];
const LL mod=1000000007;
//状态0 ： 只有2
//状态1 ： 只有2和0 
//状态2 ： 只有2和3 
//状态3 ： 只有2、0、1 
//状态4 ： 只有2、3、0 
//状态5 ： 有0 1 2 3 

int main(){
	int i,n;
	cin>>n;
	dp[1][2][0]=1;
	for(i=2;i<=n;++i){
		//对至少含有2和0且不含有1的状态进行更新 
		dp[i][0][1]=(dp[i-1][2][0]+dp[i-1][0][1]+dp[i-1][2][1])%mod;
		//第i位为0且状态为有0和2（状态1）  可能前面只有2（状态0）且第i-1位为2 也可能前面有0和2（状态1） 且第i-1位为0或2 
		dp[i][0][4]=(dp[i-1][3][2]+dp[i-1][0][4]+dp[i-1][3][4])%mod;
		//第i位为0且状态为有0、2、3 （状态4） 可能前面只有2和3(状态2）且第i-1位为3  也可能前面有0 2 3（状态4）且第i-1位为0或3  
		
		//对至少含有2(第一位必须是2) 0 1的状态进行更新 
		dp[i][1][3]=(dp[i-1][0][1]+dp[i-1][2][1]+dp[i-1][1][3]+dp[i-1][2][3])%mod;
		//第i位为1且状态为有0 1 2（状态3）  可能前面只有0和2（状态1）且第i-1位为0或2  也可能前面有0 1 2（状态3）且第i-1位为1或2 
		dp[i][1][5]=(dp[i-1][0][4]+dp[i-1][3][4]+dp[i-1][1][5]+dp[i-1][3][5])%mod;
		//第i位为1且状态为有0 1 2 3（状态5） 可能前面只有0 2 3（状态4）且第i-1位为0或3  也可能前面有0 1 2 3（状态5）且第i-1位为1或3 
	
		//对至少含有2且没有3的状态进行更新   
		dp[i][2][0]=dp[i-1][2][0];
		//第i位为2且状态只有2  前面只能都是2 
		dp[i][2][1]=(dp[i-1][0][1]+dp[i-1][2][1])%mod; 
		//第i位为2且状态为有0 2（状态1） 可能前面有0 2（状态1）且第i-1位为0或2 
		dp[i][2][3]= (dp[i-1][1][3]+dp[i-1][2][3])%mod;
		//第i位为2且状态为有0 1 2（状态3）  可能前面有0 1 2（状态3）且第i-1位为1或2 
		
		//对至少含有2 3的状态进行更新 
		dp[i][3][2]=(dp[i-1][2][0]+dp[i-1][3][2])%mod;
		//第i位为3且状态为有2 3（状态2）   可能前面只有2（状态0）且第i-1位为2  或者前面有2 3(状态2）且第i-1位为3 
		dp[i][3][4]=(dp[i-1][0][1]+dp[i-1][2][1]+dp[i-1][0][4]+dp[i-1][3][4])%mod; 
		//第i位为3且状态有2 3 0 可能前面只有2和0（状态1）且第i-1位为2或0   或者前面有2 3 0（状态4）且第i-1位为0或3 
		dp[i][3][5]=(dp[i-1][1][3]+dp[i-1][2][3]+dp[i-1][1][5]+dp[i-1][3][5])%mod;
		//第i位为3且状态有0 1 2 3 可能前面只有 0 1 2（状态3）且第i-1位为1或2   或者前面有0 1 2 3（状态5）且第i-1位为1或3 
	}
	cout<<(dp[n][1][5]+dp[n][3][5])%mod;
	return 0;
}

试题编号：	201312-5
试题名称：	I’m stuck!
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '\|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：　　'#': 任何时候玩家都不能移动到此方格；　　'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；　　'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；　　'\|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；　　'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；　　'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；　　'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。　　此外，玩家不能移动出地图。　　请找出满足下面两个性质的方格个数：　　1. 玩家可以从初始位置移动到此方格；　　2. 玩家不可以从此方格移动到目标位置。输入格式　　输入的第一行包括两个整数R 和C，分别表示地图的行和列数。(1 ≤ R, C ≤ 50)。　　接下来的R行每行都包含C个字符。它们表示地图的格子。地图上恰好有一个'S'和一个'T'。输出格式　　如果玩家在初始位置就已经不能到达终点了，就输出“I'm stuck!”（不含双引号）。否则的话，输出满足性质的方格的个数。样例输入 5 5 --+-+ ..\|#. ..\|## S-+-T ####. 样例输出 2 样例说明　　如果把满足性质的方格在地图上用'X'标记出来的话，地图如下所示：　　--+-+ 　　..\|#X 　　..\|## 　　S-+-T 　　####X

其实是一道比较简单的搜索题，只是需要优化思路。

朴素做法：直接从起点搜索一遍得到起点能到达的点，然后在对这每一个点进行一遍搜索看是否能到终点，直接统计即可。

优化方法：可以从某点到终点，说明在一定规则下也可以从终点到这个点，因此为了避免题中所给出的单向关系，我们直接规定，如果当前点的上邻接点是'.'、'+'、'|','S','T'，就可以从上邻接点到该点，同理规定其余三个方向，将能够到达终点的点标记，最终只要对从起点能到并且不能到终点的点统计即可。若从起点遍历不到终点，直接输出"I'm stuck!"。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

typedef pair<int,int> point;

char Map[55][55];
int n,m,sx,sy,tx,ty;
bool Use[55][55],isOK; 
bool StoT[55][55],TtoS[55][55];
queue<point>que;

void BFS(int x,int y){
	point p=make_pair(x,y);
	Use[x][y]=true;
	int nx,ny;
	que.push(p);
	while(que.size()){
		p=que.front(),que.pop();
		x=p.first,y=p.second;
		if(x==tx&&y==ty){//可以到达终点
			 isOK=true;
		}
		switch(Map[x][y]){
		case 'S':
		case 'T':
		case '+':nx=x-1,ny=y;
				if(nx>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x+1,ny=y;
				if(nx<=n&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x,ny=y-1;
				if(ny>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x,ny=y+1;
				if(ny<=m&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		case '-':nx=x,ny=y-1;
				if(ny>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x,ny=y+1;
				if(ny<=m&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		case '|':nx=x-1,ny=y;
				if(nx>=1&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				nx=x+1,ny=y;
				if(nx<=n&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		case '.':nx=x+1,ny=y;
				if(nx<=n&&Map[nx][ny]!='#'&&!Use[nx][ny]){
					Use[nx][ny]=true;
					StoT[nx][ny]=true;
					que.push(make_pair(nx,ny));
				}
				break;
		}
	}
}

void ReverseBFS(int x,int y){
	point p=make_pair(x,y);
	que.push(p);
	int nx,ny;
	Use[x][y]=true;
	while(que.size()){
		p=que.front(),que.pop();
		x=p.first,y=p.second;
		nx=x-1,ny=y;
		if(nx>=1&&(Map[nx][ny]=='.'||Map[nx][ny]=='|'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从上面到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
		nx=x+1,ny=y;
		if(nx<=n&&(Map[nx][ny]=='|'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从下面到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
		nx=x,ny=y-1;
		if(ny>=1&&(Map[nx][ny]=='-'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从左边到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
		nx=x,ny=y+1;
		if(ny<=m&&(Map[nx][ny]=='-'||Map[nx][ny]=='+'||Map[nx][ny]=='S'||Map[nx][ny]=='T')){//从右边到这个点 
			TtoS[nx][ny]=true;
			if(!Use[nx][ny]){
				que.push(make_pair(nx,ny));
				Use[nx][ny]=true;
			}
		}
	}
}



int main(){
	int i,j,ans=0;
	cin>>n>>m;
	for(i=1;i<=n;++i){
		cin>>Map[i]+1;
		for(j=1;j<=m;++j){
			if(Map[i][j]=='S'){
				sx=i,sy=j;
			}
			if(Map[i][j]=='T'){
				tx=i,ty=j;
			}
		}
	}
	BFS(sx,sy);
	if(!isOK){//到不了终点 
		cout<<"I'm stuck!";
		return 0;
	}
	memset(Use,0,sizeof(Use));
	ReverseBFS(tx,ty);
	for(i=1;i<=n;++i){
		for(j=1;j<=m;++j){
			if(Map[i][j]!='S'&&Map[i][j]!='T'&&StoT[i][j]&&!TtoS[i][j]){
				++ans;
			}
		}
	}
	cout<<ans;
	return 0;
}

试题编号：	201409-4
试题名称：	最优配餐
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　栋栋最近开了一家餐饮连锁店，提供外卖服务。随着连锁店越来越多，怎么合理的给客户送餐成为了一个急需解决的问题。　　栋栋的连锁店所在的区域可以看成是一个n×n的方格图（如下图所示），方格的格点上的位置上可能包含栋栋的分店（绿色标注）或者客户（蓝色标注），有一些格点是不能经过的（红色标注）。　　方格图中的线表示可以行走的道路，相邻两个格点的距离为1。栋栋要送餐必须走可以行走的道路，而且不能经过红色标注的点。　　送餐的主要成本体现在路上所花的时间，每一份餐每走一个单位的距离需要花费1块钱。每个客户的需求都可以由栋栋的任意分店配送，每个分店没有配送总量的限制。　　现在你得到了栋栋的客户的需求，请问在最优的送餐方式下，送这些餐需要花费多大的成本。输入格式　　输入的第一行包含四个整数n, m, k, d，分别表示方格图的大小、栋栋的分店数量、客户的数量，以及不能经过的点的数量。　　接下来m行，每行两个整数xi, yi，表示栋栋的一个分店在方格图中的横坐标和纵坐标。　　接下来k行，每行三个整数xi, yi, ci，分别表示每个客户在方格图中的横坐标、纵坐标和订餐的量。（注意，可能有多个客户在方格图中的同一个位置）　　接下来d行，每行两个整数，分别表示每个不能经过的点的横坐标和纵坐标。输出格式　　输出一个整数，表示最优送餐方式下所需要花费的成本。样例输入 10 2 3 3 1 1 8 8 1 5 1 2 3 3 6 7 2 1 2 2 2 6 8 样例输出 29 评测用例规模与约定　　前30%的评测用例满足：1<=n <=20。　　前60%的评测用例满足：1<=n<=100。　　所有评测用例都满足：1<=n<=1000，1<=m, k, d<=n^2。可能有多个客户在同一个格点上。每个客户的订餐量不超过1000，每个客户所需要的餐都能被送到。

很容易想出贪心的思路：每次在几个店家能到达的最近点中选择一个距离最近的顾客，然后更新成本总和，并把店家的位置挪到顾客处，原因是每次不返程的成本总和一定不会大于每送完一次都回去的成本总和。

思路很简单，但是实现上有待优化，因为每次针对不止一个商家都找一个最近顾客的复杂度显然过高，我们可以直接把这个过程放进搜索的过程中。送餐路径为最短路则告诉我们应该直接从每个商家开始对整个地图进行BFS(地图最大只有1000*1000)，每次到达一个新的顾客处则更新成本总和。

#include<iostream>
#include<queue>
using namespace std;

long long ans=0;
int n,m,k,d;
int Need[1010][1010];
bool Use[1010][1010]; 

struct Node{
	int x,y,dis;
};
queue<Node>que;

void BFS(){
	Node temp;
	int nx,ny,x,y,dis;
	while(que.size()){
		temp=que.front(),que.pop();
		x=temp.x,y=temp.y,dis=temp.dis;
		if(Need[x][y]){
			ans+=(long long)Need[x][y]*dis; 
		}
		
		nx=x-1,ny=y;//往上 
		if(nx>=1&&!Use[nx][ny]){
			Use[nx][ny]=true;
			que.push(Node{nx,ny,dis+1});
		}
		
		nx=x+1,ny=y;//往下 
		if(nx<=n&&!Use[nx][ny]){
			Use[nx][ny]=true;
			que.push(Node{nx,ny,dis+1});
		}
		
		nx=x,ny=y-1;//往左 
		if(ny>=1&&!Use[nx][ny]){
			Use[nx][ny]=true;
			que.push(Node{nx,ny,dis+1});
		}
		
		nx=x,ny=y+1;//往右 
		if(ny<=n&&!Use[nx][ny]){
			Use[nx][ny]=true;
			que.push(Node{nx,ny,dis+1});
		}
	}
}

int main(){
	int i,x,y,c;
	cin>>n>>m>>k>>d;
	for(i=1;i<=m;++i){
		cin>>x>>y;
		Use[x][y]=true;
		que.push(Node{x,y,0});
	}
	for(i=1;i<=k;++i){
		cin>>x>>y>>c;
		Need[x][y]+=c;
	}
	for(i=1;i<=d;++i){
		cin>>x>>y;
		Use[x][y]=true;
	}
	BFS();
	cout<<ans;
	return 0;
}

试题编号：	201403-5
试题名称：	任务调度
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　有若干个任务需要在一台机器上运行。它们之间没有依赖关系,因此可以被按照任意顺序执行。　　该机器有两个 CPU 和一个 GPU。对于每个任务,你可以为它分配不同的硬件资源: 　　1. 在单个 CPU 上运行。　　2. 在两个 CPU 上同时运行。　　3. 在单个 CPU 和 GPU 上同时运行。　　4. 在两个 CPU 和 GPU 上同时运行。　　一个任务开始执行以后,将会独占它所用到的所有硬件资源,不得中断,直到执行结束为止。第 i 个任务用单个 CPU,两个 CPU,单个 CPU 加 GPU,两个 CPU 加 GPU 运行所消耗的时间分别为 ai,bi,ci 和 di。　　现在需要你计算出至少需要花多少时间可以把所有给定的任务完成。输入格式　　输入的第一行只有一个正整数 n(1 ≤ n ≤ 40), 是总共需要执行的任务个数。　　接下来的 n 行每行有四个正整数 ai, bi, ci, di(ai, bi, ci, di 均不超过 10), 以空格隔开。输出格式　　输出只有一个整数,即完成给定的所有任务所需的最少时间。样例输入 3 4 4 2 2 7 4 7 4 3 3 3 3 样例输出 7 样例说明　　有很多种调度方案可以在 7 个时间单位里完成给定的三个任务,以下是其中的一种方案: 　　同时运行第一个任务(单 CPU 加上 GPU)和第三个任务(单 CPU), 它们分别在时刻 2 和时刻 3 完成。在时刻 3 开始双 CPU 运行任务 2,在时刻 7 完成。

很蛋疼的题，思路参考来源：https://bbs.csdn.net/topics/392049388

首先，如果一个任务占用了两个CPU，那么这一刻是不能启动其他任务的，那么它在运行期间内可以继续占用GPU。因此我们发现正常情况下，可以直接选择4方案而划去2方案，当然为了避免一些奇葩的数据，我们需要预处理一下，如果4方案比2方案更耗时，把4方案的时间更正为2方案的时间即可。

为分析问题我们做一些声明，设A为第一个CPU被占用的时间，B为第二个CPU被占用的时间，C为GPU被占用的时间，那么易知最少完成时间一定是>=max{A,B,C}的，因为如果调度算法使得硬件有未被占用的碎片化时间，那么这个结果一定是大于max{A,B,C}的，如果恰好可以满足使用时间最长的硬件没有任何的碎片化时间且其他硬件占用时间不会超过该最长时间，那么结果自然等于max{A,B,C}。

接下来需要求证最少完成时间<=max{A,B,C}，即找到合理的调度方案使得执行时间最长的没有任何的碎片化时间，如果理解不了，直接当作是找到使得最少完成时间=max(A,B,C}的调度方案，调度方案如下：

（1）选择选项4的任务最后运行；
（2）选择只在第一个CPU上运行的任务从时刻0开始依次不间断地运行，设这些任务一直到时刻t1才结束；
（3）选择占用第二个CPU和GPU的任务从时刻0开始依次不间断地运行，设这些任务一直到时刻t2才结束；
（4）选择占用第一个CPU和GPU的任务从时刻max{t1,t2}开始依次不间断地运行；
（5）选择只占用第二个CPU的任务从时刻t2开始依次不间断地运行。

以上图为例，在上述的任务调度方案下，至少可以保证有一个硬件是不间断运行的。

基于上述调度安排，我们可以知道，只需要关心每个任务选择的方案，而无需关系具体怎么分配硬件。

我们设dp(i,x,y,z)表示前i个任务在没有任务依赖条件下，给定X时间的CPU1，Y时间的CPU2，Z时间的GPU，是否可以完成。那么对于第i个任务，基于我们上述五个调度方案（因为CPU需要区分占用的是哪一个)的分析，有状态转移方程：

dp(i,x,y,z)=min{dp(i-1,x-a[i],y,z),dp(i-1,x,y-a[i],z),dp(i-1,x-c[i],y,z-c[i]),dp(i-1,x,y-c[i],z-c[i]),dp(i-1,x-d[i],y-d[i],z-d[i]))

其中dp(i-1,x+a[i],y,z)表示给i号任务分配CPU1，dp(i-1,x,y+b[i],z)表示给i号任务分配CPU2，dp(i-1,x+c[i],y,z+c[i])表示给i号任务分配CPU1和GPU，dp(i-1,x,y+c[i],z+c[i])表示给i号任务分配CPU2和GPU，dp(i-1,x+d[i],y+d[i],z+d[i])表示给i号任务分配CPU1、CPU2和GPU。

WALL-SQ

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
CCF 难题汇总（2013-2019 持续更新）

试题编号： 201312-4 试题名称：有趣的数时间限制： 1.0s 内存限制： 256.0MB 问题描述：问题描述　　我们把一个数称为有趣的，当且仅当：　　1. 它的数字只包含0, 1, 2, 3，且这四个数字都出现过至少一次。　　2. 所有的0都出现在所有的1之前，而所有的2都出现在所有的3之前。　　...
复制链接

扫一扫