《算法》第六章部分程序 part 5

▶ 书中第六章部分程序，包括在加上自己补充的代码，网络最大流 Ford - Fulkerson 算法，以及用到的流量边类和剩余流量网络类

● 网络最大流 Ford - Fulkerson 算法

package package01;

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.FlowEdge;
import edu.princeton.cs.algs4.FlowNetwork;
import edu.princeton.cs.algs4.Queue;

public class class01
{
    private static final double FLOATING_POINT_EPSILON = 1E-11;

    private final int V;          // 顶点数
    private boolean[] marked;     // 已搜索顶点，marked[v] = true 表示从起点 s 到顶点 v 存在一条具有剩余流量的路径
    private FlowEdge[] edgeTo;    // s -> v 路径上的最后一条边
    private double value;         // 当前最大流量

    public class01(FlowNetwork G, int s, int t)
    {
        V = G.V();
        if (s == t || !isFeasible(G, s, t))
            throw new IllegalArgumentException("
<constructor> Source == Sink || !isFeasible(G, s, t).
");
        for (value = excess(G, t); hasAugmentingPath(G, s, t);)             // 初始流量为顶点 t 净流量，只要还存在具有剩余容量的路径就要扩容
        {
            double bottle = Double.POSITIVE_INFINITY;                       // 沿着找到的路径走一遍，最小剩余容量作为扩容量
            for (int v = t; v != s; v = edgeTo[v].other(v))
                bottle = Math.min(bottle, edgeTo[v].residualCapacityTo(v));
            for (int v = t; v != s; v = edgeTo[v].other(v))                 // 扩容
                edgeTo[v].addResidualFlowTo(v, bottle);
            value += bottle;                                                // 总流量也要增加
        }
    }

    public double value()
    {
        return value;
    }

    public boolean inCut(int v)                                             // 顶点 v 是否在 s-切分中
    {
        return marked[v];
    }

    private boolean hasAugmentingPath(FlowNetwork G, int s, int t)  // 判断是否存在从 s 到 t 的剩余容量路径
    {
        edgeTo = new FlowEdge[G.V()];
        marked = new boolean[G.V()];
        Queue<Integer> queue = new Queue<Integer>();                // 广度优先搜索，保持所有搜索过的路径都有剩余容量
        for (queue.enqueue(s), marked[s] = true; !queue.isEmpty() && !marked[t];)
        {
            int v = queue.dequeue();
            for (FlowEdge e : G.adj(v))
            {
                int w = e.other(v);
                if (e.residualCapacityTo(w) > 0)                    // 如果取出的边关于终点 w 有剩余流量，则将其入队
                {
                    if (!marked[w])
                    {
                        edgeTo[w] = e;
                        marked[w] = true;
                        queue.enqueue(w);
                    }
                }
            }
        }
        return marked[t];                                           // 如果搜索到过 t，说明存在一条具有剩余容量的路径
    }

    private double excess(FlowNetwork G, int v)                     // 计算顶点 v 的净流量
    {
        double excess = 0.0;
        for (FlowEdge e : G.adj(v))                                 // 入边增加，出边减少
            excess += (v == e.to() ? e.flow() : -e.flow());
        return excess;
    }

    private boolean isFeasible(FlowNetwork G, int s, int t)         // 节点流量异常检查
    {
        for (int v = 0; v < G.V(); v++)
        {
            for (FlowEdge e : G.adj(v))
            {
                if (e.flow() < -FLOATING_POINT_EPSILON || e.flow() > e.capacity() + FLOATING_POINT_EPSILON) // 某条边的流量异常
                {
                    System.err.println("Edge does not satisfy capacity constraints: " + e);
                    return false;
                }
            }
        }
        if (Math.abs(value + excess(G, s)) > FLOATING_POINT_EPSILON)// 当前起点净流量（<0）加上图流量非零，异常
        {
            System.err.println("Excess at source = " + excess(G, s) + "Max flow         = " + value);
            return false;
        }
        if (Math.abs(value - excess(G, t)) > FLOATING_POINT_EPSILON)// 当前终点净流量（>0）减去图流量非零，异常
        {
            System.err.println("Excess at sink   = " + excess(G, t) + "Max flow         = " + value);
            return false;
        }
        for (int v = 0; v < G.V(); v++)                             // 其他节点净流量应该为零
        {
            if (v == s || v == t)
                continue;
            if (Math.abs(excess(G, v)) > FLOATING_POINT_EPSILON)
            {
                System.err.println("Net flow out of " + v + " doesn't equal zero");
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args)
    {
        int V = Integer.parseInt(args[0]), E = Integer.parseInt(args[1]), s = 0, t = V - 1;
        FlowNetwork G = new FlowNetwork(V, E);
        StdOut.println(G);
        class01 maxflow = new class01(G, s, t);
        StdOut.println("Max flow from " + s + " to " + t);
        for (int v = 0; v < G.V(); v++)                             // 打印所有具有流量的边
        {
            for (FlowEdge e : G.adj(v))
            {
                if ((v == e.from()) && e.flow() > 0)
                    StdOut.println("   " + e);
            }
        }
        StdOut.print("Min cut: ");                                  // 输出最小切分
        for (int v = 0; v < G.V(); v++)
            if (maxflow.inCut(v)) StdOut.print(v + " ");
        StdOut.println("
Max flow value = " + maxflow.value());
    }
}

● 流量边类

package package01;

public class class01
{
    private static final double FLOATING_POINT_EPSILON = 1E-10;

    private final int v;             // 起点
    private final int w;             // 终点
    private final double capacity;   // 容量
    private double flow;             // 流量

    public class01(int inputV, int inputW, double inputCapacity)    // 三种构造函数
    {
        if (inputV < 0 || inputW < 0 || inputCapacity<0)
            throw new IllegalArgumentException("
<constructor> inputV < 0 || inputW < 0 || inputCapacity < 0.
");
        v = inputV;
        w = inputW;
        capacity = inputCapacity;
        flow = 0.0;
    }

    public class01(int inputV, int inputW, double inputCapacity, double inputFlow)
    {
        if (inputV < 0 || inputW < 0 || inputCapacity<0 || inputFlow < 0.0 || inputFlow > inputCapacity)
            throw new IllegalArgumentException("
<constructor> inputV < 0 || inputW < 0 || inputCapacity < 0 || flow < 0.0 || flow > capacity.
");
        v = inputV;
        w = inputW;
        capacity = inputCapacity;
        flow = inputFlow;
    }

    public class01(class01 e)
    {
        v = e.v;
        w = e.w;
        capacity = e.capacity;
        flow = e.flow;
    }

    public int from()
    {
        return v;
    }

    public int to()
    {
        return w;
    }

    public double capacity()
    {
        return capacity;
    }

    public double flow()
    {
        return flow;
    }

    public int other(int vertex)
    {
        if (vertex == v)
            return w;
        else if (vertex == w)
            return v;
        throw new IllegalArgumentException("
<other> invalid endpoint.
");
    }

    public double residualCapacityTo(int vertex)    // 计算一条边关于某个顶点的流通能力
    {
        if (vertex == v)                            // 起点，返回边的现有流量
            return flow;
        else if (vertex == w)                       // 终点，返回边的剩余容量
            return capacity - flow;
        throw new IllegalArgumentException("
<residualCapacityTo> invalid endpoint.
");
    }

    public void addResidualFlowTo(int vertex, double delta)         // 改变边的流量
    {
        if (delta < 0.0)
            throw new IllegalArgumentException("
<addResidualFlowTo> delta < 0.0.
");
        if (vertex == v)                            // 起点，边流量减少
            flow -= delta;
        else if (vertex == w)                       // 终点，边流量增加
            flow += delta;
        else
            throw new IllegalArgumentException("
<addResidualFlowTo> invalid endpoint.
");
        if (Math.abs(flow) <= FLOATING_POINT_EPSILON)               // 流量归零
            flow = 0;
        if (Math.abs(flow - capacity) <= FLOATING_POINT_EPSILON)    // 流量达到容量
            flow = capacity;
        if (flow < 0.0)                                             // 流量异常
            throw new IllegalArgumentException("
<addResidualFlowTo> flow <0.
");
        if (flow > capacity)
            throw new IllegalArgumentException("
<addResidualFlowTo> flow > capacity.
");
    }

    public String toString()
    {
        return v + "->" + w + " " + flow + "/" + capacity;
    }

    public static void main(String[] args)
    {
        class01 e = new class01(12, 23, 4.56);
        StdOut.println(e);
    }
}

● 剩余流量网络类

package package01;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.FlowEdge;
import edu.princeton.cs.algs4.Bag;

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

    private final int V;
    private int E;
    private Bag<FlowEdge>[] adj;

    public class01(int inputV)
    {
        if (V < 0)
            throw new IllegalArgumentException("
<constructor> inputV < 0.
");
        V = inputV;
        E = 0;
        adj = (Bag<FlowEdge>[]) new Bag[V];
        for (int v = 0; v < V; v++)
            adj[v] = new Bag<FlowEdge>();
    }

    public class01(int inputV, int inputE)
    {
        this(inputV);
        if (E < 0)
            throw new IllegalArgumentException("
<constructor> inputE < 0.
");
        for (int i = 0; i < E; i++)
            addEdge(new FlowEdge(StdRandom.uniform(V), StdRandom.uniform(V), StdRandom.uniform(100)));
    }

    public class01(In in)
    {
        this(in.readInt());
        E = in.readInt();
        for (int i = 0; i < E; i++)
            addEdge(new FlowEdge(in.readInt(), in.readInt(), in.readDouble()));
    }

    public int V()
    {
        return V;
    }

    public int E()
    {
        return E;
    }

    public void addEdge(FlowEdge e)     // 添加一条边
    {
        adj[e.from()].add(e);
        adj[e.to()].add(e);
        E++;
    }

    public Iterable<FlowEdge> adj(int v)// 一个顶点上出边的迭代器，就是该顶点的单链表
    {
        return adj[v];
    }

    public Iterable<FlowEdge> edges()   // 所有边的迭代器，和搜集所有顶点处的出边
    {
        Bag<FlowEdge> list = new Bag<FlowEdge>();
        for (int v = 0; v < V; v++)
        {
            for (FlowEdge e : adj(v))
            {
                if (e.to() != v)
                    list.add(e);
            }
        }
        return list;
    }

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

    public static void main(String[] args)
    {
        In in = new In(args[0]);
        class01 G = new class01(in);
        StdOut.println(G);
    }
}