BZOJ3876 AHOI2014 支线剧情 费用流

题意：给定一张有向图，求一个路径集合，集合中的路径满足：1、起点为1，终点出度为0  2、集合中的路径覆盖了所有的点  3、在满足前两个条件的基础上，路径权值和最小

题解：

显然是个带下界的有源费用流。按照如下方式建模，对于一条边权为w的边(u,v)和任意一个点x

x向T连容量为k费用为0的边，表示其后每条路经都必须跑一次。

x向1连容量为INF费用为0的边，表示从任意一个点都可以回到1

S向v连容量为1费用为w的边，表示一个点必须经过一次。

u向v连容量为INF费用为w的边，表示一个点可以经过多次。

然后跑S到T的费用流即可。

#include <queue>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <climits>
#include <iostream>
#include <algorithm>
using namespace std;
#define U 2139062143

const int MAXN=60000+2;
const int MAXM=800000+2;
struct HASH{
    int u;
    HASH *next;
    HASH(){}
    HASH(int _u,HASH *_next):u(_u),next(_next){}
}*table[MAXN],mem[MAXM];
struct EDGE{
    int u,v,c,w;
    EDGE(){}
    EDGE(int _u,int _v,int _c,int _w):u(_u),v(_v),c(_c),w(_w){}
}e[MAXM];
int N,M,cnt=2,d[MAXN],cur[MAXN],ans;
bool flag[MAXN];
queue<int> q;

void Insert(int u,int v,int c,int w){
    table[u]=&(mem[cnt]=HASH(cnt,table[u])),e[cnt++]=EDGE(u,v,c,w);
    table[v]=&(mem[cnt]=HASH(cnt,table[v])),e[cnt++]=EDGE(v,u,0,-w);
}

bool SPFA(int s,int t){
    memset(d,0X7F,sizeof(d));
    d[s]=0,flag[s]=1,q.push(s);

    int x;
    while(!q.empty()){
        x=q.front(),q.pop();
        for(HASH *p=table[x];p;p=p->next)
            if(e[p->u].c && d[e[p->u].v]>d[x]+e[p->u].w){
                d[e[p->u].v]=d[x]+e[p->u].w,cur[e[p->u].v]=p->u;
                if(!flag[e[p->u].v]) flag[e[p->u].v]=1,q.push(e[p->u].v);
            }
        flag[x]=0;
    }
    return d[t]<U;
}

void Find(int s,int t){
    int c=INT_MAX;
    for(int i=cur[t];i;i=cur[e[i].u]) c=min(c,e[i].c);
    for(int i=cur[t];i;i=cur[e[i].u]){
        e[i].c-=c,e[i^1].c+=c;
        ans+=e[i].w*c;
    }
}

int main(){ 
    scanf("%d",&N);
    for(int i=1,k,u,w;i<=N;i++){
        scanf("%d",&k);
        Insert(i,N+1,k,0);
        if(i!=1) Insert(i,1,INT_MAX,0);
        for(int j=1;j<=k;j++){
            scanf("%d %d",&u,&w);
            Insert(0,u,1,w),Insert(i,u,INT_MAX,w);
        }
    }

    while(SPFA(0,N+1)) Find(0,N+1);
    cout << ans << endl;

    return 0;
}