模拟（堆）：USACO Jan11 瓶颈

题目描述

Farmer John is gathering the cows. His farm contains a network of N (1 <= N <= 100,000) fields conveniently numbered 1..N and connected by N-1 unidirectional paths that eventually lead to field 1. The fields and paths form a tree.

Each field i > 1 has a single one-way, exiting path to field P_i, and currently contains C_i cows (1 <= C_i <= 1,000,000,000). In each time unit, no more than M_i (0 <= M_i <= 1,000,000,000) cows can travel from field i to field P_i (1 <= P_i <= N) (i.e., only M_i cows can traverse the path).

Farmer John wants all the cows to congregate in field 1 (which has no limit on the number of cows it may have). Rules are as follows:

Time is considered in discrete units.
Any given cow might traverse multiple paths in the same time unit. However, no more than M_i total cows can leave field i (i.e., traverse its exit path) in the same time unit.
Cows never move *away* from field #1.

In other words, every time step, each cow has the choice either to

a) stay in its current field

b) move through one or more fields toward field #1, as long as the bottleneck constraints for each path are not violated

Farmer John wants to know how many cows can arrive in field 1 by certain times. In particular, he has a list of K (1 <= K <= 10,000) times T_i (1 <= T_i <= 1,000,000,000), and he wants to know, for each T_i in the list, the maximum number of cows that can arrive at field 1 by T_i if scheduled to optimize this quantity.

Consider an example where the tree is a straight line, and the T_i list contains only T_1=5, and cows are distibuted as shown:

Locn:      1---2---3---4      <-- Pasture ID numbers

C_i:       0   1   12  12     <-- Current number of cows

M_i:           5   8   3      <-- Limits on path traversal; field 1 has no limit since it has no exit

The solution is as follows; the goal is to move cows to field 1:

Tree: 1---2---3---4

t=0        0   1   12  12     <-- Initial state

t=1        5   4   7   9      <-- field 1 has cows from field 2 and 3 t=2        10  7   2   6

t=3        15  7   0   3

t=4        20  5   0   0

t=5        25  0   0   0

Thus, the answer is 25: all 25 cows can arrive at field 1 by time t=5.

Farmer John有一张N个农场构成的网络(1 <= N <= 100,000) ，我们将农场标记为1N。 农场被N-1条单向道路连接，保证从任何一个农场可以到达1号农场。FJ想让奶牛到1号农场集中 （P.S. 至于要做什么我也不知道）。 对于每个农场i > 1都有一条单独的单向道路通往P_i，并且这个农场里有C_i只奶牛 （1 <= C_i <= 1,000,000,000）。

在每个单位时间里，这条道路允许不超过M_i (0 <= M_i <= 1,000,000,000)只奶牛从农场i走到农场P_i (1 <= P_i <= N)。 Farmer John 想让所有的奶牛都集中在1号农场（农场容纳奶牛的数量是没有限制的）。下面是奶牛集中到1号农场过程的规则：

我们认为时间是离散的 * 任何奶牛都可以在一个单位时间里走过任意多条道路。但是，必须满足每条道路的上限M_i。
奶牛从来不会离开1号农场。换句话说，每一个单位时间，每只奶牛可以选择下面行动之一：

a) 留在当前的农场

b) 经过一条或者多条道路，向1号农场移动。

同样，需要满足每条道路的上限M_i。

FJ想知道有多少奶牛可以在某个特定的时刻到达1号农场。

特别的，他有一张列着K (1 <= K <= 10,000) 个时间T_i (1 <= T_i <= 1,000,000,000)的单子，他想知道对于每个T_i，如果采用最优的策略在这个时刻结束时最多能有多少奶牛到达1号农场。

输入输出格式

输入格式：

Line 1: Two space-separated integers: N and K
Lines 2..N: Line i (not i+1) describes field i with three

space-separated integers: P_i, C_i, and M_i

Lines N+1..N+K: Line N+i contains a single integer: T_i

输出格式：

Lines 1..K: Line i contains a single integer that is the maximum number of cows that can arrive at field 1 by time T_i.

输入输出样例

输入样例#1：

输出样例#1：

 1 #include <algorithm>

 2 #include <iostream>

 3 #include <cstring>

 4 #include <cstdio>

 5 #include <queue>

 6 typedef long long LL;

 7 using namespace std;

 8 const int N=100010;

 9 struct Query{LL t,res;int id;}ask[N];

10 bool cmp1(Query x,Query y){return x.t<y.t;}

11 bool cmp2(Query x,Query y){return x.id<y.id;}

12 struct Node{

13   LL t;int x;Node(LL t_=0,int x_=0){t=t_;x=x_;}

14   friend bool operator<(Node a,Node b){return a.t>b.t;}

15 };

16 priority_queue<Node>q;

17 int fa[N],anc[N],lim[N];

18 LL cow[N],pass[N];

19 int Find(int x){

20   if(anc[x]==x)return x;

21   return anc[x]=Find(anc[x]);

22 }

23 int n,Q;

24 int main(){

25   freopen("bottleneck.in","r",stdin);

26   freopen("bottleneck.out","w",stdout);

27   scanf("%d%d",&n,&Q);

28   for(int i=1;i<=n;i++)

29     anc[i]=i;

30   for(int i=2;i<=n;i++){

31     scanf("%d",&fa[i]);

32     scanf("%lld",&cow[i]);

33     scanf("%lld",&lim[i]);

34     pass[fa[i]]-=lim[i];

35     pass[i]+=lim[i];

36   }

37   for(int i=1;i<=Q;i++){

38     scanf("%lld",&ask[i].t);

39     ask[i].id=i;

40   }sort(ask+1,ask+Q+1,cmp1);

41

42   for(int i=2;i<=n;i++)

43     if(pass[i]>0){

44       LL t=cow[i]/pass[i];

45       q.push(Node(t,i));

46     }

47

48   int p=1,x,tp;

49   while(!q.empty()&&p<=Q){

50     while(p<=Q&&ask[p].t<=q.top().t)

51       ask[p].res=cow[1]-pass[1]*ask[p].t,p++;

52     if(anc[q.top().x]!=q.top().x){q.pop();continue;}

53     x=q.top().x;tp=Find(fa[x]);cow[tp]+=cow[x];

54     pass[tp]+=pass[x];anc[x]=tp;

55     if(pass[tp]>0){

56       LL t=cow[tp]/pass[tp];

57       q.push(Node(t,tp));

58     }

59     q.pop();

60   }sort(ask+1,ask+Q+1,cmp2);

61   for(int i=1;i<=Q;i++)

62     printf("%lld\n",ask[i].res);

63   return 0;

64 }