《算法》第四章部分程序 part 17

▶ 书中第四章部分程序，包括在加上自己补充的代码，无环图最短 / 最长路径通用程序，关键路径方法（critical path method）解决任务调度问题

● 无环图最短 / 最长路径通用程序

 package package01;

 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.Topological;
 import edu.princeton.cs.algs4.DirectedEdge;
 import edu.princeton.cs.algs4.EdgeWeightedDigraph;
 import edu.princeton.cs.algs4.Stack;

 public class class01
 {
     private double[] distTo;        // 起点到各顶点的距离
     private DirectedEdge[] edgeTo;  // 引入各顶点时引入的边

     public class01(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.POSITIVE_INFINITY;       // 求最长路径时改为 distTo[v] = Double.POSITIVE_INFINITY;
         distTo[s] = 0.0;
         Topological topological = new Topological(G);   // 堆图 G 进行拓扑排序
         if (!topological.hasOrder())
             throw new IllegalArgumentException("\n<Constructor> Digraph is not acyclic.\n");
         for (int v : topological.order())               // 依照拓扑顺序松弛每条边
         {
             for (DirectedEdge e : G.adj(v))
                 relax(e);
         }
     }

     private void relax(DirectedEdge e)
     {
         int v = e.from(), w = e.to();
         if (distTo[w] > distTo[v] + e.weight())     // 加入这条边会使起点到 w 的距离变短
         {                                           // 求最长路径时将其改为 if (distTo[w] < distTo[v] + e.weight())
             distTo[w] = distTo[v] + e.weight();     // 确认加入该边
             edgeTo[w] = e;
         }
     }

     public double distTo(int v)
     {
         return distTo[v];
     }

     public boolean hasPathTo(int v)
     {
         return distTo[v] < Double.POSITIVE_INFINITY;// 求最长路径时将其改为 return distTo[v] < Double.POSITIVE_INFINITY;
     }

     public Iterable<DirectedEdge> pathTo(int v)
     {
         if (!hasPathTo(v))
             return null;
         Stack<DirectedEdge> path = new Stack<DirectedEdge>();
         for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()])
             path.push(e);
         return path;
     }

     public static void main(String[] args)
     {
         In in = new In(args[0]);
         int s = Integer.parseInt(args[1]);
         EdgeWeightedDigraph G = new EdgeWeightedDigraph(in);
         class01 sp = new class01(G, s);
         for (int v = 0; v < G.V(); v++)
         {
             if (sp.hasPathTo(v))
             {
                 StdOut.printf("%d to %d (%.2f)  ", s, v, sp.distTo(v));
                 for (DirectedEdge e : sp.pathTo(v))
                     StdOut.print(e + "   ");
                 StdOut.println();
             }
             else
                 StdOut.printf("%d to %d         no path\n", s, v);
         }
     }
 }

● 关键路径方法（critical path method）解决任务调度问题

 package package01;

 import edu.princeton.cs.algs4.StdIn;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.AcyclicLP;
 import edu.princeton.cs.algs4.DirectedEdge;
 import edu.princeton.cs.algs4.EdgeWeightedDigraph;

 public class class01
 {
     private class01() {}

     public static void main(String[] args)
     {
         int n = StdIn.readInt();                                // 任务数
         int source = 2 * n;                                     // 0 ~ n-1 为各任务起点，n ~ 2n-1 为各任务终点
         int sink = 2 * n + 1;                                   // 2n 为总起点，2n + 1 为总终点
         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));    // 任务起点到任务终点的边

             int m = StdIn.readInt();                                // 以该任务完成为前提的其他任务数
             for (int j = 0; j < m; j++)
             {
                 int precedent = StdIn.readInt();                    // 后续任务的编号
                 G.addEdge(new DirectedEdge(n + i, precedent, 0.0)); // 添加本任务终点到后续任务起点的边
             }
         }

         AcyclicLP lp = new AcyclicLP(G, source);    // 生成最长路径图，尽量选权值较大的边意味着尽量把任务往前靠
         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));
     }
 }