深度优先遍历的栈实现

最新推荐文章于 2024-09-28 23:00:16 发布
最新推荐文章于 2024-09-28 23:00:16 发布
阅读量1.7k 收藏 4
点赞数
分类专栏： 提高效率 文章标签： 深度优先遍历 栈 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Irene_syz/article/details/50821736
版权

——PickingupJewels

捡珠宝是典型的需要回溯的深度优先遍历，它要求找出能获得最多珠宝的路径，并且将该路径输出。

         这个题比较难的两点是怎么不走环路和怎么回溯。回溯相对简单一点，就是出栈以后，你要将它置为未访问过，不用担心重复走它，因为还有方向控制前进的方向。

而对于环路，一开始想得很苦恼，没明白，多设了很多条件，后来还是在老大的帮助下，想通了其实不重复进栈就不会走环路，因为栈内的点是刚走过的路。

void DFS(Node* start, Node* end) {
	int dx,dy;
	int i;
	Node* n = start;
	n->dir = 0;  // 入栈则将方向置为0
	push(start);  // 将起始点入栈
	jewels_num = 0; // 珠宝数
	Node* tmp;  // 取栈顶元素
	if(start->value == 2) jewels_num++;   //如果起点是珠宝，则珠宝数++
	if(end->value == 2) jewels_num++;   //如果终点是珠宝，则珠宝数++
	while(!isEmpty()) {   // 如果栈不为空
		tmp = getTop();   // 取栈顶节点
		for(i=tmp->dir; i<4; i++) {   // 将方向置为栈顶元素的方向
			tmp->dir++;  // 栈顶元素方向++，表明走过一个方向（进栈为0，当dir为4时则表明该点4个方向已遍历）
			dx = tmp->x + DIR[i][0];
			dy = tmp->y + DIR[i][1];
			if(dx == end->x && dy == end->y) {  // 如找到终点
				if(jewels_num>Answer) {   // 判断当前路径找的珠宝数是否比已保存的数要多
					Answer =  jewels_num;  //  始终保存最大的珠宝数
					saveCurrentPath();  // 并存储该路径
				}
#ifdef TEST
				cout<<"find end! jewels_num is "<<jewels_num<<endl;	
#endif
				continue;  // 终点不入栈，其实入栈也行，反正马上就要出栈
			}
			// 1为墙，0为路，2为珠宝。判断map[dx][dy].dir == -1则可保证栈内的元素不会被重复入栈，即不走环路
			if(dx>=0 && dx<N && dy>=0 && dy<N && map[dx][dy].value != 1 && map[dx][dy].dir == -1) {
				n = &map[dx][dy];  // 指针指向当前判断点
				if(n->value == 2) jewels_num++;   // 如果是珠宝，则珠宝数++
				n->dir = 0;  // 将方向置为0
				push(n);  // 进栈
				break;  // 不再遍历当前节点
			}
		}
		if(i==4) {  // 当前节点4个方向都走完了
			n = pop();  // 当前节点出栈
			n->dir = -1;  // 并且标记为未访问过，回溯
			if(n->value == 2) jewels_num--;   // 如果当前节点为珠宝，则珠宝数--
		}
	}
}

行走的路线是：

1

5

0 0 0 2 0

2 1 0 1 2

0 0 2 2 0

0 1 0 1 2

2 0 0 0 0

-----------------N=5

3 3 3 3 3

2 1 0 1 3

0 0 2 2 3

0 1 0 1 3

2 0 0 0 3

find end! jewels_num is 3

-----------------N=5

3 3 3 3 3

2 1 0 1 3

0 0 3 3 3

0 1 3 1 2

2 0 3 3 3

find end! jewels_num is 4

-----------------N=5

3 3 3 3 3

2 1 0 1 3

3 3 3 3 3

3 1 0 1 2

3 3 3 3 3

find end! jewels_num is 5

find end! jewels_num is 3

find end! jewels_num is 1

find end! jewels_num is 2

find end! jewels_num is 4

find end! jewels_num is 2

find end! jewels_num is 5

find end! jewels_num is 2

find end! jewels_num is 5

…(find way, but not saved)

-----------------N=5

3 0 3 3 3

3 1 3 1 3

3 0 3 2 3

3 1 3 1 3

3 3 3 0 3

find end! jewels_num is 6

所以，最后输出的是

Case #1

3 0 3 3 3

3 1 3 1 3

3 0 3 2 3

3 1 3 1 3

3 3 3 0 3

6

本题中栈是用指针来实现的

typedef struct {
	int x;
	int y;
	int value;
	int dir;
}Node;
Node map[MAX][MAX];
int resultMap[MAX][MAX];

typedef struct{
	Node* data[SLENGTH];
	int top;
}Stack;
Stack s;

栈的方法主要有栈空、栈满、入栈、出栈、取栈顶节点、初始化

就不分开说了，贴个全的代码吧。 


#include <iostream>

using namespace std;
//#define TEST
//#define S_LOG
#define MAX 12
#define SLENGTH 1000
int DIR[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
int N;
int Answer;
int jewels_num;
int path_n = 3;

typedef struct {
	int x;
	int y;
	int value;
	int dir;
}Node;
Node map[MAX][MAX];
int resultMap[MAX][MAX];

typedef struct{
	Node* data[SLENGTH];
	int top;
}Stack;
Stack s;

bool isEmpty(){
	if(s.top == 0) {
		return true;
	} else {
		return false;
	}
}

bool isFull(){
	if(s.top >= SLENGTH) {
		return true;
	} else {
		return false;
	}
}

void push(Node* n) {
#ifdef S_LOG
	cout<<"push "<<n->x<<","<<n->y<<endl;				
#endif
	if(!isFull()) {
		s.data[++s.top] = n;
	} else {
#ifdef S_LOG
		cout<<"Stack is full"<<endl;
#endif
	}
}

Node* getTop() {
	Node* n = s.data[s.top];
	return n;
}

Node* pop() {
	Node* n = s.data[s.top];
	if(!isEmpty()) {
		s.top--;
#ifdef S_LOG
	cout<<"pop "<<n->x<<","<<n->y<<endl;				
#endif
	} else {
#ifdef S_LOG
		cout<<"Stack is Empty"<<endl;
#endif
	}
	return n;
}

void init() {
	s.top = 0;
}

void printMap() {
	int i,j;
	for(i=0; i<N; i++) {
		for(j=0; j<N; j++) {
			cout<<map[i][j].value<<" ";
		}
		cout<<endl;
	}
}

void printRMap() {
	int i,j;
	for(i=0; i<N; i++) {
		for(j=0; j<N; j++) {
			cout<<resultMap[i][j]<<" ";
		}
		cout<<endl;
	}
}

// 构建用于输出的数组。
void resetMap() {
	int i,j;
	for(i=0; i<N; i++) {
		for(j=0; j<N; j++) {
			if(resultMap[i][j] == path_n) {
				resultMap[i][j] = 3;
			} else {
				resultMap[i][j] = map[i][j].value;
			}
		}
	}
	resultMap[N-1][N-1] = 3;
	printRMap();
}

// 存储当前路径的方法
void saveCurrentPath(){	
	path_n++;
	int stop = s.top;
	int dx,dy;
	while(stop>0) {
		dx = s.data[stop]->x;
		dy = s.data[stop]->y;
		resultMap[dx][dy] = path_n;
		stop--;
	}
	resetMap();  // 由于resultMap一直都在赋值，因此需要保证它除了本路径以外没有走过的痕迹，因此要reset。
}

void DFS(Node* start, Node* end) {
	int dx,dy;
	int i;
	Node* n = start;
	n->dir = 0;  // 入栈则将方向置为0
	push(start);  // 将起始点入栈
	jewels_num = 0; // 珠宝数
	Node* tmp;  // 取栈顶元素
	if(start->value == 2) jewels_num++;   //如果起点是珠宝，则珠宝数++
	if(end->value == 2) jewels_num++;   //如果终点是珠宝，则珠宝数++
	while(!isEmpty()) {   // 如果栈不为空
		tmp = getTop();   // 取栈顶节点
		for(i=tmp->dir; i<4; i++) {   // 将方向置为栈顶元素的方向
			tmp->dir++;  // 栈顶元素方向++，表明走过一个方向（进栈为0，当dir为4时则表明该点4个方向已遍历）
			dx = tmp->x + DIR[i][0];
			dy = tmp->y + DIR[i][1];
			if(dx == end->x && dy == end->y) {  // 如找到终点
				if(jewels_num>Answer) {   // 判断当前路径找的珠宝数是否比已保存的数要多
					Answer =  jewels_num;  //  始终保存最大的珠宝数
					saveCurrentPath();  // 并存储该路径
				}
#ifdef TEST
				cout<<"find end! jewels_num is "<<jewels_num<<endl;	
#endif
				continue;  // 终点不入栈，其实入栈也行，反正马上就要出栈
			}
			// 1为墙，0为路，2为珠宝。判断map[dx][dy].dir == -1则可保证栈内的元素不会被重复入栈，即不走环路
			if(dx>=0 && dx<N && dy>=0 && dy<N && map[dx][dy].value != 1 && map[dx][dy].dir == -1) {
				n = &map[dx][dy];  // 指针指向当前判断点
				if(n->value == 2) jewels_num++;   // 如果是珠宝，则珠宝数++
				n->dir = 0;  // 将方向置为0
				push(n);  // 进栈
				break;  // 不再遍历当前节点
			}
		}
		if(i==4) {  // 当前节点4个方向都走完了
			n = pop();  // 当前节点出栈
			n->dir = -1;  // 并且标记为未访问过，回溯
			if(n->value == 2) jewels_num--;   // 如果当前节点为珠宝，则珠宝数--
		}
	}
}

void clearMap() {
	int i,j;
	for(i=0; i<N; i++) {
		for(j=0; j<N; j++) {
			resultMap[i][j] = 0;
			map[i][j].dir = -1;
			map[i][j].value = 0;
		}
	}
}

int main(int argc, char** argv)
{
	int T, test_case;
	int i,j;

	freopen("input.txt", "r", stdin);

	cin >> T;
	for(test_case = 0; test_case  < T; test_case++)
	{
		cin>>N;
		init();
		Answer = 0;
		for(i=0; i<N; i++) {
			for(j=0; j<N; j++) {
				map[i][j].x = i;
				map[i][j].y = j;
				cin>>map[i][j].value;
				resultMap[i][j] = map[i][j].value;
				map[i][j].dir = -1;
			}
		}
#ifdef TEST
		printMap();
#endif
		DFS(&map[0][0],&map[N-1][N-1]);
		// Print the answer to standard output(screen).
		cout << "Case #" << test_case+1 << endl;
		printRMap();
		cout << Answer << endl;
		clearMap();
	}

	return 0;//Your program should return 0 on normal termination.
}




洺优
关注
专栏目录
图深度优先遍历（递归和栈实现）
Brave master的专栏
08-07 1万+
/* depth-first traversal * two methods: recursive and non-recursive * Graph is stored in an adjacency matrix */ #include #include #define MAX 10 int sp = 0;//stack pointer int stack[MAX]; /***
基于Java的深度优先遍历（DFS）和广度优先遍历（BFS）
Robin的博客
12-08 3174
什么是深度/广度优先遍历(DFS/BFS)？ 深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。
图的深度优先遍历(堆栈实现和非堆栈实现)
软件开发资料汇总
01-03 471
// Chart.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include "stdlib.h"//如:FROMHEAD = 1，则用头插法;否则:则用尾插法#define  FROMHEAD 1/* 如:HASHEAD 被定义，则各顶点的邻接点链中; 否则:各顶点的邻接点链中;*
【图计算算法‌】深度优先搜索（DFS）算法
最新发布
大雨淅淅的博客
09-28 1557
深度优先搜索算法（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。该算法沿着树的深度遍历树的节点，尽可能深地搜索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点，这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为新的源节点并重复以上过程，直到所有节点都被访问为止。
数据结构基础（栈）——图的深度优先遍历（C语言实现）
weixin_45860066的博客
02-18 3926
题目描述 读入一个邻接矩阵存储的无向图，输出它的深度优先遍历序列。 输入格式 第１行１个整数n,表示图中的顶点数，2<=n<=100 接下来的n行是一个n*n的邻接矩阵，a[i][j]=1表示顶点i和顶点j之间有直接边相连，a[i][j]=0表示没有直接边相连，保证i=k时a[i][j]=0,且a[i,j]=a[j,i]. 输出格式 输出1~n的某一种排列，表示从顶点１开始，对该图进...
利用栈和队列实现图的深度优先遍历与广度优先遍历
ssmbyss的博客
06-07 4362
利用栈和队列实现图的深度优先遍历与广度优先遍历 结果： 深度优先遍历 [A, F, G, E, H, D, I, C, B] 广度优先遍历 [A, B, F, C, G, I, E, D, H] import java.util.*; public class Test3 { // 深度 public void DFS(HashMap<String, String> map, String startNode) { // 定义一个访问数组，判断当前节点是否访问过 A
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
在这个版本中，我们使用栈（stack）来存储待访问的节点，先处理栈顶的节点，然后将其子节点入栈，这样就能实现深度优先遍历。 2. **广度优先遍历**： 广度优先遍历从根节点开始，逐层访问所有节点。首先访问所有...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
在计算机科学中，图是一种数据结构，用于表示对象之间的关系，可以用来建模现实世界中的各种复杂系统。...通过阅读和分析这些代码，可以更深入地理解非递归算法在深度优先遍历和广度优先遍历中的具体实现。
javascript通过递归和栈实现树深度优先遍历和广度优先遍历
03-15
javascript通过递归和栈实现树深度优先遍历和广度优先遍历
图的深度优先遍历与广度优先遍历(C语言实现)
10-17
数据结构中的图结构，其中最重要的两个遍历算法——深度优先遍历与广度优先遍历
利用栈的基本操作编写，按深度优先搜索策略遍历一个强连通图的非递归形式的算法
05-29
7.24③ 试利用栈的基本操作编写，按深度优先搜索策略 遍历一个强连通图的非递归形式的算法。算法中不规定具 体的存储结构，而将图Graph看成是一种抽象的数据类型。
利用栈实现深度优先遍历
RunWithSmile的博客
12-26 3805
利用递归加栈实现深度优先遍历算法
数据结构——深度优先遍历（栈）
m0_61635175的博客
09-19 2046
数据结构——深度优先遍历（栈）
栈实现深度优先遍历_非递归
Multi-Agent_DRL
11-03 1404
#include<stdio.h> #include<stack> #define MAX 100 using namespace std; typedef struct { int e[MAX][MAX]; int ves; int edge; int book[MAX];//标志判断是否有被访问过 }MGraph; void createMGraph(MGraph *G) { int i; int j; int sta
栈 深度优先搜索（DFS）
weixin_45799833的博客
07-16 1008
数据结构 推演出的深度优先搜索
图的深度优先遍历[非堆栈、堆栈实现]
软件开发资料汇总
01-03 241
/**//*    标题：<<系统设计师>>应试编程实例-[图程序设计]    作者：成晓旭    时间：2002年09月06日(16:30:00-17:16:00)          完成图的创建函数、顺序遍历函数    时间
浅谈图的深层优先和广度优先遍历（栈实现，循环内层嵌套递归实现）（c++）
NikOHvH的博客
05-12 1253
最近刚好学到了图的深层优先遍历（DFS），发现了一些误区，比如“Skiena'sAlgorithm Design Manual第169页; Jeff Edmonds'How to Think about Algorithms, 第175–178页; Gilberg and ForouzanData Structures: A Pseudocode Approach Using C, 第497页。” 包括维基百科中也出现了同样的错误，也就是直接将广度优先遍历（BFS）中的queue直接替换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值