Algoritmo eficiente para contenção de retângulos

Dado um conjunto de intervalos em uma linha, existe um algoritmo para encontrar intervalos contidos em outros intervalos (por exemplo, Manber, "Utilizando a indução para projetar algoritmos", 1988). Existe um algoritmo para retângulos alinhados ao eixo em dimensões mais altas? $n$ $O(n \log n)$ $O(n \log n)$

Fiz algumas pesquisas na internet e tentei pensar sobre isso sozinho, mas não consegui encontrar uma generalização para dimensões mais altas. Por exemplo, dados retângulos alinhados ao eixo no plano, a tarefa é descobrir quais retângulos estão contidos em outros retângulos. $n$

algorithms computational-geometry John Donn
fonte

Uma abordagem para derivar uma solução para um problema n-1-dimensional é " varrer " um "plano" n-dimensional através do espaço relevante; outro é subdividir o último por esse plano, resolver o problema recursivamente para os objetos que não cruzam o plano divisor e outro para os que o fazem, e reunir os resultados.

greybeard

@vzn e DW: editaram a pergunta. Parece-me também que o primeiro comentário (de barba cinza) leva a um algoritmo eficiente (uma "linha de varredura" vertical cujas interseções com os retângulos sofrem alterações estruturais nos "pontos de bifurcação", que são projeções dos lados verticais dos retângulos).

John Donne

@vzn Essa é a "generalização natural" que você tinha em mente? Caso contrário, talvez você possa postar uma resposta.

John Donne

"Parece-me também que o primeiro comentário (de barba grisalha) leva a um algoritmo eficiente .." - embora eu tentei, não consegui encontrar uma estrutura de dados adequada para manter as interseções da linha de varredura vertical com os retângulos (de modo que as operações gerais necessárias são little_o (n ** 2)).

John Donne

Respostas:

Você já considerou índices multidimensionais? Eles geralmente são bastante eficientes para encontrar retângulos sobrepostos ou incluídos.

Eu, pessoalmente, escreveu uma espécie de quadtree binário de compartilhamento de prefixo: fontes Java Tem uma API para retângulos com um método especial para pesquisar retângulos incluídos no outro retângulo: PhTreeSolidF.queryInclude().

Não sei ao certo qual é a complexidade, mas é aproximadamente algo na ordem de O (n * k * log n) para construir a árvore e O (k * log n) para cada consulta (k é o número de dimensões). Para conjuntos de dados fortemente agrupados, pode até perder algo para O (1) para cada consulta (eu testei isso com n = 10.000.000 e 2 <= k <= 15).

TilmannZ
fonte

-1

existe uma extensão / generalização natural do intervalo, buscando retângulos alinhados ao eixo e hipercubos dimensionais mais altos.

o problema se reduz à verificação da inclusão do intervalo em cada eixo separadamente e, em seguida, localizando a interseção dos retângulos ou hipercubos que "possuem" cada inclusão do intervalo 1-d. leva k * O (f (n)) onde f (n) é o momento de verificar uma única dimensão e k é o número de dimensões. isso é baseado na idéia simples de que, para retângulos / hipercubos alinhados ao eixo, um hipercubo está em outro hipercubo se todos os seus lados separados também estiverem. isso não determina apenas retângulos / hipercubos alinhados a eixos sobrepostos, embora um algoritmo semelhante possa fazer isso.

não estou ciente disso publicado na literatura, mas não é complexo e, presumivelmente, é citado em algum lugar pelo menos de passagem. a literatura sobre esse assunto geralmente trabalha com árvores Kd ou quadtrees (caso 2d) e se enquadra na categoria geral de consulta / pesquisa no intervalo de banco de dados . a abordagem geralmente seria permitir que objetos geométricos gerais fossem definidos como polígonos e, em seguida, encontre todos os nós no Kd com os quais o polígono se sobrepõe e faça o cálculo do intervalo em todos os nós do (s) polígono (s) para determinar interseções.

vzn
fonte

Tenho a sensação de que você está descrevendo um

O (k * n^{2})

$O(k*n^2)$ algoritmo aqui. O que é pior do que o OP está pedindo. Um ponto importante é: qual é o resultado da sua verificação em cada dimensão. É apenas marcar as entradas cobertas por algo OU é um registro de quais entradas cobre quais? Porque se for o primeiro, não acho que a informação seja suficiente para combinar resultados de cada dimensão. Você precisa conhecer a identidade da entrada de cobertura. Na última versão em que você registra a identidade da entrada de cobertura, o tempo gasto é

O (n^{2})

$O(n^2)$ para cada D, como eu posso pensar.

Apiwat Chantawibul

concordou que a análise de complexidade não é trivial e não é detalhada / preenchida, mas acha que é "próxima" as inclusões de intervalo 1d podem ser representadas como uma árvore para a relação "A dentro de B". pode escrever o código em algum momento em ruby com alguma inclinação adicional. pode esclarecer detalhes no bate-papo de ciência da computação para qualquer pessoa com o tempo

vzn 19/11/2015