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

▶ 书中第四章部分程序，包括在加上自己补充的代码，二分图的判定和染色

● 二分图 1

//+-----------------------------------------------------------------------------
// 第四章，二分图
package package01;

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.GraphGenerator;
import edu.princeton.cs.algs4.Graph;
import edu.princeton.cs.algs4.Stack;

public class class01
{
    private boolean isBipartite;
    private boolean[] color;            // 顶点染色情况
    private boolean[] marked;
    private int[] edgeTo;
    private Stack<Integer> cycle;       // odd-length cycle

    public class01(Graph G)
    {
        isBipartite = true;
        color = new boolean[G.V()];
        marked = new boolean[G.V()];
        edgeTo = new int[G.V()];
        for (int v = 0; v < G.V(); v++)// 逐顶点深度优先遍历
        {
            if (!marked[v])
            {
                dfs(G, v);
            }
        }
    }

    private void dfs(Graph G, int v)
    {
        marked[v] = true;
        for (int w : G.adj(v))
        {
            if (cycle != null)                          // 已经有奇数环，停止递归
                return;
            if (!marked[w])                             // 正常的标记、染色、继续递归
            {
                edgeTo[w] = v;
                color[w] = !color[v];
                dfs(G, w);
            }
            else if (color[w] == color[v])              // v ~ w 形成了长度为奇数的环
            {
                isBipartite = false;
                cycle = new Stack<Integer>();
                for (int x = v; x != w; x = edgeTo[x])  // 把从 v 到 w 的顶点压栈，保存有问题的环部分
                    cycle.push(x);
                cycle.push(w);
            }
        }
    }

    public boolean isBipartite()
    {
        return isBipartite;
    }

    public boolean color(int v)
    {
        if (!isBipartite)
            throw new UnsupportedOperationException("
<color> Graph is not bipartite.
");
        return color[v];
    }

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

    public static void main(String[] args)
    {
        int V1 = Integer.parseInt(args[0]); // 生成 G(V1 + V2, E) 顶点的二分图，再随机添加 F 条边
        int V2 = Integer.parseInt(args[1]);
        int E = Integer.parseInt(args[2]);
        int F = Integer.parseInt(args[3]);

        Graph G = GraphGenerator.bipartite(V1, V2, E);
        for (int i = 0; i < F; i++)
        {
            int v = StdRandom.uniform(V1 + V2);
            int w = StdRandom.uniform(V1 + V2);
            G.addEdge(v, w);
        }
        StdOut.println(G);

        class01 b = new class01(G);
        if (b.isBipartite())
        {
            StdOut.println("Graph is bipartite");
            for (int v = 0; v < G.V(); v++)
                StdOut.println(v + ": " + b.color(v));
        }
        else
        {
            StdOut.print("Graph has an odd-length cycle: ");
            for (int x : b.oddCycle())
                StdOut.print(x + " ");
            StdOut.println();
        }
    }
}

● 二分图 2

package package01;

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.GraphGenerator;
import edu.princeton.cs.algs4.Graph;
import edu.princeton.cs.algs4.Stack;
import edu.princeton.cs.algs4.Queue;

public class class01
{
    private boolean isBipartite;   // 是否为二分图
    private boolean[] color;       // 顶点染色
    private boolean[] marked;      
    private int[] edgeTo;          
    private Queue<Integer> cycle;  // 存储了奇数长度的环（二分图则队列为空）

    public class01(Graph G)
    {
        isBipartite = true;
        color = new boolean[G.V()];
        marked = new boolean[G.V()];
        edgeTo = new int[G.V()];
        for (int v = 0; v < G.V() && isBipartite; v++)
        {
            if (!marked[v])
                bfs(G, v);                          // 广度优先遍历
        }
    }

    private void bfs(Graph G, int s)
    {
        Queue<Integer> q = new Queue<Integer>();
        color[s] = false;                                           // 颜色使用 true / false
        marked[s] = true;
        for (q.enqueue(s); !q.isEmpty();)
        {
            int v = q.dequeue();
            for (int w : G.adj(v))
                if (!marked[w])
                {
                    marked[w] = true;
                    edgeTo[w] = v;
                    color[w] = !color[v];
                    q.enqueue(w);
                }
                else if (color[w] == color[v])                      // w 已经遍历过，且形成了奇数长度的环
                {
                    isBipartite = false;
                    cycle = new Queue<Integer>();
                    Stack<Integer> stack = new Stack<Integer>();
                    int x = v, y = w;                               // 两端同时向回走，color[v] == color[w] 于是 color[x] == color[y]
                    for (; x != y; x = edgeTo[x], y = edgeTo[y])    // 存在节点 z 使得 edgeTo[x] == edgeTo[y] == z，循环结束时 x 和 y 均指向公共顶点 z                          
                    {
                        stack.push(x);
                        cycle.enqueue(y);
                    }
                    for (stack.push(x); !stack.isEmpty(); cycle.enqueue(stack.pop()));  // 公共顶点 z 压栈，然后吐栈拼入队列，多一步是防止本来栈空
                    cycle.enqueue(w);
                    return;
                }
        }
    }

    public boolean isBipartite()
    {
        return isBipartite;
    }

    public boolean color(int v)
    {
        if (!isBipartite)
            throw new UnsupportedOperationException("
<color> Graph is not bipartite.
");
        return color[v];
    }

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

    public static void main(String[] args)
    {
        int V1 = Integer.parseInt(args[0]);
        int V2 = Integer.parseInt(args[1]);
        int E = Integer.parseInt(args[2]);
        int F = Integer.parseInt(args[3]);
        Graph G = GraphGenerator.bipartite(V1, V2, E);
        for (int i = 0; i < F; i++)
        {
            int v = StdRandom.uniform(V1 + V2);
            int w = StdRandom.uniform(V1 + V2);
            G.addEdge(v, w);
        }
        StdOut.println(G);

        class01 b = new class01(G);
        if (b.isBipartite())
        {
            StdOut.println("Graph is bipartite");
            for (int v = 0; v < G.V(); v++)
                StdOut.println(v + ": " + b.color(v));
        }
        else
        {
            StdOut.print("Graph has an odd-length cycle: ");
            for (int x : b.oddCycle())
                StdOut.print(x + " ");
            StdOut.println();
        }
    }
}