hdu 4679 Terrorist’s destroy 多校第八场

先从根深搜一遍，所有子节点的最长，次长，次次长链

l1,l2,l3 分别 最长，次长，次次长链的大小，s1,s2,s3 表示来自哪个子节点

然后再从根dfs一遍，每次将父节点的最长链来更新子节点的链

不能直视的搓代码。。。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

const int maxn = 100010;
const int inf = 0x7f7f7f7f;
#define MP(a,b) make_pair((a),(b))
typedef pair<int,pair<int,int> > PII;
vector<PII >vv[maxn];
int ans,id;
struct pp
{
    int l1,l2,l3;
    int s1,s2,s3;
    pp(){}
    pp(int _l1,int _l2,int _l3,int _s1,int _s2,int _s3){l1=0,l2=0,l3=0,s1=0,s2=0,s3=0;}
}dp[maxn];
void swap(int &a ,int &b)
{
    int t;
    t=a;
    a=b;
    b=t;
}
void DP(int u,int p)
{
    dp[u]=pp(0,0,0,0,0,0);
    int sz=vv[u].size();
    for(int i=0;i<sz;i++)
    {
        int v=vv[u][i].first;
        if(v==p) continue;
        int w=vv[u][i].second.first,idx=vv[u][i].second.second;
        DP(v,u);
        if(dp[u].l3<dp[v].l1+1)
        {   dp[u].l3=dp[v].l1+1,dp[u].s3=v;
            if(dp[u].l2<dp[u].l3) {
            swap(dp[u].l3,dp[u].l2);
            swap(dp[u].s2,dp[u].s3);
            }
            if(dp[u].l1<dp[u].l2)
            {
            swap(dp[u].l1,dp[u].l2);
            swap(dp[u].s2,dp[u].s1);
            }
        }
    }
}
void dfs(int u,int p)
{
    int sz=vv[u].size();
   // printf("u=%d l=%d\n",u,dp[u].l1+dp[u].l2);
    for(int i=0;i<sz;i++)
    {
        int v=vv[u][i].first;
        if(v==p) continue;
        int w=vv[u][i].second.first,idx=vv[u][i].second.second;
        int t=dp[v].l1+dp[v].l2;
        if(v==dp[u].s1)
        {
            t=max(t,dp[u].l2+dp[u].l3);
            if(dp[v].l3<=dp[u].l2+1)
            {
                dp[v].l3=dp[u].l2+1;
                dp[v].s3=u;
            }
            if(dp[v].l2<dp[v].l3)
            {
                swap(dp[v].l3,dp[v].l2);
                swap(dp[v].s2,dp[v].s3);
            }
            if(dp[v].l1<dp[v].l2)
            {
                swap(dp[v].l1,dp[v].l2);
                swap(dp[v].s2,dp[v].s1);
            }
        }
        else if(v==dp[u].s2)
        {
            t=max(t,dp[u].l1+dp[u].l3);
            if(dp[v].l3<=dp[u].l1+1)
            {
                dp[v].l3=dp[u].l1+1;
                dp[v].s3=u;
            }
            if(dp[v].l2<dp[v].l3)
            {
                swap(dp[v].l3,dp[v].l2);
                swap(dp[v].s2,dp[v].s3);
            }
            if(dp[v].l1<dp[v].l2)
            {
                swap(dp[v].l1,dp[v].l2);
                swap(dp[v].s2,dp[v].s1);
            }
        }
        else
        {
            t=max(t,dp[u].l1+dp[u].l2);
            if(dp[v].l3<=dp[u].l1+1)
            {
                dp[v].l3=dp[u].l1+1;
                dp[v].s3=u;
            }
            if(dp[v].l2<dp[v].l3)
            {
                swap(dp[v].l3,dp[v].l2);
                swap(dp[v].s2,dp[v].s3);
            }
            if(dp[v].l1<dp[v].l2)
            {
                swap(dp[v].l1,dp[v].l2);
                swap(dp[v].s2,dp[v].s1);
            }
        }
        if(ans>t*w)
        {
            ans=t*w;
            id=idx;
        }
        else if(ans==t*w&&id>idx) id=idx;
        dfs(v,u);

    }
}
int main()
{
    int T,cas=1;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        for(int i=0;i<=n;i++) vv[i].clear();
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            vv[u].push_back(MP(v,MP(w,i)));
            vv[v].push_back(MP(u,MP(w,i)));
        }
        ans=inf;
        DP(1,0);
        dfs(1,0);
        printf("Case #%d: %d\n",cas++,id);
    }
}