BZOJ 3531 （树链剖分，线段树动态开点）

首先读完题，仔细观察一下，如果按照常规写法，那么对于每一个宗教来说都应该储存当前宗教下所有城市的评价，即建立C棵线段树去维护宗教下的所有城市，但是这里如果直接开数组维护很明显会爆内存，观察到由于每个宗教来说并不是所有城市都为有效值，而只是部分城市，考虑到这一点，可以选择动态的在线段树上开结点去维护城市评价。

对于动态开结点的操作，我是这么处理的，首先开一个大数组表示结点，前100000个表示宗教的头结点，不进行申请空间，0表示终端结点下标，在update中，首先假装这个区间所有结点存在，那么向下递归一个结点，如果该结点不存在，那么申请一个空下标，并且与上一层的父节点相连接，再给这个下标赋值与更新，那么这样以来需要申请的结点最多为n*logn个，注意在每次使用完结点后需要进行清空。

#include<cstring>
#include<string>
#include<iostream>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstdlib>
#include<cmath>
#include<vector>
//#pragma comment(linker, "/STACK:1024000000,1024000000");

using namespace std;

#define INF 0x3f3f3f3f
#define maxn 200005

struct node
{
    int l,r,pos;
    long long sum;
    long long mx;
    node()
    {
        l=r=pos=0;
        sum=0;
        mx=0;
    }
} T[15*maxn];

int Len;
int fir[maxn],nex[maxn],v[maxn],e_max;
int son[maxn],fa[maxn],siz[maxn],deep[maxn],top[maxn],tot;
int pos[maxn],w[maxn],c[maxn];

template <class T>
inline bool scan_d(T &ret)
{
    char c;
    int sgn;
    if(c=getchar(),c==EOF) return 0; //EOF
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    sgn=(c=='-')?-1:1;
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    ret*=sgn;
    return 1;
}

inline void out(long long x)
{
    if(x>9) out(x/10);
    putchar(x%10+'0');
}

void init_()
{
    memset(fir,-1,sizeof fir);
    memset(son,-1,sizeof son);
    e_max=0;
    tot=1;
}

void add_edge(int s,int t)
{
    int e=e_max++;
    v[e]=t;
    nex[e]=fir[s];
    fir[s]=e;
}

void dfs1(int k,int pre,int d)
{
    deep[k]=d;
    siz[k]=1;
    fa[k]=pre;
    for(int i=fir[k]; ~i; i=nex[i])
    {
        int e=v[i];
        if(e!=pre)
        {
            dfs1(e,k,d+1);
            siz[k]+=siz[e];
            if(son[k]==-1||siz[son[k]]<siz[e]) son[k]=e;
        }
    }
}

void dfs2(int k,int sp)
{
    top[k]=sp;
    pos[k]=tot++;
    if(son[k]==-1) return ;
    dfs2(son[k],sp);
    for(int i=fir[k]; ~i; i=nex[i])
    {
        int e=v[i];
        if(e!=fa[k]&&e!=son[k])
        {
            dfs2(e,e);
        }
    }
}

void update(int &root,int val,int d,int l,int r,int k)
{
    if(!root) root=Len,T[Len].pos=Len,Len++;
    if(d==l&&r==l)
    {
        T[root].mx=val;
        T[root].sum=val;
        return ;
    }
    int mid=l+r>>1;
    if(d<=mid) update(T[root].l,val,d,l,mid,k<<1);
    else update(T[root].r,val,d,mid+1,r,k<<1|1);
    T[root].mx=max(T[T[root].l].mx,T[T[root].r].mx);
    T[root].sum=T[T[root].l].sum+T[T[root].r].sum;
}

long long query(int kind,int root,int s,int t,int l,int r,int k)
{
    if(!root) return 0;
    if(s==l&&r==t)
    {
        if(!kind) return T[root].mx;
        return T[root].sum;
    }
    int mid=l+r>>1;
    if(t<=mid) return query(kind,T[root].l,s,t,l,mid,k<<1);
    else if(s>mid) return query(kind,T[root].r,s,t,mid+1,r,k<<1|1);
    else
    {
        if(!kind) return max(query(kind,T[root].l,s,mid,l,mid,k<<1),query(kind,T[root].r,mid+1,t,mid+1,r,k<<1|1));
        else return query(kind,T[root].l,s,mid,l,mid,k<<1)+query(kind,T[root].r,mid+1,t,mid+1,r,k<<1|1);
    }
}

long long Query1(int s,int t)
{
    long long sum=0;
    int m=c[s];
    int f1=top[s],f2=top[t];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2]) swap(f1,f2),swap(s,t);
        sum+=query(1,T[m].pos,pos[f1],pos[s],1,tot-1,1);
        s=fa[f1];
        f1=top[s];
    }
    if(deep[s]>deep[t]) swap(s,t);
    sum+=query(1,T[m].pos,pos[s],pos[t],1,tot-1,1);
    return sum;
}

long long Query2(int s,int t)
{
    int m=c[s];
    long long ans=0;
    int f1=top[s],f2=top[t];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2]) swap(f1,f2),swap(s,t);
        ans=max(ans,query(0,T[m].pos,pos[f1],pos[s],1,tot-1,1));
        s=fa[f1];
        f1=top[s];
    }
    if(deep[s]>deep[t]) swap(s,t);
    ans=max(ans,query(0,T[m].pos,pos[s],pos[t],1,tot-1,1));
    return ans;
}

int main()
{
    int n,m;
    while(scan_d(n)&&scan_d(m))
    {
        init_();
        for(int i=1; i<=n; i++)
        {
            scan_d(w[i]);
            scan_d(c[i]);
        }
        for(int i=1; i<n; i++)
        {
            int a,b;
            scan_d(a);
            scan_d(b);
            add_edge(a,b);
            add_edge(b,a);
        }
        dfs1(n/2+1,-1,1);
        dfs2(n/2+1,n/2+1);
        Len=100001;
        for(int i=1; i<=n; i++)
        {
            update(T[c[i]].pos,w[i],pos[i],1,tot-1,1);
        }
        while(m--)
        {
            char s[10];
            int l,r;
            scanf("%s",s);
            if(!strcmp(s,"QS"))
            {
                int x,y;
                scan_d(x);
                scan_d(y);
                long long ans=Query1(x,y);
                out(ans);
                puts("");
            }
            else if(!strcmp(s,"CC"))
            {
                int x,y;
                scan_d(x);
                scan_d(y);
                update(T[c[x]].pos,0,pos[x],1,tot-1,1);
                update(T[y].pos,w[x],pos[x],1,tot-1,1);
                c[x]=y;
            }
            else if(!strcmp(s,"CW"))
            {
                int x,y;
                scan_d(x);
                scan_d(y);
                update(T[c[x]].pos,y,pos[x],1,tot-1,1);
                w[x]=y;
            }
            else if(!strcmp(s,"QM"))
            {
                int x,y;
                scan_d(x);
                scan_d(y);
                long long ans=Query2(x,y);
                out(ans);
                puts("");
            }
        }
        for(int i=0; i<=Len; i++)
        {
            T[i].l=T[i].r=T[i].pos=0;
            T[i].mx=T[i].sum=0;
        }
    }
    return 0;
}