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