【网络流】BZOJ 3876 [Ahoi2014]支线剧情

126d2

题目链接：

　　http://www.lydsy.com:808/JudgeOnline/problem.php?id=3876

题目大意：

　　　给定一张拓扑图（有向无环图），每条边有边权，每次只能从第一个点出发沿着拓扑图走一条路径，求遍历所有边所需要的最小边权和。

题目思路：

　　【有源汇上下界费用流】

　　Orz两位神犇，以下思路借鉴自

　　　　http://hzwer.com/6224.html

　　　　http://blog.csdn.net/popoqqq/article/details/43024221

　　建图如下：

　　　　设汇t，源s=1，超级源S，超级汇T。

　　　　本质是每条边的下界为1，上界为MAX，跑一遍有源汇的上下界最小费用最小流。（因为上界无穷大，所以只要满足所有下界的最小费用最小流）

　　　　对每个点x：

　　　　　　从x到t连一条费用为0，流量为MAX的边，表示可以任意停止当前的剧情（接下来的剧情从更优的路径去走，画个样例就知道了）

　　　　对于每一条边权为z的边x->y：

　　　　　　从S到y连一条流量为1，费用为z的边，代表这条边至少要被走一次。

　　　　　　从x到y连一条流量为MAX，费用为z的边，代表这条边除了至少走的一次之外还可以随便走。

　　　　　　从x到T连一条流量为1，费用为0的边。（注意是每一条x->y的边都连，或者你可以记下x的出边数Kx，连一次流量为Kx，费用为0的边）。

　　建完图后从S到T跑一遍费用流，即可。（当前跑出来的就是满足上下界的最小费用最小流了）

//
//by coolxxx
//
#include<iostream>
#include<algorithm>
#include<string>
#include<iomanip>
#include<memory.h>
#include<time.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
#include<math.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define abs(a) ((a)>0?(a):(-(a)))
#define lowbit(a) (a&(-a))
#define sqr(a) (a)*(a)
#define swap(a,b) (a)^=(b),(b)^=(a),(a)^=(b)
#define eps 1e-8
#define MAX 0x7f7f7f7f
#define INF 20000
#define PI 3.1415926535897
#define N 304
#define M 5004
using namespace std;
int n,m,cas,lll,ans;
int last
,d
;
int S,T,s,t,qq[M+M];
bool K;
bool mark
;
struct data
{
int to,from,next,f,c;
}e[M*10];
inline int Read()
{
int x=0,f=1;char ch=getchar();
while(ch>'9' || ch<'0'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
void add(int u,int f,int w,int c)
{
e[++lll].to=f;e[lll].from=u;
e[lll].next=last[u];last[u]=lll;
e[lll].f=w;e[lll].c=c;
}
void link(int u,int v,int w,int c)
{
add(u,v,w,c);
add(v,u,0,-c);
}
void build()
{
int i,j,x,y,z;
memset(last,0,sizeof(last));
lll=1;ans=0;
s=1,t=n+1;
S=n+2,T=n+3;
for(i=1;i<=n;i++)
{
j=Read();
link(i,t,MAX,0);
while(j--)
{
y=Read();z=Read();
link(i,y,MAX,z);
link(S,y,1,z);
link(i,T,1,0);
}
}
link(t,s,MAX,0);
}
bool spfa(int S,int T)
{
int i,now;
memset(mark,0,sizeof(mark));
memset(d,0x7f,sizeof(d));
int head=M-1,tail=M;
qq[M]=T;
d[T]=0;mark[T]=1;
while(head++<tail)
{
now=qq[head];
for(i=last[now];i;i=e[i].next)
{
if(e[i^1].f>0 && d[now]-e[i].c<d[e[i].to])
{
d[e[i].to]=d[now]-e[i].c;
if(!mark[e[i].to])
{
if(d[e[i].to]<d[qq[head]])
qq[head--]=e[i].to;
else
qq[++tail]=e[i].to;
mark[e[i].to]=1;
}
}
}
mark[now]=0;
}
if(d[S]==MAX)return 0;
else return 1;
}
int dfs(int u,int f,int T)
{
int v,i,tt,asp=0;
if(u==T)
{
K=1;
return f;
}
mark[u]=1;
for(i=last[u];i;i=e[i].next)
{
if(!mark[e[i].to] && e[i].f>0 && d[u]-e[i].c==d[e[i].to])
{
tt=dfs(e[i].to,min(e[i].f,f-asp),T);
e[i].f-=tt;
e[i^1].f+=tt;
ans+=tt*e[i].c;
asp+=tt;
if(asp==f)
return f;
}
}
return asp;
}
void mincostflow(int S,int T)
{
while(1)
{
if(!spfa(S,T))break;
K=1;
while(K)
{
K=0;
memset(mark,0,sizeof(mark));
dfs(S,MAX,T);
}
}
}
int main()
{
#ifndef ONLINE_JUDGE
//  freopen("1.txt","r",stdin);
//  freopen("2.txt","w",stdout);
#endif
int i,j;
while(~scanf("%d",&n) && n)
{
build();
mincostflow(S,T);
printf("%d\n",ans);
}
return 0;
}

/*
//

//
*/