BZOJ 3876 支线剧情（有上下界的无源汇最小费用可行流）

3876: [Ahoi2014]支线剧情

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 1783  Solved: 1079
[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

题目链接：BZOJ 3876

很久以前做过的题目，但是不太理解，这次又拿出来重新做了一次，用了某个大牛博客里介绍的方法，从6s变成148ms，贼可怕。

题意就是给你很多边构成的图，每一条边都有边权，求按拓扑顺序的走完这些边最少需要多少时间，另外你可以从任意一个点回到起点1，然后继续按拓扑顺序走。

其实就是一个有下界的费用流，原图中每一条边的下界为1，上界为INF，那么我们可以用博客里的方法，一条边$<u,v,c,ti>$表示从u到v的流量为c，单位费用为ti，然后在新图中改成$<u,v,L,ti>$其中L为该边的下界即1，然后由于你每一个点都可以无限次立即回到原点1，那么对于每一个点肯定要有$<i,1,INF,0>$，然后就是添加与超级源点与超级汇点有关的某一条补边$<S,i,D[i],0>$或$<u,T,-D[i],0>$，其中$D[i]=\Sigma{流入i的下界流量-流出i的下界流量}$，如果大于零则说明这个流出不足，需要从源点S补一些；如果小于零则说明流入量太多了，需要释放一些到汇点T中去，然后答案就是新图的S-T费用+原图每一条边的下界流量*对应的单位费用。当然由于这种建模的方式，这样算出来的是可行流下的最大/最小费用，而不是最大流条件下的费用流，因为这样的建模就是用于求可行流的，此题也没有要求最大流，只要保证满足边的下界流量1即可

代码：

#include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define LC(x) (x<<1)
#define RC(x) ((x<<1)+1)
#define MID(x,y) ((x+y)>>1)
#define CLR(arr,val) memset(arr,val,sizeof(arr))
#define FAST_IO ios::sync_with_stdio(false);cin.tie(0);
typedef pair<int, int> pii;
typedef long long LL;
const double PI = acos(-1.0);
const int N = 310;
struct edge
{
	int to, nxt, cap, cost;
	edge() {}
	edge(int _to, int _nxt, int _cap, int _cost): to(_to), nxt(_nxt), cap(_cap), cost(_cost) {}
};
edge E[(5010 + 3 * N) << 1];
int head[N], tot;
int d[N], pre[N], path[N], D[N];
bool vis[N];
int mc, mf;

inline void add(int s, int t, int cap, int cost)
{
	E[tot] = edge(t, head[s], cap, cost);
	head[s] = tot++;
	E[tot] = edge(s, head[t], 0, -cost);
	head[t] = tot++;
}
void init()
{
	CLR(head, -1);
	tot = 0;
	mc = 0;
	mf = 0;
}
int spfa(int s, int t)
{
	CLR(d, INF);
	CLR(vis, false);
	queue<int>Q;
	d[s] = 0;
	vis[s] = 1;
	Q.push(s);
	while (!Q.empty())
	{
		int u = Q.front();
		Q.pop();
		vis[u] = 0;
		for (int i = head[u]; ~i; i = E[i].nxt)
		{
			int v = E[i].to;
			if (d[v] > d[u] + E[i].cost && E[i].cap > 0)
			{
				d[v] = d[u] + E[i].cost;
				pre[v] = u;
				path[v] = i;
				if (!vis[v])
				{
					vis[v] = 1;
					Q.push(v);
				}
			}
		}
	}
	return d[t] != INF;
}
void MCMF(int s, int t)
{
	while (spfa(s, t))
	{
		int Min = INF;
		for (int i = t; i != s && ~i; i = pre[i])
		{
			if (E[path[i]].cap < Min)
				Min = E[path[i]].cap;
		}
		for (int i = t; i != s && ~i; i = pre[i])
		{
			E[path[i]].cap -= Min;
			E[path[i] ^ 1].cap += Min;
		}
		mf += Min;
		mc += Min * d[t];
	}
}
int main(void)
{
	int n, u, v, ti, i;
	while (~scanf("%d", &n))
	{
		init();
		int S = 0, T = n + 1;
		int sum = 0;
		int R = INF, L = 1;
		for (u = 1; u <= n; ++u)
		{
			int k;
			scanf("%d", &k);
			for (i = 0; i < k; ++i)
			{
				scanf("%d%d", &v, &ti);
				D[u]--;
				D[v]++;
				add(u, v, R - L, ti);
				sum += L * ti;
			}
			if (u != 1)
				add(u, 1, INF, 0);
		}
		for (i = 1; i <= n; ++i)
		{
			if (D[i] > 0)
				add(S, i, D[i], 0);
			else if (D[i] < 0)
				add(i, T, -D[i], 0);
		}
		MCMF(S, T);
		printf("%d\n", mc + sum);
	}
	return 0;
}