A. 算法7-4,7-5：图的遍历——深度优先搜索
Description
深度优先搜索遍历类似于树的先根遍历，是树的先根遍历的推广。其过程为：假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可以从图中的某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点，重复上述过程，直至图中所有顶点都被访问到为止。
其算法可以描述如下：
在本题中，读入一个无向图的邻接矩阵（即数组表示），建立无向图并按照以上描述中的算法遍历所有顶点，输出遍历顶点的顺序。
Input
输入的第一行包含一个正整数n，表示图中共有n个顶点。其中n不超过50。
以后的n行中每行有n个用空格隔开的整数0或1，对于第i行的第j个0或1，1表示第i个顶点和第j个顶点有直接连接，0表示没有直接连接。当i和j相等的时候，保证对应的整数为0。
输入保证邻接矩阵为对称矩阵，即输入的图一定是无向图。
Output
只有一行，包含n个整数，表示按照题目描述中的深度优先遍历算法遍历整个图的访问顶点顺序。每个整数后输出一个空格，并请注意行尾输出换行。
Sample Input
<span style="color:#333333"><span style="background-color:#f5f5f5">4
0 1 0 1
1 0 0 0
0 0 0 1
1 0 1 0
</span></span>Sample Output
<span style="color:#333333"><span style="background-color:#f5f5f5">0 1 3 2
</span></span>Hint
在本题中，需要熟练掌握图的邻接矩阵存储方式。在建立完成无向图之后，需要严格按照题目描述的遍历顺序对图进行遍历。另外，算法中描述的FirstAdjVex函数和NextAdjVex函数，需要认真的自行探索并完成。
通过这道题目，应该能够对图的深度优先搜索建立更加直观和清晰的概念。
#include<bits/stdc++.h>
using namespace std;
int book[101],sum,n,e[101][101];
void dfs(int cur){
sum++;
if(sum==n) return;
for(int i=0;i<n;i++){
if(e[cur][i]==1 and book[i]==0){
book[i]=1;
cout<<i<<" ";
dfs(i);
}
}
return ;
}
int main(){
for(int i=0;i<101;i++){
book[i]=0;
}
cin>>n;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin>>e[i][j];
}
}
book[0]=1;
cout<<0<<" ";
dfs(0);
return 0;
}
C. 算法7-6：图的遍历——广度优先搜索
Description
广度优先搜索遍历类似于树的按层次遍历的过程。其过程为：假设从图中的某顶点v出发，在访问了v之后依次访问v的各个未曾被访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点。重复上述过程，直至图中所有顶点都被访问到为止。
其算法可以描述如下：
在本题中，读入一个无向图的邻接矩阵（即数组表示），建立无向图并按照以上描述中的算法遍历所有顶点，输出遍历顶点的顺序。
Input
输入的第一行包含一个正整数n，表示图中共有n个顶点。其中n不超过50。
以后的n行中每行有n个用空格隔开的整数0或1，对于第i行的第j个0或1，1表示第i个顶点和第j个顶点有直接连接，0表示没有直接连接。当i和j相等的时候，保证对应的整数为0。
输入保证邻接矩阵为对称矩阵，即输入的图一定是无向图。
Output
只有一行，包含n个整数，表示按照题目描述中的广度优先遍历算法遍历整个图的访问顶点顺序。每个整数后输出一个空格，并请注意行尾输出换行。
Sample Input
<span style="color:#333333"><span style="background-color:#f5f5f5">4
0 0 0 1
0 0 1 1
0 1 0 1
1 1 1 0
</span></span>Sample Output
<span style="color:#333333"><span style="background-color:#f5f5f5">0 3 1 2
</span></span>Hint
在本题中，需要熟练掌握图的邻接矩阵存储方式。在建立完成无向图之后，需要严格按照题目描述的遍历顺序对图进行遍历。另外，算法中描述的FirstAdjVex函数和NextAdjVex函数，需要认真的自行探索并完成。在本题中需要使用队列结构，需要对队列的概念进行复习。
通过这道题目，应该能够对图的广度优先搜索建立更加直观和清晰的概念。
#include <stdio.h>
#include <string.h>
int main()
{
int n, head, tail;
int arr[2500], map[55][55], vis[55];
while (~scanf("%d", &n))
{
head = tail = 0;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
scanf("%d", &map[i][j]);
}
vis[0] = 1;
arr[tail++] = 0;
printf("0 ");
while (head < tail)
{
for (int i = 0; i < n; i++)
{
if (map[arr[head]][i] && !vis[i])
{
vis[i] = 1;
arr[tail++] = i;
printf("%d ", i);
}
}
head++;
}
puts("");
}
return 0;
}E. 走迷宫
Description
一个迷宫由N行M列格子组成，有的格子里有障碍物，是不能走的；有的格子是空地，可以走。
现在给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。
注：只能在水平方向或垂直方向走，不能斜着走。
Input
输入文件将包含多个测试用例。
第一行是两个整数，N和M，代表迷宫的长和宽。（ 1<= N，M <= 40) 接下来是N行，每行M个字符，代表整个迷宫。
空地格子用'.'表示，有障碍物的格子用'#'表示。
迷宫左上角和右下角都是'.'。
Output
对于每组输入，输出从左上角走到右下角至少要经过多少步（即至少要经过多少个空地格子）。计算步数要包括起点和终点。
Sample Input
5 5 ..### #.... #.#.# #.#.# #.#..
Sample Output
9
#include<bits/stdc++.h>
using namespace std;
struct st//结构体数组放队列
{
int x,y,step;//三个成员分别放横坐标，纵坐标，步数
}q[2000];//队列名称
int main()
{
int i,j,r,c;//定义循环变量
int dx[4]={-1,1,0,0},dy[4]={0,0,-1,1},tx,ty,v[45][45]={0};
//dx、dy增值变量，tx和ty放新结点的坐标，v表示走没走过
int head,tail;//头指针和尾指针
char a[45][45];//放迷宫
cin>>r>>c;//多少行，多少列
for(i=1;i<=r;i++)//行
for(j=1;j<=c;j++)//列
cin>>a[i][j];
head=0,tail=1;//head表示待扩展的结点tail表示新加入的结点
q[1].x=1,q[1].y=1,q[1].step=0,v[1][1]=1;//起点入队
while(head<tail)//队列不为空
{
head++;//准备扩展下一个结点
for(i=0;i<4;i++)//上下左右四个方向
{
tx=q[head].x+dx[i],ty=q[head].y+dy[i];
//计算新结点的坐标
if(tx>=1&&tx<=r&&ty>=1&&ty<=c&&a[tx][ty]!='#'&&v[tx][ty]==0)
//只要新结点合法（不越界，没走过，可以走）
{
tail++;//为新结点做准备
q[tail].x=tx,q[tail].y=ty,q[tail].step=q[head].step+1;v[tx][ty]=1;
//新结点入队
if(tx==r&&ty==c)//判断新结点是否是目标结点
{
cout<<q[tail].step+1;
//输出新结点的步数（因为要算起点，所以加一）
return 0;
}
}
}
}
}G. 送给圣诞夜的极光
Description
圣诞老人回到了北极圣诞区，已经快到12点了。也就是说极光表演要开始了。这里的极光不是极地特有的自然极光景象。而是圣诞老人主持的人造极光。
轰隆隆……烟花响起（来自中国的浏阳花炮之乡）。接下来就是极光表演了。
人造极光其实就是空中的一幅幅n*m的点阵图像。只是因为特别明亮而吸引了很多很多小精灵的目光，也成为了圣诞夜最美丽的一刻。
然而在每幅n*m的点阵图像中，每一个点只有发光和不发光两种状态。对于所有的发光的点，在空中就形成了美丽的图画。而这个图画是以若干个（s个）图案组成的。对于图案，圣诞老人有着严格的定义：对于两个发光的点，如果他们的曼哈顿距离（对于A(x1,y1)和B(x2,y2)，A和B之间的曼哈顿距离为|x1-x2|+|y1-y2|）小于等于2。那么这两个点就属于一个图案……
小精灵们一边欣赏着极光，一边数着每一幅极光图像中的图案数。伴着歌声和舞蹈，度过了美丽的圣诞之夜。^_^
Input
第一行，两个数n和m。
接下来一共n行，每行m个字符。对于第i行第j个字符，如果其为“-”，那么表示该点不发光，如果其为“#”，那么表示该点发光。不可能出现其他的字符。
Output
第一行，一个数s。
Sample Input
19 48 ------------------------------------------------ ---####-----#-----#----------------------####--- --######----#-----#---------------------######-- -########--#-#---#-#####--#-##-##---#--########- -###--###--#-#---#-#----#-##-##--#--#--###--###- -###--###--#--#-#--######-#--#---#-#---###--###- -########--#--#-#--#------#--#----##---########- --######---#---#---######-#--#-----#----######-- ---####----------------------------#-----####--- ----------------------------------#------------- ------------------------------------------------ ---###--#--------#------#----------------------- --#---#-#---------------#----------------------- -#------#-##--#-##--##-###-#-##-###--###-#--##-- -#------##--#-##-#-#----#--##--#---##---##-#---- -#------#---#-#--#--#---#--#---#---##----#--#--- --#---#-#---#-#--#---#--#--#---#---##---##---#-- ---###--#---#-#--#-##---#--#---#---#-###-#-##--- ------------------------------------------------
Sample Output
4
Hint
1<=n,m<=100
#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
char light[151][151];
int ans,fx[12]={-1,0,1,0,1,1,-1,-1,2,0,-2,0},fy[12]={0,1,0,-1,1,-1,1,-1,0,2,0,-2},n,m;
void dfs(int x,int y)
{
light[x][y]='-';
for(int k=0;k<12;++k)
{
int to_x=x+fx[k],to_y=y+fy[k];
if(to_x>=1&&to_x<=n&&to_y>=1&&to_y<=m&&light[to_x][to_y]=='#')
dfs(to_x,to_y);
}
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;++j)
cin>>light[i][j];
for(int i=1;i<=n;i++)
for(int j=1;j<=m;++j)
if(light[i][j]=='#') {ans++;dfs(i,j);}
printf("%d",ans);
return 0;
}H. 海战
Description
在峰会期间，武装部队得处于高度戒备。警察将监视每一条大街，军队将保卫建筑物，领空将布满了F-2003飞机。此外，巡洋船只和舰队将被派去保护海岸线。不幸的是因为种种原因，国防海军部仅有很少的几位军官能指挥大型海战。因此，他们考虑培养一些新的海军指挥官，他们选择了“海战”游戏来帮助学习。
在这个著名的游戏中，在一个方形的盘上放置了固定数量和形状的船只，每只船却不能碰到其它的船。在这个题中，我们仅考虑船是方形的，所有的船只都是由图形组成的方形。编写程序求出该棋盘上放置的船只的总数。
Input
输入文件头一行由用空格隔开的两个整数R和C组成，1<=R,C<=1000，这两个数分别表示游戏棋盘的行数和列数。接下来的R行每行包含C个字符，每个字符可以为“#”，也可为“.”，“#”表示船只的一部分，“.”表示水。
Output
为每一个段落输出一行解。如果船的位置放得正确（即棋盘上只存在相互之间不能接触的方形，如果两个“#”号上下相邻或左右相邻却分属两艘不同的船只，则称这两艘船相互接触了）。就输出一段话“There are S ships.”,S表示船只的数量。否则输出“Bad placement.”。
Sample Input
6 8 .....#.# ##.....# ##.....# .......# #......# #..#...#
Sample Output
There are 5 ships.
#include <bits/stdc++.h>
using namespace std;
int n,m,ans,dx[4]={0,1,0,-1},dy[4]={1,0,-1,0},x,y,sx,sy;
char a[1001][1001];
bool c[1001][1001];
void dfs (int x,int y)
{
if (a[x][y]!='#') return ;
sx=max (sx,x);
sy=max (sy,y);
c[x][y]=true;
for (int i=0;i<4;i++)
if (x+dx[i]>0&&x+dx[i]<=n&&y+dy[i]<=m&&y+dy[i]>0&&!c[x+dx[i]][y+dy[i]])
dfs (x+dx[i],y+dy[i]);
}
int main ()
{
cin>>n>>m;
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++)
cin>>a[i][j];
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++)
if (a[i][j]=='#'&&!c[i][j])
{
sx=sy=0,ans++,dfs (i,j);
y=j;
x=i;
for (int k=x;k<=sx;k++)
for (int l=y;l<=sy;l++)
if (a[k][l]!='#')
{
cout<<"Bad placement.\n";
return 0;
}
}
cout<<"There are "<<ans<<" ships.\n";
return 0;
}I. 棋盘问题
Description
在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。
Input
每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋 子的数目。 n <= 8 , k <= n
随后的n行描述了棋盘的形状：每行有n个字符，其中 # 表示棋盘区域， . 表示空白区域（数据保证不出现多余的空白行或者空白列）。
Output
对于每一组数据，给出一行输出，输出摆放的方案数目C （数据保证C<2^31）
Sample Input
2 1 #. .# 4 4 ...# ..#. .#.. #...
Sample Output
2 1
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
char path[N][N];
int vis[N][N];//标记某个点是否放棋子
int n, k, ans = 0;
//检查该位置是否可以放棋子
bool check(int x, int y) {
//检查行和列
for (int i = 0; i < n; ++i) {
if (vis[i][y] == 1 || vis[x][i] == 1)
return false;
}
return true;
}
void dfs(int u, int sum) {
//方案可以
if (sum == 0) {
ans++;
return;
}
//当所搜索的行数大于棋盘行数时 直接返回
if (u >= n)
return;
//从当前行开始枚举
for (int row = u; row < n; row++) {
for (int i = 0; i < n; ++i) {
if (path[row][i] == '#' && check(row, i) && !vis[row][i]) {
//第u行第i列满足条件了，去搜下一行可以放棋子的位置
vis[row][i] = 1;
dfs(row + 1, sum - 1);
vis[row][i] = 0;
}
}
}
}
int main() {
while (true) {
cin >> n >> k;
if (n == -1 && k == -1)
break;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> path[i][j];
}
}
dfs(0, k);
cout << ans << endl;
//重置数据
ans = 0;
memset(vis, 0, sizeof(vis));
}
return 0;
}
J. 拯救行动
Description
公主被恶人抓走，被关押在牢房的某个地方。牢房用N*M (N, M <= 200)的矩阵来表示。矩阵中的每项可以代表道路（@）、墙壁（#）、和守卫（x）。
英勇的骑士（r）决定孤身一人去拯救公主（a）。我们假设拯救成功的表示是“骑士到达了公主所在的位置”。由于在通往公主所在位置的道路中可能遇到守卫，骑士一旦遇到守卫，必须杀死守卫才能继续前进。
现假设骑士可以向上、下、左、右四个方向移动，每移动一个位置需要1个单位时间，杀死一个守卫需要花费额外的1个单位时间。同时假设骑士足够强壮，有能力杀死所有的守卫。
给定牢房矩阵，公主、骑士和守卫在矩阵中的位置，请你计算拯救行动成功需要花费最短时间。
Input
1、两个整数代表N和M, (N, M <= 200).
2、随后N行，每行有M个字符。"@"代表道路，"a"代表公主，"r"代表骑士，"x"代表守卫, "#"代表墙壁。
Output
如果拯救行动成功，输出一个整数，表示行动的最短时间。
如果不可能成功，输出"Impossible"
Sample Input
7 8 #@#####@ #@a#@@r@ #@@#x@@@ @@#@@#@# #@@@##@@ @#@@@@@@ @@@@@@@@ 13 40 @x@@##x@#x@x#xxxx##@#x@x@@#x#@#x#@@x@#@x xx###x@x#@@##xx@@@#@x@@#x@xxx@@#x@#x@@x@ #@x#@x#x#@@##@@x#@xx#xxx@@x##@@@#@x@@x@x @##x@@@x#xx#@@#xxxx#@@x@x@#@x@@@x@#@#x@# @#xxxxx##@@x##x@xxx@@#x@x####@@@x#x##@#@ #xxx#@#x##xxxx@@#xx@@@x@xxx#@#xxx@x##### #x@xxxx#@x@@@@##@x#xx#xxx@#xx#@#####x#@x xx##@#@x##x##x#@x#@a#xx@##@#@##xx@#@@x@x x#x#@x@#x#@##@xrx@x#xxxx@##x##xx#@#x@xx@ #x@@#@###x##x@x#@@#@@x@x@@xx@@@@##@@x@@x x#xx@x###@xxx#@#x#@@###@#@##@x#@x@#@@#@@ #@#x@x#x#x###@x@@xxx####x@x##@x####xx#@x #x#@x#x######@@#x@#xxxx#xx@@@#xx#x#####@
Sample Output
13 7
#include <cstdio>
#include <queue>
//位置定义
struct POS {
int x, y;//坐标
int cost;//本节点到起点的距离
};
const int MAXN = 202;
struct MAZE {
int row, col;//迷宫大小
char data[MAXN][MAXN];//迷宫数据描述
bool visit[MAXN][MAXN];//是否已经访问过节点
int x1, y1;//起点坐标
int x2, y2;//终点坐标
};
int bfs(MAZE &maze);
int main() {
MAZE maze = {};//迷宫定义并将所有初始化为零
//读入迷宫长宽
scanf("%d %d", &maze.row, &maze.col);
//读入迷宫数据
int i,j;
for (i=0; i<maze.row; i++) {
for (j=0; j<maze.col; j++) {
scanf(" %c", &maze.data[i][j]);
if (maze.data[i][j]=='a') {
//终点
maze.x2 = i;
maze.y2 = j;
} else if (maze.data[i][j]=='r') {
//起点
maze.x1 = i;
maze.y1 = j;
}
}
}
int ans = bfs(maze);
if (ans>0) {
printf("%d\n", ans);
} else {
printf("Impossible\n");
}
return 0;
}
int bfs(MAZE &maze) {
std::queue<POS> q;//下一个节点队列
const POS move[] = {{-1,0}, {0,1}, {1,0}, {0,-1}};//骑士的移动方法
POS cur;//当前位置
POS next;//下一个位置
//加入起点
cur.x = maze.x1;
cur.y = maze.y1;
cur.cost = 0;
maze.visit[cur.x][cur.y] = true;//设置本节点已经访问
q.push(cur);
//开始遍历
while (!q.empty()) {
//弹出队首节点
cur = q.front();
q.pop();
if (maze.data[cur.x][cur.y]=='x') {
//由于有干掉守卫，所以我们我们先加入的不一定是最小的
maze.data[cur.x][cur.y]='@';
cur.cost++;
q.push(cur);
} else {
for (int i=0; i<4; i++) {
next.x = cur.x + move[i].x;
next.y = cur.y + move[i].y;
//判断是不是终点
if (next.x==maze.x2 && next.y==maze.y2) {
return cur.cost + 1;
}
//判断通过性
if (next.x>=0&&next.x<maze.row&&next.y>=0&&next.y<maze.col&&maze.visit[next.x][next.y]==false&&maze.data[next.x][next.y]!='#') {
next.cost = cur.cost + 1;
maze.visit[next.x][next.y] = true;
q.push(next);
}
}
}
}
return -1;
}
3167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
