Hiho 118

Hiho 118 网络流四·最小路径覆盖

题目

时间限制:10000ms
单点时限:1000ms
内存限制:256MB
描述
国庆期间正是旅游和游玩的高峰期。
小Hi和小Ho的学习小组为了研究课题，决定趁此机会派出若干个调查团去沿途查看一下H市内各个景点的游客情况。
H市一共有N个旅游景点(编号1..N)，由M条单向游览路线连接。在一个景点游览完后，可以顺着游览线路前往下一个景点。
为了避免游客重复游览同一个景点，游览线路保证是没有环路的。
每一个调查团可以从任意一个景点出发，沿着计划好的游览线路依次调查，到达终点后再返回。每个景点只会有一个调查团经过，不会重复调查。
举个例子：

上图中一共派出了3个调查团：
1. 蓝色：调查景点；2
2. 橙色：调查景点；1->3->4->6
3. 绿色：调查景点；5->7
当然对于这个图还有其他的规划方式，但是最少也需要3个调查团。
由于小组内的人数有限，所以大家希望调查团的数量尽可能少，同时也要将所有的景点都进行调查。
当然，如何规划调查团线路的任务落到了小Hi和小Ho的头上。
提示：最小路径覆盖
输入
第1行：2个整数N,M。1≤N≤500,0≤M≤20,000。
第2..M+1行：2个数字u,v，表示一条有向边(u,v)。保证不会出现重复的边，且不存在环。
输出
第1行：1个整数，表示最少需要的调查团数量。

解题思路

核心解法是“最小路径覆盖 = N - 最大匹配数”。
从示例中可以看出，对于每个调查团的路径，整个路径的入度为0，出度为0，内部每个点通过一条边相连。

因此我们按照如上方式构图（所有边的值均为1），将顶点扩充两倍来进行二分匹配，这样进行分配之后，右边入度为0的点就是一个调查团路径的起点，所以右边入度为0的点的个数等于最少需要的调查团的数量，这个数目也被称为最小路径覆盖数目。
显然，在进行二分匹配的时候，每找一次增广路径，就相当于右边有个点的入度增加1，因为增广路径的数目为最大匹配数目。因为每个点的入度不是1就是0，因此最小路径覆盖数目 = N - 最大匹配数。

解题代码

using System;
using System.Collections.Generic;
namespace hiho
{
    class _118
    {
        private static int TotalSize = 0;
        private static int[,] rGraph = null;
        private static bool HashPath(int[] path)
        {
            Queue<int> q = new Queue<int>();
            q.Enqueue(0);
            bool[] visited = new bool[TotalSize];
            while (q.Count > 0)
            {
                int node = q.Dequeue();
                for (int i = 0; i < TotalSize; ++i)
                {
                    if (!visited[i] && rGraph[node, i] > 0)
                    {
                        q.Enqueue(i);
                        visited[i] = true;
                        path[i] = node;
                    }
                }
            }
            return visited[TotalSize - 1];
        }
        public static void Main()
        {
            //construct graph
            string[] lineArray = Console.ReadLine().Split(' ');
            int N = int.Parse(lineArray[0]), M = int.Parse(lineArray[1]);
            if (N == 1)
            {
                Console.WriteLine(1);
                return;
            }
            TotalSize = 2 * N + 2;
            rGraph = new int[TotalSize, TotalSize];
            for (int i = 0; i < M; ++i)
            {
                lineArray = Console.ReadLine().Split(' ');
                int u = int.Parse(lineArray[0]), v = int.Parse(lineArray[1]);
                rGraph[u, v + N] = 1;
            }
            for (int i = 1; i <= N; ++i)
            {
                rGraph[0, i] = 1;
                rGraph[i + N, TotalSize - 1] = 1;
            }
            //maximum flux principle
            int[] path = new int[TotalSize];
            int count = 0;
            while (HashPath(path))
            {
                int minCap = int.MaxValue;
                for (int i = TotalSize - 1; i != 0; i = path[i])
                    if (rGraph[path[i], i] < minCap)
                        minCap = rGraph[path[i], i];
                for (int i = TotalSize - 1; i != 0; i = path[i])
                {
                    rGraph[path[i], i] -= minCap;
                    rGraph[i, path[i]] += minCap;
                }
                ++count;
            }
            //output the result
            Console.WriteLine(N - count);
        }
    }
}