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

▶ 书中第四章部分程序，包括在加上自己补充的代码，两种拓扑排序的方法

● 拓扑排序 1

package package01;

import edu.princeton.cs.algs4.Digraph;
import edu.princeton.cs.algs4.SymbolDigraph;
import edu.princeton.cs.algs4.DirectedCycle;
import edu.princeton.cs.algs4.DepthFirstOrder;
import edu.princeton.cs.algs4.EdgeWeightedDigraph;
import edu.princeton.cs.algs4.EdgeWeightedDirectedCycle;

public class class01
{
    private Iterable<Integer> order;    // 拓扑排序的结果
    private int[] rank;                 // 顶点 v 在拓扑排序中的序号为 rank[v]

    public class01(Digraph G)           // 从有向图生成拓扑排序
    {
        DirectedCycle finder = new DirectedCycle(G);        // 存在环则不能排序
        if (!finder.hasCycle())
        {
            DepthFirstOrder dfs = new DepthFirstOrder(G);   // 做 G 的深度优先搜索
            order = dfs.reversePost();                      // 取逆后序依次标号
            rank = new int[G.V()];
            int i = 0;
            for (int v : order)
                rank[v] = i++;
        }
    }

    public class01(EdgeWeightedDigraph G)                   // 从加权边有向图生成拓扑排序（算法一样，只是数据结构不同）
    {
        EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(G);
        if (!finder.hasCycle())
        {
            DepthFirstOrder dfs = new DepthFirstOrder(G);
            order = dfs.reversePost();
            rank = new int[G.V()];
            int i = 0;
            for (int v : order)
                rank[v] = i++;
        }
    }

    public Iterable<Integer> order()
    {
        return order;
    }

    public boolean hasOrder()
    {
        return order != null;
    }

    public int rank(int v)
    {
        return hasOrder() ? rank[v] : -1;
    }

    public static void main(String[] args)
    {
        String filename = args[0];
        String delimiter = args[1];                                 // 分隔符
        SymbolDigraph sg = new SymbolDigraph(filename, delimiter);
        class01 topological = new class01(sg.digraph());
        for (int v : topological.order())
            System.out.println(sg.nameOf(v));
    }
}

● 拓扑排序 2

package package01;

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.DigraphGenerator;
import edu.princeton.cs.algs4.Digraph;
import edu.princeton.cs.algs4.Queue;
import edu.princeton.cs.algs4.DirectedEdge;
import edu.princeton.cs.algs4.EdgeWeightedDigraph;

public class class01
{
    private Queue<Integer> order;
    private int[] rank;

    public class01(Digraph G)
    {
        order = new Queue<Integer>();
        rank = new int[G.V()];
        int[] indegree = new int[G.V()];
        for (int v = 0; v < G.V(); v++)
            indegree[v] = G.indegree(v);
        int count = 0;
        Queue<Integer> queue = new Queue<Integer>();
        for (int v = 0; v < G.V(); v++)                 // 收集所有没有前提条件的顶点
        {
            if (indegree[v] == 0)
                queue.enqueue(v);
        }
        for (; !queue.isEmpty();)
        {
            int v = queue.dequeue();
            order.enqueue(v);                           // 事件 v 完成，将其放入输出队列， 并给一个序号
            rank[v] = count++;
            for (int w : G.adj(v))                      // 所有紧接着 v 的事件的前提条件减少 1
            {
                indegree[w]--;
                if (indegree[w] == 0)                   // 收集此时没有前提条件的事件
                    queue.enqueue(w);
            }
        }
        if (count != G.V())                             // 遍历结束，还有顶点有入度，说明存在环
            order = null;
    }

    public class01(EdgeWeightedDigraph G)
    {
        order = new Queue<Integer>();
        rank = new int[G.V()];
        int[] indegree = new int[G.V()];
        for (int v = 0; v < G.V(); v++)
            indegree[v] = G.indegree(v);
        int count = 0;
        Queue<Integer> queue = new Queue<Integer>();
        for (int v = 0; v < G.V(); v++)
        {
            if (indegree[v] == 0)
                queue.enqueue(v);
        }
        for (; !queue.isEmpty();)
        {
            int v = queue.dequeue();
            order.enqueue(v);
            rank[v] = count++;
            for (DirectedEdge e : G.adj(v))
            {
                int w = e.to();
                indegree[w]--;
                if (indegree[w] == 0)
                    queue.enqueue(w);
            }
        }
        if (count != G.V())
            order = null;
    }

    public Iterable<Integer> order()
    {
        return order;
    }

    public boolean hasOrder()
    {
        return order != null;
    }

    public int rank(int v)
    {
        return hasOrder() ? rank[v] : -1;
    }

    public static void main(String[] args)
    {
        int V = Integer.parseInt(args[0]);                  // 生成DAG G(V,E)，再添加 F 条边
        int E = Integer.parseInt(args[1]);
        int F = Integer.parseInt(args[2]);
        Digraph G1 = DigraphGenerator.dag(V, E);            // G1 是无边圈的
        EdgeWeightedDigraph G2 = new EdgeWeightedDigraph(V);// G2 有边权的
        for (int v = 0; v < G1.V(); v++)
        {
            for (int w : G1.adj(v))
                G2.addEdge(new DirectedEdge(v, w, 0.0));
        }
        for (int i = 0; i < F; i++)
        {
            int v = StdRandom.uniform(V);
            int w = StdRandom.uniform(V);
            G1.addEdge(v, w);
            G2.addEdge(new DirectedEdge(v, w, 0.0));
        }
        StdOut.println(G1);
        StdOut.println();
        StdOut.println(G2);
        class01 topological1 = new class01(G1);             // 分别计算 G1 和 G2 的
        if (!topological1.hasOrder())
            StdOut.println("Not a DAG");
        else
        {
            StdOut.print("Topological order: ");
            for (int v : topological1.order())
                StdOut.print(v + " ");
            StdOut.println();
        }
        class01 topological2 = new class01(G2);
        if (!topological2.hasOrder())
            StdOut.println("Not a DAG");
        else
        {
            StdOut.print("Topological order: ");
            for (int v : topological2.order())
                StdOut.print(v + " ");
            StdOut.println();
        }
    }
}