POJ 3368 Frequent values（RMQ）

Posted 2020-06-17 小胡子Haso

【POJ 3368】 Frequent values（RMQ）

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 15813		Accepted: 5749

Description

You are given a sequence of n integers a₁ , a₂ , ... , a_n in non-decreasing order. In addition to that, you are given several queries consisting of indices i and j (1 ≤ i ≤ j ≤ n). For each query, determine the most frequent value among the integers a_i , ... , a_j.

Input

The input consists of several test cases. Each test case starts with a line containing two integers n and q (1 ≤ n, q ≤ 100000). The next line contains n integers a₁ , ... , a_n (-100000 ≤ a_i ≤ 100000, for each i ∈ {1, ..., n}) separated by spaces. You can assume that for each i ∈ {1, ..., n-1}: a_i ≤ a_i+1. The following q lines contain one query each, consisting of two integers i and j (1 ≤ i ≤ j ≤ n), which indicate the boundary indices for the
query.

The last test case is followed by a line containing a single 0.

Output

For each query, print one line with one integer: The number of occurrences of the most frequent value within the given range.

Sample Input

10 3
-1 -1 1 1 1 1 3 10 10 10
2 3
1 10
5 10
0

Sample Output

1
4
3

Source

Ulm Local 2007

题目意思比较明了，给出一个长n的有序数组，固定是升序。之后q次查询，每次询问区间[l,r]中出现的最长连续相同序列的长度。

刚开始想直接上ST算法，发现不是很直接的ST，需要一些辅助的东西来变换。就直接先写了发线段树。

发现线段树思路很清晰，先用num数组存下n个数的值。

对于区间[L,R]存三个值

mx:当前区间中最大的连续相同序列长度，也就是答案。

lmx:从左端点开始往右能找到的最大的相同序列长度。

rmx:从右端点开始往左能找到的最大的相同序列长度。

这样就可以做递归的初始化了，对于叶子来说 三个值一样  都是1，因为只有当前位置这一个数

对于区间[L,R] 可由[L,MID] [MID+1,R]组合

首先[L,R]的mx是两个子区间mx中大的一个

如果num[MID] == num[MID+1] 说明左右子区间中间可以连接 [L,R]的mx还要跟[L,MID].r+[MID+1,R].l比较 存较大的一个

如果[L,MID].l == MID-L+1，也就是左子区间中的数全是相同的，[L,R].l = [L,MID].l+[MID+1,R].l。否则 [L,R].l = [L,MID].l

同理 如果[MID+1,R].r == R-MID，也就是右子区间中的数全是相同的，[L,R].r = [MID+1,R].r+[L,MID].r。否则 [L,R].r = [MID+1,R].r

这样线段树的初始化就完成了

对于询问来说 询问[l,r]区间的答案

如果当前区间[L,R] MID >= r 或者MID+1 <= l 就正常跑左子树或右子树

否则 就要找左右两边递归出的较大值 另外 还要考虑num[MID] == num[MID+1]的情况 再跟左区间右端点开始的最长序列+右区间左端点开始的最长序列长度比较一下 选一个较大的即可 此时还要对左右区间的端点开始序列长度进行一些切割 越出的就去掉，最后得到的就是所求的答案

线段树思路比较好想 但写起来略繁琐 可能出现各种错误

提供份自己的代码，大家可参考下：

#include <iostream>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#define LL long long
#define Pr pair<int,int>
#define fread() freopen("in.in","r",stdin)
#define fwrite() freopen("out.out","w",stdout)

using namespace std;
const int INF = 0x3f3f3f3f;
const int msz = 10000;
const int mod = 1e9+7;
const double eps = 1e-8;

struct Tree
{
	int l,r,mx;
};

//线段树
Tree bit[433333];
//存放n个数
int a[233333];

void init(int root,int l,int r)
{
	if(l == r)
	{
		scanf("%d",&a[l]);
		bit[root].mx = bit[root].l = bit[root].r = 1;
		return;
	}
	int mid = (l+r)>>1;
	init(root<<1,l,mid);
	init(root<<1|1,mid+1,r);

	bit[root].mx = max(bit[root<<1].mx,bit[root<<1|1].mx);

	//如果左右子区间中间可连接，进行一些选取
	if(a[mid] == a[mid+1]) 
	{
		bit[root].mx = max(bit[root].mx,bit[root<<1].r+bit[root<<1|1].l);
		if(bit[root<<1].l == mid-l+1) bit[root].l = bit[root<<1].l+bit[root<<1|1].l;
		else bit[root].l = bit[root<<1].l;

		if(bit[root<<1|1].r == r-mid) bit[root].r = bit[root<<1|1].r+bit[root<<1].r;
		else bit[root].r = bit[root<<1|1].r;
	}
	else
	{
		bit[root].l = bit[root<<1].l;
		bit[root].r = bit[root<<1|1].r;
	}
}

int Search(int root,int l,int r,int ll,int rr)
{
	if(l == ll && r == rr)
		return bit[root].mx;

	int mid = (l+r)>>1;
	if(mid >= rr) return Search(root<<1,l,mid,ll,rr);
	else if(mid+1 <= ll) return Search(root<<1|1,mid+1,r,ll,rr);
	else
	{
		int tmp = 0;
		if(a[mid] == a[mid+1]) tmp = min(mid-ll+1,bit[root<<1].r)+min(rr-mid,bit[root<<1|1].l);
		return max(max(Search(root<<1,l,mid,ll,mid),Search(root<<1|1,mid+1,r,mid+1,rr)),tmp);
	}
}

int main()
{
	//fread();
	//fwrite();

	int n,m,l,r;
	while(~scanf("%d",&n) && n)
	{
		scanf("%d",&m);
		init(1,1,n);
		while(m--)
		{
			scanf("%d%d",&l,&r);
			printf("%d\n",Search(1,1,n,l,r));
		}
	}

	return 0;
}

今天又想了下ST的写法，大体讲一下，可能讲的不是很明白，大家谅解～

不过提交发现跟线段树相比就优化了几百MS（其实也蛮多了，毕竟2000MS时限，。

大体思路就是在存放数值的数组num之外，再开一个辅助数组f 表示从当前位置往后最多能连续到的位置

比如这个数据:

10 3
-1 -1 1 1 1 1 3 3 10 10

对应的f数组就是

 2  2 6 6 6 6 7 7 10 10

对于rmq数组 我的写法是初始化时允许越出 就是只存储当前区间中出现过的数往后延伸出的最大的的长度，超出界限也允许。

这样在查询时需要加一些特殊处理，可能是导致时间不是很理想的原因。

初始化跟普通的rmq一样 就不详讲了

对于查询区间[L,R] 存在三种情况：

1.f[L] >= R 就是整个区间都是连续相同 类似【这种状态 这样答案就是R-L+1

2.f[f[L]+1] >= R 就是刚好两半的情况 类似【】【 这种状态 譬如上面数据中查询[4,7] 刚好是两种数 输出答案就是f[L]-L+1和R-f[L]中较大的一个

3.其余情况，就是类似 【】【】【】【】【 这种状态 其实会发现上面两种都是这种情况的延伸，其实就是两个很细小的剪枝，不过也省去了一些区间为负的特判。

对于这种情况 就需要二分出最后一个残缺的区间的左端点，因为在最开始提到 这个我写的这个ST的数组允许越出，对于右边界需要特殊处理。我想到的是二分。。所以这里可能会多一个nlogn 这样找到右边那个残缺区间的左端点后就好做了 求一下完整区间的RMQ 然后与右部的长度选一个较大的，即为答案

代码如下：

#include <iostream>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#define LL long long
#define Pr pair<int,int>
#define fread() freopen("in.in","r",stdin)
#define fwrite() freopen("out.out","w",stdout)

using namespace std;
const int INF = 0x3f3f3f3f;
const int msz = 10000;
const int mod = 1e9+7;
const double eps = 1e-8;

int num[233333];
int f[233333];
int rmq[233333][19];
int n;

void init()
{
	for(int i = 1; i <= n; ++i)
		scanf("%d",&num[i]);

	for(int i = n; i >= 1; --i)
		if(i != n && num[i] == num[i+1]) f[i] = f[i+1];
		else f[i] = i;

	for(int k = 0; k <= 18; ++k)
		for(int i = 1; i <= n && i+(1<<k)-1 <= n; ++i)
			if(!k) rmq[i][k] = f[i]-i+1;
			else rmq[i][k] = max(rmq[i][k-1],rmq[i+(1<<(k-1))][k-1]);
}

int RMQ(int l,int r)
{
	int k = log((r-l+1)*1.0)/log(2.0);
	return max(rmq[l][k],rmq[r-(1<<k)+1][k]);
}

int main()
{
	//fread();
	//fwrite();

	int q,l,r;
	while(~scanf("%d",&n) && n)
	{
		scanf("%d",&q);
		init();
		while(q--)
		{
			scanf("%d%d",&l,&r);
			if(f[l] >= r) printf("%d\n",r-l+1);
			else if(f[f[l]+1] >= r) printf("%d\n",max(f[l]-l+1,r-f[l]));
			else
			{
				int ans = -1;
				int ll = f[l]+1,rr = r;
				while(ll <= rr)
				{
					int mid = (ll+rr)>>1;
					if(f[mid] == f[r])
					{
						ans = mid;
						rr = mid-1;
					}else ll = mid+1;
				}
				printf("%d\n",max(RMQ(l,ans-1),r-ans+1));
			}
		}
	}


	return 0;
}