《算法》第四章部分程序 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("
<Constructor> V < 0.
");
        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("
<Constructor> E < 0 || E > V*V.
");

        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("
<dist> Negative cost cycle exists.
");
        return distTo[s][t];
    }

    public Iterable<DirectedEdge> path(int s, int t)
    {
        if (hasNegativeCycle())
            throw new UnsupportedOperationException("
<Iterable> Negative cost cycle exists.
");
        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
", v, w);
                }
            }
        }
    }
}