Jiu Yuan Wants to Eat【2018焦作网络赛】【树链剖分】

题目链接

树链剖分学习笔记，可以看这里

---

  这道题还真挺好的，以前不会做，现在想了发现，学过树链剖分之后，剩下的部分就是处理去反那块比较的不容易些了，但是想了一下午，现在还是给我敲出来了，我们主要难处理的就是关于求反，那么怎么处理求反？

  一开始读题的时候，我还在想，是不是求反是与此数的最大2次幂系数开始，后来推了测试样例，发现，是直接对64为比特位都求反，那么我们似乎可以推一个公式了，因为2^64-1就是满unsigned long long，而且之前用过无符号类型就是在哈希里，它会在满了之后自动向前重新开始，所以相当于是在自动取模，那么，怎么处理去反呢？

  去反可以看作111111......11111-X，那么，换句话说，不就是相当于想乘以“-1”在加上unsigned long long的满值吗？那么建树不就是完成了吗？

---

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 1e5+5;
const ull INF=(ull)0-(ull)1;
int N, Q, cnt, head[maxN], root[maxN], depth[maxN], size[maxN], W_son[maxN], top[maxN], id[maxN], num;
ull tree[maxN<<2], lazy[maxN<<2], mult[maxN<<2];
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
}edge[maxN<<1];
void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
}
void dfs1(int u, int fa, int deep)
{
    root[u] = fa;
    depth[u] = deep;
    size[u] = 1;
    int maxxSon = -1;
    for(int i=head[u]; i!=-1; i=edge[i].nex)
    {
        int v = edge[i].to;
        if(v == fa) continue;
        dfs1(v, u, deep+1);
        size[u] += size[v];
        if(maxxSon < size[v])
        {
            maxxSon = size[v];
            W_son[u] = v;
        }
    }
}
void dfs2(int x, int topf)
{
    top[x] = topf;
    id[x] = ++num;
    if(!W_son[x]) return;
    dfs2(W_son[x], topf);
    for(int i=head[x]; i!=-1; i=edge[i].nex)
    {
        int y = edge[i].to;
        if(y==W_son[x] || y==root[x]) continue;
        dfs2(y, y);
    }
}
void buildTree(int rt, int l, int r)
{
    lazy[rt] = 0;   mult[rt] = 1;
    if(l == r)
    {
        tree[rt] = 0;
        return;
    }
    int mid = (l + r)>>1;
    buildTree(rt<<1, l, mid);
    buildTree(rt<<1|1, mid+1, r);
    tree[rt] = 0;
}
void pushup(int rt)
{
    tree[rt] = tree[rt<<1] + tree[rt<<1|1];
}
void pushdown(int rt, int l, int r)
{
    if(mult[rt]!=1)
    {
        mult[rt<<1]*=mult[rt];  lazy[rt<<1]*=mult[rt];
        mult[rt<<1|1]*=mult[rt];    lazy[rt<<1|1]*=mult[rt];
        tree[rt<<1]*=mult[rt];
        tree[rt<<1|1]*=mult[rt];
        mult[rt] = 1;
    }
    if(lazy[rt])
    {
        lazy[rt<<1] += lazy[rt];
        lazy[rt<<1|1] += lazy[rt];
        int mid = (l + r)>>1;
        tree[rt<<1] += lazy[rt]*(mid - l + 1);
        tree[rt<<1|1] += lazy[rt]*(r - mid);
        lazy[rt] = 0;
    }
}
void update_add(int rt, int l, int r, int ql, int qr, ull val)
{
    if(ql<=l && qr>=r)
    {
        lazy[rt] += val;
        tree[rt] += val*(r - l + 1);
        return;
    }
    int mid = (l + r)>>1;
    pushdown(rt, l, r);
    if(ql>mid) update_add(rt<<1|1, mid+1, r, ql, qr, val);
    else if(qr<=mid) update_add(rt<<1, l, mid, ql, qr, val);
    else
    {
        update_add(rt<<1, l, mid, ql, qr, val);
        update_add(rt<<1|1, mid+1, r, ql, qr, val);
    }
    pushup(rt);
}
void update_multi(int rt, int l, int r, int ql, int qr, ull val)
{
    if(ql<=l && qr>=r)
    {
        lazy[rt] *= val;
        mult[rt] *= val;
        tree[rt] *= val;
        return;
    }
    pushdown(rt, l, r);
    int mid = (l + r)>>1;
    if(ql>mid) update_multi(rt<<1|1, mid+1, r, ql, qr, val);
    else if(qr<=mid) update_multi(rt<<1, l, mid, ql, qr, val);
    else
    {
        update_multi(rt<<1, l, mid, ql, qr, val);
        update_multi(rt<<1|1, mid+1, r, ql, qr, val);
    }
    pushup(rt);
}
void update_Range_add(int x, int y, ull val)
{
    while(top[x] != top[y])
    {
        if(depth[top[x]] < depth[top[y]]) swap(x, y);
        update_add(1, 1, N, id[top[x]], id[x], val);
        x = root[top[x]];
    }
    if(depth[x] > depth[y]) swap(x, y);
    update_add(1, 1, N, id[x], id[y], val);
}
void update_Range_Multi(int x, int y, ull val)
{
    while(top[x] != top[y])
    {
        if(depth[top[x]] < depth[top[y]]) swap(x, y);
        update_multi(1, 1, N, id[top[x]], id[x], val);
        x = root[top[x]];
    }
    if(depth[x] > depth[y]) swap(x, y);
    update_multi(1, 1, N, id[x], id[y], val);
}
ull query(int rt, int l, int r, int ql, int qr)
{
    if(ql<=l && qr>=r) return tree[rt];
    pushdown(rt, l, r);
    int mid = (l + r)>>1;
    if(ql>mid) return query(rt<<1|1, mid+1, r, ql, qr);
    else if(qr<=mid) return query(rt<<1, l, mid, ql, qr);
    else
    {
        ull ans = query(rt<<1, l, mid, ql, qr);
        ans += query(rt<<1|1, mid+1, r, ql, qr);
        return ans;
    }
}
ull query_Range(int x, int y)
{
    ull ans = 0;
    while(top[x] != top[y])
    {
        if(depth[top[x]] < depth[top[y]]) swap(x, y);
        ans += query(1, 1, N, id[top[x]], id[x]);
        x = root[top[x]];
    }
    if(depth[x] > depth[y]) swap(x, y);
    ans += query(1, 1, N, id[x], id[y]);
    return ans;
}
void init()
{
    cnt = num = 0;
    memset(head, -1, sizeof(head));
    memset(W_son, 0, sizeof(W_son));
}
int main()
{
    while(scanf("%d", &N)!=EOF)
    {
        init();
        for(int i=2; i<=N; i++)
        {
            int e1; scanf("%d", &e1);
            addEddge(i, e1);
            addEddge(e1, i);
        }
        dfs1(1, 1, 0);
        dfs2(1, 1);
        buildTree(1, 1, N);
        scanf("%d", &Q);
        while(Q--)
        {
            int op, u, v;
            ull x;
            scanf("%d", &op);
            if(op == 1)
            {
                scanf("%d%d%llu", &u, &v, &x);
                update_Range_Multi(u, v, x);
            }
            else if(op == 2)
            {
                scanf("%d%d%llu", &u, &v, &x);
                update_Range_add(u, v, x);
            }
            else if(op == 3)
            {
                scanf("%d%d", &u, &v);
                update_Range_Multi(u, v, -1);
                update_Range_add(u, v, INF);
            }
            else
            {
                scanf("%d%d", &u, &v);
                printf("%llu\n", query_Range(u, v));
            }
        }
    }
    return 0;
}