主席树学习笔记 Apare_xzc

最新推荐文章于 2020-09-22 04:51:00 发布
最新推荐文章于 2020-09-22 04:51:00 发布
阅读量215 收藏 2
点赞数 1
分类专栏： Apare_xzc 解题报告 HDU 学习笔记 文章标签： 主席树 区间第K大 树上第K大 可持久化线段树 Apare_xzc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40531479/article/details/89222996
版权

主席树学习笔记

xzc 2019/4/11

  上次打武大网络赛，除了一道树上第K大的板子题，没搞出来，于是乎，我这周学了主席树，和gdl一起做了专题里的4道题目。
  今天晚上才AC了E题(终于跟上了gdl的进度)，这道题做了3天了，感觉有点儿收获，所以想记录下来

主席树专题vj链接(5道)

A.K-th Number poj-2104

分析：
求静态区间第K大(从小到大第K个)，主席树板子题

我的代码：

  我把前会长Y_Cl给的板子改成了自己的

  • 去掉了num[],直接用a[]存离散化后的值
  • 把指针的写法用数组模拟了，这样更节省空间
/*
Status：Accepted
Time：1672ms
Memory：22608kB
Length：1541
Lang：G++
Submitted：2019-04-09 20:35:24
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(register int i=(a);i>=(b);--i)
#define Mst(a,b) memset(a,(b),sizeof(a)) 
using namespace std;
const int maxn = 1e5+10;
int a[maxn],p[maxn],n,cnt;
struct Node{
	int Lchild,Rchild,sum;
}node[maxn*20];
int root[maxn*20];
int update(int left,int right,int v,int p)
{
	if(v<left||v>right) return p;
	int t = cnt++;
	node[t].Lchild = node[p].Lchild;
	node[t].Rchild = node[p].Rchild;
	node[t].sum = node[p].sum + 1;
	int mid = (left+right)>>1;
	if(left==right) return t;
	node[t].Lchild = update(left,mid,v,node[p].Lchild);
	node[t].Rchild = update(mid+1,right,v,node[p].Rchild);
	return t;
}
void build()
{
	cnt = 0;
	root[0] = cnt++;
	node[0].Lchild = node[0].Rchild = node[0].sum = 0;
	For(i,1,n) root[i] = update(1,n,a[i],root[i-1]);
}
int query(int left,int right,int k,int rx,int ry)
{
	if(left==right) return left;
	int tot = node[node[ry].Lchild].sum - node[node[rx].Lchild].sum;
	int mid = (left+right)>>1;
	if(k<=tot) return query(left,mid,k,node[rx].Lchild,node[ry].Lchild);
	else return query(mid+1,right,k-tot,node[rx].Rchild,node[ry].Rchild);
}
int main()
{
	int m;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		For(i,1,n) scanf("%d",a+i), p[i] = a[i];
		sort(p+1,p+n+1);
		For(i,1,n) a[i] = lower_bound(p+1,p+n+1,a[i])-p;
		build();
		int l,r,k;
		while(m--)
		{
			scanf("%d%d%d",&l,&r,&k);
			printf("%d\n",p[query(1,n,k,root[l-1],root[r])]);
		}
	}
	
	return 0;
}

指针写法：

/*
Accepted
1688ms
22608kB
1399
G++
2019-04-08 20:19:00
*/
Select Code
#include <iostream>
#include <cstdio>
#include <algorithm>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
using namespace std;
const int maxn = 1e5+10;
int a[maxn],p[maxn],n,cnt;
struct Node{
	Node * Lchild, * Rchild;
	int sum;
}node[maxn*20],*root[maxn*20];
Node * update(int left,int right,int v,Node * p)
{
	if(v<left||v>right) return p;
	Node * t = &node[cnt++];
	t->Lchild = p->Lchild;
	t->Rchild = p->Rchild;
	t->sum = p->sum + 1; 
	if(left==right) return t;
	int mid = (left+right)>>1;
	t -> Lchild = update(left,mid,v,p->Lchild);
	t -> Rchild = update(mid+1,right,v,p->Rchild);
	return t;	
}
void build()
{
	cnt = 0;
	root[0] = &node[cnt++];
	root[0]->Lchild = root[0]->Rchild = root[0];
	root[0]->sum = 0;
	For(i,1,n) root[i] = update(1,n,a[i],root[i-1]);
}
int query(int left,int right,int k,Node*x,Node*y)
{
	if(left==right) return left;
	int tot = y->Lchild->sum - x->Lchild->sum;
	int mid = (left+right)>>1;
	if(k<=tot) return query(left,mid,k,x->Lchild,y->Lchild);
	else return query(mid+1,right,k-tot,x->Rchild,y->Rchild);
}

int main()
{
	//freopen("in.txt","r",stdin);
	int m;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		For(i,1,n) scanf("%d",a+i), p[i] = a[i];
		sort(p+1,p+1+n);
		For(i,1,n) a[i] = lower_bound(p+1,p+1+n,a[i])-p;
		build();
		int l,r,k;
		while(m--)
		{
			scanf("%d%d%d",&l,&r,&k);
			printf("%d\n",p[query(1,n,k,root[l-1],root[r])]);
		}	
	} 
	
	return 0;	
}

B.Count on a tree spoj-COT

题意：
  询问树上第K小

分析：
  和区间第K大的思想一样，还是要离散化，区间的意义也相同。
  我们知道：一棵树上，两个结点u，v之间的距离可以用这个抽象的公式来求：
dis(u,v) = dis(u)+dis(v)-2*dis(lca(u,v))
  u,v这条路径上面包含的节点的个数可以这样计算：
num(u.v) = num(root_to_u) + num(root_to_v) - num(root_to_lca)-num(root_to_fa(lca))
  我们可以先dfs出一棵生成树，然后记录下来书上每个节点x的父节点fa[x]
  建立主席树的时候，每建一棵线段树，不是从数组a前一个点那棵树的基础上建，而是从fa[x]的基础上建树
  我求LCA的方法是dfs+RMQ

我的代码(指针写的)：

/*
Status: Accepted
Time: 1480ms
Memory: 168960kB
Length: 3254
Lang: C++ (gcc 6.3)
Submitted: 2019-04-08 21:47:25
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define Mst(a,b) memset(a,(b),sizeof(a))
using namespace std;
const int maxn = 1e5+100;
int a[maxn],p[maxn],n,cnt;
struct Edge{
	int to,Next;
}edge[maxn<<1];
int head[maxn],totEdge;
int disToRoot[maxn];
int First[maxn];
int sequence[maxn<<1];
int deep[maxn<<1];
int father[maxn];
bool vis[maxn];
struct Node{
	Node * Lchild, * Rchild;
	int sum;
}node[maxn*40],*root[maxn*40];
Node * update(int left,int right,int v,Node * p);
void build();
int query(int left,int right,int k,Node*ru,Node*rv,Node*rlca,Node*rfalca);
void initG();
void addedge(int u,int v);
void dfs(int x,int fa);
void dfs(int x,int fa,int dep,int &cntOfSeq)
{
	father[x] = fa;
	vis[x] = true;
	root[x] = update(1,n,a[x],root[fa]);
	sequence[++cntOfSeq] = x;
	deep[cntOfSeq] = dep;
	First[x] = cntOfSeq;
	for(int i=head[x];i!=-1;i=edge[i].Next)
	{
		int to = edge[i].to;
		if(vis[to]) continue;
		vis[to] = true;
		disToRoot[to] = disToRoot[x]+1;
		dfs(to,x,dep+1,cntOfSeq);
		sequence[++cntOfSeq] = x;
		deep[cntOfSeq] = dep;
	}
}
int Min[maxn<<1][20];
int Log2[maxn<<1]={-1};
void getST(int n)
{
	For(i,1,n) Min[i][0] = i;
	for(int j=1;(1<<j)<=n;++j)
	{
		for(int i=1;i+(1<<j)-1<=n;++i)
		{
			int a = Min[i][j-1];
			int b = Min[i+(1<<(j-1))][j-1];
			Min[i][j] = deep[a]>deep[b]?b:a;
		}
	}
} 
int LCA(int x,int y)
{
	x = First[x];
	y = First[y];
	if(x>y) swap(x,y);
	int j = Log2[y-x+1];
	int a = Min[x][j];
	int b = Min[y-(1<<j)+1][j];
	return deep[a]>deep[b]?sequence[b]:sequence[a];
}
int main()
{
	//freopen("in.txt","r",stdin);
	For(i,1,maxn*2-15) Log2[i] = Log2[i>>1]+1;
	int m;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		For(i,1,n) scanf("%d",a+i), p[i] = a[i];
		sort(p+1,p+1+n);
		For(i,1,n) a[i] = lower_bound(p+1,p+1+n,a[i])-p;
		int u,v;
		initG();
		For(i,2,n)
		{
			scanf("%d%d",&u,&v);
			addedge(u,v);
			addedge(v,u);
		}	
		build(); //先建一棵空树
		Mst(vis,0); 
		int cntOfSequence = 0;
		dfs(1,0,1,cntOfSequence);
		int k,lca;
		getST(2*n-1); 
		while(m--)
		{
			scanf("%d%d%d",&u,&v,&k);
			lca = LCA(u,v);
			printf("%d\n",p[query(1,n,k,root[u],root[v],root[lca],root[father[lca]])]);
		}	
	} 
	
	
	return 0;	
}

void initG()
{
	Mst(head,-1);
	totEdge = 0;
}
void addedge(int u,int v)
{
	edge[totEdge].to = v;
	edge[totEdge].Next = head[u];
	head[u] = totEdge++;
}
Node * update(int left,int right,int v,Node * p)
{
	if(v<left||v>right) return p;
	Node * t = &node[cnt++];
	t->Lchild = p->Lchild;
	t->Rchild = p->Rchild;
	t->sum = p->sum + 1; 
	if(left==right) return t;
	int mid = (left+right)>>1;
	t -> Lchild = update(left,mid,v,p->Lchild);
	t -> Rchild = update(mid+1,right,v,p->Rchild);
	return t;	
}
void build()
{
	cnt = 0;
	root[0] = &node[cnt++];
	root[0]->Lchild = root[0]->Rchild = root[0];
	root[0]->sum = 0;
}
int query(int left,int right,int k,Node*ru,Node*rv,Node *rlca,Node*rfalca)
{
	if(left==right) return left;
	int tot = ru->Lchild->sum + rv->Lchild->sum 
	     - rlca->Lchild->sum - rfalca->Lchild->sum;
	int mid = (left+right)>>1;
	if(k<=tot) 
		return query(left,mid,k,ru->Lchild,rv->Lchild,rlca->Lchild,rfalca->Lchild);
	else 
		return query(mid+1,right,k-tot,ru->Rchild,rv->Rchild,rlca->Rchild,rfalca->Rchild);
}

附：2019武大网络赛那道区间第K大(大！)

  • 区间第K大就是区间第cnt-k+1小
  • cnt = deep[u]+deep[v]-deep[lca(u,v)]-deep[fa[lca(u,v)]
  • (deep[u]为节点u在生成树中的深度)

我的代码：

/*
Apr/08/2019 22:10UTC+8	
CCNU_你们好强啊我们都是面包手	
F - Climb	
GNU C++17 Accepted	1294 ms	59200 KB
*/
Apr/09/2019 06:22UTC+8	CCNU_你们好强啊我们都是面包手	F - Climb	GNU C++17	Accepted	1294 ms	59200 KB
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define Mst(a,b) memset(a,(b),sizeof(a))
using namespace std;
const int maxn = 1e5+20;
int a[maxn],p[maxn],n,cnt;//p离散化 
struct Edge{
	int to,Next;
}edge[maxn<<1];
int head[maxn],totEdge;//邻接表 
int First[maxn],sequence[maxn<<1],deep[maxn<<1];
int father[maxn];
bool vis[maxn]; //dfs 
int Min[maxn<<1][20];
int Log2[maxn<<1]={-1};
struct Node{
	Node * Lchild, * Rchild;
	int sum;
}node[maxn*20],*root[maxn*20];
Node * update(int,int,int,Node*); 
void build(); //建第一课空树(爷爷节点) 
void initG(); //初始化邻接表 
void addedge(int u,int v);
void dfs(int x,int fa,int deep,int&);
void getST(int n); 
int LCA(int x,int y);
int query(int,int,int,Node*,Node*,Node*,Node*);
int main()
{
	//freopen("in.txt","r",stdin);
	For(i,1,maxn*2-15) Log2[i] = Log2[i>>1]+1;
	int T,m;scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&m);
		For(i,1,n) scanf("%d",a+i), p[i] = a[i];
		sort(p+1,p+1+n);
		For(i,1,n) a[i] = lower_bound(p+1,p+1+n,a[i])-p;
		int u,v;
		initG();
		For(i,2,n)
		{
			scanf("%d%d",&u,&v);
			addedge(u,v);
			addedge(v,u);
		}	
		build(); //先建一棵空树
		Mst(vis,0); 
		int cntOfSequence = 0;
		dfs(1,0,1,cntOfSequence); //dfs生成树的同时，在父节点基础上建立新的线段树 
		int k,lca;
		getST(2*n-1); //线性预处理(nlogn) 
		while(m--)
		{
			scanf("%d%d%d",&u,&v,&k); 
			lca = LCA(u,v);
			int totNum = deep[First[u]]+deep[First[v]]-deep[First[lca]]-deep[First[father[lca]]];
			if(k>totNum) //询问的K大于这条路径上所有顶点的个数 
			{
				printf("-1\n");
				continue;
			}
			k = totNum - k+1;
			printf("%d\n",p[query(1,n,k,root[u],root[v],root[lca],root[father[lca]])]);
		}	
	} 
	
	return 0;	
}

void initG()
{
	Mst(head,-1);
	totEdge = 0;
}
void addedge(int u,int v)
{
	edge[totEdge].to = v;
	edge[totEdge].Next = head[u];
	head[u] = totEdge++;
}
void dfs(int x,int fa,int dep,int &cntOfSeq)
{
	father[x] = fa;
	vis[x] = true;
	root[x] = update(1,n,a[x],root[fa]);
	sequence[++cntOfSeq] = x;
	deep[cntOfSeq] = dep;
	First[x] = cntOfSeq;
	for(int i=head[x];i!=-1;i=edge[i].Next)
	{
		int to = edge[i].to;
		if(vis[to]) continue;
		vis[to] = true;
		dfs(to,x,dep+1,cntOfSeq);
		sequence[++cntOfSeq] = x;
		deep[cntOfSeq] = dep;
	}
}
void getST(int n)
{
	For(i,1,n) Min[i][0] = i;
	for(int j=1;(1<<j)<=n;++j)
	{
		for(int i=1;i+(1<<j)-1<=n;++i)
		{
			int a = Min[i][j-1];
			int b = Min[i+(1<<(j-1))][j-1];
			Min[i][j] = deep[a]>deep[b]?b:a;
		}
	}
} 
int LCA(int x,int y)
{
	x = First[x];
	y = First[y];
	if(x>y) swap(x,y);
	int j = Log2[y-x+1];
	int a = Min[x][j];
	int b = Min[y-(1<<j)+1][j];
	return deep[a]>deep[b]?sequence[b]:sequence[a];
}
Node * update(int left,int right,int v,Node * p)
{
	if(v<left||v>right) return p;
	Node * t = &node[cnt++];
	t->Lchild = p->Lchild;
	t->Rchild = p->Rchild;
	t->sum = p->sum + 1; 
	if(left==right) return t;
	int mid = (left+right)>>1;
	t -> Lchild = update(left,mid,v,p->Lchild);
	t -> Rchild = update(mid+1,right,v,p->Rchild);
	return t;	
}
void build()
{
	cnt = 0;
	root[0] = &node[cnt++];
	root[0]->Lchild = root[0]->Rchild = root[0];
	root[0]->sum = 0;
}
int query(int left,int right,int k,Node*ru,Node*rv,Node *rlca,Node*rfalca)
{
	if(left==right) return left;
	int tot = ru->Lchild->sum + rv->Lchild->sum 
	     - rlca->Lchild->sum - rfalca->Lchild->sum;
	int mid = (left+right)>>1;
	if(k<=tot) 
		return query(left,mid,k,ru->Lchild,rv->Lchild,rlca->Lchild,rfalca->Lchild);
	else 
		return query(mid+1,right,k-tot,ru->Rchild,rv->Rchild,rlca->Rchild,rfalca->Rchild);
}

D.Super Mario HDU-4417
题意：
  一个数列，求区间内元素值<=H的个数

两种做法：

  1. 主席树
  2. 离线+线段树

主席树的代码：

/*
Status：Accepted
Time：187ms
Memory：23708kB
Length：1690
Lang：G++
Submitted：2019-04-09 21:07:54
*/
//主席树，数组模拟 
#include <bits/stdc++.h>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(register int i=(a);i>=(b);--i)
#define Mst(a,b) memset(a,(b),sizeof(a))
#define LL long long
#define MP make_pair
#define pb push_back 
using namespace std;
const int maxn = 1e5+10; 
int a[maxn],p[maxn],n,cnt;
struct Node{
	int Lchild,Rchild,sum;
}node[maxn*20];
int root[maxn*20];
int update(int left,int right,int v,int p)
{
	if(v<left||v>right) return p;
	int t = cnt++;
	node[t].Lchild = node[p].Lchild;
	node[t].Rchild = node[p].Rchild;
	node[t].sum = node[p].sum+1;
	if(left==right) return t;
	int mid = (left+right)>>1;
	node[t].Lchild = update(left,mid,v,node[p].Lchild);
	node[t].Rchild = update(mid+1,right,v,node[p].Rchild);
	return t;
} 
void build()
{
	cnt = 0;
	root[0] = cnt++;
	node[0].Lchild = node[0].Rchild = node[0].sum = 0;
	For(i,1,n) root[i] = update(1,n,a[i],root[i-1]);
}
int query(int left,int right,int qx,int qy,int rx,int ry)
{
	if(left>qy || right<qx) return 0;
	if(qx<=left&&right<=qy) return node[ry].sum - node[rx].sum;
	int mid = (left+right)>>1;
	int ansL = query( left,  mid,qx,qy,node[rx].Lchild,node[ry].Lchild);
	int ansR = query(mid+1,right,qx,qy,node[rx].Rchild,node[ry].Rchild);
	return ansL + ansR;
}

int main()
{
	//freopen("in.txt","r",stdin);
	int m,T;scanf("%d",&T);
	For(ca,1,T)
	{
		scanf("%d%d",&n,&m);
		For(i,1,n) scanf("%d",a+i), p[i] = a[i];
		sort(p+1,p+n+1);
		For(i,1,n) a[i] = lower_bound(p+1,p+n+1,a[i])-p;
		build();
		int l,r,H;
		printf("Case %d:\n",ca);
		while(m--)
		{
			scanf("%d%d%d",&l,&r,&H);
			H = upper_bound(p+1,p+n+1,H)-p-1;
			printf("%d\n",query(1,n,1,H,root[l],root[r+1]));
		}
	}

	return 0;
}

离线+线段树：

/*
Status: Accepted
Time：171ms
Memory：6236kB
Length：1892
Lang：G++
Submitted：2019-04-09 21:10:02
*/
//贴的之前erd老师课堂上写的线段树+离线
#include <bits/stdc++.h>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(register int i=(a);i>=(b);--i)
#define Mst(a,b) memset(a,(b),sizeof(a))
#define LL long long
using namespace std;
const int maxn = 1e5+100;
struct A{
	int x,id;
}a[maxn];
struct Node{
	int left,right,sum; //or id
	int mid(){return (left+right)>>1;}
}tree[maxn<<2]; 
struct Re{
	int L,R,h,id,ans;
	void input(int _id)
	{
		scanf("%d%d%d",&L,&R,&h);
		id = _id;
		++L,++R;
	}
}r[maxn];
void build(int left,int right,int pos=1)
{
	tree[pos].left = left;
	tree[pos].right = right;
	tree[pos].sum = 0;
	if(tree[pos].left==tree[pos].right) 
		return;
	int mid = (left+right)>>1;
	build(left,mid,pos<<1);
	build(mid+1,right,pos<<1|1);	
}
void Insert(int x,int pos=1)
{
	
	if(tree[pos].left==tree[pos].right)
	{
		++tree[pos].sum;
		return;
	}
		
	int mid = tree[pos].mid();
	if(x<=mid) Insert(x,pos<<1);
	else Insert(x,pos<<1|1);
	tree[pos].sum = tree[pos<<1].sum+tree[pos<<1|1].sum;
}
int quire(int left,int right,int pos=1)
{
	if(left>tree[pos].right||right<tree[pos].left)
		return 0;
	if(left<=tree[pos].left&&right>=tree[pos].right)
		return tree[pos].sum;
	int Ls = quire(left,right,pos<<1);
	int Rs = quire(left,right,pos<<1|1);
	return Ls+Rs;
}
int main()
{
	//freopen("in.txt","r",stdin);
	//freopen("out.txt","w",stdout);
	int T;scanf("%d",&T);
	int m,n;
	For(ca,1,T)
	{
		scanf("%d%d",&n,&m);
		build(1,n); 
		For(i,1,n) scanf("%d",&a[i].x),a[i].id = i;
		For(i,0,m-1)
		{
			r[i].input(i);
		}
		sort(a+1,a+n+1,[](A xa,A xb){return xa.x<xb.x;});
		sort(r,r+m,[](Re xx,Re yy){return xx.h<yy.h;});
		int k = 1;
		For(i,0,m-1) 
		{
			while(k<=n&&a[k].x<=r[i].h) Insert(a[k++].id);
			r[i].ans = quire(r[i].L,r[i].R); 
		}
		sort(r,r+m,[](Re xx,Re yy){return xx.id<yy.id;});
		printf("Case %d:\n",ca);
		For(i,0,m-1)
			printf("%d\n",r[i].ans);
	}
	
	return 0;	
}

E-To the moon HDU - 4348
题意：

  • 维护区间和
  • 一开始给出数列a[n]的初值，时间戳t为0
  • C L R add 更新操作，把数列[L,R]这部分都加上add,并且时间戳t++
  • Q L R 询问操作，询问当前时间下数列区间[L,R]的和
  • H L R h 询问操作，询问过去某个时间h(h<t)的区间和[L,R]
  • B tt 时间点回到过去的tt(tt<t)

分析：
  可持久化线段树
  每次更新(C操作)的时候，时间戳t++,新建一棵线段树，并记录线段树根节点的在内存池中的编号为root[t]
  询问H时，在root[H]的那棵线段树中查询
  询问当前区间时，在root[t]的线段树中查询
  B操作时，直接把t该为tt,然后cnt=root[tt+1]这样省空间，相当于是delete了后面的所有树(我觉得这一点我写得非常好~)
  int build(left,right)函数用于建立第一棵t=0时的树，返回值为该节点从内存池中分配的下标
  update(left,right,x,y,add,&t,p)函数用引用的方式实现了返回新分配节点的下标，这个几点表示的区间为[left,right],要更新的范围是[x,y]，都+add, t用于返回下标，p是先前时间戳为t-1时候的线段树根节点的下标
  采用永久化标记的思想，lazy不push_down；不论是更新还是查询，当前节点代表的区间[left,right]一定包含了要查询或者更新的范围[x,y]。

  • 在更新中，进入函数的节点都是包含了更新范围的，都是要新建的节点，如果两个范围下好重合，那么直接lazy+=add;return;不必再往下新建子节点了
  • 在查询中，进入函数的节点区间一定也是包含了查询范围的，如果恰好重合，那么return sum[t];不然，就分类讨论要查询区间是在左子树，还是右子树，还是跨了mid。
  • 这个[left,righy]一定包含[x,y]的性质使得我们可以直接求出lazy*(y-x+1)
程序还是跑得飞快的，空间也不多

代码：

/*
Status: Accepted
Time: 218ms
Memory: 10816kB
Length: 2608
Lang: G++
Submitted: 2019-04-11 21:40:54
*/
#include <bits/stdc++.h>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(register int i=(a);i>=(b);--i)
#define Mst(a,b) memset(a,(b),sizeof(a))
#define LL long long
#define MP make_pair
#define pb push_back
using namespace std;
const int maxn = 1e5+4;
const int N = maxn*20;
int a[maxn];
int lson[N],rson[N],root[N],n,cnt;
LL sum[N],lazy[N];
int build(int left,int right)
{
    int t = ++cnt;
    lazy[t] = 0;
    if(left==right)
    {
        sum[t] = a[left];
        return t;
    }
    int mid = (left+right)>>1;
    lson[t] = build(left,mid);
    rson[t] = build(mid+1,right);
    sum[t] = sum[lson[t]]+sum[rson[t]];
    return t;
}
void update(int left,int right,int x,int y,int add,int &t,int p)
{
    t = ++cnt; ///该区间[left,right]一定包含要更新的区间[x,y]
    lazy[t] = lazy[p];
    lson[t] = lson[p];
    rson[t] = rson[p];
    sum[t] = sum[p]+1ll*(y-x+1)*add;
    if(left==x&&right==y)
    {
        lazy[t] += add;
        return;
    }
    int mid = (left+right)>>1;
    if(y<=mid) update(left,mid,x,y,add,lson[t],lson[p]);
    else if(x>mid) update(mid+1,right,x,y,add,rson[t],rson[p]);
    else
        update(left,mid,x,mid,add,lson[t],lson[p]),
        update(mid+1,right,mid+1,y,add,rson[t],rson[p]);
}
LL query(int left,int right,int qx,int qy,int t)
{
    if(left==qx&&right==qy) return sum[t];
    LL add = lazy[t]*(qy-qx+1);
    int mid = (left+right)>>1;
    if(qy<=mid) return query(left,mid,qx,qy,lson[t])+add;
    else if(qx>mid) return query(mid+1,right,qx,qy,rson[t])+add;
    else return
        query(left,mid,qx,mid,lson[t])+
        query(mid+1,right,mid+1,qy,rson[t])+add;
}

int main()
{
    int m,t,tt,h,l,r,add,ca=0;
    char op[3];
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        For(i,1,n) scanf("%d",a+i);
        cnt = -1;
        root[0] = build(1,n);
        if(ca++) printf("\n");
        t = 0; ///current time
        while(m--)
        {
            scanf("%s",op);
            switch (op[0])
            {
                case 'Q':
                    scanf("%d%d",&l,&r);
                    printf("%lld\n",query(1,n,l,r,root[t]));
                    break;
                case 'B':
                    scanf("%d",&t);cnt = root[t+1]-1;
                    break;
                case 'H':
                    scanf("%d%d%d",&l,&r,&tt);
                    printf("%lld\n",query(1,n,l,r,root[tt]));
                    break;
                case 'C':scanf("%d%d%d",&l,&r,&add);
                    ++t;
                    update(1,n,l,r,add,root[t],root[t-1]);
                    break;
            }
        }
    }
    return 0;
}
Apare_xzc
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
二阶魔方的最少步打乱 Apare_xzc
01-06
Apare_xzc 2020.2.20 13:17 前言：  博主xzc是一个魔方爱好者，三阶sub 25s。虽然水平不高，但是对魔方十分热爱。博主对二阶魔方编码，然后通过bfs得到了二阶魔方的全部状态。 下面是得到的最少步打乱。  最少步...
《数据库系统概念》第6版 学习笔记 Apare_xzc
Apare_xzc的博客
09-09 377
《数据库系统概念》第6版 学习笔记 Apare_xzc 2020.9.9 数据库系统概念的官方网站 MySQL建表 # 官方文档的 DDL-MySQL+drop drop table if exists prereq; # 先修课表 drop table if exists time_slot; drop table if exists advisor; drop table if exists takes; drop table if exists student; # 学生信息表 drop tabl
XZC的毕业旅行计划 Apare_xzc
Apare_xzc的博客
02-11 404
XZC的毕业旅行计划 时间限制：1000ms 内存限制：256M 题面：         XZC打算毕业旅行，要从出发地出发到达目的地。地图有n个城市，m条双向高铁线路。你能帮他找到一条最省钱，而且中转最少的路线吗？他还是一个学生党，所以首先要保证从出发地到目的地的高铁票费用(因为普快是在是太慢了，他回家要坐20...
exgcd复习 Apare_xzc
Apare_xzc的博客
04-02 360
exgcd复习 2019/3/25 xzc 拓展欧几里得原理可以用来解这样的不定方程： aX + bY = c(求X,Y) 若c不是gcd(a,b)的倍数，则该不定方程一定无解 则问题可以转化为求不定方程的一组解{x,y}： aX + by = gcd(a,b) 我们知道欧几里得算法：gcd(a,b) = gcd(b,a%b) (1.0). a * X1 + b * Y1 = gcd(a,...
连号区间数 Apare_xzc
Apare_xzc的博客
11-13 291
连号区间数 题目： 问题描述 小明这些天一直在思考这样一个奇怪而有趣的问题： 在1~N的某个全排列中有多少个连号区间呢？这里所说的连号区间的定义是： 如果区间[L, R] 里的所有元素（即此排列的第L个到第R个元素）递增排序后能得到一个长度为R-L+1的“连续”数列，则称这个区间连号区间。 当N很小的时候，小明可以很快地算出答案，但是当N变大的时候，问题就不是那么简单了，现在小明需要你的帮助...
昆仑山上放宝物 Apare_xzc
Apare_xzc的博客
02-23 256
昆仑山上放宝物 Apare_xzc 时间限制：1000ms 内存限制：128M 题面         叮~欢迎来到昆仑山仙境。昆仑山上的仙人正在采集山顶上的灵气。他把这个任务交给了大弟子。仙人有一个宝物，这个宝物可以快速吸收山顶上的灵气，但是需要放置到合理的位置上。宝物只能放到山顶上（山顶也是灵气浓度最高的地方...
xzc最喜欢的二叉树 Apare_xzc
Apare_xzc的博客
01-27 1937
题目名称：XZC最喜欢的二叉树 题目时限：1000ms 最大内存：128M 题目描述：         众所周知，树是XZC最喜欢的数据结构。 二叉树是树的一种，是每个节点的子节点个数都不超过2的树。经典的二叉树有：红黑树，替罪羊树，胜者树，败者树…二叉树的遍历方式也有很多种，如：层序遍历，先序遍历(有人也称作前...
OS学习之Day02 Apare_xzc
Apare_xzc的博客
09-22 358
OS学习之Day02 进程的同步与互斥 问题引入： 老渣约会的故事，女一和女二 略 管道通信：         管道通信是一种半双工通信，读进程和写进程并法执行。由于并发，必然导致异步性。因此，“写数据”和“读数据”的先后顺序是不确定的。而在实际应用中，必须按照“读数据->写数据”的顺序执行。 信号量机制 Dijkstra提出的 信号量可以分为：整型信号量 和 记录型信号量 用户进程可以通过使用操作系
关于贪心算法的一些总结 Apare_xzc
Apare_xzc的博客
12-07 465
关于贪心算法的一些总结 关于贪心算法：   来自百度百科的定义：贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。 贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。 贪心算法的2个基本要...
【xzc的平面类求解】 Apare_xzc
Apare_xzc的博客
11-29 434
平面类求解 by xzc 我们知道，三维平面有一般方程Ax+By+Cz+D = 0 知道一般方程我们可以根据一般方程求点到平面的距离 可以求平面的二面角 求平面的一般方程只要知道一下任意一组信息即可 已知平面上不共线的三个点坐标求平面方程 已知平面上一个点坐标和平面法向量求方程 已知平面上一个点坐标和平面法向量求方程 已知平面上一点坐标与两个方向向量求方程 已知平面上两点坐...
1.rar_labview_labview pare_labview 密码
07-15
这是一个基于LABVIEW的透明面板设计！按前面板的旋钮可以实现，前面板逐渐透明的过程！不需要解压缩密码
bkpsdm_pare:PARE 2018 Dengan Laravel
04-01
bkpsdm_pare PARE 2018 Dengan Laravel
hrnet_w32-36af842e.pth
07-23
HRNet（deep-high-resolution-net.pytorch）官方预训练模型，官方下载需要梯子到GoogleDrive下载，我下载好了供大家使用。
matlab-gamultiobj.zip_MATLAB pareto_Pareto最优前沿_gamultiobj函数_pare
07-14
同时优化两个目标函数，并获得pareto最优前沿
糖果(2019第十届蓝桥杯省赛C++A组I题) 解题报告(状压dp) Apare_xzc
Apare_xzc的博客
04-05 4751
糖果(2019第十届蓝桥杯省赛C++A组I题) 解题报告(状压dp) xzc 2019/4/5 试题 I: 糖果 时间限制: 1.0s 内存限制: 256.0MB 本题总分：25分 【问题描述】   糖果店的老板一共有 M 种口味的糖果出售。为了方便描述，我们将 M 种口味编号 1 ∼ M。   小明希望能品尝到所有口味的糖果。遗憾的是老板并不单独出售糖果，而是 K 颗一包整包出售。   幸好糖...
四人过桥求最短时间(《算法设计与分析》习题一的第8题) Apare_xzc
Apare_xzc的博客
04-03 4730
4人过桥求最短时间 题意： 《算法设计与分析》习题一的第8题 4个人晚上过桥，每次最多两人并行，只有一个手电筒。 4个人过桥的最快时间分别为1,2,5,10(分钟) 先挑两个人过去，再有个人送回来，然后在过两个人… 直到4个人都过去，求最少的总时间 暴力： 写了一晚上，好累 用两个vector模拟桥两边有哪些人 先dfs处理出4选2，3选2的情况 然后在暴力DFS找时间最短的方案 我的代码 /* ...
[CCF] 我做过的CCF题目汇总 Apare_xzc
Apare_xzc的博客
12-16 3675
[CCF] 我做过的CCF题目汇总 by xzc 导言：   2019.12.15打了一场CCF，近期应该是不打算再参加了，做一个总结吧。 我今年9月份开学才知道CCF认证，当时我家LH敦促我要参加，后来事情太多，一直没放心上，直到11月初才报了名，参加第十八次CCF计算机职业资格认证考试, 准备了一个多月。 我的第十八次CCF的题解：这里<–CSDN and 牛客–>...
[开关问题]01串翻转全变零 阿里笔试2020 Apare_xzc
Apare_xzc的博客
04-03 3523
[开关问题]01串翻转全变为零 Apare_xzc 问题描述：     有一个01串，长度为len(1<=len<=20)，我们可以对这个字符串进行翻转操作，定义如下： 我们可以对字符串任意位置进行操作，操作后，此位置与其相邻的两个位置的字符改变(‘1’变’0’，‘0’变’1’)。 问最少翻转多少次这个字符串可以全部变为为’0’。输出最少步...
Error response from daemon: driver failed programming external connectivity on endpoint jolly_pare
最新发布
09-01
这个错误通常表示容器不能与主机的网络接口建立连接。可能有几个原因导致这种情况发生： 1. 端口冲突：容器正在使用的端口可能与主机上的已经在使用的端口相冲突。您可以尝试更改容器使用的端口，或者停止正在使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值