2018ICPC网络赛(焦作站)E题题解

一、题目链接

二、题意

给定一棵树，有四种操作：

$1\ u\ v\ x$：把节点$u$到$v$路径上的所有点的权值乘以$x$；

$2\ u\ v\ x$：把节点$u$到$v$路径上的所有点的权值加上$x$；

$3\ u\ v$：把节点$u$到$v$路径上的所有点的权值取反(~操作)；

$4\ u\ v$：查询节点$u$到$v$路径上的所有点的权值和；

所有操作都需要$mod\ 2^{64}$。

三、思路

操作1、2和4是很裸的树链剖分。关键是操作3。这里有个小技巧：对任意一个数字$x$取反，都等于$-(x+1)$。对于此题的$unsigned\ long\ long$类型，同样适用($-1$就是$1111\cdots1111_{(2)}=2^{64}-1$)。明白这个以后，取反操作可以变成加法和乘法。

然后要注意的是，线段树的区间加和区间乘的顺序问题，这里也有个技巧：如果区间$[l,r]$之前的和是$sum$，这个区间先加了一个$x$，再乘了一个$y$，那么可以变成$sum*y+x*y$。即让这个区间先乘一个$y$，再加上$x*y$。这样就可以保证以先乘后加的顺序不出问题了。

然后这题就愉快地AC了。

结论：对任意一个数$x$取反，无论这个数的类型是什么($int,unsigned\ int,long\ long,unsigned\ long\ long$都可以)，都等于$-(x+1)$。

四、代码

#include<bits/stdc++.h>
using namespace std;
#define MAXN 100010
typedef unsigned long long ULL;
struct edge {
    int to, next;
    edge(, ): to(to), next(next) {}
} es[MAXN * ];
int head[MAXN], ecnt;
int f[MAXN], deep[MAXN], siz[MAXN], zson[MAXN], top[MAXN], o2n[MAXN], dfscnt;
int n, q;
ULL a[MAXN];

namespace st {
    struct node {
        ULL sum, slazy, plazy;
        node(ULL a1 = , ULL a2 = , ULL a3 = ): sum(a1), slazy(a2), plazy(a3) {}
    } ns[MAXN * ];
    void init() {
        , t =  * n + ; i < t; ++i)ns[i] = node(, , );
    }
    void pushdown(int rt, int l, int r) {
        , rch = rt <<  | , mid = (l + r) >> ;
         || ns[rt].plazy != ) {
            ns[lch].sum = ns[lch].sum * ns[rt].plazy + (mid - l + ) * ns[rt].slazy;
            ns[rch].sum = ns[rch].sum * ns[rt].plazy + (r - mid) * ns[rt].slazy;
            ns[lch].plazy *= ns[rt].plazy;
            ns[rch].plazy *= ns[rt].plazy;
            ns[lch].slazy = ns[lch].slazy * ns[rt].plazy + ns[rt].slazy;
            ns[rch].slazy = ns[rch].slazy * ns[rt].plazy + ns[rt].slazy;
            ns[rt].plazy = , ns[rt].slazy = ;
        }
    }
    , , int r = n) {
        if(l > ur || r < ul)return;
        if(l >= ul && r <= ur) {
            )ns[rt].sum += x * ULL(r - l + ), ns[rt].slazy += x;
            else ns[rt].sum *= x, ns[rt].plazy *= x, ns[rt].slazy *= x;
            return;
        }
        pushdown(rt, l, r);
        ;
        , l, mid);
         | , mid + , r);
        ns[rt].sum = ns[rt << ].sum + ns[rt <<  | ].sum;
    }
    ULL query(, , int r = n) {
        if(l > qr || r < ql)return 0LL;
        if(l >= ql && r <= qr)return ns[rt].sum;
        pushdown(rt, l, r);
        ;
        ULL res = ;
        , l, mid);
         | , mid + , r);
        return res;
    }
};
void add(int from, int to) {
    es[++ecnt] = edge(to, head[from]), head[from] = ecnt;
}
void init() {
    memset(head, , ]) * (n + ));
    ecnt = ;
    memset(zson, , ]) * (n + ));
    dfscnt = ;
    st::init();
}
void dfs1(int root, int par) {
    deep[root] = deep[par] + , f[root] = par, siz[root] = ;
    ;
    for(int i = head[root]; i; i = es[i].next) {
        int to = es[i].to;
        if(to != par) {
            dfs1(to, root);
            siz[root] += siz[to];
            if(ms < siz[to]) {
                ms = siz[to], zson[root] = to;
            }
        }
    }
}
void dfs2(int root, int par, int tp) {
    top[root] = tp, o2n[root] = ++dfscnt;
    st::update(dfscnt, dfscnt, a[root], );
    if(!zson[root])return;
    dfs2(zson[root], root, tp);
    for(int i = head[root]; i; i = es[i].next) {
        int to = es[i].to;
        if(to != par && to != zson[root]) {
            dfs2(to, root, to);
        }
    }
}
void update(int u, int v, ULL x, int type) {
    int tu = top[u], tv = top[v];
    while(tu != tv) {
        if(deep[tu] >= deep[tv]) {
            st::update(o2n[tu], o2n[u], x, type);
            u = f[tu], tu = top[u];
        }
        else {
            st::update(o2n[tv], o2n[v], x, type);
            v = f[tv], tv = top[v];
        }
    }
    if(o2n[u] <= o2n[v])st::update(o2n[u], o2n[v], x, type);
    else st::update(o2n[v], o2n[u], x, type);
}
ULL query(int u, int v) {
    int tu = top[u], tv = top[v];
    ULL res = ;
    while(tu != tv) {
        if(deep[tu] >= deep[tv]) {
            res += st::query(o2n[tu], o2n[u]);
            u = f[tu], tu = top[u];
        }
        else {
            res += st::query(o2n[tv], o2n[v]);
            v = f[tv], tv = top[v];
        }
    }
    if(o2n[u] <= o2n[v])res += st::query(o2n[u], o2n[v]);
    else res += st::query(o2n[v], o2n[u]);
    return res;
}
int main() {
//    freopen("e.in","r",stdin);
    int fa, op, u, v;
    ULL x;
    while(~scanf("%d", &n)) {
        init();
        ; i <= n; ++i) {
            scanf("%d", &fa);
            add(fa, i), add(i, fa);
        }
        dfs1(, );
        dfs2(, , );
        scanf("%d", &q);
        while(q--) {
            scanf("%d", &op);
            ) {
                scanf("%d%d%llu", &u, &v, &x);
                update(u, v, x, );
            }
            ) {
                scanf("%d%d%llu", &u, &v, &x);
                update(u, v, x, );
            }
            ) {
                scanf("%d%d", &u, &v);
                update(u, v, , );
                update(u, v, -, );
            }
            else {
                scanf("%d%d", &u, &v);
                ULL res = query(u, v);
                printf("%llu\n", res);
            }
        }
    }
    ;
}