POJ 3368 Frequent values (线段树)

Frequent values

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 11083		Accepted: 4063

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(1~100000)个点的序列，从大到小排序，有一些点的大小是相等的，问区间[a,b]上，相等大小的点最多是几个。

 

思路：线段树+离散化。离散的运用：将连续的相等的一个区间的点集，聚集为线段树的一个节点，并且在这个节点上有信息能体现出这个区间的性质。

 

#include<iostream>
#include<cstdio>
#include<cstring>

using namespace std;

const int N=100010;

#define L(rt) (rt<<1)
#define R(rt) (rt<<1|1)

struct Tree{
    int l,r;
    int len;    //  len保存这个点集的点的数量
}tree[N<<2];

struct Point{
    int x,y;
}seg[N];

int num[N],hash[N];

void PushUp(int rt){
    tree[rt].len=max(tree[L(rt)].len,tree[R(rt)].len);
}

void build(int l,int r,int rt){
    tree[rt].l=l;
    tree[rt].r=r;
    if(l==r){   
        tree[rt].len=seg[l].y-seg[l].x+1;
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,L(rt));
    build(mid+1,r,R(rt));
    PushUp(rt);
}

int ans;

void query(int L,int R,int rt){
    if(tree[rt].l==L && tree[rt].r==R){
        ans=max(ans,tree[rt].len);
        return ;
    }
    int mid=(tree[rt].l+tree[rt].r)>>1;
    if(R<=mid)
        query(L,R,L(rt));
    else if(L>=mid+1)
        query(L,R,R(rt));
    else{
        query(L,mid,L(rt));
        query(mid+1,R,R(rt));
    }
}

int main(){

    //freopen("input.txt","r",stdin);

    int n,m;
    while(~scanf("%d",&n) && n){
        scanf("%d",&m);
        for(int i=1;i<=n;i++)
            scanf("%d",&num[i]);
        int cnt=0,pre=999999;
        for(int i=1;i<=n;i++){   //  离散化，将点的序列离散化为一个个的点集
            if(num[i]!=pre){
                pre=num[i];
                cnt++;
                seg[cnt].x=i;
                seg[cnt].y=i;
            }else
                seg[cnt].y=i;
            hash[i]=cnt;        //  hash保存序列上第i个点，对应的点集的下标
        }
        build(1,cnt,1);
        int a,b;
        while(m--){
            scanf("%d%d",&a,&b);
            int loc1=hash[a];   //如下，好的主函数操作能很大程度上简化线段树的复杂度
            int loc2=hash[b];
            if(loc1==loc2)      //  情况1：[a,b]为一个点集
                printf("%d\n",b-a+1);
            else{               //  情况2，3：[a,b]包含多个点集
                int n1=seg[loc1].y-a+1;
                int n2=0;
                int n3=b-seg[loc2].x+1;
                if(loc2-loc1>1){    //情况3：[a,b]包含3个以上点集，中间点集最大值用到线段树
                    ans=0;
                    query(loc1+1,loc2-1,1);
                    n2=ans;
                }
                printf("%d\n",max(n1,max(n2,n3)));
            }
        }
    }
    return 0;
}