loj 6197. 法克 最小路径覆盖 好题

题目链接点这里

传统的最小路径覆盖算法是不能多次经过一个点的，解决方法有以下三种：

1：构造floyd闭包，对于间接到达的边也加边，转化为传统路径覆盖来做。可以看这题，缺点是仅适用于n较小的情况

2：我们可以知道，每个点必须经过一次，对于x拆点成x和n+x后，加一条下届为1的边，然后我们可以利用上下界最小流，直接跑出最小流，这就是答案。。可惜我超时了一组数据

3：就是题解中所说的，，就是在传统最小路径覆盖建完图之后，对于n+i到i建一条INF的边。。然后跑最大流就好了、、。完美

#include<iostream>
#include<cstdio>
#include<math.h>
#include<algorithm>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<queue>
#include<string.h>
#include<cstring>
#include<vector>
#include<time.h>
#include<stdlib.h>
using namespace std;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3f
#define FIN freopen("input.txt","r",stdin)
#define mem(x,y) memset(x,y,sizeof(x))
typedef unsigned long long ULL;
typedef long long LL;
#define fuck(x) cout<<"x"<<endl;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef pair<pair<int,int>,int> PIII;
typedef pair<LL,LL> PII;
const double eps=1e-100;
const int MX=555555;
const int P=1e9+7;
int n,m;
int head[MX],e_cnt;
struct Edge
{
    int nxt,to,cap;
} E[2*MX];
void edge_init()
{
    mem(head,-1);
    e_cnt=0;
}
void edge_add(int u,int v,int cap)
{
    E[e_cnt].nxt=head[u];
    E[e_cnt].to=v;
    E[e_cnt].cap=cap;
    head[u]=e_cnt++;
}
//正向边和反向边一定要一起建立！！，因为用到i^1
bool vis[MX];//注意点数！！
int d[MX],cur[MX];//注意点数！！
bool BFS(int s,int t)
{
    mem(vis,0);
    queue<int> Q;
    Q.push(s);
    vis[s]=1;
    d[s]=0;
    d[t]=-1;
    while(!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        for(int i=head[u]; ~i; i=E[i].nxt)
        {
            int v=E[i].to;
            if(vis[v]||!E[i].cap) continue;
            d[v]=d[u]+1;
            vis[v]=1;
            Q.push(v);
        }
    }
    return d[t]!=-1;
}
int DFS(int x,int t,int a)
{
    if(x==t||a==0) return a;
    int flow=0,f;
    for(int &i=cur[x]; ~i; i=E[i].nxt)
    {
        int v=E[i].to;
        if(d[v]==d[x]+1&&(f=DFS(v,t,min(a,E[i].cap))))
        {
            E[i].cap-=f;
            E[i^1].cap+=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}
int Dinic(int s,int t)
{
    int flow=0;
    while(BFS(s,t))
    {
        memcpy(cur,head,sizeof(head));
        flow+=DFS(s,t,INF);
    }
    return flow;
}
int main()
{
    FIN;
    while(cin>>n>>m)
    {
        int s=0,t=2*n+1;
        edge_init();
        for(int i=1; i<=m; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            edge_add(u,v+n,INF);
            edge_add(v+n,u,0);
        }
        for(int i=1; i<=n; i++)
        {
            edge_add(n+i,i,INF);
            edge_add(i,n+i,0);
            edge_add(s,i,1);
            edge_add(i,s,0);
            edge_add(i+n,t,1);
            edge_add(t,i+n,0);
        }
        cout<<n-Dinic(s,t)<<endl;
    }
    return 0;
}