[bzoj5042][笛卡尔树]LWD的分科岛

最新推荐文章于 2019-10-15 22:31:24 发布
最新推荐文章于 2019-10-15 22:31:24 发布
阅读量1.7k 收藏
点赞数
分类专栏： bzoj ST表 笛卡尔树 OI路漫漫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rose_max/article/details/78071780
版权
bzoj 同时被 3 个专栏收录
483 篇文章 2 订阅
订阅专栏
OI路漫漫
109 篇文章 4 订阅
订阅专栏
ST表
5 篇文章 0 订阅
订阅专栏

Description

大家都知道在文理分科的时候总是让人纠结的，纠结的当然不只是自己。比如 YSY 就去读了文科， LWD 知道了很
气。于是他就去卡了 BZOJ 测评机， 晚上他做了一个谜一样的梦，自己在一座全是 YSY 的分科岛。这里有 YSY
草， YSY 花， YSY 糖……每个 YSY 都有一个美（ Ti）丽（ Zhong）值。当然没有小于零的体重啦！LWD 于是不
惜重金卖肉想买下这座岛，可是分科岛的岛主，是一位忠实的区间问题爱好者。他想把小岛传给一个谜一样的爱好
者，所以岛主给了 LWD 一个终极挑战——选出一片区域中最美丽的 YSY。可是岛主的审美观不像 YYR那么专一，
他有时喜欢现代美——最轻的，有时喜欢唐代美——最重的。这让被欢喜冲昏了头脑（血液集中在下半身）的 LWD
十分苦恼。他要在规定时间内完成挑战赢得买岛的权利，于是只有求助 DalaoYYR，可是 YYR 要准备课件啊。只
有比 YYR 弱很多的你能够帮他了。挑战内容如下岛主将把 N 个 YSY 摆成一个条形，并给出所有 YSY 的美丽值。
挑出多少个就要看岛主心情了，他觉得 LWD 是条汉子就会给出很多很多的 YSY 满足他。岛主将给出 Q 个考验，
询问内容是在给定区间内求出最美丽的 YSY。你已经了解规则了，开始你的表演吧！

Input

第一行为一个整数 N，表示岛主摆出了 N 个 YSY。
接下来一行 N 个整数，表示每个 YSY 的美丽值(单位：kg)，因为 YSY 整体很美所以 YSY
不会超过 1019kg。
接下来一行一个整数 Q，表示岛主有 Q 个考验。Q<=1500000
接下来 Q 行，每行三个整数 opt, l, r 。 opt 等于 1 时表示岛主那时喜欢现代美，等于 2
时代表岛主那时喜欢唐代美。询问最美计划在区间[l, r]中进行
100%的数据 N<= 3000000, 美丽值不会超过 1019， Q<= 150000
数据量巨大，请优化读入

Output

每一行对于每个考验输出结果，以回车符结束。

Sample Input

5 5
1 2 3 4 5
1 1 2
2 1 3
1 2 5
2 4 5
2 1 5

Sample Output

1
3
2
5
5

这才是正经题解下面全是年轻废话…

对原数列建出笛卡尔树
然后两点之间的最值就是他们LCA的值
之后tarjan求一下LCA即可
笛卡尔树主要满足了两个性质
即左右儿子均满足不大于/不小于当前节点，并且左边节点的编号一定比他小，右边节点的编号一定比他大
建树的过程只需要维护右边一条链即可

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline char nc() {
    static char buf[1000000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;
}
inline int read(void) {
    char ch=nc();
    int sum=0;
    while(!(ch>='0'&&ch<='9'))
        ch=nc();
    while(ch>='0'&&ch<='9')
        sum=(sum<<3)+(sum<<1)+(ch^48),ch=nc();
    return sum;
}
//inline int read()
//{
//    int f=1,x=0;char ch=getchar();
//    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
//    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
//    return x*f;
//}
int stack[20];
inline void write(int x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
inline void pr1(int x){write(x);putchar(' ');}
inline void pr2(int x){write(x);putchar('\n');}
const int MAXN=3000005;
struct egde{int x,y,o,next;}a[MAXN],b[MAXN];int len,last[MAXN],len1,last1[MAXN];
void ins1(int x,int y,int o){len1++;b[len1].x=x;b[len1].y=y;b[len1].o=o;b[len1].next=last1[x];last1[x]=len1;}
void ins(int x,int y){len++;a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;}

int cal[MAXN],n,m;
int sta[MAXN],tp,root;
bool check(int u,int v,int o)
{
	if(o==1)return u<=v;
	else return u>=v;
}
void buildtree(int o)
{
	sta[tp=1]=1;
	for(int i=2;i<=n;i++)
	{
		int lst=-1;
		while(tp&&check(cal[i],cal[sta[tp]],o))
		{
			if(lst!=-1)ins(sta[tp],lst);
			lst=sta[tp--];
		}
		if(lst!=-1)ins(i,lst);
		sta[++tp]=i;
	}
	while(tp>1)ins(sta[tp-1],sta[tp]),tp--;
	root=sta[1];
}
int rt[MAXN];
int findrt(int x){return rt[x]==x?x:rt[x]=findrt(rt[x]);}
//vector<pii> vec[MAXN];
int ok[MAXN],fa[MAXN],tim,ID,ans[MAXN];
void DFS(int x)
{
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		fa[y]=x;DFS(y);
	}
	ok[x]=tim;
	for(int k=last1[x];k;k=b[k].next)
	{
		int y=b[k].y;
		if(ok[y]==tim)ans[b[k].o]=cal[findrt(y)];
	}
	int up=findrt(fa[x]);
	rt[x]=up;
}
struct ed{int l,r,o;}w[MAXN];
int main()
{
	n=read();m=read();
	for(int i=1;i<=n;i++)cal[i]=read();
	for(int i=1;i<=m;i++)w[i].o=read(),w[i].l=read(),w[i].r=read();
	for(int i=1;i<=m;i++)if(w[i].o==1)ins1(w[i].l,w[i].r,i),ins1(w[i].r,w[i].l,i);
	tim++;
	buildtree(1);
	for(int i=1;i<=n;i++)rt[i]=i;
	DFS(root);
	tim++;
	len=0;memset(last,0,sizeof(last));
	len1=0;memset(last1,0,sizeof(last1));
	for(int i=1;i<=m;i++)if(w[i].o==2)ins1(w[i].l,w[i].r,i),ins1(w[i].r,w[i].l,i);
	buildtree(2);
	for(int i=1;i<=n;i++)rt[i]=i;
	DFS(root);
	for(int i=1;i<=m;i++)pr2(ans[i]);
	return 0;
}

下面全是废话

正经题解前说的话

写了这篇题解没想到帮了这么多被毒瘤题卡住的人。。
不过我还真想到了除了On的rmq外的东西。就是可持久化01tire
对于每个点反着建01tire，即高位的深度较低
然后像主席树那样合并起来搞可持久化数据结构。。
这样可以弄出来一个空间小于st表时间小于线段树的东西
至于我是怎么想到的？？这个魅力值<=1019很可疑啊
但是我发现我又被卡空间了。。各路神犇可以指导一下吗

//这是MLE的代码
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
struct node
{
	int lc,rc,c0,c1;//lc 0  rc 1 
}tr[30000005];int tot;
int tmp[15];
void getlen(int x)
{
	int p=11;
	if(x==0){for(int i=1;i<=11;i++)tmp[i]=0;return ;}
	while(x)
	{
		tmp[p--]=x%2;
		x/=2;
	}
	for(int i=1;i<=p;i++)tmp[i]=0;
}
int rt[3100000];
void add()
{
	int x=++tot;
	for(int i=1;i<=11;i++)
	{
		if(tmp[i]==0){tr[x].c0++;tr[x].lc=++tot;x=tr[x].lc;}
		else {tr[x].c1++;tr[x].rc=++tot;x=tr[x].rc;}
	}
}
void merge(int &x,int y)
{
	if(x==0){x=y;return ;}
	if(y==0)return ;
	tr[x].c0+=tr[y].c0;
	tr[x].c1+=tr[y].c1;
	merge(tr[x].lc,tr[y].lc);
	merge(tr[x].rc,tr[y].rc);
}
int bin[20],ans;
int solmax(int x,int y)
{
	ans=0;
	int px=x,py=y;
	for(int i=11;i>=1;i--)
	{
		int c=tr[px].c1-tr[py].c1;
		if(c>0)
		{
			ans+=bin[i];
			px=tr[px].rc;py=tr[py].rc;
		}
		else if(tr[px].c0-tr[py].c0>0){px=tr[px].lc;py=tr[py].lc;}
		else break;
	}
	return ans;
}
int solmin(int x,int y)
{
	ans=0;
	int px=x,py=y;
	for(int i=11;i>=1;i--)
	{
		int c=tr[px].c0-tr[py].c0;
		if(c>0){px=tr[px].lc;py=tr[py].lc;}
		else if(tr[px].c1-tr[py].c1>0){ans+=bin[i];px=tr[px].rc;py=tr[py].rc;}
		else break;
	}
	return ans;
}
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	bin[1]=1;for(int i=2;i<=15;i++)bin[i]=bin[i-1]*2;
	tot=0;
	for(int i=1;i<=n;i++)
	{
		int x;
		scanf("%d",&x);
		getlen(x);
		rt[i]=tot+1;add();merge(rt[i],rt[i-1]);
	}
	while(m--)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1)printf("%d\n",solmin(rt[r],rt[l-1]));
		else printf("%d\n",solmax(rt[r],rt[l-1]));
	}
	return 0;
}

题解

首先，说点东西。。每个询问长度才1000左右？？？？？
所以这可以投机一点st表。。但是估计是卡着时间过去的
还有。。不能定两个数组，两个数组都会炸。。还得一个数组拆开来用。。
所以说切了这题还是觉得很无奈。。
两个数组维护最大最小值然后Nlogn求吧。bzoj上大佬D说可以线性RMQ然而不会，就卡下数据吧。
正解好像是On的RMQ 可以参照一下OZY大佬的blog


#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
int mn[11][3000001],s[3000001],Log[3000001];
int ans[1500001];
int x[1500001],y[1500001],k[1500001];
int n,m;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void premn()
{
	//mn[i][j]=min(mn[i-1][j],mn[i-1][j+1<<i])
	Log[0]=-1;
	for(int i=1;i<=n;i++)Log[i]=Log[i/2]+1;
	for(int i=1;(1<<i)<=n && i<=10;i++)
		for(int j=1;j+(1<<i)-1<=n && j<=n;j++)
		{
			mn[i][j]=min(mn[i-1][j],mn[i-1][j+(1<<(i-1))]);
		}
}
int maxnum;
void premx()
{
	for(int i=1;i<=n;i++)mn[0][i]=s[i];
	for(int i=1;(1<<i)<=maxnum && i<=10;i++)
		for(int j=1;j+(1<<i)-1<=maxnum && j<=maxnum;j++)
		{
			mn[i][j]=max(mn[i-1][j],mn[i-1][j+(1<<(i-1))]);
		}
}
int main()
{
//	freopen("naive.in","r",stdin);
//	freopen("naive.out","w",stdout);
	n=read();m=read();
	for(int i=1;i<=n;i++){mn[0][i]=s[i]=read();}
	
	premn();int tmp=0;maxnum=0;
	for(int i=1;i<=m;i++)
	{
		int op=read(),xx=read(),yy=read();
		if(op==1)
		{
			int kk=Log[yy-xx+1];
			ans[i]=min(mn[kk][xx],mn[kk][yy-(1<<kk)+1]);
		}
		else
		{
			tmp++;
			x[tmp]=xx;y[tmp]=yy;k[tmp]=i;
			maxnum=max(maxnum,yy);
		}
	}
	premx();
	for(int i=1;i<=tmp;i++)
	{
		int kk=Log[y[i]-x[i]+1];
		ans[k[i]]=max(mn[kk][x[i]],mn[kk][y[i]-(1<<kk)+1]);
	}
	for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
	return 0;
}
Rose_max
关注
专栏目录
sgu155 笛卡尔树
lyc
02-22 698
此题是笛卡尔树的模板题。需要好好改进，作为模板之用。   笛卡尔树又称笛卡儿树，在数据结构中属于二叉树的一种。 笛卡尔树结构由Vuillmin在解决范围搜索的几何数据结构问题时提出的，从数列中构造一棵笛卡尔树可以线性时间完成，需要采用基于栈的算法来找到在该数列中的所有最近小数。由此可知，笛卡尔树是一种特定的二叉树数据结构，可由数列构造，在范围最值查询、范围top k查询（rang
BZOJ：3894: 文理分科（网络流）
少主大人殿下的博客
03-20 530
题目 每个同学都只能选择文科或者理科一种，选择文科会获得一个权值，理科也有，如果一个人以及周围四个人都选择了一个学科，那么又会获得一个权值。 将权值最大化。 分析 很经典的网络流题目，用最小割。 首先我们的模型想法是把最终和S集联通的弄成文集，T集联通的弄成理集，然后用最小割割掉，为了使用最小割，我们采取首先加入所有权值，然后看根据选择减少了哪些权值。 连边的方式就是： 对于一个...
[BZOJ]5042: LWD的分科岛 笛卡尔树+LCA
TYB的博客
12-12 486
Description 大家都知道在文理分科的时候总是让人纠结的，纠结的当然不只是自己。比如 YSY 就去读了文科， LWD 知道了很气。于是他就去卡了 BZOJ 测评机， 晚上他做了一个谜一样的梦，自己在一座全是 YSY 的分科岛。这里有 YSY 草， YSY 花， YSY 糖……每个 YSY 都有一个美（ Ti）丽（ Zhong）值。当然没有小于零的体重啦！LWD 于是不惜重金卖肉想买下这座岛...
bzoj5042: LWD的分科岛 两种做法
OZY的博客
09-25 839
两种做法的快速rmq
BZOJ.2616.SPOJ PERIODNI(笛卡尔树 树形DP)
weixin_30458043的博客
04-02 111
BZOJ SPOJ 直观的想法是构建笛卡尔树（每次取最小值位置划分到两边），在树上DP，这样两个儿子的子树是互不影响的。 令\(f[i][j]\)表示第\(i\)个节点，放了\(j\)个车的方案数。 设\(v\)是\(i\)的一个儿子，对于子树部分的转移，有\[f'[i][j]=\sum_{k\leq j}f[v][j-k]f[i][k]\] 求完子树贡献后，对于\(i\)节点代表的矩形，设高度...
【BZOJ2616】SPOJ PERIODNI 笛卡尔树+树形DP
aodanchui1057的博客
11-05 163
【BZOJ2616】SPOJ PERIODNI Description Input 第1行包括两个正整数N，K，表示了棋盘的列数和放的车数。第2行包含N个正整数，表示了棋盘每列的高度。 Output 包括一个非负整数，表示有多少种放置的方案，输出答案mod1000000007后的结果即可。 Sample Input ...
wangjunrui666#bzoj-problem##5041. LWD的降临1
07-25
第一行一个整数t，表示数据组数 第一行四个实数x1,y1,x2,y2，表示两焦点坐标 第二行三个实数x0,y0,r，表示YSY星球(在二维平面中是一个圆)的圆心
bzoj2830 随机树
Elijahqi
06-12 308
http://www.elijahqi.win/archives/3673 题面：https://www.luogu.org/problemnew/show/P3830 第一问设dp[x]表示 叶子节点为x的叶子节点的平均深度期望 首先知道每次一定是在dp[i-1]的基础上+2 并且 那么这个答案最后就是 2对于i个叶子节点每种情况贡献的平均值 都是2/x 第二问 考虑对于一个随机变量x...
BZOJ 4231 回忆树（AC自动机+BIT+KMP）
Freopen的博客
04-02 391
回忆树是树。 具体来说，是n个点n-1条边的无向连通图，点标号为1~n，每条边上有一个字符（出于简化目的，我们认为只有小写字母）。 对一棵回忆树来说，回忆当然是少不了的。 一次回忆是这样的：你想起过往，触及心底…唔,不对，我们要说题目。 这题中我们认为回忆是这样的：给定2个点u，v(u可能等于v)和一个非空字符串s，问从u到v的简单路径上的所有边按照到u的距离从小到大的顺序排列后，边上的字符依次...
BZOJ3757 苹果树——树上莫队
DancingZ的博客
08-14 319
Description 　　神犇家门口种了一棵苹果树。苹果树作为一棵树，当然是呈树状结构，每根树枝连接两个苹果，每个苹果都可以沿着一条由树枝构成的路径连到树根，而且这样的路径只存在一条。由于这棵苹果树是神犇种的，所以苹果都发生了变异，变成了各种各样的颜色。我们用一个到n之间的正整数来表示一种颜色。树上一共有n个苹果。每个苹果都被编了号码，号码为一个1到n之间的正整数。我们用0代表树根。只会有一个...
【BZOJ2658】[Zjoi2012]小蓝的好友(mrx) 平衡树维护笛卡尔树+扫描线
aodanchui1057的博客
12-29 216
【BZOJ2658】[Zjoi2012]小蓝的好友(mrx) Description 终于到达了这次选拔赛的最后一题，想必你已经厌倦了小蓝和小白的故事，为了回馈各位比赛选手，此题的主角是贯穿这次比赛的关键人物——小蓝的好友。 在帮小蓝确定了旅游路线后，小蓝的好友也不会浪费这个难得的暑假。与小蓝不同，小蓝的好友并不想将时间花在旅游上，而是盯上了最近发行的即时战略游戏——Sango...
笛卡尔树
Moon1125666900的博客
06-24 421
具体介绍可以参见这篇Blog https://www.cnblogs.com/pushing-my-way/archive/2012/08/24/2653709.html 相关题目： bzoj2616 题解：将图形从下至上划分为若干个矩形，呈现一个树形的结构。然后问题就转化为树上的DP了~ 详细参见：https://blog.csdn.net/qq_39972971/article/de...
BZOJ2616: SPOJ PERIODNI【笛卡尔树树形DP】
Master.Yi的博客
10-15 393
题目描述： N≤500，K≤500，h[i] ≤1000000，mod 109+7。 题目分析： 根据图形比较容易想到按照最小值划分区间，那么hminh_{min}hmin​*n这一个矩形区域就由这个最小值控制，两边的比hminh_{min}hmin​高的车显然不会互相影响，据此就可以想到一个根据最小值划分然后DP的做法。 划分的过程就是笛卡尔树的形态，所以问题就变成了在笛卡尔树上DP，f[i]...
[BZOJ]4199: [Noi2015]品酒大会（后缀数组+笛卡尔树）
weixin_30415801的博客
05-04 131
Time Limit: 10 SecMemory Limit: 512 MB Description Input Output Sample Input 10 ponoiiipoi 2 1 4 7 4 8 3 6 4 7 Sample Output 45 56 10 56 3 32 0 0 0 0 0 0 0 0 0 0 0...
bzoj2616 SPOJ PERIODNI 笛卡尔树+DP
litble的成(tui)长(fei)史
05-13 315
题目分析 建立出小根堆性质的笛卡尔树，于是每个节点可以代表一个矩形，其宽度为子树大小，高度为该节点记录的那一列高度-父节点那一列高度。 设f(x,i)f(x,i)f(x,i)表示以xxx为跟的子树中放了iii个棋子的方案数。 初始值：f(0,0)=1f(0,0)=1f(0,0)=1 首先求出不在xxx的矩形中放棋子的方案数：f(x,i)=∑j=0if(ls(x),j)f(rs(x),i−j)f(x...
BZOJ5042: LWD的分科岛
weixin_30648963的博客
05-03 73
【传送门：BZOJ5042】 简要题意： 　　给出n个数，q个询问，每个询问输入opt,l,r，如果opt=1，则输出l到r中的最小值，否则输出最大值 题解： 　　直接上ST表，自信一波，结果 　　MLE？？好吧，离线求，最大最小值用一个数组求 　　TLE？？？好吧，看讨论，询问的范围1000左右，好，缩一波时间 　　RE？？？？好吧，不预处理2的次方，直接位运算 　　AC...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值