consulta decimal IK

Enlaces: https://ac.nowcoder.com/acm/contest/3979/I
Fuente: Red de Ganado-off

título Descripción

 

 

Ideas: A primera vista, el título hace que quiera empezar a pensar en dirección a los grosores de línea de árboles más el Presidente del árbol, pero hay operaciones de modificación, porque no puedo empezar;

Después leí otras personas blog, sobre todo por medio del bloque

En este código, el tamaño de cada bloque es sqrt (n);

Nos bloque total, entonces dos parámetros de matriz para describir la información de segmentos: L R [i] [i] se describirá acerca de los puntos extremos de la i-ésimo bloque;

A continuación, ordenar los datos en el bloque;

Para las operaciones de actualización: Nos fuimos y criterios de valoración adecuados para atravesar el punto entero nuevo bloque pertenece, y luego actualiza el valor de la especie;

  ¿Por qué dos actualización independiente esto? Desde operación de actualización no es muy probablemente relevante para cubrir ambos bloques finales, la actualización directamente

  A continuación, es posible cubrir todo el bloque, es decir, entre los otros bloques LR, vamos a un nodo etiquetado perezoso, actualización directa puede hacerse cargo (hasta que la consulta cambió de nuevo)

  Abajo esta manera, si el tamaño de bloque k es la complejidad operación de modificación es 2 k * * log (k) (donde los dos extremo actualización puntos bloque de pedido +) + k (lr traverse bloque intermedio)

Para consulta: Utilizamos la mitad del camino, enumerar la respuesta, según el juez: si fuera del ans era mayor o igual k

  El funcionamiento restante con actualización sustancialmente similar;

  Vamos a terminar alrededor de su bloque para atravesar de nuevo, actualización de respuesta (2 * k)

  Recorrido de la gama media, el valor de rango medio perezoso o menos si determina la respuesta, además de que tenemos toda la gama,

         Por el contrario, todo el intervalo de desplazamiento, para encontrar el número de respuestas coincidentes; sustancialmente la complejidad (logk * k) logk como la operación de límite distinto, k es el número de bloques;

  Por lo tanto, la complejidad de la consulta aproximadamente: (2 * k + logk * k) * log n; k = sqrt (n)

1 #include <. Bits / STDC ++ h>
 2  #define registro rint int
 3  #define deb (x) cerr << # x << "=" << (x) << '\ n';
4  usando  espacio de nombres std;
5 typedef largo  largo ll;
6  utilizando pii = par < int , int > ;
7  const  int maxN = 8E4 + 5 ;
8  int n, m, un [maxN];
9  int tamaño, bnum, lz [maxN];
10  int L [maxN], R [maxN];
11 vector < int> V [maxN];
12  
13 inline int get_id ( int x) {
 14      retorno x / tamaño;
15  }
 16  
17 inline void actualización ( int l, int r, int x) {
 18      int id = get_id (l);
19      si (L [id] < l) {
 20          v [id] .clear ();
21          para ( int i = L [id]; i <= R [id]; i ++ ) {
 22              a [i] = min (a [i], lz [id]);
23             si (i> = l && i <= r) a [i] = min (a [i], x);
24              v [id] .push_back (a [i]);
25          }
 26          sort (v [id] .begin (), v [id] .end ());
27          Identificación ++ ;
28      } 
 29      si (id> = bnum) de retorno ;
30      , mientras que (R [id] <= r && id < bnum) {
 31          lz [id] = min (LZ [id], x);
32          Identificación ++ ;
33      } 
 34      
35      si (L [id]> r || id> = bnum) de retorno ;
36      v [id] .clear ();
37     para ( int i = L [id]; i <= R [id]; i ++ ) {
 38          a [i] = min (a [i], lz [id]);
39          si (i> = l && i <= r) a [i] = min (a [i], x);
40          v [id] .push_back (a [i]);
41      }
 42      sort (v [id] .begin (), v [id] .end ());
43  }
 44  
45 inline int ck ( int l, int r, int k) {
 46      int id = get_id (l), res = 0 ;
47      si (L [id] < l) {
 48          para (int i = l; i <= min (R [id], r); i ++ ) {
 49              a [i] = min (a [i], lz [id]);
50              si (a [i] <= k) res ++ ;
51          }
 52          Identificación ++ ;
53      }
 54      si (id> = bnum) de retorno res;
55      , mientras que (R [id] <= r && id < bnum) {
 56          si (LZ [id] <= k) res + = R [id] - L [id] + 1 ;
57          else res + = upper_bound (v [id] .begin (), v [id] .end (), k) - v [id] .begin ();
58          Identificación ++ ;
59      }
60      si (L [id]> r || id> = bnum) de retorno res;
61      para ( int i = L [id]; i <= min (R [id], r); i ++ ) {
 62          a [i] = min (a [i], lz [id]);
63          si (a [i] <= k) res ++ ;
64      }
 65      de retorno res;
66  }
 67  
68 inline int consulta ( int L, int R, int k) {
 69      int l = 1 , r = 1E9, mid;
70      , mientras que (l <= r) {
71          mediados = l + r >> 1 ;
72          Si (ck (L, R, MID)> = k) r = mid - 1 ;
73          otro l = mediados + 1 ;
74      }
 75      de retorno l;
76  }
 77  
78  int main () {
 79      scanf ( " % d% d " , y n, y m);
80      para ( int i = 0 ; i <n; i ++) scanf ( " % d " , a + i);
81      size = sqrt (n), bnum = (n - 1) / Tamaño + 1 ;
82      para ( int i = 0 ; i <bnum; i ++ ) {
 83          lz [i] = 0x3f3f3f3f ;
84          L [i] = i * tamaño, R [i] = i * tamaño + tamaño - 1 ;
85          si (i == bnum - 1 ) R [i] = n - 1 ;
86          para ( int j = L [i]; j <= R [i]; j ++ ) v [i] .push_back (a [j]);
87          sort (v [i] .begin (), v [i] .end ());
88      }
 89      mientras que (M-- ) {
 90          int op, l, r, k;
91          scanf ( " % d% d% d% d " , & OP, & l, & r, y k);
92          yo--, r-- ;
93          Si (op == 1 ) actualización (l, r, k);
94          otra cosa printf ( " % d \ n " , consulta (l, r, k));
95      }
 96 }

https://blog.csdn.net/Scar_Halo/article/details/104095690 (extracto de este blog)

 

Supongo que te gusta

Origin www.cnblogs.com/pangbi/p/12464978.html
Recomendado
Clasificación