深度优先算法

深度优先算法核心思想

需求： 以上是一张图，求1号节点到5号节点的最短路径。

节点之间有边则可以走，如果没有则不能，例如：从1号节点可以到2号节点，路径为2。从1号节点不能直接到3号节点

分析：
为了求得最短路径，我们需要将所有从1号顶点到5号节点的可能情况遍历一遍。首先我们从1号顶点开始尝试访问未走到过的顶点，此时发现2号顶点没有走过，于是来到了2号顶点。再从2号顶点开始尝试访问未走到过的顶点，此时发现3号顶点没有走过，于是来到了3号顶点。以此类推最后可以到达5号顶点，此时完成一次遍历切将路径长度（14）记录下来。接着我们需要返回到4号顶点，从4号顶点接着尝试未被访问过的顶点，此时需要退回到3号顶点，以此类推，当我们退回到2号顶点，接着尝试未被访问过的顶点，尝试访问4号顶点，此时发现无法从2号顶点走到4号顶点，所以回退到2号顶点，接着尝试5号顶点，发现可以到达，此时又完成一次遍历，将路径长度（9）记录下来。以此类推，直到尝试过所有顶点。

总结： 深度优先算法的核心思想就是：从一个未被访问过的顶点开始，沿当前顶点边走到未被访问过的顶点，当没有未被访问过的顶点时，则返回上一个顶点，继续试探访问别的顶点，直到所有顶点都被访问过。

深度优先算法基本模型

  void dfs (int step) {
   判断边界
   尝试每一种可能 for (int i > = 0; i <= n; i++) {  
   继续下一步 dfs(step + 1);
  }
}

代码实现：

---

int[][] arrs = new int[5][5];
int top = 4; //最后要到达的顶点为4号顶点
int minDistance = 999; //初始化最小路径
int[] book = new int[5]; //用于记录已经走过的节点

/**
 * 初始化数组
 *
 */
private void initArrs() {

    for (int i = 0; i <= 4; i++) {
        for (int j = 0; j <= 4; j++) {

            //每个顶点不能自己到达自己，例如从1号顶点到1号定点的路径为0
            if (i == j) {
                arrs[i][j] = 0;
                continue;
            }

            //设置0号定点可以到达的点以及路径，如果不能到达则路径为999
            if (i == 0) {
                if (j == 1) {
                    arrs[i][j] = 2;
                } else if (j == 4) {
                    arrs[i][j] = 10;
                } else {
                    arrs[i][j] =999;
                }
            }

            //设置1号定点可以到达的点以及路径，如果不能到达则路径为999
            if (i == 1) {
                if (j == 2) {
                    arrs[i][j] = 3;
                } else if (j == 4) {
                    arrs[i][j] = 7;
                } else {
                    arrs[i][j] =999;
                }
            }

            //设置2号定点可以到达的点以及路径，如果不能到达则路径为999
            if (i == 2) {
                if (j == 0) {
                    arrs[i][j] = 4;
                } else if (j == 3) {
                    arrs[i][j] = 4;
                } else {
                    arrs[i][j] =999;
                }
            }

            //设置3号定点可以到达的点以及路径，如果不能到达则路径为999
            if (i == 3) {
                if (j == 4) {
                    arrs[i][j] = 5;
                } else {
                    arrs[i][j] =999;
                }
            }

            //设置4号定点可以到达的点以及路径，如果不能到达则路径为999
            if (i == 4) {
                if (j == 2) {
                    arrs[i][j] = 3;
                } else {
                    arrs[i][j] =999;
                }
            }
        }

    }
}

/**
 * 算法核心
 * @param currentNode
 * @param distance
 */
private void dfs(int currentNode, int distance) {

    if (distance > minDistance) {
        return;
    }

    if (currentNode == top) {
        if (distance < minDistance) {
            minDistance = distance;
        }

        //输出走过的路径
        for (int i = 0; i <= 4; i++) {
            if (book[i] == 1) {
                System.out.print(i + " ");
            }
        }
        System.out.println();

        return;
    }

    for (int i = 0; i <= 4; i++) {
        if (arrs[currentNode][i] != 999 && arrs[currentNode][i] != 0 && book[i] == 0) {
            book[i] = 1;
            dfs(i, distance + arrs[currentNode][i]);
            book[i] = 0;
        }
    }
}

@Test
public void testDeepSearch() {
    initArrs();
    for (int i = 0; i <= 4; i++) {
        for (int j = 0; j <= 4; j++) {
            System.out.print(arrs[i][j]+"      ");
        }
        System.out.println("");
    }
    book[0] = 1;
    dfs(0, 0);
    System.out.println(minDistance);
}