最小路径覆盖问题(网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;
}