深度优先遍历的栈实现

——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 4000 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.
}