codeforces 294E Shaass the Great (树形dp，好题)

题意：

给出一棵树，每条边有一个权值，现在要将树的某个边打断，然后重新建一条等长的边在某两点间，要求建完边的图形也要是树。求使得所有点两两距离和最短的方案。

题解：

我们分析如果某条边打断，那么就分成了两棵树，我们假设断掉的是u，v两点的边，那么两两距离和可以化成这个公式：

S = { u的树中任意两点距离和 }+{ v的树中任意两点的距离和 } + { u树中任意点到u的距离和 * v的节点数} + { v树中任意点到v的距离和 * u的节点数 } + { u的节点数 * v的节点数 * uv之间的距离 }

这题可以说把数上的操作弄到了极致。设这样的状态dp[u][3]  0表示u的子树孩子的数量，1u的子树的每个孩子到这个点的距离和，2表示u的子树两两点距离的和。

这个处理非常的有技巧，具体看代码。

#include<iostream>
#include<math.h>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<map>
using namespace std;
typedef long long ll;
const int oo=0x3f3f3f3f;
const ll OO=1LL<<61;
const ll MOD=2147483647;
const int maxn=5005;
ll dp[maxn][3];///2表示任意两点的距离和，1任意点到i的距离和，0表示子树的孩子数
struct EDGE
{
    int v,next;
    ll w;
}E[maxn<<1];
int head[maxn],tol;
int U[maxn],V[maxn];
ll C[maxn];

void add_edge(int u,int v,ll w)
{
    E[tol].v=v;
    E[tol].w=w;
    E[tol].next=head[u];
    head[u]=tol++;
}

void Init()
{
    memset(head,-1,sizeof head);
    tol=0;
}

void dfs(int u,int pre)
{
    dp[u][0]=dp[u][1]=dp[u][2]=0;
    for(int i=head[u];i!=-1;i=E[i].next)
    {
        int v=E[i].v;
        if(v==pre)continue;
        dfs(v,u);
        dp[u][2]+=dp[v][2]+dp[v][1]*dp[u][0]+dp[v][0]*dp[u][1]+dp[u][0]*dp[v][0]*E[i].w;
        dp[u][1]+=dp[v][1]+E[i].w*dp[v][0];
        dp[u][0]+=dp[v][0];
    }
    dp[u][0]++;///这个节点还没加，所有任意点到这个节点的距离要加在dp[u][2]中
    dp[u][2]+=dp[u][1];
}

void dfsm(int u,int pre,ll& mi)
{
    mi=min(mi,dp[u][1]);
    for(int i=head[u];i!=-1;i=E[i].next)
    {
        int v=E[i].v;
        if(v==pre)continue;
        dp[v][1]=dp[v][1]+(dp[u][1]-dp[v][1]-E[i].w*dp[v][0])+(dp[u][0]-dp[v][0])*E[i].w;
        dp[v][0]=dp[u][0];
        dfsm(v,u,mi);
    }
}

int main()
{
    int n;
    ll c;
    while(scanf("%d",&n)!=EOF)
    {
        Init();
        for(int i=1;i<=n-1;i++)
        {
            scanf("%d %d %I64d",&U[i],&V[i],&C[i]);
            add_edge(U[i],V[i],C[i]);
            add_edge(V[i],U[i],C[i]);
        }
        ll ans=OO;
        for(int i=1;i<=n-1;i++)
        {
            ll mi=OO;
            dfs(U[i],V[i]);
            dfsm(U[i],V[i],mi);
            ll s1=(n-dp[U[i]][0])*mi+dp[U[i]][2];
            mi=OO;
            dfs(V[i],U[i]);
            dfsm(V[i],U[i],mi);
            ll s2=(n-dp[V[i]][0])*mi+dp[V[i]][2];
            ll sum=s1+s2+dp[U[i]][0]*dp[V[i]][0]*C[i];
            ans=min(ans,sum);
        }
        cout<<ans<<endl;
    }
    return 0;
}
/**
3
1 2 2
1 3 4
6
1 2 1
2 3 1
3 4 1
4 5 1
5 6 1
6
1 3 1
2 3 1
3 4 100
4 5 2
4 6 1

*/