【有源汇上下界费用流】BZOJ 3876 [Ahoi2014]支线剧情

题目链接：

　　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的出边数K_x，连一次流量为K_x，费用为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[N],d[N];
 int S,T,s,t,qq[M+M];
 bool K;
 bool mark[N];
 struct data
 {
     int to,from,next,f,c;
 }e[M*];
 inline int Read()
 {
     int x=,f=;char ch=getchar();
     while(ch>'' || ch<''){if(ch=='-')f=-;ch=getchar();}
     while(ch>='' && ch<=''){x=x*+ch-'';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,,-c);
 }
 void build()
 {
     int i,j,x,y,z;
     memset(last,,sizeof(last));
     lll=;ans=;
     s=,t=n+;
     S=n+,T=n+;
     for(i=;i<=n;i++)
     {
         j=Read();
         link(i,t,MAX,);
         while(j--)
         {
             y=Read();z=Read();
             link(i,y,MAX,z);
             link(S,y,,z);
             link(i,T,,);
         }
     }
     link(t,s,MAX,);
 }
 bool spfa(int S,int T)
 {
     int i,now;
     memset(mark,,sizeof(mark));
     memset(d,0x7f,sizeof(d));
     int head=M-,tail=M;
     qq[M]=T;
     d[T]=;mark[T]=;
     while(head++<tail)
     {
         now=qq[head];
         for(i=last[now];i;i=e[i].next)
         {
             if(e[i^].f> && 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]=;
                 }
             }
         }
         mark[now]=;
     }
     if(d[S]==MAX)return ;
     else return ;
 }
 int dfs(int u,int f,int T)
 {
     int v,i,tt,asp=;
     if(u==T)
     {
         K=;
         return f;
     }
     mark[u]=;
     for(i=last[u];i;i=e[i].next)
     {
         if(!mark[e[i].to] && e[i].f> && 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^].f+=tt;
             ans+=tt*e[i].c;
             asp+=tt;
             if(asp==f)
                 return f;
         }
     }
     return asp;
 }
 void mincostflow(int S,int T)
 {
     while()
     {
         if(!spfa(S,T))break;
         K=;
         while(K)
         {
             K=;
             memset(mark,,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 ;
 }

 /*
 //

 //
 */