Пример #1
0
  // 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++;
 }
Пример #3
0
 /**
  * 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;
 }
Пример #4
0
 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;
  }
Пример #6
0
 /**
  * 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++;
 }
Пример #7
0
 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;
 }
Пример #8
0
 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;
     }
   }
 }
Пример #9
0
 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]);
     }
   }
 }
Пример #10
0
  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); // 将边添加到最小生成树中
    }
  }
Пример #11
0
  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);
    }
  }
Пример #12
0
 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);
 }
Пример #13
0
 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;
 }
Пример #14
0
  /**
   * 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);
  }
Пример #15
0
  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);
      }
    }
  }
Пример #16
0
  // 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);
  }
Пример #17
0
	public void addEdge(Edge e){//这个要着重看下很重要哦,这个才是图形成的关键
		int v = e.either();w=e.other();
		adj[v].add(e);
		adj[w].add(e);
		E++;
	}
Пример #18
0
 private void visit(EdgeWeightedGraph G, int v) {
   marked[v] = true;
   for (Edge e : G.adj(v)) {
     if (!marked[e.other(v)]) pq.offer(e);
   }
 }