// 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; }
/** Add the undirected edge e to this graph. */ public void addEdge(Edge e) { int v = e.either(); int w = e.other(v); adj[v].add(e); adj[w].add(e); E++; }
/** * Returns all edges in the edge-weighted graph. To iterate over the edges in the edge-weighted * graph, use foreach notation: <tt>for (Edge e : G.edges())</tt>. * * @return all edges in the edge-weighted graph as an Iterable. */ public Iterable<Edge> edges() { Bag<Edge> list = new Bag<Edge>(); for (int v = 0; v < V; v++) { int selfLoops = 0; for (Edge e : adj(v)) { if (e.other(v) > v) { list.add(e); } // only add one copy of each self loop (self loops will be consecutive) else if (e.other(v) == v) { if (selfLoops % 2 == 0) list.add(e); selfLoops++; } } } return list; }
private void visit(EdgeWeightedGraph G, int v) { // Mark v and add to pq all edges from v to unmarked vertices. marked[v] = true; for (Edge e : G.adj(v)) { if (!marked[e.other(v)]) { pq.insert(e); } } }
public Iterable<Edge> edges() { Bag<Edge> edges = new Bag<Edge>(); for (int i = 0; i < V; i++) { for (Edge be : adj(i)) { if (i < be.other(i)) edges.add(be); } } return edges; }
/** * Adds the undirected edge <tt>e</tt> to the edge-weighted graph. * * @param e the edge * @throws java.lang.IndexOutOfBoundsException unless both endpoints are between 0 and V-1 */ public void addEdge(Edge e) { int v = e.either(); int w = e.other(v); if (v < 0 || v >= V) throw new IndexOutOfBoundsException("vertex " + v + " is not between 0 and " + (V - 1)); if (w < 0 || w >= V) throw new IndexOutOfBoundsException("vertex " + w + " is not between 0 and " + (V - 1)); adj[v].add(e); adj[w].add(e); E++; }
public Set<Node> getConnectedNodes(Node node) { Set<Edge> edges = this.getEdges(node); if (edges == null) { return null; } Set<Node> nodes = new HashSet<>(); for (Edge e : edges) { nodes.add(e.other(node)); } return nodes; }
public void visit(int v) { marked[v] = true; for (Edge e : G.adj(v)) { int w = e.other(v); if (marked[w]) continue; if (disTo[w] > e.weight()) { disTo[w] = e.weight(); if (!pq.contains(w)) { pq.insert(w, e.weight()); } else pq.changeKey(w, e.weight()); edgeTo[w] = v; } } }
private void visit(EdgeWeightedGraph G, int v) // Add v to tree; update data structures. { marked[v] = true; for (Edge e : G.adj(v)) { int w = e.other(v); if (marked[w]) continue; // v-w is ineligible. if (e.weight() < distTo[w]) // Edge e is new best connection from tree to w. { edgeTo[w] = e; distTo[w] = e.weight(); if (pq.contains(w)) pq.change(w, distTo[w]); else pq.insert(w, distTo[w]); } } }
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 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); } }
private Node exploreNode(Set<Node> nodes, Node node) { this.permanentNodes.add(node); nodes.remove(node); Set<Edge> edges = this.graph.getEdges(node); if (edges == null) { throw new IllegalStateException("Node not connected. Node: " + node); } int nodeLabel = this.getLabel(node); for (Edge edge : edges) { Node other = edge.other(node); if (this.permanentNodes.contains(other)) { continue; } this.setLabel(other, nodeLabel + edge.getWeight()); nodes.add(other); } return this.closestNode(nodes); }
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; }
/** * 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 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); } } }
// 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); }
public void addEdge(Edge e){//这个要着重看下很重要哦,这个才是图形成的关键 int v = e.either();w=e.other(); adj[v].add(e); adj[w].add(e); E++; }
private void visit(EdgeWeightedGraph G, int v) { marked[v] = true; for (Edge e : G.adj(v)) { if (!marked[e.other(v)]) pq.offer(e); } }