《算法》第五章部分程序 part 5

▶ 书中第五章部分程序，包括在加上自己补充的代码，Knuth-Morris-Pratt 无回溯匹配，Boyer - Moore 无回溯匹配，Rabin - Karp 指纹匹配

● Knuth-Morris-Pratt 无回溯匹配

 package package01;

 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private final int R;                    // 字符集基数
     private int[][] dfa;                    // 回溯数组
     private String pat;                     // 模式的两种保存方式
     private char[] pattern;

     public class01(String pat)              // 分别从两种表示方式中创建回溯数组，算法仙童
     {
         this.R = 256;
         this.pat = pat;

         int m = pat.length();
         dfa = new int[R][m];
         dfa[pat.charAt(0)][0] = 1;          // 第 0 位匹配，接下来匹配第 1 位
         for (int x = 0, j = 1; j < m; j++)  // 跳转点初始化为 0，即某次比较后需要退回到模式的头部再开始
         {
             for (int c = 0; c < R; c++)
                 dfa[c][j] = dfa[c][x];      // 原文字母 c 与模式第 j 位比较等价于原文字母 c 与模式第 x 位比较，跳转点也相同
             dfa[pat.charAt(j)][j] = j + 1;  // 原文某位与模式第 j 位正确匹配，接下来应该用原文下一位与模式 j+1 位进行匹配
             x = dfa[pat.charAt(j)][x];      // 设置 x 为原文某位与模式第 x 位比较后的跳转点
         }
     }

     public class01(char[] pattern, int R)
     {
         this.R = R;
         this.pattern = new char[pattern.length];
         for (int j = 0; j < pattern.length; j++)
             this.pattern[j] = pattern[j];

         int m = pattern.length;
         dfa = new int[R][m];
         dfa[pattern[0]][0] = 1;
         for (int x = 0, j = 1; j < m; j++)
         {
             for (int c = 0; c < R; c++)
                 dfa[c][j] = dfa[c][x];
             dfa[pattern[j]][j] = j + 1;
             x = dfa[pattern[j]][x];
         }
     }

     public int search(String txt)                       // 利用 DFA 原理进行匹配
     {
         int m = pat.length(), n = txt.length(), i, j;   // i 指向待匹配字符串，j 指向模式
         for (i = 0, j = 0; i < n && j < m; i++)         // i 不断自增，j 不断跳转
             j = dfa[txt.charAt(i)][j];                  // y = dfa[txt[i]][j] 表示 txt[i] 与 pattern[j] 比较后，下一步应该与 txt[i+1] 进行比较的模式的下标，
                                                         // 即下一步应该把 txt[i+1] 与 pattern[y] 进行比较
         return (j == m) ? (i - m) : n;                  // 找到匹配则返回子字符串的索引位置，没有匹配则返回原字符串的长度
     }

     public int search(char[] text)
     {
         int m = pattern.length;
         int n = text.length;
         int i, j;
         for (i = 0, j = 0; i < n && j < m; i++)
             j = dfa[text[i]][j];
         return (j == m) ? (i - m) : n;
     }

     public static void main(String[] args)
     {
         String pat = args[0], txt = args[1];
         char[] pattern = pat.toCharArray(), text = txt.toCharArray();   // 输入存成两种格式，分别进行匹配

         class01 kmp1 = new class01(pat);
         int offset1 = kmp1.search(txt);
         class01 kmp2 = new class01(pattern, 256);
         int offset2 = kmp2.search(text);

         StdOut.println("text:    " + txt);                              // 输出原文
         StdOut.print("pattern: ");
         for (int i = 0; i < offset1; i++)                               // 匹配的前导空格
             StdOut.print(" ");
         StdOut.println(pat);

         StdOut.print("pattern: ");
         for (int i = 0; i < offset2; i++)
             StdOut.print(" ");
         StdOut.println(pat);
     }
 }

● Boyer - Moore 无回溯匹配

 package package01;

 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private final int R;
     private int[] right;               // 回溯控制数组
     private char[] pattern;
     private String pat;

     public class01(String inputPat)
     {
         R = 256;
         pat = inputPat;
         int m = pat.length();
         right = new int[R];
         for (int c = 0; c < R; c++)   // 初始化为 -1
             right[c] = -1;
         for (int j = 0; j < m; j++)   // 记录每个字母在模式或者能够出现的最靠右的地方
             right[pat.charAt(j)] = j;
     }

     public class01(char[] inputPattern, int inputR)
     {
         R = inputR;
         pattern = new char[inputPattern.length];
         for (int j = 0; j < pattern.length; j++)
             pattern[j] = inputPattern[j];
         int m = pattern.length;
         right = new int[R];
         for (int c = 0; c < R; c++)
             right[c] = -1;
         for (int j = 0; j < m; j++)
             right[pattern[j]] = j;
     }

     public int search(String txt)
     {
         int m = pat.length(), n = txt.length(), skip;
         for (int i = 0; i <= n - m; i += skip)          // i 指向原文，向后移动
         {
             skip = 0;
             for (int j = m - 1; j >= 0; j--)            // j 指向模式，向前移动
             {
                 if (pat.charAt(j) != txt.charAt(i + j)) // 若原文第 i+j 位 和模式第 j 位匹配，则自减 j 继续检查，若不匹配则要尝试跳转
                 {
                     skip = Math.max(1, j - right[txt.charAt(i + j)]);   // 考虑原文第 i+j 位在匹配串中最右出现的位置，
                     break;                                              // 若模式根本没有该字符，则 right[x] 等于 -1，skip 等于 1，原文前进 1 格，从模式头部开始重新匹配
                 }                                                       // 若模式有该字符，则 j - right[x] 等于该字符的右边的字符数（跳转后不需要检查的部分）
             }
             if (skip == 0)                              // j 循环检查完了 skip 都没变过，找到了，此时 i 指向原文中匹配的子字符串的开头
                 return i;
         }
         return n;                                       // i 循环走完了都没找到
     }

     public int search(char[] text)
     {
         int m = pattern.length, n = text.length, skip;
         for (int i = 0; i <= n - m; i += skip)
         {
             skip = 0;
             for (int j = m - 1; j >= 0; j--)
             {
                 if (pattern[j] != text[i + j])
                 {
                     skip = Math.max(1, j - right[text[i + j]]);
                     break;
                 }
             }
             if (skip == 0)
                 return i;
         }
         return n;
     }

     public static void main(String[] args)
     {
         String pat = args[0], txt = args[1];
         char[] pattern = pat.toCharArray(), text = txt.toCharArray();

         class01 bm1 = new class01(pat);
         int offset1 = bm1.search(txt);
         class01 bm2 = new class01(pattern, 256);
         int offset2 = bm2.search(text);

         StdOut.println("text:    " + txt);
         StdOut.print("pattern: ");
         for (int i = 0; i < offset1; i++)
             StdOut.print(" ");
         StdOut.println(pat);

         StdOut.print("pattern: ");
         for (int i = 0; i < offset2; i++)
             StdOut.print(" ");
         StdOut.println(pat);
     }
 }

● Rabin - Karp 指纹匹配

 package package01;

 import java.math.BigInteger;
 import java.util.Random;
 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private String pat;
     private long patHash;    // 模式的 hash 值
     private int R;           // 字符集基数
     private int m;           // 模式畅读
     private long q;          // 计算 hash 用的大素数
     private long RM;         // 中间值，等于 R^(m-1) % q

     public class01(char[] inputPattern, int inputR)
     {
         new class01(String.valueOf(inputPattern), inputR);
     }

     public class01(String inputPat, int inputR)
     {
         pat = inputPat;
         R = inputR;
         m = pat.length();
         q = longRandomPrime();
         RM = 1;                             // 计算 RM
         for (int i = 1; i <= m - 1; i++)
             RM = (R * RM) % q;
         patHash = hash(pat, m);
     }

     private long hash(String key, int m)    // 计算 hash 值，m 为字符串长度，hash = (Σ key[i] * R^(m-1-i)) % q，求和循环 i
     {                                       // 递推 x[0] = key[0] % q，x[k+1] = (R * x[k] + key[k+1]) % q
         long h = 0;
         for (int j = 0; j < m; j++)
             h = (R * h + key.charAt(j)) % q;
         return h;
     }

     public int search(String txt)
     {
         int n = txt.length();
         if (n < m)                                                      // 原文太短
             return n;
         long txtHash = hash(txt, m);                                    // 注意传入模式长度 m，表示计算 txt[0] ~ txt[m-1] 的 hash
         if ((patHash == txtHash) && check(txt, 0))                      // 原文头一段 hash 等于模式 hash，且通过了逐字比较，完成匹配
             return 0;
         for (int i = m; i < n; i++)
         {
             txtHash = (txtHash - RM * txt.charAt(i - m) % q + q) % q;   // 更新原文的 hash，首先去掉第 i - m 位
             txtHash = (txtHash*R + txt.charAt(i)) % q;                  // 然后加入第 i 位
             int offset = i - m + 1;                                     // 新的比较起点
             if ((patHash == txtHash) && check(txt, offset))             // 同上，通过 hash 比较和逐字比较，完成匹配
                 return offset;
         }
         return n;                                                       // 没有匹配
     }

     private static long longRandomPrime()                               // 生成大素数
     {
         return BigInteger.probablePrime(31, new Random()).longValue();
     }

     private boolean check(String txt, int i)                            // 复查原文 txt[i] ~ txt[i+m-1] 是否匹配模式
     {
         for (int j = 0; j < m; j++)
         {
             if (pat.charAt(j) != txt.charAt(i + j))
                 return false;
         }
         return true;
     }

     public static void main(String[] args)
     {
         String pat = args[0], txt = args[1];
         class01 searcher = new class01(pat, 256);
         int offset = searcher.search(txt);

         StdOut.println("text:    " + txt);
         StdOut.print("pattern: ");
         for (int i = 0; i < offset; i++)
             StdOut.print(" ");
         StdOut.println(pat);
     }
 }