castle problem——(深度优先搜索,递归实现和stack实现)

将问题的各状态之间的转移关系描述
为一个图,则深度优先搜索遍历整个图的
框架为:
Dfs(v) {
if( v 访问过)
return;
将v标记为访问过;
对和v相邻的每个点u: Dfs(u);
}
int main() {
while(在图中能找到未访问过的点 k)
Dfs(k);
}

4
例题:百练2815 城堡问题
? 右图是一个城堡的地形图
。请你编写一个程序,计
算城堡一共有多少房间,
最大的房间有多大。城堡
被分割成m×n(m≤50,
n≤50)个方块,每个方块可
以有0~4面墙。
5
输入输出
? 输入
? 程序从标准输入设备读入数据。
? 第一行是两个整数,分别是南北向、东西向的方块数。
? 在接下来的输入行里,每个方块用一个数字(0≤p≤50)描述。用一个数
字表示方块周围的墙, 1表示西墙, 2表示北墙, 4表示东墙, 8表示南
墙。 每个方块用代表其周围墙的数字之和表示。 城堡的内墙被计算两
次,方块(1,1)的南墙同时也是方块(2,1)的北墙。
? 输入的数据保证城堡至少有两个房间。
? 输出
? 城堡的房间数、城堡中最大房间所包括的方块数。
? 结果显示在标准输出设备上。
6
? 样例输入
4
7
11 6 11 6 3 10 6
7 9 6 13 5 15 5
1 10 12 7 13 7 5
13 11 10 8 10 12 13
? 样例输出
5 9
1表示西墙, 2表示北墙, 4表示东墙, 8表
示南墙。每个方块用代表其周围墙的数字之
和表示。
7
解题思路
? 对每一个 方块,深度优先搜索,从而给这个方
块能够到达的所有位置染色。最后统计一共用
了几种颜色,以及每种颜色的数量。
? 比如
1 1 2 2 3 3 3
1 1 1 2 3 4 3
1 1 1 5 3 5 3
1 5 5 5 5 5 3
? 从而一共有5个房间,最大的房间( 1)占据9
个格子
8

#include<iostream>
#include<string>
#include<stack>
using namespace std;

int R,C;//行数和列数
int rooms[60][60];//房间的标号(这里都是从1开始的)
int color[60][60];//标记房间是否染过色
int maxRoomArea = 0;//这里是指最大的房间面积(几个格子)
int	roomNum = 0;//房间号
int roomArea;//在一次深搜的过程中,所能达到面积(在渐变的一个变量)

//深搜的函数
void Dfs(int i,int k)
{
	if(color[i][k])
		return;
	++roomArea;
	color[i][k]=roomNum;
	if( (rooms[i][k] & 1) == 0 ) Dfs(i,k-1); //向西走
	if( (rooms[i][k] & 2) == 0 ) Dfs(i-1,k); //向北
	if( (rooms[i][k] & 4) == 0 ) Dfs(i,k+1); //向东
	if( (rooms[i][k] & 8) == 0 ) Dfs(i+1,k); //向南
}

int main()
{
	cin>>R>>C;
	for(int i=1;i<=1;i++)
		for(int k=1;k<=1;k++)
			cin>>rooms[i][k];
	memset(color,0,sizeof(color));
	for( int i = 1;i <= R; ++i)
		for( int k = 1; k <= C; ++ k)
		{
			if( !color[i][k] )
			{
				++roomNum ;
				roomArea = 0;
				Dfs(i,k);
				maxRoomArea = max(roomArea,maxRoomArea);
			}
		}
		cout << roomNum << endl;
		cout << maxRoomArea << endl;
	system("pause");
	return 1;
}

void Dfs(int r,int c) { //不用递归,用栈解决,程序其他部分不变
	struct Room {
		int r,c;
		Room(int rr,int cc):r(rr),c(cc) { }
	};
	stack<Room> stk;
	stk.push(Room(r,c));
	while ( !stk.empty() ) {
		Room rm = stk.top();
		int i = rm.r; int k = rm.c;
		if( color[i][k]) stk.pop();
		else {
			++ roomArea;
			color [i][k] = roomNum;
			if( (rooms[i][k] & 1) == 0 ) stk.push(Room(i,k-1)); //向西走
			if( (rooms[i][k] & 2) == 0 ) stk.push(Room(i-1,k)); //向北
			if( (rooms[i][k] & 4) == 0 ) stk.push(Room(i,k+1)); //向东
			if( (rooms[i][k] & 8) == 0 ) stk.push(Room(i+1,k)); //向南
		}
	}
}

  

时间: 2024-10-02 07:52:47

castle problem——(深度优先搜索,递归实现和stack实现)的相关文章

图的深度优先搜索 递归和非递归实现 c++版本

本文参考了李春葆版本的数据结构上机指导,但是原版是c代码, 本文用了c++实现,并且修复了深度优先搜索非递归的一个bug. graph.cpp文件: #include "graph.h" #include <queue> #include <stack> int visited[MAXV ]; MGraph ::MGraph(int A[100][10], int nn , int ee) { e= ee ; n= nn ; for (int i=0;i<

深度优先搜索入门:POJ1164城堡问题(递归、用栈模拟递归)

将问题的各状态之间的转移关系描述为一个图,则深度优先搜索遍历整个图的框架为:Dfs(v) {if( v 访问过)return;将v标记为访问过;对和v相邻的每个点u: Dfs(u);}int main() {while(在图中能找到未访问过的点 k) Dfs(k);} 例题: POJ1164 The Castle Description 1 2 3 4 5 6 7 ############################# 1 # | # | # | | # #####---#####---#-

图的深度优先搜索(DFS)简介与实现(递归与非递归方法)

上一篇刚刚学习了C++图的实现,今天对深度优先搜索(DFS)进行了一定学习,并作出一定实现.在本文中图的实现,以及相应的函数调用(如获得第一个邻接顶点.获得下一个邻接顶点等)均是基于上文中的实现,故如果想参考测试代码,还需导入上文中相应的类定义.关于C++图的实现可参考此处,这里实现了对图的邻接表以及邻接矩阵两种实现,而本文的深度优先搜索对于上面两种实现均是可行的. 当然,对于图的深度优先搜索的相关定义,本文也不再过多赘述,维基的解释应该就足够,下面将探讨其实现. 1.深度优先搜索的非递归实现:

图论 深度优先搜索 广度优先搜索的非递归实现

深度优先遍历 1.深度优先遍历的递归定义 假设给定图G的初态是所有顶点均未曾访问过.在G中任选一顶点v为初始出发点(源点),则深度优先遍历可定义如下:首先访问出发点v,并将其标记为已访问过:然后依次从v出发搜索v的每个邻接点w.若w未曾访问过,则以w为新的出发点继续进行深度优先遍历,直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止.若此时图中仍有未访问的顶点,则另选一个尚未访问的顶点作为新的源点重复上述过程,直至图中所有顶点均已被访问为止. 图的深度优先遍历类似于树的

[ACM] 1016 Prime Ring Problem (深度优先搜索)

Prime Ring Problem Problem Description A ring is compose of n circles as shown in diagram. Put natural number 1, 2, ..., n into each circle separately, and the sum of numbers in two adjacent circles should be a prime. Note: the number of first circle

迷宫寻址中深度优先搜索的递归和非递归算法比较

巧若拙(欢迎转载,但请注明出处:http://blog.csdn.net/qiaoruozhuo) 本文只探究迷宫寻址中深度优先搜索的递归和非递归算法比较,其他相关代码详见<迷宫问题(巧若拙)>http://blog.csdn.net/qiaoruozhuo/article/details/41020745 深度优先搜索的递归算法是很容易实现的,只需设置一个驱动函数,然后递归调用子函数就可以了. 代码如下: int DeepSearchWay()//寻找路径:深度搜索 { CopyMiGong

Windows C++ 非递归式(stack)深度优先遍历目录

1 #include <Windows.h> 2 #include <cstdio> 3 #include <cstring> 4 #include <string> 5 #include <stack> 6 7 typedef void (__stdcall *P_WALK_DIR_CALLBACK)(const std::string &In_strFilePath); 8 9 int WalkDir(const char *In_p

递归之深度优先搜索

递归的思想在写程序中运用较为广泛,看视很复杂的问题,通常通过递归思想找出"递归结构",分解成重复的小步骤即可解决,但是递归的思想有时并不好理解(大佬,悟性高的忽略).本文通过介绍全排序例子介绍递归思想,最后给出前一次博客写的"坑爹的奥数"问题进行递归优化,给出执行时间. 一.问题描述:假如有编号为1.2.3的3张扑克牌和编号为1.2.3的3个盒子.现在需要将这3张扑克牌分别放到3个盒子里面,并且每个盒子有且只有一张扑克牌.那么一共有多少种不同的放法呢? 当有n个数字

深度优先搜索(DFS)

定义: (维基百科:https://en.wikipedia.org/wiki/Depth-first_search) 深度优先搜索算法(Depth-First-Search),是搜索算法的一种.是沿着树的深度遍历树的节点,尽可能深的搜索树的分支.当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点.这一过程一直进行到已发现从源节点可达的所有节点为止.如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止(属于盲目搜索). 基