【网络流】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*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;
}
 
 
/*
//
 
//
*/