HDU 4123 Bob’s Race（RMQ）

题意是说给出一棵树，N（10^5）个顶点，以及每条边的权值，现在需要选择连续的K个点（顶点编号连续），可以被选出来的条件是：

若d[i]代表顶点i到树上其他点的距离的最大值，使得区间[a, b]的d值的最大差值不大于Q，

也就是max(d[a], d[a + 1], ..., d[b]) - max(d[a], d[a + 1], ..., d[b]) <= Q

Q是给出的一个查询（共有m<=500个查询），求对应每一个查询的K的最大值

思路是首先预处理出每个点到其他点的最大距离, 这可以通过两遍dfs算出来，然后对于每一个查询Q，找出一个最大长度的区间，使得这个区间的最大最小值差<=Q，所以还需要RMQ预处理出每个区间的最大值与最小值（这里查询需要做到O(1)），然后扫描一遍数组便可以得到这个最大长度的区间。

 #pragma comment(linker, "/STACK:1677721600")
 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <cmath>
 #include <ctime>
 #include <vector>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define inf (-((LL)1<<40))
 #define lson k<<1, L, (L + R)>>1
 #define rson k<<1|1,  ((L + R)>>1) + 1, R
 #define mem0(a) memset(a,0,sizeof(a))
 #define mem1(a) memset(a,-1,sizeof(a))
 #define mem(a, b) memset(a, b, sizeof(a))
 #define FIN freopen("in.txt", "r", stdin)
 #define FOUT freopen("out.txt", "w", stdout)
 #define rep(i, a, b) for(int i = a; i <= b; i ++)
 #define dec(i, a, b) for(int i = a; i >= b; i --)

 template<class T> T MAX(T a, T b) { return a > b ? a : b; }
 template<class T> T MIN(T a, T b) { return a < b ? a : b; }
 template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
 template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

 //typedef __int64 LL;
 typedef long long LL;
 const int MAXN =  + ;
 const int MAXM = ;
 const double eps = 1e-;
 LL MOD = ;

 struct Node {
     int v, s;
     Node(int _v = , int _s = ) {
         v = _v; s = _s;
     }
 };

 vector<Node>G[MAXN];
 int mx[MAXN], se[MAXN], d[MAXN], idx[MAXN];
 int ma[MAXN][], mi[MAXN][];
 int n, u, v, w;
 int m, Q;

 void init(int n) {
     rep (i, , n) G[i].clear();
     mem0(mx); mem0(se);
 }

 void dfs1(int u, int fa) {
     mx[u] = se[u] = ;
     int sz = G[u].size();
     rep (i, , sz - ) {
         int v = G[u][i].v;
         if(v == fa) continue;
         dfs1(v, u);
         int len = G[u][i].s + mx[v];
         if(len > mx[u]) se[u] = mx[u], mx[u] = len;
         else if(len > se[u]) se[u] = len;
     }
 }

 void dfs2(int u, int fa, int dis) {
     d[u] = max(dis, max(mx[u], se[u]));
     int sz = G[u].size();
     rep (i, , sz - ) {
         int v = G[u][i].v, len = G[u][i].s;
         if(v == fa) continue;
         if(len + mx[v] == mx[u])
             dfs2(v, u, max(dis, se[u]) + len);
         else
             dfs2(v, u, max(dis, mx[u]) + len);
     }
 }

 void rmq_init(int n) {
     rep (i, , n) ma[i][] = mi[i][] = d[i];
     for(int j = ; (<<j) <= n; j ++) {
         for(int i = ; i + (<<j) -  <= n; i ++) {
             ma[i][j] = max(ma[i][j - ], ma[i + ( << (j - ))][j - ]);
             mi[i][j] = min(mi[i][j - ], mi[i + ( << (j - ))][j - ]);
         }
     }
     rep (len, , n) {
         idx[len] = ;
         while(( << (idx[len] + )) <= len) idx[len] ++;
     }
 }

 int rmq(int l, int r) {
     int k = idx[r - l + ];
     return max(ma[l][k], ma[r - ( << k) + ][k]) - min(mi[l][k], mi[r - ( << k) + ][k]);
 }

 int main()
 {
 //    FIN;
     while(~scanf("%d %d", &n, &m) && n) {
         init(n);
         rep (i, , n - ) {
             scanf("%d %d %d", &u, &v, &w);
             G[u].push_back(Node(v, w));
             G[v].push_back(Node(u, w));
         }

         //计算每个点到叶子节点的最远距离
         dfs1(, -);
         dfs2(, -, );

         //计算答案
         rmq_init(n);
         while(m --) {
             scanf("%d", &Q);
             int l = , ans = ;
             rep (i, , n) {
                 while(l < i && rmq(l, i) > Q) l ++;
                 ans = max(ans, i - l + );
             }
             cout << ans << endl;
         }
     }
     return ;
 }