UVA-11235 Valores frecuentes: algoritmo ST + codificación de longitud de ejecución

Valores frecuentes

Descripción:
Dada una secuencia, a1, a2 ... a3, su tarea es responder el número de ocurrencias del valor más frecuente en ai, ... aj para una serie de consultas (i, j).

Idea:
El algoritmo ST se puede utilizar para este problema, pero no esperaba que la principal dificultad de codificación estuviera en el preprocesamiento de datos.
Use una estructura struct node{ int value,cnt; node(int v,int c):value(v),cnt(c){} };para almacenar el valor de un segmento de números y el número de ocurrencias.

Use la estructura para struct pos{ int index,left,right; pos(int index,int l,int r):index(index),left(l),right(r){} };almacenar el número del segmento donde se ubica una determinada posición y la posición de los puntos finales izquierdo y derecho de este segmento

Tratando con la situación de división de tiempo de la consulta:
①L y R están en el mismo segmento La
respuesta es L-R + 1
②L, R con 2 segmentos o más en el medio La respuesta
debe estar en
x1 = índice (L) .right-L + 1
x2 = índice R ( R) .left + 1
x3 = ST (índice (L) +1, índice (R) -1)
.

#include<stdio.h>
#include<iostream>
#include<cmath>
#include<math.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<map>
#define ms0(a) memset(a,0,sizeof(a))
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;

const int maxn = 1e5+10;
int n,q,d[maxn][20];

struct node{
    int value,cnt;
    node(int v,int c):value(v),cnt(c){}
};
struct pos{
    int index,left,right;
    pos(int index,int l,int r):index(index),left(l),right(r){}
};
void ST_init(const vector<int>& A)
{
    int n = (int)A.size();
    for(int i=0;i<n;i++) d[i][0]=A[i];
    for(int j=1;(1<<j)<=n;j++)
    {
        for(int i=0;i+(1<<j)-1<n;i++)
        {
            d[i][j] = max(d[i][j-1],d[i+(1<<(j-1))][j-1]);
        }
    }
}

int ST(int l,int r)
{
    int k = 0;
    while (1<<(k+1)<=r-l+1) k++;
    return max(d[l][k],d[r-(1<<k)+1][k]);
}

int main(){
    while(~scanf("%d",&n)&&n)
    {
        vector<node> num;vector<pos> a;
        vector<int> A;
        ms0(d);
        int x,y;
        scanf("%d",&q);
        scanf("%d",&x);
        num.push_back(node(x,1));
        for(int i=2;i<=n;i++)
        {
            scanf("%d",&y);
            if(x==y){
                num[num.size()-1].cnt++;
            }
            else{
                num.push_back(node(y, 1));
            }
            x=y;
        }
        int count = 0;
        a.push_back(pos(0,0,0));//填充0位置
        int size = num[0].cnt; count++;
        for(int j=1;j<=size;j++)
            a.push_back(pos(count,1,size));
        for(int i=1;i<num.size();i++)
        {
            int size = num[i].cnt; count++;
            int lastRight = a[a.size()-1].right;
            for(int j=1;j<=size;j++)
            {
                a.push_back(pos(count,lastRight+1, lastRight+size));
            }
        }
        for(int i=0;i<num.size();i++)
            A.push_back(num[i].cnt);
        ST_init(A);
        for(int i=1;i<=q;i++)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            if(a[l].index==a[r].index)
                printf("%d\n",r-l+1);
            else
            {
                int ans = max(a[l].right-l+1,r-a[r].left+1);
                int L = a[l].index+1,R = a[r].index-1;
                ans = max(ans,L<=R?ST(L-1, R-1):0);
                printf("%d\n",ans);
            }
        }
    }
    return 0;
}