【BZOJ 4353】 Play with tree

【题目链接】

点击打开链接

【算法】

树链剖分

对于线段树的每个节点，记录这段区间的最小值，最小值的个数，值为0的个数,此外，还要维护两个懒惰标记

【代码】

本题细节很多，写程序时要认真严谨！

#include<bits/stdc++.h>
using namespace std;
#define MAXN 100010
#define MAXLOG 20
const int INF = 1e9;

int i,n,m,tot,opt,u,v,c,x,y,timer,Lca,tmp;
int dep[MAXN],dfn[MAXN],head[MAXN],size[MAXN],anc[MAXN][MAXLOG],fa[MAXN],top[MAXN],son[MAXN];

struct Edge
{
        int to,nxt;
} e[MAXN<<];

struct SegmentTree
{
        struct Node
        {
                int l,r,sum,cnt,Min,taga,tagb;
        } Tree[MAXN<<];
        inline void build(int index,int l,int r)
        {
                int mid;
                Tree[index].l = l; Tree[index].r = r;
                Tree[index].sum = Tree[index].cnt = r - l + ;
                Tree[index].taga = -;
                Tree[index].tagb = ;
                Tree[index].Min = ;
                if (l == r) return;
                mid = (l + r) >> ;
                build(index<<,l,mid);
                build(index<<|,mid+,r);
        }
        inline void pushdown(int index)
        {
                int l = Tree[index].l,r = Tree[index].r;
                int mid = (l + r) >> ;
                if (Tree[index].taga != -)
                {
                        Tree[index<<].sum = mid - l + ;
                        if (!Tree[index].taga) Tree[index<<].cnt = mid - l + ;
                        else Tree[index<<].cnt = ;
                        Tree[index<<].Min = Tree[index].taga;
                        Tree[index<<|].sum = r - mid;
                        if (!Tree[index].taga) Tree[index<<|].cnt = r - mid;
                        else Tree[index<<|].cnt = ;
                        Tree[index<<|].Min = Tree[index].taga;
                        Tree[index<<].tagb = Tree[index<<|].tagb = ;
                        Tree[index<<].taga = Tree[index<<|].taga = Tree[index].taga;
                        Tree[index].taga = -;
                }
                if (Tree[index].tagb)
                {
                        Tree[index<<].Min += Tree[index].tagb;
                        if (!Tree[index<<].Min) Tree[index<<].cnt = Tree[index<<].sum;
                        else Tree[index<<].cnt = ;
                        Tree[index<<|].Min += Tree[index].tagb;
                        if (!Tree[index<<|].Min) Tree[index<<|].cnt = Tree[index<<|].sum;
                        else Tree[index<<|].cnt = ;
                        if (Tree[index<<].taga != -) Tree[index<<].taga += Tree[index].tagb;
                        else Tree[index<<].tagb += Tree[index].tagb;
                        if (Tree[index<<|].taga != -) Tree[index<<|].taga += Tree[index].tagb;
                        else Tree[index<<|].tagb += Tree[index].tagb;
                        Tree[index].tagb = ;
                }
        }
        inline void update(int index)
        {
                Tree[index].Min = min(Tree[index<<].Min,Tree[index<<|].Min);
                Tree[index].cnt = Tree[index<<].cnt + Tree[index<<|].cnt;
                if (Tree[index<<].Min < Tree[index<<|].Min) Tree[index].sum = Tree[index<<].sum;
                else if (Tree[index<<|].Min < Tree[index<<].Min) Tree[index].sum = Tree[index<<|].sum;
                else Tree[index].sum = Tree[index<<].sum + Tree[index<<|].sum;
        }
        inline void modify(int index,int l,int r,int val)
        {
                int mid;
                if (l > r) return;
                if (Tree[index].l == l && Tree[index].r == r)
                {
                        Tree[index].Min = val;
                        Tree[index].taga = val;
                        Tree[index].tagb = ;
                        Tree[index].sum = r - l + ;
                        if (!val) Tree[index].cnt = r - l + ;
                        else Tree[index].cnt = ;
                        return;
                }
                pushdown(index);
                mid = (Tree[index].l + Tree[index].r) >> ;
                if (mid >= r) modify(index<<,l,r,val);
                else if (mid +  <= l) modify(index<<|,l,r,val);
                else
                {
                        modify(index<<,l,mid,val);
                        modify(index<<|,mid+,r,val);
                }
                update(index);
        }
        inline void add(int index,int l,int r,int val)
        {
                int mid;
                if (l > r) return;
                if (Tree[index].l == l && Tree[index].r == r)
                {
                        Tree[index].Min += val;
                        if (Tree[index].taga != -) Tree[index].taga += val;
                        else Tree[index].tagb += val;
                        if (!Tree[index].Min) Tree[index].cnt = Tree[index].sum;
                        else Tree[index].cnt = ;
                        return;
                }
                pushdown(index);
                mid = (Tree[index].l + Tree[index].r) >> ;
                if (mid >= r) add(index<<,l,r,val);
                else if (mid +  <= l) add(index<<|,l,r,val);
                else
                {
                        add(index<<,l,mid,val);
                        add(index<<|,mid+,r,val);
                }
                update(index);
        }
        inline int query_min(int index,int l,int r)
        {
                int mid;
                if (l > r) return INF;
                if (Tree[index].l == l && Tree[index].r == r) return Tree[index].Min;
                pushdown(index);
                mid = (Tree[index].l + Tree[index].r) >> ;
                if (mid >= r) return query_min(index<<,l,r);
                else if (mid +  <= l) return query_min(index<<|,l,r);
                else return min(query_min(index<<,l,mid),query_min(index<<|,mid+,r));
        }
        inline int query()
        {
                return Tree[].cnt - ;
        }
} T;
inline void add(int u,int v)
{
        tot++;
        e[tot] = (Edge){v,head[u]};
        head[u] = tot;
}
inline void dfs1(int u)
{
        int i,v;
        size[u] = ;
        anc[u][] = fa[u];
        for (i = ; i < MAXLOG; i++)
        {
                if (dep[u] < ( << i)) break;
                anc[u][i] = anc[anc[u][i-]][i-];
        }
        for (i = head[u]; i; i = e[i].nxt)
        {
                v = e[i].to;
                if (fa[u] != v)
                {
                        dep[v] = dep[u] + ;
                        fa[v] = u;
                        dfs1(v);
                        size[u] += size[v];
                        if (size[v] > size[son[u]]) son[u] = v;
                }
        }
}
inline void dfs2(int u,int tp)
{
        int i,v;
        dfn[u] = ++timer;
        top[u] = tp;
        if (son[u]) dfs2(son[u],tp);
        for (i = head[u]; i; i = e[i].nxt)
        {
                v = e[i].to;
                if (fa[u] != v && son[u] != v) dfs2(v,v);
        }
}
inline void solve1(int u,int v,int c)
{
        int tu = top[u],tv = top[v];
        while (tu != tv)
        {
                T.modify(,dfn[tv],dfn[v],c);
                v = fa[tv]; tv = top[v];
        }
        T.modify(,dfn[u]+,dfn[v],c);
}
inline void solve2(int u,int v,int c)
{
        int tu = top[u],tv = top[v];
        while (tu != tv)
        {
                T.add(,dfn[tv],dfn[v],c);
                v = fa[tv]; tv = top[v];
        }
        T.add(,dfn[u]+,dfn[v],c);
}
inline int query_min(int u,int v)
{
        int tu = top[u],tv = top[v],ans = INF;
        while (tu != tv)
        {
                ans = min(ans,T.query_min(,dfn[tv],dfn[v]));
                v = fa[tv]; tv = top[v];
        }
        ans = min(ans,T.query_min(,dfn[u]+,dfn[v]));
        return ans;
}
inline int lca(int x,int y)
{
        int i,t;
        if (dep[x] > dep[y]) swap(x,y);
        t = dep[y] - dep[x];
        for (i = ; i < MAXLOG; i++)
        {
                if (t & ( << i))
                        y = anc[y][i];
        }
        if (x == y) return x;
        for (i = MAXLOG - ; i >= ; i--)
        {
                if (anc[x][i] != anc[y][i])
                {
                        x = anc[x][i];
                        y = anc[y][i];
                }
        }
        return fa[x];
}
template <typename T> inline void read(T &x)
{
    int f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}
template <typename T> inline void write(T x)
{
    if (x < )
    {
        putchar('-');
        x = -x;
    }
    if (x > ) write(x/);
    putchar(x%+'');
}
template <typename T> inline void writeln(T x)
{
    write(x);
    puts("");
}  

int main() {

        read(n); read(m);
        for (i = ; i < n; i++)
        {
                read(x); read(y);
                add(x,y);
                add(y,x);
        }
        dfs1();
        dfs2(,);
        T.build(,,timer);
        while (m--)
        {
                read(opt);
                if (opt == )
                {
                        read(u); read(v); read(c);
                        Lca = lca(u,v);
                        solve1(Lca,u,c);
                        solve1(Lca,v,c);
                } else
                {
                        read(u); read(v); read(c);
                        Lca = lca(u,v);
                        tmp = min(query_min(Lca,u),query_min(Lca,v));
                        if (tmp + c < ) c = -tmp;
                        solve2(Lca,u,c);
                        solve2(Lca,v,c);
                }
                writeln(T.query());
        }

        return ;

}