Algoritmos eficientes para problemas de visibilidade vertical

Ao pensar em um problema, percebi que precisava criar um algoritmo eficiente para resolver a seguinte tarefa:

O problema: recebemos uma caixa quadrada bidimensional do lado $n$ cujos lados são paralelos aos eixos. Podemos examiná-lo através do topo. No entanto, também existem $m$ segmentos horizontais. Cada segmento tem um inteiro $y$ coordenada x ( $0 \le y \le n$ ) e $x$ -coordena ( $0 \le x_1 < x_2 \le n$ ) e pontos Connects $(x_1,y)$ e $(x_2,y)$ (veja o imagem abaixo).

Gostaríamos de saber, para cada segmento de unidade na parte superior da caixa, quão profundo podemos olhar verticalmente dentro da caixa se examinarmos esse segmento.

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

Exemplo: dados $n=9$ e $m=7$ segmentos localizados como na figura abaixo, o resultado é $(5, 5, 5, 3, 8, 3, 7, 8, 7)$ . Veja como a luz profunda pode entrar na caixa.

Sete segmentos; a parte sombreada indica a região que pode ser alcançada pela luz

Felizmente para nós, tanto $n$ e $m$ são bastante pequeno e podemos fazer os cálculos off-line.

O algoritmo mais fácil de resolver esse problema é a força bruta: para cada segmento, percorra toda a matriz e atualize-a sempre que necessário. No entanto, isso nos dá um não muito impressionante . $O(mn)$

Uma grande melhoria é usar uma árvore de segmentos capaz de maximizar valores no segmento durante a consulta e ler os valores finais. Não vou descrevê-lo mais, mas vemos que a complexidade do tempo é . $O((m+n) \log n)$

No entanto, criei um algoritmo mais rápido:

Esboço:

Classifique os segmentos em ordem decrescente de coordenada (tempo linear usando uma variação da classificação de contagem). Agora observe que, se qualquer segmento de unidade já foi coberto por qualquer segmento antes, nenhum segmento a seguir poderá limitar o feixe de luz que passa por esse segmento de unidade . Em seguida, faremos uma varredura de linha de cima para baixo na caixa. $y$ $x$ $x$
Agora, vamos introduzir algumas definições: o segmento da unidade é um segmento horizontal imaginário na varredura cujos coordenadas são números inteiros e cujo comprimento é 1. Cada segmento durante o processo de varredura pode ser desmarcado (ou seja, um feixe de luz saindo do o topo da caixa pode alcançar esse segmento) ou marcado (caso oposto). Considere um segmento de unidade com , sempre desmarcado. Vamos também introduzir os conjuntos . Cada conjunto conterá uma sequência inteira de segmentos de unidades marcados consecutivos (se houver algum) com a seguinte marca não marcada $x$ $x$ $x$ $x_1=n$ $x_2=n+1$ $S_0=\{0\}, S_1=\{1\}, \dots, S_n=\{n\}$ $x$ segmento.
Precisamos de uma estrutura de dados capaz de operar nesses segmentos e conjuntos com eficiência. Usaremos uma estrutura de união de busca estendida por um campo que contém o índice máximo do segmento de unidades (índice do segmento não marcado ). $x$
Agora podemos lidar com os segmentos com eficiência. Digamos que agora estamos considerando o ésimo segmento em ordem (chame de "consulta"), que começa em e termina em . Precisamos encontrar todos os segmentos não marcados da unidade que estão contidos no ésimo segmento (esses são exatamente os segmentos nos quais o feixe de luz terminará). Vamos fazer o seguinte: primeiro, encontramos o primeiro segmento não marcado dentro da consulta ( encontre o representante do conjunto no qual está contido e obtenha o índice máximo desse conjunto, que é o segmento não marcado por definição ). Então este índice $i$ $x_1$ $x_2$ $x$ $i$ $x_1$ $x$ está dentro da consulta, adicioná-lo para o resultado (o resultado para este segmento é ) e marcar este índice ( União conjuntos contendo e ). Em seguida, repita esse procedimento até encontrarmos todos os segmentos não marcados , ou seja, a próxima consulta Find nos fornece o índice . $y$ $x$ $x+1$ $x \ge x_2$

Observe que cada operação de união de localização será realizada em apenas dois casos: ou começamos a considerar um segmento (que pode acontecer vezes) ou apenas marcamos um segmento de unidade (isso pode acontecer vezes). Assim, a complexidade geral é ( é uma função inversa de Ackermann ). Se algo não estiver claro, posso elaborar mais sobre isso. Talvez eu possa adicionar algumas fotos se tiver algum tempo. $m$ $x$ $n$ $O((n+m)\alpha(n))$ $\alpha$

Agora cheguei ao "muro". Não consigo criar um algoritmo linear, embora pareça que deveria haver um. Então, eu tenho duas perguntas:

Existe um algoritmo de tempo linear (ou seja, ) resolvendo o problema de visibilidade do segmento horizontal? $O(n+m)$
Caso contrário, qual é a prova de que o problema de visibilidade é ? $\omega(n+m)$

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

Com que rapidez você classifica seus m segmentos?

babou

@babou, a pergunta especifica a classificação por contagem, que, como diz a pergunta, é executada em tempo linear ("tempo linear usando uma variação da classificação por contagem").

Você tentou varrer da esquerda para a direita? Tudo o que você precisa é classificar e nas etapas e para caminhar para a direita. Então, no total .

x 1

$x1$

x 2

$x2$

O (m)

$O(m)$

O (m)

$O(m)$

O (m)

$O(m)$

invalid_id

@invalid_id Sim, eu tentei. No entanto, nesse caso, a linha de varredura deve reagir adequadamente quando atingir o início do segmento (em outras palavras, adicionar o número igual à coordenada do segmento ao multiset), atingir o final do segmento (remover uma ocorrência de -coordenate) e produz o segmento ativo mais alto (valor máximo de saída no multiset). Não ouvi nenhuma estrutura de dados que nos permita fazer isso em tempo constante (amortizado).

y

$y$

y

$y$

Mnbvmar

@mnbvmar talvez seja uma sugestão idiota, mas e quanto a uma matriz de tamanho , você varre e interrompe cada célula . Para cada célula que você conhece max é possível inseri-la na matriz, além disso, você pode acompanhar o máximo geral com uma variável.

n

$n$

O (n)

$O(n)$

y

$y$

invalid_id

Respostas:

Primeiro tipo tanto e coordenadas das linhas nos dois agrupamentos separados e . $x1$ $x2$ $A$ $B$ $O(m)$
Também mantemos um tamanho de matriz de bits auxiliar para acompanhar os segmentos ativos. $n$
Comece a varrer da esquerda para a direita:
para $(i=0,i<n,i++)$
{
..se com valor $\exists x1=i$ $y$ $c$ $O(1)$
.. {
.... encontrar ( ) $\max$
.... armazenar ( ) $\max$ $O(1)$
..}
..se com valor $\exists x2=i$ $y$ $c$ $O(1)$
.. {
.... encontrar ( ) $\max$
.... armazenar ( ) $\max$ $O(1)$
..}
}

find ( ) pode ser implementado usando uma matriz de bits com bits. Agora, sempre que removermos ou adicionarmos um elemento a , podemos atualizar esse número inteiro, definindo um pouco como true ou false, respectivamente. Agora você tem duas opções, dependendo da linguagem de programação usada e a suposição é relativamente pequena, ou seja, menor que o que é pelo menos 64 bits ou uma quantidade fixa desses números inteiros: $\max$ $n$ $L$ $n$ $long long int$

Obter o bit menos significativo em tempo constante é suportado por alguns hardwares e gcc.
Ao converter em um número inteiro você obterá o máximo (não diretamente, mas você pode derivá-lo). $L$ $O(1)$

Eu sei que isso é um hack porque assume um valor máximo para e, portanto, pode ser visto como uma constante então ... $n$ $n$

ID Inválido
fonte

Pelo que vejo, supondo que você tenha um processador x86 de 64 bits, você pode lidar apenas com . E se estiver na ordem de milhões?

n \leq 64

$n \le 64$

n

$n$

Mnbvmar #

Então você precisará de mais números inteiros. Com dois números inteiros, você pode manipular até 128, etc. Portanto, a etapa de localização máxima de fica oculta no número de inteiros necessários, que você ainda pode otimizar se for pequeno. Você mencionou na sua pergunta que é relativamente pequeno, então acho que não é da ordem de milhões. A propósito, long long int é sempre de pelo menos 64 bits por definição, mesmo em um processador de 32 bits.

n

$n$

O (m)

$O(m)$

m

$m$

n

$n$

invalid_id

Claro que é verdade, o padrão C ++ define long long intcomo pelo menos o tipo inteiro de 64 bits. No entanto, não será que se for enorme e denotarmos o tamanho da palavra como (geralmente ), cada um levará tempo ? Em seguida, terminaríamos com total .

n

$n$

w

$w$

w = 64

$w=64$ find

O (\frac{n}{w})

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

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

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

Mnbvmar 01/09

Sim, infelizmente para grandes valores de esse é o caso. Então agora eu me pergunto o quão grande será no seu caso e se é limitado. Se for realmente da ordem de milhões, esse truque não funcionará mais, mas se para valores baixos de , será rápido e praticamente . Portanto, a melhor opção de algoritmo é, como sempre, dependente da entrada. Por exemplo, para ordenação por inserção é normalmente mais rápida do que a ordenação por mesclagem, mesmo com um tempo de execução de comparação com .

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

Estou confuso com a sua escolha de formatação. Você sabe que pode digitar código aqui, certo?

Raphael

Eu não tenho um algoritmo linear, mas este parece ser O (m log m).

Classifique os segmentos com base na primeira coordenada e altura. Isso significa que (x1, l1) sempre vem antes (x2, l2) sempre que x1 <x2. Além disso, (x1, l1) na altura y1 vem antes (x1, l2) na altura y2 sempre que y1> y2.

Para cada subconjunto com a mesma primeira coordenada, fazemos o seguinte. Seja o primeiro segmento (x1, L). Para todos os outros segmentos do subconjunto: se o segmento for maior que o primeiro, altere-o de (x1, xt) para (L, xt) e adicione-o ao subconjunto L na ordem correta. Caso contrário, solte-o. Finalmente, se o próximo subconjunto tiver uma primeira coordenada menor que L, divida (x1, L) em (x1, x2) e (x2, L). Adicione (x2, L) ao próximo subconjunto na ordem correta. Podemos fazer isso porque o primeiro segmento do subconjunto é mais alto e cobre o intervalo de (x1, L). Esse novo segmento pode ser o que cobre (L, x2), mas não saberemos isso até que olhemos para o subconjunto que tem a primeira coordenada L.

Depois de percorrermos todos os subconjuntos, teremos um conjunto de segmentos que não se sobrepõem. Para determinar qual é o valor Y para um determinado X, precisamos apenas percorrer os segmentos restantes.

Então, qual é a complexidade aqui: A classificação é O (m log m). O loop entre os subconjuntos é O (m). Uma pesquisa também é O (m).

Portanto, parece que esse algoritmo é independente de n.

Ninguém em particular
fonte