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

今天写到这类题，没学过，当场学习！
记录一下。
（刚学,还没有完全理解，可能有错误，一发现错误就回来改）

定义：

前提：有向无环图
最小路径覆盖：找出最少的路径，使得路径经过所有点
最小路径覆盖分为：
1.最小不相交路径覆盖：顾名思义，就是路径不相交，没有经过相同的点。
2.最小可相交路径覆盖：就是能经过相同的点

最小不相交路径覆盖

解题方法：对题目给的图进行最大匹配，如最大匹配为ans，节点数量为n
则最小路径为（n-ans）
原理：不匹配的时候需要的路径为n，每次匹配到一条边相当于将这条边的两个点缩成一个点，，所以n-1，最多匹配ans条边，则最小路径为n-ans

例题：hdu1151
code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
typedef long long ll;
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int maxm=200;
vector<int>g[maxm];
int mark[maxm];
int now[maxm];
int n,m;
int dfs(int x){
    for(int i=0;i<(int)g[x].size();i++){
        int v=g[x][i];
        if(!mark[v]){
            mark[v]=1;
            if(now[v]==0||dfs(now[v])){
                now[v]=x;
                return 1;
            }
        }
    }
    return 0;
}
int main(){
    int T;
    cin>>T;
    while(T--){
        cin>>n>>m;
        for(int i=1;i<=n;i++){
            g[i].clear();
        }
        for(int i=1;i<=m;i++){
            int a,b;
            cin>>a>>b;
            g[a].push_back(b);
        }
        int ans=0;
        memset(now,0,sizeof now);
        for(int i=1;i<=n;i++){
            memset(mark,0,sizeof mark);
            ans+=dfs(i);
        }
        cout<<n-ans<<endl;
    }
    return 0;
}

最小可相交路径覆盖

例题：poj2594
解题方法：先用floyd传递闭包增加路径数量，剩余步骤和最小不相交路径覆盖相同
原理：假如有一条边是a->b->c,传递闭包时添加a->c的边（不管它是否经过b）剩下的就变成最小不相交路径了。（感觉有点错误）
code：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
typedef long long ll;
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int maxm=505;
int g[maxm][maxm];
int mark[maxm];
int now[maxm];
int n,m;
int dfs(int x){
    for(int i=1;i<=n;i++){
        if(g[x][i]&&!mark[i]){
            mark[i]=1;
            if(now[i]==0||dfs(now[i])){
                now[i]=x;
                return 1;
            }
        }
    }
    return 0;
}
int main(){
    while(cin>>n>>m&&(n+m)){
        memset(g,0,sizeof g);
        for(int i=1;i<=m;i++){
            int a,b;
            cin>>a>>b;
            g[a][b]=1;
        }
        for(int k=1;k<=n;k++){//floyd传递闭包
            for(int i=1;i<=n;i++){
                if(g[i][k]==1){//减少不必要的循环
                    for(int j=1;j<=n;j++){
                        if(g[k][j]==1){
                            g[i][j]=1;
                        }
                    }
                }
            }
        }
        int ans=0;
        memset(now,0,sizeof now);
        for(int i=1;i<=n;i++){
            memset(mark,0,sizeof mark);
            ans+=dfs(i);
        }
        cout<<n-ans<<endl;
    }

    return 0;
}