搜索题集整理（DFS&BFS）

前言

学习了《夜深人精写算法-算法入门篇》后配套练习的搜索题，其中包含各种DFS和BFS基础运用，记忆搜索等，目前做到DFS，以后有新内容会继续补充。（题集来源于weixin_30325487）本文主要是将题集的题完成后个人的思路与解题方式、题意以及代码（部分会标注注释），一起从入门到精通吧！

一、DFS

1、Red and Black-POJ1979

题目传送门
Time Limit: 1000MS Memory Limit: 30000K
Total Submissions: 67564

description

There is a rectangular room, covered with square tiles. Each tile is
colored either red or black. A man is standing on a black tile. From a
tile, he can move to one of four adjacent tiles. But he can’t move on
red tiles, he can move only on black tiles.

Write a program to count the number of black tiles which he can reach
by repeating the moves described above. Input

The input consists of multiple data sets. A data set starts with a
line containing two positive integers W and H; W and H are the numbers
of tiles in the x- and y- directions, respectively. W and H are not
more than 20.

There are H more lines in the data set, each of which includes W
characters. Each character represents the color of a tile as follows.

‘.’ - a black tile ‘#’ - a red tile ‘@’ - a man on a black
tile(appears exactly once in a data set) The end of the input is
indicated by a line consisting of two zeros. Output

For each data set, your program should output a line which contains
the number of tiles he can reach from the initial tile (including
itself).

Sample Input

6 9
....#.    
.....#     
......     
......     
......     
......     
......     
#@...#      
.#..#.      
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........
11 6
..#..#..#..
..#..#..#..
..#..#..###
..#..#..#@.
..#..#..#..
..#..#..#..
7 7
..#.#..
..#.#..
###.###
...@...
###.###
..#.#..
..#.#..
0 0

Sample Output

45
59
6
13

题 意

‘@’为当前人所在的位置，’.‘代表黑格子，’#‘代表红格子。
走在起始位置和黑格子上可以上下左右移动，到红格子了则不能动。
问最多可以经过几个黑格子。
注意：可以重复踩之前走过的格子。

思 路

运用dfs遇到黑格子并且之前没有经过的就进入dfs，每进一次dfs答案就+1
注意：小心不要跑到图外

代码（含注释）

const int maxn=1e3+10;
char mp[maxn][maxn];   //存图
int vis[maxn][maxn];   //标记有没有跑过该点
int ans=0; //答案
int n,m; 
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};  //上下左右跑的四个方向
void dfs(int x,int y){     
	if(x<0||y<0||x>=n||y>=m) return;    //如果跑出图了就返回
	vis[x][y]=1;                        //标记当前点已经经过
	ans++;   //每跑一次dfs就代表进来一个新的没跑过的黑格子，所以答案要加一
	for(int i=0;i<4;i++){   //循环跑上下左右四个方向
		int xx=x+dir[i][0],yy=y+dir[i][1];  //跑上/下/左/右后的点的坐标
		if(mp[xx][yy]=='#'||vis[xx][yy]!=-1) 
			continue;                 //如果是红格子或已经跑过就不跑
		dfs(xx,yy);       //满足条件的进入下一个dfs
	}
	return;
}
int main(){
	while(cin>>m>>n){
		if(n==0&&m==0) break;
		memset(vis,-1,sizeof(vis));
		int x,y;
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cin>>mp[i][j];
				if(mp[i][j]=='@') x=i,y=j;       //标记当前人在那个点
			}
		}
		dfs(x,y);
		cout<<ans<<endl;
		ans=0;
	}
	return 0;
}

2、The Game-POJ1970

题目传送门
Time Limit: 1000MS Memory Limit: 30000K
Total Submissions: 7862

Description

A game of Renju is played on a 19*19 board by two players. One player uses black stones and the other uses white stones. The game begins in an empty board and two players alternate in placing black stones and white stones. Black always goes first. There are 19 horizontal lines and 19 vertical lines in the board and the stones are placed on the intersections of the lines.
Horizontal lines are marked 1, 2, …, 19 from up to down and vertical lines are marked 1, 2, …, 19 from left to right.
The objective of this game is to put five stones of the same color consecutively along a horizontal, vertical, or diagonal line. So, black wins in the above figure. But, a player does not win the game if more than five stones of the same color were put consecutively.
Given a configuration of the game, write a program to determine whether white has won or black has won or nobody has won yet. There will be no input data where the black and the white both win at the same time. Also there will be no input data where the white or the black wins in more than one place.

Input

The first line of the input contains a single integer t (1 <= t <= 11), the number of test cases, followed by the input data for each test case. Each test case consists of 19 lines, each having 19 numbers. A black stone is denoted by 1, a white stone is denoted by 2, and 0 denotes no stone.

Output

There should be one or two line(s) per test case. In the first line of the test case output, you should print 1 if black wins, 2 if white wins, and 0 if nobody wins yet. If black or white won, print in the second line the horizontal line number and the vertical line number of the left-most stone among the five consecutive stones. (Select the upper-most stone if the five consecutive stones are located vertically.)

Sample Input

1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 2 0 0 2 2 2 1 0 0 0 0 0 0 0 0 0 0
0 0 1 2 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 0 0 1 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 2 2 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 2 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Sample Output

1
3 2

题意

题意很简单就是五子棋，判断是1赢了还是2赢了
注意：只能连五个，连续多了或少了都不行

思路

跑所有的点，并且找这个点能连成线的点的个数，如果是五个，再找第一个反方向位置是否有点（防止找到连续五个以上的点）

代码（含注释）

const int maxn=20;
int mp[maxn][maxn];  //mp用于记图
int step[4][2]={{-1,1},{0,1},{1,1},{1,0}};  //只需要四个方向
int dfs(int x,int y,int z){
	int xx=x+step[z][0],yy=y+step[z][1];   //沿当前方向的下一个点的坐标
	if(xx>19||y>19||x<=0||y<=0) return 0;  //防止跑出图
	if(mp[xx][yy]==mp[x][y]) return 1+dfs(xx,yy,z); //查看下一个点是否是现在相同的点
	return 0;
}
int main(){
	int t;
	cin>>t;
	while(t--){
		int f1=-1,f2=-1; //f1,f2用来记答案需要的棋子的位置X和Y
		for(int i=1;i<=19;i++) for(int j=1;j<=19;j++) cin>>mp[i][j];
		for(int i=1;i<=19;i++){
			for(int j=1;j<=19;j++){
				if(mp[i][j]==0) continue;   //当前没有棋子就跳过
				else{
					for(int k=0;k<4;k++){
						int xx=i+step[k][0],yy=j+step[k][1]; //寻找四个方位哪个方位有相连的棋子
						if(mp[xx][yy]==mp[i][j]){
							int a=2+dfs(xx,yy,k); //符合要求跑dfs找一共有几个棋子相连接，+2是因为自己本身（x,y）一个，(xx，yy)又是一个
							//cout<<i<<" "<<j<<" "<<a<<endl;
							if(a==5) {
								if(mp[i-step[k][0]][j-step[k][1]]!=mp[i][j]) //找第一个棋子反方向是否还有相连接的棋子
									f1=i,f2=j;  //满足要求记录答案
							}
						}
					}
				}
			}
		}	
		if(f1!=-1) cout<<mp[f1][f2]<<endl<<f1<<" "<<f2<<endl;
		else cout<<0<<endl;
	}
	return 0;
}

3、Frogger-POJ2253

题目传送门
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 90851

Description

Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he
notices Fiona Frog who is sitting on another stone. He plans to visit
her, but since the water is dirty and full of tourists’ sunscreen, he
wants to avoid swimming and instead reach her by jumping.
Unfortunately Fiona’s stone is out of his jump range. Therefore Freddy
considers to use other stones as intermediate stops and reach her by a
sequence of several small jumps. To execute a given sequence of jumps,
a frog’s jump range obviously must be at least as long as the longest
jump occuring in the sequence. The frog distance (humans also call it
minimax distance) between two stones therefore is defined as the
minimum necessary jump range over all possible paths between the two
stones.

You are given the coordinates of Freddy’s stone, Fiona’s stone and all
other stones in the lake. Your job is to compute the frog distance
between Freddy’s and Fiona’s stone.

Input

The input will contain one or more test cases. The first line of each
test case will contain the number of stones n (2<=n<=200). The next n
lines each contain two integers xi,yi (0 <= xi,yi <= 1000)
representing the coordinates of stone #i. Stone #1 is Freddy’s stone,
stone #2 is Fiona’s stone, the other n-2 stones are unoccupied.
There’s a blank line following each test case. Input is terminated by
a value of zero (0) for n.

Output

For each test case, print a line saying “Scenario #x” and a line saying “Frog Distance = y” where x is replaced by the test case number (they are numbered from 1) and y is replaced by the appropriate real number, printed to three decimals. Put a blank line after each test case, even after the last one.

Sample Input

2
0 0
3 4

3
17 4
19 4
18 5

0

Sample Output

Scenario #1
Frog Distance = 5.000
（注意换行）
Scenario #2
Frog Distance = 1.414

题意

给你n个点，第一个点是青蛙的起点，第二个点是青蛙需要到达的终点，问你每个通路的最长路段中的最短距离。
举个例子A(3)B(2)C和A(1)D(4)C，第一个是A到B距离为3，B到C距离为2，选择最长的路短则为3；第二个是A到D距离为1，D到C距离为4，选择最长的路短则为4；最后选择最长路短中的最小距离，便是在3与4之间选一个最小的所以答案为3；（题目有一点点绕）

思路

我是用了floyd，解法有很多可以参考这篇（传送门），这题就是将floyd稍微变形一些即可，具体看代码

代码（含注释）

const int maxn=2e2+3;
int n;
double mp[maxn][maxn];
void floyd(){
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				mp[i][j]=min(mp[i][j],max(mp[i][k],mp[k][j]));
				//i是起点，j是终点，k是两点间的中间点
				//max(mp[i][k],mp[k][j]) 这一步是在找出ikj这条路中最大的路短
				//min(本身，新找的)  再比较原本的和新找的哪个路段更小
				//最后找出来的就是所所有通路中的最长段中的最小段
			}
		}
	}
}
int main(){
	int t=0;
	int x[maxn],y[maxn];
	while(cin>>n){
		if(n==0) break;
		t++;
		for(int i=1;i<=n;i++){
			cin>>x[i]>>y[i];
		}
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				mp[i][j]=mp[j][i]=sqrt(double(x[i]-x[j])*double(x[i]-x[j])+double(y[i]-y[j])*double(y[i]-y[j]));
			}
		}
		floyd();
		printf("Scenario #%d\nFrog Distance = %.3f\n\n",t,mp[1][2]);
		//注意换行的格式
	}
	return 0;
}

4、Nearest Common Ancestors—POJ1330

题目传送门
Time Limit: 1000MS Memory Limit: 10000K
Total Submissions: 45420

Description

A rooted tree is a well-known data structure in computer science and
engineering. An example is shown below:

In the figure, each node is labeled with an integer from {1,
2,…,16}. Node 8 is the root of the tree. Node x is an ancestor of
node y if node x is in the path between the root and node y. For
example, node 4 is an ancestor of node 16. Node 10 is also an ancestor
of node 16. As a matter of fact, nodes 8, 4, 10, and 16 are the
ancestors of node 16. Remember that a node is an ancestor of itself.
Nodes 8, 4, 6, and 7 are the ancestors of node 7. A node x is called a
common ancestor of two different nodes y and z if node x is an
ancestor of node y and an ancestor of node z. Thus, nodes 8 and 4 are
the common ancestors of nodes 16 and 7. A node x is called the nearest
common ancestor of nodes y and z if x is a common ancestor of y and z
and nearest to y and z among their common ancestors. Hence, the
nearest common ancestor of nodes 16 and 7 is node 4. Node 4 is nearer
to nodes 16 and 7 than node 8 is.

For other examples, the nearest common ancestor of nodes 2 and 3 is
node 10, the nearest common ancestor of nodes 6 and 13 is node 8, and
the nearest common ancestor of nodes 4 and 12 is node 4. In the last
example, if y is an ancestor of z, then the nearest common ancestor of
y and z is y.

Write a program that finds the nearest common ancestor of two distinct
nodes in a tree.

Input

The input consists of T test cases. The number of test cases (T) is
given in the first line of the input file. Each test case starts with
a line containing an integer N , the number of nodes in a tree,
2<=N<=10,000. The nodes are labeled with integers 1, 2,…, N. Each of
the next N -1 lines contains a pair of integers that represent an edge
–the first integer is the parent node of the second integer. Note that a tree with N nodes has exactly N - 1 edges. The last line of
each test case contains two distinct integers whose nearest common
ancestor is to be computed.

Output

Print exactly one line for each test case. The line should contain the
integer that is the nearest common ancestor.

Sample Input

2
16
1 14
8 5
10 16
5 9
4 6
8 4
4 10
1 13
6 15
10 11
6 7
10 2
16 3
8 1
16 12
16 7
5
2 3
3 4
3 1
1 5
3 5

Sample Output

4
3

题意

【就是找最近公共祖先(LCA)】
T组，每组一棵树给n-1条边，每条边由a,b组成，a是b的父节点，第n个a,b表示需要找a和b的最近公共祖先（LCA）

思路

运用了链式前向星存图，先找到没有父节点的节点为根节点，然后运用dfs为每一个节点添加其层数，检查a,b两点，是否a的层数比b的大，不是的话互换位置，一直寻找a的父节点直至和b同一层，最后同时寻找a和b的父节点，直至两个父节点相同吧，即为公共祖先。

代码（含注释）

const int maxn=1e4+10;
int all=0;         //记录几条边
int deep[maxn],head[maxn],fath[maxn];
struct edge{  //不懂链式前向星的先去学一下更好理解
	int next;//指到相邻边
	int data;//相连的点
}v[maxn];
void add(int x,int y){  //加边
	v[all].next=head[x];   //记录该边的相邻边
	v[all].data=y;     //该边相连的点
	head[x]=all;		//更新x点的边（下一次再碰到x点，这条就是相邻边了）
	all++;			//记录第几条边
}
void dfs(int x,int d){
	for(int i=head[x];i!=-1;i=v[i].next){
		dfs(v[i].data,d+1);		//寻找下一条边
	}
	deep[x]=d;				//记录层数
}
int main(){
	int t;
	cin>>t;
	while(t--){
		int n;
		cin>>n;
		all=0;
		for(int i=0;i<=n;i++){
			head[i]=-1;			//清空
			fath[i]=-1;			//清空	
		}
		for(int i=0;i<n-1;i++){
			int x,y;
			cin>>x>>y;
			add(x,y);		//加边
			fath[y]=x;
		}

		int root;
		for(int i=1;i<=n;i++){
			if(fath[i]==-1) root=i;   //找到没有父亲的节点即为父节点
		}
		//cout<<root<<endl;
		dfs(root,0);			//遍历该树，为每个节点添加层数
		// for(int i=1;i<=n;i++){
		// 	cout<<"i:  "<<i<<"   " <<deep[i]<<endl;
		// }        //可以解开这边的注释查看层数是否正确
		int a,b;
		cin>>a>>b;
		int da=deep[a],db=deep[b];
		if(da<db){      //确保a的层数比b多
			int c=a;
			a=b;
			b=c;
		}
		while(deep[a]>deep[b]) a=fath[a];  //将一直寻找父节点直到同一层
		while(a!=b){  //寻找同一个父亲
			a=fath[a];
			b=fath[b];
		}
		cout<<a<<endl;
	}
	return 0;
}

5、Robot Motion —POJ1573

题目传送门
Time Limit: 1000MS Memory Limit: 10000K
Total Submissions: 17950

Description

A robot has been programmed to follow the instructions in its path.
Instructions for the next direction the robot is to move are laid down
in a grid. The possible instructions are

N north (up the page) S south (down the page) E east (to the right on
the page) W west (to the left on the page)

For example, suppose the robot starts on the north (top) side of Grid
1 and starts south (down). The path the robot follows is shown. The
robot goes through 10 instructions in the grid before leaving the
grid.

Compare what happens in Grid 2: the robot goes through 3 instructions
only once, and then starts a loop through 8 instructions, and never
exits.

You are to write a program that determines how long it takes a robot
to get out of the grid or how the robot loops around.

Input

There will be one or more grids for robots to navigate. The data for
each is in the following form. On the first line are three integers
separated by blanks: the number of rows in the grid, the number of
columns in the grid, and the number of the column in which the robot
enters from the north. The possible entry columns are numbered
starting with one at the left. Then come the rows of the direction
instructions. Each grid will have at least one and at most 10 rows and
columns of instructions. The lines of instructions contain only the
characters N, S, E, or W with no blanks. The end of input is indicated
by a row containing 0 0 0.

Output

For each grid in the input there is one line of output. Either the
robot follows a certain number of instructions and exits the grid on
any one the four sides or else the robot follows the instructions on a
certain number of locations once, and then the instructions on some
number of locations repeatedly. The sample input below corresponds to
the two grids above and illustrates the two forms of output. The word
“step” is always immediately followed by “(s)” whether or not the
number before it is 1.

Sample Input

3 6 5
NEESWE
WWWESS
SNWWWW
4 5 1
SESWE
EESNW
NWEEN
EWSEN
0 0 0

Sample Output

10 step(s) to exit
3 step(s) before a loop of 8 step(s)

题意

给你三个数，第一个数代表地图的行数，第二个数代表地图的列数，第三个数代表你起点在第几列，每次从该列的第一个开始走。地图上每一格都标有一个字母，N代表往上走，S代表往下走，E代表往右走，W代表往左走，最后会出现两种结果，一种是走出地图那就输出（步数）step(s) to exit，另一种就是循环走同一段路，输出 （不重复的步数）step(s) before a loop of 8（循环的步数）step(s)

思路

dfs模拟，就直接暴力，地图很小不会t

代码（含注释）

char mp[106][106],cet[106][106];
int ste[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
int n,m;
int step;
int dfs(int x,int y){
	//cout<<x<<" "<<y<<" "<<step<<endl;;
	if(x<=0||y<=0||x>n||y>m) return 0;
	if(cet[x][y]!=0) return cet[x][y];
	cet[x][y]=++step;
	if(mp[x][y]=='N') x+=ste[0][0],y+=ste[0][1];
	else if(mp[x][y]=='E') x+=ste[1][0],y+=ste[1][1];
	else if(mp[x][y]=='S') x+=ste[2][0],y+=ste[2][1];
	else if(mp[x][y]=='W') x+=ste[3][0],y+=ste[3][1];
	dfs(x,y);
} 
int main(){
	int k;
	while(cin>>n>>m>>k){
		memset(cet,0,sizeof(cet));
		step=0;
		if(n==0&&m==0&&k==0) break;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				cin>>mp[i][j];
			}
		}
		int x=1,y=k;
		int ans=dfs(x,y);

		if(ans==0) cout<<step<<" step(s) to exit"<<endl;
		else{
			int a=ans-1,b=step-a;
			cout<<a<<" step(s) before a loop of "<<b<<" step(s)"<<endl;
		} 
	}
	return 0;
}

6、Dessert —POJ1950

题目传送门
Time Limit: 1000MS Memory Limit: 30000K
Total Submissions: 6659

Description

FJ has a new rule about the cows lining up for dinner. Not only must
the N (3 <= N <= 15) cows line up for dinner in order, but they must
place a napkin between each pair of cows with a “+”, “-”, or “.” on
it. In order to earn their dessert, the cow numbers and the napkins
must form a numerical expression that evaluates to 0. The napkin with
a “.” enables the cows to build bigger numbers. Consider this equation
for seven cows:
1 - 2 . 3 - 4 . 5 + 6 . 7

This means 1-23-45+67, which evaluates to 0. You job is to assist the
cows in getting dessert. (Note: “… 10 . 11 …”) will use the number
1011 in its calculation.)

Input

One line with a single integer, N

Output

One line of output for each of the first 20 possible expressions –
then a line with a single integer that is the total number of possible
answers. Each expression line has the general format of number, space,
napkin, space, number, space, napkin, etc. etc. The output order is
lexicographic, with “+” coming before “-” coming before “.”. If fewer
than 20 expressions can be formed, print all of the expressions.

Sample Input

7

Sample Output

1 + 2 - 3 + 4 - 5 - 6 + 7
1 + 2 - 3 - 4 + 5 + 6 - 7
1 - 2 + 3 + 4 - 5+ 6 - 7
1 - 2 - 3 - 4 - 5 + 6 + 7
1 - 2 . 3 + 4 + 5 + 6 + 7
1 - 2 . 3 - 4 . 5 + 6 . 7
6

题意

给你一个数n，代表现在有1，2，3，4，…，n-1，n。现在要你在每两个数字之间增加符号，使最后这个式子等于0。+和-与平时计算方法一样，.是代表将两个数连接（2.3就是把23）
举例：1 - 2 . 3 - 4 . 5 + 6 . 7=1-23-45+67=0
最后输出所有情况的式子（大于20种就输出20种）与情况总数。

思路

dfs模拟符号全排列的所有情况，因为数字位置不变，排列符号的同时计算这个式子的当前值（全部排列完再算容易t）

代码（含注释）

char ch[20];
int n,ans=0;
void dfs(int sum,int depth,int pre){
	//cout<<sum<<" "<<depth<<" "<<pre<<endl;
	 if(depth==n+1){
	 	if(sum==0){
	 		ans++;
	 		if(ans<21){
	 			printf("1");
	 			for(int i=2;i<=n;i++){
	 				printf(" %c %d",ch[i],i);
	 			}
	 			printf("\n");
	 		}
	 	}
	 	return;
	 }
	ch[depth]='+';
	dfs(sum+depth,depth+1,depth);
	ch[depth]='-';
	dfs(sum-depth,depth+1,-depth);
	ch[depth]='.';
	int temp;
	if(pre>0) temp=depth;
	else temp=-depth;
	if(depth<10) temp=pre*10+temp;
	else if(depth>=10) temp=pre*100+temp;
	dfs(sum-pre+temp,depth+1,temp);
	return;
}
int main(){
	scanf("%d",&n);
	dfs(1,2,1);
	cout<<ans<<endl;
}