RMQ算法_ST表__2019牛客多校联盟A题Equivalent Prefixes

最新推荐文章于 2019-08-05 16:33:32 发布

XiaoboAc

最新推荐文章于 2019-08-05 16:33:32 发布

阅读量122

点赞数

分类专栏： Acm之旅___2019集训刷题总结文章标签： ST表单调栈

本文链接：https://blog.csdn.net/qq_43332231/article/details/96476773

版权

Acm之旅___2019集训刷题总结专栏收录该内容

3 篇文章 0 订阅

订阅专栏

题目

在这里插入图片描述

题目大意就是给你两个长度为n的序列让你找到一个尽可能大的下标p使得1-p之间的任意两个区间l-r都满足RMQ(u,l,r)相等其实就是最小下标相同
RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在i,j里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题。
这样就涉及到了RMQ算法当然这也是其中一种做法还可以用单调栈维护写或者建立两个笛卡尔树比较前缀p的时候他们是否相同而我也谈下自己在总结这个题的时候学到的知识
第一个样例
2
1 2
2 1
那么对于第一组数区间最小值下标长度为1的时候后就是1 长度为2 及1 2的时候最小值下标仍为1
同理第二组数据 1 2 所以要保证有相同的最小值下标那么就是1
第二组样例
最小值下标
1 2 2
1 2 2
所以输出3
同样最后一组
1 2 2 2 2
1 2 2 2 5
所以最多是第四个输出4
那么什么是RMQ算法
了解RMQ之前我们先了解下LCA（最近公共祖先）
在寻找最近公共祖先的时候有个ST算法直接百度也比较详细
用f[i][j] 表示区间起点为j长度为2^i的区间内的最小值所在下标，通俗的说，就是

区间 [i,i+2^j)的区间内的最小值的下标。

在这里插入图片描述
仔细观察发现正好为区间的长度len，所以只要区间长度一定，k就能在常数时间内求出来。而区间长度只有n种情况，所以k可以通过预处理进行预存。
举个例子
我们假设数组arr为：1 5 7 9 3 2 6 4
我们设二维数组dp[i][j]表示从第i位开始连续2^j个数中的最小值。例如dp[2][1]就表示从第二位数开始连续两个数的最小值（也就是从第二位数到第三位数的最小值），即5，7中的最小值，所以dp[2][1] = 5
其实我们求 dp[i][j] 的时候可以把它分成两部分，第一部分是从 i 到 i + 2 ^( j-1 ) - 1 ，第二部分从 i + 2 ^( j-1 ) 到i + 2^j -1 ，为什么可以这么分呢？其实我们都知道二进制数前一个数是后一个的两倍，那么可以把 i ~ i + 2^j -1 这个区间通过2^(j-1) 分成相等的两部分，那么转移方程很容易就写出来了。（dp[i][0]就表示第i个数字本身）
那么根据这个思路就可以建立一个ST表来求出区间的最小OR最大值

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
using namespace std;
const int maxn=1e5+5;
int dp[maxn][20];//记录最小值
int dp2[maxn][20];//记录最大值 
int a[maxn];
int n;
void rmq_init()
{
	for(int i=0;i<n;i++) {//初始化dp[i][0]  代表元素自己本身 
		dp[i][0]=a[i];
		dp2[i][0]=a[i]; 
	}
	for(int j=1;(1<<j)<=n;j++) {//对于这个范围可以这样理解 因为dp[i][j]代表的是i到i+2^j范围内的最小值
		//所以2^j必须要小于等于n 
		for(int i=0;i+(1<<j)-1<n;i++) {//同上 
			dp[i][j]=min(dp[i][j-1],dp[i+(1<<j-1)][j-1]);//找出两个区间内的最小值 
			dp2[i][j]=max(dp2[i][j-1],dp2[i+(1<<j-1)][j-1]);//找出两个区间内的最大值 
		}
	}
}

int query_min(int l,int r){//查询最小值 
	int k=(int)log(r-l+1.0)/log(2.0);//看博客上推的k等于区间长度-1 
	return min(dp[l][k],dp[r-(1<<k)+1][k]);//返回两段区间内的最小值 
}
int query_max(int l,int r) {
	int k=(int)log(r-l+1.0)/log(2.0);
	//向下取整并转换成int，功能同floor()，保证u+1<<k落在[u,v]内。ceil()向上取整 
	return max(dp2[l][k],dp2[r-(1<<k)+1][k]);
}
int main()
{
	cin>>n;
	for(int i=0;i<n;i++) {
		cin>>a[i];
	}
	rmq_init();
	int m;
	cin>>m;
	while(m--) {
		int l,r;
		cin>>l>>r;
		cout<<query_min(l-1,r-1)<<endl;
		cout<<query_max(l-1,r-1)<<endl;
	}
 }

同样的ST表也可以记录最小值或者最大值的下标

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath> 
#include<cstring>
#include<string>
using namespace std;
#define Xiaobo main
const int maxn=1e5+5;
int ind_max[maxn][20];
int ind_min[maxn][20];
int n;
int a[maxn];
void init()
{
	for(int i=0;i<n;i++) {
		ind_max[i][0]=i;
		ind_min[i][0]=i;
	}
	for(int j=1;(1<<j)<=n;j++) {
		for(int i=0;i+(1<<j)-1<n;i++) {
			if(a[ind_max[i][j-1]]>a[ind_max[i+(1<<j-1)][j-1]]){
				ind_max[i][j]=ind_max[i][j-1];
			}
			else {
				ind_max[i][j]=ind_max[i+(1<<j-1)][j-1];
			}
			if(a[ind_min[i][j-1]]>a[ind_min[i+(1<<j-1)][j-1]]){
				ind_min[i][j]=ind_min[i+(1<<j-1)][j-1];
			}
			else {
				ind_min[i][j]=ind_min[i][j-1];
			}
		}
	}
}
int query_min(int l,int r){
	int k=(int)log(r-l+1.0)/log(2.0);
	if(a[ind_min[l][k]]>a[ind_min[r-(1<<k)+1][k]]){
		return ind_min[r-(1<<k)+1][k];
	}
	else return ind_min[l][k];
}
int query_max(int l,int r) {
	int k=(int)log(r-l+1.0)/log(2.0);
	if(a[ind_max[l][k]]<a[ind_max[r-(1<<k)+1][k]]){
		return ind_max[r-(1<<k)+1][k];
	}
	else return ind_max[l][k];
}
int Xiaobo()
{
	int m;
	cin>>n;
	for(int i=0;i<n;i++) cin>>a[i];
	init();
	cin>>m;
	while(m--) {
		int u,v;
		cin>>u>>v;
		cout<<query_min(u-1,v-1)+1<<endl;
		cout<<query_max(u-1,v-1)+1<<endl;
	}
}

打比赛的时候就是用ST表求得，可惜我太菜了ST表虽说建好了但是最后判断条件没写对，枯了，

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<ctype.h>
#include<set>  
#include<map>  
#include<iomanip>
#include<vector>   
#include<time.h>  
#include<assert.h>  
#include<cmath>	
#include<algorithm>
#include<bitset>
#include<limits.h>
#include<stack>
#include<queue>
using namespace std;
const int maxn=100010;
const int maxm=1001;
const int inf=INT_MAX;
 
int n,st[maxn][16],sti[maxn][16];
int st2[maxn][16],sti2[maxn][16]; 
int a[maxn],b[maxn];
void initindex(){ 
	for(int i=0;i<n;++i) sti[i][0]=i;
	for(int j=1;(1<<j)<=n;++j){
		for(int i=0;i+(1<<j)-1<n;++i){
			sti[i][j]=a[sti[i][j-1]]<a[sti[i+(1<<(j-1))][j-1]]?sti[i][j-1]:sti[i+(1<<(j-1))][j-1];
		}
	}
	for(int i=0;i<n;i++) sti2[i][0]=i;
	for(int j=1;(1<<j)<=n;j++) {
		for(int i=0;i+(1<<j)-1<n;i++) {
			sti2[i][j]=b[sti2[i][j-1]]<b[sti2[i+(1<<(j-1))][j-1]]?sti2[i][j-1]:sti2[i+(1<<(j-1))][j-1];
		}
	}
} 
 
int index(int u,int v){
	int k=(int)(log(v-u+1.0)/log(2.0));
	return a[sti[u][k]]<a[sti[v-(1<<k)+1][k]]?sti[u][k]:sti[v-(1<<k)+1][k];
}
int index2(int u,int v) {
	int k=(int)(log(v-u+1.0)/log(2.0));
	return b[sti2[u][k]]<b[sti2[v-(1<<k)+1][k]]?sti2[u][k]:sti2[v-(1<<k)+1][k];
} 
int dfs(int st,int en) {
	if(st>=en) return true;
	int a1=index(st,en);
	int b1=index2(st,en);
	if(a1!=b1) return false;
	return (dfs(st,a1-1)&&dfs(a1+1,en));	
}
int main(){
	//initrmq();
	initindex();
	while(~scanf("%d",&n)) {
		for(int i=0;i<n;i++) {
			scanf("%d",&a[i]);
		}
		for(int j=0;j<n;j++) {
			scanf("%d",&b[j]);
		}
		initindex();
		int l=0,r=n;
		while(l<r) {
			int mid=(l+r)/2;
			if(dfs(0,mid)) l=mid+1;
			else r=mid;
		}
		cout<<r<<endl;
	}
	return 0;
}

还有一位大佬写的维护单调栈的代码，比较两个笛卡尔树是否相同，而我还没有真正理解，，，贴上去慢慢理解把哈哈哈

#include<bits/stdc++.h>
using namespace std;
#define Sheryang main
#define TYPE int
const int maxn=1e5+7;
typedef long long ll;
const int mod=1e9+7;
void Smax(TYPE &a,TYPE b){if(a<b) a=b;}
void Smin(TYPE &a,TYPE b){if(a>b) a=b;}
///#define getchar()(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++)
///char buf[(1 << 21) + 1], *p1 = buf, *p2 = buf;
#define IO cin.tie(0),ios::sync_with_stdio(false);
#define pi acos(-1)
#define PII pair<ll,ll>
ll read(){ll c = getchar(),Nig = 1,x = 0;while(!isdigit(c) && c!='-')c = getchar();if(c == '-')Nig = -1,c = getchar();while(isdigit(c))x = ((x<<1) + (x<<3)) + (c^'0'),c = getchar();return Nig*x;}
#define read read()
/** keep hungry and keep calm! **/
 
int n,a[maxn],b[maxn],st[maxn],ans[maxn];
 
int judge(int r){
    int top = 0;
    for(int i=1;i<=r;i++){
        while(top && a[st[top]] > a[i]) top--;
        ans[i] = st[top];//st[top]是队尾下标 
        //ans是队首元素记录的最小值下标 
        st[++top] = i;
    }
     
    top = 0;
    for(int i=1;i<=r;i++){
        while(top && b[st[top]] > b[i]) top--;
        if(ans[i] != st[top]) return 0;
        st[++top] = i;
    }
     
    top = 0;
    for(int i=r;i>=1;i--){
        while(top && a[st[top]] > a[i]) top--;
        ans[i] = st[top];
        st[++top] = i;
    }
     
    top = 0;
    for(int i=r;i>=1;i--){
        while(top && b[st[top]] > b[i]) top--;
        if(ans[i] != st[top]) return 0;
        st[++top] = i;
    }
     
    return 1;
}
 
int Sheryang(){
     
    while(~scanf("%d",&n)){
         
        for(int i=1;i<=n;i++){
            a[i] = read;
        }
        for(int i=1;i<=n;i++){
            b[i] = read;
        }
         
        int l=1,r=n,mid,ans=1;
        while(l<=r){
            int mid = l+r>>1;
            if(judge(mid)){
                l = mid + 1;
                ans = mid;
            }else{
                r = mid - 1;
            }
        }
         
        printf("%d\n",ans);
    }
     
     
    return 0;
}

这次比赛最大的感悟就是二分查找答案，递归验证区间是否符合题意，菜的真实。。。继续刷题吧

XiaoboAc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RMQ算法_ST表__2019牛客多校联盟A题Equivalent Prefixes

题目题目大意就是给你两个长度为n的序列让你找到一个尽可能大的下标p使得1-p之间的任意两个区间l-r都满足RMQ(u,l,r)相等其实就是最小下标相同RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在i,j里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题。这...
复制链接

扫一扫