算法技巧：字符匹配算法 - RABIN KARP 和 KMP

文档阅读

Rabin Kapr文档阅读
KMP文档阅读

Rabin Kapr

本质是滑动窗口计算字符串的hash值(会重复的，需要set进行去重)，需要弄懂两个公式

/* 在最低位添加一个数字 */
int number = 8264;
// number 的进制
int R = 10;
// 想在 number 的最低位添加的数字
int appendVal = 3;
// 运算，在最低位添加一位 ，公式I
number = R * number + appendVal; 
// 此时 number = 82643

/* 在最高位删除一个数字 */
int number = 8264;
// number 的进制
int R = 10;
// number 最高位的数字
int removeVal = 8;
// 此时 number 的位数
int L = 4;
// 运算，删除最高位数字 ，公式II
number = number - removeVal * R^(L-1);
// 此时 number = 264

KMP

public class KMP {
    private int[][] dp;
    private String pat;

    public KMP(String pat) {
        this.pat = pat;
        int M = pat.length();
        // dp[状态][字符] = 下个状态
        dp = new int[M][128];
        // base case
        dp[0][pat.charAt(0)] = 1;
        // 影子状态 X 初始为 0
        int X = 0;
        // 构建状态转移图（稍改的更紧凑了）
        for (int j = 1; j < M; j++) {
            for (int c = 0; c < 128; c++)
                dp[j][c] = dp[X][c];
            dp[j][pat.charAt(j)] = j + 1;
            // 更新影子状态
            X = dp[X][pat.charAt(j)];
        }
    }

    public int search(String txt) {
        int M = pat.length();
        int N = txt.length();
        // pat 的初始态为 0
        int j = 0;
        for (int i = 0; i < N; i++) {
            // 计算 pat 的下一个状态
            j = dp[j][txt.charAt(i)];
            // 到达终止态，返回结果
            if (j == M) return i - M + 1;
        }
        // 没到达终止态，匹配失败
        return -1;
    }
}

题目

187. 重复的DNA序列

Rabin Kapr 算法

class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        int[] nums = new int[s.length()];
        // 将字符转换为数值便于计算hash
        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if(c == 'A') nums[i] = 1;
            else if(c == 'C') nums[i] = 2;
            else if(c == 'G') nums[i] = 3;
            else if(c == 'T') nums[i] = 4;
        }
        Set<String> res = new HashSet<>();
        int left = 0, right = 0;
        //Rabin Karp匹配
        Set<Integer> set = new HashSet<>();
        int R = 4;//进制
        int L = 10;//序列长度
        int RL = (int) Math.pow(R, L - 1);//删除时需要使用
        int windowHash = 0;
        while(right < nums.length){
            windowHash = windowHash * R + nums[right];
            right++;
            while(right - left == L){
                if(set.contains(windowHash)){
                    res.add(s.substring(left, right));
                }else set.add(windowHash);
                windowHash = windowHash - nums[left] * RL;
                left++;
            }
        }
        return new ArrayList<>(res);
    }
}

28. 找出字符串中第一个匹配项的下标

KMP算法

class Solution {
    public int strStr(String haystack, String needle) {
        KMP kmp = new KMP(needle);
        return kmp.search(haystack);
    }
    class KMP{
        int[][] dp;
        String pattern;
        public KMP(String s){
            pattern = s;
            dp = new int[s.length()][128];//dp[状态][字符]指向下个状态
            dp[0][s.charAt(0)] = 1;
            int X = 0;//影子状态，落后一位于dp[i][j]
            for(int i = 1; i < s.length(); i++){
                for(int j = 0; j < 128; j++){
                    dp[i][j] = dp[X][j];
                }
                dp[i][s.charAt(i)] = i + 1;
                X = dp[X][s.charAt(i)];
            }
        }

        public int search(String s){
            int state = 0;//状态
            for(int i = 0; i < s.length(); i++){
                state = dp[state][s.charAt(i)];
                if(state == pattern.length()) return i - pattern.length() + 1;
            }
            return -1;
        }
    }
}