【算法-广度优先遍历（WFS Width-First Searching）- 最短路径 】

广度优先搜索（WFS Width-First Searching）

GitHub代码: BFSShortestPath.java

总结

• WFS，数据结构采用 Queue
  • enqueue 输入init 节点
  • dequeue 就是 出栈，并加入其 子节点
• DFS宽度优先，数据结构就是 Stack
  • 递归自带Stack效果，所以可递归

代码

引用地址

package _07._07;

import java.util.Vector;
import java.util.Stack;
import java.util.LinkedList;
import java.util.Queue;

public class ShortestPath {

    private Graph G;   // 图的引用
    private int s;     // 起始点
    private boolean[] visited;  // 记录dfs的过程中节点是否被访问
    private int[] from;         // 记录路径, from[i]表示查找的路径上i的上一个节点
    private int[] ord;          // 记录每个节点到 s 的距离


    // 构造函数, 寻路算法, 寻找图graph从s点到其他点的路径
    public ShortestPath(Graph graph, int s){

        // 算法初始化
        G = graph;
        assert s >= 0 && s < G.V();

        visited = new boolean[G.V()];
        from = new int[G.V()];
        ord = new int[G.V()];
        for( int i = 0 ; i < G.V() ; i ++ ){
            visited[i] = false;
            from[i] = -1;
            ord[i] = -1;
        }
        this.s = s;

        // 无向图最短路径算法, 从s开始广度优先遍历整张图
        Queue<Integer> q = new LinkedList<Integer>();

        q.add(s);
        visited[s] = true;
        ord[s] = 0;
        while( !q.isEmpty() ){
            int v = q.remove();
            for( int i : G.adj(v) )
                if( !visited[i] ){
                    q.add(i);
                    visited[i] = true;
                    from[i] = v;
                    ord[i] = ord[v] + 1;
                }
        }
    }

    // 查询从s点到w点是否有路径
    public boolean hasPath(int w){
        assert w >= 0 && w < G.V();
        return visited[w];
    }

    // 查询从s点到w点的路径, 存放在vec中
    public Vector<Integer> path(int w){

        assert hasPath(w) ;

        Stack<Integer> s = new Stack<Integer>();
        // 通过from数组逆向查找到从s到w的路径, 存放到栈中
        int p = w;
        while( p != -1 ){
            s.push(p);
            p = from[p];
        }

        // 从栈中依次取出元素, 获得顺序的从s到w的路径
        Vector<Integer> res = new Vector<Integer>();
        while( !s.empty() )
            res.add( s.pop() );

        return res;
    }

    // 打印出从s点到w点的路径
    public void showPath(int w){

        assert hasPath(w) ;

        Vector<Integer> vec = path(w);
        for( int i = 0 ; i < vec.size() ; i ++ ){
            System.out.print(vec.elementAt(i));
            if( i == vec.size() - 1 )
                System.out.println();
            else
                System.out.print(" -> ");
        }
    }

    // 查看从s点到w点的最短路径长度
    // 若从s到w不可达，返回-1
    public int length(int w){
        assert w >= 0 && w < G.V();
        return ord[w];
    }
}

BFS 作用

1. 是否存在A到B的路径
   • 从A开始 BFS 所有的节点
   • 记录节点是否被访问的（visited 数组结构， boolean类型， i为节点序号）
   • 记录当前节点 父节点（visited 数组结构， 序号类型， i为节点序号）
   • 从B节点，反向遍历父节点，直至A节点（Stack结构）
   • 打印Stack结构（路径）
2. 找出最短的路径
   • 设置visited array，只允许访问一次
   • 最早的一次访问，一定是最短的路径（当然，可能有多个最短，但只选择了一个）

作用范围

• 有向图、二叉树
• 无法作用于加权图
  • 加权图（采用Dijkstra’s algorithm, 狄克斯特拉算法，之后更新)

时间复杂度

• O(节点数+边数）= O(节点数) + O(边数)
• O(边数) 沿每条边前行耗时
• O(节点数) 每个节点添加耗时

考题： 左侧正三角形遍历

• 输入n，座标：为n*n的矩形的 左下方三角形
• 每个座标上有数值
• 起始座标 0，0;只有一个item
• 下个座标，只允许当前座标的 down、right
• 终止条件，走到最后一行，即第n行
• 输出 到达终止条件，路径数值累加最大的，