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;
}