dp+离散（RMQ）

最新推荐文章于 2022-07-15 07:41:41 发布
最新推荐文章于 2022-07-15 07:41:41 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： dp的那些小事
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiwei408/article/details/8800230
版权

一、RMQ问题描述

RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在[i,j]里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题

ST算法（Sparse Table）:它是一种动态规划的方法。 
以最小值为例。a为所寻找的数组. 
用一个二维数组dp(i,j)记录区间[i,i+2^j-1](持续2^j个)区间中的最小值。其中dp[i,0] = a[i]; 所以，对于任意的一组(i,j)，dp(i,j) = min{dp(i,j-1),dp(i+2^(j-1),j-1)}来使用动态规划计算出来。 
这个算法的高明之处不是在于这个动态规划的建立，而是它的查询：它的查询效率是O(log(j-i)). 假设我们要求区间[m,n]中a的最小值，找到一个数k使得2^k<n-m+1)并且2^(k+1)>=n-m+1. 
这样，可以把这个区间分成两个部分：[m,m+2^k-1]和[n-2^k+1,n].这两个部分要一定保证完全覆盖这个区间，我们发现，这两个区间是已经初始化好的. 
前面的区间是dp(m,k)，后面的区间是dp(n-2^k+1,k). 
这样，只要看这两个区间的最小值，就可以知道整个区间的最小值！

二、RMQ的应用

1、poj1207

/*裸的RMQ
*/
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
int dat[10002];
int dp[10002][18];
int get_dat(int n)
{
	int cnt=1;
	while(n!=1)
	{
		if(n&1){n=3*n+1;}
		else{n/=2;}
		++cnt;
	}
	return cnt;
}
void make_max_rmq()
{
	for(int j=1;(1<<j)<=10000;++j)
	{
		for(int i=1;i+(1<<j)-1<=10000;++i)
		{
			dp[i][j]=max(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
		}
	}
		
}
int get_max_rmq(int a,int b)
{
	int k=0;
	while(a+(1<<k)<b-(1<<k)+1)++k;
	return max(dp[a][k],dp[b-(1<<k)+1][k]);
}
int main()
{
	for(int i=1;i<=10000;++i)
	{
		dat[i]=get_dat(i);
		dp[i][0]=dat[i];
	}
	int l,h,a,b;
	make_max_rmq();
	while(~scanf("%d%d",&a,&b))
	{
		l=a<b?a:b;		h=a>b?a:b;
		int ans=get_max_rmq(l,h);
		printf("%d %d %d\n",a,b,ans);
	}
	return 0;
}


 

2、poj3264

/*n个数，求i，j的最大值和最小值之差
 */
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
int m,n;
int dat[50002];
int dpmax[50002][18];
int dpmin[50002][18];
void make_max_rmq()
{
	for(int i=1;i<=n;++i)
	{
		dpmax[i][0]=dat[i];
	}
	for(int j=1;(1<<j)<=n;++j)
	{
		for(int i=1;i+(1<<j)-1<=n;++i)
		{
			dpmax[i][j]=max(dpmax[i][j-1],dpmax[i+(1<<(j-1))][j-1]);
		}
	}
}
void make_min_rmq()
{
	for(int i=1;i<=n;++i)
	{
		dpmin[i][0]=dat[i];
	}
	for(int j=1;(1<<j)<=n;++j)
	{
		for(int i=1;i+(1<<j)-1<=n;++i)
		{
			dpmin[i][j]=min(dpmin[i][j-1],dpmin[i+(1<<(j-1))][j-1]);
		}
	}
}
int get_max_rmq(int a,int b)
{
	int k=0;
	while(a+(1<<k)<b-(1<<k)+1)++k;
	return max(dpmax[a][k],dpmax[b-(1<<k)+1][k]);
}
int get_min_rmq(int a,int b)
{
	int k=0;
	while(a+(1<<k)<b-(1<<k)+1)++k;
	return min(dpmin[a][k],dpmin[b-(1<<k)+1][k]);
}
int main()
{
	int a,b;
	while(~scanf("%d%d",&n,&m))
	{
		for(int i=1;i<=n;++i)
		{
			scanf("%d",&dat[i]);
		}
		make_max_rmq();
		make_min_rmq();
		while(m--)
		{
			scanf("%d%d",&a,&b);
			int ans=get_max_rmq(a,b)-get_min_rmq(a,b);
			printf("%d\n",ans);
		}
	}
	return 0;
}


 

3、poj3368

/*
 * 有n个数升序排列，输出i,j的最大的众数
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
#define N 100002
int n,m;
int rank[N];
int dat[N];
int dp[N][18];
int rear[N];
int head[N];
void make_max_rmq()
{
	for(int i=1;i<=n;++i)
	{
		dp[i][0]=rank[i];
	}
	for(int j=1;j<=(int)(log((double)n)/log(2.0));++j)
	{
		for(int i=1;i+(1<<j)-1<=n;++i)
		{
			dp[i][j]=max(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
		}
	}
}
int get_max_rmq(int a,int b)
{
	int k=0;
	while(a+(1<<k)<b-(1<<k)+1)++k;  
	return max(dp[a][k],dp[b-(1<<k)+1][k]);
}
int main()
{
	int a,b;
	while(~scanf("%d",&n))
	{
		if(!n)break;
		scanf("%d",&m);
		int cnt=0;
		memset(head,0,sizeof(head));
		memset(rear,0,sizeof(rear));
		head[0]=1;
		for(int i=1;i<=n;++i)
		{
			scanf("%d",&dat[i]);
			if(dat[i]==dat[i-1]||i==1)
			{
				rank[i]=++cnt;
				head[i]=head[i-1];
			}
			else{
				head[i]=i;
				rear[head[i-1]]=i-1;
				rank[i]=1;
				cnt=1;
			}
		}
		make_max_rmq();
		while(m--)
		{
			scanf("%d%d",&a,&b);
			int ans;
			if(dat[a]==dat[b]){ans=b-a+1;}
			else if(rear[head[a]]+1==head[b])
			{
				ans=max(rear[head[a]]-a+1,b-head[b]+1);
			}
			else
			{
				ans=max(rear[head[a]]-a+1,b-head[b]+1);
				ans=max(ans,get_max_rmq(rear[head[a]]+1,head[b]-1));
			}
			printf("%d\n",ans);
		}
	}
	return 0;
}


 

4、poj2109 二维RMQ

/* 求子矩阵的最大值与最小值
 */
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define inf 0x7ffffff
int dpmax[252][252][8];
int dpmin[252][252][8];
int dat[252][252];
int n,b,k;
void make_rmq2()
{
	for(int k=1;(1<<k)<=n;++k)
	{
	for(int i=1;i<=n;++i)
	{
		for(int j=1;j<=n;++j)
		{
			dpmax[i][j][k]=dpmax[i][j][k-1];
			if(i+(1<<(k-1))<=n)
			dpmax[i][j][k]=max(dpmax[i][j][k],dpmax[i+(1<<(k-1))][j][k-1]);
			if(j+(1<<(k-1))<=n)
			dpmax[i][j][k]=max(dpmax[i][j][k],dpmax[i][j+(1<<(k-1))][k-1]);
			if((i+(1<<(k-1))<=n)&&(j+(1<<(k-1))<=n))
			dpmax[i][j][k]=max(dpmax[i][j][k],dpmax[i+(1<<(k-1))][j+(1<<(k-1))][k-1]);
			
			dpmin[i][j][k]=dpmin[i][j][k-1];
			if(i+(1<<(k-1))<=n)
			dpmin[i][j][k]=min(dpmin[i][j][k],dpmin[i+(1<<(k-1))][j][k-1]);
			if(j+(1<<(k-1))<=n)
			dpmin[i][j][k]=min(dpmin[i][j][k],dpmin[i][j+(1<<(k-1))][k-1]);
			if((i+(1<<(k-1))<=n)&&(j+(1<<(k-1))<=n))
			dpmin[i][j][k]=min(dpmin[i][j][k],dpmin[i+(1<<(k-1))][j+(1<<(k-1))][k-1]);			
		}
		
	}
	}
}
int get_max_rmq2(int x,int y,int k)
{
	int r=dpmax[x][y][k];
	if(x+b-(1<<k)<=n)
	r=max(r,dpmax[x+b-(1<<k)][y][k]);
	if(y+b-(1<<k)<=n)
	r=max(r,dpmax[x][y+b-(1<<k)][k]);
	if((x+b-(1<<k)<=n)&&(y+b-(1<<k)<=n))
	r=max(r,dpmax[x+b-(1<<k)][y+b-(1<<k)][k]);
	return r;
}
int get_min_rmq2(int x,int y,int k)
{
	int r=dpmin[x][y][k];
	if(x+b-(1<<k)<=n)
	r=min(r,dpmin[x+b-(1<<k)][y][k]);
	if(y+b-(1<<k)<=n)
	r=min(r,dpmin[x][y+b-(1<<k)][k]);
	if((x+b-(1<<k)<=n)&&(y+b-(1<<k)<=n))
	r=min(r,dpmin[x+b-(1<<k)][y+b-(1<<k)][k]);
	return r;
}
int main()
{
	int x,y;
	while(~scanf("%d%d%d",&n,&b,&k))
	{
		for(int i=1;i<=n;++i)
		{
			for(int j=1;j<=n;++j)
			{
				scanf("%d",&dat[i][j]);
				dpmax[i][j][0]=dpmin[i][j][0]=dat[i][j];
			}
		}
		int p=0;
		while((1<<(p+1))<=b){++p;}
		make_rmq2();
		while(k--)
		{
			scanf("%d%d",&x,&y);
			int ans=get_max_rmq2(x,y,p)-get_min_rmq2(x,y,p);
			printf("%d\n",ans);
		}
	}
	return 0;
}


 

5、Poj2452 RMQ+两次二分

/*
题意：有一串N个不同数字的序列，求出一个最长的连续子序列si~sj，满足si是最小数，sj是最大数。

思路：首先预处理，对于每个si,找出以它为起点后面最大数的位置rear[i].然后二分找到以si为最小值的区间，然后在这个区间里面二分寻找最大值的位置j，j-i的最大值即为所求
*/
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))。
const int N=5e4+2;
int n;
int dat[N];
int dpmax[N][30];
int dpmin[N][30];
int rear[N];
void make_rmq()
{
	for(int j=1;(1<<j)<=n;++j)
	{
		for(int i=1;i+(1<<j)-1<=n;++i)
		{
			dpmax[i][j]=max(dpmax[i][j-1],dpmax[i+(1<<(j-1))][j-1]);
			dpmin[i][j]=min(dpmin[i][j-1],dpmin[i+(1<<(j-1))][j-1]);
		}
	}
}
int get_max_rmq(int a,int b)
{
	int k=0;
	while(a+(1<<k)<b-(1<<k)+1)++k;
	return max(dpmax[a][k],dpmax[b-(1<<k)+1][k]);
}
int get_min_rmq(int a,int b)
{
	int k=0;
	while(a+(1<<k)<b-(1<<k)+1)++k;
	return min(dpmin[a][k],dpmin[b-(1<<k)+1][k]);
}

int main()
{
	while(~scanf("%d",&n))
	{
		for(int i=1;i<=n;++i)
		{
			scanf("%d",&dat[i]);
			dpmin[i][0]=dpmax[i][0]=dat[i];
		}
		int t=n;
		rear[n]=n;
		for(int i=n-1;i>=1;--i)
		{
			if(dat[i]<dat[t])
			{
				rear[i]=t;
			}
			else
			{
				rear[i]=i;
				t=i;
			}
		}
		for(int i=1;i<=n;++i)
		{
		}
		int ans=-1;
		make_rmq();
		for(int i=1;i<=n;++i)
		{
			int low=i,high=rear[i],mid,t=-1;
			if(get_min_rmq(i,high)==dat[i]){t=max(t,high);}
			else{
				while(low<high)
				{
					if(get_min_rmq(i,low)==dat[i])
					{t=max(t,low);}
					if(get_min_rmq(i,high)==dat[i])
					{t=max(t,high);}
					mid=(low+high)/2;
					if(get_min_rmq(i,mid)==dat[i])
					{
						t=max(t,mid);
						low=mid+1;
					}
					else{high=mid-1;}
				}
			}
			high=t;low=i;
			int w=get_max_rmq(low,high);
			if(get_max_rmq(i,high)==dat[high])
			{
				ans=max(ans,high-i);
			}
			else
			{
				while(low<high)
				{
					if(dat[low]==w)
					{ans=max(ans,low-i);}
					if(dat[high]==w)
					{ans=max(ans,high-i);}

					mid=(low+high)/2;
					if(get_max_rmq(i,mid)<w)
					{low=mid+1;}
					else{high=mid-1;
						if(dat[mid]==w)ans=max(ans,mid-i);
					}
				}
			}

		}
		if(ans==0)ans=-1;
		printf("%d\n",ans);
	}
	return 0;
}


 

 

shiwei408
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HIHO #1069 : 最近公共祖先·三(RMQ+DFS LCA在线算法)
qwesde
08-09 332
题目链接 RMQ+DFS 实现在线的算法，dfs把树离散成一棵树，然后跑rmq，这个hihoCoder里面讲解的很好 #include<cstdio> #include<algorithm> #include<iostream> #include<cstring> #include<string> #include<cmath> #include<queue> #include<map> #inc
Acm+java各种数据结构_Acm竞赛算法——数据结构算法分类
weixin_32251071的博客
02-26 623
ACM竞赛的算法，分为了数学、数据结构和算法三大块。一 数学(Mathematics)1 离散数学(Discrete Mathematics)1.1 图论(Graph Theory)图的遍历(Graph Traversal): DFS, BFS最小生成树(Minimum Spanning Tree): Prim, Kruskal最短路径(Shortest Path): Dijkstra, Floy...
浅谈RMQ（RMQ详解）
11-03
最全的RMQ资料，看懂了应该RMQ没问题了
离散化dp
Suryxin's blogs
05-11 189
传送门 题目描述： 在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0，1，……，L（其中L是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。 题目给出独木桥的长度L，青蛙跳跃的距离范
hdoj 4028（离散DP）
zxc的专栏
08-25 436
刚开始的时候一直以为是数论，
过河（离散,dp)
HANGANG的博客
03-22 238
#include<stdio.h> #include<stdlib.h> #include<algorithm> #include<string.h> using namespace std; int dp[2000]; int v[2000]; int a[205]; int main() { int l,s,t,m; scanf(...
hdoj4028(离散DP)
ysjjovo的专栏
09-12 578
1.思路 N数据范围小 先做预处理将1至40的数据打表出来！ DP方程： dp[i]=dp[i-1]//继承 dp[i][j]=d[i][j]+dp[i-1][k]  ,j=lcm(i,k)  j是i和k的最小公倍数 dp[i][j]的含义是前i根针的组合中最小公倍数
ACM巨全模板 .pdf
10-07
7.dp[i]=min(dp[i+1]…dp[i+k]),multset 博弈： 1.NIM博弈 (n堆每次最少取一个) 2.威佐夫博弈(两堆每次取至少一个或一起取一样的) 3.约瑟夫环 4.斐波那契博弈 (取的数依赖于对手刚才取的数) 5.sg函数 数论： 1.数论 ...
[颓废史]蒟蒻的刷题记录
ws_fqk
01-05 3350
QAQ蒟蒻一枚，其实我就是来提供水题库的。 以下记录从2016年开始。1.1 1227: [SDOI2009]虔诚的墓主人 树状数组+离散化 3132: 上帝造题的七分钟 树状数组 二维区间加减+查询 3038: 上帝造题的七分钟2 线段树+剪枝1.2 1047: [HAOI2007]理想的正方形 二维单调队列维护最值1.4 2095: [Poi2010]Bridges 二分+混合图欧拉
ACMer需要掌握的算法讲解 (2).docx
最新发布
03-11
* DP算法：POJ3267、POJ1836、POJ1260、POJ2533 二、图算法 * 度限制最小生成树和第K最短路：POJ1639、POJ3216、POJ2446 * 最优比率生成树：POJ2728 * 最小树形图：POJ3164 * 次小生成树 * 无向图、有向图的最小环...
RMQ求区间最值（最大最小）
08-28
RMQ(Range Minimum/Maximum Query),即区间最大/小值查询，查询的时间复杂度为O（1）
RMQ&LCA;问题
12-04
该ppt讲了一种基于线段树的RMQ的ST算法问题和LCA算法，适合初学者用。
hdu4028 离散DP
好好学习
09-17 503
以后一定要每天都写报告 题意：40个数，选出几个，使其lcm大于等于m,计数DP, map   #include #include #include #include #include #include #define inf (1 << 30)
数学建模笔记（十三）：离散模型（DP、图论）
qq_52441682的博客
07-15 4545
完全路径从某个顶点出发沿着弧方向经过所有顶点的路径称为完全路径连通图概念解释强连通图任意两个顶点之间都存在互达的路径s(2)=As(1)=A∗A∗es(2)=As(1)=A∗A∗e通过AeAeAe所得的结果就是之前的得分向量，此时已经出现了一定的排名，我们将AAA与这个6行1列的矩阵再做一次矩阵乘法，不断重复这个过程。最终排名将会稳定下来，就可以将稳定的结果作为排名的依据。...
一道莫名其妙的离散化dp
CRZbulabula的博客
10-30 711
青蛙 (frog.pas/c/cpp) 【问题描述】 在韩国，成古利(一种青蛙)的顽皮是出名的，它总是在晚上到稻田上乱逛，并踩平水稻。 这种青蛙总是以直线跳过稻田，且每个跳跃的长度都是一样： 如下 Figure-1 是一片稻田，Figure-2 则是青蛙的路径，黑色的点表示被踩平的水稻 在晚上，有可能许多青蛙跳到你的稻田中，如 Figure-3 就是三只青蛙跳过的路径（注 意，有可能
数位DP（离散化+技巧）
nucshiyilang的博客
05-22 366
题目链接 从1到9的最小公倍数是2520，每一个数被自己的非零位整除，则一定为2520的某一个因子整除，因此求和可以直接对2520取模，这样不影响结果，从1到2520，所有的最小公倍数只有48个，因此可以离散化一下，后面就是数位dp的过程了。dp[pos][presum][index[prelcm]]表示到了第几位，到目前为止和为多少，到目前为止的lcm值。 #include #include
RMQ算法的介绍
ruangongshi的专栏
07-22 386
1. 概述      RMQ（Range Minimum/Maximum Query），即区间最值查询，是指这样一个问题：对于长度为n的数列A，回答若干询问RMQ（A,i,j）(i,j 间的最小/大值。这两个问题是在实际应用中经常遇到的问题，下面介绍一下解决这两种问题的比较高效的算法。当然，该问题也可以用线段树（也叫区间树）解决，算法复 杂度为：O(N)~O(logN)，这里我们暂不介绍。
离散化+dp+线段树
shaohang_的博客
08-26 415
YJJ's Salesman Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 729    Accepted Submission(s): 204   Problem Description YJJ is a salesman wh...
HDU 5008 Boring String Problem 后缀数组 RMQ
leodestiny
09-15 1121
题意：给出一个字符串，求出第k大的
RMQ与LCA算法详解及其相互转化
"该资源主要探讨了RMQ（Range Minimum Query，区间最小值查询）和LCA（Lowest Common Ancestor，最近公共祖先）两种算法，并通过关系图展示了它们之间的联系。文章首先介绍了这两个概念，然后阐述了它们在信息学竞赛...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值