最小生成树（二）Prim算法

Posted on 2020-06-01 19:09 只会一点java 阅读(894) 评论(0) 编辑收藏举报

一、思想

1.1 基本概念

加权无向图的生成树：一棵含有其所有顶点的无环连通子图。
最小生成树（MST）：一棵权值最小（树中所有边的权值之和）的生成树。

1.2 算法原理

1.2.1 切分定理

切分定义：图的一种切分是将图的所有顶点分为两个非空且不重合的两个集合。横切边是一条连接两个属于不同集合的顶点的边。
切分定理：在一幅加权图中，给定任意的切分，它的横切边中的权重最小者必然属于图的最小生成树。

1.2.2 算法原理

切分定理是解决最小生成树问题的所有算法的基础。切分定理再结合贪心算法思想，就可以最终落地实现最小生成树。

Prim算法原理：

一开始树中只有一个顶点，向它添加v-1条边，每次总是将下一条连接 “树中的顶点” 与 “不在树中的顶点” 且权重最小的边，加入树中。如下图，当我们将顶点v添加到树中时，可能使得w到最小生成树的距离更近了（然后遍历顶点v的领接链表即可）。

核心：

使用一个索引优先队列，保存每个非树顶点w的一条边（将它与树中顶点连接起来的权重最小的边）。优先队列（小顶堆）的最小键即是权重最小的横切边的权重，而和它相关联的顶点V就是下一个将被添加到树中的顶点。

二、实现

2.1 无向边

  1 package study.algorithm.graph;
  2 
  3 import study.algorithm.base.StdOut;
  4 
  5 /***
  6  * @Description 无向边
  7  * @author denny.zhang
  8  * @date 2020/5/25 10:34 上午
  9  */
 10 public class Edge implements Comparable<Edge> {
 11 
 12     /**
 13      * 一个顶点
 14      */
 15     private final int v;
 16     /**
 17      * 另一个顶点
 18      */
 19     private final int w;
 20     /**
 21      * 权重
 22      */
 23     private final double weight;
 24 
 25     /**
 26      * Initializes an edge between vertices {@code v} and {@code w} of
 27      * the given {@code weight}.
 28      *
 29      * @param  v one vertex
 30      * @param  w the other vertex
 31      * @param  weight the weight of this edge
 32      * @throws IllegalArgumentException if either {@code v} or {@code w} 
 33      *         is a negative integer
 34      * @throws IllegalArgumentException if {@code weight} is {@code NaN}
 35      */
 36     public Edge(int v, int w, double weight) {
 37         if (v < 0) throw new IllegalArgumentException("vertex index must be a nonnegative integer");
 38         if (w < 0) throw new IllegalArgumentException("vertex index must be a nonnegative integer");
 39         if (Double.isNaN(weight)) throw new IllegalArgumentException("Weight is NaN");
 40         this.v = v;
 41         this.w = w;
 42         this.weight = weight;
 43     }
 44 
 45     /**
 46      * Returns the weight of this edge.
 47      *
 48      * @return the weight of this edge
 49      */
 50     public double weight() {
 51         return weight;
 52     }
 53 
 54     /**
 55      * 返回边的任意一个顶点
 56      *
 57      * @return either endpoint of this edge
 58      */
 59     public int either() {
 60         return v;
 61     }
 62 
 63     /**
 64      * 返回边的另一个顶点
 65      *
 66      * @param  vertex one endpoint of this edge
 67      * @return the other endpoint of this edge
 68      * @throws IllegalArgumentException if the vertex is not one of the
 69      *         endpoints of this edge
 70      */
 71     public int other(int vertex) {
 72         if      (vertex == v) return w;
 73         else if (vertex == w) return v;
 74         else throw new IllegalArgumentException("Illegal endpoint");
 75     }
 76 
 77     /**
 78      * Compares two edges by weight.
 79      * Note that {@code compareTo()} is not consistent with {@code equals()},
 80      * which uses the reference equality implementation inherited from {@code Object}.
 81      *
 82      * @param  that the other edge
 83      * @return a negative integer, zero, or positive integer depending on whether
 84      *         the weight of this is less than, equal to, or greater than the
 85      *         argument edge
 86      */
 87     @Override
 88     public int compareTo(Edge that) {
 89         return Double.compare(this.weight, that.weight);
 90     }
 91 
 92     /**
 93      * Returns a string representation of this edge.
 94      *
 95      * @return a string representation of this edge
 96      */
 97     public String toString() {
 98         return String.format("%d-%d %.5f", v, w, weight);
 99     }
100 
101     /**
102      * Unit tests the {@code Edge} data type.
103      *
104      * @param args the command-line arguments
105      */
106     public static void main(String[] args) {
107         Edge e = new Edge(12, 34, 5.67);
108         StdOut.println(e);
109         StdOut.println("任意一个顶点="+e.either());
110         StdOut.println("另一个顶点="+e.other(12));
111     }
112 }

如上图，初始化时构造了一个邻接表。Bag<Edge>[] adj，如下图。每条边有2个顶点，所以插入adj[]中2次。

2.2.边加权无向图

  1 package study.algorithm.graph;
  2 
  3 import study.algorithm.base.*;
  4 
  5 import java.util.NoSuchElementException;
  6 
  7 /***
  8  * @Description 边权重无向图
  9  * @author denny.zhang
 10  * @date 2020/5/25 10:50 上午
 11  */
 12 public class EdgeWeightedGraph {
 13     private static final String NEWLINE = System.getProperty("line.separator");
 14 
 15     /**
 16      * 顶点数
 17      */
 18     private final int V;
 19     /**
 20      * 边数
 21      */
 22     private int E;
 23     /**
 24      * 顶点邻接表，每个元素Bag代表：由某个顶点关联的边数组,按顶点顺序排列
 25      */
 26     private Bag<Edge>[] adj;
 27     
 28     /**
 29      * Initializes an empty edge-weighted graph with {@code V} vertices and 0 edges.
 30      *
 31      * @param  V the number of vertices
 32      * @throws IllegalArgumentException if {@code V < 0}
 33      */
 34     public EdgeWeightedGraph(int V) {
 35         if (V < 0) throw new IllegalArgumentException("Number of vertices must be nonnegative");
 36         this.V = V;
 37         this.E = 0;
 38         adj = (Bag<Edge>[]) new Bag[V];
 39         for (int v = 0; v < V; v++) {
 40             adj[v] = new Bag<Edge>();
 41         }
 42     }
 43 
 44     /**
 45      * Initializes a random edge-weighted graph with {@code V} vertices and <em>E</em> edges.
 46      *
 47      * @param  V the number of vertices
 48      * @param  E the number of edges
 49      * @throws IllegalArgumentException if {@code V < 0}
 50      * @throws IllegalArgumentException if {@code E < 0}
 51      */
 52     public EdgeWeightedGraph(int V, int E) {
 53         this(V);
 54         if (E < 0) throw new IllegalArgumentException("Number of edges must be nonnegative");
 55         for (int i = 0; i < E; i++) {
 56             int v = StdRandom.uniform(V);
 57             int w = StdRandom.uniform(V);
 58             double weight = Math.round(100 * StdRandom.uniform()) / 100.0;
 59             Edge e = new Edge(v, w, weight);
 60             addEdge(e);
 61         }
 62     }
 63 
 64     /**  
 65      * Initializes an edge-weighted graph from an input stream.
 66      * The format is the number of vertices <em>V</em>,
 67      * followed by the number of edges <em>E</em>,
 68      * followed by <em>E</em> pairs of vertices and edge weights,
 69      * with each entry separated by whitespace.
 70      *
 71      * @param  in the input stream
 72      * @throws IllegalArgumentException if {@code in} is {@code null}
 73      * @throws IllegalArgumentException if the endpoints of any edge are not in prescribed range
 74      * @throws IllegalArgumentException if the number of vertices or edges is negative
 75      */
 76     public EdgeWeightedGraph(In in) {
 77         if (in == null) throw new IllegalArgumentException("argument is null");
 78 
 79         try {
 80             // 顶点数
 81             V = in.readInt();
 82             // 邻接表
 83             adj = (Bag<Edge>[]) new Bag[V];
 84             // 初始化邻接表，一个顶点对应一条链表
 85             for (int v = 0; v < V; v++) {
 86                 adj[v] = new Bag<Edge>();
 87             }
 88             // 边数
 89             int E = in.readInt();
 90             if (E < 0) throw new IllegalArgumentException("Number of edges must be nonnegative");
 91             // 遍历每一条边
 92             for (int i = 0; i < E; i++) {
 93                 // 一个顶点
 94                 int v = in.readInt();
 95                 // 另一个顶点
 96                 int w = in.readInt();
 97                 validateVertex(v);
 98                 validateVertex(w);
 99                 // 权重
100                 double weight = in.readDouble();
101                 // 构造边
102                 Edge e = new Edge(v, w, weight);
103                 // 添加边
104                 addEdge(e);
105             }
106         }   
107         catch (NoSuchElementException e) {
108             throw new IllegalArgumentException("invalid input format in EdgeWeightedGraph constructor", e);
109         }
110 
111     }
112 
113     /**
114      * Initializes a new edge-weighted graph that is a deep copy of {@code G}.
115      *
116      * @param  G the edge-weighted graph to copy
117      */
118     public EdgeWeightedGraph(EdgeWeightedGraph G) {
119         this(G.V());
120         this.E = G.E();
121         for (int v = 0; v < G.V(); v++) {
122             // reverse so that adjacency list is in same order as original
123             Stack<Edge> reverse = new Stack<Edge>();
124             for (Edge e : G.adj[v]) {
125                 reverse.push(e);
126             }
127             for (Edge e : reverse) {
128                 adj[v].add(e);
129             }
130         }
131     }
132 
133 
134     /**
135      * Returns the number of vertices in this edge-weighted graph.
136      *
137      * @return the number of vertices in this edge-weighted graph
138      */
139     public int V() {
140         return V;
141     }
142 
143     /**
144      * Returns the number of edges in this edge-weighted graph.
145      *
146      * @return the number of edges in this edge-weighted graph
147      */
148     public int E() {
149         return E;
150     }
151 
152     // throw an IllegalArgumentException unless {@code 0 <= v < V}
153     private void validateVertex(int v) {
154         if (v < 0 || v >= V)
155             throw new IllegalArgumentException("vertex " + v + " is not between 0 and " + (V-1));
156     }
157 
158     /**
159      * Adds the undirected edge {@code e} to this edge-weighted graph.
160      *
161      * @param  e the edge
162      * @throws IllegalArgumentException unless both endpoints are between {@code 0} and {@code V-1}
163      */
164     public void addEdge(Edge e) {
165         // 一个顶点
166         int v = e.either();
167         // 另一个顶点
168         int w = e.other(v);
169         validateVertex(v);
170         validateVertex(w);
171         // 追加进顶点v的邻接链表
172         adj[v].add(e);
173         // 追加进顶点w的领接链表
174         adj[w].add(e);
175         // 边数++
176         E++;
177     }
178 
179     /**
180      * 顶点V关联的全部边
181      *
182      * @param  v the vertex
183      * @return the edges incident on vertex {@code v} as an Iterable
184      * @throws IllegalArgumentException unless {@code 0 <= v < V}
185      */
186     public Iterable<Edge> adj(int v) {
187         validateVertex(v);
188         return adj[v];
189     }
190 
191     /**
192      * Returns the degree of vertex {@code v}.
193      *
194      * @param  v the vertex
195      * @return the degree of vertex {@code v}               
196      * @throws IllegalArgumentException unless {@code 0 <= v < V}
197      */
198     public int degree(int v) {
199         validateVertex(v);
200         return adj[v].size();
201     }
202 
203     /**
204      * Returns all edges in this edge-weighted graph.
205      * To iterate over the edges in this edge-weighted graph, use foreach notation:
206      * {@code for (Edge e : G.edges())}.
207      *
208      * @return all edges in this edge-weighted graph, as an iterable
209      */
210     public Iterable<Edge> edges() {
211         Bag<Edge> list = new Bag<Edge>();
212         for (int v = 0; v < V; v++) {
213             int selfLoops = 0;
214             for (Edge e : adj(v)) {
215                 if (e.other(v) > v) {
216                     list.add(e);
217                 }
218                 // add only one copy of each self loop (self loops will be consecutive)
219                 else if (e.other(v) == v) {
220                     if (selfLoops % 2 == 0) list.add(e);
221                     selfLoops++;
222                 }
223             }
224         }
225         return list;
226     }
227 
228     /**
229      * Returns a string representation of the edge-weighted graph.
230      * This method takes time proportional to <em>E</em> + <em>V</em>.
231      *
232      * @return the number of vertices <em>V</em>, followed by the number of edges <em>E</em>,
233      *         followed by the <em>V</em> adjacency lists of edges
234      */
235     public String toString() {
236         StringBuilder s = new StringBuilder();
237         s.append(V + " " + E + NEWLINE);
238         for (int v = 0; v < V; v++) {
239             s.append(v + ": ");
240             for (Edge e : adj[v]) {
241                 s.append(e + "  ");
242             }
243             s.append(NEWLINE);
244         }
245         return s.toString();
246     }
247 
248     /**
249      * Unit tests the {@code EdgeWeightedGraph} data type.
250      *
251      * @param args the command-line arguments
252      */
253     public static void main(String[] args) {
254         In in = new In(args[0]);
255         EdgeWeightedGraph G = new EdgeWeightedGraph(in);
256         StdOut.println(G);
257     }
258 
259 }

2.3 索引小值优先队列

  1 package study.algorithm.base;
  2 
  3 import java.util.Iterator;
  4 import java.util.NoSuchElementException;
  5 
  6 /**
  7  * 索引（顶点）最小优先级队列
  8  *
  9  * @param <Key>
 10  */
 11 public class IndexMinPQ<Key extends Comparable<Key>> implements Iterable<Integer> {
 12     /**
 13      * 元素数量上限
 14      */
 15     private int maxN;
 16     /**
 17      * 元素数量
 18      */
 19     private int n;
 20     /**
 21      * 索引二叉堆（数组中每个元素都是顶点，顶点v，对应keys[v]）：数组从pq[0]代表原点其它顶点从pq[1]开始插入
 22      */
 23     private int[] pq;
 24     /**
 25      * 标记索引为i的元素在二叉堆中的位置。pq的反转数组（qp[index]=i）：qp[pq[i]] = pq[qp[i]] = i
 26      */
 27     private int[] qp;
 28 
 29     /**
 30      * 元素有序数组（按照pq的索引赋值）
 31      */
 32     public Key[] keys;
 33 
 34     /**
 35      * 初始化一个空索引优先队列，索引范围:0 ~ maxN-1
 36      *
 37      * @param  maxN the keys on this priority queue are index from {@code 0}
 38      *         {@code maxN - 1}
 39      * @throws IllegalArgumentException if {@code maxN < 0}
 40      */
 41     public IndexMinPQ(int maxN) {
 42         if (maxN < 0) throw new IllegalArgumentException();
 43         this.maxN = maxN;
 44         // 初始有0个元素
 45         n = 0;
 46         // 初始化键数组长度为maxN + 1
 47         keys = (Key[]) new Comparable[maxN + 1];
 48         // 初始化"键值对"数组长度为maxN + 1
 49         pq   = new int[maxN + 1];
 50         // 初始化"值键对"数组长度为maxN + 1
 51         qp   = new int[maxN + 1];
 52         // 遍历给"值键对"数组赋值-1，后续只要!=-1,即包含i
 53         for (int i = 0; i <= maxN; i++)
 54             qp[i] = -1;
 55     }
 56 
 57     /**
 58      * Returns true if this priority queue is empty.
 59      *
 60      * @return {@code true} if this priority queue is empty;
 61      *         {@code false} otherwise
 62      */
 63     public boolean isEmpty() {
 64         return n == 0;
 65     }
 66 
 67     /**
 68      * Is {@code i} an index on this priority queue?
 69      *
 70      * @param  i an index
 71      * @return {@code true} if {@code i} is an index on this priority queue;
 72      *         {@code false} otherwise
 73      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
 74      */
 75     public boolean contains(int i) {
 76         validateIndex(i);
 77         return qp[i] != -1;
 78     }
 79 
 80     /**
 81      * Returns the number of keys on this priority queue.
 82      *
 83      * @return the number of keys on this priority queue
 84      */
 85     public int size() {
 86         return n;
 87     }
 88 
 89     /**
 90      * 插入一个元素，将元素key关联索引i
 91      *
 92      * @param  i an index
 93      * @param  key the key to associate with index {@code i}
 94      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
 95      * @throws IllegalArgumentException if there already is an item associated
 96      *         with index {@code i}
 97      */
 98     public void insert(int i, Key key) {
 99         validateIndex(i);
100         if (contains(i)) throw new IllegalArgumentException("index is already in the priority queue");
101         // 元素个数+1
102         n++;
103         // 索引为i的二叉堆位置为n
104         qp[i] = n;
105         // 二叉堆底部插入新元素，值=i
106         pq[n] = i;
107         // 索引i对应的元素赋值
108         keys[i] = key;
109         // 二叉堆中，上浮最后一个元素（小值上浮）
110         swim(n);
111     }
112 
113     /**
114      * 返回最小元素的索引
115      *
116      * @return an index associated with a minimum key
117      * @throws NoSuchElementException if this priority queue is empty
118      */
119     public int minIndex() {
120         if (n == 0) throw new NoSuchElementException("Priority queue underflow");
121         return pq[1];
122     }
123 
124     /**
125      * 返回最小元素（key）
126      *
127      * @return a minimum key
128      * @throws NoSuchElementException if this priority queue is empty
129      */
130     public Key minKey() {
131         if (n == 0) throw new NoSuchElementException("Priority queue underflow");
132         return keys[pq[1]];
133     }
134 
135     /**
136      * 删除最小值key,并返回最小值（优先队列索引）
137      *
138      * @return an index associated with a minimum key
139      * @throws NoSuchElementException if this priority queue is empty
140      */
141     public int delMin() {
142         if (n == 0) throw new NoSuchElementException("Priority queue underflow");
143         // pq[1]即为索引最小值
144         int min = pq[1];
145         // 交换第一个元素和最后一个元素
146         exch(1, n--);
147         // 把新换来的第一个元素下沉
148         sink(1);
149         // 校验下沉后，最后一个元素是最小值
150         assert min == pq[n+1];
151         // 恢复初始值，-1即代表该元素已删除
152         qp[min] = -1;        // delete
153         // 方便垃圾回收
154         keys[min] = null;
155         // 最后一个元素（索引）赋值-1
156         pq[n+1] = -1;        // not needed
157         return min;
158     }
159 
160     /**
161      * Returns the key associated with index {@code i}.
162      *
163      * @param  i the index of the key to return
164      * @return the key associated with index {@code i}
165      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
166      * @throws NoSuchElementException no key is associated with index {@code i}
167      */
168     public Key keyOf(int i) {
169         validateIndex(i);
170         if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
171         else return keys[i];
172     }
173 
174     /**
175      * Change the key associated with index {@code i} to the specified value.
176      *
177      * @param  i the index of the key to change
178      * @param  key change the key associated with index {@code i} to this key
179      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
180      * @throws NoSuchElementException no key is associated with index {@code i}
181      */
182     public void changeKey(int i, Key key) {
183         validateIndex(i);
184         if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
185         keys[i] = key;
186         swim(qp[i]);
187         sink(qp[i]);
188     }
189 
190     /**
191      * Change the key associated with index {@code i} to the specified value.
192      *
193      * @param  i the index of the key to change
194      * @param  key change the key associated with index {@code i} to this key
195      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
196      * @deprecated Replaced by {@code changeKey(int, Key)}.
197      */
198     @Deprecated
199     public void change(int i, Key key) {
200         changeKey(i, key);
201     }
202 
203     /**
204      * 减小索引i对应的值为key
205      * 更新：
206      * 1.元素数组keys[]
207      * 2.小顶二叉堆pq[]
208      *
209      * @param  i the index of the key to decrease
210      * @param  key decrease the key associated with index {@code i} to this key
211      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
212      * @throws IllegalArgumentException if {@code key >= keyOf(i)}
213      * @throws NoSuchElementException no key is associated with index {@code i}
214      */
215     public void decreaseKey(int i, Key key) {
216         validateIndex(i);
217         if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
218         // key 值一样，报错
219         if (keys[i].compareTo(key) == 0)
220             throw new IllegalArgumentException("Calling decreaseKey() with a key equal to the key in the priority queue");
221         // key比当前值大，报错
222         if (keys[i].compareTo(key) < 0)
223             throw new IllegalArgumentException("Calling decreaseKey() with a key strictly greater than the key in the priority queue");
224         // key比当前值小，把key赋值进去
225         keys[i] = key;
226         // 小值上浮（qp[i]=索引i在二叉堆pq[]中的位置）
227         swim(qp[i]);
228     }
229 
230     /**
231      * Increase the key associated with index {@code i} to the specified value.
232      *
233      * @param  i the index of the key to increase
234      * @param  key increase the key associated with index {@code i} to this key
235      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
236      * @throws IllegalArgumentException if {@code key <= keyOf(i)}
237      * @throws NoSuchElementException no key is associated with index {@code i}
238      */
239     public void increaseKey(int i, Key key) {
240         validateIndex(i);
241         if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
242         if (keys[i].compareTo(key) == 0)
243             throw new IllegalArgumentException("Calling increaseKey() with a key equal to the key in the priority queue");
244         if (keys[i].compareTo(key) > 0)
245             throw new IllegalArgumentException("Calling increaseKey() with a key strictly less than the key in the priority queue");
246         keys[i] = key;
247         sink(qp[i]);
248     }
249 
250     /**
251      * Remove the key associated with index {@code i}.
252      *
253      * @param  i the index of the key to remove
254      * @throws IllegalArgumentException unless {@code 0 <= i < maxN}
255      * @throws NoSuchElementException no key is associated with index {@code i}
256      */
257     public void delete(int i) {
258         validateIndex(i);
259         if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
260         int index = qp[i];
261         exch(index, n--);
262         swim(index);
263         sink(index);
264         keys[i] = null;
265         qp[i] = -1;
266     }
267 
268     // throw an IllegalArgumentException if i is an invalid index
269     private void validateIndex(int i) {
270         if (i < 0) throw new IllegalArgumentException("index is negative: " + i);
271         if (i >= maxN) throw new IllegalArgumentException("index >= capacity: " + i);
272     }
273 
274    /***************************************************************************
275     * General helper functions.
276     ***************************************************************************/
277     private boolean greater(int i, int j) {
278         return keys[pq[i]].compareTo(keys[pq[j]]) > 0;
279     }
280 
281     private void exch(int i, int j) {
282         int swap = pq[i];
283         pq[i] = pq[j];
284         pq[j] = swap;
285         qp[pq[i]] = i;
286         qp[pq[j]] = j;
287     }
288 
289 
290    /***************************************************************************
291     * Heap helper functions. 上浮
292     ***************************************************************************/
293     private void swim(int k) {
294         // 如果父节点值比当前节点值大，交换，父节点作为当前节点，轮询。即小值上浮。
295         while (k > 1 && greater(k/2, k)) {
296             exch(k, k/2);
297             k = k/2;
298         }
299     }
300      //下沉
301     private void sink(int k) {
302         while (2*k <= n) {
303             int j = 2*k;
304             if (j < n && greater(j, j+1)) j++;
305             if (!greater(k, j)) break;
306             exch(k, j);
307             k = j;
308         }
309     }
310 
311 
312    /***************************************************************************
313     * Iterators.
314     ***************************************************************************/
315 
316     /**
317      * Returns an iterator that iterates over the keys on the
318      * priority queue in ascending order.
319      * The iterator doesn't implement {@code remove()} since it's optional.
320      *
321      * @return an iterator that iterates over the keys in ascending order
322      */
323     @Override
324     public Iterator<Integer> iterator() { return new HeapIterator(); }
325 
326     private class HeapIterator implements Iterator<Integer> {
327         // create a new pq
328         private IndexMinPQ<Key> copy;
329 
330         // add all elements to copy of heap
331         // takes linear time since already in heap order so no keys move
332         public HeapIterator() {
333             copy = new IndexMinPQ<Key>(pq.length - 1);
334             for (int i = 1; i <= n; i++)
335                 copy.insert(pq[i], keys[pq[i]]);
336         }
337 
338         @Override
339         public boolean hasNext()  { return !copy.isEmpty();                     }
340         @Override
341         public void remove()      { throw new UnsupportedOperationException();  }
342 
343         @Override
344         public Integer next() {
345             if (!hasNext()) throw new NoSuchElementException();
346             return copy.delMin();
347         }
348     }
349 
350 
351     /**
352      * Unit tests the {@code IndexMinPQ} data type.
353      *
354      * @param args the command-line arguments
355      */
356     public static void main(String[] args) {
357         // insert a bunch of strings
358         String[] strings = { "it", "was", "the", "best", "of", "times", "it", "was", "the", "worst" };
359 
360         IndexMinPQ<String> pq = new IndexMinPQ<String>(strings.length);
361         for (int i = 0; i < strings.length; i++) {
362             pq.insert(i, strings[i]);
363         }
364 
365         // delete and print each key
366         while (!pq.isEmpty()) {
367             int i = pq.delMin();
368             StdOut.println(i + " " + strings[i]);
369         }
370         StdOut.println();
371 
372         // reinsert the same strings
373         for (int i = 0; i < strings.length; i++) {
374             pq.insert(i, strings[i]);
375         }
376 
377         // print each key using the iterator
378         for (int i : pq) {
379             StdOut.println(i + " " + strings[i]);
380         }
381         while (!pq.isEmpty()) {
382             pq.delMin();
383         }
384 
385     }
386 }

2.4 Prim算法(基于二叉堆)

  1 package study.algorithm.graph;
  2 
  3 import study.algorithm.base.*;
  4 
  5 import java.util.Arrays;
  6 
  7 /***
  8  * @Description 使用Prim算法计算一棵最小生成树 27  *
 28  * @author denny.zhang
 29  * @date 2020/5/26 9:50 上午
 30  */
 31 public class PrimMST {
 32     private static final double FLOATING_POINT_EPSILON = 1E-12;
 33 
 34     /**
 35      * 顶点索引，树顶点到非树顶点的最短边(距离树最近的边)
 36      */
 37     private Edge[] edgeTo;
 38     /**
 39      * 顶点索引，最短边的权重
 40      */
 41     private double[] distTo;
 42     /**
 43      * 顶点索引，标记顶点是否在最小生成树中
 44      */
 45     private boolean[] marked;
 46     /**
 47      * 有效的横切边（索引最小优先队列，索引为顶点v,值pq[v]=edgeTo[v].weight()=distTo[v]）
 48      */
 49     private IndexMinPQ<Double> pq;
 50 
 51     /**
 52      * 计算一个边加权图的最小生成树
 53      * @param G the edge-weighted graph
 54      */
 55     public PrimMST(EdgeWeightedGraph G) {
 56         // 初始化3个顶点索引数组
 57         edgeTo = new Edge[G.V()];
 58         distTo = new double[G.V()];
 59         marked = new boolean[G.V()];
 60         // 初始化：顶点索引最小优先队列
 61         pq = new IndexMinPQ<Double>(G.V());
 62         for (int v = 0; v < G.V(); v++) {
 63             // 初始化为无穷大
 64             distTo[v] = Double.POSITIVE_INFINITY;
 65         }
 66         // 遍历顶点数
 67         for (int v = 0; v < G.V(); v++)
 68         {
 69             // 如果顶点0开始能全进树，那就一次搞定
 70             StdOut.println("v="+ v+",marked[v]="+marked[v]);
 71             // 如果没进树
 72             if (!marked[v]) {
 73                 StdOut.println("v="+v+"，执行prim");
 74                 // 最小生成树
 75                 prim(G, v);
 76             }
 77         }
 78 
 79         // 校验，可省略
 80         assert check(G);
 81     }
 82 
 83 
 84     /**
 85      * 从顶点s开始生成图G
 86      * @param G
 87      * @param s
 88      */
 89     private void prim(EdgeWeightedGraph G, int s) {
 90         // 顶点s的权重=0
 91         distTo[s] = 0.0;
 92         // 顶点s进队列，key为索引，value为边权重
 93         pq.insert(s, distTo[s]);
 94         StdOut.println("顶点s进队列:  s="+ s+",distTo[s]="+distTo[s]);
 95         StdOut.println("pq="+ Arrays.toString(pq.keys));
 96 
 97         // 循环
 98         while (!pq.isEmpty()) {
 99             // 取出最小权重边的顶点（最近的顶点）
100             int v = pq.delMin();
101             // 添加到树中
102             scan(G, v);
103         }
104     }
105 
106     /**
107      * 将顶点V添加到树中，更新数据
108      * @param G
109      * @param v
110      */
111     private void scan(EdgeWeightedGraph G, int v) {
112         StdOut.println("v="+ v+",进树");
113         // 标记 进树
114         marked[v] = true;
115         // 遍历顶点v的邻接边
116         for (Edge e : G.adj(v)) {
117             StdOut.println("遍历顶点v的邻接边：v="+ v+",e="+e.toString());
118             // 另一个顶点
119             int w = e.other(v);
120             StdOut.println("w=" + w);
121             // 如果w已进树，跳过（至少有一个点不在树中，计算才有意义）
122             if (marked[w]) {
123                 StdOut.println("已进树，跳过w=" + w);
124                 continue;
125             }
126             // 如果边e的权重 < 当前到顶点w的权重
127             if (e.weight() < distTo[w]) {
128                 StdOut.println("e.weight()="+e.weight()+" ，distTo[w]=" + distTo[w]);
129                 // 更新最小权重
130                 distTo[w] = e.weight();
131                 // 连接w和树的最佳边变为e
132                 edgeTo[w] = e;
133                 // 顶点w在pq队列中
134                 if (pq.contains(w)) {
135                     StdOut.println("顶点w在pq队列中：w="+w);
136                     // 减小w索引对应的权重值，小值上浮
137                     pq.decreaseKey(w, distTo[w]);
138                  // 顶点w不在队列中
139                 } else {
140                     StdOut.println("顶点w不在pq队列中，插入队列前：w="+w+"，pq="+ Arrays.toString(pq.keys));
141                     // 插入队列
142                     pq.insert(w, distTo[w]);
143                     StdOut.println("顶点w不在pq队列中，插入队列后：w="+w+"，pq="+Arrays.toString(pq.keys));
144                 }
145             }
146         }
147     }
148 
149     /**
150      * Returns the edges in a minimum spanning tree (or forest).
151      * @return the edges in a minimum spanning tree (or forest) as
152      *    an iterable of edges
153      */
154     public Iterable<Edge> edges() {
155         Queue<Edge> mst = new Queue<Edge>();
156         for (int v = 0; v < edgeTo.length; v++) {
157             Edge e = edgeTo[v];
158             if (e != null) {
159                 mst.enqueue(e);
160             }
161         }
162         return mst;
163     }
164 
165     /**
166      * Returns the sum of the edge weights in a minimum spanning tree (or forest).
167      * @return the sum of the edge weights in a minimum spanning tree (or forest)
168      */
169     public double weight() {
170         double weight = 0.0;
171         for (Edge e : edges()) {
172             weight += e.weight();
173         }
174         return weight;
175     }
176 
177 
178     // check optimality conditions (takes time proportional to E V lg* V)
179     private boolean check(EdgeWeightedGraph G) {
180 
181         // check weight
182         double totalWeight = 0.0;
183         for (Edge e : edges()) {
184             totalWeight += e.weight();
185         }
186         if (Math.abs(totalWeight - weight()) > FLOATING_POINT_EPSILON) {
187             System.err.printf("Weight of edges does not equal weight(): %f vs. %f\n", totalWeight, weight());
188             return false;
189         }
190 
191         // check that it is acyclic
192         UF uf = new UF(G.V());
193         for (Edge e : edges()) {
194             int v = e.either(), w = e.other(v);
195             if (uf.find(v) == uf.find(w)) {
196                 System.err.println("Not a forest");
197                 return false;
198             }
199             uf.union(v, w);
200         }
201 
202         // check that it is a spanning forest
203         for (Edge e : G.edges()) {
204             int v = e.either(), w = e.other(v);
205             if (uf.find(v) != uf.find(w)) {
206                 System.err.println("Not a spanning forest");
207                 return false;
208             }
209         }
210 
211         // check that it is a minimal spanning forest (cut optimality conditions)
212         for (Edge e : edges()) {
213 
214             // all edges in MST except e
215             uf = new UF(G.V());
216             for (Edge f : edges()) {
217                 int x = f.either(), y = f.other(x);
218                 if (f != e) {
219                     uf.union(x, y);
220                 }
221             }
222 
223             // check that e is min weight edge in crossing cut
224             for (Edge f : G.edges()) {
225                 int x = f.either(), y = f.other(x);
226                 if (uf.find(x) != uf.find(y)) {
227                     if (f.weight() < e.weight()) {
228                         System.err.println("Edge " + f + " violates cut optimality conditions");
229                         return false;
230                     }
231                 }
232             }
233 
234         }
235 
236         return true;
237     }
238 
239     public static void main(String[] args) {
240         // 读取图文件
241         In in = new In(args[0]);
242         // 初始化：边加权无向图
243         EdgeWeightedGraph G = new EdgeWeightedGraph(in);
244         // 核心算法Prim
245         PrimMST mst = new PrimMST(G);
246         // 打印全部边
247         for (Edge e : mst.edges()) {
248             StdOut.println(e);
249         }
250         // 打印总权重
251         StdOut.printf("%.5f\n", mst.weight());
252     }
253 
254 
255 }

运行方法：

使用导入文件的方式，后续只需要修改文件内容，即可执行，比较方便。8个顶点，16条边的边加权无向图，内容如下：

运行配置：

运行:

结合邻接链表来看结果，其实就是遍历了一遍邻接表。

v=0,marked[v]=false----从顶点0作为原点，构建最小生成树，---begin!
v=0，执行prim
顶点s进队列:  s=0,distTo[s]=0.0
pq=[0.0, null, null, null, null, null, null, null, null]
v=0,进树---》顶点0开始  另一个顶点： 6 2 4 7 
遍历顶点v的邻接边：v=0,e=6-0 0.58000
w=6
e.weight()=0.58 ，distTo[w]=Infinity
顶点w不在pq队列中，插入队列前：w=6，pq=[null, null, null, null, null, null, null, null, null]
顶点w不在pq队列中，插入队列后：w=6，pq=[null, null, null, null, null, null, 0.58, null, null]
遍历顶点v的邻接边：v=0,e=0-2 0.26000
w=2
e.weight()=0.26 ，distTo[w]=Infinity
顶点w不在pq队列中，插入队列前：w=2，pq=[null, null, null, null, null, null, 0.58, null, null]
顶点w不在pq队列中，插入队列后：w=2，pq=[null, null, 0.26, null, null, null, 0.58, null, null]
遍历顶点v的邻接边：v=0,e=0-4 0.38000
w=4
e.weight()=0.38 ，distTo[w]=Infinity
顶点w不在pq队列中，插入队列前：w=4，pq=[null, null, 0.26, null, null, null, 0.58, null, null]
顶点w不在pq队列中，插入队列后：w=4，pq=[null, null, 0.26, null, 0.38, null, 0.58, null, null]
遍历顶点v的邻接边：v=0,e=0-7 0.16000
w=7
e.weight()=0.16 ，distTo[w]=Infinity
顶点w不在pq队列中，插入队列前：w=7，pq=[null, null, 0.26, null, 0.38, null, 0.58, null, null]
顶点w不在pq队列中，插入队列后：w=7，pq=[null, null, 0.26, null, 0.38, null, 0.58, 0.16, null]
v=7,进树---》顶点7开始 另一个顶点： 2 1 0 5 4
遍历顶点v的邻接边：v=7,e=2-7 0.34000
w=2
遍历顶点v的邻接边：v=7,e=1-7 0.19000
w=1
e.weight()=0.19 ，distTo[w]=Infinity
顶点w不在pq队列中，插入队列前：w=1，pq=[null, null, 0.26, null, 0.38, null, 0.58, null, null]
顶点w不在pq队列中，插入队列后：w=1，pq=[null, 0.19, 0.26, null, 0.38, null, 0.58, null, null]
遍历顶点v的邻接边：v=7,e=0-7 0.16000
w=0
已进树，跳过w=0
遍历顶点v的邻接边：v=7,e=5-7 0.28000
w=5
e.weight()=0.28 ，distTo[w]=Infinity
顶点w不在pq队列中，插入队列前：w=5，pq=[null, 0.19, 0.26, null, 0.38, null, 0.58, null, null]
顶点w不在pq队列中，插入队列后：w=5，pq=[null, 0.19, 0.26, null, 0.38, 0.28, 0.58, null, null]
遍历顶点v的邻接边：v=7,e=4-7 0.37000
w=4
e.weight()=0.37 ，distTo[w]=0.38
顶点w在pq队列中：w=4
v=1,进树---》顶点1开始 另一个顶点： 3 2 7 5
遍历顶点v的邻接边：v=1,e=1-3 0.29000
w=3
e.weight()=0.29 ，distTo[w]=Infinity
顶点w不在pq队列中，插入队列前：w=3，pq=[null, null, 0.26, null, 0.37, 0.28, 0.58, null, null]
顶点w不在pq队列中，插入队列后：w=3，pq=[null, null, 0.26, 0.29, 0.37, 0.28, 0.58, null, null]
遍历顶点v的邻接边：v=1,e=1-2 0.36000
w=2
遍历顶点v的邻接边：v=1,e=1-7 0.19000
w=7
已进树，跳过w=7
遍历顶点v的邻接边：v=1,e=1-5 0.32000
w=5
v=2,进树---》顶点2开始 另一个顶点： 6 7 1 0 3
遍历顶点v的邻接边：v=2,e=6-2 0.40000
w=6
e.weight()=0.4 ，distTo[w]=0.58
顶点w在pq队列中：w=6
遍历顶点v的邻接边：v=2,e=2-7 0.34000
w=7
已进树，跳过w=7
遍历顶点v的邻接边：v=2,e=1-2 0.36000
w=1
已进树，跳过w=1
遍历顶点v的邻接边：v=2,e=0-2 0.26000
w=0
已进树，跳过w=0
遍历顶点v的邻接边：v=2,e=2-3 0.17000
w=3
e.weight()=0.17 ，distTo[w]=0.29
顶点w在pq队列中：w=3
v=3,进树---》顶点3开始 另一个顶点： 6 1 2 5
遍历顶点v的邻接边：v=3,e=3-6 0.52000
w=6
遍历顶点v的邻接边：v=3,e=1-3 0.29000
w=1
已进树，跳过w=1
遍历顶点v的邻接边：v=3,e=2-3 0.17000
w=2
已进树，跳过w=2
v=5,进树---》顶点5开始 另一个顶点： 1 7 4
w=1
已进树，跳过w=1
遍历顶点v的邻接边：v=5,e=5-7 0.28000
w=7
已进树，跳过w=7
遍历顶点v的邻接边：v=5,e=4-5 0.35000
w=4
e.weight()=0.35 ，distTo[w]=0.37
顶点w在pq队列中：w=4
v=4,进树---》顶点4开始 另一个顶点：6 0 7 5 
遍历顶点v的邻接边：v=4,e=6-4 0.93000
w=6
遍历顶点v的邻接边：v=4,e=0-4 0.38000
w=0
已进树，跳过w=0
遍历顶点v的邻接边：v=4,e=4-7 0.37000
w=7
已进树，跳过w=7
遍历顶点v的邻接边：v=4,e=4-5 0.35000
w=5
已进树，跳过w=5
v=6,进树---》顶点6开始 另一个顶点：4 0 3 2
遍历顶点v的邻接边：v=6,e=6-4 0.93000
w=4
已进树，跳过w=4
遍历顶点v的邻接边：v=6,e=6-0 0.58000
w=0
已进树，跳过w=0
遍历顶点v的邻接边：v=6,e=3-6 0.52000
w=3
已进树，跳过w=3
遍历顶点v的邻接边：v=6,e=6-2 0.40000
w=2
已进树，跳过w=2----从顶点0作为原点，构建最小生成树，---end!
v=1,marked[v]=true----从顶点1作为原点，构建最小生成树，已经入树，跳过!后续节点都已进树，都跳过。
v=2,marked[v]=true
v=3,marked[v]=true
v=4,marked[v]=true
v=5,marked[v]=true
v=6,marked[v]=true
v=7,marked[v]=true
1-7 0.19000---》打印最小生成树的边  权重
0-2 0.26000
2-3 0.17000
4-5 0.35000
5-7 0.28000
6-2 0.40000
0-7 0.16000
1.810000---》打印最小生成树的总权重

三、总结

使用二叉堆（索引小值优先队列实现）优化的Prim算法，

3.1 空间复杂度

构造了几个顶点v索引的数组，所以和顶点数v成正比。

3.2 时间复杂度

主要就在优先队列的操作上

1.PrimMST->prim中：共v个顶点，每次取出最小值pq.delMin() 取第一个最小值元素，并把最后一个元素填充，新上来的这个元素下沉sink()大值下沉,时间复杂度=logv, 共v个顶点，也就是vlogv。
2.PrimMST->prim->scan 中：遍历顶点的邻接表（邻接边链表），不管是更新更小值 decreaseKey()、还是插入新值 insert() ->都要执行swim()小值上浮，时间复杂度=logv，一共E条边，所以Elogv.

所以：O(vlgv+elgv)=ElgV

3.3. 优化

1.如果使用斐波那契堆也就是Fredman-Tarjan算法，稠密图的decreaseKey操作耗时可以降到O（1），所以总耗时=O(V*logV+E*O(1))=ElgV

2.接近线性的算法Chazelle,但算法很复杂，就不再描述。

下一节，我们分析Kruskal算法。

刷新页面返回顶部

只会一点java

公告