搜索与回溯典型题目解析

前排提示，本文收录的题目不是全部，只是抽取一些题目进行解析。因为笔者是在写完所有题之后在写此篇，推导过程中的量的名称可能与参考代码中不一样，还望谅解。

题目链接：信息学奥赛一本通（C++版）在线评测系统

1212：LETTERS

【题目描述】

给出一个roe×col的大写字母矩阵，一开始的位置为左上角，你可以向上下左右四个方向移动，并且不能移向曾经经过的字母。问最多可以经过几个字母。

【输入】

第一行，输入字母矩阵行数R和列数S，1≤R,S≤20。

接着输出R行S列字母矩阵。

【输出】

最多能走过的不同字母的个数。

【输入样例】

3 6

HFDFFB

AJHGDH

DGAGEH

【输出样例】

【推导过程】

每次从一个点出发，可以向右与向下走，不能走回头路，使用vis_le[]记录已经走过的路；同时也不能走已经走过的字母，采用一个桶数组vit_[]标记走过的数组；为了记录偏移量，定义dr[]{-1,0,1,0}与dc[]{0,-1,0,1}（绕一圈的量）记录偏移量，使用循环。之后再采用搜索与回溯算法，查找可以走的路并储存。

【参考代码】

# include<iostream>

# include<cstring>

using namespace std;

const int maxn=26;

int r,s;

int g[maxn][maxn];

string ss;

int Max;

bool vis_le[maxn]; //标记字母

bool vis_[maxn][maxn];//标记点

int dr[]={1,0,-1,0};

int dc[]={0,-1,0,1};

void search(int x,int y,int step)

{

if(step>Max)

Max=step;

for(int i=0;i<4;i++)

{

int newx=x+dr[i];

int newy=y+dc[i];

if(newx>=0&&newx<r&&newy>=0&&newy<s&&!vis_le[g[newx][newy]]&&!vis_[newx][newy])

{

vis_le[g[newx][newy]]=vis_[newx][newy]=1;

search(newx,newy,step+1);

vis_le[g[newx][newy]]=vis_[newx][newy]=0;

}

int main()

{

cin>>r>>s;

for(int i=0;i<r;i++)

{

cin>>ss;

for(int j=0;j<ss.size();j++)

{

g[i][j]=ss[j]-'A';

}

memset(vis_le,0,sizeof(vis_le));

memset(vis_,0,sizeof(vis_));

vis_le[g[0][0]]=1;vis_[0][0]=1; //站在第一个点去向四周做选择，并把第一个点死锁

search(0,0,1); //因为第一个点有一个字母，故已访问一个字母，所以第三个参数为1

cout<<Max<<endl;

return 0;

}

1213：八皇后问题

【题目描述】

在国际象棋棋盘上放置八个皇后，要求每两个皇后之间不能直接吃掉对方。

【输入】

(无)

【输出】

按给定顺序和格式输出所有八皇后问题的解（见样例）。

【输入样例】

（无）

【输出样例】

No. 1

1 0 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 1

0 1 0 0 0 0 0 0

0 0 0 1 0 0 0 0

0 0 0 0 0 1 0 0

0 0 1 0 0 0 0 0

No. 2

1 0 0 0 0 0 0 0

0 0 0 0 0 0 1 0

0 0 0 1 0 0 0 0

0 0 0 0 0 1 0 0

0 0 0 0 0 0 0 1

0 1 0 0 0 0 0 0

0 0 0 0 1 0 0 0

0 0 1 0 0 0 0 0

...以下省略

【推导过程】

这是一道很经典的题目。算法的基本思路是依次在每一列的每一个点（列数不与上一个重合），并查看是否符合要求，不符合递归摆放下一个（行数加1，到达边界后行数重置，列数加1），符合记录坐标，定义a[]，表示第i行的皇后在第j列。录8个摆放完毕后输出答案。皇后可以吃同一行——摆放是行数加1、同一列——建立b[]，=1表示第j列有皇后了，=0就便是没有、同一对角线的棋子——先建立ysx[],表示从左下到右下的对角线，总共15条斜线，每条斜线上所有格子行号+列号=固定值，值范围2至16；再建立yxx[]，表示从左上到右下的对角线，总共15条斜线，每条斜线上所有格子行号-列号=固定值，值范围7至-7（C++不能操控负数组，所以[14]并+7）。

【参考代码】

#include<iostream>

using namespace std;

int a[9];//a[i]=j 记录第i行的皇后在j列

int b[9];//b[j]=1 表示第j列有皇后了，=0表示第j列没有皇后

int qipan[9][9];//记录棋盘中的数字，有皇后的格子数字为1，没有皇后的格子为0

int ysx[16];//表示从左下到右上的斜线,y=右，s=上，x=斜,总共15条斜线，每条斜线上所有格子行号+列号=固定值，值范围2至16，

int yxx[16];//表示从左上到右下的斜线,y=右，x=下，x=斜,总共15条斜线，每条斜线上所有格子行号-列号=固定值，值范围7至-7

int i,j,sum;//sum记录多少种可能

void print();

void dfs(int i) //确定第i行皇后位置

{

int j;

for(j=1;j<=8;j++)

{

if(b[j]==0&&ysx[i+j]==0&&yxx[i-j+7]==0)//1.这一列没有皇后，2.这个点并不在某个皇后覆盖的从左下到右上的斜线上，3. 这个点并不在某个皇后覆盖的从左上到右下的斜线上

{

a[i]=j;

b[j]=1;

qipan[i][j]=1;

ysx[i+j]=1;

yxx[i-j+7]=1;

if(i==8)

{

//if(sum<3)

print();

}

else

dfs(i+1);

//以下为回溯

a[i]=0;

b[j]=0;

qipan[i][j]=0;

ysx[i+j]=0;

yxx[i-j+7]=0;

}

return;

}

void print()

{

sum++;

int m,n;

cout<<"No. "<<sum<<endl;

for(m=1;m<=8;m++)

{

for(n=1;n<=8;n++)

{

if(qipan[n][m]==1)

cout<<"1"<<" ";

else

cout<<"0"<<" ";

}

cout<<endl;

}

return;

}

int main()

{

dfs(1);

return 0;

}

1214：八皇后

【题目描述】

会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。如何将8个皇后放在棋盘上（有8 × 8个方格），使它们谁也不能被吃掉！这就是著名的八皇后问题。

对于某个满足要求的8皇后的摆放方法，定义一个皇后串a与之对应，即a=b1b2...b8a=b1b2...b8，其中bi为相应摆法中第i行皇后所处的列数。已经知道8皇后问题一共有92组解（即92个不同的皇后串）。

给出一个数b，要求输出第b个串。串的比较是这样的：皇后串x置于皇后串y之前，当且仅当将x视为整数时比y小。

【输入】

第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数b(1≤b≤92)。

【输出】

输出有n行，每行输出对应一个输入。输出应是一个正整数，是对应于b的皇后串。

【输入样例】

【输出样例】

15863724

84136275a

【推导过程】

只是在判断处、输出处不同，与之前的是一样的

【参考代码】

#include<bits/stdc++.h>

using namespace std;

int a[8][8],ab=0;

int b[1000];

int c[1000];

int n,a1;

bool cheak(int x,int l)

{

for(int i=x;i>=0;i--)

{

if(a[i][l]==1)

{

return 0;

}

for(int k=x,c=l;k>=0&&c>=0;k--,c--)

{

if(a[k][c]==1)

{

return 0;

}

for(int k=x,c=l;k>=0&&c<8;k--,c++)

{

if(a[k][c]==1)

{

return 0;

}

return 1;

}

void fun(int x)

{

int l;

if(x>7)

{

ab++;

if(ab==a1)

{

for(int i=0;i<8;i++)

{

cout<<b[i]+1;

}

cout<<endl;

}

else

{

for(l=0;l<8;l++)

{

if(cheak(x,l))

{

a[x][l]=1;

b[x]=l;

fun(x+1);

a[x][l]=0;

}

int main()

{

int a;

cin>>n;

for(int i=0;i<n;i++)

{

cin>>a1;

fun(0);

ab=0;

}

return 0;

}

1215：迷宫

【题目描述】

一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由n×n的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。如果起点或者终点有一个不能通行(为#)，则看成无法办到。

【输入】

第1行是测试数据的组数kk，后面跟着kk组输入。每组测试数据的第11行是一个正整数n(1≤n≤100)，表示迷宫的规模是n×n的。接下来是一个n×n的矩阵，矩阵中的元素为.或者#。再接下来一行是4个整数ha,la,hb,lb，描述A处在第ha行, 第la列，B处在第hb行, 第lb列。注意到ha,la,hb,lb全部是从0开始计数的。

【输出】

k行，每行输出对应一个输入。能办到则输出“YES”，否则输出“NO”。

【输入样例】

.##

..#

#..

0 0 2 2

.....

###.#

..#..

###..

...#.

0 0 4 0

【输出样例】

YES

NO

【推导过程】

首先，这道题只需要搜索而不需要回溯，这道题只需要查找到终点，能就输出”YES”，不能就输出”NO”,不需要记录。为了使“可以走”与“不能走”形成“true”与“false”，定义ch(char型)，先读入ch，判断后存入a[][]（0与1的形式）。与其它偏移题一样，定义偏移量数组dx[]{-1,0,1,0}与dy[]{0,-1,0,1}。在输入完数据后，需要进行特判，如果起点或终点就是障碍物，直接输入”NO”；之后定义标志变量flag，初始化为false。为了防止不走回头路，需要一个标识数组b[][]。没越界、没有障碍物、没走过满足3者才可以走，否则直接失败；如果成功，flag=true。

最后判断——flag=false输出”NO”，flag=true输出“Yes“。（记得用循环！！！）

【参考代码】

#include<bits/stdc++.h>

using namespace std;

int k, n;

char a[105][105]; //地图

int b[105][105]; //标记数组

int d[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; //方向数组

int startx, starty, endx, endy;

bool flag;

void dfs(int x, int y) {

//递归出口

if (x == endx && y == endy) {

cout << "YES" << endl;

flag = true;

return;

}

//递归条件

for (int i = 0; i < 4; i++) {

int nextx = x + d[i][0];

int nexty = y + d[i][1];

if (nextx >= 0 && nexty >= 0 && nextx < n && nexty < n && a[nextx][nexty] == '.' && !b[nextx][nexty]) {

//没越界、没有障碍物、没走过，同时满足三者才可以走

b[nextx][nexty] = 1;

dfs(nextx, nexty);

//b[nextx][nexty] = 0;

}

int main()

{

cin >> k;

for (int i = 0; i < k; i++) {

//初始化工作

memset(a, 0, sizeof(a));

memset(b, 0, sizeof(b));

//输入地图维度

cin >> n;

//输入地图

for (int row = 0; row < n; row++) {

for (int col = 0; col < n; col++) {

cin >> a[row][col];

}

//输入起点终点

cin >> startx >> starty >> endx >> endy;

//特判

if (a[startx][starty] == '#' || a[endx][endy] == '#') { //起点或终点为#

cout << "NO" << endl;

continue;

}

flag = false;

b[startx][starty] = 1;

dfs(startx, starty);

if (flag == false) cout << "NO" << endl;

}

return 0;

}