图--加权无向图

最小生成树

一幅加权图的最小生成树(MST)是它的一棵权值最小(树中所有边的权值之和)的生成树

Prim算法

每一步都会为一棵生长中的树添加一条权重最小的边,一开始,这棵树只有一个顶点

最小生成树的Prim算法的延时实现

使用一条优先队列来保存所有的横切边,一个由顶点索引的数组来标记树的顶点以及一条队列来保存最小生成树的边.这种延时实现会在优先队列中保留失效的边.

public class LazyPrimMST {
    private boolean[] marked;
    private Queue<Edge> mst;  //最小生成树的边
    private MinPQ<Edge> pq;   //优先级队列,获得最小的边

    public LazyPrimMST(EdgeWeightedGraph g){
        pq = new MinPQ<>();
        marked = new boolean[g.V()];
        mst = new Queue<>();

        visit(g,0);
        while(!pq.isEmpty()){
            Edge e = pq.delMin();   //从pq中得到权重最小的边
            int v = e.either(), w = e.other(v);
            if(marked[v]&&marked[w]) continue;
            mst.enqueue(e);
            if(!marked[v]) visit(g, v);
            if(!marked[w]) visit(g, w);
        }
    }

    private void visit(EdgeWeightedGraph g, int v){
        //标记顶点v并将所有连接v和未被标记顶点的边加入pq
        marked[v] = true;
        for(Edge e : g.adj(v))
            if(!marked[e.other(v)]) pq.insert(e);
    }

    public Iterable<Edge> edges(){
        return mst;
    }
}

Prim算法的即时实现

将所有有效的横切边保存在了一条索引优先队列中

public class PrimMST {
    private Edge[] edgeTo;
    private double[] distTo;
    private boolean[] marked;
    private IndexMinPQ<Double> pq;  //有效的横切边

    public PrimMST(EdgeWeightedGraph g){
        edgeTo = new Edge[g.V()];
        distTo = new double[g.V()];
        marked = new boolean[g.V()];
        for(int v=0; v<g.V(); v++){
            distTo[v] = Double.POSITIVE_INFINITY;
        }
        pq = new IndexMinPQ<>(g.V());

        distTo[0] = 0.0;
        pq.insert(0, 0.0);
        while(!pq.isEmpty())
            visit(g, pq.delMin());
    }

    private void visit(EdgeWeightedGraph g, int v){
        marked[v] = true;
        for(Edge e : g.adj(v)){
            int w = e.other(v);
            if(marked[w]) continue;
            if(e.weight()<distTo[w]){ //连接w和树的最佳边Edge变为e
                edgeTo[w] = e;

                distTo[w] = e.weight();
                if(pq.contains(w)) pq.change(w, distTo[w]);
                else               pq.insert(w, distTo[w]);
            }
        }
    }

    public Iterable<Edge> edges(){
        Bag<Edge> mst = new Bag<Edge>();
        for(int v = 1; v<edgeTo.length; v++)
            mst.add(edgeTo[v]);
        return mst;
    }
}

---

Kruskal算法

主要思想:按照边的权重顺序(从小到大)处理它们,将边加入最小生成树中

public class KruskalMST {
    private Queue<Edge> mst;

    public KruskalMST(EdgeWeightedGraph g){
        mst = new Queue<Edge>();
        MinPQ<Edge> pq = new MinPQ<>();
        for(Edge e : g.edges()) pq.insert(e);
        UF uf = new UF(g.V());  //并查集 union-find

        while(!pq.isEmpty() && mst.size()<g.V()-1){
            Edge e = pq.delMin();
            int v = e.either(), w = e.other(v);
            if(uf.connected(v, w)) continue;

            uf.union(v, w);  //合并分量
            mst.enqueue(e);  //将边添加到最小生成树中
        }
    }

    public Iterable<Edge> edges(){
        return mst;
    }
}