树上的路径 BZOJ 3784

树上的路径

【问题描述】

给定一个N个结点的树，结点用正整数1..N编号。每条边有一个正整数权值。用d(a,b）表示从结点a到结点b路边上经过边的权值。其中要求a<b.将这n*(n-1)/2个距离从大到小排序，输出前M个距离值。

【输入格式】

第一行两个正整数N,M

下面N-1行，每行三个正整数a,b,c(a,b<=N，C<=10000)。表示结点a到结点b有一条权值为c的边。

【输出格式】

共M行，如题所述.

【样例输入】

5 10
1 2 1
1 3 2
2 4 3
2 5 4

【样例输出】

7
7
6
5
4
4
3
3
2
1
【数据范围】

N<=50000,M<=Min(300000,n*(n-1) /2 )

---

题解：

考虑将点分治时访问的点的顺序作为一个序列

每个位置都有其对应的区间（指向这个位置所在重心树访问的前面所有子树，那么这就代表了这个位置对应的点出发经过这个重心的所有路径）

那么原问题转化为了BZOJ 2006 超级钢琴的问题

 #include<cmath>
 #include<queue>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 const int inf = ;
 const int logn = ;
 const int logs = ;
 const int maxn = 5e4 + ;
 const int maxm = maxn << ;
 const int maxs = maxn * logn + ;
 inline void Scan(int &x)
 {
     char c;
     bool o = false;
     while(!isdigit(c = getchar())) o = (c != '-') ? o : true;
     x = c - '';
     while(isdigit(c = getchar())) x = x *  + c - '';
     if(o) x = -x;
 }
 int tot, nex[maxm], ver[maxm], fir[maxn], val[maxm];
 inline void Ins(int x, int y, int z)
 {
     nex[++tot] = fir[x];
     fir[x] = tot;
     ver[tot] = y;
     val[tot] = z;
 }
 int sum, root;
 int size[maxn], heavy[maxn];
 bool vis[maxn];
 void Getroot(int u, int f)
 {
     heavy[u] = ;
     size[u] = ;
     for(int i = fir[u]; i; i = nex[i])
     {
         int v = ver[i];
         if(v == f || vis[v]) continue;
         Getroot(v, u);
         size[u] += size[v];
         heavy[u] = max(heavy[u], size[v]);
     }
     heavy[u] = max(heavy[u], sum - size[u]);
     if(heavy[u] < heavy[root]) root = u;
 }
 struct couple
 {
     int l, r;
 };
 couple c[maxs];
 int num, l, r;
 int dis[maxn], len[maxs];
 int big[logs][maxs];
 void Getdis(int u, int f)
 {
     len[++num] = dis[u], big[][num] = num;
     c[num] = (couple) {l, r};
     for(int i = fir[u]; i; i = nex[i])
     {
         int v = ver[i];
         if(v == f || vis[v]) continue;
         dis[v] = dis[u] + val[i];
         Getdis(v, u);
     }
 }
 void Div(int u)
 {
     root = ;
     Getroot(u, );
     l = r = ++num;
     len[num] = , big[][num] = num;
     vis[root] = true;
     for(int i = fir[root]; i; i = nex[i])
     {
         int v = ver[i];
         if(vis[v]) continue;
         dis[v] = val[i];
         Getdis(v, root);
         r = num;
     }
     for(int i = fir[root]; i; i = nex[i])
     {
         int v = ver[i];
         if(vis[v]) continue;
         sum = size[v];
         Div(v);
     }
 }
 inline int Max(int a, int b)
 {
     return (len[a] > len[b]) ? a : b;
 }
 int bin[logs], lg[maxs];
 inline void Rmq()
 {
     int lgn = log2(num);
     bin[] = ;
     for(int i = ; i <= lgn; ++i) bin[i] = bin[i - ] << , lg[bin[i]] = ;
     for(int i = ; i <= num; ++i) lg[i] += lg[i - ];
     for(int k = ; k <= lgn; ++k)
         for(int i = ; i <= num; ++i)
         {
             if(i + bin[k] -  > num) continue;
             int j = i + bin[k - ];
             big[k][i] = Max(big[k - ][i], big[k - ][j]);
         }
 }
 inline int Query(int l, int r)
 {
     if(l > r) return -;
     int len = lg[r - l + ];
     return Max(big[len][l], big[len][r - bin[len] + ]);
 }
 int n, m;
 struct interval
 {
     int l, r, a, b, v;
 };
 inline bool operator < (interval a, interval b)
 {
     return a.v < b.v;
 }
 priority_queue <interval> q;
 int main()
 {
     Scan(n), Scan(m);
     int a, b;
     for(int i = ; i < n; ++i)
     {
         int c;
         Scan(a), Scan(b), Scan(c);
         Ins(a, b, c), Ins(b, a, c);
     }
     sum = n;
     root = ;
     heavy[] = inf;
     Div();
     Rmq();
     int x;
     for(int i = ; i <= num; ++i)
     {
         a = c[i].l, b = c[i].r;
         if(a)
         {
             x = Query(a, b);
             q.push((interval) {a, b, i, x, len[i] + len[x]});
         }
     }
     int u, v;
     interval s;
     while(m--)
     {
         s = q.top(), q.pop();
         u = Query(s.l, s.b - );
         v = Query(s.b + , s.r);
         if(u > ) q.push((interval) {s.l, s.b - , s.a, u, len[u] + len[s.a]});
         if(v > ) q.push((interval) {s.b + , s.r, s.a, v, len[v] + len[s.a]});
         printf("%d\n", s.v);
     }
 }