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 + 10;
struct node{
    int v, w, next;
    node(){};
    node(int V, int W, int NEXT) : v(V), w(W), next(NEXT){};
}edge[MAXN << 1];

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

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

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 != -1; i = edge[i].next){
        int v = edge[i].v;
        if(v == pre) continue;
        dis[v] = dis[u] + edge[i].w;
        dfs(v, u, h + 1);
        ver[++indx] = u;
        deep[indx] = h;
    }
}


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

int RMQ(int l, int r){
    int len = log2(r - l + 1);
    int x = dp[l][len], y = dp[r - (1 << len) + 1][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 != -1; 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 << 1] + sum[rt << 1 | 1];
}

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

void build(int l, int r, int rt){
    add[rt] = 0;
    if(l == r){
        sum[rt] = dis[sol[l]];
        return;
    }
    int mid = (l + r) >> 1;
    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 + 1) * key;
        add[rt] += key;
        return;
    }
    push_down(rt, r - l + 1);
    int mid = (l + r) >> 1;
    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 + 1);
    int mid = (l + r) >> 1;
    int ans = 0;
    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 = 1; 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[1] = 0;
        dfs(1, -1, 1);
        ST(indx);
        dfs2(1, -1);
        build(1, cnt, 1);
        while(q--){
            scanf("%d", &op);
            if(!op){
                scanf("%d", &y);
                int lca = LCA(s, y);
                int sol1 = query(l[s], l[s], 1, cnt, 1);
                int sol2 = query(l[y], l[y], 1, cnt, 1);
                int sol3 = query(l[lca], l[lca], 1, cnt, 1);
                printf("%d
", sol1 + sol2 - 2 * 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, 1, cnt, 1);
                w[x] = y;//注意记录修改后的权值
            }
        }
    }
    return 0;
}