SGU 206. Roads

206. Roads

time limit per test: 0.5 sec.
memory limit per test: 65536 KB
input: standard
output: standard

The kingdom of Farland has N cities connected by M roads. Some roads are paved with stones, others are just country roads. Since paving the road is quite expensive, the roads to be paved were chosen in such a way that for any two cities there is exactly one way to get from one city to another passing only the stoned roads.

The kingdom has a very strong bureaucracy so each road has its own ordinal number ranging from 1 to M: the stoned roads have numbers from 1 to N-1 and other roads have numbers from N to M. Each road requires some money for support, i-th road requires ci coins per year to keep it intact. Recently the king has decided to save some money and keep financing only some roads. Since he wants his people to be able to get from any city to any other, he decided to keep supporting some roads in such a way, that there is still a path between any two cities.

It might seem to you that keeping the stoned roads would be the good idea, however the king did not think so. Since he did not like to travel, he did not know the difference between traveling by a stoned road and travelling by a muddy road. Thus he ordered you to bring him the costs of maintaining the roads so that he could order his wizard to choose the roads to keep in such a way that the total cost of maintaining them would be minimal.

Being the minister of communications of Farland, you want to help your people to keep the stoned roads. To do this you want to fake the costs of maintaining the roads in your report to the king. That is, you want to provide for each road the fake cost of its maintaining di in such a way, that stoned roads form the set of roads the king would keep. However, to lower the chance of being caught, you want the value of sum(i = 1..M, |ci-di|) to be as small as possible.

You know that the king's wizard is not a complete fool, so if there is the way to choose the minimal set of roads to be the set of the stoned roads, he would do it, so ties are allowed.

Input

The first line of the input file contains N and M (2 ≤ N ≤ 60, N-1 ≤ M ≤ 400). Next M lines contain three integer numbers ai, bi and ci each — the numbers of the cities the road connects (1 ≤ ai ≤ N, 1 ≤ bi ≤ N, ai ≠ bi) and the cost of maintaining it (1 ≤ ci ≤ 10 000).

Output

Output M lines — for each road output di that should be reported to be its maintainance cost so that he king would choose first N-1 roads to be the roads to keep and the specified sum is minimal possible.

Sample test(s)

Input

4 5
4 1 7
2 1 5
3 4 4
4 2 5
1 3 1

Output

4
5
4
5
4

---

题意

给你m条带权边，保证前n-1条边成为一颗树，要求改变边的权值，使得最小生成树为前n-1条边，求最小改变量方案。

---

很棒的一道非常经典的匹配模型的题！早在1999年，网络流大牛Ahuja（《Network Flows: Theory, Algorithms and Applications》的作者）就对此进行了研究，并提出了\(O(n^2\log n)\)的优秀算法（但是由于没有使用Tex导致排版很DT。。不过好在不影响阅读）。链接在此。

该问题被称为 Inverse Spanning Tree Problem

摘录ABSTRACT如下：

In this paper, we consider the inverse spanning tree problem. Given an undirected graph G0 = (N0, A0)with n nodes, m arcs, an arc cost vector c, and a spanning tree T0, the inverse spanning tree problem is toperturb the arc cost vector c to a vector d so that T0 is a minimum spanning tree with respect to the costvector d and the cost of perturbation given by |d – c| = |d c |ij ij (i, j) A − is minimum. We show that the dual of the inverse spanning tree problem is a bipartite node weighted matching problem on a specially structured graph (which we call the path graph) that contains m nodes and as many as (m-n+1)(n-1) = O(nm) arcs. We first transform the bipartite node weighted matching problem into a specially structured minimum cost flow problem and use its special structure to develop an O(n3) algorithm. We next use its special structure more effectively and develop an O(n2 log n) time algorithm. This improves the previous O(n3) time algorithm due to Sokkalingam, Ahuja and Orlin [1999].

作者对该问题建立网络流模型，得到\(O(n^3)\)的解决方案，然后又通过use its special structure more effectively得到\(O(n^2\log n)\)的计算方式，而非动态树优化。。。Tarjan逆天。。常数大到爆。原话：

The algorithm given in Figure 1 can also be implemented in \(O(n^2 \log n)\) time using the dynamic tree data structure due to Sleator and Tarjan [1983]. However,the dynamic tree data structure has large computational overhead and is difficult to implement. In the next section, we describe another \(O(n^2 \log n)\) algorithm that is simpler and is easier to implement. In fact, our improved implementation of the node weighted matching algorithm is the same as the one described above, except that it is carried out on a transformed network.

如下为\(O(n^3)\)的做法，使用加slack优化的KM算法。

首先注意到：如果最开始的边是最小生成树上的边，那么就要求在后面的边在加入到树后形成的环内为环上最大权边，否则就可以把要求的边更新掉。不妨设Akane[i]为边i的边权值，Ranma[i]为边i需要改变的值，那么对于加入的第n~m条内的边k，要求对环内每条Akane值大于加入边值的边j都有：Akane[k] <= Akane[j]，Akane[j]-Ranma[j]<= Akane[k]+Ranma[k]，移项得：Akane[j]-Akane[k]<=Ranma[j] +Ranma[k]，左边为常量，右边是我们要均衡分配的权值，而这正是KM匹配算法的标准形式，如是我们可以建立模型，从而解决此问题。

至于\(O(n^2\log n)\)的做法，sbit略感兴趣，但最近有点忙（改noi(p)模拟题。。），留个坑，如果您对此也有兴趣，欢迎和sbit讨论。。（可以增长见识 出题时卡时限 啊什么的。。。）

#include <bits/stdc++.h>
#define rep(_i, _j) for(int _i = 1; _i <= _j; ++_i)
const int INF = 0x3f3f3f3f;
typedef long long LL;
typedef double DB;
using namespace std;
const int maxn = 60 + 5;
const int maxd = 400 + 20;
struct Edge {
	int edge, head[maxn], cost[maxn * 2], to[maxn * 2], next[maxn * 2];
	Edge() {
		edge = 0;
		memset(head, -1, sizeof head);
	}
	void addedge(int u, int v, int c) {
		next[edge] = head[u];
		cost[edge] = c;
		to[edge] = v;
		head[u] = edge++;
	}
} E;
int n, m;
int g[maxd][maxd], c[maxd];

bool calc(int p, int fa, int goal, int id, int cost) {
	if(p == goal) return true;
	for(int i = E.head[p]; i != -1; i = E.next[i]) {
		if(E.to[i] != fa && calc(E.to[i], p, goal, id, cost)) {
			g[i >> 1][id] = max(g[i >> 1][id], E.cost[i] - cost);
			return true;
		}
	}
	return false;
}
bool visx[maxd], visy[maxd];
int link[maxd], lx[maxd], ly[maxd], N, slack;

bool dfs(int u) {
	visx[u] = true;
	for(int i = 0, tmp; i < N; ++i) if(!visy[i]) {
		tmp = lx[u] + ly[i] - g[u][i];
		if(tmp == 0) {
			visy[i] = true;
			if(link[i] == -1 || dfs(link[i])) {
				link[i] = u;
				return true;
			}
		} else {
			slack = min(slack, tmp);
		}
	}
	return false;
}

int main() {
#ifndef ONLINE_JUDGE
	freopen("206.in", "r", stdin); freopen("206.out", "w", stdout);
#endif
	scanf("%d%d", &n, &m);
	--n, m -= n;
	for(int i = 0, a, b, t; i < n; ++i) {
		scanf("%d%d%d", &a, &b, &t);
		E.addedge(a, b, t), E.addedge(b, a, t);
	}
	memset(g, 0, sizeof g);
	for(int i = 0, a, b; i < m; ++i) {
		scanf("%d%d%d", &a, &b, &c[i]);
		calc(a, -1, b, i, c[i]);
	}
	N = max(n, m);
	memset(link, -1, sizeof link);
	for(int i = 0; i < N; ++i) {
		for(int j = 0; j < N; ++j) {
			lx[i] = max(lx[i], g[i][j]);
		}
	}
	for(int i = 0; i < N; ++i) {
		for(;;) {
			slack= INF;
			memset(visx, false, sizeof(visx[0]) * N);
			memset(visy, false, sizeof(visy[0]) * N);
			if(dfs(i)) break;
			for(int j = 0; j < N; ++j) {
				if(visx[j]) lx[j] -= slack;
				if(visy[j]) ly[j] += slack;
			}
		}
	}
	for(int i = 0; i < n; ++i) {
		printf("%d\n", E.cost[i << 1] - lx[i]);
	}
	for(int i = 0; i < m; ++i) {
		printf("%d\n", ly[i] + c[i]);
	}

	return 0;
}