En Word factorización

Dadas dos cadenas $S_1, S_2$ , escribimos $S_1S_2$ para su concatenación. Dada una cadena $S$ y número entero $k\geq 1$ , escribimos $(S)^k = SS\cdots S$ para la concatenación de $k$ copias de $S$ . Ahora dada una cadena, podemos usar esta notación para 'comprimirla', es decir, $AABAAB$ puede escribirse como $((A)^2 B)^2$ . Llamemos al peso de unacompresiónel número de caracteres que aparecen en él, por lo que el peso de$((A)^2 B^2)$ es dos, y el peso de$(AB)^2 A$ (unacompresiónde$ABABA$ ) es tres (las$A$ separadasse cuentan por separado).

Ahora considere el problema de calcular la compresión 'más ligera' de una cadena $S$ dada con $|S|=n$ . Después de pensarlo, hay un enfoque de programación dinámica obvio que se ejecuta en $O(n^3 \log n)$ u $O(n^3)$ dependiendo del enfoque exacto.

Sin embargo, me han dicho que este problema se puede resolver en tiempo $O(n^2 \log n)$ , aunque no puedo encontrar ninguna fuente sobre cómo hacerlo. Específicamente, este problema se dio en un concurso de programación reciente (problema K aquí , últimas dos páginas). Durante el análisis se presentó un algoritmo $O(n^3 \log n)$ , y al final se mencionó el enlace pseudo cuadrático ( aquí en la marca de cuatro minutos). Lamentablemente, el presentador solo se refirió a 'un complicado lema combinatorio de palabras', así que ahora he venido aquí para pedir la solución :-)

Si no te estoy malentendiendo, creo que la factorización de costo mínimo se puede calcular en tiempo siguiente manera.$O(n^2)$

Para cada índice i, calcularemos un grupo de valores para siguiente manera. Supongamos que es el número entero más pequeño de modo que haya un número entero satisfagaPara este particular , deje que sea ​​el más grande con esta propiedad. Si no existe tal , establezca para que sepamos que hay valores cero para este índice.$(p_i^\ell, r_i^\ell)$$\ell=1,2,\ldots$$p_i^1\ge 1$$r\ge 2$

Deje que sea ​​el entero más pequeño estrictamente más grande que satisfaga, asimismo, para algunos . Como antes, tome como el máximo que tiene fijo . En general, es el número más pequeño estrictamente más grande que . Si no existe tal , entonces .$p_i^2$$(r_i^1-1)p_i^1$

Tenga en cuenta que para cada índice i, tenemos debido a que los valores de aumentan geométricamente con . (si existe , no solo es estrictamente mayor que sino que es mayor que al menos Esto establece el aumento geométrico. )$L_i=O(\log (i+1))$$p_i^\ell$$\ell$$p_i^{\ell+1}$$(r_i^\ell-1)p_i^\ell$$p_i^\ell/2$

Supongamos que ahora se nos dan todos los valores . El costo mínimo viene dado por la recurrencia entendiendo que para configuramos . La tabla se puede llenar en tiempo.$(p_i^\ell,r_i^\ell)$

$$\mathrm{dp}(i,j) = \min\left\{\mathrm{dp}(i, j-1) + 1, \min_\ell \left(\mathrm{dp}\left(i,j - r_j^\ell p_j^\ell\right) + \mathrm{dp}(j-r_j^\ell p_j^\ell+1,j-p_j^\ell)\right)\right\}$$ $i>j$$\mathrm{dp}(i,j) = +\infty$$O(n^2 + n\sum_j L_j)$

Ya hemos observado anteriormente que al delimitar la suma término por término. Pero en realidad, si miramos la suma total, podemos probar algo más preciso.$\sum_j L_j = O(\sum_j \log (j+1)) = \Theta(n\log n)$

Considere el árbol de sufijos del reverso de (es decir, el árbol de prefijos de S). cada contribución a la suma a un borde de para que cada borde se cargue como máximo una vez. Cargue cada hasta el borde que emana de y vaya hacia . Aquí es la hoja del árbol de prefijos correspondiente a y nca denota el ancestro común más cercano.$T(\overleftarrow{S})$$S$$\sum_i L_i$$T(\overleftarrow{S})$$p_i^j$$\mathrm{nca}(v(i), v(i-p_i^j))$$v(i-p_i^j)$$v(i)$$S[1..i]$

Esto muestra que . Los valores se pueden calcular en el tiempo mediante un recorrido del árbol de sufijos, pero dejaré los detalles para una edición posterior si alguien está interesado.$O(\sum_i L_i)=O(n)$$(p_i^j,r_i^j)$$O(n+\sum_i L_i)$

Avísame si esto tiene sentido.

Existe su cadena inicial S de longitud n. Aquí está el pseudocódigo del método.

next_end_bracket = n
for i in [0:n]: # main loop

    break if i >= length(S) # due to compression
    w = (next_end_bracket - i)# width to analyse

    for j in [w/2:0:-1]: # period loop, look for largest period first
        for r in [1:n]: # number of repetition loop
            if i+j*(r+1) > w:
                break r loop

            for k in [0:j-i]:
                # compare term to term and break at first difference
                if S[i+k] != S[i+r*j+k]:
                    break r loop

        if r > 1:
            # compress
            replace S[i:i+j*(r+1)] with ( S[i:i+j] )^r
            # don't forget to record end bracket...
            # and reduce w for the i-run, carrying on the j-loop for eventual smaller periods. 
            w = j-i

Intencionalmente di pequeños detalles sobre "paréntesis finales", ya que necesita muchos pasos para apilar y desapilar, lo que dejaría claro el método central. La idea es probar una eventual contracción adicional dentro de la primera. por ejemplo ABCBCABCBC => (ABCBC) ² => (A (BC) ²) ².

Entonces, el punto principal es buscar períodos grandes primero. Tenga en cuenta que S [i] es el i-ésimo término de S omitiendo cualquier "(", ")" o potencia.

• i-loop es O (n)
• j-loop es O (n)
• r + k-loops es O (log (n)) ya que se detiene en la primera diferencia

Esto es globalmente O (n²log (n)).