DFS深度搜索算法

首先是dfs算法的基础思想，在一个元素全是零的整形数组中，按照右下左上的优先级进行填充，从左上角开始依次填充阿拉伯数字

代码示例：
//DFS深度优先搜索算法
//说白了，一条路走到底，不撞南墙不回头

include<bits/stdc++.h>

int a[10][10];
void f(int x,int y,int k)
{
a[x][y]=k;
if(y+1<=4&&a[x][y+1]0)
{
f(x,y+1,k+1);
}
else if(x+1<=4&&a[x+1][y]0)
{
f(x+1,y,k+1);
}
else if(y-1>=1&&a[x][y-1]0)
{
f(x,y-1,k+1);
}
else if(x-1>=1&&a[x-1][y]0)
{
f(x-1,y,k+1);
}
else
return;
}

int main()
{
f(1,1,1);
for(int i=1;i<=4;i++)
{
for(int j=1;j<=4;j++)
{
cout<<setw(5)<<a[i][j]<<" ";
}
cout<<endl;
}
system("pause");
return 0;
}

输出：
1 2 3 4
16 15 14 5
11 12 13 6
10 9 8 7

这就是基础思路：按照某种顺序来实现按照某种路径走完全全程

接下来是进阶算法：
数组中是1的位置不能走，只能走0的位置，找出一条路径即可，行走优先级右下左上

代码实现：
//在这个函数中，xy记录迷宫二维数组中数的位置，k代表路径二维数组中的数的位置
int n;
char a[30][30]; //不要用int类型的数组，否则会将数组中的所有数字全部初始化成0
int path[410][3]; //路径二维数组

void print(int k)
{
for(int i=1;i<k;i++)
{
cout<<"("<<path[i][1]<<","<<path[i][2]<<")";
if(i!=k-1){
cout<<"->";
}
}
exit(0);
}
void dfs(int x,int y,int k)
{
path[k][1]=x;
path[k][2]=y;
a[x][y]='1'; //给走过的路径进行标记，防止重复通过
if(xn&&yn)
{
print(k);
}
if(a[x][y-1]'0') dfs(x,y-1,k+1);
if(a[x-1][y]'0') dfs(x-1,y,k+1);
if(a[x][y+1]'0') dfs(x,y+1,k+1);
if(a[x+1][y]'0') dfs(x+1,y,k+1);
}

int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
cin>>a[i][j];
}
}
dfs(1,1,1);
return 0;
}

这串代码的最不能理解的地方在于递归算法如归遇到了死胡同会自动回退到上一次的递归并执行下一行代码，直到找到可以通行的代码为止，而在dfs函数中用于递归的顺序刚好就可以实现这一点，所以测试就有：
输入：
4
0 0 0 1
0 0 0 0
0 1 1 0
0 1 1 0

输出：
(1,1)->(1,2)->(1,3)->(2,3)->(2,4)->(3,4)->(4,4)

烧脑的要死，所以说学计算机的头发掉得快呢...