ACM深度优先搜索DFS

预备知识

先根遍历

根 —> 左子树 —> 右子树，左子树中任何一个元素都比右子树靠前。

下图中：2 7 1 6 5 3 8 9 4

中根遍历

左子树 —> 根  —> 右子树。

下图中：1 7 5 6 3 2 8 4 9

后根遍历

左子树 —> 右子树 —> 根。

下图中：1 5 3 6 7 4 9 8 2

eg. 一棵二叉树

注意： 

1. 给定先根、中根遍历结果，可以唯一缺点一棵二叉树。
2. 给定中根、后根遍历结果，可以唯一缺点一棵二叉树。
3. 给定先根、后根遍历结果，不可以唯一缺点一棵二叉树。

---

基本模型

解决“当下应该如何做”，下一步只需要改变参数即可。（感觉没有开始做就结束了）

void dfs(int step)
{
    特殊情况处理（一般用来结束递归）
    枚举当前每一种可能 for(int i = 1; i <= n; i++)
        在枚举的每一种可能中，递归调用dfs(step+1)
}

---

经典例题

输出前n个正整数的全排列（递归）

        解：转化为子问题（假如前k个数已经排好，那么剩下的问题就是其余k-1个数的全排列）。枚举每个位上的可能。

#include <cstdio>
#include <cstring>
using namespace std;

int n, num[10], visit[10];    //num[]保存全排列结果，visit[]标记每次递归该数字有没有用过
void dfs(int);

int main()
{
	while(~scanf("%d", &n))
	{
		memset(visit, 0, sizeof(visit));
		dfs(1);
	}
	return 0;
}

void dfs(int step)    //接下来准备填第step个数字
{
    //递归先处理特殊情况（末状态）
	if(step == n+1)
	{
		for(int i = 1; i <= n; i++)
			printf("%d ", num[i]);
		printf("\n");
		return;
	}
	for(int i = 1; i <= n; i++)
	{
		if(visit[i] == 0)
		{
			num[step] = i;
			visit[i] = 1;
			dfs(step+1);
            
			visit[i] = 0;    //回溯
		}
	}
}

        注意：理解“回溯”操作十分重要。每次递归调用结束之后随着进行到下一个数字，都把上一个数组在标记数组中对应的位置变成0，所以在下一步才可以使用这一个数字。

走迷宫（只能刚刚好到出口处才行）

        解：剪枝：可走的步数小于时间、奇偶性。考虑每一步该怎么走（往除了墙或是已经走过的路的四个方向上走）。

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;

int N, M, T, startx, starty, targetx, targety;
char map[8][8];
bool escape;
int moves[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};    //四个方向
void dfs(int, int, int);

int main()
{
	while(cin >> N >> M >> T)
	{
		if(N == 0 && M == 0 && T == 0) break;
		int roadNum = 0;
		for(int i = 1; i <= N; i++)
			for(int j = 1; j <= M; j++)
			{
				char temp;
				cin >> temp;
				if(temp == 'S')
				{
					startx = i;
					starty = j;
				}
				else if(temp == 'D')
				{
					targetx = i;
					targety = j;
				}
				else if(temp == '.')
					roadNum++;
				map[i][j] = temp;
			}
		if(roadNum+1 < T || (abs(startx-targetx)+abs(starty-targety)) % 2 != T%2)		//通过距离和奇偶性剪枝
		{
			printf("NO\n");
			continue;
		}
		escape = 0;
		map[startx][starty] = 'X';
		dfs(startx, starty, 0);
		if(escape)
			printf("YES\n");
		else
			printf("NO\n");
	}
	return 0;
}

void dfs(int x, int y, int time)
{
	if(x > N || y > M || x < 1 || y < 1) return;
	if(x == targetx && y == targety && time == T)
		escape = 1;
	if(escape) return;
	if(T-time < abs(targetx-x) + abs(targety-y))	//通过剩余的距离和时间剪枝
		return;
	for(int i = 0; i < 4; i++)
	{
		if(map[x+moves[i][0]][y+moves[i][1]] != 'X')
		{
			map[x+moves[i][0]][y+moves[i][1]] = 'X';
			dfs(x+moves[i][0], y+moves[i][1], time+1);
			map[x+moves[i][0]][y+moves[i][1]] = '.';    //回溯，此时说明前面的情况都走不通
		}
	}
	return;
}