UVA-11235 Algorithme de valeurs fréquentes-ST + encodage de la longueur de course

Valeurs fréquentes

Description:
Étant donné une séquence, a1, a2 ... a3, votre tâche consiste à répondre au nombre d'occurrences de la valeur la plus fréquente dans ai, ... aj pour une série de requêtes (i, j).

Idée: l'
algorithme ST peut être utilisé pour ce problème, mais je ne m'attendais pas à ce que la principale difficulté de codage soit dans le prétraitement des données.
Utilisez une structure struct node{ int value,cnt; node(int v,int c):value(v),cnt(c){} };pour stocker la valeur d'un segment de nombres et le nombre d'occurrences.

Utilisez la structure pour struct pos{ int index,left,right; pos(int index,int l,int r):index(index),left(l),right(r){} };stocker le numéro du segment où se trouve une certaine position et la position des extrémités gauche et droite de ce segment

Traitement de la situation de division temporelle de la requête:
①L et R sont dans le même segment La
réponse est L-R + 1
②L, R avec 2 segments et plus ajoutés
et ans devrait être à
x1 = index (L) .droite-L + 1
x2 = R-index ( R) .gauche + 1
x3 = ST (index (L) +1, index (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;
}