[ZJOI2008]树的统计Count（点权树链剖分（模板已完善））

最新推荐文章于 2020-04-11 21:33:29 发布

林下的码路

最新推荐文章于 2020-04-11 21:33:29 发布

阅读量485

点赞数

分类专栏：线段树哈希递归 ACM DFS 文章标签： ACM 算法 dfs

本文链接：https://blog.csdn.net/Enjoying_Science/article/details/48162833

版权

ACM 同时被 3 个专栏收录

521 篇文章 1 订阅

订阅专栏

DFS

63 篇文章 0 订阅

订阅专栏

递归

56 篇文章 0 订阅

订阅专栏

Link：http://www.lydsy.com/JudgeOnline/problem.php?id=1036

1036: [ZJOI2008]树的统计Count

Time Limit: 10 Sec Memory Limit: 162 MB
Submit: 8605 Solved: 3519
[ Submit][ Status][ Discuss]

Description

一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 III. QSUM u v: 询问从点u到点v的路径上的节点的权值和注意：从点u到点v的路径上的节点包括u和v本身

Input

输入的第一行为一个整数n，表示节点的个数。接下来n – 1行，每行2个整数a和b，表示节点a和节点b之间有一条边相连。接下来n行，每行一个整数，第i行的整数wi表示节点i的权值。接下来1行，为一个整数q，表示操作的总数。接下来q行，每行一个操作，以“CHANGE u t”或者“QMAX u v”或者“QSUM u v”的形式给出。对于100％的数据，保证1<=n<=30000，0<=q<=200000；中途操作中保证每个节点的权值w在-30000到30000之间。

Output

对于每个“QMAX”或者“QSUM”的操作，每行输出一个整数表示要求输出的结果。

Sample Input

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

Sample Output

4
1
2
2
10
6
5
6
5
16

HINT

Source

树的分治

坑点：注意输入的点权值可能是负的！！！因为这个，WA了一发~QAQ

AC code：

#pragma comment(linker, "/STACK:1024000000,1024000000") //因OJ采用Windows系统，要加入这一行用于 进行手动扩栈，这样就不会引起爆栈  
#include<stdio.h>
#include<string.h>
#include<vector>
const int N=50015;
using namespace std;
 
int head[N], to[N << 1], next1[N << 1], tot;//边信息 
int top[N];    //top[v]=u表示点v,u在一个链中，且u是这个链深度最小的点（即顶端）
int fath[N];   //记录父节点
int deep[N];   //每个点在树上的深度
int num[N];    //每棵子树的节点个数
int son[N];    //选的重边子节点
int p[N];      //树上每个点在线段树中所对应的点
int pos;       //线段树叶子结点总数 
 
void addEdge(const int& u, const int& v) {
  to[tot] = v, next1[tot] = head[u], head[u] = tot++;
}
 
void addUndirEdge(const int& u, const int& v) {
  addEdge(u, v), addEdge(v, u);
}
 
void init(int n)
{
    pos=0; tot=0;
    memset(son,-1,sizeof(son));
    memset(head,-1,sizeof(head));
}
void dfs1(int u,int pre,int d)//第一遍dfs求出fath,deep,num,son
{
    deep[u]=d; fath[u]=pre; num[u]=1;
    for (int i = head[u]; i != -1; i = next1[i]) {
    int v = to[i];
        if(v==pre)continue;
        dfs1(v,u,d+1);
        num[u]+=num[v];
        if(son[u]==-1||num[v]>num[son[u]])
            son[u]=v;
    }
}
void getpos(int u,int root)
{
    top[u]=root;
    p[u]=++pos;//从1开始  
    if(son[u]==-1)
        return ;
    getpos(son[u],root);
    for (int i = head[u]; i != -1; i = next1[i]) {
    int v = to[i];
        if(son[u]!=v&&v!=fath[u])
            getpos(v,v);
    }
}
 
//线段树
struct tree
{
    int sum,maxv,toc,addc;//区间和，区间最大值， 
 }root[N*4];
int val[N];//权值 
int MAX(int a,int b)
{
    return a>b?a:b;
}
void build(int l,int r,int k)//建树，范围为l~r，k为根节点的线段树。  build(1,pos,1);
{
    int mid=(l+r)/2;
    root[k].addc=0;
    root[k].toc=0;
    if(l==r){
        root[k].sum=root[k].maxv=val[l]; return ;
    }
    build(l,mid,k<<1);
    build(mid+1,r,k<<1|1);
    root[k].sum=root[k<<1].sum+root[k<<1|1].sum;
    root[k].maxv=MAX(root[k<<1].maxv,root[k<<1|1].maxv);
}
void upson(int k,int l,int r)//更新儿子 
{
    int mid=(l+r)/2;
    if(root[k].toc)
    {
        root[k<<1].sum=(mid-l+1)*root[k].toc;
        root[k<<1].maxv=root[k].toc;
        root[k<<1].toc=root[k].toc;
        root[k<<1].addc=0;
 
        root[k<<1|1].sum=(r-mid)*root[k].toc;
        root[k<<1|1].maxv=root[k].toc;
        root[k<<1|1].toc=root[k].toc;
        root[k<<1|1].addc=0;
        root[k].toc=0;
    }
 
    if(root[k].addc)
    {
        root[k<<1].sum+=(mid-l+1)*root[k].addc;
        root[k<<1].maxv+=root[k].addc;
        root[k<<1].addc+=root[k].addc;
 
        root[k<<1|1].sum+=(r-mid)*root[k].addc;
        root[k<<1|1].maxv+=root[k].addc;
        root[k<<1|1].addc+=root[k].addc;
        root[k].addc=0;
    }
}
void updata1(int l,int r,int k,const int L,const int R,int c)//从范围为1(l)~pos（r），根节点为1（k）的线段树中更新 成段更新的区间位置为（L,R）的元素值为c
{
				                                       
    if(L<=l&&r<=R)
    {
        root[k].sum=(r-l+1)*c; root[k].maxv=c;
        root[k].toc=c; root[k].addc=0;
        return ;
    }
    int mid=(l+r)/2;
    upson(k,l,r);
 
    if(L<=mid)
        updata1(l,mid,k<<1,L,R,c);
    if(mid<R)
        updata1(mid+1,r,k<<1|1,L,R,c);
    root[k].sum=root[k<<1].sum+root[k<<1|1].sum;
    root[k].maxv=MAX(root[k<<1].maxv,root[k<<1|1].maxv);
}
void updata2(int l,int r,int k, int L, int R,int c)//从范围为1(l)~pos（r），根节点为1（k）的线段树中更新 成段更新的区间位置为（L,R）的元素值为原来的值加上增量c
{
    if(L<=l&&r<=R)
    {
        root[k].sum+=(r-l+1)*c; root[k].maxv+=c;
        root[k].addc+=c;
        return ;
    }
    int mid=(l+r)/2;
    upson(k,l,r);
 
    if(L<=mid)
        updata2(l,mid,k<<1,L,R,c);
    if(mid<R)
        updata2(mid+1,r,k<<1|1,L,R,c);
    root[k].sum=root[k<<1].sum+root[k<<1|1].sum;
    root[k].maxv=MAX(root[k<<1].maxv,root[k<<1|1].maxv);
}
int sum,maxv;
void query(int l,int r,int k,int L,int R)//查询范围为1(l)~pos（r），根节点为1（k）的线段树[L,R]区间的和（全局变量sum）与最大值（全局变量maxv） 
{
    if(L<=l&&r<=R)
    {
        sum+=root[k].sum;
        maxv=MAX(maxv,root[k].maxv);
        return ;
    }
    int mid=(l+r)/2;
    upson(k,l,r);
 
    if(L<=mid)
        query(l,mid,k<<1,L,R);
    if(mid<R)
        query(mid+1,r,k<<1|1,L,R);
}
void swp(int &a,int &b)//交换a、b 
{
    int tt;
    tt=a; a=b; b=tt;
}
/* 
已经在边权查询的基础上修改好了的点权查询，实现查询u->v路径上节点的权值的和全局变量sum）、
u->v路径上节点的最大权值（全局变量maxv）其他点权查询功能在这边权的模板上依样画葫芦修改即可实现*/ 
void Operat0(int u,int v) //查询u->v路径上节点的权值的和全局变量sum）、u->v路径上节点的最大权值（全局变量maxv）  
{
    int f1=top[u], f2=top[v];
    sum=0; maxv=-999999999;
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2])
        {
            swp(f1,f2); swp(u,v);
        }
        query(1,pos,1,p[f1],p[u]);//对应查询范围为1(l)~pos（r），根节点为1（k）的线段树[L,R]区间的和（全局变量sum）与最大值（全局变量maxv） 
        u=fath[f1]; f1=top[u];
    }
    //if(u==v) return ;//点权查询与边权查询的区别之一:若是点权查询，则这一句要注释掉！！！ 
    if(deep[u]>deep[v]) swp(u,v);
    //query(1,pos,1,p[son[u]],p[v]);//边权查询用这句，若是点权查询则用下一句代码 
    query(1,pos,1,p[u],p[v]);//点权查询与边权查询的区别之一:点p[u]，边p[son[u]]  
}
/* 在边权查询的基础上修改好了的点权查询 */ 
void Operat1(int u,int v,int c)//表示从u点到v点的路径的每条边权都变成c
{
    int f1=top[u], f2=top[v];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2])
        {
            swp(f1,f2); swp(u,v);
        }
        updata1(1,pos,1,p[f1],p[u],c);//对应从范围为1(l)~pos（r），根节点为1（k）的线段树中更新 成段更新的区间位置为（p[f1],p[u]）的元素值为c
        u=fath[f1]; f1=top[u];
    }
    //if(u==v) return ;//点权更新与边权更新的区别之一:若是点权更新，则这一句要注释掉！！！
    if(deep[u]>deep[v]) swp(u,v);
    //updata1(1,pos,1,p[son[u]],p[v],c);//边权更新用这句，若是点权更新则用下一句代码 
    updata1(1,pos,1,p[u],p[v],c);//点权更新与边权更新的区别之一:点p[u]，边p[son[u]]  
}
/* 
已经在边权更新的基础上修改好了的点权更新，实现从u点到v点的路径的每个点都加上c，其
他点权更新功能在这边权的模板上依样画葫芦修改即可实现*/ 
void Operat2(int u,int v,int c)//表示从u点到v点的路径的每个点都加上c
{
    int f1=top[u], f2=top[v];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2])
        {
            swp(f1,f2); swp(u,v);
        }
        updata2(1,pos,1,p[f1],p[u],c);//对应从范围为1(l)~pos（r），根节点为1（k）的线段树中更新 成段更新的区间位置为（p[f1],p[u]）的元素值为原来的值加上增量c
        u=fath[f1]; f1=top[u];//向上迭代 
    }
    //if(u==v) return ;//点权更新与边权更新的区别之一:若是点权更新，则这一句要注释掉！！！ 
    if(deep[u]>deep[v]) swp(u,v);
    //updata2(1,pos,1,p[son[u]],p[v],c);//边权更新用这句，若是点权更新则用下一句代码 
    updata2(1,pos,1,p[u],p[v],c);//点权更新与边权更新的区别之一:点p[u]，边p[son[u]]  
}
/* 
在边权更新的基础上修改好了的点权更新 */ 
struct EDG
{
    int u,v,c;
}edg[N];
int point[N]; 
char ope[11];
int main()
{
    int n,m,q,op,a,b;
    while(scanf("%d",&n)!=EOF)
    {
        init(n);//初始化 
        /*for(int i=1;i<n;i++)
        {
            scanf("%d%d%d",&edg[i].u,&edg[i].v,&edg[i].c);
            addUndirEdge(edg[i].u, edg[i].v);
        }*/
        m=n-1; 
       for(int i=1;i<=m;i++) //输入点权值 
       {
        	scanf("%d%d",&edg[i].u,&edg[i].v);
            addUndirEdge(edg[i].u, edg[i].v);
		}
		for(int i=1;i<=n;i++) //输入点权值 
            scanf("%d",&point[i]);  
        dfs1(1,1,1);//第一遍dfs求出fath,deep,num,son
        getpos(1,1);
        pos=n;      //线段树叶子结点总数 
        /*for(int i=1;i<n;i++)//将边的权值录入对应的线段树的位置上 
        {
            if(deep[edg[i].u]>deep[edg[i].v])
                edg[i].v=edg[i].u;
            val[p[edg[i].v]]=edg[i].c; //转换成在线段树上的对应位置  
        }*/
        for(int i=1;i<=n;i++)
        {
        	val[p[i]]=point[i];//一定要注意转换成在线段树上的对应位置  
		}
        build(1,pos,1);
        scanf("%d",&q);
        while(q--)
        {
            //scanf("%d%d%d",&op,&a,&b);
            scanf("%s%d%d",&ope,&a,&b);
            if(strcmp(ope,"QMAX")==0)
            {
                //Operat0(a,b); //查询u->v路径上节点的权值的和全局变量sum）、u->v路径上节点的最大权值（全局变量maxv）
                //printf("%d %d\n",maxv,sum);
                Operat0(a,b); 
                printf("%d\n",maxv);
            }
            //else if(op==1)
              //  updata1(1,pos,1,p[edg[a].v],p[edg[a].v],b);//从范围为1~pos，根节点为1的线段树中更新原先按顺序输入时的第a条边，将该边权值改为b 	                                          //也就是单点更新（其对应线段树成段更新的区间位置为（p[edg[a].v],p[edg[a].v]））										  
            else if(strcmp(ope,"QSUM")==0)
            {
                //int tt,c;
                //scanf("%d%d",&tt,&c);
                //if(tt==0)
                 //   Operat1(a,b,c);//表示从a点到b点的路径的每条边权都变成c
               // else
                  //  Operat2(a,b,c);//表示从a点到b点的路径的每条边权都加上c
                  Operat0(a,b); 
                  printf("%d\n",sum);
                /*if(ope[0]=='D')
				{
					c=-c;
				}
				Operat2(a,tt,c);//表示从a点到b点的路径的每个点权都加上c */
            }
            else
            {
            	Operat1(a,a,b);//表示从a点到b点的路径的每条边权都变成c
			}
        }
    }
}

林下的码路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
[ZJOI2008]树的统计Count（点权树链剖分（模板已完善））

Link：http://www.lydsy.com/JudgeOnline/problem.php?id=10361036: [ZJOI2008]树的统计CountTime Limit: 10 Sec Memory Limit: 162 MBSubmit: 8605 Solved: 3519[Submit][Status][Discuss]Description
复制链接

扫一扫