最小路径覆盖问题(网24题，二)

                                                        最小路径覆盖问题

 

题目链接：Click Here~

算法分析：

    DAG的最小路径覆盖。所谓最小路径覆盖，就是在图中找尽量少的路径，使得每个结点恰好在一条路径上（换句话说，不同的路径不能有公共点）。注意，单独的结点也可以作为一条路径。

   DAG的最小路径覆盖解法如下：吧所有结点i拆为X结点i和Y结点i'，如果图G中存在有向边i->j'，则在二分图中引入边i->j'。设二分图最大匹配数为m，则结果就是n-m。

证明：

   因为匹配和路径覆盖式意义对应的。对于路径覆盖中的每条简单路径，除了最后一个“结尾节点”之外都有唯一的后继和它对应（即匹配结点），因此匹配就是非结尾结点的个数。@(其实不准确)。当匹配数达到最大是，非结尾结点的个数也将达到最大。此时，结尾结点的个数最少，即路径条数最少。

 @准确解释是：匹配数要分奇偶讨论，总的应该是(x+1)/2。

  需要注意的是，本算法也适用于带权的DAG，但不适用与非DAG的有向图（即有环的有向图）。

下面是转载自别人的博客：

【问题分析】

有向无环图最小路径覆盖，可以转化成二分图最大匹配问题，从而用最大流解决。

【建模方法】

构造二分图，把原图每个顶点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;
}