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

▶ 书中第四章部分程序，加上自己补充的代码，图的环相关

● 无向图中寻找环

package package01;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.Graph;
import edu.princeton.cs.algs4.Stack;

public class class01
{
    private boolean[] marked;
    private int[] edgeTo;
    private Stack<Integer> cycle;       // 用来存储环的顶点

    public class01(Graph G)
    {
        if (hasSelfLoop(G))
            return;
        if (hasParallelEdges(G))
            return;
        marked = new boolean[G.V()];
        edgeTo = new int[G.V()];
        for (int v = 0; v < G.V(); v++)
        {
            if (!marked[v])
                dfs(G, -1, v);              // 首次调用时参数 u 要赋成非定点编号的值
        }
    }

    private void dfs(Graph G, int u, int v) // 深度优先探索，传入起点 v 及其父顶点 u
    {
        marked[v] = true;
        for (int w : G.adj(v))
        {
            if (cycle != null)              // 已经找到环，停止搜索（只搜一个就停）
                return;
            if (!marked[w])
            {
                edgeTo[w] = v;
                dfs(G, v, w);
            }
            else if (w != u)                // 顶点 w 已经遍历，且边 w-v 不是来边 u-v，说明成环
            {
                cycle = new Stack<Integer>();
                for (int x = v; x != w; x = edgeTo[x])  // 这里 w 指向该环在本次遍历中最早遇到的顶点
                    cycle.push(x);
                cycle.push(w);
                cycle.push(v);
            }
        }
    }

    private boolean hasSelfLoop(Graph G)            // 自环
    {
        for (int v = 0; v < G.V(); v++)
        {
            for (int w : G.adj(v))
            {
                if (v == w)
                {
                    cycle = new Stack<Integer>();
                    cycle.push(v);
                    cycle.push(v);
                    return true;
                }
            }
        }
        return false;
    }

    private boolean hasParallelEdges(Graph G)       // 平行边
    {
        marked = new boolean[G.V()];
        for (int v = 0; v < G.V(); v++)
        {
            for (int w : G.adj(v))
            {
                if (marked[w])
                {
                    cycle = new Stack<Integer>();
                    cycle.push(v);
                    cycle.push(w);
                    cycle.push(v);
                    return true;
                }
                marked[w] = true;
            }
            for (int w : G.adj(v))                  // 恢复遍历前的状态，一遍其他顶点进行检查
                marked[w] = false;
        }
        return false;
    }

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

    public Iterable<Integer> cycle()                // 将环用迭代器方式输出
    {
        return cycle;
    }

    public static void main(String[] args)
    {
        In in = new In(args[0]);
        Graph G = new Graph(in);
        class01 finder = new class01(G);
        if (finder.hasCycle())
        {
            for (int v : finder.cycle())
                StdOut.print(v + " ");
            StdOut.println();
        }
        else
            StdOut.println("
<main> Graph is aycyclic.
");
    }
}

● 有向图中找环

package package01;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.Digraph;
import edu.princeton.cs.algs4.Stack;

public class class01
{
    private boolean[] marked;
    private int[] edgeTo;
    private boolean[] onStack;          // 记录递归顺序，递归回退时需要恢复（marked 不恢复）
    private Stack<Integer> cycle;

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

    private void dfs(Digraph G, int v)  // 有向图不用传递起点的父顶点
    {
        onStack[v] = true;              // 进入新节点时两个变量都要记录
        marked[v] = true;
        for (int w : G.adj(v))
        {
            if (cycle != null)
                return;
            if (!marked[w])
            {
                edgeTo[w] = v;
                dfs(G, w);
            }
            else if (onStack[w])        // 用 onStack 来检测本次递归是否已经遍历过顶点 w
            {
                cycle = new Stack<Integer>();
                for (int x = v; x != w; x = edgeTo[x])
                    cycle.push(x);
                cycle.push(w);
                cycle.push(v);
            }
        }
        onStack[v] = false;             // 递归回退，恢复搜索痕迹
    }

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

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

    public static void main(String[] args)
    {
        In in = new In(args[0]);
        Digraph G = new Digraph(in);
        class01 finder = new class01(G);
        if (finder.hasCycle())
        {
            for (int v : finder.cycle())
                StdOut.print(v + " ");
            StdOut.println();
        }
        else
            StdOut.println("
<main> Graph is aycyclic.
");
    }
}

● 有向图中找环，广度优先搜索，非递归

package package01;

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

public class class01
{
    private Stack<Integer> cycle;

    public class01(Digraph G)
    {
        int[] indegree = new int[G.V()];
        for (int v = 0; v < G.V(); v++)
            indegree[v] = G.indegree(v);
        Queue<Integer> queue = new Queue<Integer>();
        for (int v = 0; v < G.V(); v++) // 所有入度为 0 的点入队，可作为遍历的起点，且绝对不是环的顶点
        {
            if (indegree[v] == 0)
                queue.enqueue(v);
        }
        for (; !queue.isEmpty();)       // 广度优先遍历，反复将 “入度为 0 的顶点的相邻顶点” 的入度减 1，相当于砍掉所有的链
        {
            int v = queue.dequeue();
            for (int w : G.adj(v))
            {
                indegree[w]--;
                if (indegree[w] == 0)
                    queue.enqueue(w);
            }
        }
        int[] edgeTo = new int[G.V()];  // 父顶点数组是局部变量就够了
        int root = -1;                  // 初始化为非顶点的编号
        for (int v = 0; v < G.V(); v++) // 遍历顶点，如果还有顶点有入度，说明存在环，将其顶点赋给 root
        {
            if (indegree[v] == 0)       // 跳过链中的顶点
                continue;
            else
                root = v;
            for (int w : G.adj(v))      // 顺着入度仍大于 0 的顶点往前爬
            {
                if (indegree[w] > 0)
                    edgeTo[w] = v;
            }
        }
        if (root != -1)                 // root 被覆盖，说明存在环，root 值为最后一个换的最后一个顶点
        {
            cycle = new Stack<Integer>();
            //for (boolean[] visited = new boolean[G.V()]; !visited[root]; visited[root] = true, root = edgeTo[root]);
            // 源码中维护了最后一个环的顶点集，但是以后再也没有用到，删掉
            cycle.push(root);
            for (int v = edgeTo[root]; v != root; v = edgeTo[v])
                cycle.push(v);
            //cycle.push(root); 多压一次根节点
        }
    }

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

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

    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 G = DigraphGenerator.dag(V, E);
        for (int i = 0; i < F; i++)
        {
            int v = StdRandom.uniform(V);
            int w = StdRandom.uniform(V);
            G.addEdge(v, w);
        }
        StdOut.println(G);
        class01 finder = new class01(G);
        if (finder.hasCycle())
        {
            for (int v : finder.cycle())
                StdOut.print(v + " ");
            StdOut.println();
        }
        else
            StdOut.println("
<main> Graph is aycyclic.
");
    }
}