最小生成树，prime, kruskal与并查集算法

一、定义：

连通图：

　　如果有路径使得顶点i，j相连。则称顶点i，j连通。

最小生成树：　

　　在含有n个顶点的连通图中，选取n-1个边，构成一个极小连通子图，使得各个边的权值和最小，则这个最小连通子图称为最小生成树。如图所示：

 

 

 

 

 

 

则可以看出权值和为40的这个图为最小生成树。

 

二、解法

1、Prime算法　　

• 首先定义两个集合U，V用来存放顶点。V用来存放已经加入的点，U用来存放没有加入的点。
• 从起点开始，将其放入集合V中
• 以V为搜索框架，在U中寻找V不存在的点，使得点v与点u的边权值最小，将边vu加入集合E中
• 重复此步骤，直到V、U顶点一样

图解：

　　

Code:

package algorithm;

import java.util.ArrayList;
import java.util.List;

public class Prime {
    private static final int INF = 0x7fffffff;

    public static class Edge {
        char from;
        char to;
        int weight;

        public Edge(char from, char to, int weight) {
            this.from = from;
            this.to = to;
            this.weight = weight;
        }
    }

    public static class Graph {
        char[] nodes;
        int[][] matrix;

        public Graph(char[] nodes, int[][] matrix) {
            this.nodes = nodes;
            this.matrix = matrix;
        }
    }

    public static List<Edge> prime(Graph graph) {
        int n = graph.nodes.length;
        boolean[] visited = new boolean[n];
        visited[0] = true;
        List<Edge> res = new ArrayList<>();

        for (int a = 0; a < n-1; a++) {
            int from = 0, to = 0, min = INF;
            for (int i = 0; i < n; i++) {
                if (visited[i]) {
                    for (int j = 0; j < n; j++) {
                        if (!visited[j] && j != i && graph.matrix[i][j] < min) {
                            min = graph.matrix[i][j];
                            from = i;
                            to = j;
                        }
                    }
                }
            }
            visited[to] = true;
            res.add(new Edge(graph.nodes[from], graph.nodes[to], min));
        }

        return res;
    }

    public static void main(String[] args) {
        char[] nodes = {
                'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'
        };

        int[][] matrix = {
                {0,   3,   INF, 10,  INF, INF, INF, INF},
                {3,   0,   8,   INF, 7,   INF, INF, INF},
                {INF, 8,   0,   INF, INF, 9,   INF, INF},
                {10,  INF, INF, 0,   7,   2,   14,  INF},
                {INF, 7,   INF, 7,   0,   INF, 9,   INF},
                {INF, INF, INF, 2,   INF, 0,   7,   INF},
                {INF, INF, INF, 14,  9,   7,   0,   6  },
                {INF, INF, 9,   INF, INF, INF, 6,   0  }
        };

        Graph graph = new Graph(nodes, matrix);

        List<Edge> res = prime(graph);
        for(Edge edge : res){
            System.out.println("from " + edge.from + " to " + edge.to + " wight " + edge.weight);
        }
    }
}

结果：

　　

 

 

 

 

 

2、Kruskal算法

步骤

• 将图G的边按照权值从小到大排序得到边的集合 E，初始化极小连通子图V
• 遍历E，从E中取出每个边e，如果e中的两个点和V不属于统一连通分量(将e加进V中不构成环），则将e加入V中
• 重复上述过程，直到已经加入了n-1条边，其中n为顶点个数。

图解

如果要加入一个边e到一个图G，判断新图有没有环：

• 记录图G中所有点f的终点t
• 分别寻找边e两点a,b的终点
• 如果边a,b的终点一样则，a，b已经在一个连通图中，如果加入e边，则形成了环
• 现有算法并查集算法(合并-查找)

Code:

　　

package algorithm;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Kruskal {
    private static int[] endsOfNode;
    private static int INF = 0x7fffffff;

    //定义边类
    public static class Edge implements Comparable<Edge> {
        int from;
        int to;
        int weight;

        public Edge(int from, int to, int weight) {
            this.from = from;
            this.to = to;
            this.weight = weight;
        }

        @Override
        public int compareTo(Edge o1) {
            return this.weight - o1.weight;
        }
    }

    //定义图类
    public static class Graph {
        char[] nodes;
        int[][] matrix;

        public Graph(char[] nodes, int[][] matrix) {
            this.nodes = nodes;
            this.matrix = matrix;
        }
    }

    //得到一个连通图的终点, 递归更新每一个点的终点，查找操作，并且将每一个点的终点都统一成一级结构,64,65,70行为合并 join操作
    public static int getEndOfNode(int index) {
        if (endsOfNode[index] != index) endsOfNode[index] = getEndOfNode(endsOfNode[index]);
        return index;
    }

    public static List<Edge> kruskal(Graph graph) {
        int n = graph.nodes.length;
        endsOfNode = new int[n];

        for (int i = 0; i < n; i++) endsOfNode[i] = i;


        List<Edge> edges = new ArrayList<>();
        for (int i = 0; i < n; i++)
            for (int j = i + 1; j < n; j++)
                if (graph.matrix[i][j] != INF)
                    edges.add(new Edge(i, j, graph.matrix[i][j]));

        Collections.sort(edges);

        int c = 0;
        List<Edge> res = new ArrayList<>();
        for (Edge edge : edges) {
            int x = getEndOfNode(edge.from);
            int y = getEndOfNode(edge.to);
　　
            if(x == y) continue;
            if (c++ == n - 1) break;
            res.add(edge);
            endsOfNode[x] = y;
        }
        return res;
    }


    public static void main(String [] args){
        char[] nodes = {
                'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'
        };

        int[][] matrix = {
                {0,   3,   INF, 10,  INF, INF, INF, INF},
                {3,   0,   8,   INF, 7,   INF, INF, INF},
                {INF, 8,   0,   INF, INF, 9,   INF, INF},
                {10,  INF, INF, 0,   7,   2,   14,  INF},
                {INF, 7,   INF, 7,   0,   INF, 9,   INF},
                {INF, INF, INF, 2,   INF, 0,   7,   INF},
                {INF, INF, INF, 14,  9,   7,   0,   6  },
                {INF, INF, 9,   INF, INF, INF, 6,   0  }
        };

        Graph graph = new Graph(nodes, matrix);

        List<Edge> res = kruskal(graph);
        for(Edge edge : res){
            System.out.println("from " + nodes[edge.from] + " to " + nodes[edge.to] + " wight " + edge.weight);
        }
    }
}

结果：

3、并查集算法

1、

      在kruskal算法中，如果我们要新加入一条边到一个子图当中，需要判断如果加入改边，是否会形成环。如图所示，如果已经加入了边E(a,b), E(b,c), 现在要加入E(a,c)。需要先判断加入边E(a,c)是否形成了环，即判断点a，c是否在同一个连通子图中。

　　

2、

　　那么如何判断呢？我们可以构造一个连通图。然后在这个联通图中，从边的一点出发去寻找另一个点。如果找到这两个点在同一个连通图中，否则不在一个连通图中。

　　这是一个简单粗暴最容易想到的方法。如果A，B在同一个连通子图中，每次查找的时间复杂度是O(n²)，n为连通子图的节点个数。

3、Can we do better?

　　如果能设计一个结构，使得在一个连通子图中所有子节点都指向一个父节点，那么查找的时间复杂度会是O(1)，更新每个子节点的时间复杂度是O(n).

　　实际做法是

• 记录每个子节点C的父节点F
• 如果父节点F有了父节点G，则更新F的每一个子节点的父节点为G
• 要保证边两端节点命名的顺序，例如E(a,b) ，E(b,c)要有字母顺序

4、Code（非递归版本）

    public int find(int node){
        int end = node;

        while (end != ends[end]) end = ends[end]; //查找根节点

        while (node != end){  //更新每个子节点的父节点为 end
            int nt = ends[node];
            ends[node] = end;
            node = nt;
        }

        return end;
    }


    public void join(int a, int b){
        int ae = union(a);
        int be = union(b);
        if (ae != be){
            ends[ae] = be; //插入边的右节点 为 左节点的父节点
        }
    }

递归代码更简洁：

　　 public int find(int node){
        if(ends[node] != node) ends[node] = find(node);
        return node;
    }
    
    public void join(int a, int b){
        int ae = union(a);
        int be = union(b);
        if (ae != be){
            ends[ae] = be; //插入边的右节点 为 左节点的父节点
        }
    }