¿Cómo usar un algoritmo codicioso para encontrar la secuencia no decreciente más cercana a la dada?

Te dan n enteros todos entre y . Debajo de cada número entero , debe escribir un número entero entre y con el requisito de que los formen una secuencia no decreciente. Defina la desviación de dicha secuencia como . Diseñe un algoritmo que encuentre las b_i 's con la desviación mínima en tiempo de ejecución O (n \ sqrt [4] {l}) .$a_1, \ldots, a_n$$0$$l$$a_i$$b_i$$0$$l$$b_i$$\max(|a_1-b_1|, \ldots, |a_n-b_n|)$$b_i$$O(n\sqrt[4]{l})$

Sinceramente, no tengo ni idea de cómo comenzar a resolver esta pregunta. A mí me parece una pregunta de programación dinámica, pero el profesor dijo que esto debería resolverse utilizando un algoritmo codicioso. Sería muy apreciado si alguien me puede señalar en la dirección correcta dando una pequeña pista.

Comencemos con la siguiente observación:

Deje que $max$ denote el máximo de la secuencia $a_1,...,a_n$ , y deje que $min$ denote su mínimo. Si $a_1=max$ , entonces elegir $b_1=b_2=...=b_n=\lfloor(max+min)/2\rfloor$ es óptimo.

¿Por qué es este el caso? Bueno, dado que la secuencia comienza con el máximo, elegimos grande y sufrimos una gran desviación del mínimo de la secuencia (ya que cualquier posterior debe ser mayor o igual a ), o elegimos pequeño y sufrimos desviación al . El promedio minimiza la desviación máxima.$b_1$$b_i$$b_1$$b_1$$max$

Ahora podemos tratar de generalizar esta observación para usarla en secuencias generales . Por ejemplo, podemos dividir cualquier secuencia en subsecuencias, de modo que cada una comience con el máximo de la subsecuencia respectiva.$a_1,...,a_n$

Ejemplo: se divide en , y .$(2,6,4,1,5,2,8,7,5,1)$$(2)$$(6,4,1,5,2)$$(8,7,5,1)$

Dada esta partición, ahora podemos resolver cada una de estas subsecuencias por separado, y obtener una asignación de los 's, que sin embargo podrían violar la condición no decreciente. Esto se puede solucionar sin perder la optimización.$b_i$

Observe que la última subsecuencia siempre contiene el máximo de toda la secuencia (de lo contrario, habría otra subsecuencia después de ella). Sean los valores que asignamos a las subsecuencias. Ahora, para lograr una no disminución en , comenzamos desde atrás en y hacia el frente. Si es mayor que , simplemente establecemos . Si es más pequeño, lo guardamos. Luego, procedemos a comparar con y así sucesivamente. Tenga en cuenta que reducir al valor de$max$$w_1,w_2,...,w_k$$k$$w_1,...,w_k$$w_k$$w_{k-1}$$w_k$$w_{k-1}:=w_k$$w_{k-2}$$w_{k-1}$$w_i$$w_{i+1}$nunca aumenta la desviación, ya que el valor máximo en la subsecuencia asignada con es siempre menor que el máximo en la subsecuencia asignada con .$w_i$$w_{i+1}$

Este algoritmo debería ser correcto, creo. Con respecto al tiempo de ejecución, el paso clave es calcular los máximos crecientes para las subsecuencias, que es posible en ? No sabe dónde contribuye.$O(n)$$l$

Voy a pensar en voz alta aquí solo trabajando en las pistas que me has dado. Vayamos a la pista original de decir que es lo que debes probar primero. Puedo pensar en un algoritmo codicioso que tiene ese tiempo.$O(nl)$

La parte de la complejidad del tiempo significa que puede mantener una lista del recuento de cada ocurrencia de cada valor . Eso es solo crear un conjunto que rastrea el recuento de cada en el conjunto. Puede crear la lista de inicialización escaneando la secuencia de entrada una vez.$l$$0..l$$\text{Count} = { C_0, \ldots, C_l}$$l$

Puede escanear esta lista en para obtener el valor máximo y mínimo. Si tuviera que llenar la lista completa de con este punto medio, su varianza sería simplemente la diferencia de este valor y el máximo / mínimo. Este es básicamente el peor de los casos, vamos a llamarlo .$O(l)$$b$$b_w$

Así que trabaje hasta desde la izquierda. Ambos pueden descartar este elemento de y obtener el mínimo / máximo de en . Ahora podemos ser codiciosos. No elegimos ya que eso obliga a la lista completa restante hacia arriba (para cumplir con el requisito no decreciente) y, por lo tanto, aumenta la varianza. El valor mínimo que podemos elegir es . Si está en el rango aceptable, lo seleccionamos, si está por debajo del rango, use el mínimo. Esto minimiza la varianza en dadas las restricciones conocidas.$b_i$$\text{Count}$$b[i+1] \ldots b[n]$$O(l)$$b_i > b_w$$b[i-1]$$a_i$$b_i$

Esto es solo una idea, tal vez tengo suerte y te señala en la dirección correcta. Es posible que este algoritmo no funcione (lo hace para mis pocas pruebas simples), pero coincide con las sugerencias dadas, por lo que quizás sea útil. Si es correcto, es fácil ver que la parte se puede soltar con seguridad a , más aún, no estoy seguro.$O(l)$$O(\log l)$

Aquí está la solución del profesor, que él llama "reducción": para cada de a , intente construir una solución si sabemos que la desviación es menor o igual que . La primera para la que se puede encontrar una solución es la desviación mínima. Podemos encontrar una solución dada la desviación en el tiempo . Entonces el tiempo de ejecución es . Luego, en lugar de usar la búsqueda lineal, podemos usar la búsqueda binaria para determinar la desviación más pequeña para la cual es posible una solución. Esto reduce el tiempo de ejecución a , que satisface el requisito de .$i$$0$$l$$i$$i$$O(n)$$O(nl)$$O(n\log l)$$O(n\sqrt[4]{l})$

Creo que esto debería ser factible en O (n).

Tome el problema similar: dado , 1 ≤ i ≤ n, y d ≥ 0, encuentre en orden no descendente tal que para todo i, o demuestre que no es posible. Esto se puede hacer en O (n), y utilizando la búsqueda binaria, el problema original se resuelve en O (n log l).b i | a i - b i | ≤ $a_i$$b_i$$|a_i - b_i| ≤ d$

Ahora si hay i ≤ j tal que a_i - a_j> 2d, entonces no hay solución (porque ).$b_i ≥ a_i - d, b_j ≤ a_j + d < a_i - 2d + d = a_i - d ≤ b_i$

Pero si a_i - a_j ≤ 2d para todo i ≤ j, entonces creo que siempre se encontrará una solución. Entonces, todo lo que tenemos que hacer es encontrar m = max (a_i - a_j) para todo i ≤ j, y elegir d = floor ((m + 1) / 2). Ese máximo se puede encontrar en O (n).