2019ICPC上海网络赛A 边分治+线段树

题目：

给定一棵树， 带边权。

现在有2种操作：

1.修改第i条边的权值。

2.询问u到其他一个任意点的最大距离是多少。

解法：边分治+线段树

首先我们将所有的点修改和边修改都存在对应的边里面。

然后接下来就是边分治的过程。

对于边分治的一层来说，以这条边为界分割出来。

设这条边为 x, y, w

我们把这层图上所有的边修改， 点询问都拿出来， 按照修改时间排序一下。

在切掉这条边的基础上。

然后以x为根， dfn建立一棵线段树， 记下边修改是修改在那个子树上的。

然后以y为根， dfn建立一棵线段树， 记下边修改是修改在那个子树上的。

然后对于一个修改操作来说， 就是相当于修改这颗子树的所有点的权值。

对于一个询问操作来说， 就是询问这个点到这边根的距离 + 中间这条边 + 另一边的最大值。

注意的是， 记得维护中间这条边的修改。

为了排除虚点的影响， 我就把虚点的权值设为-inf了，但是感jio是可以不用这样搞的。

总复杂度分析：

每个点只会出现在log个子图内， 每个修改和询问也最多是出现在这log个子图内。

每幅图sort + 线段树操作1次。

所以是 n * log + q * log * log。

代码：

#include<bits/stdc++.h>
using namespace std;
#define Fopen freopen("_in.txt","r",stdin); freopen("_out.txt","w",stdout);
#define LL long long
#define ULL unsigned LL
#define fi first
#define se second
#define pb push_back
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define lch(x) tr[x].son[0]
#define rch(x) tr[x].son[1]
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
typedef pair<int,int> pll;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const LL mod =  (int)1e9+;
const int N = 2e5 + ;
struct Node{
    int head[N], to[N<<], nt[N<<], ct[N<<], id[N<<];
    int tot;
    void init(){
        memset(head, -, sizeof(head));
        tot = ;
    }
    void add(int u, int v, int cost, int fid){
        ct[tot] = cost;
        to[tot] = v;
        nt[tot] = head[u];
        id[tot] = fid;
        head[u] = tot++;
    }
}e[];
int n, maxn, m, white[N], cut[N<<];
void rebuild(int o, int u){
    int ff = ;
    for(int i = e[].head[u]; ~i; i = e[].nt[i]){
        int v = e[].to[i];
        if(o == v) continue;
        if(!ff){
            e[].add(u, v, e[].ct[i], e[].id[i]);
            e[].add(v, u, e[].ct[i], e[].id[i]);
            ff = u;
        }
        else {
            ++n;
            e[].add(ff, n, , ); e[].add(n, ff, , );
            e[].add(n, v, e[].ct[i], e[].id[i]); e[].add(v, n, e[].ct[i], e[].id[i]);
            ff = n;
        }
        rebuild(u, v);
    }
}

int sz[N], minval, id;
void get_edge(int o, int u, int num){
    sz[u] = ;
    for(int i = e[].head[u]; ~i; i = e[].nt[i]){
        int v = e[].to[i];
        if(v == o || cut[i>>]) continue;
        get_edge(u, v, num);
        sz[u] += sz[v];
        int tmp = max(sz[v], num - sz[v]);
        if(tmp < minval){
            minval = tmp;
            id = i;
        }
    }
}
int k = , op;
int qtot = ;
pll P[N<<];
int L[N];
vector<pll> edge[N];
vector<pll> Que[N];
LL ans[N];
int col[N];
int ecol[N];
struct GG{
    LL a[N];
    LL seg[N<<], lazy[N<<];
    int point[N];
    int edis[N];
    int tot = ;
    int dfn[N], out[N], fdfn[N];
    void dfs(int o, int u, LL dis){
        sz[u] = ;
        dfn[u] = ++tot;
        fdfn[tot] = u;
        col[u] = op;
        if(u > maxn)
            a[tot] = -INF;
        else
            a[tot] = dis;
        for(pll & t : Que[u])
            P[++qtot] = t;
        for(int i = e[].head[u]; ~i; i = e[].nt[i]){
            int v = e[].to[i];
            if(v == o || cut[i>>]) continue;
            ecol[e[].id[i]] = op;
            point[e[].id[i]] = v;
            edis[e[].id[i]] = e[].ct[i];
            for(pll & t : edge[e[].id[i]]){
                P[++qtot] = t;
            }
            dfs(u, v, dis + e[].ct[i]);
            sz[u] += sz[v];
        }
        out[u] = tot;

    }
    void Build(int l, int r, int rt){
        lazy[rt] = ;
        if(l == r){
            seg[rt] = a[l];
            return ;
        }
        int m = l+r >> ;
        Build(lson); Build(rson);
        seg[rt] = max(seg[rt<<], seg[rt<<|]);
    }
    void Tree_Build(){
        Build(, tot, );
    }
    void PushDown(int rt){
        if(lazy[rt]){
            lazy[rt<<] += lazy[rt];
            lazy[rt<<|] += lazy[rt];
            seg[rt<<] += lazy[rt];
            seg[rt<<|] += lazy[rt];
            lazy[rt] = ;
        }
    }
    void Update(int L, int R, int C, int l, int r, int rt){
        if(L <= l && r <= R){
            seg[rt] += C;
            lazy[rt] += C;
            return ;
        }
        int m = l+r >> ;
        PushDown(rt);
        if(L <= m) Update(L, R, C, lson);
        if(m <  R) Update(L, R, C, rson);
        seg[rt] = max(seg[rt<<], seg[rt<<|]);
    }
    void Tree_Update(int id, int ct){
        int u = point[id];
        Update(dfn[u], out[u], ct-edis[id], , tot, );
        edis[id] = ct;
    }
    LL Query(int L, int l, int r, int rt){
        if(l == r) return seg[rt];
        PushDown(rt);
        int m = l+r >> ;
        if(L <= m) return Query(L, lson);
        return Query(L, rson);
    }
    LL Tree_Query(int x){
        return Query(dfn[x], , tot, );
    }
    void init(){
        tot = ;
    }
}Seg[];
void solve(int u, int num){
//    cout << u << " " << num << endl;
    if(num <= ) return ;
    minval = inf;
    get_edge(, u, num);
    int nid = id;
    cut[nid>>] = ;
    qtot = ;
    op = ;
    Seg[].init();
    Seg[].dfs(, e[].to[nid], );
    Seg[].Tree_Build();
    op = ;
    Seg[].init();
    Seg[].dfs(, e[].to[nid ^ ], );
    Seg[].Tree_Build();
    int gid = e[].id[nid];
    for(pll & t : edge[gid])
        P[++qtot] = t;
    sort(P+, P++qtot);
    for(int i = ; i <= qtot; ++i){
        if(P[i].se < ){
            int u = -P[i].se;
            if(u == gid)
                e[].ct[nid] = L[P[i].fi];
            else
                Seg[ecol[u]].Tree_Update(u, L[P[i].fi]);
        }
        else {
            int u = P[i].se;
            int id = col[u];
            ans[P[i].fi] = max(ans[P[i].fi], Seg[id].Tree_Query(u) + Seg[id^].seg[] + e[].ct[nid]);
        }
    }
    solve(e[].to[nid], sz[e[].to[nid]]);
    solve(e[].to[nid^], sz[e[].to[nid^]]);
}
int main(){
    e[].init(), e[].init();
    scanf("%d", &n);
    maxn = n;
    for(int i = , u, v, w; i < n; ++i){
        scanf("%d%d%d", &u, &v, &w);
        e[].add(u, v, w, i);
        e[].add(v, u, w, i);
    }
    int q, u;
    char s[];
    scanf("%d", &q);
    for(int i = ; i <= q; ++i){
        ans[i] = -;
        scanf("%s", s);
        if(s[] == 'Q'){
            scanf("%d", &u);
            Que[u].pb(pll(i, u));
        }
        else {
            scanf("%d%d", &u, &L[i]);
            edge[u].pb(pll(i, -u));
        }
    }
    rebuild(, );
//    cout << n << endl;
    solve(, n);
    for(int i = ; i <= q; ++i){
        if(~ans[i])
            printf("%lld\n", ans[i]);
    }
    return ;
}
/*
2
1 2 1
3
Q 1
Q 1
C 1 6
*/