Eu estou procurando um algoritmo para encontrar redução transitiva de uma hierarquia de contenção de retângulos DAG, ou seja, existe uma aresta direcionada de um retângulo para outro se o primeiro retângulo contiver o segundo.$O(|V| + |E|)$

Ou seja, remova o máximo de arestas possível para que, se você puder alcançar v de u, para v e u arbitrários, ainda possa alcançá-lo após a remoção das arestas.

Suponha que os retângulos sejam únicos, por isso estamos lidando com um DAG.

Isso é útil, por exemplo, com a mineração quantitativa de regras de associação de Srikant / Agrawal 1996. Lá, estamos interessados ​​em ancestrais próximos para hiper-retângulos que os ancestrais nos contêm. A determinação do ancestral próximo é semelhante à determinação do descendente próximo, que está relacionado à redução transitiva com contenção de retângulo. Esse tipo de mineração de regras está relacionado ao algoritmo APRIORI para mineração de regras de associação padrão (isto é, "booleana") da Agrawal / Srikant 1994.

Um problema semelhante é a redução transitiva do DAG padrão, que está aqui:
Redução transitiva do DAG

Referências

• Agrawal, Srikant - Algoritmos rápidos para regras de associação de mineração (1994)
• Srikant, Agrawal - Regras quantitativas de associação de mineração em grandes tabelas relacionais (1996)

14 de Dezembro de 2018

Abordagem padrão e uma alternativa heurística

Abordagem padrão - use gráfico e produto à distância

Observamos que a redução transitiva é redutível ao fechamento transitivo e vice-versa, tanto em tempo adicional $O(n ^ 2)$. Então, sabemos que, se pudermos resolver o fechamento transitivo em$O(n ^ 2 \cdot \textrm{polylog}(n))$ tempo, também podemos resolver a multiplicação de matriz booleana (MM) em tempo semelhante, reduzindo-a ao fechamento transitivo (ou redução transitiva), de acordo com Fischer / Meyer 1971. Lax Boolean MM é onde os valores de entrada estão $\{0, 1\}$ e temos semi-anel de $(\textrm{OR}, \textrm{AND})$. Podemos resolver MM booleanos frouxos reduzindo para MM padrão (mais, vezes). Isso significa que atualmente é improvável uma abordagem de tempo significativamente subcúbico para redução transitiva. Podemos reduzir a redução transitiva do DAG baseado em nó para a redução transitiva do DAG baseada em retângulo por ordem topológica e formas com tamanho inversamente relacionado à distância da fonte. Para a aplicação de retângulos, é claro que não devemos ter ciclos, o que acontece quando os retângulos são idênticos; nesse caso, devemos remover duplicatas. Um algoritmo mais direto é para reduzir a computação assumindo um gráfico esparso, o que leva$O(n ^ 3)$Tempo. Esses tempos também estão ignorando que, para criar o DAG inicial, devemos executar$n ^ 2$ testes de contenção, cada um dos quais leva tempo $O(d) = O(2) = O(1)$.

Alternativa heurística - use R-tree

Como alternativa, assumindo que temos dimensão $d$ moderadamente baixo e fixo e não atado firmemente por $O(n)$, podemos chegar em momentos que parecem subcúbicos em $n$. Temos duas opções - ambas usam uma variante R-tree com carregamento em massa, por exemplo, via abordagem sort-tile-recursive (STR) via Leutenegger 1997 e são equilibradas e dinâmicas via reconstrução ocasional do tipo bkd-tree (consulte Procopiuc 2003) para apoiar inserções e exclusões em$O(\log^2(n))$Tempo. Veja Guttman 1984 para detalhes sobre R-tree padrão. A idéia principal é encontrarmos descendentes próximos para cada um dos$n$ retângulos fornecidos através de um total de $n$consultas de descendentes próximos. Consideramos que ambas as opções envolvem heurísticas porque podemos ter muitos palpites intermediários para os descendentes próximos que não sobrevivem, apesar de as subconsultas terem um bom tempo garantido para a opção um.

Se tivermos retângulos em pares que não envolvam invólucro / contenção e a sobreposição estiver altamente correlacionada com invólucro / contenção, é possível que possamos obter um melhor desempenho usando o R-tree através de uma das duas opções para nossa abordagem. Observamos que uma consulta de gabinete de retângulo solicita retângulos de retângulo de consulta que o contenham e uma consulta de contenção de retângulo solicita retângulos de retângulo de consulta que cabem nela. A consulta de descendentes próximos funciona aproximadamente por meio de uma abordagem heurística. Encontramos retângulos primitivos contidos no retângulo de consulta e usamos consultas auxiliares para verificar se os retângulos retornados têm pais que estão contidos no retângulo de consulta original. O candidato descendentes próximos que armazenamos em um "conflito" árvore R secundária para acelerar as verificações na forma de subconsulta de gabinete com parada antecipada que determina se um pai candidato encerra (e desqualifica) um descendente próximo candidato; mantemos essa árvore de conflito por meio de inserções e exclusões. Observamos que, quando encontramos retângulos da mesma forma, podemos optar por manter um deles arbitrariamente. Usamos uma fila de melhor prioridade para orientar a ordem de consideração das caixas delimitadoras; nós preferimos caixas delimitadoras contidas e fazemos o desempate preferindo uma área maior da caixa delimitadora (porque é mais difícil ser intermediário em uma caixa contida maior). podemos optar por manter um deles arbitrariamente. Usamos uma fila de melhor prioridade para orientar a ordem de consideração das caixas delimitadoras; nós preferimos caixas delimitadoras contidas e fazemos o desempate preferindo uma área maior da caixa delimitadora (porque é mais difícil ser intermediário em uma caixa contida maior). podemos optar por manter um deles arbitrariamente. Usamos uma fila de melhor prioridade para orientar a ordem de consideração das caixas delimitadoras; preferimos caixas delimitadoras contidas e desempate ao preferir uma área maior da caixa delimitadora (porque é mais difícil ser um intermediário para uma caixa contida maior).

Opção # 1 - use o futuro

A primeira opção é usar a consulta antecipada de subconsultas, como gabinete de retângulo e contenção de retângulo em conjunto com a transformação de canto. A consulta de descendentes próximos não usaria diretamente o look-ahead; suas subconsultas fazem. Então, temos um coeficiente de$d$para consultas antecipadas para verificações de borda. Não entraremos em muitos detalhes sobre o futuro, exceto pelo fato de que exige caixas delimitadoras quase disjuntas para os irmãos (embora a borda compartilhada seja permitida) e está relacionado ao conhecimento de que uma criança em cada uma das subárvores definitivamente tem uma correspondência (o que é tornou mais simples perceber que também usamos a transformação de canto) por meio de$d$verificações de borda em cada nó. Deve-se notar que, sem o fechamento antecipado e a contenção, já são necessários pelo menos$d$tempo para cada nó para uma árvore-R. Modificamos a subconsulta de gabinete para usar a parada antecipada, o que leva tempo para que essa consulta seja$O(\log(n))$ ao invés de $O(\log^2(n))$. Tempo para cada consulta de descendente próximo$O(k \cdot \log^2(n))$, Onde $k$ é o número de descendentes próximos palpites st $k$ é em $O(n)$. Isso significa para$n$ consultas com descendentes em geral, levamos um tempo $O(k \cdot n \cdot \log^2(n))$ = $O(n ^ 2 \cdot \log^2(n))$. Como isso é menos que cúbico em$n$ (embora omitamos um fator de $d$supondo que seja moderadamente baixo e fixo), essa abordagem pode ser usada para obter melhor desempenho na prática. Deixamos de lado os detalhes de que, para subconsultas de compartimento / contenção de uso antecipado, podemos levar um tempo não constante, mesmo se houver zero correspondências.

Opção # 2 - não use look-ahead

A segunda opção é não usar o look-ahead e tudo o que podemos dizer (sem outras suposições simplificadoras) é que, para cada consulta de descendente próximo, temos o pior caso possível. $n$ palpites, cada um dos quais levaria $O(\log(n))$hora de encontrar (porque não descemos um galho mais de uma vez). Observamos que assumimos que não usamos a transformação de canto. Como resultado, temos um tempo extremamente frouxo e pessimista, vinculado a$O(n \cdot \log(n))$para tentar desqualificar um descendente próximo de palpite por meio de subconsulta de gabinete com parada antecipada. O tempo para uma consulta de descendente próximo é limitado por$O(k' \cdot n \cdot \log(n))$, Onde $k'$ é o pior número de palpites (ie $n$) Hora de$n$ consultas de descendentes próximos é delimitada por $O(k' \cdot n ^ 2 \cdot \log(n))$ = $O(n ^ 3 \cdot \log(n))$. Este valor é mais do que cúbico em$n$ (novamente observando que omitimos um fator de $d$como é moderadamente baixo e fixo), mas os tempos para a abordagem são consideravelmente pessimistas e acreditamos que ainda há uma chance de que ela possa ter um bom desempenho na prática com força bruta. Mostramos que isso é plausível, fazendo agora algumas suposições, que discutiremos abaixo. Embora a primeira opção não tire proveito da possibilidade de que o número de palpites possa ser significativamente menor do que$n$ além disso, possui limites teóricos mais baixos, porque eles aproveitam a possibilidade de que a subconsulta do gabinete com parada antecipada para desqualificar um descendente próximo do palpite possa ser garantida como rápida.

Opção # 2 - três premissas

A suposição "sobreposição zero" diz que (i) as caixas delimitadoras não se sobrepõem ao retângulo de consulta, a menos que delimitemos o retângulo de consulta para consulta de gabinete ou que estejamos contidos pelo retângulo de consulta para consulta de restrição; e (ii) caixas delimitadoras para irmãos que não estão contidas no outro não se sobrepõem, exceto em um limite. Observamos que a primeira parte dessa suposição só pode ser verdadeira, por exemplo, porque uma coleção de retângulos real tem um maior retângulo que não pode ser fechado e um menor retângulo que não pode conter. Nós introduzimos$b$, que descreve a média da taxa de falso positivo positivo para real positivo para acreditar que um filho para um nó está associado a uma correspondência garantida durante a tentativa de desqualificar subconsulta st $b$ é em $[0, 1]$. O tempo para a consulta de descendente próximo da segunda opção é dividido em duas partes. A primeira parte descreve os palpites. A segunda parte descreve as tentativas de desqualificar cada palpite. A terceira parte é lidar com atualizações na árvore de conflitos. Suponha que o número de palpites seja$k''$. O tempo para a primeira parte é$O(k'' \cdot \log(n))$. O tempo para a segunda parte é$O(k'' \cdot (b + 1)^{\log(n)} \cdot \log(n))$. O tempo para a terceira parte é$O(k'' \cdot \log^2(n))$. O tempo total é vagamente (assumindo$b$ é um) em $O(k'' \cdot n \cdot \log^2(n))$. O tempo para$n$ consultas de descendentes próximos é $O(k'' \cdot n ^ 2 \cdot \log^2(n))$ = $O(n ^ 3 \cdot \log^2(n))$ E se $k''$ é em $O(n)$. Isso não parece ser melhor que força bruta. Se fizermos a suposição "sobreposição zero",$b$ é zero, o que dá $n$ tempo de consulta de descendente próximo de $O(k'' \cdot n \cdot \log^2(n))$ = $O(n ^ 2 \cdot \log^2(n))$ E se $k''$ é em $O(n)$. O fator de$\log^2(n)$ (ao invés de $\log(n)$) vem da inserção / exclusão da árvore de conflito dos descendentes próximos do palpite. Essa suposição pode ser verdadeira para retângulos de uma hierarquia altamente coerente - ou seja, uma com muitas relações de compartimento / contenção realizadas e boa separação entre retângulos que não estão relacionados via compartimento / contenção.

Temos duas outras suposições - "esparsidade uniforme" e "sem poda", cada uma das quais com finalidades secundárias relacionadas à nossa aplicação da mineração quantitativa de regras de associação. Eles nos permitem ajustar o trabalho para reduzir drasticamente, já que a segunda opção para consultas com descendentes próximos pode custar muito tempo. Especificamente, digamos que o número médio de partições para um atributo quantitativo (tratar o atributo categórico como possivelmente vários atributos quantitativos de duas partições) seja$p$; então, o número de regiões sólidas consideradas para cada atributo quantitativo é$p ^ 2$- todos sobrevivem se não tivermos nenhuma suposição de poda. À medida que reduzimos$p$, o espaço de todos os possíveis retângulos multidimensionais diminui e através da suposição de "esparsidade uniforme" para $n$ temos mais colisões (ou seja, possivelmente mais relações de fechamento / contenção), mas o número de retângulos (que são feitos de combinações de regiões sólidas para diferentes atributos) diminui mais rapidamente - isso significa que os descendentes mais próximos consultam a quantidade de tempo necessária que podemos drasticamente encolher reduzindo o número médio de partições $p$ levemente.

Detalhes compartilhados diversos

A única razão pela qual acreditamos que alguém pode querer não usar a opção 1 é um pouco mais dificuldade de implementação. Frequentemente, não vemos um algoritmo proposto que gera relatórios e que, para cada partida, seja um coeficiente de tempo que não seja um. Ainda assim, o coeficiente que temos de$\log(n)$ ou $\log^2(n)$ está bem; $\log^q(n)$ para baixo $q$ geralmente é aceitável onde quer que vejamos $O(1)$, ao contrário de quando temos, por exemplo $n$ onde vemos $O(1)$. Em geral, uma árvore R é melhor que a árvore de segmentos de várias camadas para consultas de gabinete / contenção / interseção de retângulo ou consulta de dominação de ponto se$d$ é menos do que $\log^{max(d - 1, 1)}(n)$ para $d \geq 1$dado que para uma árvore R não clonamos retângulos armazenados. A opção um e a opção dois com premissas implicam que parecemos ser melhores que a força bruta, uma vez que é apropriado omitir$d$.

Referências

• Pratyaksh - Redução transitiva do DAG - resposta (2014)
  https://cs.stackexchange.com/q/29133
• Wikipedia - Redução transitiva - Calculando a redução em gráficos esparsos
  https://en.wikipedia.org/wiki/Transitive_reduction
• Fischer, Meyer - Multiplicação de matrizes booleanas e fechamento transitivo (1971)
• Leutenegger et al. - STR: um algoritmo simples e eficiente para empacotamento de árvores R (1997)
• Procopiuc et al. - Bkd-tree: uma kd-tree dinâmica e escalonável (2003)
• Guttman - R-trees: Uma estrutura dinâmica de índices para busca espacial (1984)