定义：在一个有向图中，找出最少的路径，使得这些路径经过了所有的点。

最小路径覆盖分为最小不相交路径覆盖和最小可相交路径覆盖。

最小不相交路径覆盖：每一条路径经过的顶点各不相同。如图，其最小路径覆盖数为3。即1->3>4，2，5。

最小可相交路径覆盖：每一条路径经过的顶点可以相同。如果其最小路径覆盖数为2。即1->3->4，2->3>5。

特别的，每个点自己也可以称为是路径覆盖，只不过路径的长度是0。

 

算法：把原图的每个点V拆成$V_x$和$V_y$两个点，如果有一条有向边A->B，那么就加边$A_x->B_y$。这样就得到了一个二分图。那么最小路径覆盖=原图的结点数-新图的最大匹配数。

证明：一开始每个点都是独立的为一条路径，总共有n条不相交路径。我们每次在二分图里找一条匹配边就相当于把两条路径合成了一条路径，也就相当于路径数减少了1。所以找到了几条匹配边，路径数就减少了多少。所以有最小路径覆盖=原图的结点数-新图的最大匹配数。

因为路径之间不能有公共点，所以加的边之间也不能有公共点，这就是匹配的定义。

习题：POJ1422

  1. //
  2. //  main.cpp
  3. //  POJ1422最小不想交路径覆盖
  4. //
  5. //  Created by beMaster on 16/4/8.
  6. //  Copyright © 2016年 beMaster. All rights reserved.
  7. //
  9. #include <iostream>
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <vector>
  13. using namespace std;
  14. const int N = 200 + 10;
  15. vector<int> g[N];
  16. int cy[N];
  17. bool vis[N];
  18. bool dfs(int u){
  19.     for(int i=0; i<g[u].size(); ++i){
  20.         int v = g[u][i];
  21.         if(vis[v]) continue;
  22.         vis[v] = true;
  23.         if(cy[v]==-1 || dfs(cy[v])){
  24.             cy[v] = u;
  25.             return true;
  26.         }
  27.     }
  28.     return false;
  29. }
  30. int solve(int n){
  31.     int ret = 0;
  32.     memset(cy, -1, sizeof(cy));
  33.     for(int i=1;i<=n;++i){
  34.         memset(vis, 0, sizeof(vis));
  35.         ret += dfs(i);
  36.     }
  37.     return n - ret;
  38. }
  39. int main(int argc, const char * argv[]) {
  40.     int t,n,m;
  41.     int u,v;
  42.     scanf("%d",&t);
  43.     while(t--){
  44.         scanf("%d%d",&n,&m);
  45.         for(int i=1;i<=n;++i)
  46.             g[i].clear();
  47.         for(int i=0;i<m;++i){
  48.             scanf("%d%d",&u,&v);
  49.             g[u].push_back(v);
  50.         }
  51.         
  52.         int ans = solve(n);
  53.         printf("%d\n",ans);
  54.     }
  55.     return 0;
  56. }

 

算法：先用floyd求出原图的传递闭包，即如果a到b有路径，那么就加边a->b。然后就转化成了最小不相交路径覆盖问题。

证明：为了连通两个点，某条路径可能经过其它路径的中间点。比如1->3->4，2->4->5。但是如果两个点a和b是连通的，只不过中间需要经过其它的点，那么可以在这两个点之间加边，那么a就可以直达b，不必经过中点的，那么就转化成了最小不相交路径覆盖。

题目：POJ2594

  1. //
  2. //  main.cpp
  3. //  POJ2594最小可相交路径覆盖
  4. //
  5. //  Created by beMaster on 16/4/8.
  6. //  Copyright © 2016年 beMaster. All rights reserved.
  7. //
  9. #include <iostream>
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <vector>
  13. using namespace std;
  14. const int N = 500 + 10;
  15. bool dis[N][N];
  16. bool vis[N];
  17. int cy[N];
  18. void floyd(int n){
  19.     for(int i=1;i<=n;++i)
  20.         for(int j=1;j<=n;++j)
  21.             for(int k=1;k<=n;++k)
  22.                 if(dis[i][k] && dis[k][j])//传递可达性
  23.                     dis[i][j] = true;
  24. }
  25. bool dfs(int u, int n){
  26.     for(int i=1;i<=n;++i){
  27.         if(!vis[i] && dis[u][i]){
  28.             vis[i] = true;
  29.             if(cy[i]==-1 || dfs(cy[i], n)){
  30.                 cy[i] = u;
  31.                 return true;
  32.             }
  33.         }
  34.     }
  35.     return false;
  36. }
  37. int solve(int n){
  38.     int cnt = 0;
  39.     memset(cy,-1,sizeof(cy));
  40.     for(int i=1;i<=n;++i){
  41.         memset(vis,0,sizeof(vis));
  42.         cnt += dfs(i, n);
  43.     }
  44.     return n - cnt;
  45. }
  46. int main(int argc, const char * argv[]) {
  47.     int n,m;
  48.     int a,b;
  49.     while(scanf("%d%d",&n,&m),n+m){
  50.         for(int i=1;i<=n;++i)
  51.             for(int j=1;j<=n;++j)
  52.                 dis[i][j] = false;
  53.         for(int i=1;i<=m;++i){
  54.             scanf("%d%d",&a,&b);
  55.             dis[a][b] = true;
  56.         }
  57.         floyd(n);
  58.         int ans = solve(n);
  59.         printf("%d\n",ans);
  60.     }
  61.     return 0;
  62. }
  63.

 

 

参考：

二分图大讲堂——彻底搞定最大匹配数（最小覆盖数）、最大独立数、最小路径覆盖、带权最优匹配

版权声明：本文为原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：