poj2763(lca / RMQ + 线段树)

题目链接: http://poj.org/problem?id=2763

题意: 第一行输入 n, q, s 分别为树的顶点个数, 询问/修改个数, 初始位置. 接下来 n - 1 行形如 x, y, w 的输入为点 x, y 之间连边且边权为 w.

接下来 q 行输入, 若输入形式为 1 x y 则为将点 x 的权值修改为 y , 若输入形式为 0 x 则询问 s 到 x 的最短距离为多少. 上一组的 x 为下一组的 s.

思路: 若去掉修改边权部分, 则为一个 lca 模板题. 对于修改边权, 直接暴力向下修改 dis 数组可能会 tle . 可以将树映射到线段树上, 那样修改时间可降为为 log(n).

具体操作为, dfs 出每点的入点时间戳 l [MAXN] 和出点时间戳 r [MAXN] , 并记录 dfs 顺序 sol [MAXN] .

将 dis [sol [MAXN] ] 放入 sum 数组建线段树.

那么 x 到根结点的距离为: query(l[x], l[x], 1, n, 1) .

将 x 点的权值由 w 修改到 w' 操作为: updata(l[x], r[x], w - w', 1, n, 1) .

代码:

 #include <iostream>
 #include <stdio.h>
 #include <math.h>
 #include <string.h>
 #define lson l, mid, rt << 1
 #define rson mid + 1, r, rt << 1 | 1
 using namespace std;

 const int MAXN = 3e5 + ;
 struct node{
     int v, w, next;
     node(){};
     node(int V, int W, int NEXT) : v(V), w(W), next(NEXT){};
 }edge[MAXN << ];

 int dp[MAXN << ][];
 int a[MAXN], b[MAXN], w[MAXN];
 int sum[MAXN << ], add[MAXN << ];
 int l[MAXN], r[MAXN], sol[MAXN], cnt;
 int head[MAXN], dis[MAXN], dep[MAXN], ip, indx;
 int first[MAXN], ver[MAXN << ], deep[MAXN << ];

 void init(void){
     memset(head, -, sizeof(head));
     ip = ;
     cnt = ;
     indx = ;
 }

 void addedge(int u, int v, int w){
     edge[ip] = node(v, w, head[u]);
     head[u] = ip++;
 }

 void dfs(int u, int pre, int h){
     dep[u] = h;
     ver[++indx] = u;
     deep[indx] = h;
     first[u] = indx;
     for(int i = head[u]; i != -; i = edge[i].next){
         int v = edge[i].v;
         if(v == pre) continue;
         dis[v] = dis[u] + edge[i].w;
         dfs(v, u, h + );
         ver[++indx] = u;
         deep[indx] = h;
     }
 }

 void ST(int n){
     for(int i = ; i <= n; i++){
         dp[i][] = i;
     }
     for(int j = ; ( << j) <= n; j++){
         for(int i = ; i + ( << j) -  <= n; i++){
             int x = dp[i][j - ], y = dp[i + ( << (j - ))][j - ];
             dp[i][j] = deep[x] < deep[y] ? x : y;
         }
     }
 }

 int RMQ(int l, int r){
     int len = log2(r - l + );
     int x = dp[l][len], y = dp[r - ( << len) + ][len];
     return deep[x] < deep[y] ? x : y;
 }

 int LCA(int x, int y){
     int l = first[x], r = first[y];
     if(l > r) swap(l, r);
     int pos = RMQ(l, r);
     return ver[pos];
 }

 void dfs2(int x, int pre){
     sol[++cnt] = x;
     l[x] = cnt;
     for(int i = head[x]; i != -; i = edge[i].next){
         int v = edge[i].v;
         if(v != pre) dfs2(v, x);
     }
     r[x] = cnt;
 }

 void push_up(int rt){
     sum[rt] = sum[rt << ] + sum[rt <<  | ];
 }

 void push_down(int rt, int m){
     if(add[rt]){
         add[rt << ] += add[rt];
         add[rt <<  | ] += add[rt];
         sum[rt << ] += (m - (m >> )) * add[rt];
         sum[rt <<  | ] += (m >> ) * add[rt];
         add[rt] = ;
     }
 }

 void build(int l, int r, int rt){
     add[rt] = ;
     if(l == r){
         sum[rt] = dis[sol[l]];
         return;
     }
     int mid = (l + r) >> ;
     build(lson);
     build(rson);
     push_up(rt);
 }

 void updata(int L, int R, int key, int l, int r, int rt){
     if(L <= l && R >= r){
         sum[rt] += (r - l + ) * key;
         add[rt] += key;
         return;
     }
     push_down(rt, r - l + );
     int mid = (l + r) >> ;
     if(L <= mid) updata(L, R, key, lson);
     if(R > mid) updata(L, R, key, rson);
     push_up(rt);
 }

 int query(int L, int R, int l, int r, int rt){
     if(L <= l && R >= r) return sum[rt];
     push_down(rt, r - l + );
     int mid = (l + r) >> ;
     int ans = ;
     if(L <= mid) ans += query(L, R, lson);
     if(R > mid) ans += query(L, R, rson);
     return ans;
 }

 int main(void){
     int n, q, s, x, y, z, op;
     while(~scanf("%d%d%d", &n, &q, &s)){
         init();
         for(int i = ; i < n; i++){
             scanf("%d%d%d", &x, &y, &z);
             addedge(x, y, z);
             addedge(y, x, z);
             a[i] = x;
             b[i] = y;
             w[i] = z;
         }
         dis[] = ;
         dfs(, -, );
         ST(indx);
         dfs2(, -);
         build(, cnt, );
         while(q--){
             scanf("%d", &op);
             if(!op){
                 scanf("%d", &y);
                 int lca = LCA(s, y);
                 int sol1 = query(l[s], l[s], , cnt, );
                 int sol2 = query(l[y], l[y], , cnt, );
                 int sol3 = query(l[lca], l[lca], , cnt, );
                 printf("%d\n", sol1 + sol2 -  * sol3);
                 s = y;
             }else{
                 scanf("%d%d", &x, &y);
                 int u = a[x], v = b[x], add = y - w[x];
                 int cnt2 = dep[u] > dep[v] ? u : v;
                 updata(l[cnt2], r[cnt2], add, , cnt, );
                 w[x] = y;//注意记录修改后的权值
             }
         }
     }
     return ;
 }