kruskal算法和prim算法
1、两种算法都针对无向图
2、目的：生成最小生成树
生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。
一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。
最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。
一、Kruskal算法 --克鲁斯卡尔
1.将图中的所有边按权值从小到大排序； 2.把图中的n个顶点看成独立的n棵树组成的森林； 3.按权值从小到大选择边，所选的边连接的两个顶点ui，vi应属于两颗不同的树，然后将这两颗树合并作为一颗树。 4.重复（3），直到所有顶点都在一颗树内或者有n-1条边为止。
package Algorithms.Graph; import java.util.*; //undirected graph only public class Kruskal { public static class Mysets{ public HashMap<Node, List<Node>> setMap; //每一个点Node都建立一个小集合，把自己放进去，然后再把（Node，{Node}）放入setMap中 public Mysets(List<Node> nodes){ for (Node cur:nodes){ List<Node> set = new ArrayList<Node>(); set.add(cur); setMap.put(cur,set); } } //判断from和to两节点在不在同一集合中（比较两集合的内存地址是否相同） public boolean isSameSet(Node from,Node to){ List<Node> fromSet = setMap.get(from); List<Node> toSet = setMap.get(to); return fromSet == toSet; } //把from所在集合和to所在集合合并为一个集合 //将to集合中所有点都添加到from集合中，再把to集合中所有Node在setMap中的指向变为from所在集合 public void union(Node from,Node to){ List<Node> fromSet = setMap.get(from); List<Node> toSet = setMap.get(to); for (Node toNode:toSet ){ fromSet.add(toNode); setMap.put(toNode,fromSet); } } } //以上方法没有并查集快 //################################################################################### // Union-Find Set public static class UnionFind { private HashMap<Node, Node> fatherMap; private HashMap<Node, Integer> rankMap; public UnionFind() { fatherMap = new HashMap<Node, Node>(); rankMap = new HashMap<Node, Integer>(); } private Node findFather(Node n) { Node father = fatherMap.get(n); if (father != n) { father = findFather(father); } fatherMap.put(n, father); return father; } public void makeSets(Collection<Node> nodes) { fatherMap.clear(); rankMap.clear(); for (Node node : nodes) { fatherMap.put(node, node); rankMap.put(node, 1); } } public boolean isSameSet(Node a, Node b) { return findFather(a) == findFather(b); } public void union(Node a, Node b) { if (a == null || b == null) { return; } Node aFather = findFather(a); Node bFather = findFather(b); if (aFather != bFather) { int aFrank = rankMap.get(aFather); int bFrank = rankMap.get(bFather); if (aFrank <= bFrank) { fatherMap.put(aFather, bFather); rankMap.put(bFather, aFrank + bFrank); } else { fatherMap.put(bFather, aFather); rankMap.put(aFather, aFrank + bFrank); } } } } public static class EdgeComparator implements Comparator<Edge> { @Override public int compare(Edge o1, Edge o2) { return o1.weight - o2.weight; } } public static Set<Edge> kruskalMST(Graph graph) { UnionFind unionFind = new UnionFind(); unionFind.makeSets(graph.nodes.values()); PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(new EdgeComparator()); for (Edge edge : graph.edges) { priorityQueue.add(edge); } Set<Edge> result = new HashSet<>(); while (!priorityQueue.isEmpty()) { Edge edge = priorityQueue.poll(); if (!unionFind.isSameSet(edge.from, edge.to)) { result.add(edge); unionFind.union(edge.from, edge.to); } } return result; } }
二、prim算法 --普里姆
此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点。
priorityQueue：优先级队列，存放解锁的边，并按照权值从小到大依次弹出解锁的边
HashSet<Node> set：把新点放入set中，用来判断一个点是否为新点
Set<Node> result：用来存放依次挑选的边
1、选择一个节点A
2、把A所有的边加入优先级队列中
3、从优先级队列中取出一个边（权值最小的边）
4、判断这个边所指向的节点是否在set集合中，如果不在，说明是一个新点，将其添加到set中
5、取出这个新点所有的边，放入优先级队列中，再重复以上步骤
代码实现
package Algorithms.Graph; import java.util.Comparator; import java.util.HashSet; import java.util.PriorityQueue; import java.util.Set; // undirected graph only public class Prim { public static class EdgeComparator implements Comparator<Edge> { @Override public int compare(Edge o1, Edge o2) { return o1.weight - o2.weight; } } public static Set<Edge> primMST(Graph graph) { PriorityQueue<Edge> priorityQueue = new PriorityQueue<>( new EdgeComparator()); //优先级队列：用来存放解锁的边 HashSet<Node> set = new HashSet<>(); Set<Edge> result = new HashSet<>(); //用来存放依次挑选的边 for (Node node : graph.nodes.values()) { //随便挑一个点，for循环是为了处理森林的问题 //node是开始点 如果一个图是连通图，就不需要for循环 if (!set.contains(node)) { set.add(node); for (Edge edge : node.edges) { //由一个点，解锁所有相连的边 priorityQueue.add(edge); //把这个点所有的边放入优先级队列中 } while (!priorityQueue.isEmpty()) { Edge edge = priorityQueue.poll(); //从优先级队列中取一个边（value值最小的边） Node toNode = edge.to; //拿到这个边所指向的Node if (!set.contains(toNode)) { // 如果这个Node不再set集合中，就是一个新Node set.add(toNode); result.add(edge); for (Edge nextEdge : toNode.edges) { //然后再把这个新Node所有的边放入优先级队列中 priorityQueue.add(nextEdge); } //以上代码可能会把重复的边扔到优先级队列中，但不影响结果（会被if条件直接跳过） } } } } return result; } // 请保证graph是连通图 // graph[i][j]表示点i到点j的距离，如果是系统最大值代表无路 // 返回值是最小连通图的路径之和 public static int prim(int[][] graph) { int size = graph.length; int[] distances = new int[size]; boolean[] visit = new boolean[size]; visit[0] = true; for (int i = 0; i < size; i++) { distances[i] = graph[0][i]; } int sum = 0; for (int i = 1; i < size; i++) { int minPath = Integer.MAX_VALUE; int minIndex = -1; for (int j = 0; j < size; j++) { if (!visit[j] && distances[j] < minPath) { minPath = distances[j]; minIndex = j; } } if (minIndex == -1) { return sum; } visit[minIndex] = true; sum += minPath; for (int j = 0; j < size; j++) { if (!visit[j] && distances[j] > graph[minIndex][j]) { distances[j] = graph[minIndex][j]; } } } return sum; } public static void main(String[] args) { System.out.println("hello world!"); } }
