DFS走迷宫

BFS走出的是一条最短路径，DFS走出的不一定是最短路径。只要把前面的BFS代码稍作修改，改成递归的形式即可。BFS使用的队列的数据结构来存储中间结果，DFS使用的是栈，因此DFS使用递归的形式。

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<string.h>

#define MAXLEN  100

int edge_to[MAXLEN];
int maze[MAXLEN][MAXLEN];
bool visited[MAXLEN][MAXLEN];   // 0 UN-VISITED, 1 VISITED
char str[MAXLEN];
int source = 0;
int goal = 0;
int row, col;

void scanf_maze()
{
    int j, i;

    if(scanf("%d %d", &row, &col) == 2)
    {
        if(row <= 0 || col <= 0)
            return;
        for(i = 1; i <= row; i++)
        {
            scanf("%s", str);
            for(j = 1; j <= col; j++)
            {
                // find the source and the goal;
                if(str[j -1] == 's')
                    source = (i - 1) * col + j;
                else if(str[j - 1] == 'g')
                    goal = (i - 1) * col + j;

                maze[i][j] = str[j-1] - '0';
            }
        }
    }
    
//    for(i = 0; i < row + 2; i++)
//    {
//        for(j = 0; j < col + 2; j ++)
//            printf("%d ", maze[i][j]);
//        putchar('\n');
//    }
}
// return the adjcent vertex satisfied the condition:
// not been visited and not a varrier(a passage).
inline int row_(int num)
{
    return (num / col) + 1;
}
inline int col_(int num)
{
    if(((num % col) == 0) && num != 0)
        return col;
    return num % col;
}
int adj(int cur_vertex, int adj)
{
    switch(adj) // adj = 0 the one upper; adj = 1 the one left; adj = 2 the one right; adj =3 the one down
    {
        case 3: if(maze[row_(cur_vertex)-1][col_(cur_vertex)] && !visited[row_(cur_vertex)-1][col_(cur_vertex)]) return (cur_vertex - col);break;
        case 2: if(maze[row_(cur_vertex)][col_(cur_vertex)-1] && !visited[row_(cur_vertex)][col_(cur_vertex)-1]) return (cur_vertex - 1);break;
        case 1: if(maze[row_(cur_vertex)][col_(cur_vertex)+1] && !visited[row_(cur_vertex)][col_(cur_vertex)+1]) return (cur_vertex + 1);break;
        case 0: if(maze[row_(cur_vertex)+1][col_(cur_vertex)] && !visited[row_(cur_vertex)+1][col_(cur_vertex)]) return (cur_vertex + col);break;
        default: break;
    }
    return -1;
}
void dfs(int vertex)
{
    int i, result;
    
    visited[row_(vertex)][col_(vertex)] = 1;    //mark the current vertex which has been visited 

    for(i = 0; i < 4; i++)
    {
        if((result = adj(vertex, i)) >= 0)
        {
            edge_to[result] = vertex;// its parent node
            visited[row_(result)][col_(result)] = 1;
            dfs(result);    // put the vertex has been visited on the stack
            // the end conditon of the recursion is that if statements all break up.
        }
    }
}
void path_to(int goal_)
{
    if(edge_to[goal_] == source)
    {
        printf("%d-%d", source, goal_);
        return;
    }

    path_to(edge_to[goal_]);
    printf("-%d", goal_);
}
int main()
{ 
    memset(edge_to, 0, sizeof(edge_to));
    //memset(maze, 1, MAXLEN * MAXLEN * sizeof(int));   // 1 is the passage, 0 is the barriar
    memset(maze, 0, sizeof(maze));
    memset(str, 0, MAXLEN);
    memset(visited, 0, sizeof(visited));

    scanf_maze(); 
    dfs(source);
    path_to(goal);
    
    putchar('\n');
    return 0;
}

这里的修改分成两个部分，第一次把队列去掉，使用递归，发现找出路的结果跟BFS相同，这是因为DFS在找到相邻的顶点后会把该顶点入栈，因此哪个顶点先入栈决定了找到的是那条路径，因此为了与BFS做区别，把找顶点的函数adj()里边的顺序有原来的上、左、右、下变成了下、右、上、左，这样的话路径明显变长了，结果如下：

6 5
s101g
10111
10100
10111
11101
11111
1-6-11-16-21-26-27-28-29-30-25-20-15-14-19-18-13-8-9-4-5

迷宫跟BFS相同，找到的路径明显变长了，这同时也就说明了DFS找到的不一定是最短的路径。

但是这里怎么出现了14,15，额额额，汗，等会儿处理。

先画一下这里的栈的情况吧。先入栈的是S就是编号为1的顶点，这里到18的时候会有一点变化，其他情况大致相同：

也就是23,22（因为18会先检查下面的23而不是上面的13）会有出栈的过程，最终找到出口。但是为什么14,15会冒出来呢？？

BUG:

这里的输出其实是有误的，太惨了正确的输出是：

6 5
s101g
10111
10100
10111
11101
11111
1-6-11-16-21-26-27-28-29-30-25-20-19-18-13-8-9- 10-5

原因是在坐标处理时的一个bug（在row_()函数中），在每一行的结尾的处理是和行中的其它元素不同的，正确的处理方式是：

 49 inline int row_(int num)
 50 {
 51     if((num % col) == 0)
 52         return num / col;
 53     return (num / col) + 1;
 54 }

增加了一个if语句，输出就对了，同时输出的路径也变了上面的图上应该走的是10，不走4。不在传图了。