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

▶ 书中第四章部分程序，包括在加上自己补充的代码，有边权有向图的邻接矩阵，FloydWarshall 算法可能含负环的有边权有向图任意两点之间的最短路径

● 有边权有向图的邻接矩阵

 package package01;

 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.StdRandom;
 import edu.princeton.cs.algs4.DirectedEdge;

 public class class01
 {
     private static final String NEWLINE = System.getProperty("line.separator");

     private final int V;
     private int E;
     private DirectedEdge[][] adj;

     public class01(int inputV)
     {
         if (inputV < 0)
             throw new IllegalArgumentException("\n<Constructor> V < 0.\n");
         V = inputV;
         E = 0;
         adj = new DirectedEdge[V][V];
     }

     public class01(int inputV, int inputE)
     {
         this(inputV);
         if (inputE < 0 || inputE > V*V)
             throw new IllegalArgumentException("\n<Constructor> E < 0 || E > V*V.\n");

         for (E = 0; E != inputE;)
         {
             int v = StdRandom.uniform(V), w = StdRandom.uniform(V);
             double weight = Math.round(100 * StdRandom.uniform()) / 100.0;
             addEdge(new DirectedEdge(v, w, weight));
         }
     }

     public int V()
     {
         return V;
     }

     public int E()
     {
         return E;
     }

     public void addEdge(DirectedEdge e)
     {
         int v = e.from();
         int w = e.to();
         if (adj[v][w] == null)
         {
             E++;
             adj[v][w] = e;
         }
     }

     public Iterable<DirectedEdge> adj(int v)
     {
         return new AdjIterator(v);
     }

     private class AdjIterator implements Iterator<DirectedEdge>, Iterable<DirectedEdge>
     {
         private int v;
         private int w = 0;

         public AdjIterator(int inputV)
         {
             v = inputV;
         }

         public Iterator<DirectedEdge> iterator()
         {
             return this;
         }

         public boolean hasNext()    // 同一行里还有元素（还有以该顶点为起点的边）
         {
             for (; w < V; w++)
             {
                 if (adj[v][w] != null)
                     return true;

             }
             return false;
         }

         public DirectedEdge next()
         {
             if (!hasNext())
                 throw new NoSuchElementException();
             return adj[v][w++];
         }

         public void remove()
         {
             throw new UnsupportedOperationException();
         }
     }

     public String toString()
     {
         StringBuilder s = new StringBuilder();
         s.append(V + " " + E + NEWLINE);
         for (int v = 0; v < V; v++)
         {
             s.append(v + ": ");
             for (DirectedEdge e : adj(v))
                 s.append(e + "  ");
             s.append(NEWLINE);
         }
         return s.toString();
     }

     public static void main(String[] args)
     {
         int V = Integer.parseInt(args[0]);
         int E = Integer.parseInt(args[1]);
         class01 G = new class01(V, E);
         StdOut.println(G);
     }
 }

● FloydWarshall 算法可能含负环的有边权有向图任意两点之间的最短路径

 package package01;

 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.StdRandom;
 import edu.princeton.cs.algs4.DirectedEdge;
 import edu.princeton.cs.algs4.EdgeWeightedDigraph;
 import edu.princeton.cs.algs4.EdgeWeightedDirectedCycle;
 import edu.princeton.cs.algs4.Stack;
 import edu.princeton.cs.algs4.AdjMatrixEdgeWeightedDigraph;

 public class class01
 {
     private boolean hasNegativeCycle;  // 是否有负环
     private double[][] distTo;         // 从 v 到 w 的最短路径记作 distTo[v][w]
     private DirectedEdge[][] edgeTo;   // 从 v 到 w 的最短路径的最后一条边记作 edgeTo[v][w]

     public class01(AdjMatrixEdgeWeightedDigraph G)
     {
         int V = G.V();
         distTo = new double[V][V];
         edgeTo = new DirectedEdge[V][V];
         for (int v = 0; v < V; v++)     // 邻接表元素初始化为正无穷
         {
             for (int w = 0; w < V; w++)
                 distTo[v][w] = Double.POSITIVE_INFINITY;
         }
         for (int v = 0; v < G.V(); v++)
         {
             for (DirectedEdge e : G.adj(v))     // 添加以 v 为起点的各条边
             {
                 distTo[e.from()][e.to()] = e.weight();
                 edgeTo[e.from()][e.to()] = e;
             }
             if (distTo[v][v] >= 0.0)            // 自环归零
             {
                 distTo[v][v] = 0.0;
                 edgeTo[v][v] = null;
             }
         }
         for (int i = 0; i < V; i++)             // 循环 V 次
         {
             for (int v = 0; v < V; v++)         // 用 0 ~ i 作为中间顶点，尝试将其引入
             {
                 if (edgeTo[v][i] == null)       // v 不可达 i，跳过
                     continue;
                 for (int w = 0; w < V; w++)
                 {
                     if (distTo[v][w] > distTo[v][i] + distTo[i][w]) // 引入顶点 i 使得 v 到 w 的距离缩短
                     {
                         distTo[v][w] = distTo[v][i] + distTo[i][w]; // 正式引入顶点 i
                         edgeTo[v][w] = edgeTo[i][w];
                     }
                 }
                 if (distTo[v][v] < 0.0)         // 检测负环，条件是某顶点到自身的最短路径小于 0
                 {
                     hasNegativeCycle = true;
                     return;
                 }
             }
         }
     }

     public boolean hasNegativeCycle()
     {
         return hasNegativeCycle;
     }

     public Iterable<DirectedEdge> negativeCycle()
     {
         for (int v = 0; v < distTo.length; v++)
         {
             if (distTo[v][v] < 0.0)
             {
                 int V = edgeTo.length;
                 EdgeWeightedDigraph spt = new EdgeWeightedDigraph(V);
                 for (int w = 0; w < V; w++)         // 把与 v 有关的边加入一个含边权有向图，用类 EdgeWeightedDirectedCycle 寻找环
                 {
                     if (edgeTo[v][w] != null)       // 实际上所有从 v 延伸出去的最短路径的边都加上了
                         spt.addEdge(edgeTo[v][w]);
                 }
                 EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(spt);
                 return finder.cycle();
             }
         }
         return null;
     }

     public boolean hasPath(int s, int t)
     {

         return distTo[s][t] < Double.POSITIVE_INFINITY;
     }

     public double dist(int s, int t)
     {
         if (hasNegativeCycle())
             throw new UnsupportedOperationException("\n<dist> Negative cost cycle exists.\n");
         return distTo[s][t];
     }

     public Iterable<DirectedEdge> path(int s, int t)
     {
         if (hasNegativeCycle())
             throw new UnsupportedOperationException("\n<Iterable> Negative cost cycle exists.\n");
         if (!hasPath(s, t))
             return null;
         Stack<DirectedEdge> path = new Stack<DirectedEdge>();
         for (DirectedEdge e = edgeTo[s][t]; e != null; e = edgeTo[s][e.from()])
             path.push(e);
         return path;
     }

     public static void main(String[] args)
     {
         int V = Integer.parseInt(args[0]);
         int E = Integer.parseInt(args[1]);
         AdjMatrixEdgeWeightedDigraph G = new AdjMatrixEdgeWeightedDigraph(V);
         for (int i = 0; i < E; i++)
         {
             int v = StdRandom.uniform(V);
             int w = StdRandom.uniform(V);
             double weight = Math.round(100 * (StdRandom.uniform() - 0.15)) / 100.0;
             if (v == w) G.addEdge(new DirectedEdge(v, w, Math.abs(weight)));
             else G.addEdge(new DirectedEdge(v, w, weight));
         }

         StdOut.println(G);
         class01 spt = new class01(G);
         StdOut.printf("  ");
         for (int v = 0; v < G.V(); v++)
             StdOut.printf("%6d ", v);
         StdOut.println();
         for (int v = 0; v < G.V(); v++)
         {
             StdOut.printf("%3d: ", v);
             for (int w = 0; w < G.V(); w++)
             {
                 if (spt.hasPath(v, w))
                     StdOut.printf("%6.2f ", spt.dist(v, w));
                 else
                     StdOut.printf("  Inf ");    // 存在负环的路径长度显示为负无穷
             }
             StdOut.println();
         }
         if (spt.hasNegativeCycle())             // 有负环单独显示，否则正常显示各条最短路径
         {
             StdOut.println("Negative cost cycle:");
             for (DirectedEdge e : spt.negativeCycle())
                 StdOut.println(e);
             StdOut.println();
         }
         else
         {
             for (int v = 0; v < G.V(); v++)
             {
                 for (int w = 0; w < G.V(); w++)
                 {
                     if (spt.hasPath(v, w)) {
                         StdOut.printf("%d to %d (%5.2f)  ", v, w, spt.dist(v, w));
                         for (DirectedEdge e : spt.path(v, w))
                             StdOut.print(e + "  ");
                         StdOut.println();
                     }
                     else
                         StdOut.printf("%d to %d no path\n", v, w);
                 }
             }
         }
     }
 }