UVA1440 有下界的最小流

题意很简单:

给出一张有向图,每次你可以从图中的任意一点出发,经过若干条边后停止,然后问你最少走几次可以将图中的每条边都走过至少一次,并且要输出方案

这个转化为网络流的话,就相当于 求一个最小流,并且存在下界,即每条边至少走一次


这让我联想到很久之前的一道题,也是有向图,问走多少条路径可以将整个图中的每条边都走过,但是跟本题不同的是,那题是不允许重复走边的。

那道题目的解是这样的:

对于图中的每个点i,设D[i]为(i的入度-i的出度)的值,按照D[i]将图中的点分类:D[i]<0的称为“入少出多”的点,D[i]>0的称为“出少入多”的点,D[i]=0的称为“入出相等”的点。则有:
定理 有向无环图中最小边路径覆盖的值等于图中所有“入少出多”的点的D值之和。
证明:
其实只需证明:对于一个至少有一条边的有向无环图,必然存在一条路径,其起点是“入少出多”的点,终点是“出少入多”的点,所有中间点都是“入出相等”的点(只要不断的在图中找到并删去这条路径,直到图中无边为止)。
首先,由于图中无环,一定存在“入少出多”的点和“出少入多”的点。
然后,假设图中所有“入少出多”的点的后继(注意:后继和后代是不同的,一个点的后代包括这个点的所有后继、所有后继的后继、所有后继的后继的后继……)也都是“入少出多”的点,则图中所有“入少出多”的点构成了一个闭合子图,在这个闭合子图中,由于所有的点都是“入少出多”的,整个子图的入度之和必然大于出度之和,这是不可能的(有向图中的所有点入度之和必然等于所有点出度之和),故可得:图中必然存在至少一个“入少出多”的点,它有不是“入少出多”的后继。
这样,在这些拥有不是“入少出多”的后继的点中选择一个点i,将其作为路径的起点,在它的不是“入少出多”的后继中选出一个点j,若j是“出少入多”的点,则边<i, j>就是符合条件的一条路径,结束;若这样的j都是“入出相等”的点,则考虑j的后代:j的后继可能都是“入少出多”的,但j的后代中必然存在至少一个点j'不是“入少出多”的(否则j的所有后代也将构成全都是“入少出多”的闭合子图),这些j'中必然存在一个点的前趋i'是“入少出多”的,这是,需要舍弃原来的路径,将i'作为新路径的起点,j'作为新路径的第一个中间点,继续找;若j的后继不全是“入少出多”的,则若其中有“出少入多”的则路径已找到,若都是“入出相等”的,由于图中无环,将路径不断延伸,最终一定会找到合法路径。

为啥讲这道题呢,肯定跟本题有关系。

上面这个定理求出的解,肯定适用于本题。但是不一定是最优解,也就是有可能多走了若干次。

这个叫可行流,可以到对应一个建好的图中,如下所示:

设每个点i的入度减去出度为d[i], S为源点,T为汇点。
对于d[i] > 0的点i, 连边<i,T>
对于d[i] < 0的点i, 连边<S,i>
其它边连法与输入的边相同。

建好的这个图的最大流就是上边那个定理求出的解,假设为flow1。

然后有一个结论,求有下界的最小流的求法是:

首先要有可行流,然后倒向求解。

保持那个中间那些边方向不变,就是输入的那些边,

然后原来从源点连过来的点都连去汇点,原来连去汇点的都从源点连过去。

即对于d[i] < 0的点i, 连边<i,T>
对于d[i] >0的点i, 连边<S,i>

这其实啊 ,就是原来那个图,然后从T到S做最大流

假设这个求出的流量是flow2,则有下界的最小流的最优解是flow1-flow2

那么这是啥原理呢。

最开始的定理中说道对于一个至少有一条边的有向无环图,必然存在一条路径,其起点是“入少出多”的点,终点是“出少入多”的点,所有中间点都是“入出相等”的点  

那么其实我们找的每条路径都是起点入少出多,差为1,终点,出少入多,也是差为1

反向建图求的是什么呢,就是在新图中起点出少入多的,差为1,终点,入少出多,也是差为1的路径

然后对于每找到这样的一个流的路径,可以将原始建图中的两条路径合并,然后新路径的中间点正好都是出入度相等的,两头出入度不同相差为1

我们通过画图来验证这个


例如此图,从上到下从左到右编号1->6

按照最开始那个定理求出的解有3个路径

 1->3   2->3->4->5   4->6

然后你倒着建图 求出来了一条可以做衔接的路径 是3->4

1->3   4->6就被连接了

从而答案减去1

在画图的过程中,我们可以发现,对于每条这样的可以当做中间衔接的路径,一定可以合并原始建图中的两个路径。

然后本题的第一个问题就解决了


然后就是输出。

没有要求字典序。

具体的做法可以这样,在逆向的建图中,假如某条边走流量走了x ,则说明整个过程中该边被走了x+1次,

那么可以构造新图,同样的位置加入一条容量为x+1的边,

可以计算出这个新图的所有的d[i],对于此图,就可以使用第一个定理来做了,必然得到最优解,

在具体实现中,可以通过dfs来寻找路径,以某点为开始时,能走就走,一直走到不能走为止,注意可能从某个点发出多个路径,

并且在走的时候需要注意的是,由于我们要删掉这条路径,会导致路径的开头和结尾的d发生变化,需要作出修改

代码参考了一下网上的一个人http://blog.csdn.net/auto_ac/article/details/9398657


#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <set>
#include <vector>
#include <map>
#define MAXN 111
#define MAXM 55555
#define INF 1000000007
using namespace std;
struct EDGE {
    int v, next;
    int w;
}edge[MAXM];
int head[MAXN], e;
void init() {
    memset(head, -1, sizeof(head));
    e = 0;
}
void add(int u, int v, int w) {
    edge[e].v = v;
    edge[e].w = w;
    edge[e].next = head[u];
    head[u] = e++;
    edge[e].v = u;
    edge[e].w = 0;
    edge[e].next = head[v];
    head[v] = e++;
}
int n, nt;
int h[MAXN];
int gap[MAXN];
int src, des;
int dfs(int pos, int cost) {
    if(pos == des) return cost;
    int j, minh = n - 1;
    int lv = cost, d;
    for(j = head[pos]; j != -1; j = edge[j].next) {
        int v = edge[j].v;
        int w = edge[j].w;
        if(w > 0) {
            if(h[v] + 1 == h[pos]) {
                if(lv < edge[j].w) d = lv;
                else d = edge[j].w;
                d = dfs(v, d);
                edge[j].w -= d;
                edge[j ^ 1].w += d;
                lv -= d;
                if(h[src] >= n) return cost - lv;
                if(lv == 0) break;
            }
            if(h[v] < minh) minh = h[v];
        }
    }
    if(lv == cost) {
        --gap[h[pos]];
        if(gap[h[pos]] == 0) h[src] = n;
        h[pos] = minh + 1;
        ++gap[h[pos]];
    }
    return cost - lv;
}
int sap() {
    int ret = 0;
    memset(gap, 0, sizeof(gap));
    memset(h, 0, sizeof(h));
    gap[0] = n;
    while(h[src] < n) ret += dfs(src, INF);
    return ret;
}
int d[MAXN];
typedef pair<int, int> PII;
vector<PII> g[MAXN];
int ans[MAXN];
int cnt, flag;
void dfs(int u) {
    int f = 0;
    ans[cnt++] = u;
    for(int i = 0; i < g[u].size(); i++) {
        if(flag) return;
        int v = g[u][i].first;
        if(!g[u][i].second) continue;
        f = 1;
        --g[u][i].second;
        dfs(v);
    }
    if(!f) d[u]--, flag = 1;
}
int main()
{
    int u, v, t;
    while(scanf("%d", &nt) != EOF) {
        init();
        memset(d, 0, sizeof(d));
        for(int i = 1; i <= nt; i++) {
            scanf("%d", &t);
            while(t--) {
                scanf("%d", &v);
                d[i]--;
                d[v]++;
                add(i, v, INF);
            }
        }
        src = nt + 1;
        des = nt + 2;
        n = nt + 2;
        int res = 0;
        for(int i = 1; i <= nt; i++) {
            if(d[i] > 0) add(src, i, d[i]);
            else if(d[i] < 0) add(i, des, -d[i]), res -= d[i];
        }
        printf("%d\n", res - sap());
        for(int i = 1; i <= nt; i++) g[i].clear();
        for(int i = 1; i <= nt; i++) {
            for(int j = head[i]; j != -1; j = edge[j].next) {
                if((j & 1) || edge[j].v > nt) continue;
                g[i].push_back(make_pair(edge[j].v, edge[j ^ 1].w + 1));
                d[i] -= edge[j ^ 1].w;
                d[edge[j].v] += edge[j ^ 1].w;
            }
        }
        for(int i = 1; i <= nt; i++) {
            while(d[i] < 0) {
                cnt = 0;
                flag = 0;
                d[i]++;
                dfs(i);
                for(int j = 0; j < cnt; j++) {
                    printf("%d", ans[j]);
                    if(j == cnt - 1) printf("\n");
                    else printf(" ");
                }
            }
        }
    }
	return 0;
}


©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值