有向无环图（DAG）的最小路径覆盖

DAG的最小路径覆盖

 

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

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

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

最小可相交路径覆盖：每一条路径通过的顶点能够相同。若是其最小路径覆盖数为2。即1->3->4，2->3>5。

特别的，每一个点本身也能够称为是路径覆盖，只不过路径的长度是0。

 

DAG的最小不相交路径覆盖

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

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

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

习题：POJ1422

//
//  main.cpp
//  POJ1422最小不想交路径覆盖
//
//  Created by beMaster on 16/4/8.
//  Copyright © 2016年 beMaster. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int N = 200 + 10;
vector<int> g[N];
int cy[N];
bool vis[N];
bool dfs(int u){
    for(int i=0; i<g[u].size(); ++i){
        int v = g[u][i];
        if(vis[v]) continue;
        vis[v] = true;
        if(cy[v]==-1 || dfs(cy[v])){
            cy[v] = u;
            return true;
        }
    }
    return false;
}
int solve(int n){
    int ret = 0;
    memset(cy, -1, sizeof(cy));
    for(int i=1;i<=n;++i){
        memset(vis, 0, sizeof(vis));
        ret += dfs(i);
    }
    return n - ret;
}
int main(int argc, const char * argv[]) {
    int t,n,m;
    int u,v;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;++i)
            g[i].clear();
        for(int i=0;i<m;++i){
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
        }
        
        int ans = solve(n);
        printf("%d\n",ans);
    }
    return 0;
}

 

DAG的最小可相交路径覆盖

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

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

题目：POJ2594

//
//  main.cpp
//  POJ2594最小可相交路径覆盖
//
//  Created by beMaster on 16/4/8.
//  Copyright © 2016年 beMaster. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
const int N = 500 + 10;
bool dis[N][N];
bool vis[N];
int cy[N];
void floyd(int n){
    for(int i=1;i<=n;++i)
        for(int j=1;j<=n;++j)
            for(int k=1;k<=n;++k)
                if(dis[i][k] && dis[k][j])//传递可达性
                    dis[i][j] = true;
}
bool dfs(int u, int n){
    for(int i=1;i<=n;++i){
        if(!vis[i] && dis[u][i]){
            vis[i] = true;
            if(cy[i]==-1 || dfs(cy[i], n)){
                cy[i] = u;
                return true;
            }
        }
    }
    return false;
}
int solve(int n){
    int cnt = 0;
    memset(cy,-1,sizeof(cy));
    for(int i=1;i<=n;++i){
        memset(vis,0,sizeof(vis));
        cnt += dfs(i, n);
    }
    return n - cnt;
}
int main(int argc, const char * argv[]) {
    int n,m;
    int a,b;
    while(scanf("%d%d",&n,&m),n+m){
        for(int i=1;i<=n;++i)
            for(int j=1;j<=n;++j)
                dis[i][j] = false;
        for(int i=1;i<=m;++i){
            scanf("%d%d",&a,&b);
            dis[a][b] = true;
        }
        floyd(n);
        int ans = solve(n);
        printf("%d\n",ans);
    }
    return 0;
}
 

 

 

参考：

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