// check optimality conditions (takes time proportional to E V lg* V) private boolean check(EdgeWeightedGraph G) { // check total weight double total = 0.0; for (Edge e : edges()) { total += e.weight(); } double EPSILON = 1E-12; if (Math.abs(total - weight()) > EPSILON) { System.err.printf("Weight of edges does not equal weight(): %f vs. %f\n", total, weight()); return false; } // check that it is acyclic UF uf = new UF(G.V()); for (Edge e : edges()) { int v = e.either(), w = e.other(v); if (uf.connected(v, w)) { System.err.println("Not a forest"); return false; } uf.union(v, w); } // check that it is a spanning forest for (Edge e : edges()) { int v = e.either(), w = e.other(v); if (!uf.connected(v, w)) { System.err.println("Not a spanning forest"); return false; } } // check that it is a minimal spanning forest (cut optimality conditions) for (Edge e : edges()) { int v = e.either(), w = e.other(v); // all edges in MST except e uf = new UF(G.V()); for (Edge f : mst) { int x = f.either(), y = f.other(x); if (f != e) uf.union(x, y); } // check that e is min weight edge in crossing cut for (Edge f : G.edges()) { int x = f.either(), y = f.other(x); if (!uf.connected(x, y)) { if (f.weight() < e.weight()) { System.err.println("Edge " + f + " violates cut optimality conditions"); return false; } } } } return true; }
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<Double>(G.V()); distTo[0] = 0.0; pq.insert(0, 0.0); // Initialize pq with 0, weight 0. while (!pq.isEmpty()) visit(G, pq.delMin()); // Add closest vertex to tree. }
/** * Initializes a new edge-weighted graph that is a deep copy of <tt>G</tt>. * * @param G the edge-weighted graph to copy */ public EdgeWeightedGraph(EdgeWeightedGraph G) { this(G.V()); this.E = G.E(); for (int v = 0; v < G.V(); v++) { // reverse so that adjacency list is in same order as original Stack<Edge> reverse = new Stack<Edge>(); for (Edge e : G.adj[v]) { reverse.push(e); } for (Edge e : reverse) { adj[v].add(e); } } }
public KruskalMST(EdgeWeightedGraph G) { mst = new Queue<Edge>(); MaxPQ<Edge> pq = new MaxPQ<Edge>(); 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.delMax(); // 从pq得到权重最小的边和他的顶点 int v = e.either(), w = e.other(v); if (uf.connected(v, w)) continue; // 忽略失效的边,两个顶点已经在生成树中了 uf.union(v, w); // 否则将两者合并,在一个树中,顶点 mst.enqueue(e); // 将边添加到最小生成树中 } }
public MyPrimMST(EdgeWeightedGraph G) { this.G = G; pq = new IndexMinPQ<Double>(G.V()); disTo = new double[G.V()]; edges = new Bag<Edge>(); for (int i = 0; i < G.V(); ++i) disTo[i] = Double.POSITIVE_INFINITY; edgeTo = new int[G.V()]; marked = new boolean[G.V()]; disTo[0] = 0.0; visit(0); while (!pq.isEmpty()) { int v = pq.delMin(); weight += disTo[v]; edges.add(new Edge(v, edgeTo[v], disTo[v])); visit(v); } }
KruskalMST(EdgeWeightedGraph G) { MinPQ<Edge> pq = new MinPQ<Edge>(); // we dont need to pass a new comparator let it // follow the natural ordering of edges double temp_wt = 0; for (Edge e : G.edges()) pq.insert(e); UF set = new UF(G.V()); while (!pq.isEmpty() && mst.size() < (G.V() - 1)) { Edge e = pq.delMin(); int v = e.either(); int w = e.other(v); if (!set.connected(v, w)) { set.union(v, w); mst.add(e); temp_wt += e.weight(); } } this.weight = temp_wt; }
// Kruskal's algorithm public KruskalMST(EdgeWeightedGraph G) { // more efficient to build heap by passing array of edges MinPQ<Edge> pq = new MinPQ<Edge>(); for (Edge e : G.edges()) { pq.insert(e); } // run greedy algorithm UF uf = new UF(G.V()); while (!pq.isEmpty() && mst.size() < G.V() - 1) { Edge e = pq.delMin(); int v = e.either(); int w = e.other(v); if (!uf.connected(v, w)) { // v-w does not create a cycle uf.union(v, w); // merge v and w components mst.enqueue(e); // add edge e to mst weight += e.weight(); } } // check optimality conditions assert check(G); }
/** * Dado un grafo no dirigido y con pesos, ejecuta el algoritmo de Kruskal para la obtención del su * árbol de cobertura mínima. * * @param G Grafo no dirigido con pesos al cual se le deesea obtener su arbol de cobertura mínima. */ public void minimumSpanningTree(EdgeWeightedGraph G) // By Kruskal's algorithm { LinkedList<Edge> mst = new LinkedList<>(); MinPQ<Edge> pq = new MinPQ<>(G.E()); for (Edge edge : G.edges()) // Bag<Edge> != Comparator<Edge> :c pq.insert(edge); UF uf = new UF(G.V()); while (!pq.isEmpty() && mst.size() < G.V() - 1) { Edge edge = pq.delMin(); int v = edge.either(), w = edge.other(v); if (!uf.connected(v, w)) { uf.union(v, w); mst.add(edge); } } System.out.println(""); for (Edge edge : mst) System.out.println(edge); }
public LazyPrimMST(EdgeWeightedGraph G) { pq = new PriorityQueue<>(Collections.reverseOrder()); marked = new boolean[G.V()]; mst = new LinkedList<>(); visit(G, 0); while (!pq.isEmpty()) { Edge e = pq.poll(); int v = e.either(); int w = e.other(v); if (marked[v] && marked[w]) continue; mst.offer(e); if (!marked[v]) visit(G, v); if (!marked[w]) visit(G, w); } }
public LazyPrimMST(EdgeWeightedGraph G) { pq = new MinPQ<Edge>(); marked = new boolean[G.V()]; mst = new Queue<Edge>(); visit(G, 0); // assumes G is connected (see ex. 4.3.22) while (!pq.isEmpty()) { Edge e = pq.delMin(); // Get lowest-weight from pq. int v = e.either(); int w = e.other(v); if (marked[v] && marked[w]) { continue; // Skip if ineligible } mst.enqueue(e); // Add edge to tree if (!marked[v]) { // Add vertex to tree (either v or w). visit(G, v); } if (!marked[w]) { visit(G, w); } } }