HDU 4123 Bob's Race：树的直径 + 单调队列 + st表

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

题意：

　　给你一棵树，n个节点，每条边有长度。

　　然后有m个询问，每个询问给定一个q值。

　　设dis[i]为：从节点i出发，不重复经过节点，所能够走的最远距离。

　　每次询问问你：区间[l,r]最长能有多长，同时保证 max{dis[i]} - min{dis[i]} <= q (i∈[l,r])

题解：

　　首先有一个结论：

　　　　从树上的任意一个节点出发，尽可能往远走，最终一定会到达树的直径的两个端点之一。

　　所以先两遍dfs1，找出直径的两个端点。

　　然后分别从两个端点dfs2，求出所有节点的dis[i]。

　　因为节点必须选编号连续的一段区间，所以可以用到单调队列。

　　枚举每个节点i加入队首。

　　然后对于每个i，不断地丢掉队尾pos++，直到当前的区间[pos,i]符合条件。

　　那么每次都需要判断是否有 max{dis[i]} - min{dis[i]} <= q (i∈[pos,i])

　　这就要用到st表了，然后O(1)判断就好。

AC Code:

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#define MAX_N 50005
#define MAX_K 20

using namespace std;

struct Edge
{
    int dest;
    int len;
    Edge(int _dest,int _len)
    {
        dest=_dest;
        len=_len;
    }
    Edge(){}
};

int n,m;
int maxd;
int st,ed;
int dis[MAX_N];
int lg[MAX_N];
int maxt[MAX_N][MAX_K];
int mint[MAX_N][MAX_K];
vector<Edge> edge[MAX_N];

void read()
{
    for(int i=1;i<=n;i++) edge[i].clear();
    int x,y,z;
    for(int i=1;i<n;i++)
    {
        cin>>x>>y>>z;
        edge[x].push_back(Edge(y,z));
        edge[y].push_back(Edge(x,z));
    }
}

void dfs1(int now,int p,int d,int &v)
{
    if(d>maxd)
    {
        maxd=d;
        v=now;
    }
    for(int i=0;i<edge[now].size();i++)
    {
        Edge temp=edge[now][i];
        if(temp.dest!=p) dfs1(temp.dest,now,d+temp.len,v);
    }
}

void dfs2(int now,int p,int d)
{
    dis[now]=max(dis[now],d);
    for(int i=0;i<edge[now].size();i++)
    {
        Edge temp=edge[now][i];
        if(temp.dest!=p) dfs2(temp.dest,now,d+temp.len);
    }
}

void init_st()
{
    lg[0]=-1;
    for(int i=1;i<=n;i++)
    {
        lg[i]=lg[i>>1]+1;
        maxt[i][0]=mint[i][0]=dis[i];
    }
    for(int k=1;(1<<k)<=n;k++)
    {
        for(int i=1;i+(1<<k)-1<=n;i++)
        {
            maxt[i][k]=max(maxt[i][k-1],maxt[i+(1<<(k-1))][k-1]);
            mint[i][k]=min(mint[i][k-1],mint[i+(1<<(k-1))][k-1]);
        }
    }
}

int query_max(int l,int r)
{
    int k=lg[r-l+1];
    return max(maxt[l][k],maxt[r-(1<<k)+1][k]);
}

int query_min(int l,int r)
{
    int k=lg[r-l+1];
    return min(mint[l][k],mint[r-(1<<k)+1][k]);
}

void work()
{
    maxd=-1;
    dfs1(1,-1,0,st);
    maxd=-1;
    dfs1(st,-1,0,ed);
    memset(dis,-1,sizeof(dis));
    dfs2(st,-1,0);
    dfs2(ed,-1,0);
    init_st();
    while(m--)
    {
        int q;
        cin>>q;
        int ans=1;
        int pos=1;
        for(int i=1;i<=n;i++)
        {
            while(query_max(pos,i)-query_min(pos,i)>q) pos++;
            ans=max(ans,i-pos+1);
        }
        cout<<ans<<endl;
    }
}

int main()
{
    while(cin>>n>>m)
    {
        if(n==0 && m==0) break;
        read();
        work();
    }
}