树链剖分模板题+模板

FJUTOJ2790

这个题贼麻烦 要线段树这么多功能   这颗线段树现在已经同时具备了区间加区间开根区间赋值区间求和区间最大区间最小

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int N=1e4+7;

int n;

int id[N],prid[N],deep[N],fa[N],Size[N],son[N],top[N],tot;

inline char getcharc()
{
    static const int BUFSIZE=100001;
    static char buf[BUFSIZE],*psta=buf,*pend=buf;
    if(psta==pend)
    {
        psta=buf;
        pend=buf+fread(buf,1,BUFSIZE,stdin);
        if(psta==pend)
            return -1;
    }
    return *psta++;
}

float SqrtByCarmack( float number )
{
    int i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( int * ) &y;
    i  = 0x5f375a86 - ( i >> 1 );
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );
    y  = y * ( threehalfs - ( x2 * y * y ) );
    y  = y * ( threehalfs - ( x2 * y * y ) );
    return number*y;
}
inline void nextInt(int &x) {//读取一个整型

    char c;
    do c=getcharc(); while (c<'0'||c>'9');
    x=c-'0';
    while ('0'<=(c=getcharc())&&c<='9') x=x*10+c-'0';
}
inline void nextInt(long long &x) {//读取一个整型

    char c;
    do c=getcharc(); while (c<'0'||c>'9');
    x=c-'0';
    while ('0'<=(c=getcharc())&&c<='9') x=x*10+c-'0';
}
struct Segment_tree
{
    struct Node
    {
        long long val,Max,lazy,Min,lazyf;
        int Size,son[2];
        void init()
        {
            lazy=son[0]=son[1]=Size=val=Max=val=lazyf=0;
        }
    } T[N*4];
    int cnt,root;

    void init(int l,int r,long long *a)
    {
        cnt=0;
        root=build(l,r,a);
    }

    inline void update(int pos)
    {
        if(T[pos].Size==1)return ;
        T[pos].val=T[T[pos].son[0]].val+T[T[pos].son[1]].val;
        T[pos].Max=max(T[T[pos].son[0]].Max,T[T[pos].son[1]].Max);
        T[pos].Min=min(T[T[pos].son[0]].Min,T[T[pos].son[1]].Min);
    }

    inline void pushdown(int pos)
    {
        int lc=T[pos].son[0],rc=T[pos].son[1];
        if(T[pos].lazyf)
        {
            if(lc)
            {
                T[lc].lazyf=T[pos].lazyf;
                T[lc].val=T[pos].lazyf*T[lc].Size;
                T[lc].Max=T[lc].Min=T[pos].lazyf;
                T[lc].lazy=0;
            }
            if(rc)
            {
                T[rc].lazyf=T[pos].lazyf;
                T[rc].val=T[pos].lazyf*T[rc].Size;
                T[rc].Max=T[rc].Min=T[pos].lazyf;
                T[rc].lazy=0;
            }
            T[pos].lazyf=0;
        }
        if(T[pos].lazy)
        {
            if(lc)
            {
                T[lc].lazy+=T[pos].lazy;
                T[lc].val+=T[pos].lazy*T[lc].Size;
                T[lc].Max+=T[pos].lazy;
                T[lc].Min+=T[pos].lazy;
            }
            if(rc)
            {
                T[rc].lazy+=T[pos].lazy;
                T[rc].val+=T[pos].lazy*T[rc].Size;
                T[rc].Max+=T[pos].lazy;
                T[rc].Min+=T[pos].lazy;
            }
            T[pos].lazy=0;
        }
    }

    inline int build(int l,int r,long long *a)
    {
        long long pos=++cnt;
        T[pos].init();
        T[pos].Size=r-l+1;
        if(l==r)
        {
            T[pos].val=a[l];
            T[pos].Max=a[l];
            T[pos].Min=a[l];
            return pos;
        }
        int mid=(l+r)>>1;
        T[pos].son[0]=build(l,mid,a);
        T[pos].son[1]=build(mid+1,r,a);
        update(pos);
        return pos;
    }

    void add(int L,int R,int l,int r,long long v,int pos=1)
    {
        if(L==l&&R==r)
        {
            T[pos].val+=v*(r-l+1);
            T[pos].lazy+=v;
            T[pos].Max+=v;
            T[pos].Min+=v;
            return ;
        }
        pushdown(pos);
        int mid=(L+R)>>1;
        if(r<=mid)
            add(L,mid,l,r,v,T[pos].son[0]);
        else if(l>mid)
            add(mid+1,R,l,r,v,T[pos].son[1]);
        else
        {
            add(L,mid,l,mid,v,T[pos].son[0]);
            add(mid+1,R,mid+1,r,v,T[pos].son[1]);
        }
        update(pos);
    }

    void cover(int L,int R,int l,int r,long long v,int pos=1)
    {
        if(L==l&&R==r)
        {
            T[pos].lazyf=v;
            T[pos].val=T[pos].lazyf*T[pos].Size;
            T[pos].Max=T[pos].lazyf;
            T[pos].Min=T[pos].lazyf;
            T[pos].lazy=0;
            return ;
        }
        pushdown(pos);
        int mid=(L+R)>>1;
        if(r<=mid)
            cover(L,mid,l,r,v,T[pos].son[0]);
        else if(l>mid)
            cover(mid+1,R,l,r,v,T[pos].son[1]);
        else
        {
            cover(L,mid,l,mid,v,T[pos].son[0]);
            cover(mid+1,R,mid+1,r,v,T[pos].son[1]);
        }
        update(pos);
    }

    void qrt(int L,int R,int l,int r,int pos=1)
    {
        if(r==R&&l==L&&(int)(SqrtByCarmack(T[pos].Max)+0.0001)==(int)(SqrtByCarmack(T[pos].Min)+0.0001))
        {
            cover(L,R,l,r,SqrtByCarmack(T[pos].Max)+0.0001,pos);
            return ;
        }
        if(r==R&&l==L&&T[pos].Max-T[pos].Min<=1)
        {
            add(L,R,l,r,(int)(SqrtByCarmack(T[pos].Max)+0.0001)-T[pos].Max,pos);
            return ;
        }
        pushdown(pos);
        int mid=(L+R)>>1;
        if(r==R&&l==L)
        {
            qrt(L,mid,l,mid,T[pos].son[0]);
            qrt(mid+1,R,mid+1,r,T[pos].son[1]);
        }
        else if(r<=mid)
            qrt(L,mid,l,r,T[pos].son[0]);
        else if(l>mid)
            qrt(mid+1,R,l,r,T[pos].son[1]);
        else
        {
            qrt(L,mid,l,mid,T[pos].son[0]);
            qrt(mid+1,R,mid+1,r,T[pos].son[1]);
        }
        update(pos);
    }

    long long query_Sum(int L,int R,int l,int r,int pos=1)
    {
        if(L==l&&R==r)
        {
            return T[pos].val;
        }
        pushdown(pos);
        int mid=(L+R)>>1;
        if(r<=mid)
            return query_Sum(L,mid,l,r,T[pos].son[0]);
        else if(l>mid)
            return query_Sum(mid+1,R,l,r,T[pos].son[1]);
        else
            return query_Sum(L,mid,l,mid,T[pos].son[0])+query_Sum(mid+1,R,mid+1,r,T[pos].son[1]);
    }
}tree;
int first[N],sign;
struct node
{
    int to,next;
}edge[N*4];
void creat()
{
    memset(first,0,sizeof(first));
    sign=1;
}
void add_edge(int from,int to)
{
    edge[sign].to=to;
    edge[sign].next=first[from];
    first[from]=sign++;
}

void dfs1(int now,int pre,int d)
{
    deep[now]=d,fa[now]=pre,Size[now]=1;
    for(int i=first[now];i;i=edge[i].next)
    {
        int to=edge[i].to;;
        if(to==pre)continue;
        dfs1(to,now,d+1);
        Size[now]+=Size[to];
        if(!son[now]||Size[to]>Size[son[now]])
            son[now]=to;
    }
}
void dfs2(int now,int Top)
{
    top[now]=Top,id[now]=++tot;
    prid[id[now]]=now;
    if(!son[now])return ;
    dfs2(son[now],Top);
    for(int i=first[now];i;i=edge[i].next)
    {
        int to=edge[i].to;
        if(to!=son[now]&&to!=fa[now])
        {
            dfs2(to,to);
        }

    }
}

long long tree_query(int x,int y)
{
    int f1=top[x],f2=top[y];
    long long ans=0;
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2])swap(f1,f2),swap(x,y);

        ans+=tree.query_Sum(1,n,id[f1],id[x]);
        x=fa[f1],f1=top[x];
    }
    ans+=(deep[x]>deep[y])?tree.query_Sum(1,n,id[y],id[x]):tree.query_Sum(1,n,id[x],id[y]);
    return ans;
}

void tree_add(int x,int y,long long v)
{
    int f1=top[x],f2=top[y];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2])swap(f1,f2),swap(x,y);
        tree.add(1,n,id[f1],id[x],v);
        x=fa[f1],f1=top[x];
    }
    deep[x]>deep[y]?tree.add(1,n,id[y],id[x],v):tree.add(1,n,id[x],id[y],v);
}

void tree_sqrt(int x,int y)
{
    int f1=top[x],f2=top[y];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2])swap(f1,f2),swap(x,y);
        tree.qrt(1,n,id[f1],id[x]);
        x=fa[f1],f1=top[x];
    }
    deep[x]>deep[y]?tree.qrt(1,n,id[y],id[x]):tree.qrt(1,n,id[x],id[y]);
}

long long a[N];

int main()
{
    //freopen("test.txt","r",stdin);
    //freopen("output1.txt","w",stdout);
    int q;
    nextInt(n),nextInt(q);
    creat();
    int x,y;
    for(int i=1;i<n;i++)
    {
        nextInt(x),nextInt(y);
        add_edge(x,y);
        add_edge(y,x);
    }
    dfs1(1,0,1);
    dfs2(1,1);
    for(int i=1;i<=n;i++)
        nextInt(a[id[i]]);
    tree.init(1,n,a);
    long long op,v;
    while(q--)
    {
        nextInt(op);
        if(op==1)
        {
            nextInt(x);
            nextInt(y);
            nextInt(v);
            tree_add(x,y,v);
        }
        else if(op==2)
        {
            nextInt(x);
            nextInt(y);
            tree_sqrt(x,y);
        }
        else
        {
            nextInt(x);
            nextInt(y);
            printf("%lld
",tree_query(x,y));
        }
    }
    return 0;
}