codeforces 294 E Shaass The Great

The great Shaass is the new king of the Drakht empire. The empire has n cities which are connected by n - 1 bidirectional roads. Each road has an specific length and connects a pair of cities. There’s a unique simple path connecting each pair of cities.

His majesty the great Shaass has decided to tear down one of the roads and build another road with the same length between some pair of cities. He should build such road that it’s still possible to travel from each city to any other city. He might build the same road again.

You as his advisor should help him to find a way to make the described action. You should find the way that minimize the total sum of pairwise distances between cities after the action. So calculate the minimum sum.

Input
The first line of the input contains an integer n denoting the number of cities in the empire, (2 ≤ n ≤ 5000). The next n - 1 lines each contains three integers ai, bi and wi showing that two cities ai and bi are connected using a road of length wi, (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ wi ≤ 106).

Output
On the only line of the output print the minimum pairwise sum of distances between the cities.

Please do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specificator.

Examples
Input
3
1 2 2
1 3 4
Output
12
Input
6
1 2 1
2 3 1
3 4 1
4 5 1
5 6 1
Output
29
Input
6
1 3 1
2 3 1
3 4 100
4 5 2
4 6 1
Output
825

题意：

给一棵有边权的树，要求去掉一条边再重新连上，使这棵树重新联通，求操作之后树上每两个点之间的距离和最小值。

思路：

• 首先因为数据范围比较小，可以枚举去掉哪条边。

• 然后把分出来的两棵树重心连起来。为什么连重心？（一看就是重心）假设连边的点分别是X1和X2，两棵树内部和为sum1和sum2，两棵树节点到X1和X2的距离和分别是_sum1和_sum2，sz1和sz2是两棵树的大小，w是边的权值那么最后的距离和为sum1+sum2+_sum1*sz2+_sum2*sz1+w*sz1*sz2，而当X1，X2取重心时_sum1和_sum2是最小的，一旦X从重心移到一个非重心的点，一定会出现一棵size大于1/2树的大小的子树，对于移动路过的那条边W，有大于1/2的点到X的距离加上了W，其余减去了Ｗ，故_sum会变大。由此可知连边在重心时结果最优。

• 然后就是麻烦的处理过程。为了求出上述公式的值，我们需要知道的值有：１两棵树的大小，２两棵子树重心编号，３树的内部所有点对距离，４树的所有点到重心的距离和。对，只要这么点就够了。为了求出这些值最好实现的方法就是４遍DFS，每一遍求一个值，最后套公式，再给去掉每条边的情况取最小值就好了。

• 具体实现其实并没有用到什么高端的算法，全都是最普通的深搜。其实想想什么tarjan，倍增，树上差分这种树型结构的操作，好像全都是建立在DFS的基础上。灵活运用暴力搜索还是挺重要的吧。

代码：

//好长呀
#include<iostream>
#include<cstdio>
#include<cstring>
#define int long long
#define ll long long
using namespace std;
const ll INF = 1e18+10;
const int N = 10010;
int n;
struct EDGE{
    int nxt, v, w;
}edge[N*2];
int point[N], e, del, col[N];
ll maxsub[N], sz[N];
ll ans, sumr[N], sum[N];

void add_edge(int u, int v, int w)
{
    edge[++e] = (EDGE){point[u], v, w};
    point[u] = e;
}

void init()
{
    cin >> n;
    memset(point, -1, sizeof(point)); e = 0;
    for (int i = 1; i < n; i++){
        int x, y, z;
        cin >> x >> y >> z;
        add_edge(x, y, z);
        add_edge(y, x, z);
    }
    ans = INF;
}

void dfs1(int u, int fa)//求树的大小和最大子树大小，找重心的预备
{
    sz[u] = 1; maxsub[u] = 0;
    for (int i = point[u]; i != -1; i = edge[i].nxt){
        int v = edge[i].v;
        if (v == fa || i == del) continue;
        col[v] = col[u];
        dfs1(v, u);
        maxsub[u] = max(maxsub[u], sz[v]);
        sz[u] += sz[v];
    }
}

int dfs2(int u, int fa, int rsz)//找重心
{
    if (max(maxsub[u], rsz-sz[u]) <= rsz/2) return u;
    int tmp = 0;
    for (int i = point[u]; i != -1; i = edge[i].nxt){
        int v = edge[i].v;
        if (v == fa || col[v] != col[u]) continue;
        tmp = dfs2(v, u, rsz);
        if (tmp) return tmp;
    }
    return tmp;
}

void dfs3(int u, int fa)//求子树内部所有点对距离和
{
    int sznow = 1;
    sumr[u] = sum[u] = 0;
    for (int i = point[u]; i != -1; i = edge[i].nxt){
        int v = edge[i].v;
        int w = edge[i].w;
        if (v == fa || col[v] != col[u]) continue;
        dfs3(v, u);
        sum[u] = sum[u]+sum[v]+sumr[u]*sz[v]+sumr[v]*sznow+w*sznow*sz[v];
//把一棵子树连到父亲上面，sum[u]是当前树中所有点对距离和，sum[v]是v为根子树的，sumr[]整棵子树是到根的距离和
        sumr[u] += sumr[v]+w*sz[v];
        sznow += sz[v];
    }
}

void dfs4(int u, int fa)//以重心为根dfs，求所有点到中心的距离和（即到根的距离和）
{
    sumr[u] = 0; sz[u] = 1;
    for (int i = point[u]; i != -1; i = edge[i].nxt){
        int v = edge[i].v;
        int w = edge[i].w;
        if (v == fa || col[v] != col[u]) continue;
        dfs4(v, u);
        sumr[u] += sumr[v]+w*sz[v];
        sz[u] += sz[v];
    }
}

void delete_edge(int v, int u, int ed)
{
    //以１和切掉的边的较深节点为根建树
    del = ed;
    col[1] = 1; dfs1(1, 0);
    col[v] = 2; dfs1(v, u);
    int ctr1 = dfs2(1, 0, sz[1]);
    int ctr2 = dfs2(v, u, sz[v]);
    dfs3(1, 0);
    ll sum1 = sum[1];
    dfs3(v, u);
    ll sum2 = sum[v];
    //以两棵树重心建树
    dfs4(ctr1, 0);
    ll _sum1 = sumr[ctr1];
    dfs4(ctr2, 0);
    ll _sum2 = sumr[ctr2];
    ans = min(ans, sum1+sum2+_sum1*sz[ctr2]+_sum2*sz[ctr1]+(ll)edge[ed].w*sz[ctr1]*sz[ctr2]);
}

void work(int u, int fa)
{
    for (int i = point[u]; i != -1; i = edge[i].nxt){
        int v = edge[i].v;
        if (v == fa) continue;
        delete_edge(v, u, i);
        work(v, u);
    }
}

main()
{
    init();
    work(1, 0);
    cout << ans << endl;
    return 0;
}