JAVA estruturas de dados e algoritmos: KMP

resumo

KMP algoritmo é uma melhoria da cadeia correspondente algoritmo, proposto por DEKnuth, JHMorris e VRPratt, para que as pessoas chamam de Knuth - Morris - Pratt operação (referido algoritmo KMP). O núcleo KMP algoritmo com base em informações não corresponde, para minimizar o número de match string string padrão principal para atingir o objectivo de correspondência rápido. implementação específica é implementado por uma função next (), a função de correspondência locais em si contém cadeia padrão informações. KMP algoritmo complexidade de tempo de O (m + n).

breve introdução

cadeia correspondente é o funcionamento básico da cadeia, a maneira mais direta é a atravessar a busca completa retrocesso, mas sua alta complexidade, e como as pessoas procuram para coincidir com a eficiência e otimizar o jogo, combinando a sua complexidade é gradualmente reduzido.
Neste processo, quando a parte mais importante da KMP, ele irá reduzir a complexidade do algoritmo original para o (n + m) em que n, m é o comprimento dos dois cordões.

detalhado

O recuo mais directo

Iniciar cadeia correspondente da esquerda, se você encontrar o mesmo sc j + 1 e colegas, até que todos foram atravessados ​​quando retornar ao p subscrito, se não é o mesmo que o processo de correspondência levado de volta para sc i.

public class Match_kmp {
    public static void main(String[] args) {
        System.out.println(indexOf("aaavbvdd","vbv"));
    }
    private static int indexOf(String s,String p){
        int i = 0;
        int sc = i;
        int j = 0;
        while (sc<s.length()){
            if(s.charAt(sc)==p.charAt(j)){
                j++;
                sc++;
                if(j==p.length()){
                    return i;
                }
            }else
            {
                i++;
                sc=i;
                j=0;
            }
        }
        return -1;
    }
}

Como resultado, a primeira partida é devolvido i subscrito

• Este método de resolver a complexidade alcançado O (N * m), KMP algoritmo descrito abaixo.

jogo KMP

diagrama

① correspondem esquerda para a direita, quando i = 0, j = 0; se o mesmo j ++, i ++, j se não Backtracking idênticos

② um jogo diferente da última vez retrocesso tempo se a violência combinando i ++, então j = 0;
mas antes de podermos fazer uso da corda foi mais de T, retrocesso. Esta é mais tempo será reduzida complexidade. j depende na parte de trás ao lado do texto correspondente T [Matriz]. Próximo Solução abaixo da referida matriz em .next = {} 0,0,0,0,2,2
$= Tamanho certo da -próximo string combinada [j]$
tão próxima [5] = 2, o tamanho certo = 5-2, j neste momento é também retrocesso
$j = próxima [j-1]$
③ assim, em seguida, j = 2; comparados não são idênticos, o retrocesso j = 2-próxima [j-

KMP

public class MatchKMP {
    public static void main(String[] args) {
        int ne[] =getNext("abcdabd");
        int res = kmp("ssdfgasdbababa","bababa",ne);
        System.out.println(res);
    }
    private static int kmp(String s,String t,int[] next){
        for (int i = 0,j=0;i<s.length();i++){
            while(j>0&&s.charAt(i)!=t.charAt(j)){
                j=next[j-1];
            }if(s.charAt(i)==t.charAt(j)){
                j++;
            }
            if(j==t.length()){
                return i-j+1;
            }
        }
        return 0;
    }
    private static int[] getNext(String t){
        int next[]=new int[t.length()];
        next[0]=0;
        for (int i = 1,j=0; i < t.length(); i++) {
            while (j>0&&t.charAt(j)!=t.charAt(i))
                j=next[j-1];
            if(t.charAt(i)==t.charAt(j))
                j++;
            next[i]=j;
        }
        return next;
    }
}

Resolver próxima série

• Prefixo é uma coleção de personagens, exceto a última
• Em adição a um primeiro conjunto de caracteres de sufixo o
  prefixo e de sufixo de abcabd calculado
  antes de sufixos de caracteres são 0
  ab & prefixo é [a] um sufixo [b] 0 é o mesmo
  prefixo é ABC [a, ab] sufixo é [bc, c] a mesma que a 0
  prefixo ABCA é [a, ab, ABC] sufixo é [BCA, CA, um] 0
  abcab o prefixo [a, ab, ABC, ABCA ] sufixo é [bcab, táxi, ab, b] ao máximo o mesmo que ab próxima [4] = 2
  prefixo abcabd é [a, ab, ABC, ABCB , abcabd]
  sufixo [bcabd, CABD, abd, bd , d] comprimento total máximo ou ab-la próximo [ 5] = 2;

  private static int[] getNext(String t){
        int next[]=new int[t.length()];
        next[0]=0;
        for (int i = 1,j=0; i < t.length(); i++) {
            while (j>0&&t.charAt(j)!=t.charAt(i))
                j=next[j-1];
            if(t.charAt(i)==t.charAt(j))
                j++;
            next[i]=j;
        }
        return next;
    }

resumo

algoritmo de aprendizagem KMP Passei muito tempo, especialmente quando leitura não foi compreendida. Mais tarde, depois de seu próprio desenho, e imediatamente entender, as coisas ainda têm que fazê-lo.

referência

Baidu Encyclopedia KMP algoritmo

Desenho mim, e imediatamente entender, as coisas ainda têm que fazê-lo.

referência

Baidu Encyclopedia KMP algoritmo

Blog de Ruan Yifeng cadeia correspondente algoritmo KMP