El robot más ágil LibreOJ-10120 RMQ problema para hacer un máximo y un mínimo respectivamente

El viento ha diseñado muchos robots. Pero todos piensan que son los más fuertes, por lo que comienza un juego ...

Los robots quieren saber quién es el más ágil, por lo que jugaron la siguiente competencia. En primer lugar, habrá una fila de n n números delante de ellos.  Verán quién puede anotar el valor máximo y mínimo de cada número k k consecutivo en el juego  . Por supuesto, estos robots son muy rápidos en el cálculo, ¿y a quién están jugando? Escribe rápido

Pero Wind también quiere saber la respuesta. ¿Puedes ayudarlo?

Entrada

La primera línea es  n , k n, k, y el significado es como se describe en el título.

La segunda línea tiene un total de  n n números y es una secuencia de números Todos los números están en Pascal el longint rango, es decir, todos los números son enteros y están en  el  rango  [ - 2 31 , 2 31 - 1 ] [−231,231−1].

Salida

Hay  n - k + 1 n − k + 1 filas, y la fila  i i th  es el máximo y el mínimo de los números k k del i i th al  i + k - 1 i + k − 1  .

Ejemplo

Entrada de muestra

5 3
1 2 3 4 5

Salida de muestra

3 1
4 2
5 3

Insinuación

Para todos los datos, 1 ≤ k ≤ n ≤ 10 5 1 ≤ k ≤ n ≤ 105.

#include <bits / stdc ++. h>
 usando el  espacio de nombres std; 
en línea ll read () { 
    char ch = getchar (); ll res = 0 , f = 1 ;
    while (ch < ' 0 ' || ch> ' 9 ' ) { if (ch == ' - ' ) f = - 1 ; ch = getchar ();}
     while (ch> = ' 0 ' && ch <= ' 9 ' ) res = res * 10 + ch- ' 0 ' , ch = getchar ();
    res * f; 
} escritura vacía en 
línea (ll zx) {
     if (zx < 0 ) zx = -zx, putchar ( ' - ' );
    if (zx < 10 ) putchar (zx + ' 0 ' );
    else { 
        escribir (zx / 10 ); 
        putchar (zx % 10 + ' 0 ' ); 
    } 
} 
ll n, m, a [ 100010 ], f [ 100010 ] [ 20 ], f2 [ 100010 ] [ 20 ];
nulo ST () {
     para (ll i = 1 ; i <= n; i ++) f [i] [ 0 ] = a [i];
    para (ll j = 1 ; ( 1 << j) <= n; j ++ ) {
         para (ll i = 1 ; i + ( 1 << j) - 1 <= n; i ++ ) { 
            f [i] [j] = max (f [i] [j- 1 ], f [i + ( 1 << (j- 1 ))] [j- 1 ]); 
        } 
    } 
} 
ll RMQ (ll l, ll r) { 
    ll k = 0 ;
    mientras que (( 1 << (k +1 )) <= r-l + 1 ) k ++ ;
    return max (f [l] [k], f [r- ( 1 << k) + 1 ] [k]); 
} 
nulo ST2 () {
     para (ll i = 1 ; i <= n; i ++) f2 [i] [ 0 ] = a [i];
    para (ll j = 1 ; ( 1 << j) <= n; j ++ ) {
         para (ll i = 1 ; i + ( 1 << j) - 1 <= n; i ++ ) { 
            f2 [i] [j] = min (f2 [i] [j- 1 ], f2 [i + ( 1 << (j- 1 ))] [j- 1 ]);
        } 
    } 
} 
ll RMQ2 (ll l, ll r) { 
    ll k = 0 ;
    mientras que (( 1 << (k + 1 )) <= r-l + 1 ) k ++ ;
    retorno min (f2 [l] [k], f2 [r- ( 1 << k) + 1 ] [k]); 
} 
int main () { 
    n = read (); m = read ();
    para (ll i = 1 ; i <= n; i ++) a [i] = read (); 
    ST (); ST2 (); 
    para (ll i = 1 ; i <= n-m + 1 ; i ++ ) { 
        write (RMQ (i, i + m- 1)); 
        putchar ( '  ' ); 
        escribir (RMQ2 (i, i + m- 1 )); 
        putchar ( ' \ n ' ); 
    } 
    devuelve  0 ; 
}