费用流-Wannafly Day2 TwoGraph-神题

TwoGraph

题意

题解

这真是一道神题,这题有两点比较难想,其中第一点是最难想的.
我们先考虑只有一张图的情况.
性质:
[1]如果给每个点匹配一条边,形成一个$(点,边)$对,其中点不能重复出现,边也不能重复出现.那么这些对形成的图的联通块要么是树,要么是环套树.
证明性质[1]:
每个含有$n$条边的联通块中至多有$n+1$个点(如果再多就不连通了!),至少有$n$个点(因为$n$条边对应$n$个不同的点).
那么形成的要么是树,要么是环套树.

因此,我们需要做一张图,满足可以给点匹配其相连的边的网络,如下图.
当给出数据是一颗树时,$cost[(1,2)]=c1,cost[(2,3)]=c2$.
费用流建图如下.

至此,只有一张图的情况我们就搞完了,那么两张图,选边之间有依赖关系怎么办呢?好办!

我们实际上只需要对两张图各自建图,然后把其中一张图倒过来,源点改成汇点,然后对应边拼起来(就像两个漏斗一样).

这样每条边如果被选了,那么一定会经过图1的点,也会经过图2的点.

示例如下:

采坑提示

最小费用最大流:spfa找最短路
最大费用最大流:spfa找最长路

代码

#include<bits/stdc++.h>
using namespace std;

#define rep(i,a,b) for(int i = a;i <= b;++i)
#define int long long
const int inf = 0x3f3f3f3f3f3f3f3f;
const int mm = 200010;
const int maxn = 10010;
int node,src,dest,edge;
int ver[mm],flow[mm],cst[mm],nxt[mm];
int head[maxn],work[maxn],dis[maxn],q[maxn];
int tot_cost;
void prepare(int _node,int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=0; i<node; ++i)head[i]=-1;
    edge=0;
    tot_cost = 0;
}
void add_edge(int u,int v,int c,int cost)
{
    ver[edge]=v,flow[edge]=c,nxt[edge]=head[u],cst[edge]=cost,head[u]=edge++;
    ver[edge]=u,flow[edge]=0,nxt[edge]=head[v],cst[edge]=-cost,head[v]=edge++;
}
int ins[maxn];
int pre[maxn];
bool Dinic_spfa()
{
    memset(ins,0,sizeof(ins));
    //memset(dis,-1,sizeof(dis));
    rep(i,0,maxn-1) {
        dis[i] = -inf;
    }
    memset(pre,-1,sizeof(pre));
    queue<int> Q;
    //int i,u,v,l,r=0;
    Q.push(src);
    dis[src] = 0,ins[src] = 1;
    pre[src] = -1;
    while(!Q.empty()){
        int u = Q.front();Q.pop();
        ins[u] = 0;
        for(int e = head[u];e != -1;e = nxt[e]){
            int v = ver[e];
            if(!flow[e]) continue;
            if(dis[v] < dis[u] + cst[e]){
                dis[v] = dis[u] + cst[e];
                pre[v] = e;
                if(!ins[v]) ins[v] = 1,Q.push(v);
            }
        }    	
    }
    return dis[dest] > 0;
}
int Dinic_flow()
{
    int i,ret=0,delta=inf;
    while(Dinic_spfa())
    {
        for(int i=pre[dest];i != -1;i = pre[ver[i^1]])
    		delta = min(delta,flow[i]);
		for(int i=pre[dest];i != -1;i = pre[ver[i^1]])
    		flow[i] -= delta,flow[i^1] += delta;
		ret+=delta;
		tot_cost += dis[dest]*delta;
    }
    return ret;
}
int n1,n2,m;
signed main() {
    ios::sync_with_stdio(false);
    cin >> n1 >> n2 >> m;
    prepare(2+n1+n2+2*m,0,n1+n2+2*m+1);
    
    rep(i,1,n1) {
        add_edge(0,i,1,0);
    }
    rep(i,1,n2) {
        add_edge(n1+i,n1+n2+2*m+1,1,0);
    }
    rep(i,1,m) {
        int a,b,c,d,cost;
        cin >> a >> b >> c >> d >> cost;
        add_edge(n1+n2+i,n1+n2+m+i,1,cost);
        add_edge(a,n1+n2+i,1,0);
        add_edge(b,n1+n2+i,1,0);
        add_edge(n1+n2+m+i,n1+c,1,0);
        add_edge(n1+n2+m+i,n1+d,1,0);
    }
    Dinic_flow();
    cout << tot_cost << endl;
}