[网络流二十四题]最小路径覆盖问题

最小路径覆盖

 

题目描述

 

一个有向无回路的图G＝(V，E)的一个路径覆盖是一个其结点不相交的路径集合P，图中的每一个结点仅包含于P中的一条路径。路径可从任意结点开始和结束，且长度也为任意值，包括0。请写出一个有效算法，找出一个包含尽可能少的路径的路径覆盖图中的所有点。

　　例如下图至少用两条路径覆盖，路径可以是：1-5-3，2-4。

 

输入

 

输入文件第一行为n(n≤4000)，表示图G的顶点个数，从第二行开始每行有两个数u,v表示存在边（u,v）。

 

输出

 

输出文件的第一行为所求的最少的路径覆盖数k。第二行至第k+1行为每条路径上以0结尾的顶点序列。

 

样例输入

 

5
1 2
1 5
2 3
2 4
5 3

 

样例输出

 

2
1 5 3 0
2 4 0


    这题自己的代码调了一晚上+早上一节课莫名其妙调不过去--弃了 抄了同学的代码
    这个问题乍一看似乎与网络流没有什么关系，一开始我想到的似乎是最小割
    后来经过dalao们指导，知道了是把DAG中点每一个点拆成一个出点一个入点，然后重构成二分图。
    因为最小路径覆盖中的每一个路径上点（非起点终点）的出度与入度都是1
    所以就能用二分图最大匹配来求解最小路径覆盖
    答案是n - 二分图最大匹配数
    这里的解法用的是Dinic，对于二分图出点集合中的每一个点，连一条从S出发的边，对于每个出点集合中的点连一条边到T，跑一遍最大流就好了
    下面是同学的代码:

#include<iostream>
#include<cmath>
#include<cstdio> 
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#define inf 0x7fffffff 
using namespace std;
struct edge {
    int to, cap, next;
}e[400005];
int head[8005], iter[8005], lev[8005], way[8005];
bool mk[8005];
int st, en, c, cnt = 1, s, t, n, m;
inline void ins(int x, int y, int cp)
{
    cnt++; e[cnt].to = y; e[cnt].next = head[x]; head[x] = cnt; e[cnt].cap = cp;
    cnt++; e[cnt].to = x; e[cnt].next = head[y]; head[y] = cnt; e[cnt].cap = 0;
}
void bfs()
{
    memset(lev, -1, sizeof(lev));
    queue<int>q;
    lev[0] = 0; q.push(0);
    while (!q.empty()) {
        int v = q.front(); q.pop();
        for (int i = head[v]; i; i = e[i].next) {
            edge &ed = e[i];
            if (ed.cap>0 && lev[ed.to]<0) {
                lev[ed.to] = lev[v] + 1; q.push(ed.to);
            }
        }
    }
}
int dfs(int u, int f)
{
    int used = 0;
    if (u == t) return f;
    for (int i = head[u]; i; i = e[i].next)
    {
        edge &ed = e[i];
        if (ed.cap>0 && lev[u]<lev[ed.to]) {
            int w = dfs(ed.to, min(f - used, ed.cap));
            if (w>0) {
                if (ed.to - n>0) { way[u] = ed.to - n; mk[ed.to - n] = true; }
                ed.cap -= w; e[i ^ 1].cap += w; used += w;
                if (used == f) return f;
            }
        }
    }
    if (!used) lev[u] = -1;
    return used;
}
int dinic()
{
    int fl = 0;
    while (1)
    {
        bfs(); if (lev[t]<0) return fl;
        int d = dfs(0, inf); if (d>0) fl += d;
    }
}
int main()
{
    scanf("%d", &n); s = 0; t = 2 * n + 1;
    while (scanf("%d%d", &st, &en) == 2) ins(st, en + n, 1);
    for (int i = 1; i <= n; i++) ins(0, i, 1); for (int i = 1; i <= n; i++)ins(i + n, 2 * n + 1, 1);
    printf("%d\n", n - dinic());
    for (int i = 1; i <= n; i++) {
        if (mk[i]) continue;
        for (int j = i; j; j = way[j]) printf("%d ", j);
        printf("0\n");
    }
    return 0;
}

            下面是自己的（恬不知耻的放上来）不知道哪里出BUG了QAQQ

#include<cstdio>
#include<cstring>
#include<queue>

const int Maxv = 8005, INF = 0x6ffffff; 
int Head[Maxv], Next[Maxv << 1], V[Maxv << 1], W[Maxv << 1], Way[Maxv], Dep[Maxv], cnt = 1, n, s, t; 
bool Mk[Maxv]; 

void Add(int u, int v, int w){
    cnt++; 
    Next[cnt] = Head[u]; 
    V[cnt] = v; 
    W[cnt] = w; 
    Head[u] = cnt; 
}

void Add_Edge(int u, int v, int w){
    Add(u, v, w); 
    Add(v, u, 0); 
}

void BFS(){
    std::queue<int> Q; 
    memset(Dep, -1, sizeof(Dep)); 
    Dep[s] = 0; 
    Q.push(s); 
    while (!Q.empty()) { 
        int u = Q.front(); 
        Q.pop();
        for (int i = Head[u]; i; i = Next[i]) {
            if (Dep[V[i]] < 0 && W[V[i]] > 0) {  //没有增广过且剩余容量大于0 
                Dep[V[i]] = Dep[u] + 1; 
                Q.push(V[i]); 
            }
        }
    }
}

int DFS(int u, int dist){
    int flow = 0; 
    if (u == t) {
        return dist; 
    }
    for (int i = Head[u]; i; i = Next[i]) {
        if (Dep[V[i]] == Dep[u] + 1 && W[i] > 0) {
            int w = DFS(V[i], std::min(dist - flow, W[i])); 
            if (w > 0) {
                if (V[i] - n > 0) {
                    Way[u] = V[i] - n; 
                    Mk[V[i] - n] = true; 
                }
                W[i] -= w; 
                W[i ^ 1] += w; 
                flow += w; 
                if (flow == dist) {
                    return dist; 
                }
            }
        }
    }
    if (!flow) {
        Dep[u] = -1; 
    }
    return flow; 
}

int Dinic() {
    int Ans = 0; 
    while (1) {
        BFS(); 
        if (Dep[t] < 0) {
            return Ans; 
        }
        int d = DFS(0, INF); 
        if (d > 0) {
            Ans += d;  
        }
    }
}

int main(){
    int st, ed; 
    scanf("%d", &n); 
    s = 0;
    t = 2 * n + 1; 
    while (scanf("%d%d", &st, &ed) == 2) {
        Add_Edge(st, ed, 1); 
    }
    for (int i = 1; i <= n; i++) {
        Add_Edge(s, i, 1);
    }
    for (int i = 1; i <= n; i++) {
        Add_Edge(i + n, t, 1);
    }            //连入超级S和超级T, 把DAG重构成二分图
    printf("%d\n", n - Dinic());    
    for (int i = 1; i <= n; i++) {
        if (Mk[i]) {
            continue; 
        }
        for (int j = 1; j; j = Way[j]) {
            printf("%d ", j); 
        }
        printf("0\n"); 
    }
    return 0; 
}