「网络流24题」最小路径覆盖问题

Posted qixingzhi

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了「网络流24题」最小路径覆盖问题相关的知识,希望对你有一定的参考价值。

传送门:>Here<

题意:求DAG的最小路径覆盖并输出方案。所谓最小路径覆盖是指,将原图分为若干条路径,任意两条路径不能有公共点,要使路径数量尽可能少

思路分析

依然能够联系到二分图。事实上这个问题在学二分图的时候提到过,然而当时并没有弄明白……

公式:DAG的最小路径覆盖 = 顶点数 - 最大匹配

千万不要弄混淆的是这里的最大匹配并不是指直接在DAG上做最大匹配,而是需要拆点然后搞。

具体过程如下:

原图共有N个点。将每个点$i$拆成两个点,记为$X_i$与$Y_i$,对于任意一条原图中的边$(u,v)$,连接$(X_u, Y_v)$(有向边)。很容易发现,左半部对应着每条边的起点,右半部对应着终点。然后以X为左半部,Y为右半部做二分图的最大匹配,得到答案ans,则最小路径覆盖就是N-ans。

为什么最小路径覆盖就是N-ans呢?

假设拆点建的图中一条匹配边都没有——也就意味着没有边。此时每一个顶点为一条路径,最小路径覆盖为N。

然后,在拆点建的图中增加一条匹配边,我们发现这对应着原图中的一个点融入了另一条路径,因此最小路径覆盖要-1。进一步我们发现,每增加一条能够匹配的边,就意味着原图中的又一个点加入到了某一条路径当中。因此最小路径覆盖会-1。因此有多少条匹配边就减几次。所以要让答案最小,也就是让匹配边尽量多。问题转化为了二分图的最大匹配问题

那为什么我们要拆点呢?原因在于原图是一个有向图,对于一个路径内部的点(非起点、终点),一定有一条边进入它,一条边从它出。如果直接拿原图做二分图匹配不会容许一个点有两条边的情况。而拆点以后,左侧的点仅仅作为起点,右侧的点仅仅作为终点,因此这种情况对应到每一个点依然只有一条边。如果一个点出发有两条边,对应着原图中一个点作为起点有两条边,此时由于要求最小路径覆盖,必须舍弃一条边,二分图匹配会自动舍弃另一条边。

以上是公式的原理,下面来谈如何输出方案。

对于每一个起点,我们记录它出发是否有一条饱和弧到达一个终点,如果有,意味着它一定不是终点。我们对于每一个点记录一个由它出发到达的点(sec),以及以它作为终点的边的那个起点(pre)。如果当前点不作为任何一条边的终点,那它就是起点;反之,如果不到达任何一个其他点,那么它就是终点。因此我们只需要枚举每个点以及由他延伸出去的弧,查看每条弧是否饱和,若饱和则说明这是匹配边,记录sec和pre即可

Code

/*By DennyQi*/
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
#define  r  read()
#define  Max(a,b)  (((a)>(b)) ? (a) : (b))
#define  Min(a,b)  (((a)<(b)) ? (a) : (b))
using namespace std;
typedef long long ll;
const int MAXN = 10010;
const int MAXM = 10010;
const int INF = 1061109567;
inline int read(){
    int x = 0; int w = 1; register int c = getchar();
    while(c ^ - && (c < 0 || c > 9)) c = getchar();
    if(c == -) w = -1, c = getchar();
    while(c >= 0 && c <= 9) x = (x << 3) +(x << 1) + c - 0, c = getchar(); return x * w;
}
int N,M,S,T,x,y,ans_min;
int first[MAXM*2],nxt[MAXM*2],to[MAXM*2],cap[MAXM*2],flow[MAXM*2],num_edge=-1;
int level[MAXN],cur[MAXN],pre[MAXN],sec[MAXN];
queue <int> q;
inline void add(int u, int v, int c, int f){
    to[++num_edge] = v;
    cap[num_edge] = c;
    flow[num_edge] = f;
    nxt[num_edge] = first[u];
    first[u] = num_edge;
}
inline bool BFS(){
    memset(level, 0, sizeof(level));
    while(!q.empty()) q.pop();
    q.push(S);
    level[S] = 1;
    int u,v;
    while(!q.empty()){
        u = q.front(); q.pop();
        for(int i = first[u]; i != -1; i = nxt[i]){
            v = to[i];
            if(!level[v] && cap[i]-flow[i]>0){
                level[v] = level[u]+1;
                q.push(v);
            }
        }
    }
    return level[T]!=0;
}
int DFS(int u, int a){
    if(u == T || a == 0) return a;
    int ans = 0, v, _f;
    for(int& i = cur[u]; i != -1; i = nxt[i]){
        v = to[i];
        if(level[u]+1==level[v] && cap[i]-flow[i]>0){
            _f = DFS(v, Min(a,cap[i]-flow[i]));
            ans += _f, a -= _f;
            flow[i] += _f, flow[i^1] -= _f;
            if(a == 0) break;
        }
    }
    return ans;
}
inline void Dinic(){
    int ans = 0;
    while(BFS()){
        for(int i = S; i <= T; ++i) cur[i] = first[i];
        ans += DFS(S, INF);
    }
    ans_min = N - ans;
}
int main(){
    N=r,M=r;
    S = 0, T = 2*N+2;
    memset(first, -1, sizeof(first));
    for(int i = 1; i <= M; ++i){
        x=r,y=r;
        add(x, y+N, 1, 0);
        add(y+N, x, 0, 0);
    }
    for(int i = 1; i <= N; ++i){
        add(S, i, 1, 0), add(i, S, 0, 0);
        add(i+N, T, 1, 0), add(T, i+N, 0, 0);
    }
    Dinic();
    for(int i = 1; i <= N; ++i){
        int v;
        for(int j = first[i]; j != -1; j = nxt[j]){
            v = to[j];
            if(cap[j]-flow[j]==0 && cap[j]==1){
                pre[v-N] = i;
                sec[i] = v-N;
            }
        }
    }
    for(int i = 1; i <= N; ++i){
        if(!pre[i]){
            int u = i;
            while(sec[u] != 0){
                printf("%d ", u);
                u = sec[u];
            }
            printf("%d
",u);
        }
    }
    printf("%d", ans_min);
    return 0;
}

 

 

以上是关于「网络流24题」最小路径覆盖问题的主要内容,如果未能解决你的问题,请参考以下文章

网络流24题 #03最小路径覆盖问题

「网络流24题」最小路径覆盖问题

最小路径覆盖问题网络流24题

网络流24题 最小路径覆盖问题

COGS728. [网络流24题] 最小路径覆盖问题

[网络流24题] 最小路径覆盖问题