1738: 最小路径覆盖问题 二分最大匹配/最大流

给定有向图G=(V,E)。设P 是G 的一个简单路（顶点不相交）的集合。如果V 中每个 顶点恰好在P 的一条路上，则称P是G 的一个路径覆盖。

P 中路径可以从V 的任何一个顶 点开始，长度也是任意的，特别地，可以为0。G 的最小路径覆盖是G 的所含路径条数最少 的路径覆盖。

设计一个有效算法求一个有向无环图G 的最小路径覆盖。

提示：设V={1，2，... ，n}，构造网络G1=(V1,E1)如下： 每条边的容量均为1。

求网络G1的（ x0 , y0 ）最大流。

编程任务： 对于给定的有向无环图G，编程找出G的一个最小路径覆盖

 

构造二分图，把原图每个顶点i拆分成二分图X，Y集合中的两个顶点Xi和Yi。对于原图中存在的每条边(i,j)，在二分图中连接边(Xi,Yj)。然后把二分图最大匹配模型转化为网络流模型，求网络最大流。

最小路径覆盖的条数，就是原图顶点数，减去二分图最大匹配数。沿着匹配边查找，就是一个路径上的点，输出所有路径即可。

 

【建模分析】

对于一个路径覆盖，有如下性质：

1、每个顶点属于且只属于一个路径。

2、路径上除终点外，从每个顶点出发只有一条边指向路径上的另一顶点。

所以我们可以把每个顶点理解成两个顶点，一个是出发，一个是目标，建立二分图模型。该二分图的任何一个匹配方案，都对应了一个路径覆盖方案。如果匹配数为0，那么显然路径数=顶点数。每增加一条匹配边，那么路径覆盖数就减少一个，所以路径数=顶点数 - 匹配数。要想使路径数最少，则应最大化匹配数，所以要求二分图的最大匹配。

 

注意，此建模方法求最小路径覆盖仅适用于有向无环图，如果有环或是无向图，那么有可能求出的一些环覆盖，而不是路径覆盖。

如果是无向图，则是N-（match/2）

 

最后讨论改题的做法：

一、二分匹配法的话,就是上面说到的求解最大匹配数。最小路径覆盖 = 顶点个数 - 最大匹配数。

     然后，做这题时候我还学到了一个新的东西，就是在输出多条路径时候，可以用路径作色法来求出所有路径。做法就是，对相同的路径作色相同的颜色。而作色过程可以用递归不断的进行更新。其实最后总共作了几种颜色，就是有几条最小路径覆盖。

二分版：

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 1e3 + 5;
vector<int> G[maxn];
int link[maxn],color[maxn];
bool used[maxn];
int n,m;
void Init()
{
    for(int i = 0;i < maxn;++i)
        G[i].clear();
}
bool dfs(int u)
{
    for(int i = 0;i < (int)G[u].size();++i){
        int v = G[u][i];
        if(!used[v]){
            used[v] = true;
            if(link[v]==-1||dfs(link[v])){
                link[v] = u;
                return true;
            }
        }
    }
    return false;
}
int Find()
{
    int res = 0;
    memset(link,-1,sizeof(link));
    for(int i = 1;i <= n;++i){
        memset(used,false,sizeof(used));
        if(dfs(i))res++;
    }
    return res;
}
void DFS(int u,int num)
{
    for(int i = 0;i < (int)G[u].size();++i){
        int v = G[u][i];
        if(!color[v]&&link[v]==u){
            color[v] = num;
            DFS(v,num);
            break;     //因为一个点只可能链接一个
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m)){
        Init();
        int x,y;
        for(int i = 0;i < m;++i){
            scanf("%d%d",&x,&y);
            G[x].push_back(y);
        }
        int ans = Find();
        int cnt = 1;
        memset(color,0,sizeof(color));
        for(int i = 1;i <= n;++i){
            if(link[i]==-1&&!color[i]){ //从起始点和没作色开始找
                color[i] = cnt;
                DFS(i,cnt);
                cnt++;                  //下一条路的颜色
            }
        }
        for(int i = 1;i < cnt;++i){
            bool first = true;
            for(int j = 1;j <= n;++j){
                if(color[j]==i){
                   if(first)printf("%d",j);
                   else printf(" %d",j);
                   first = false;
                }
            }
            printf("\n");
        }
        printf("%d\n",n-ans);
    }
    return 0;
}

网络流最大流版：

     算法的一些思路上面的都已经说的很好了，这里就不再赘述了。就是最小路径覆盖 = 顶点数 - 最大匹配数。然后，在递归求判断是否满流打印解路径就可以了。通过这题，我理解了以前一直没有理解的最小路径覆盖。而且加深了对二分匹配的理解，也知道了如何实现最小路径覆盖的拆点的做法。即，输入两个联系的边(x,y)可以通过把y’ = y+n(n为题中的顶点个数)来达到拆点的目的。此时建立的图，就是一个二分图。

#include <iostream>
#include <vector>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 2e3 + 5;
const int INF = 1e6;
struct Edge{
   int from,to,cap,flow;
};
vector<Edge> edges;
vector<int> G[maxn];
int d[maxn],cur[maxn];
bool vst[maxn];
int n,m,s,t;
void Init()
{
    for(int i = 0;i < maxn;++i)
        G[i].clear();
    edges.clear();
}
void AddEdge(int from,int to,int cap)
{
    edges.push_back((Edge){from,to,cap,0});
    edges.push_back((Edge){to,from,0,0});
    int sz = edges.size();
    G[from].push_back(sz-2);
    G[to].push_back(sz-1);
}
bool BFS()
{
    memset(vst,false,sizeof(vst));
    queue<int> Q;
    Q.push(s);
    d[s] = 0;
    vst[s] = true;
    while(!Q.empty()){
        int u = Q.front();
        Q.pop();
        for(int i = 0;i < (int)G[u].size();++i){
            Edge& e = edges[G[u][i]];
            if(!vst[e.to]&&e.cap > e.flow){
                vst[e.to] = true;
                d[e.to] = d[u] + 1;
                Q.push(e.to);
            }
        }
    }
    return vst[t];
}
int DFS(int u,int a)
{
    if(u==t||a==0)
        return a;
    int f,flow = 0;
    for(int& i = cur[u];i < (int)G[u].size();++i){
        Edge& e = edges[G[u][i]];
        if(d[e.to]==d[u]+1&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
            e.flow += f;
            edges[G[u][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a==0)break;
        }
    }
    return flow;
}
int Maxflow()
{
    int flow = 0;
    while(BFS()){
        memset(cur,0,sizeof(cur));
        flow += DFS(s,INF);
    }
    return flow;
}
void Print(int u)
{
    vst[u] = true;
    for(int i = 0;i < (int)G[u].size();++i){
        Edge& e = edges[G[u][i]];
        if(e.flow == 1&&e.from!=s&&e.to!=t){
            printf(" %d",e.to-n);
            Print(e.to-n);
        }
        break;
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m)){
        Init();
        int x,y;
        for(int i = 0;i < m;++i){
            scanf("%d%d",&x,&y);
            AddEdge(x,y+n,1);          // 拆点
        }
        s = 0,t = 2*n+1;
        for(int i = 1;i <= n;++i){
            AddEdge(s,i,1);
            AddEdge(i+n,t,1);
        }
        int ans = n - Maxflow();
        memset(vst,0,sizeof(vst));
        for(int i = 1;i <= n;++i)if(!vst[i]){
            printf("%d",i);
            Print(i);
            printf("\n");
        }
        printf("%d\n",ans);
    }
    return 0;
}