Beispiel #1
0
  public static void main(String[] args) {
    In in = new In("jobsPC1.txt");
    int N = in.readInt();
    in.readLine();
    EdgeWeightedDigraph G;
    G = new EdgeWeightedDigraph(2 * N + 2);
    int s = 2 * N, t = 2 * N + 1;
    for (int i = 0; i < N; ++i) {
      String[] a = in.readLine().split("\\s+");
      double duration = Double.parseDouble(a[0]);
      G.addEdge(new DirectedEdge(i, i + N, duration));
      G.addEdge(new DirectedEdge(s, i, 0.0));
      G.addEdge(new DirectedEdge(i + N, t, 0.0));
      for (int j = 1; j < a.length; ++j) {
        G.addEdge(new DirectedEdge(i + N, Integer.parseInt(a[j]), 0));
      }
    }
    StdOut.println(G);
    MyAcyclicLP lp = new MyAcyclicLP(G, s);

    StdOut.println("Start times: ");
    for (int i = 0; i < N; ++i) StdOut.printf("%4d: %5.1f\n", i, lp.distTo(i));
    StdOut.printf("%5.1f\n", lp.distTo(t));

    for (DirectedEdge e : lp.pathTo(t)) {
      StdOut.print(e + " ");
    }
    StdOut.println();
  }
Beispiel #2
0
 public DepthFirstOrder(EdgeWeightedDigraph G) {
   pre = new int[G.V()];
   post = new int[G.V()];
   postorder = new Queue<Integer>();
   preorder = new Queue<Integer>();
   marked = new boolean[G.V()];
   for (int v = 0; v < G.V(); v++) if (!marked[v]) dfs(G, v);
 }
  public EdgeWeightedDirectedCycle(EdgeWeightedDigraph G) {
    marked = new boolean[G.V()];
    onStack = new boolean[G.V()];
    edgeTo = new DirectedEdge[G.V()];
    for (int v = 0; v < G.V(); v++) if (!marked[v]) dfs(G, v);

    // check that digraph has a cycle
    assert check(G);
  }
Beispiel #4
0
 /**
  * Método recursivo usado para la obtención de todos los caminos posibles dentro de un árbol. Si
  * un nodo tiene un outdegree igual a 0, es una hoja, y el camino ha terminado. De lo contrario,
  * debe continuar buscando caminos entre los nodos adyacentes al primer nodo mencionado.
  *
  * @param G Grafo dirigido y con pesos sobre el cual se están buscando caminos.
  * @param node Nodo que se está visitando actualmente.
  * @param weight Peso actual del camino.
  * @param path Representaoión como String del camino que se ha seguido hasta el nodo actual.
  */
 private void getPaths(EdgeWeightedDigraph G, Integer node, double weight, String path) {
   if (G.outdegree(node) == 0) this.paths.put(weight, path);
   else
     for (DirectedEdge edge : G.adj(node))
       this.getPaths(
           G,
           edge.to(),
           weight + edge.weight(),
           path + "| " + edge.from() + " -> " + edge.to() + " | ");
 }
Beispiel #5
0
	private boolean findNegativeCycle(){
		int V =  edgeTo.length;
		EdgeWeightedDigraph spt;
		spt = new EdgeWeightedDigraph(V);
		for (int v = 0 ; v < V ; v++ ) {
			if(edgeTo[v] !=null) 
				spt.addEdge(edgeTo[v]);
		}
		EdgeWeightedCycleFinder cf ; 
		cf = new EdgeWeightedCycleFinder(spt);
		cycle = cf.cycle();
	}
Beispiel #6
0
	public DijkstraSP(EdgeWeightedDigraph G , int s){
		edgeTo =new DirectedEdge[G.V()];
		distTo =new double[G.V()];
		pq = new  IndexMinPQ<Double>(G.V());

		for(int v = 0 ; v < G.V() ; v++) distTo[v] = Double.POSITIVE_INFINITY;
		distTo[s]=0;
		pq.insert(s,0.0);
		while(!pq.isEmpty()){
			relax(G,pq.delMin());
		}
	}
  public AcyclicLP(EdgeWeightedDigraph G, int s) {
    distTo = new double[G.V()];
    edgeTo = new DirectedEdge[G.V()];
    for (int v = 0; v < G.V(); v++) distTo[v] = Double.NEGATIVE_INFINITY;
    distTo[s] = 0.0;

    // relax vertices in toplogical order
    Topological topological = new Topological(G);
    for (int v : topological.order()) {
      for (DirectedEdge e : G.adj(v)) relax(e);
    }
  }
  public SingleSourceShortestPaths(EdgeWeightedDigraph G, int source) {
    this.source = source;

    this.distTo = new double[G.V()];
    this.edgeTo = new DirectedEdge[G.V()];

    for (int v = 0; v < G.V(); ++v) {
      this.distTo[v] = Double.POSITIVE_INFINITY;
    }

    this.distTo[this.source] = 0.0;
  }
Beispiel #9
0
	public AcyclicSP(EdgeWeightedDigraph G ,int s){
		edgeTo = new DirectedEdge[G.V()];
		distTo = new double[G.V()];

		for(int v = 0 ; v < G.V() ; v++){
			distTo[v] = Double.POSITIVE_INFINITY;
		}
		distTo[s] = 0.0;
		Topological top = new Topological(G);
		for(int v:top.order()){
			relax(G,v);
		}
	}
Beispiel #10
0
	private void findNegativeCycle(){
		int V = edgeTo.length;
		EdgeWeightedDigraph spt ; 
		spt = new EdgeWeightedDigraph;
		for (int v = 0 ; v < V ; v++ ) {
			if(edgeTo[v] !=null ){
				spt.addEdge(edgeTo[v]);
			}
		}
		EdgeWeightedCycleFinder cf;
		cf = new EdgeWeightedCycleFinder(spt);
		cycle = cf.cycle();//cycle()方法来自4.2界
	}
Beispiel #11
0
	private void relax(EdgeWeightedDigraph G ,int v){
		for(DirectedEdge e:G.adj(v)){
			int w = e.to();
			if(distTo[w]>distTo[v]+e.weight()){
				distTo[w] = distTo[v]+e.weight();
				edgeTo[w] = e;
				if(!onQ[w]){
					q.enqueue(w);
					onQ[w] = true;
				}
			}
			if(cost++ %G.V() == 0 ) findNegativeCycle();
		}
	}
 /**
  * Initializes a new edge-weighted digraph that is a deep copy of <tt>G</tt>.
  *
  * @param G the edge-weighted digraph to copy
  */
 public EdgeWeightedDigraph(EdgeWeightedDigraph 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<DirectedEdge> reverse = new Stack<DirectedEdge>();
     for (DirectedEdge e : G.adj[v]) {
       reverse.push(e);
     }
     for (DirectedEdge e : reverse) {
       adj[v].add(e);
     }
   }
 }
 /** @param args */
 public static void main(String[] args) {
   // TODO Auto-generated method stub
   In in = new In("E:\\jwork\\algs4-data\\tinyEWDAG.txt");
   EdgeWeightedDigraph G = new EdgeWeightedDigraph(in);
   int s = 5;
   AcyclicLP sp = new AcyclicLP(G, s);
   for (int i = 0; i < G.V(); i++) {
     System.out.printf(s + "-" + i + ":%.2f\n", sp.distTo(i));
     for (DirectedEdge edge : sp.pathTo(i)) {
       System.out.print(edge + " ");
     }
     System.out.println();
   }
 }
  // check that algorithm computes either the topological order or finds a directed cycle
  private void dfs(EdgeWeightedDigraph G, int v) {
    onStack[v] = true;
    marked[v] = true;
    for (DirectedEdge e : G.adj(v)) {
      int w = e.to();

      // short circuit if directed cycle found
      if (cycle != null) return;

      // found new vertex, so recur
      else if (!marked[w]) {
        edgeTo[w] = e;
        dfs(G, w);
      }

      // trace back directed cycle
      else if (onStack[w]) {
        cycle = new Stack<DirectedEdge>();
        while (e.from() != w) {
          cycle.push(e);
          e = edgeTo[e.from()];
        }
        cycle.push(e);
      }
    }

    onStack[v] = false;
  }
Beispiel #15
0
	public BellmanFordSP(EdgeWeightedDigraph G ,int s){
		distTo = new double[G.V()];
		edgeTo = new DirectedEdge[G.V()];
		onQ = new boolean[G.V()];
		queue = new Queue<Integer>();

		for(int v = 0 ; v < G.V() ; v++) distTo[v] = Double.POSITIVE_INFINITY;

		distTo[s] = 0.0;

		onQ[s]=true;
		while(!queue.isEmpty() && !hasNegativeCycle()){
			int v = queue.dequeue();
			onQ[v] = false;
			relax(G,v);
		}
	}
  public static void main(String[] args) {

    // create random DAG with V vertices and E edges; then add F random edges
    int V = Integer.parseInt(args[0]);
    int E = Integer.parseInt(args[1]);
    int F = Integer.parseInt(args[2]);
    EdgeWeightedDigraph G = new EdgeWeightedDigraph(V);
    int[] vertices = new int[V];
    for (int i = 0; i < V; i++) vertices[i] = i;
    StdRandom.shuffle(vertices);
    for (int i = 0; i < E; i++) {
      int v, w;
      do {
        v = StdRandom.uniform(V);
        w = StdRandom.uniform(V);
      } while (v >= w);
      double weight = Math.random();
      G.addEdge(new DirectedEdge(v, w, weight));
    }

    // add F extra edges
    for (int i = 0; i < F; i++) {
      int v = (int) (Math.random() * V);
      int w = (int) (Math.random() * V);
      double weight = Math.random();
      G.addEdge(new DirectedEdge(v, w, weight));
    }

    StdOut.println(G);

    // find a directed cycle
    EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(G);
    if (finder.hasCycle()) {
      StdOut.print("Cycle: ");
      for (DirectedEdge e : finder.cycle()) {
        StdOut.print(e + " ");
      }
      StdOut.println();
    }

    // or give topologial sort
    else {
      StdOut.println("No directed cycle");
    }
  }
Beispiel #17
0
	public void relax(EdgeWeightedDigraph G , int v){//vertex relaxation
		for(DirectedEdge e: G.adj(v)){//没有遍历树,只是遍历了从v指向的所有边(edges)
			int w = e.to();
			if(distTo[w]>distTo[v]+e.weight){
				distTo[w]=distTo[v]+e.weight;
				edgeTo[w]=e;
			}
		}
	}
 private void relax(EdgeWeightedDigraph G, int v) {
   for (DirectedEdge edge : G.adj(v)) {
     int w = edge.to();
     if (distTo[w] < distTo[v] + edge.weight()) {
       distTo[w] = distTo[v] + edge.weight();
       edgeTo[w] = edge;
     }
   }
 }
  public static void main(String[] args) {
    In in = new In(args[0]);
    int s = Integer.parseInt(args[1]);
    EdgeWeightedDigraph G = new EdgeWeightedDigraph(in);

    AcyclicLP lp = new AcyclicLP(G, s);

    for (int v = 0; v < G.V(); v++) {
      if (lp.hasPathTo(v)) {
        StdOut.printf("%d to %d (%.2f)  ", s, v, lp.distTo(v));
        for (DirectedEdge e : lp.pathTo(v)) {
          StdOut.print(e + "   ");
        }
        StdOut.println();
      } else {
        StdOut.printf("%d to %d         no path\n", s, v);
      }
    }
  }
Beispiel #20
0
	private void relax(EdgeWeightedDigraph G ,int v){
		for(DirectedEdge e:G.adj(V)){
			int w = e.to();
			if(distTo[w]>distTo[v]+e.weight()){
				distTo[w] = distTo[v]+e.weight();
				edgeTo[w] = e;
				if(pq.contains(w)) pq.change(w,distTo[w]);
				else pq.insert(w,distTo[w]);
			}
		}
	}
Beispiel #21
0
 // run DFS in edge-weighted digraph G from vertex v and compute preorder/postorder
 private void dfs(EdgeWeightedDigraph G, int v) {
   marked[v] = true;
   pre[v] = preCounter++;
   preorder.enqueue(v);
   for (DirectedEdge e : G.adj(v)) {
     int w = e.to();
     if (!marked[w]) {
       dfs(G, w);
     }
   }
   postorder.enqueue(v);
   post[v] = postCounter++;
 }
Beispiel #22
0
	public static void main(String[] args){
		int N = StdIn.readInt();StdIn.readLine();
		EdgeWeightedDigraph G ;
		G = new EdgeWeightedDigraph(2*N+2);
		int s = 2*N ,t = 2*N+1;
		for(int i = 0 ; i < N ; i++){
			String[] a = StdIn.readLine().split("\\s+");
			double duration = Double.parseDouble(a[0]);
			G.addEdge(new DirectedEdge(i,i+N,duration));
			G.addEdge(new DirectedEdge(s,i,0.0));
			G.addEdge(new DirectedEdge(i+N,t,0.0));
			for(int j  = 1 ;  j  < a.length ; j++){
				int sucessor = Integer.parseInt(a[j]);
				G.addEdge(new DirectedEdge(i+N,sucessor,0.0));
			}
		}
		AcyclicSP lp = new AcyclicSP(G,s);
		StdOut.println("START TIME:");
		for(int i  = 0 ; i  < N ; i++){
			StdOut.printf("%4d:%5.1f\n",i,lp.distTo(i));
			StdOut.printf("finish time :%5.1f\n",lp.distTo(t));
		}
	}
 public AcyclicLP(EdgeWeightedDigraph G, int s) {
   this.s = s;
   distTo = new double[G.V()];
   for (int i = 0; i < distTo.length; i++) {
     distTo[i] = INFINITY;
   }
   edgeTo = new DirectedEdge[G.V()];
   EdgeWeightedTopologicalOrder order = new EdgeWeightedTopologicalOrder(G);
   int count = 0;
   int kb = Integer.MAX_VALUE;
   edgeTo[s] = null;
   distTo[s] = 0; /* initialize*/
   for (int i : order.reversePost()) {
     if (i == s) {
       kb = count;
     }
     if (count < kb) {
       count++;
       continue;
     }
     relax(G, i);
   }
 }
  /**
   * Reads the precedence constraints from standard input and prints a feasible schedule to standard
   * output.
   */
  public static void main(String[] args) {

    // number of jobs
    int N = StdIn.readInt();

    // source and sink
    int source = 2 * N;
    int sink = 2 * N + 1;

    // build network
    EdgeWeightedDigraph G = new EdgeWeightedDigraph(2 * N + 2);
    for (int i = 0; i < N; i++) {
      double duration = StdIn.readDouble();
      G.addEdge(new DirectedEdge(source, i, 0.0));
      G.addEdge(new DirectedEdge(i + N, sink, 0.0));
      G.addEdge(new DirectedEdge(i, i + N, duration));

      // precedence constraints
      int M = StdIn.readInt();
      for (int j = 0; j < M; j++) {
        int precedent = StdIn.readInt();
        G.addEdge(new DirectedEdge(N + i, precedent, 0.0));
      }
    }

    // compute longest path
    AcyclicLP lp = new AcyclicLP(G, source);

    // print results
    StdOut.println(" job   start  finish");
    StdOut.println("--------------------");
    for (int i = 0; i < N; i++) {
      StdOut.printf("%4d %7.1f %7.1f\n", i, lp.distTo(i), lp.distTo(i + N));
    }
    StdOut.printf("Finish time: %7.1f\n", lp.distTo(sink));
  }
Beispiel #25
0
	DisjkstraAllPairsSP(EdgeWeightedDigraph G){
		all = new DijkstraSP[G.V()];
		for(int v = 0 ; v < G.V() ; v++){
			all[v] = new DijkstraSP(G,v);
		}
	}