P3168 [CQOI2015]任务查询系统

最新推荐文章于 2022-03-26 17:28:16 发布

Sxy_Limit

最新推荐文章于 2022-03-26 17:28:16 发布

阅读量136

点赞数

分类专栏：线段树 Sxy_Limit_Luogu_Sol 题解

本文链接：https://blog.csdn.net/sxy__orz/article/details/104219075

版权

题解同时被 3 个专栏收录

91 篇文章 0 订阅

订阅专栏

Sxy_Limit_Luogu_Sol

80 篇文章 0 订阅

订阅专栏

线段树

26 篇文章 0 订阅

订阅专栏

介绍本题的两种做法:

方法1

前置芝士

线段树:一个很重要的数据结构.
树状数组:一个很重要的数据结构.

具体实现

区间修改,单点查询很容易就会想到树状数组了,至于查询前k个数的和又可以丢给权值线段树去干,所以第一种很显然的方法就是树状数组套一个线段树实现.

代码

#include<bits/stdc++.h>
#define REP(i,first,last) for(int i=first;i<=last;++i)
#define DOW(i,first,last) for(int i=first;i>=last;--i)
using namespace std;
const int maxN=5e5+7;
const int INF=2147483647;
int N,M;
int op[maxN];
int s[maxN],e[maxN],p[maxN];
int arr[maxN];
int sor[maxN];
int len=0;
map<int,int>Hash;//数据很大需要离散化
int val__[maxN];//记录离散化以后每个数代表的原来的值
struct Tree//动态开点线段树
{
	int sum,lson,rson;
	long long sum_;
}tree[maxN*32];
int point_cnt=0;
//线段树标准define
#define LSON tree[now].lson
#define RSON tree[now].rson
#define MIDDLE ((left+right)>>1)
#define LEFT LSON,left,MIDDLE
#define RIGHT RSON,MIDDLE+1,right
void PushUp(int now)
{
	tree[now].sum=tree[LSON].sum+tree[RSON].sum;//数的个数
	tree[now].sum_=tree[LSON].sum_+tree[RSON].sum_;//每个数相加以后的和
}
void UpDataMain(int num,int val,int &now,int left=1,int right=len)
//修改,在now中加入val个num
{
	if(num<left||right<num)
	{
		return;
	}
	if(!now)
	{
		now=++point_cnt;
	}
	if(left==right)
	{
		tree[now].sum+=+val;
		tree[now].sum_+=+val*val__[num];//需要加上原理的值*个数
		return;
	}
	UpDataMain(num,val,LEFT);
	UpDataMain(num,val,RIGHT);
	PushUp(now);
}
int lowbit(int now)//树状数组用的lowbit
{
	return now&-now;
}
int root[maxN];
void UpData(int top,int num,int val)//在top的位置加上val个num
{
	for(int now=top;now<=N;now+=lowbit(now))//树状数组的修改
	{
		UpDataMain(num,val,root[now]);
	}
}
//记录下当前需要加上的树的当前节点
int add_tree[maxN];
int num_add=0;
int GetSum()//当前树中数的个数
{
	int sum=0;
	REP(i,1,num_add){sum+=tree[add_tree[i]].sum;}
	return sum;
}
long long GetSum_()//当前树的数的和
{
	long long sum=0;
	REP(i,1,num_add){sum+=tree[add_tree[i]].sum_;}
	return sum;
}
int GetSumLeft()//当前树的左子树的数的个数
{
	int sum=0;
	REP(i,1,num_add){sum+=tree[tree[add_tree[i]].lson].sum;}
	return sum;
}
long long GetSum_Left()//当前树的左子树的数的和
{
	long long sum=0;
	REP(i,1,num_add){sum+=tree[tree[add_tree[i]].lson].sum_;}
	return sum;
}
int GetSumRight()//当前树的右子树的数的个数
{
	int sum=0;
	REP(i,1,num_add){sum+=tree[tree[add_tree[i]].rson].sum;}
	return sum;
}
long long GetSum_Right()//当前树的右子树的数的和
{
	long long sum=0;
	REP(i,1,num_add){sum+=tree[tree[add_tree[i]].rson].sum_;}
	return sum;
}
void GetRootLeft()//将节点换成左儿子
{
	REP(i,1,num_add){add_tree[i]=tree[add_tree[i]].lson;}
}
void GetRootRight()//将节点换成右儿子
{
	REP(i,1,num_add){add_tree[i]=tree[add_tree[i]].rson;}
}
long long QueryMain(int k,int left=1,int right=len)//查询部分主要函数
{
	int sum=GetSum();//得到当前树的数的个数
	if(left==right)//如果是叶节点
	{
		return /*当前表示的数*/val__[left]*/*只有sum个数,最多取k个数,所以取一个min*/min(sum,k);
	}
	if(k>=sum)//如果k太大
	{
		return GetSum_();//返回当前树的数的和
	}
	int left_sum=GetSumLeft();//左子树的数的个数
	if(left_sum>=k)//如果大于等于k就差左子树
	{
		GetRootLeft();
		return QueryMain(k,left,MIDDLE);
	}
	//否则就差找右子树
	long long result=GetSum_Left();
	GetRootRight();
	return result+QueryMain(k-left_sum,MIDDLE+1,right);
}
void BeforeQuery(int place)//预处理
{
	num_add=0;
	for(int now=place;now;now-=lowbit(now))
	{
		add_tree[++num_add]=root[now];
	}
}
long long Query(int place,int k)//查询
{
	BeforeQuery(place);//预处理
	return QueryMain(k);
}
void UpDataAdd(int left,int right,int num)//修改,和普通树状数组相同
{
	UpData(left,Hash[num],1);
	UpData(right+1,Hash[num],-1);
}
int main()
{
	scanf("%d%d",&M,&N);
	int num_cnt=0;
	REP(i,1,M)
	{
		scanf("%d%d%d",&s[i],&e[i],&p[i]);//记录下来离散化
		sor[++num_cnt]=p[i];
	}
	sort(sor+1,sor+1+num_cnt);
	sor[0]=-INF;
	REP(i,1,num_cnt)
	{
		if(sor[i]!=sor[i-1])
		{
			Hash[sor[i]]=++len;
			val__[len]=sor[i];
		}
	}
	REP(i,1,M)
	{
		UpDataAdd(s[i],e[i],p[i]);//直接修改
	}
	long long pre=1;
	int x,a,b,c,k;
	REP(i,1,N)
	{
		scanf("%d%d%d%d",&x,&a,&b,&c);
		k=1+(a*pre+b)%c;//按公式计算k
		pre=Query(x,k);//查询
		printf("%lld\n",pre);
	}
	return 0;
}

方法2

前置芝士

可持久化线段树 :可以用主席树来实现.
差分:优化方法1.

具体实现

可以发现方法1非常非常麻烦,所以可以发现可以用主席树维护前缀每个数出现的次数,然后就差分搞一下就好了.

代码

#include<bits/stdc++.h>
#define REP(i,first,last) for(int i=first;i<=last;++i)
#define DOW(i,first,last) for(int i=first;i>=last;--i)
using namespace std;
const int maxN=3e5+7;
int N,M;
int sor[maxN];
long long hanum[maxN];
int p[maxN];
int tot=0;
map<int,int>Hash;

//一个没什么用的东西,可以像搞图论一样把每个位置要放入的数和这个位置连一条边,可以简单处理
struct Edge
{
	int next,val,add;
}edge[maxN*2];
int cnt_edge=0;
int head[maxN];
#define FOR(now) for(int _i_=head[now];_i_;_i_=edge[_i_].next)
#define VAL edge[_i_].val
#define ADD edge[_i_].add
void AddEdge(int form,int val,int add)
{
	edge[++cnt_edge].val=val;
	edge[cnt_edge].add=add;
	edge[cnt_edge].next=head[form];
	head[form]=cnt_edge;
}

struct Tree//主席树
{
	int lson,rson,sum;
	long long sum_;
}tree[maxN*32];
#define LSON tree[now].lson
#define RSON tree[now].rson
#define MIDDLE ((left+right)>>1)
#define LEFT LSON,left,MIDDLE
#define RIGHT RSON,MIDDLE+1,right
#define NEW_LSON tree[new_tree].lson
#define NEW_RSON tree[new_tree].rson
int cnt_point=0;
void PushUp(int now)
{
	tree[now].sum=tree[LSON].sum+tree[RSON].sum;
	tree[now].sum_=tree[LSON].sum_+tree[RSON].sum_;
}
void UpData(int num,int val,int &new_tree,int now,int left=1,int right=tot)
{
	if(num<left||right<num)
	{
		new_tree=now;
		return;
	}
	new_tree=++cnt_point;
	if(left==right)
	{//和方法一差不多
		tree[new_tree].sum=tree[now].sum+val;//加上数的个数
		tree[new_tree].sum_=tree[now].sum_+hanum[num]*val/*数的个数*这个数*/;
		return;
	}
	UpData(num,val,NEW_LSON,LEFT);
	UpData(num,val,NEW_RSON,RIGHT);
	PushUp(new_tree);
}
long long Query(int k,int now,int left=1,int right=tot)//查询写得比较随便
{
	if(k<=0)return 0;//懒得分类讨论
	if(left==right)//到叶节点了直接计算
	{
		return min(k,tree[now].sum)/*取k和当期树中数的个数的小值*/*hanum[left];
	}
	if(k>=tree[now].sum)//如果k太大了
	{
		return tree[now].sum_;
	}
	return Query(k,LEFT)+Query(k-tree[LSON].sum,RIGHT);
}
int root[maxN];//记录每个位置的主席树的根节点
int main()
{
	scanf("%d%d",&M,&N);
	int s,e;
	REP(i,1,M)
	{
		scanf("%d%d%d",&s,&e,&p[i]);
		sor[i]=p[i];
		AddEdge(s,p[i],1);//添加边到这个数,和差分相同,l位置+1,r+1位置-1
		AddEdge(e+1,p[i],-1);
	}
	sort(sor+1,sor+1+M);//离散化
	sor[0]=114154;
	REP(i,1,M)
	{
		if(sor[i]!=sor[i-1])
		{
			Hash[sor[i]]=++tot;
			hanum[tot]=sor[i];
		}
	}
	int check;
	REP(i,1,N)//建树
	{
		if(head[i])//如果这个位置有加入新的数
		{
			check=1;//开始是从上一颗树变化,后来是自己修改自己
			FOR(i)//把数加入这个数
			{
				UpData(Hash[VAL],ADD,root[i],root[i-check]);
				check=0;
			}
		}
		else
		{
			root[i]=root[i-1];//没有就和上一个位置相同
		}
	}
	long long pre=1;
	int x,a,b,c,k;
	REP(i,1,N)
	{
		scanf("%d%d%d%d",&x,&a,&b,&c);
		k=1+(a*pre+b)%c;//计算k
		pre=Query(k,root[x]);
		printf("%lld\n",pre);
	}
	return 0;
}

比较两种方法

方法1的做法更显然,很容易得出,但是 $N\log_2^2N$ 的时间复杂度很容易TLE,方法二更容易写,但是需要用到差分,不一定可以直接想出来,跑起来比方法1快了很多.

Sxy_Limit

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
P3168 [CQOI2015]任务查询系统

介绍本题的两种做法:方法1前置芝士线段树:一个很重要的数据结构.树状数组:一个很重要的数据结构.具体实现区间修改,单点查询很容易就会想到树状数组了,至于查询前k个数的和又可以丢给权值线段树去干,所以第一种很显然的方法就是树状数组套一个线段树实现.代码#include<bits/stdc++.h>#define REP(i,first,last) for(int i...
复制链接

扫一扫