ACdream 1229 Data Transmission

Data Transmission

Special JudgeTime Limit: 12000/6000MS (Java/Others)Memory Limit: 128000/64000KB (Java/Others)

Problem Description

Recently one known microprocessor productioner has developed the new type of microprocessors that can be used in difficult mathematical calculations. The processor contains N so called nodes that are connected by M channels. Data organized in packets, pass from source node to target node by channels and are processed by the intermediate nodes.

Each node has its level that determines the type of work this node does. The source node has level 1 while the target node has level L. For data to be correctly processed each packet of it must pass in order all nodes with levels from 1 to L - that is, first it must be processed by the source node, after that by some node of level 2, so on, and finally by the target node.

Nodes can process as much data as they are asked to, however channels can only transmit the limited amount of data in a unit of time. For synchronization reasons, any data can only be transmitted from a node with level i to some node with level i + 1 and cannot be transmitted between nodes which levels differ by more than one or from a node of higher level to a node of lower level. Nodes are so fast that they can process data packet immediately, so as soon as it reaches the node it is ready to be transmitted to the node of the next level.

No data should stall in any node and no node can produce its own data, so each unit of time the number of packets coming to any node except source and target, must be equal to the number of packets leaving this node.

The scheme of data transmission that satisfies the conditions provided is called the data flow. Data flow is called blocking if there is no way to increase the value of the data flow just increasing the amount of data passing by some channels (however, there may be the way to increase it, decreasing the amount of data for some channels and increasing for other ones).

Input

The first line of the input file contains three integer numbers - N, M and L (2 <= N <= 1 500, 1 <= M <= 300 000, 2 <= L <= N). Let nodes be numbered from 1 to N. The second line contains N integer numbers, i-th of them is the level li of the i-th node (1 <= li <= L). Only one node has level 1, that is the source node, and only one node has level L - that is the target node.

Next M lines describe channels, each lines contains three integer numbers a, b and c - nodes connected by this channel and its capacity in packets per unit of time (1 <= a, b <= N, lb = la+1, 1 <= c <= 106).

Two nodes can be connected by at most one channel.

Output

Output the description of the data flow found. Output file must contain M lines, they must correspond to channels and contain the amount of data transmitted by the channel in a unit of time. Channels must be listed in the order they are specified in the input file.

Sample Input

6 7 4

1 2 3 4 3 2

1 2 3

2 3 3

3 4 4

1 6 4

6 3 2

5 4 3

6 5 4

Sample Output

Source

Andrew Stankevich Contest 3

Manager

mathlover

解题：dinic算法+贪心初始流。。。太BT的一道题目。。。

 #include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <algorithm>

 #include <climits>

 #include <vector>

 #include <queue>

 #include <cstdlib>

 #include <string>

 #include <set>

 #include <stack>

 #define LL long long

 #define pii pair<int,int>

 #define INF 0x3f3f3f3f

 using namespace std;

 const int maxn = ;

 struct arc{

     int to,flow,next;

     arc(int x = ,int y = ,int z = -){

         to = x;

         flow = y;

         next = z;

     }

 };

 arc e[];

 int head[maxn],d[maxn],lev[maxn],_rank[maxn],in[maxn],out[maxn];

 int n,m,L,S,T,hd,tl,tot,cur[maxn],q[maxn];

 void myscanf(int &x){

     char ch;

     while((ch = getchar()) > '' || ch < '');

     x = ;

     x = x* + ch - '';

     while((ch = getchar()) >= '' && ch <= '')

         x = x* + ch - '';

 }

 void add(int u,int v,int flow){

     e[tot] = arc(v,flow,head[u]);

     head[u] = tot++;

     e[tot] = arc(u,,head[v]);

     head[v] = tot++;

 }

 bool cmp(const int &x,const int &y){

     return lev[x] < lev[y];

 }

 void greedy(){

     memset(in,,sizeof(in));

     memset(out,,sizeof(out));

     sort(_rank+,_rank+n+,cmp);

     in[S] = INF;

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

         int u = _rank[i];

         for(int j = head[u]; ~j; j = e[j].next){

             if(!(j&) && in[u] > out[u]){

                 int f = min(e[j].flow,in[u] - out[u]);

                 in[e[j].to] += f;

                 out[u] += f;

             }

         }

     }

     memset(in,,sizeof(in));

     in[T] = INF;

     for(int i = n; i >= ; --i){

         int v = _rank[i];

         for(int j = head[v]; ~j; j = e[j].next){

             int u = e[j].to;

             if(j& && out[u] > in[u]){

                 int f = min(e[j^].flow,min(out[u] - in[u],in[v]));

                 in[v] -= f;

                 in[u] += f;

                 e[j].flow += f;

                 e[j^].flow -= f;

             }

         }

     }

 }

 bool bfs(){

     memset(d,-,sizeof(d));

     hd = tl = ;

     q[tl++] = S;

     d[S] = ;

     while(hd < tl){

         int u = q[hd++];

         for(int i = head[u]; ~i; i = e[i].next){

             if(e[i].flow && d[e[i].to] == -){

                 d[e[i].to] = d[u] + ;

                 q[tl++] = e[i].to;

             }

         }

     }

     return d[T] > -;

 }

 int dfs(int u,int low){

     if(u == T) return low;

     int tmp = ,a;

     for(int &i = cur[u]; ~i; i = e[i].next){

         if(e[i].flow && d[e[i].to] == d[u] +  && (a=dfs(e[i].to,min(low,e[i].flow)))){

             tmp += a;

             low -= a;

             e[i].flow -= a;

             e[i^].flow += a;

             if(!low) break;

         }

     }

     if(!tmp) d[u] = -;

     return tmp;

 }

 int dinic(){

     int tmp = ;

     while(bfs()){

         memcpy(cur,head,sizeof(head));

         tmp += dfs(S,INF);

     }

     return tmp;

 }

 int main() {

     int i,u,v,cap;

     scanf("%d %d %d",&n,&m,&L);

     memset(head,-,sizeof(head));

     for(i = ; i <= n; i++){

         myscanf(lev[i]);

         _rank[i] = i;

         if(lev[i] == ) S = i;

         else if(lev[i] == L) T = i;

     }

     for(int i = tot = ; i < m; i++){

         myscanf(u);

         myscanf(v);

         myscanf(cap);

         add(u,v,cap);

     }

     greedy();

     dinic();

     for(int i = ; i < m; i++)

         printf("%d\n",e[i<<|].flow);

     return ;

 }