zoj 3659 Conquer a New Region

The wheel of the history rolling forward, our king conquered a new region in a distant continent.

There are N towns (numbered from 1 to N) in this region connected by several roads. It's confirmed that there is exact one route between any two towns. Traffic is important while controlled colonies are far away from the local country. We define the capacity C(i, j) of a road indicating it is allowed to transport at most C(i, j) goods between town i and town j if there is a road between them. And for a route between i and j, we define a value S(i, j) indicating the maximum traffic capacity between i and j which is equal to the minimum capacity of the roads on the route.

Our king wants to select a center town to restore his war-resources in which the total traffic capacities from the center to the other N - 1 towns is maximized. Now, you, the best programmer in the kingdom, should help our king to select this center.

Input

There are multiple test cases.

The first line of each case contains an integer N. (1 ≤ N ≤ 200,000)

The next N - 1 lines each contains three integers a, b, c indicating there is a road between town a and town b whose capacity is c. (1 ≤ a, b ≤ N, 1 ≤ c ≤ 100,000)

Output

For each test case, output an integer indicating the total traffic capacity of the chosen center town.

Sample Input

4
1 2 2
2 4 1
2 3 1
4
1 2 1
2 4 1
2 3 1

Sample Output

4
3

有N个城市，N-1条路把这些城市连起来（刚好是一个树）。相邻的两个城市有一个运输容量C(i, j)，而城市x到城市y的那条路的运输能力S取决与这条路上所经过的所有路中最小的那个容量。 以哪一个城市为中心，到其他N-1个城市的运输能力总和最大？

思路：把路按照权值从大到小排序，这样对于每次的选择，此次加入的边总是最小的，然后不断的加入边。 对于要加入的一条路，这条路连接这城市x和y，x所在的集合为A， y所在的集合为B， 可以确定A,B集合内的所有路都比当前这条路的权值大。如果让集合B加入集合A，就是让中心城市位于集合A，那么可以确定这两个集合合并之后的总权值为: A的权值总和+B的数量*当前这条路的权值。同样算出让集合B加入集合A的情况，取两者合并后权值大的进行合并。

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
using namespace std;
int Father[200005];
long long sum[200005];
int Count[200005];  //数量
int Find(int x)
{
    if(x!=Father[x])
    {
        Father[x]=Find(Father[x]);
    }
    return Father[x];
}
struct node
{
    int a;
    int b;
    int w;
    bool operator<(const node &t)const
    {
        return w>t.w;
    }
};
int main()
{
    int n;
    node num[200005];
    while (scanf("%d",&n)!=EOF)
    {
        for (int i=0; i<n-1; i++)
        {
            scanf("%d%d%d",&num[i].a,&num[i].b,&num[i].w);
        }
        for (int i=0; i<=n; i++)
        {
            Father[i]=i;
            sum[i]=0;
            Count[i]=1;
        }
        sort(num, num+n-1);
        long long ans=0;
        for (int i=0; i<n-1; i++)
        {
            int x=Find(num[i].a);
            int y=Find(num[i].b);
            long long w1=(long long)num[i].w*Count[x]+sum[y];   //y作为x的根
            long long w2=(long long)num[i].w*Count[y]+sum[x];   //x作为y的根
            if(w1>w2)
            {
                Father[x]=y;
                sum[y]=w1;
                Count[y]+=Count[x];
            }
            else
            {
                sum[x]=w2;
                Father[y]=x;
                Count[x]+=Count[y];
            }
            long long t=max(w1,w2);
            ans=ans>t?ans:t;
        }
        cout<<ans<<endl;
    }
    return 0;
}