POJ 3368 Frequent values

题目大意：

给定一个非递减的整数序列（n），然后给出m个查询区间，针对每一个查询，输出次去间内出现次数最多的“次数”。

例如：n=10,m=3

非递减序列：-1 -1 1 1 1 1 3 10 10 10

查询序列：

2 3

1 10

5 10

则结果分别是：1，4，3。

看到这道题，最直接的想法是针对每一个序列q(x,y)，线性扫描统计区间x~y中每一数字出现的次数，求出最大值。但是由于

m非常大，这样的查询很耗时。

提到“区间内查询问题”，这时候就想到线段树：可以用于查询某一个区间的最大值，最小值等。而查询的时间复杂度只是lgn。

但是这道题怎么用线段树来处理呢？

根据题意，给定序列时非递减序列，于是可以将相同节点通过离散化压缩到线段树的叶子节点，并记录其出现次数。所以，给

定一个查询q(x,y)，如果x和y正好处在“序列中某个整数的起始和结束位置“，那么，可以通过线段树查询得到x~y间出现的最多

次数。如果是其他情况呢？

我们可以考虑把序列中相同元素分组，并根据分组情况如下划分：

1. 如果x和y在一个组，那么最长长度就是y - x + 1

2. 如果组号相差1，那么找出两者的分界点z(假设z点和x点组号相同)，那么答案就是Max{z - x + 1, y - z}

3. 如果相差大于1，那么先将两头截掉，统计大的记录，再和中间那段的最大值比较大小，中间那段的最大值可以用线段树

区间查询最值



#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;
const int M = 100010;
struct node
{
		int l,r;
		int c;
}tr[10*M];
struct group
{
		int v;
		int s,e;
}map[M];
int n,q;
int a[M];

int cmp(const void *a,const void *b)
{
		return *(int *)a -*(int *)b;
}
void build(int l,int r,int p)
{
		tr[p].l=l;
		tr[p].r=r;
		tr[p].c=0;
		if(l==r)
				return;
		int mid = (l+r)>>1;

		build(l,mid,p*2);
		build(mid+1,r,p*2+1);
}
void insert(int r,int c,int p)
{
		if(tr[p].r==tr[p].l && tr[p].r==r)
		{
				tr[p].c=c;
				return;
		}

		int mid= (tr[p].l+tr[p].r)>>1;
		if(r<=mid)
				insert(r,c,p*2);
		else
				insert(r,c,p*2+1);

		tr[p].c = tr[p*2].c>tr[p*2+1].c?tr[p*2].c:tr[p*2+1].c;
}
int query(int l,int r,int p)
{
		if(l==tr[p].l && r==tr[p].r)
		{
				return tr[p].c;
		}

		int mid = (tr[p].l+tr[p].r)>>1;

		if(l>mid)
				return query(l,r,p*2+1);
		else if(r<=mid)
				return query(l,r,p*2);
		else
		{
				int tmp1=query(l,mid,p*2);
				int tmp2 = query(mid+1,r,p*2+1);
				return tmp1>tmp2?tmp1:tmp2;
		}
}
int bin_search(int n,int key)
{
		int l=1;
		int h=n;
		while(l<=h)
		{
				int mid = l+(h-l)/2;
				if(map[mid].v>key)
						h=mid-1;
				else if(map[mid].v<key)
						l=mid+1;
				else
						return mid;

		}
		return l;
}
int main()
{
		scanf("%d",&n);
		while(n!=0)
		{
				memset(tr,0,sizeof(tr));
				memset(map,0,sizeof(map));
				memset(a,0,sizeof(a));
				scanf("%d",&q);
				int i =0;
				for(i=1;i<=n;i++)
				{
						scanf("%d",&a[i]);
				}

				int j=1;
				map[j].v=a[1];
				map[j].s=1;
				map[j].e=1;
				for(i=2;i<=n;i++)
				{
					if(a[i]!=a[i-1])
					{
						j++;
						map[j].v=a[i];
						map[j].s=i;
						map[j].e=i;
					}
					else
							map[j].e++;
				}
				int len = j;
				build(1,j,1);
				for(i=0;i<n;i++)
				{
						int tmp = bin_search(len,a[i]);
						int c = map[tmp].e-map[tmp].s+1;
						insert(tmp,c,1);
				}
				for(i=0;i<q;i++)
				{
						int sum=0;
						int l,r;
						scanf("%d %d",&l,&r);

						int g1 = bin_search(len,a[l]);
						int g2 = bin_search(len,a[r]);

						if(g1==g2)
								sum = r-l+1;
						else if(g2-g1==1)
						{
								int tmp1 = r-map[g2].s+1;
								int tmp2 = map[g1].e-l+1;
								sum = tmp1>tmp2?tmp1:tmp2;
						}
						else
						{
								int tmp1 = r-map[g2].s+1;
								int tmp2 = map[g1].e-l+1;
								sum = tmp1>tmp2?tmp1:tmp2;

								int sum1 = query(g1+1,g2-1,1);
								if(sum1>sum)
										sum=sum1;
						}
						printf("%d/n",sum);
				}
				scanf("%d",&n);

		}
}