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

▶ 书中第四章部分程序，包括在加上自己补充的代码，在有权有向图中寻找环，Bellman - Ford 算法求最短路径，套汇算法

● 在有权有向图中寻找环

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.Stack;

public class class01
{
    private boolean[] marked;
    private DirectedEdge[] edgeTo;
    private boolean[] onStack;              // 各顶点当前是否在搜索栈中，递归回退时要清空
    private Stack<DirectedEdge> cycle;      // 存储环，若空则表示图中不存在环

    public class01(EdgeWeightedDigraph G)
    {
        marked = new boolean[G.V()];
        edgeTo = new DirectedEdge[G.V()];
        onStack = new boolean[G.V()];
        for (int v = 0; v < G.V(); v++)
        {
            if (!marked[v])
                dfs(G, v);
        }
    }

    private void dfs(EdgeWeightedDigraph G, int v)
    {
        marked[v] = true;
        onStack[v] = true;
        for (DirectedEdge e : G.adj(v))
        {
            int w = e.to();
            if (cycle != null)              // 已经有环了
                return;
            if (!marked[w])
            {
                edgeTo[w] = e;
                dfs(G, w);
            }
            else if (onStack[w])            // 该点已经遍历过，且在栈中，即有环
            {
                cycle = new Stack<DirectedEdge>();
                DirectedEdge f = e;
                for (; f.from() != w; f = edgeTo[f.from()]) // 回退搜索栈压入 cycle 中，直到该环在搜索栈中的首元素 w 处
                    cycle.push(f);
                cycle.push(f);              // 压入环在搜索栈中的首元素 w
                return;
            }
        }
        onStack[v] = false;                 // 递归回退时栈要清空，但 marked 不清空
    }

    public boolean hasCycle()
    {
        return cycle != null;
    }

    public Iterable<DirectedEdge> cycle()
    {
        return cycle;
    }

    public static void main(String[] args)
    {
        int V = Integer.parseInt(args[0]);  // 新建有边权有向图 G(E,V)，再添加 F 条边
        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 = 1, w = 0;
            for (; v >= w; v = StdRandom.uniform(V), w = StdRandom.uniform(V));
            double weight = StdRandom.uniform();
            G.addEdge(new DirectedEdge(v, w, weight));
        }
        for (int i = 0; i < F; i++)
        {
            int v = StdRandom.uniform(V), w = StdRandom.uniform(V);
            double weight = StdRandom.uniform(0.0, 1.0);
            G.addEdge(new DirectedEdge(v, w, weight));
        }

        StdOut.println(G);                  // 原图
        class01 finder = new class01(G);    // 搜索环
        if (finder.hasCycle())
        {
            StdOut.print("Cycle: ");
            for (DirectedEdge e : finder.cycle())
                StdOut.print(e + " ");
            StdOut.println();
        }
        else
            StdOut.println("No directed cycle");
    }
}

● Bellman - Ford 算法求最短路径

package package01;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
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.Queue;

public class class01
{
    private double[] distTo;                // 起点到各顶点的距离
    private DirectedEdge[] edgeTo;          // 起点到各顶点的最后一条边
    private boolean[] onQueue;              // 各顶点当前是否在搜索队中
    private Queue<Integer> queue;           // 搜索队列
    private int cost;                       // 调用函数 relax 的次数
    private Iterable<DirectedEdge> cycle;   // 存储负环，若空则表示图中不存在负环

    public class01(EdgeWeightedDigraph G, int s)
    {
        distTo = new double[G.V()];
        edgeTo = new DirectedEdge[G.V()];
        onQueue = new boolean[G.V()];
        for (int v = 0; v < G.V(); v++)
            distTo[v] = Double.POSITIVE_INFINITY;
        distTo[s] = 0.0;
        queue = new Queue<Integer>();
        for (queue.enqueue(s), onQueue[s] = true; !queue.isEmpty() && !hasNegativeCycle();) // 存在负环则停止搜索
        {
            int v = queue.dequeue();                //  每次从搜索队列中拿走一个顶点，松弛以该顶点为起点的边
            onQueue[v] = false;
            relax(G, v);
        }
    }

    private void relax(EdgeWeightedDigraph G, int v)
    {
        for (DirectedEdge e : G.adj(v))
        {
            int w = e.to();
            if (distTo[w] > distTo[v] + e.weight()) // 加入这条边会使起点到 w 的距离变短
            {
                distTo[w] = distTo[v] + e.weight();
                edgeTo[w] = e;
                if (!onQueue[w])                    // 注意若 w 已经在搜索队列中则不做任何改变
                {
                    queue.enqueue(w);
                    onQueue[w] = true;
                }
            }
            if (cost++ % G.V() == 0)                // 每当松弛了 V 的倍数次时检查是否存在负环
            {
                findNegativeCycle();
                if (hasNegativeCycle())
                    return;
            }
        }
    }

    private void findNegativeCycle()                // 利用类 EdgeWeightedDirectedCycle 来找环
    {
        int V = edgeTo.length;
        EdgeWeightedDigraph spt = new EdgeWeightedDigraph(V);
        for (int v = 0; v < V; v++)
        {
            if (edgeTo[v] != null)
                spt.addEdge(edgeTo[v]);
        }
        EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(spt);
        cycle = finder.cycle();
    }

    public boolean hasNegativeCycle()
    {
        return cycle != null;
    }

    public Iterable<DirectedEdge> negativeCycle()
    {
        return cycle;
    }

    public boolean hasPathTo(int v)
    {
        return distTo[v] < Double.POSITIVE_INFINITY;
    }

    public double distTo(int v)
    {
        if (hasNegativeCycle())
            throw new UnsupportedOperationException("
<distTo> Negative cost cycle exists.
");
        return distTo[v];
    }

    public Iterable<DirectedEdge> pathTo(int v)
    {
        if (hasNegativeCycle())
            throw new UnsupportedOperationException("
<pathTo> Negative cost cycle exists.
");
        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);
        if (sp.hasNegativeCycle())
        {
            for (DirectedEdge e : sp.negativeCycle())
                StdOut.println(e);
        }
        else
        {
            for (int v = 0; v < G.V(); v++)
            {
                if (sp.hasPathTo(v))
                {
                    StdOut.printf("%d to %d (%5.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);
            }
        }
    }
}

 ● 套汇，本质是寻找负环

package package01;

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

public class class01
{
    private class01() {}

    public static void main(String[] args)
    {
        int V = StdIn.readInt();                            // 顶点数
        String[] name = new String[V];
        EdgeWeightedDigraph G = new EdgeWeightedDigraph(V);
        for (int v = 0; v < V; v++)                         // 建图
        {
            name[v] = StdIn.readString();
            for (int w = 0; w < V; w++)
            {
                double rate = StdIn.readDouble();
                DirectedEdge e = new DirectedEdge(v, w, -Math.log(rate));// 汇率取负对数，x1x2x3 < 1 -> -logx1 -logx2 -logx3 < 0
                G.addEdge(e);
            }
        }
        BellmanFordSP spt = new BellmanFordSP(G, 0);        // 用 BF 算法找负环
        if (spt.hasNegativeCycle())
        {
            double stake = 1000.0;
            for (DirectedEdge e : spt.negativeCycle())
            {
                StdOut.printf("%10.5f %s ", stake, name[e.from()]);
                stake *= Math.exp(-e.weight());
                StdOut.printf("= %10.5f %s
", stake, name[e.to()]);
            }
        }
        else
            StdOut.println("No arbitrage opportunity");
    }
}