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

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;
}