hdu4679 Terrorist’s destroy 解题报告

题意：给你一棵树和边上的权值，定义去掉一条边的花费为边权值（a）乘上b，b定义为去掉边后形成的两棵树中两点间的最远距离（注意是各自内部的最远距离），问去掉哪条边的花费最少？

分析：首先我们可以将树的直径找出来，如下图

假设1->6就是这棵树的直径，非直径上的边为枝条，有两种删除边的方式：

1.去掉的是枝条

2.去掉的是直径上的边

方式1：b值一定是直径长度，可以枚举直接处理。

方式2：我们先把直径上的点做预处理，dep[i]表示第i个点的最深的枝条深度（如dep[1] = 1; dep[2] = 2; dep[3] = 3; dep[4] = 1; dep[5] = 2;dep[6] = 1)

f1[i] 表示删除第i个点右边的边左侧能得到的b值   f2[i] 表示删除第i个点左边的边右侧能得到的b值

（如f1[1] = 0; f1[2] = 2; f1[3] = 4;  f1[4] =4; f1[5] =5; ) 那么f1 ，f2的值怎么求呢？ 可以证明f1的值只能是（一部分直径+一条枝条的长度）或是一部分直径的长度，绝不可能是由两段枝条组成。

所以我们有递推式 f1[i] = max{f1[i-1],i-1+dep[i]-1}       注意：这里的i是指从左边数第几个点，并非编号

f2递推式类似，有了f1和f2数组我们就可以枚举直径上的边了，从而在O（1）的时间算得每次的花费

c++代码

#include<cstdio>
#include<cstring>
const int INF = 2000000000;
const int MAXX = 200020;
int q[MAXX],dislong[MAXX],f1[MAXX],f2[MAXX],pre[MAXX],father[MAXX],dep[MAXX];
int list[MAXX],next[MAXX],p[MAXX],c[MAXX],order[MAXX],maxx,n;
bool b[MAXX],inlong[MAXX];

int getmax(int x,int y)
{
    return x>y?x:y;
}
int getmin(int x,int y)
{
    return x>y?y:x;
}
int findlong(int xx,int n)
{
    int t,w,now,k,x;
    for (int i = 1; i <= n; i++)
    {
        b[i] = true;
    }
    t = 0; w = 1;
    q[1] = xx;
    dislong[1] = 1;
    b[xx] = false;
    pre[xx] = 0;
    maxx = 0;
    while (t < w)
    {
        t++; x = q[t];
        k = list[x];
        while (k > 0)
        {
            if (b[p[k]] == true)
            {
                w++;
                b[p[k]] = false;
                q[w] = p[k];
                dislong[w] = dislong[t]+1;
                pre[p[k]] = x;
                if (dislong[w] > maxx) {maxx = dislong[w]; now = p[k];}
            }
            k = next[k];
        }
    }
    return now;
}
void init(int n)
{
    for (int i = 1; i <= n; i++)
    {
        list[i] = 0;
    }
}
void dfs(int x,int pre1)
{
    int k;
    dep[x] = 1;
    k = list[x];
    while (k > 0)
    {
        if (inlong[p[k]] == false && p[k] != pre1)
        {
            dfs(p[k],x);
            dep[x] = getmax(dep[x],dep[p[k]]+1);
        }
        k = next[k];
    }
}
void finddep()
{
    int i;
    for (i = 1; i <= n; i++)
    if (inlong[i])
    {

        dfs(i,0);
    }
}
int main()
{
    int step,temp,kase,tot,i,k,kk,x,y,z,front,rear;
    int sum,ans,result;
    scanf("%d",&temp);
    for (kase = 1; kase <= temp; kase++)
    {
        tot = 0;
        scanf("%d",&n);
        init(n);
        for (i = 1;i < n; i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            tot++;
            next[tot] = list[x];
            list[x] = tot;
            p[tot] = y;
            c[tot] = z;
            order[tot] = i;
            tot++;
            next[tot] = list[y];
            list[y] = tot;
            p[tot] = x;
            c[tot] = z;
            order[tot] = i;
        }
        if (n != 1)
        {
            memset(pre,0,sizeof(pre));
            front = findlong(1,n);
            rear = findlong(front,n);
            sum = maxx-1;

            k = rear;
            memset(inlong,false,sizeof(inlong));
            memset(father,0,sizeof(father));
            while (k > 0)
            {
                inlong[k] = true;
                father[pre[k]] = k;
                k = pre[k];
            }
            memset(dep,0,sizeof(dep));
            finddep();//
            //cong front -> rear
            memset(f1,0,sizeof(f1));
            memset(f2,0,sizeof(f2));
            k = front; step = 0;
            while (k != rear)
            {
                step++;
                f1[k] = getmax(f1[pre[k]],step-1+dep[k]-1); //?
                k = father[k];
            }
            // cong rear->front
            k = rear; step = 0;
            father[rear] = 0;
            while (k != front)
            {
                step++;
                f2[k] = getmax(f2[father[k]],step-1+dep[k]-1);
                k = pre[k];
            }
            //遍历直径
            ans = INF;
            result = INF;
            k = front;
            while (k != rear)
            {
                kk = list[k];
                while (kk > 0)
                {
                    if (p[kk] == father[k]) break;
                    kk = next[kk];
                }
                if (ans > c[kk]*getmax(f1[k],f2[father[k]]))
                {
                    ans = c[kk]*getmax(f1[k],f2[father[k]]);
                    result = order[kk];

                }
                else if (ans == c[kk]*getmax(f1[k],f2[father[k]]))
                {
                    if (result > order[kk]) result = order[kk];
                }
                k = father[k];
            }

            //遍历枝条
            for (i = 1; i <= n; i++)
            {
                k = list[i];
                while (k > 0)
                {
                    if(!(inlong[i] && inlong[p[k]]))
                    {
                        if (ans > c[k]*sum)
                        {
                            ans = c[k]*sum;
                            result = order[k];

                        }
                        else if (ans == c[k]*sum)
                        {
                            if (result > order[k]) result = order[k];
                        }
                    }
                    k = next[k];
                }
            }
            printf("Case #%d: ",kase);
            printf("%d\n",result);
        }
    }
    return 0;
}