Algoritmo eficiente para distância de edição para sequências curtas

Eu tenho um aplicativo que precisa calcular bilhões de distâncias de levenshtein entre pares de strings. As cadeias são sequências de DNA curtas (70 de comprimento), consistindo apenas de 4 caracteres. Também pode-se supor que uma das seqüências seja fixa, ou seja, estamos comparando uma sequência fixa com um bilhão de outras seqüências.

Eu sei que a implementação de programação dinâmica da distância levenshtein é $\mathcal{O}(m n)$, gostaria de saber se há algum espaço para melhorias. Eu encontrei esses dois algoritmos:

• $\mathcal{O}(n + d^2)$algoritmo, em que é a distância de edição de Berghel et al . No entanto, não posso assumir que é pequeno, por isso pode não dar nenhuma vantagem$d$$d$
• $log(n)^{\mathcal{O}(1/\epsilon)}$ aproximação em $n^{1+\epsilon}$tempo de Andoni et al . Mas tenho duas preocupações com relação a isso:
  • Esse algoritmo também é rápido na prática?
  • Faz $log(n)^{\mathcal{O}(1/\epsilon)}$ significa que a distância de edição calculada no pior dos casos é $log(n)^{\mathcal{O}(1/\epsilon)}$vezes o real? Nesse caso, é demais.

Você conhece algum outro algoritmo / idéia / abordagem que possa ser aplicável?

Uma abordagem é construir um autômato de Levenshtein para a cadeia fixa (veja, por exemplo, aqui ). Dada uma string$x$ e uma distância $D$, você pode criar um DFA que reconheça todas as strings que estão à distância $\le D$ de $x$. Assim, você pode testar se uma sequência está próxima de$x$ no $O(n)$ hora, onde $n$é o comprimento da string. Não tenho certeza de quais são os requisitos de espaço para armazenar o DFA (eles são lineares em$m,n$, mas pode ser exponencial em $D$)

Como alternativa, você pode usar um algoritmo "early-out" para calcular a distância de edição. Você mencionou que só está interessado na distância de edição se for menor que algum limite$D$. Existe um algoritmo "early-out" para calcular a distância de edição cujo tempo de execução é$O(\max(n,m) \times D)$, que calcula a distância de edição, se for $\le D$ ou então gera "muito grande" se for $>D$. Basicamente, você executa o algoritmo de programação dinâmica padrão para a distância de edição, mas calcula apenas os elementos da matriz que são$\le D$longe da diagonal. No seu caso, isso pode ou não ser melhor do que as outras alternativas.

Se eu tivesse que fazer bilhões e tivesse apenas 4 caracteres, eu os representaria como
1000
0100
0010
0001.
É um número inteiro de 35 bytes.

Pontue um pouco ande conte os 1s

Não é perfeito, mas bilhões é muito, a menos que você jogue muita CPU nele.