BZOJ1037 ZJOI2008 树的统计 树链剖分+线段树

1A好评……不愧是把线段树写吐的人- -

树链剖分只能用线段树来维护吗……其实静态维护区间我也只会写线段树……

树链剖分裸题不解释

#include <cstdio>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN=100000+2;
struct HASH{
	int u;
	HASH *next;
	HASH(){}
	HASH(int _u,HASH *_next):u(_u),next(_next){}
}mem[2*MAXN];
struct NODE{
	int v,son,f,c,depth,belong,mark;
	HASH *child;
}node[MAXN];
typedef struct TREE{
	int v,s,l,r,same;
	TREE *lchild,*rchild;
	TREE(){}
	TREE(int _l,int _r):l(_l),r(_r),s(0),same(INT_MIN),lchild(0),rchild(0){}
} *ROOT;
ROOT root;
int N,Q,cnt,mark[MAXN];
char s[8+2];

void Insert(int u,int v){ node[u].child=&(mem[cnt++]=HASH(v,node[u].child));}

void DFS1(int x,int f,int d){
	node[x].f=f,node[x].depth=d,node[x].c=1;

	for(HASH *p=node[x].child;p;p=p->next)
		if(p->u!=f){
			DFS1(p->u,x,d+1);
			node[x].c+=node[p->u].c;
			if(!node[x].son || node[p->u].c>node[node[x].son].c) node[x].son=p->u;
		}
}

void DFS2(int x,int b){
	node[x].belong=b,node[x].mark=++cnt,mark[cnt]=x;
	if(!node[x].son) return;
	DFS2(node[x].son,b);
	for(HASH *p=node[x].child;p;p=p->next)
		if(p->u!=node[x].f && p->u!=node[x].son) DFS2(p->u,p->u);
}

void Pushup(ROOT &x){
    x->s=x->lchild->s+x->rchild->s;
    x->v=max(x->lchild->v,x->rchild->v);
}

void Pushdown(ROOT &x,int m){
    if(x->same!=INT_MIN){
        x->lchild->v=x->rchild->v=x->same;
        x->lchild->same=x->rchild->same=x->same;
        x->lchild->s=x->same*(m-(m>>1));
        x->rchild->s=x->same*(m>>1);
        x->same=INT_MIN;
    }
}

void Build(ROOT &x,int l,int r){
	x=new TREE(l,r);
	if(l==r){
		x->s=x->v=node[mark[l]].v;
		return;
	}

	int m=(l+r)>>1;
	Build(x->lchild,l,m),Build(x->rchild,m+1,r);

	Pushup(x);
}

void Change(ROOT &x,int p,int v){
    if(x->l==x->r){
        x->v=x->same=v,x->s=v*(x->r-x->l+1);
        return;
    }

    Pushdown(x,x->r-x->l+1);

    int m=(x->l+x->r)>>1;
    if(p<=m) Change(x->lchild,p,v);
    else Change(x->rchild,p,v);

    Pushup(x);
}

int Find_Max(ROOT &x,int l,int r){
    if(x->l>=l && x->r<=r) return x->v;

    Pushdown(x,x->r-x->l+1);

    int m=(x->l+x->r)>>1,ret=INT_MIN;
    if(l<=m) ret=max(ret,Find_Max(x->lchild,l,r));
    if(r>m) ret=max(ret,Find_Max(x->rchild,l,r));

    return ret;
}

int Get_Max(int u,int v){
	int ret=INT_MIN;
	while(node[u].belong!=node[v].belong){
		if(node[node[u].belong].depth<node[node[v].belong].depth) swap(u,v);
		ret=max(ret,Find_Max(root,node[node[u].belong].mark,node[u].mark));
		u=node[node[u].belong].f;
	}

	if(node[u].depth<node[v].depth) swap(u,v);
	ret=max(ret,Find_Max(root,node[v].mark,node[u].mark));

	return ret;
}

int Find_Sum(ROOT &x,int l,int r){
    if(x->l>=l && x->r<=r) return x->s;

    Pushdown(x,x->r-x->l+1);

    int m=(x->l+x->r)>>1,ret=0;
    if(l<=m) ret+=Find_Sum(x->lchild,l,r);
    if(r>m) ret+=Find_Sum(x->rchild,l,r);

    return ret;
}

int Get_Sum(int u,int v){
    int ret=0;
    while(node[u].belong!=node[v].belong){
        if(node[node[u].belong].depth<node[node[v].belong].depth) swap(u,v);
        ret+=Find_Sum(root,node[node[u].belong].mark,node[u].mark);
        u=node[node[u].belong].f;
    }

    if(node[u].depth<node[v].depth) swap(u,v);
    ret+=Find_Sum(root,node[v].mark,node[u].mark);

    return ret;
}

int main(){
    memset(node,0,sizeof(node));
    cnt=0;

    cin >> N;
    for(int i=1,u,v;i<N;i++){
        cin >> u >> v;
        Insert(u,v),Insert(v,u);
    }
    for(int i=1;i<=N;i++) cin >> node[i].v;

    cnt=0,DFS1(1,0,0),DFS2(1,1);
    Build(root,1,cnt);

    cin >> Q;
    for(int i=1,a,b;i<=Q;i++){
        scanf("%s %d %d",s,&a,&b);
        if(strstr(s,"QMAX")) cout << Get_Max(a,b) << endl;
        if(strstr(s,"QSUM")) cout << Get_Sum(a,b) << endl;
        if(strstr(s,"CHANGE")) Change(root,node[a].mark,b);
    }

	return 0;
}