UVa11506 - Angry Programmer(ISAP)

You, a programmer of an important software house, have been fired because you didn't solve an important problem that was assigned to you. You are very furious and want to take revenge on your boss, breaking the communication between his computer and the central server.

The computer of your boss and the central server are in the same network, which is composed of many machines (computers) and wires linking pairs of those machines. There is at most one wire between any pair of machines and there can be pairs of machines without a wire between them.

To accomplish your objective, you can destroy machines and wires, but you can't destroy neither the computer of your boss nor the central server, because those machines are monitored by security cameras. You have estimated the cost of blowing up each machine and the cost of cutting each wire in the network.

You want to determine the minimum cost of interrupting the communication between your boss' computer and the central server. Two computers A and B can communicate if there is a sequence of undestroyed machines x₁,...,x_n such that x₁ = A , x_n = B and x_i is linked with x_i+1 with an uncut wire (for each 1  i  n - 1 ).

Input 

The input consists of several test cases. Each test case is represented as follows:

• A line with two integers M and W ( 2  M  50 , 0  W  1000 ), representing (respectively) the number of machines and the number of wires in the network.
• M - 2 lines, one per machine (different from the boss' machine and the central server), containing the following information separated by spaces:
  • An integer i ( 2  i  M - 1 ) with the identifier of the machine. Assume that the boss' machine has id 1 and that the central server has id M .
  • An integer c ( 0  c  100000 ) specifying the cost of destroying the machine.
• W lines, one per wire, containing the following information separated by spaces:
  • Two integers j and k ( 1  j < k  M ) specifying the identifiers of the machines linked by the wire. Remember that the wire is bidirectional.
  • An integer d ( 0  d  100000 ) specifying the cost of cutting the wire.

The end of the input is specified by a line with the string ``0 0''.

Suppose that the machines have distinct identifiers.

Output 

For each test case, print a line with the minimum cost of interrupting the communication between the computer of your boss and the central server.

Sample Input 

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

Sample Output 

4
3

#include <cstdio>  
#include <queue>  
#include <cstring>  
#include <algorithm>  
  
using namespace std;  
  
const int N = 110;  
const int INF = 0x3f3f3f3f;  
   
int m, w;   
int d[N], num[N];  
int cur[N], p[N];
int cap[N][N], flow[N][N];
  
bool input();  
void rev_bfs();
int max_flow();
int Augment();
int Retreat(int &i);

int main()  
{  
    #ifndef ONLINE_JUDGE  
        freopen("d:\\OJ\\uva_in.txt", "r", stdin);  
    #endif  
      
    while (input()) {  
		 int ans = max_flow();
        printf("%d\n", ans);  
    }  
    return 0;  
}  
  
bool input()  
{  
    if (scanf("%d%d", &m, &w) != 2 || (m == 0 && w == 0)) return false;  
      
    int u, v, c;  
	
	memset(cap, 0x00, sizeof(cap));
	memset(flow, 0x00, sizeof(flow));
    for (int i = 0; i < m - 2; i++) {  
        scanf("%d%d", &u, &c);  
		 cap[u][u + m] = cap[u + m][u] = c;
    }  
      
    for (int i = 0; i < w; i++) {  
        scanf("%d%d%d", &u, &v, &c);  
		if (u == 1 && v == m) {
			  cap[u][v] = cap[v][u] = c;
        } else if (u == 1 && v != m) {  
			  cap[u][v] = c;
			  cap[v + m][u] = c;
        } else if (u == m && v == 1) {  
			  cap[u][v] = cap[v][u] = c;
        } else if (u == m && v != 1) {   
			cap[u][v] = c;
			cap[v + m][u] = c;
        } else {  
			cap[u + m][v] = c;
			cap[v + m][u] = c;
        }  
    }  
    return true;  
}  

void rev_bfs()
{
	queue<int> q;
	
	memset(num, 0x00, sizeof(num));
	for (int i = 1; i <= 2 * m; i++) {
		num[d[i] = 2 * m]++;
	}
	
	num[2 * m]--;
	d[m] = 0;
	num[0]++;
	q.push(m);
	
	while (!q.empty()) {
		int v = q.front(); q.pop();
		for (int u = 1; u < 2 * m; u++) {
			if (d[u] < 2 * m || cap[u][v] == 0) continue;
			
			q.push(u);
			num[d[u]]--;
			d[u] = d[v] + 1;
			num[d[u]]++;
		}
	}
}

int max_flow()
{
	int f = 0, i, j;
	
	memset(d, 0x00, sizeof(d));
	memset(p, 0x00, sizeof(p));
	rev_bfs();
	
	for (i = 1; i <= 2 * m; i++) cur[i] = 1;
	i = 1;
	
	for (; d[1] < 2 * m; )
	{
		for (j = cur[i]; j <= 2 * m; j++) {
			if (cap[i][j] > flow[i][j] && d[i] == d[j] + 1) break;
		}
	
		if (j <= 2 * m) {
			cur[i] = j;
			p[j] = i;
			i = j;
	
			if (i == m) {
				f += Augment();
				i = 1;
			}
		} else {
			cur[i] = 1;
			if (Retreat(i) == 0) break;
		}
	}
	return f;
}

int Augment()
{
	int ans = INF;
	for (int i = m, j = p[i]; i != 1; i = j, j = p[j]) {
		ans = min(ans, cap[j][i] - flow[j][i]);
	}
	
	for (int i = m,  j = p[i]; i != 1; i = j, j = p[j]) {
		flow[j][i] += ans;
		flow[i][j] -= ans;
	}
	
	return ans;
}

int Retreat(int &i)
{
	int mind = 2 * m - 1;
	
	for (int j = 1; j <= 2 * m; j++) {
		if (cap[i][j] > flow[i][j] && d[j] < mind) {
			mind = d[j];
		}
	}
	
	int tmp = d[i];
	num[d[i]]--;
	d[i] = mind + 1;
	num[d[i]]++;
	
	if (i != 1) i = p[i];
	
	return num[tmp];
}