Algoritmos eficientes para problemas de visibilidad vertical

Al pensar en un problema, me di cuenta de que necesitaba crear un algoritmo eficiente para resolver la siguiente tarea:

El problema: se nos da una caja cuadrada bidimensional del lado $n$ cuyos lados son paralelos a los ejes. Podemos verlo a través de la parte superior. Sin embargo, también hay $m$ segmentos horizontales. Cada segmento tiene un entero $y$ -coordinado ( $0 \le y \le n$ ) $x$ -coordinado ( $0 \le x_1 < x_2 \le n$ ) y conecta los puntos $(x_1,y)$ y $(x_2,y)$ (mire el imagen debajo).

Nos gustaría saber, para cada segmento de la unidad en la parte superior de la caja, qué tan profundo podemos mirar verticalmente dentro de la caja si miramos a través de este segmento.

$x \in \{0,\dots,n-1\}$ $\max_{i:\ [x,x+1]\subseteq[x_{1,i},x_{2,i}]} y_i$

Ejemplo: dado y segmentos situados como en la imagen siguiente, el resultado es . Mira cuán profunda puede entrar la luz en la caja. $n=9$ $m=7$ $(5, 5, 5, 3, 8, 3, 7, 8, 7)$

Siete segmentos; la parte sombreada indica la región a la que se puede llegar con luz

Afortunadamente para nosotros, tanto $n$ como $m$ son bastante pequeños y podemos hacer los cálculos fuera de línea.

El algoritmo más fácil para resolver este problema es la fuerza bruta: para cada segmento atraviese toda la matriz y actualícela cuando sea necesario. Sin embargo, no nos da muy impresionante . $O(mn)$

Una gran mejora es utilizar un árbol de segmentos que pueda maximizar los valores en el segmento durante la consulta y leer los valores finales. No lo describiré más, pero vemos que la complejidad del tiempo es . $O((m+n) \log n)$

Sin embargo, se me ocurrió un algoritmo más rápido:

Contorno:

Ordene los segmentos en orden decreciente de coordenada (tiempo lineal usando una variación del orden de conteo). Ahora tenga en cuenta que si algún segmento de la unidad ha sido cubierto por algún segmento anteriormente, ningún segmento siguiente puede limitar el haz de luz que atraviesa este segmento de la unidad . Luego haremos un barrido de línea desde la parte superior a la inferior de la caja. $y$ $x$ $x$
Ahora introduzcamos algunas definiciones: el segmento de la unidad es un segmento horizontal imaginario en el barrido cuyas coordenadas son enteros y cuya longitud es 1. Cada segmento durante el proceso de barrido puede estar sin marcar (es decir, un haz de luz que va desde la parte superior del cuadro puede alcanzar este segmento) o marcado (caso opuesto). Considere un segmento de unidad con , siempre sin marcar. También presentemos los conjuntos . Cada conjunto contendrá una secuencia completa de segmentos de unidades marcados consecutivos (si hay alguno) con los siguientes elementos sin marcar $x$ $x$ $x$ $x_1=n$ $x_2=n+1$ $S_0=\{0\}, S_1=\{1\}, \dots, S_n=\{n\}$ $x$ segmento.
Necesitamos una estructura de datos que pueda operar en estos segmentos y conjuntos de manera eficiente. Usaremos una estructura de búsqueda-unión extendida por un campo que contenga el índice máximo del segmento de la unidad (índice del segmento sin marcar ). $x$
Ahora podemos manejar los segmentos de manera eficiente. Digamos que ahora estamos considerando el -ésimo segmento en orden (llámelo "consulta"), que comienza en y termina en . Necesitamos encontrar todos los segmentos de la unidad sin marcar que están contenidos dentro del segmento -ésimo (estos son exactamente los segmentos en los que el haz de luz terminará su camino). Haremos lo siguiente: en primer lugar, encontramos el primer segmento sin marcar dentro de la consulta ( Encuentre el representante del conjunto en el que está contenido y obtenga el índice máximo de este conjunto, que es el segmento sin marcar por definición ). Entonces este índice $i$ $x_1$ $x_2$ $x$ $i$ $x_1$ $x$ está dentro de la consulta, agréguelo al resultado (el resultado para este segmento es ) y marque este índice ( conjuntos de unión que contienen y ). Luego repita este procedimiento hasta que encontremos todos los segmentos sin marcar , es decir, la siguiente consulta Buscar nos da el índice . $y$ $x$ $x+1$ $x \ge x_2$

Tenga en cuenta que cada operación de búsqueda y unión se realizará solo en dos casos: comenzamos a considerar un segmento (que puede suceder veces) o acabamos de marcar un segmento de unidad (esto puede suceder veces). Por lo tanto, la complejidad general es ( es una función inversa de Ackermann ). Si algo no está claro, puedo elaborar más sobre esto. Quizás pueda agregar algunas fotos si tengo algo de tiempo. $m$ $x$ $n$ $O((n+m)\alpha(n))$ $\alpha$

Ahora llegué a "la pared". No puedo encontrar un algoritmo lineal, aunque parece que debería haber uno. Entonces, tengo dos preguntas:

¿Existe un algoritmo de tiempo lineal (es decir, ) para resolver el problema de visibilidad del segmento horizontal? $O(n+m)$
Si no, ¿cuál es la prueba de que el problema de visibilidad es ? $\omega(n+m)$

algorithms data-structures time-complexity computational-geometry mnbvmar
fuente

¿Qué tan rápido clasificas tus segmentos m ?

babou

@babou, la pregunta especifica el orden de conteo, que como dice la pregunta, se ejecuta en tiempo lineal ("tiempo lineal usando una variación del orden de conteo").

¿Intentaste barrer de izquierda a derecha? Todo lo que necesita es ordenar en y tanto en los pasos como en para caminar hacia la derecha. Entonces en total .

x 1

$x1$

x 2

$x2$

O (m)

$O(m)$

O (m)

$O(m)$

O (m)

$O(m)$

invalid_id

@invalid_id Sí, lo intenté. Sin embargo, en este caso, la línea de barrido debe reaccionar adecuadamente cuando se encuentra con el comienzo del segmento (en otras palabras, agregue el número igual a la coordenada del segmento al conjunto múltiple), se encuentra con el final del segmento (eliminar una ocurrencia de -coordinar) y generar el segmento activo más alto (valor máximo de salida en el conjunto múltiple). No he oído hablar de ninguna estructura de datos que nos permita hacer esto en tiempo constante (amortizado).

y

$y$

y

$y$

mnbvmar

@mnbvmar puede ser una sugerencia tonta, pero ¿qué tal una matriz de tamaño , barre y detiene cada celda . Para evry cell sabes max puedes ingresarlo en la matriz, además puedes hacer un seguimiento del máximo general con una variable.

n

$n$

O (n)

$O(n)$

y

$y$

invalid_id

Respuestas:

Primero ordenar tanto y coordenadas de las líneas en dos matrices separadas y . $x1$ $x2$ $A$ $B$ $O(m)$
También mantenemos un tamaño de matriz de bits auxiliar para realizar un seguimiento de los segmentos activos. $n$
Comience a barrer de izquierda a derecha:
para $(i=0,i<n,i++)$
{
..if exist con valor $\exists x1=i$ $y$ $c$ $O(1)$
.. {
.... encontrar ( ) $\max$
.... tienda ( ) $\max$ $O(1)$
..}
..if con valor $\exists x2=i$ $y$ $c$ $O(1)$
.. {
.... encontrar ( ) $\max$
.... tienda ( ) $\max$ $O(1)$
..}
}

find ( ) se puede implementar usando una matriz de bits con bits. Ahora, siempre que eliminemos o agreguemos un elemento a , podemos actualizar este número entero estableciendo un bit en verdadero o falso respectivamente. Ahora tiene dos opciones dependiendo del lenguaje de programación utilizado y la suposición es relativamente pequeña, es decir, más pequeña que que es al menos 64 bits o una cantidad fija de estos enteros: $\max$ $n$ $L$ $n$ $long long int$

Obtener el bit menos significativo en tiempo constante es compatible con algunos hardware y gcc.
Al convertir a un número entero obtendrá el máximo (no directamente, pero puede derivarlo). $L$ $O(1)$

Sé que esto es un gran truco porque asume un valor máximo para y, por lo tanto, puede verse como una constante entonces ... $n$ $n$

identificación invalida
fuente

Como veo, suponiendo que tenga un procesador x86 de 64 bits, solo puede manejar

. ¿Qué pasa si

está en el orden de millones?

n \leq 64

$n \le 64$

n

$n$

mnbvmar

Entonces necesitarás más números enteros. Con dos enteros, puede manejar

hasta 128, etc. Por lo tanto, el paso de búsqueda máxima

está oculto en la cantidad de enteros necesarios, que aún puede optimizar si

es pequeño. Usted mencionó en su pregunta que

es relativamente pequeño, así que supongo que no está en el orden de millones. Por cierto, long long int siempre tiene al menos 64 bits por definición, incluso en un procesador de 32 bits.

n

$n$

O (m)

$O(m)$

m

$m$

n

$n$

invalid_id

Por supuesto que es cierto, el estándar C ++ se define long long intcomo un tipo entero de al menos 64 bits. Sin embargo, no será que si

es enorme y denotamos el tamaño de la palabra como

(generalmente

), entonces cada uno tomará

n

$n$

w

$w$

w = 64

$w=64$ find

tiempo? Entonces terminaríamos con

total

O (\frac{n}{w})

$O\left(\frac{n}{w}\right)$

O (\frac{m n}{w})

$O\left(\frac{mn}{w}\right)$

mnbvmar

Sí, desafortunadamente para grandes valores de

ese es el caso. Así que ahora me pregunto qué tan grande será

en su caso y si está limitado. Si realmente es del orden de millones, este corte ya no funcionará, pero si

para valores bajos de

será rápido y prácticamente

. Entonces, la mejor opción de algoritmo es, como de costumbre, dependiente de la entrada. Por ejemplo, para

ordenación por inserción es normalmente más rápida que la ordenación por fusión, incluso con un tiempo de ejecución de

comparación con

n

$n$

n

$n$

c \cdot w \geq n

$c\cdot w\geq n$

c

$c$

O (n + m)

$O(n+m)$

n \leq 100

$n\leq 100$

O (n^{2})

$O(n^2)$

O (n \log n)

$O(n \log n)$

invalid_id

Estoy confundido por su elección de formato. Sabes que puedes escribir código aquí, ¿verdad?

Raphael

No tengo un algoritmo lineal, pero este parece ser O (m log m).

Ordenar los segmentos según la primera coordenada y la altura. Esto significa que (x1, l1) siempre viene antes (x2, l2) siempre que x1 <x2. Además, (x1, l1) a la altura y1 viene antes (x1, l2) a la altura y2 siempre que y1> y2.

Para cada subconjunto con la misma primera coordenada, hacemos lo siguiente. Deje que el primer segmento sea (x1, L). Para todos los demás segmentos del subconjunto: si el segmento es más largo que el primero, cámbielo de (x1, xt) a (L, xt) y agréguelo al subconjunto L en el orden correcto. De lo contrario, déjalo caer. Finalmente, si el siguiente subconjunto tiene una primera coordenada menor que L, luego divida el (x1, L) en (x1, x2) y (x2, L). Agregue (x2, L) al siguiente subconjunto en el orden correcto. Podemos hacer esto porque el primer segmento en el subconjunto es más alto y cubre el rango de (x1, L). Este nuevo segmento puede ser el que cubre (L, x2), pero no lo sabremos hasta que veamos el subconjunto que primero tiene la coordenada L.

Después de recorrer todos los subconjuntos, tendremos un conjunto de segmentos que no se superponen. Para determinar cuál es el valor de Y para una X dada, solo tenemos que recorrer los segmentos restantes.

Entonces, ¿cuál es la complejidad aquí: el tipo es O (m log m). Recorriendo los subconjuntos está O (m). Una búsqueda también es O (m).

Entonces parece que este algoritmo es independiente de n.

Nadie en particular
fuente