HDU 4123 Bob’s Race (树形DP+RMQ维护极值)*

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4123

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define read(x,y) scanf("%d%d",&x,&y)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
const int  maxn =5e4+5;
const int mod=1e9+7;
const int ub=1e6;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：题意比较烦，
一颗树，可以选择序号连续的一段起点进行比赛，
每个人都要跑的尽量远，一个连续序号的区间的选择的权值就是
其中最大值和最小值的差值。
那么给定若干查询，求其权值不大于给定值的
区间长度最大值。

首先对于每个点跑尽量远的描述，
可以用树形DP搞一搞，我没用树的直径的相关知识，
最好想的算法，就是对每个点，维护子节点中的最大值和次大值并顺带记录下标，
对于每个最大值，用rmq维护下区间极值，
然后查询的时候暴力扫下就行（确定一端端点）。

时间复杂度：O(m*n+nlogn)。
*/
///数据域
int n,m,x,y,z;
///链式前向星
struct edge{int u,nxt,w;}e[maxn<<1];
int head[maxn],tot=0;
void init(){memset(head,-1,sizeof(head));tot=0;}
void add(int x,int y,int z){e[tot]=edge{y,head[x],z};head[x]=tot++;}
///维护树的最大值和次大值
int maxf[maxn],fid[maxn],maxs[maxn],sid[maxn];
void maintain(int u,int v,int w)
{
    if(w>maxs[u])
    {
        maxs[u]=w;
        sid[u]=v;
    }
    if(maxf[u]<maxs[u])
    {
        swap(maxf[u],maxs[u]);
        swap(fid[u],sid[u]);
    }
}

void dfs(int u,int pre)
{
    maxf[u]=fid[u]=maxs[u]=sid[u]=0;
    for(int i=head[u];~i;i=e[i].nxt)
    {
        int v=e[i].u;
        if(v==pre) continue;
        dfs(v,u);
        maintain(u,v,maxf[v]+e[i].w);
    }
}

void dfs(int u,int pre,int d)
{
    maintain(u,pre,d);
    for(int i=head[u];~i;i=e[i].nxt)
    {
        int v=e[i].u;
        if(v==pre) continue;
        dfs(v,u,(v==fid[u]?maxs[u]:maxf[u])+e[i].w);
    }
}
///RMQ查询结构
int dpMax[maxn][20],dpMin[maxn][20];
void rmq_init()
{
    for(int i=1;i<=n;i++) dpMax[i][0]=dpMin[i][0]=maxf[i];
    for(int k=1;(1<<k)<=n;k++)
        for(int i=1;i+(1<<k)-1<=n;i++)
        {
            dpMax[i][k]=max(dpMax[i][k-1],dpMax[i+(1<<(k-1))][k-1]);
            dpMin[i][k]=min(dpMin[i][k-1],dpMin[i+(1<<(k-1))][k-1]);
        }
}
int rmq_query(int l,int r)
{
    int k=0;while((1<<(k+1))<=r-l+1) k++;
    int maxans=max(dpMax[l][k],dpMax[r-(1<<k)+1][k]);
    int minans=min(dpMin[l][k],dpMin[r-(1<<k)+1][k]);
    return maxans-minans;
}

int main()
{
    while(scanf("%d%d",&n,&m)&&(n||m))
    {
        init();
        for(int i=1;i<n;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z),add(y,x,z);
        }
        dfs(1,0);dfs(1,0,0);
        rmq_init();
        for(int i=0;i<m;i++)
        {
            scanf("%d",&x);
            int ans=0,idx=1;
            for(int i=1;i<=n;i++)///居然没超时T_T
            {
                while(idx<=i&&rmq_query(idx,i)>x) idx++;
                ans=max(ans,i-idx+1);
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}