迷宫（C++，DFS）
题目描述
给定一个 N × M N \times M N×M 方格的迷宫，迷宫里有 T T T 处障碍，障碍处不可通过。
在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。
给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方案。
输入格式
第一行为三个正整数 N , M , T N,M,T N,M,T，分别表示迷宫的长宽和障碍总数。
第二行为四个正整数 S X , S Y , F X , F Y SX,SY,FX,FY SX,SY,FX,FY， S X , S Y SX,SY SX,SY 代表起点坐标， F X , F Y FX,FY FX,FY 代表终点坐标。
接下来 T T T 行，每行两个正整数，表示障碍点的坐标。
输出格式
输出从起点坐标到终点坐标的方案总数。
样例 #1
样例输入 #1
2 2 1
1 1 2 2
1 2
样例输出 #1
1
提示
对于 100 % 100\% 100% 的数据， 1 ≤ N , M ≤ 5 1 \le N,M \le 5 1≤N,M≤5， 1 ≤ T ≤ 10 1 \le T \le 10 1≤T≤10， 1 ≤ S X , F X ≤ n 1 \le SX,FX \le n 1≤SX,FX≤n， 1 ≤ S Y , F Y ≤ m 1 \le SY,FY \le m 1≤SY,FY≤m。
解题思路：
题目要求就是找出所有从起点到终点的路径，那么就可以采用深度优先搜索来找出每一条路径
我们逐步来实现递归函数
首先，参数列表部分，只需传入x、y用以代表当前坐标
void deep_first_search(int x, int y);
然后，我们来实现递归主体部分
先进行准备工作
创建一个二维数组，来表示地图
再创建一个二维数组，用来标记走过的格子
再再创建一个二维数组，用来存储四个方向
bool map[5][5] = { 0 };//读入地图，0为平地，1为障碍物
bool map_book[5][5] = { 0 };//标记走过的路，0为未走过，1为走过，防止重复
int step[4][2] = //按右、下、左、上四个方向尝试
{
{0, 1},
{1, 0},
{0, -1},
{-1, 0}
};
准备工作完成，开始实现
for循环尝试四个方向，判断是否可行
若可行，则标记该格子已经走过，然后进入这一个格子，重复以上步骤
此外，在递归返回后不要忘记取消标记
void deep_first_search(int x, int y)//利用深度优先搜索寻找每一条路径，x、y分别代表当前坐标
{
//递归主体
for (int i = 0; i < 4; i++)//尝试每一个方向
{
int temp_x = x + step[i][0];
int temp_y = y + step[i][1];
if (map_book[temp_x][temp_y] || map[temp_x][temp_y])//如果走过或者遇到障碍物，尝试下一个方向
{
continue;
}
else if (temp_x < 0 || temp_x > N - 1 || temp_y < 0 || temp_y > M - 1)//如果出界，尝试下一个方向
{
continue;
}
map_book[temp_x][temp_y] = true;//标记为已经走过
deep_first_search(temp_x, temp_y);
map_book[temp_x][temp_y] = false;//取消标记
}
return;
}
最后，递归停止条件当然就是当前坐标与终点坐标相等了
void deep_first_search(int x, int y)//利用深度优先搜索寻找每一条路径，x、y分别代表当前坐标
{
//递归结束条件
if (x == final_x - 1 && y == final_y - 1)
{
sum_path++;//找到一条符合条件的路径
return;
}
//递归主体
for (int i = 0; i < 4; i++)//尝试每一个方向
{
int temp_x = x + step[i][0];
int temp_y = y + step[i][1];
if (map_book[temp_x][temp_y] || map[temp_x][temp_y])//如果走过或者遇到障碍物，尝试下一个方向
{
continue;
}
else if (temp_x < 0 || temp_x > N - 1 || temp_y < 0 || temp_y > M - 1)//如果出界，尝试下一个方向
{
continue;
}
map_book[temp_x][temp_y] = true;//标记为已经走过
deep_first_search(temp_x, temp_y);
map_book[temp_x][temp_y] = false;//取消标记
}
return;
}
至此，本题核心解题部分说明完毕
完整代码如下
#include <iostream>
using namespace std;
int sum_path = 0;//用于累计总数
int N, M;//分别代表长度和宽度
int final_x, final_y;//代表终点坐标
bool map[5][5] = { 0 };//读入地图，0为平地，1为障碍物
bool map_book[5][5] = { 0 };//标记走过的路，0为未走过，1为走过，防止重复
int step[4][2] = //按右、下、左、上四个方向尝试
{
{0, 1},
{1, 0},
{0, -1},
{-1, 0}
};
//void out_put_path()//输出路径
//{
// for (int i = 0; i < N; i++)
// {
// for (int j = 0; j < M; j++)
// {
// putchar(char(map_book[i][j] + '0'));
// putchar(' ');
// }
// putchar('\n');
// }
//}
void deep_first_search(int x, int y)//利用深度优先搜索寻找每一条路径，x、y分别代表当前坐标
{
//递归结束条件
if (x == final_x - 1 && y == final_y - 1)
{
sum_path++;//找到一条符合条件的路径
//out_put_path();//显示路径
//putchar('\n');
return;
}
//递归主体
for (int i = 0; i < 4; i++)//尝试每一个方向
{
int temp_x = x + step[i][0];
int temp_y = y + step[i][1];
if (map_book[temp_x][temp_y] || map[temp_x][temp_y])//如果走过或者遇到障碍物，尝试下一个方向
{
continue;
}
else if (temp_x < 0 || temp_x > N - 1 || temp_y < 0 || temp_y > M - 1)//如果出界，尝试下一个方向
{
continue;
}
map_book[temp_x][temp_y] = true;//标记为已经走过
deep_first_search(temp_x, temp_y);
map_book[temp_x][temp_y] = false;//取消标记
}
return;
}
int main()
{
int T, start_x, start_y, obstacle_x, obstacle_y;
cin >> N >> M >> T;
cin >> start_x >> start_y;
cin >> final_x >> final_y;
for (int i = 0; i < T; i++)
{
cin >> obstacle_x >> obstacle_y;
map[obstacle_x - 1][obstacle_y - 1] = true;//添加障碍物
}
map_book[start_x - 1][start_y - 1] = true;//注意要将起点标记
deep_first_search(start_x - 1, start_y - 1);
cout << sum_path;
return 0;
}
马的遍历（C++，BFS）
题目描述
有一个 n × m n \times m n×m 的棋盘，在某个点 ( x , y ) (x, y) (x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。
输入格式
输入只有一行四个整数，分别为 n , m , x , y n, m, x, y n,m,x,y。
输出格式
一个 n × m n \times m n×m 的矩阵，代表马到达某个点最少要走几步（不能到达则输出 − 1 -1 −1）。
样例 #1
样例输入 #1
3 3 1 1
样例输出 #1
0 3 2
3 -1 1
2 1 4
提示
数据规模与约定
对于全部的测试点，保证 1 ≤ x ≤ n ≤ 400 1 \leq x \leq n \leq 400 1≤x≤n≤400， 1 ≤ y ≤ m ≤ 400 1 \leq y \leq m \leq 400 1≤y≤m≤400。
解题思路：
本题要求是找到到达每个点的最少步数
若对广度优先搜索（Breadth First Search）有所了解，则马上就会发现，广度优先搜索第一次到达所需的步数即为所要求的最小步数，那么我们需要做的就是用BFS去遍历每一个能够到达的点
这里进一步思考，可以认识到我们无需取消标记，也就是说我们没有递归返回操作
同时认识到数据量较大，容易发生爆栈
那么我们就可以用不定次数循环也就是while循环来实现广度优先搜索
接下来说明如何实现广度优先搜索
首先进行准备工作
创建一个队列，用于广度优先搜索
创建一个二维数组，用于存储到达每个点的最少步数
再创建一个二维数组，用于防止重复到达格子
再再创建一个二维数组，用于存储马能走的八种方向
准备工作完成
queue<node>bfs_queue;
int step_map[400][400] = { 0 };//用于记录到达每一个格子的步数
bool book_map[400][400] = { 0 };//用于判断是否重复到达
int step[8][2] =//大方向按照右、下、左、上的顺序，对于每个大方向，先上后下，先左后右
{
{-1, 2},
{1, 2},
{2, -1},
{2, 1},
{-1, -2},
{1, -2},
{-2, -1},
{-2, 1}
};
循环条件就是!bfs_queue.empty()，如果进一步强化条件，可以加上一个&& sum != N * M
接下来实现循环体
首先我们要尝试八个方向，判断每次尝试是否成功，若不成功，则尝试下一个方向
若成功，则将该方向入队，存储当前到达该位置需要的步数，标记该位置为已走过
八个方向尝试完毕后，不要忘记将队首出队
然后重复以上步骤即可，循环体实现完毕
while (!bfs_queue.empty() && sum != M * N)
{
//循环主体
for (int i = 0; i < 8; i++)//尝试八个方向
{
temp_node.m_x = bfs_queue.front().m_x + step[i][0];
temp_node.m_y = bfs_queue.front().m_y + step[i][1];
if (temp_node.m_x < 0 || temp_node.m_x > N - 1 || temp_node.m_y < 0 || temp_node.m_y > M - 1)//若出界，则尝试下一个方向
{
continue;
}
else if (book_map[temp_node.m_x][temp_node.m_y])//若走过，则尝试下一个方向
{
continue;
}
bfs_queue.push(temp_node);
step_map[temp_node.m_x][temp_node.m_y] = step_map[bfs_queue.front().m_x][bfs_queue.front().m_y] + 1;//记录到达这个格子所需的步数，即为最小步数
book_map[temp_node.m_x][temp_node.m_y] = true;//标记已走过
sum++;
}
bfs_queue.pop();//八个方向尝试完毕，队首出队
}
至此，本题核心结题实现完毕
应该不会有人被输出卡住了吧（小声），只要”设置宽度为5+左对齐“就好啦
#include <iomanip>
for (int i = 0; i < N; i++)
{
for (int j = 0; j < M; j++)
{
if (step_map[i][j] == 0)//将未到达的点修改为-1
{
if(i != start_x || j != start_y)//注意排除起点
{
step_map[i][j] = -1;
}
}
cout << setw(5) << setiosflags(ios::left) << step_map[i][j];
}
cout << endl;
}
那么，本题的完整代码如下
#include <iostream>
#include <iomanip>
#include <queue>
using namespace std;
struct node
{
int m_x;
int m_y;
};
queue<node>bfs_queue;
int step_map[400][400] = { 0 };//用于记录到达每一个格子的步数
bool book_map[400][400] = { 0 };//用于判断是否重复到达
int step[8][2] =//大方向按照右、下、左、上的顺序，对于每个大方向，先上后下，先左后右
{
{-1, 2},
{1, 2},
{2, -1},
{2, 1},
{-1, -2},
{1, -2},
{-2, -1},
{-2, 1}
};
int main()
{
struct node temp_node;
int N, M, start_x, start_y, sum = 0;//sum用于记录已经走过的格子数量
cin >> N >> M;
cin >> start_x >> start_y;
temp_node.m_x = --start_x, temp_node.m_y = --start_y;
bfs_queue.push(temp_node);//读入起始位置
step_map[temp_node.m_x][temp_node.m_y] = 0;
book_map[temp_node.m_x][temp_node.m_y] = 1;//注意要标记起点为已走过
sum++;
while (!bfs_queue.empty() && sum != M * N)
{
//循环主体
for (int i = 0; i < 8; i++)//尝试八个方向
{
temp_node.m_x = bfs_queue.front().m_x + step[i][0];
temp_node.m_y = bfs_queue.front().m_y + step[i][1];
if (temp_node.m_x < 0 || temp_node.m_x > N - 1 || temp_node.m_y < 0 || temp_node.m_y > M - 1)//若出界，则尝试下一个方向
{
continue;
}
else if (book_map[temp_node.m_x][temp_node.m_y])//若走过，则尝试下一个方向
{
continue;
}
bfs_queue.push(temp_node);
step_map[temp_node.m_x][temp_node.m_y] = step_map[bfs_queue.front().m_x][bfs_queue.front().m_y] + 1;//记录到达这个格子所需的步数，即为最小步数
book_map[temp_node.m_x][temp_node.m_y] = true;//标记已走过
sum++;
}
bfs_queue.pop();//八个方向尝试完毕，队首出队
}
for (int i = 0; i < N; i++)
{
for (int j = 0; j < M; j++)
{
if (step_map[i][j] == 0)//将未到达的点修改为-1
{
if(i != start_x || j != start_y)//注意排除起点
{
step_map[i][j] = -1;
}
}
cout << setw(5) << setiosflags(ios::left) << step_map[i][j];
}
cout << endl;
}
return 0;
}
[USACO1.5]八皇后 Checker Challenge（C++，DFS）
题目描述
一个如下的 6 × 6 6 \times 6 6×6 的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线（包括两条主对角线的所有平行线）上至多有一个棋子。
上面的布局可以用序列 2 4 6 1 3 5 2\ 4\ 6\ 1\ 3\ 5 2 4 6 1 3 5 来描述，第 i i i 个数字表示在第 i i i 行的相应位置有一个棋子，如下：
行号 1 2 3 4 5 6 1\ 2\ 3\ 4\ 5\ 6 1 2 3 4 5 6
列号 2 4 6 1 3 5 2\ 4\ 6\ 1\ 3\ 5 2 4 6 1 3 5
这只是棋子放置的一个解。请编一个程序找出所有棋子放置的解。
并把它们以上面的序列方法输出，解按字典顺序排列。
请输出前
3
3
3 个解。最后一行是解的总个数。
输入格式
一行一个正整数 n n n，表示棋盘是 n × n n \times n n×n 大小的。
输出格式
前三行为前三个解，每个解的两个数字之间用一个空格隔开。第四行只有一个数字，表示解的总数。
样例 #1
样例输入 #1
6
样例输出 #1
2 4 6 1 3 5
3 6 2 5 1 4
4 1 5 2 6 3
4
提示
【数据范围】
对于
100
%
100\%
100% 的数据，
6
≤
n
≤
13
6 \le n \le 13
6≤n≤13。
题目翻译来自NOCOW。
USACO Training Section 1.5
解题思路：
八皇后的问题其实类似于全排列的问题，接下来先说明为什么类似，然后我们就自然知道为什么用深度优先搜索了
首先，我们回忆一下全排列的需求，就是要求n个（0~9）数字不能重复出现，求有多少种不同的顺序
那么我们稍微修改一下这道题，我们先把n的范围变为6~13，这很好理解
然后我们再修改一下“不能重复出现”这个条件，就可以得到八皇后的问题了
接下来就会发现问题其实就在于“不能重复出现”的判断
行可以通过递推的层数来避免重复
列的不重复只需要一个一维数组即可
那么对角线呢？
先来看看主对角线，我们会发现“行数-列数”可以很好地对应每一条主对角线
（图中的单元格内为行数-列数的差）
再来看看副对角线，我们又会发现“行数+列数”可以很好地对应每一条副对角线
（图中单元格内为行数+列数的和）
那么判断的问题解决了，递归主体代码如下
int n, sum = 0;//行数、方法总数
bool column_array[13] = { false };//列标记物
bool main_diagon_array[25] = { false };//主对角标记物（-12~12）
bool secondary_diagon_array[25] = { false };//副对角标记物（0~24）
int column_queen[13] = { 0 };//存储皇后位置
void depth_first_search(int line_num)//传入行数
{
for (int i = 0; i < n; i++)//尝试每一列
{
if (column_array[i] || main_diagon_array[line_num - i + 12] || secondary_diagon_array[i + line_num])//检查当前列、主副对角线
{
continue;
}
column_queen[line_num] = i + 1;//注意：存储的列数需要+1
column_array[i] = true;//标记列数
main_diagon_array[line_num - i + 12] = true;//标记主对角线
secondary_diagon_array[i + line_num] = true;//标记副对角线
depth_first_search(line_num + 1);//尝试下一行
column_array[i] = false;//取消标记
main_diagon_array[line_num - i + 12] = false;//取消标记
secondary_diagon_array[i + line_num] = false;//取消标记
}
}
递归结束的条件就很好想到啦，然后根据题意判断后输出即可
if (line_num == n)//所有行均填入皇后，终止
{
if (sum < 3)
{
for (int i = 0; i < n; i++)
{
cout << column_queen[i] << ' ';
}
putchar('\n');
}
sum++;
return;
}
这里可能会疑问为什么这样就是按字典顺序输出的，因为我们总体上就是在尽量先填充小序号的列，得到的结果自然就是字典顺序啦
完整的实现代码如下
#include <iostream>
#include <cmath>
using namespace std;
int n, sum = 0;//行数、方法总数
bool column_array[13] = { false };//列标记物
bool main_diagon_array[25] = { false };//主对角标记物（-12~12）
bool secondary_diagon_array[25] = { false };//副对角标记物（0~24）
int column_queen[13] = { 0 };//存储皇后位置
void depth_first_search(int line_num)//传入行数
{
if (line_num == n)//所有行均填入皇后，终止
{
if (sum < 3)
{
for (int i = 0; i < n; i++)
{
cout << column_queen[i] << ' ';
}
putchar('\n');
}
sum++;
return;
}
for (int i = 0; i < n; i++)//尝试每一列
{
if (column_array[i] || main_diagon_array[line_num - i + 12] || secondary_diagon_array[i + line_num])//检查当前列、主副对角线
{
continue;
}
column_queen[line_num] = i + 1;//注意：存储的列数需要+1
column_array[i] = true;//标记列数
main_diagon_array[line_num - i + 12] = true;//标记主对角线
secondary_diagon_array[i + line_num] = true;//标记副对角线
depth_first_search(line_num + 1);//尝试下一行
column_array[i] = false;//取消标记
main_diagon_array[line_num - i + 12] = false;//取消标记
secondary_diagon_array[i + line_num] = false;//取消标记
}
}
int main()
{
cin >> n;
depth_first_search(0);
cout << sum << endl;
return 0;
}
2018
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
