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=;i<=n;i++) edge[i].clear();
     int x,y,z;
     for(int i=;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=;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=;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[]=-;
     for(int i=;i<=n;i++)
     {
         lg[i]=lg[i>>]+;
         maxt[i][]=mint[i][]=dis[i];
     }
     for(int k=;(<<k)<=n;k++)
     {
         for(int i=;i+(<<k)-<=n;i++)
         {
             maxt[i][k]=max(maxt[i][k-],maxt[i+(<<(k-))][k-]);
             mint[i][k]=min(mint[i][k-],mint[i+(<<(k-))][k-]);
         }
     }
 }
 
 int query_max(int l,int r)
 {
     int k=lg[r-l+];
     return max(maxt[l][k],maxt[r-(<<k)+][k]);
 }
 
 int query_min(int l,int r)
 {
     int k=lg[r-l+];
     return min(mint[l][k],mint[r-(<<k)+][k]);
 }
 
 void work()
 {
     maxd=-;
     dfs1(,-,,st);
     maxd=-;
     dfs1(st,-,,ed);
     memset(dis,-,sizeof(dis));
     dfs2(st,-,);
     dfs2(ed,-,);
     init_st();
     while(m--)
     {
         int q;
         cin>>q;
         int ans=;
         int pos=;
         for(int i=;i<=n;i++)
         {
             while(query_max(pos,i)-query_min(pos,i)>q) pos++;
             ans=max(ans,i-pos+);
         }
         cout<<ans<<endl;
     }
 }
 
 int main()
 {
     while(cin>>n>>m)
     {
         if(n== && m==) break;
         read();
         work();
     }
 }