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

▶ 书中第六章部分程序，包括在加上自己补充的代码，包括二分图最大匹配（最小顶点覆盖）的交替路径算法和 HopcroftKarp 算法

● 二分图最大匹配（最小顶点覆盖）的交替路径算法

 package package01;

 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.BipartiteX;
 import edu.princeton.cs.algs4.Graph;
 import edu.princeton.cs.algs4.GraphGenerator;
 import edu.princeton.cs.algs4.Queue;

 public class class01
 {
     private final int V;
     private BipartiteX bipartition;
     private int cardinality;             // 匹配集的顶点数
     private int[] mate;                  // 每个顶点的配对顶点，-1 表示未配对
     private boolean[] inMinVertexCover;  // 顶点是否处于最小覆盖中
     private boolean[] marked;            // 标记已经搜索过的顶点
     private int[] edgeTo;                // 搜索序列中的父节点标号

     public class01(Graph G)
     {
         V = G.V();
         mate = new int[V];
         for (int v = 0; v < V; v++)
             mate[v] = -1;
         for (; hasAugmentingPath(G);)
         {
             int t = -1;
             for (int v = 0; v < G.V(); v++)                 // 寻找增广路径的一个端点，它不在 mate 表中，但在搜索序列中
             {
                 if (!isMatched(v) && edgeTo[v] != -1)
                 {
                     t = v;
                     break;
                 }
             }
             for (int v = t; v != -1; v = edgeTo[edgeTo[v]]) // 增广路经中每两个相邻顶点做成匹配
             {
                 int w = edgeTo[v];
                 mate[v] = w;
                 mate[w] = v;
             }
             cardinality++;                                  // 全部调整完成，匹配集中顶点数量增加 1
         }
         inMinVertexCover = new boolean[V];                  // 更新 inMinVertexCover[]，加入最小覆盖的条件是未匹配的黑点和已匹配的红点
         for (int v = 0; v < V; v++)
         {
             if (bipartition.color(v) && !marked[v] || !bipartition.color(v) && marked[v])
                 inMinVertexCover[v] = true;
         }
         assert certifySolution(G);
     }

     private boolean hasAugmentingPath(Graph G)              // 是否存在可调整路径，算法是寻找图中最短增广路经，注意函数对 mate[] 只读
                                                             // 交替路径：沿着交替路径前进，每条边依次属于、不属于匹配集合
                                                             // 增广路经：起点和终点都属于未匹配集的交替路径，说明可以通过对换路径上所有边（匹配 <-> 未匹配）来增加匹配集的顶点数
     {
         marked = new boolean[V];
         edgeTo = new int[V];
         for (int v = 0; v < V; v++)
             edgeTo[v] = -1;
         Queue<Integer> queue = new Queue<Integer>();
         for (int v = 0; v < V; v++)
         {
             if (bipartition.color(v) && !isMatched(v))      // 所有未配对的黑色点（true）加入搜索队列，作为初始点
             {
                 queue.enqueue(v);
                 marked[v] = true;
             }
         }
         for (; !queue.isEmpty();)
         {
             int v = queue.dequeue();
             for (int w : G.adj(v))
             {
                 if (isResidualGraphEdge(v, w) && !marked[w])// w 是一个新顶点，v - w 是未配对黑-红边且或是已配对红-黑边
                 {
                     edgeTo[w] = v;                          // 搜索序列中，把 w 当做 v 的后继
                     marked[w] = true;
                     if (!isMatched(w))                      // w 是未经配对的顶点，说明找到了增广路经，否则 w 也加入搜索队列
                         return true;
                     queue.enqueue(w);
                 }
             }
         }
         return false;
     }

     private boolean isResidualGraphEdge(int v, int w)       // 要么 v 黑且 v - w 未配对，要么 v 红且 v - w 已配对
     {
         return (mate[v] != w) && bipartition.color(v) || (mate[v] == w) && !bipartition.color(v);
     }

     public int mate(int v)
     {
         return mate[v];
     }

     public boolean isMatched(int v)             // mate[v] >= 0 返回 1，mate[v] == -1 返回 0
     {
         return mate[v] != -1;
     }

     public int size()
     {
         return cardinality;
     }

     public boolean isPerfect()                  // 是否为完美匹配
     {
         return cardinality * 2 == V;
     }

     public boolean inMinVertexCover(int v)      // 顶点是否在最小覆盖中
     {
         return inMinVertexCover[v];
     }

     private boolean certifySolution(Graph G)    // 检查结果正确性
     {
         for (int v = 0; v < V; v++)             // 检查 mate[] 对称性
         {
             if (mate(v) == -1)
                 continue;
             if (mate(mate(v)) != v)
                 return false;
         }
         int matchedVertices = 0;                // 检查 cardinality 与 mate[] 一致性
         for (int v = 0; v < V; v++)
         {
             if (mate(v) != -1)
                 matchedVertices++;
         }
         if (2 * size() != matchedVertices)
             return false;
         int sizeOfMinVertexCover = 0;           // 检查 cardinality 与 inMinVertexCover[] 一致性
         for (int v = 0; v < V; v++)
         {
             if (inMinVertexCover(v))
                 sizeOfMinVertexCover++;
         }
         if (size() != sizeOfMinVertexCover)
             return false;
         boolean[] isMatched = new boolean[V];   // 检查 mate[] 唯一性
         for (int v = 0; v < V; v++)
         {
             int w = mate[v];
             if (w == -1)
                 continue;
             if (v == w)
                 return false;
             if (v >= w)
                 continue;
             if (isMatched[v] || isMatched[w]) return false;
             isMatched[v] = true;
             isMatched[w] = true;
         }
         for (int v = 0; v < V; v++)             // 检查匹配集中的每个顶点至少有一条远端也属于匹配集的边
         {
             if (mate(v) == -1)
                 continue;
             boolean isEdge = false;
             for (int w : G.adj(v))
             {
                 if (mate(v) == w)
                     isEdge = true;
             }
             if (!isEdge)
                 return false;
         }
         for (int v = 0; v < V; v++)             // 检查 inMinVertexCover[] 是一个覆盖
         {
             for (int w : G.adj(v))
             {
                 if (!inMinVertexCover(v) && !inMinVertexCover(w))
                     return false;
             }
         }
         return true;
     }

     public static void main(String[] args)
     {
         int V1 = Integer.parseInt(args[0]);
         int V2 = Integer.parseInt(args[1]);
         int E = Integer.parseInt(args[2]);
         Graph G = GraphGenerator.bipartite(V1, V2, E);
         if (G.V() < 1000)
             StdOut.println(G);

         class01 matching = new class01(G);

         StdOut.printf("Number of edges in max matching        = %d\n", matching.size());
         StdOut.printf("Number of vertices in min vertex cover = %d\n", matching.size());
         StdOut.printf("Graph has a perfect matching           = %b\n", matching.isPerfect());
         StdOut.println();

         if (G.V() >= 1000)
             return;
         StdOut.print("Max matching: ");
         for (int v = 0; v < G.V(); v++)
         {
             int w = matching.mate(v);
             if (matching.isMatched(v) && v < w)
                 StdOut.print(v + "-" + w + " ");
         }
         StdOut.print("\nMin vertex cover: ");
         for (int v = 0; v < G.V(); v++)
         {
             if (matching.inMinVertexCover(v))
                 StdOut.print(v + " ");
         }
         StdOut.println();
     }
 }

● 二分图最大匹配（最小顶点覆盖）的 HopcroftKarp 算法，仅注释与普通交替路径法不同的地方

 package package01;

 import java.util.Iterator;
 import edu.princeton.cs.algs4.StdOut;
 import edu.princeton.cs.algs4.BipartiteX;
 import edu.princeton.cs.algs4.Stack;
 import edu.princeton.cs.algs4.Graph;
 import edu.princeton.cs.algs4.GraphGenerator;
 import edu.princeton.cs.algs4.Queue;

 public class class01
 {
     private final int V;
     private BipartiteX bipartition;
     private int cardinality;
     private int[] mate;
     private boolean[] inMinVertexCover;
     private boolean[] marked;
     private int[] distTo;                                   // 搜索序列中抵达每个顶点的最小路径长度

     public class01(Graph G)
     {
         V = G.V();
         mate = new int[V];
         for (int v = 0; v < V; v++)
             mate[v] = -1;
         for (; hasAugmentingPath(G);)
         {
             Iterator<Integer>[] adj = (Iterator<Integer>[]) new Iterator[G.V()];    // 邻接表迭代器列表
             for (int v = 0; v < G.V(); v++)
                 adj[v] = G.adj(v).iterator();
             for (int s = 0; s < V; s++)
             {
                 if (isMatched(s) || !bipartition.color(s))  // 只取未配对的黑色（true）顶点
                     continue;
                 Stack<Integer> path = new Stack<Integer>(); // 使用非递归的深度优先遍历寻找关于顶点 s 的交替路径
                 for (path.push(s); !path.isEmpty();)
                 {
                     int v = path.peek();
                     if (!adj[v].hasNext())                  // 栈顶顶点没有出边，跳过
                     {
                         path.pop();
                         continue;
                     }
                     int w = adj[v].next();
                     if (!isLevelGraphEdge(v, w))            // 若 v -w 不是搜索队列生成的边，跳过
                         continue;
                     path.push(w);
                     if (!isMatched(w))                      // w 是新点，它不在 mate 表中，但在搜索序列中
                     {
                         for (; !path.isEmpty();)            // 增广路经中每两个相邻顶点做成匹配
                         {
                             int x = path.pop(), y = path.pop();
                             mate[x] = y;
                             mate[y] = x;
                         }
                         cardinality++;
                     }
                 }
             }
         }
         inMinVertexCover = new boolean[V];
         for (int v = 0; v < V; v++)
         {
             if (bipartition.color(v) && !marked[v] || !bipartition.color(v) && marked[v])
                 inMinVertexCover[v] = true;
         }
     }

     private boolean hasAugmentingPath(Graph G)
     {
         marked = new boolean[V];
         distTo = new int[V];
         for (int v = 0; v < V; v++)
             distTo[v] = Integer.MAX_VALUE;
         Queue<Integer> queue = new Queue<Integer>();        // 从未配对的顶点开始广度优先搜索
         for (int v = 0; v < V; v++)
         {
             if (bipartition.color(v) && !isMatched(v))      // 所有未配对的黑色点（true）加入搜索队列，作为初始点，初始点距离为 0
             {
                 queue.enqueue(v);
                 marked[v] = true;
                 distTo[v] = 0;
             }
         }
         boolean hasAugmentingPath = false;
         for (; !queue.isEmpty();)                           // 要运行直到所有顶点都被遍历过才结束
         {
             int v = queue.dequeue();
             for (int w : G.adj(v))
             {
                 if (isResidualGraphEdge(v, w) && !marked[w])
                 {
                     distTo[w] = distTo[v] + 1;              // 标记顶点距离为已知顶点加 1 而不标记父节点编号
                     marked[w] = true;
                     if (!isMatched(w))
                         hasAugmentingPath = true;           // 仅标记发现了交替路径而不返回
                     if (!hasAugmentingPath)
                         queue.enqueue(w);
                 }
             }
         }
         return hasAugmentingPath;
     }

     private boolean isResidualGraphEdge(int v, int w)
     {
         return (mate[v] != w) && bipartition.color(v) || (mate[v] == w) && !bipartition.color(v);
     }

     private boolean isLevelGraphEdge(int v, int w)          // v - w 是搜索队列生成的边
     {
         return (distTo[w] == distTo[v] + 1) && isResidualGraphEdge(v, w);
     }

     public int mate(int v)
     {
         return mate[v];
     }

     public boolean isMatched(int v)
     {
         return mate[v] != -1;
     }

     public int size()
     {
         return cardinality;
     }

     public boolean isPerfect()
     {
         return cardinality * 2 == V;
     }

     public boolean inMinVertexCover(int v)
     {
         return inMinVertexCover[v];
     }

     private static String toString(Iterable<Integer> path)
     {
         StringBuilder sb = new StringBuilder();
         for (int v : path)
             sb.append(v + "-");
         String s = sb.toString();
         s = s.substring(0, s.lastIndexOf('-'));
         return s;
     }

     public static void main(String[] args)
     {
         int V1 = Integer.parseInt(args[0]);
         int V2 = Integer.parseInt(args[1]);
         int E = Integer.parseInt(args[2]);
         Graph G = GraphGenerator.bipartite(V1, V2, E);
         if (G.V() < 1000)
             StdOut.println(G);

         class01 matching = new class01(G);

         StdOut.printf("Number of edges in max matching        = %d\n", matching.size());
         StdOut.printf("Number of vertices in min vertex cover = %d\n", matching.size());
         StdOut.printf("Graph has a perfect matching           = %b\n", matching.isPerfect());
         StdOut.println();

         if (G.V() >= 1000)
             return;
         StdOut.print("Max matching: ");
         for (int v = 0; v < G.V(); v++)
         {
             int w = matching.mate(v);
             if (matching.isMatched(v) && v < w)
                 StdOut.print(v + "-" + w + " ");
         }
         StdOut.print("\nMin vertex cover: ");
         for (int v = 0; v < G.V(); v++)
         {
             if (matching.inMinVertexCover(v))
                 StdOut.print(v + " ");
         }
         StdOut.println();
     }
 }