[uva11235]Frequent values（RMQ，ST，离散化）

题目链接：https://vjudge.net/problem/UVA-11235

题意：给一串不递减数字，q次询问，每次查询[l,r]内出现次数最多的数字出现的次数。

查询分两部分：一部分是[l,r]为同一个数的区间，另一部分则是在上下界处截取一部分的情况。

首先离散化，后用l[],r[],v[]分别记录每一段相同数字的左右区间和出现次数。v可以直接由r-l+1更新得到。

第一部分更新ret后，接下来的rmq分三部分：

第一部分查询左边界截取一部分的数字的当前长度，第二部分查询右边界的，第三部分查询删掉左右边界后中间完整的部分的最值。

ST表维护最值就好了。

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int maxn = 100100;

int n, m, q;
int a[maxn];
int h[maxn], hcnt;

int l[maxn], r[maxn], v[maxn];
int dp[maxn][33];

void st(int* b) {
    for(int i = 1; i <= m; i++) dp[i][0] = b[i];
    int k = int(log(n+1.0)/log(2.0));
    for(int j = 1; j <= k; j++) {
        for(int i = 1; i + (1 << j) - 1 <= m; i++) {
            dp[i][j] = max(dp[i][j-1], dp[i+(1<<(j-1))][j-1]);
        }
    }
}

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

int id(int x) {
    return lower_bound(h, h+hcnt, x) - h + 1;
}

int main() {
    // freopen("in", "r", stdin);
    while(~scanf("%d",&n) && n) {
        scanf("%d", &q);
        memset(l, 0, sizeof(l));
        memset(r, 0, sizeof(r));
        memset(v, 0, sizeof(v));
        m = -1;
        int pre = -1, ll = 1, rr, cnt = 0;
        for(int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            h[i-1] = a[i];
        }
        sort(h, h+n); hcnt = unique(h, h+n) - h;
        for(int i = 1; i <= n; i++) a[i] = id(a[i]);
        for(int i = 1; i <= n; i++) {
            if(pre != a[i]) {
                l[++m] = ll, r[m] = i - 1;
                v[m] = r[m] - l[m] + 1;
                pre = a[i];
                ll = i;
                cnt = 1;
            }
            else rr++, cnt++;
        }
        l[++m] = ll, r[m] = n;
        v[m] = r[m] - l[m] + 1;
        st(v);
        while(q--) {
            scanf("%d %d", &ll, &rr);
            if(a[ll] == a[rr]) {
                cout << rr - ll + 1 << endl;
                continue;
            }
            int ret = max(0, r[a[ll]]-ll+1);
            ret = max(ret, rr-l[a[rr]]+1);
            if(a[ll] + 1 <= a[rr] - 1) ret = max(ret, query(a[ll]+1, a[rr]-1));
            cout << ret << endl;
        }
    }
    return 0;
}