最小路径覆盖

  最小不可交路径覆盖 

题目链接：https://www.luogu.org/problemnew/show/P2764

　题解：

　　如何建模？

　 把每个点i拆成xi和yi两个点。若i与j间有边，就链接xi与yj，求两个集合的最大匹配。

　　证明：

　 我们可以把一开始的点每个点看做一条路径。那么每增加一条匹配边，就相当于把两个路径连在一起。连起来的路径越多，则最后路径总数越少。

　　怎么求最大匹配？

　 网络流。

　　怎么输出方案？

　 一开始建两层图。比较修改的图与原图，有修改的地方就是连接的路径。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<bitset>
#define LL long long
#define RI register int
using namespace std;
const int INF = 0x7ffffff ;
const int N = 150 + 10 ;
const int M = 6000 + 10 ;

inline int read() {
    int k = 0 , f = 1 ; char c = getchar() ;
    for( ; !isdigit(c) ; c = getchar())
      if(c == '-') f = -1 ;
    for( ; isdigit(c) ; c = getchar())
      k = k*10 + c-'0' ;
    return k*f ;
}
struct Edge {
    int to, next, flow ;
}e[(M<<1)+(N<<2)], ee[(M<<1)+(N<<2)] ;
int n, m, s, t ; int head[N<<1], dep[N<<1] ;
bitset<N<<1>vis ;
inline void add_edge(int x,int y,int ff) {
    static int cnt = 1 ;
    e[++cnt].to = y, e[cnt].next = head[x], e[cnt].flow = ff, head[x] = cnt ;
    ee[cnt].to = y, ee[cnt].next = head[x], ee[cnt].flow = ff;
    e[++cnt].to = x, e[cnt].next = head[y], e[cnt].flow = 0, head[y] = cnt ;
    ee[cnt].to = x, ee[cnt].next = head[y], ee[cnt].flow = 0 ;
}

inline bool F_bfs() {
    memset(dep,0,sizeof(dep)) ;
    queue<int>q ; q.push(s) ; dep[s] = 1 ;
    while(!q.empty()) {
        int x = q.front() ; q.pop() ;
        for(int i=head[x];i;i=e[i].next) {
            int y = e[i].to ; if(dep[y] || !e[i].flow) continue ;
            dep[y] = dep[x] + 1 ; q.push(y) ;
        }
    }
    return dep[t] ;
}
int F_dfs(int x,int minflow) {
    if(x == t || minflow <= 0) return minflow ;
    int fflow = 0 ;
    for(int i=head[x];i;i=e[i].next) {
        int y = e[i].to ; if(dep[y] != dep[x]+1) continue ;
        int temp = F_dfs(y,min(minflow,e[i].flow)) ;
        fflow += temp ; minflow -= temp ;
        e[i].flow -= temp ; e[i^1].flow += temp ;        
//        out[x]++, out[y]-- ; printf("x:%d,y:%d
",x,y) ;
        if(!minflow) break ;
    }
    return fflow ;
}

void dfs(int x) {
    vis[x] = 1 ;
    printf("%d ",x) ;
    for(int i=head[x];i;i=e[i].next) {
        int y = e[i].to ;
        if(ee[i].flow && !e[i].flow) {
            dfs(y-n) ; break ;
        }
    }
}

int main() {
//    freopen("path3.in","r",stdin) ;
//    freopen("path3.out","w",stdout) ;
    n = read(), m = read() ;
    int x, y, ans = 0 ; s = (n<<1)+1, t = (n<<1)+2 ;
    for(int i=1;i<=m;i++) {
        x = read(), y = read() ;
        add_edge(x,n+y,1) ;
    }
    for(int i=1;i<=n;i++) add_edge(s,i,1) ;
    for(int i=n+1;i<=(n<<1);i++) add_edge(i,t,1) ;
    while(F_bfs()) {
        ans += F_dfs(s,INF) ;
    }
//    printf("ans:%d
",ans) ;
    ans = n-ans ;    
    for(int i=1;i<=n;i++) {
        if(vis[i]) continue ;
        bool flag = 0 ;
        for(int j=head[i];j;j=e[j].next) {
            if(ee[j].flow && !e[j].flow) {
                flag = 1 ; break ;
            }
        }
        if(flag) {
            dfs(i) ; printf("
") ;
        }
    }
    printf("%d
",ans) ;
    return 0 ;
}

 最小可交路径覆盖

   把每个点与它可到达的点都按上题连上边，然后就按上题求即可。

 魔术球问题

题目链接：https://www.luogu.org/problemnew/show/P2765

　　每增加一个球求一遍最小路径覆盖。连完新边之后直接在残量网络上求即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue> 
#include<bitset>
#define LL long long
#define RI register int
using namespace std;
const int INF = 0x7ffffff ;
const int N = 55 + 2 ;
const int M = 1600 + 10 ;

inline int read() {
    int k = 0 , f = 1 ; char c = getchar() ;
    for( ; !isdigit(c) ; c = getchar())
      if(c == '-') f = -1 ;
    for( ; isdigit(c) ; c = getchar())
      k = k*10 + c-'0' ;
    return k*f ;
}
struct Edge {
    int to, next, flow ;
}e[M*100], ee[M*100] ;
int n, s, t ; int head[M<<1], dep[M<<1] ;
bitset<M>vis ;
inline void add_edge(int x,int y,int ff) {
    static int cnt = 1 ;
    ee[++cnt].to = y, ee[cnt].next = head[x], ee[cnt].flow = ff ;
    e[cnt].to = y, e[cnt].next = head[x], e[cnt].flow = ff, head[x] = cnt ;
    ee[++cnt].to = x, ee[cnt].next = head[y], ee[cnt].flow = 0 ;
    e[cnt].to = x, e[cnt].next = head[y], e[cnt].flow = 0, head[y] = cnt ;
}

inline bool F_bfs() {
    memset(dep,0,sizeof(dep)) ;
    queue<int>q ; q.push(s) ; dep[s] = 1 ;
    while(!q.empty()) {
        int x = q.front() ; q.pop() ;
        for(int i=head[x];i;i=e[i].next) {
            int y = e[i].to ; if(dep[y] || !e[i].flow) continue ;
            dep[y] = dep[x] + 1 ; q.push(y) ;
        }
    }
    return dep[t] ;
}
int F_dfs(int x,int minflow) {
//    printf("xxx
") ;
    if(x == t || minflow <= 0) return minflow ;
    int fflow = 0 ;
    for(int i=head[x];i;i=e[i].next) {
        int y = e[i].to ; if(dep[y] != dep[x]+1 || !e[i].flow) continue ;
        int temp = F_dfs(y,min(minflow,e[i].flow)) ;
        fflow += temp ; minflow -= temp ;
        e[i].flow -= temp ; e[i^1].flow += temp ;
        if(!minflow) break ;
    }
    return fflow ;
}
void dfs(int x) {
    printf("%d ",x) ; vis[x] = 1 ;
    for(int i=head[x];i;i=e[i].next) {
        if(ee[i].flow && !e[i].flow) {
            dfs(e[i].to-M) ; break ;
        }
    }
}

inline int sqr(int x) { return x*x ; }
int main() {
//    freopen("balla.in","r",stdin) ;
//    freopen("balla.out","w",stdout) ;
    n = read() ; int nn = 0 ; s = (M<<1)-10, t = (M<<1)-9 ;
    int ans = 0, maxx ;
    while(1) {
        nn++ ;
        add_edge(s,nn,1) ; add_edge(nn+M,t,1) ;
        for(int i=1;i<nn;i++) if(sqr(sqrt(i+nn)) == i+nn) add_edge(i,nn+M,1) ;
        while(F_bfs()) ans += F_dfs(s,INF) ;
        if(nn-ans > n) break ;
        maxx = nn ;
    }
    printf("%d
",maxx) ;
    for(int x=1;x<=maxx;x++) {
        if(vis[x]) continue ;
//        for(int i=head[x];i;i=e[i].next) {
//            if(ee[i].flow && !e[i].flow) {
        dfs(x) ; printf("
") ; // break ;
//            }
//        }
    }
    return 0 ;
}