《算法》第四章部分程序 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("
<Constructor> Digraph is not acyclic.
");
        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
", 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
", i, lp.distTo(i), lp.distTo(i + n));
        StdOut.printf("Finish time: %7.1f
", lp.distTo(sink));
    }
}