BZOJ 3876: [Ahoi2014]支线剧情(有源有汇有下界的费用流）

3876: [Ahoi2014]支线剧情

Time Limit: 10 Sec   Memory Limit: 256 MB
Submit: 426   Solved: 257
[ Submit][ Status][ Discuss]

Description

【故事背景】

宅男JYY非常喜欢玩RPG游戏，比如仙剑，轩辕剑等等。不过JYY喜欢的并不是战斗场景，而是类似电视剧一般的充满恩怨情仇的剧情。这些游戏往往

都有很多的支线剧情，现在JYY想花费最少的时间看完所有的支线剧情。

【问题描述】

JYY现在所玩的RPG游戏中，一共有N个剧情点，由1到N编号，第i个剧情点可以根据JYY的不同的选择，而经过不同的支线剧情，前往Ki种不同的新的剧情点。当然如果为0，则说明i号剧情点是游戏的一个结局了。

JYY观看一个支线剧情需要一定的时间。JYY一开始处在1号剧情点，也就是游戏的开始。显然任何一个剧情点都是从1号剧情点可达的。此外，随着游戏的进行，剧情是不可逆的。所以游戏保证从任意剧情点出发，都不能再回到这个剧情点。由于JYY过度使用修改器，导致游戏的“存档”和“读档”功能损坏了，

所以JYY要想回到之前的剧情点，唯一的方法就是退出当前游戏，并开始新的游戏，也就是回到1号剧情点。JYY可以在任何时刻退出游戏并重新开始。不断开始新的游戏重复观看已经看过的剧情是很痛苦，JYY希望花费最少的时间，看完所有不同的支线剧情。

Input

输入一行包含一个正整数N。

接下来N行，第i行为i号剧情点的信息；

第一个整数为，接下来个整数对，Bij和Tij，表示从剧情点i可以前往剧

情点，并且观看这段支线剧情需要花费的时间。

Output

 输出一行包含一个整数，表示JYY看完所有支线剧情所需要的最少时间。

Sample Input

6
2 2 1 3 2
2 4 3 5 4
2 5 5 6 6
0
0
0

Sample Output

24

HINT

 JYY需要重新开始3次游戏，加上一开始的一次游戏，4次游戏的进程是

1->2->4，1->2->5，1->3->5和1->3->6。

对于100%的数据满足N<=300,0<=Ki<=50,1<=Tij<=300,Sigma(Ki)<=5000

解题思路：

先建立超级源点s（0），超级汇点t（n+1） 
t–>s 花费为0，流量为INF 
对于边u–>v
s–>v 花费为c，流量为1（表示下界为1） 
u–>v 花费为c，流量为INF（表示可以走很多次） 
u–>t 花费为0，流量为u的出度（等价于每连一条u–>v的边，增加一条u向t的边流量为u–>v的下界1最后效果累加） 
u–>1（原图的源点） 花费为0，流量为INF（去掉这个源点） 
注意的是循环中如果i=1，不要连1–>1的边，否则有的数据会死循环

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#define LL long long
using namespace std;
int read()
{
    int x = 0, f = 1; char ch = getchar();
    while(ch < '0' || ch > '9') {if(ch == '-') f *= -1; ch = getchar();}
    while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}
const int maxn = 10000 + 10;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int from, to, cap, flow, cost;
    Edge(int u, int v, int c, int f, int w) : from(u), to(v), cap(c), flow(f), cost(w) { }
};
int n;
vector<Edge>edges;
vector<int>G[maxn];
int inq[maxn];
int d[maxn];
int p[maxn];
int a[maxn];
void init()
{
    for(int i=0;i<maxn;i++)
        G[i].clear();
    edges.clear();
}
void AddEdge(int from, int to, int cap, int cost)
{
    edges.push_back(Edge(from,to,cap,0,cost));
    edges.push_back(Edge(to,from,0,0,-cost));
    int M = edges.size();
    G[from].push_back(M-2);
    G[to].push_back(M-1);
}
bool SPFA(int s, int t, int& flow, LL& cost)
{
    for(int i=0;i<=n+1;i++)
        d[i] = INF;
    memset(inq, 0, sizeof(inq));
    d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;
    queue<int>Q;
    Q.push(s);
    while(!Q.empty())
    {
        int u = Q.front();Q.pop();
        inq[u] = 0; int sz = G[u].size();
        for(int i=0;i<sz;i++)
        {
            Edge& e = edges[G[u][i]];
            if(e.cap > e.flow && d[e.to] > d[u] + e.cost)
            {
                d[e.to] = d[u] + e.cost;
                p[e.to] = G[u][i];
                a[e.to] = min(a[u], e.cap - e.flow);
                if(!inq[e.to]){Q.push(e.to);inq[e.to] = 1;}
            }
        }
    }
    if(d[t] == INF) return false;
    flow += a[t];
    cost += (LL) d[t] * (LL) a[t];
    for(int u=t;u!=s;u=edges[p[u]].from)
    {
        edges[p[u]].flow += a[t];
        edges[p[u]^1].flow -= a[t];
    }
    return true;
}
int MincostMaxflow(int s, int t, LL& cost)
{
    int flow = 0; cost = 0;
    while(SPFA(s,t,flow,cost));
    return flow;
}
int N, m, b, t;
int main()
{
    N = read();
    int S = 0, T = N + 1;
    n = N + 2;
    AddEdge(T, S, INF ,0);
    for(int i=1;i<=N;i++)
    {
        m = read();
        AddEdge(i, T, m, 0);
        if(i != 1)AddEdge(i, 1, INF, 0);
        for(int j=1;j<=m;j++)
        {
            b = read(), t = read();
            AddEdge(S, b, 1, t);
            AddEdge(i, b, INF, t);
        }
    }
    long long cost = 0;
    int ans = MincostMaxflow(S, T, cost);
    printf("%lld\n", cost);
    return 0;
}