数组题目总结 -- 滑动窗口算法延伸：字符串匹配算法（KMP，Rabin-Karp ）

已于 2023-07-26 15:12:52 修改
阅读量314 收藏
点赞数
分类专栏： 算法-系统整理 文章标签： 算法
于 2023-07-26 14:46:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39671159/article/details/131911790
版权

目录

一. 重复的DNA序列

思路和代码：

I. 博主的做法

  • 一共 31 个用例，到第 30 个，超时了，，
  • 博主的思路就是滑动窗口
    • template：为固定的模板字符串
    • temp：从template的第二位起始的临时字符串，用于和 template 进行比较
    • 不断的遍历，如果 temp == template 并且 template 不在 res 当中，那么添加到 res 里去
class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        int len = 10;
        int left = 0;
        int start;
        int end;

        List<String> res = new ArrayList<>();

        String template = "";
        String temp = "";
        
        while(left + len <= s.length()){
            start = left + 1;
            end = start + len;

            template = s.substring(left, left + len);

            while(end <= s.length()){
                temp = s.substring(start, end);
                if(temp.equals(template) && !res.contains(template))
                    res.add(temp);
                start++;
                end = start + len;
            }
            left++;
        }


        return res;
    }
}

II. 东哥的做法

法一：hash 暴力法
  • 遍历所有含有 10 个元素的字符串，如果，有重复的，加入 res 里面
class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        Set<String> needs = new HashSet<>();
        Set<String> res = new HashSet<>();
        int len = 10;

        String temp = "";

        for(int i = 0; i + len <= s.length(); i++){
            temp = s.substring(i, i + len);

            if(needs.contains(temp))
                res.add(temp);
            else
                needs.add(temp);
        }
        return new LinkedList<>(res);
    }
}
  • 假设s的长度为 N，目标子串的长度为 L（本题 L = 10），for 循环遍历 s 的O(N)个字符，对每个字符都要截取长度为 L 的子字符串，所以这个算法的时间复杂是O(NL)。
法二：hash + 滑动窗口
  • 一旦想把字符转化成字符串，就难免需要O(L)的时间来操作。通过其他方式优化这个事：用数字代替字母
  • 把AGCT四种字符等价为0123四个数字，那么长度为L = 10的一个碱基序列其实就可以等价为一个十位数，这个数字可以唯一标识一个子串
  • 而且窗口移动的过程，其实就是给这个数字的最低位添加数字，并删除最高位数字的过程！！！
    • 可以在 O(1) 的时间完成
    • 我们再想如果用传统的10进制来算，因为字符串固定 10 位，那么我们数字也要 10 位，而10 * 10 > 2147483647 已经超过了 int 的表示范围。我们其实只用了 4 个字母，那么其他的位数就浪费了，我们最终搞一个 4 进制就 ok 了
    • 看下面一个小例子：
      • 给你输入一个字符串形式的正整数，如何把它转化成数字的形式？
	string s = "8264";
	int number = 0;
	for (int i = 0; i < s.size(); i++) {
	    // 将字符转化成数字
	    number = 10 * number + (s[i] - '0');
	    print(number);
	}
	// 打印输出：
	// 8
	// 82
	// 826
	// 8264
  • 因为我们默认的是 10 进制，接下来我们抽象一下：
	/* 在最低位添加一个数字 */
	int number = 8264;
	// number 的进制
	int R = 10;
	// 想在 number 的最低位添加的数字
	int appendVal = 3;
	// 运算，在最低位添加一位
	number = R * number + appendVal;
	// 此时 number = 82643
	
	/* 在最高位删除一个数字 */
	int number = 8264;
	// number 的进制
	int R = 10;
	// number 最高位的数字
	int removeVal = 8;
	// 此时 number 的位数
	int L = 4;
	// 运算，删除最高位数字
	number = number - removeVal * R^(L-1);
	// 此时 number = 264
  • 四进制理解不了就用十进制理解，完了，一替换就完事了
  • 理解了上面的代码，就可以看本题的代码了：
class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        int[] nums = new int[s.length()];
		//将字符串转换成数字数组
        for(int i = 0; i < s.length(); i++){
            switch(s.charAt(i)){
                case 'A':
                    nums[i] = 0;
                    break;
                case 'C':
                    nums[i] = 1;
                    break;
                case 'G':
                    nums[i] = 2;
                    break;
                case 'T':
                    nums[i] = 3;
                    break;
            }
        }
		//存放字符对应的数字（哈希）
        Set<Integer> seen = new HashSet<>();
        //存放返回结果
        Set<String> res = new HashSet<>();
        //数字的位数
        int len = 10;
        //进制
        int R = 4;
        //用于减法的参数，类比十进制：564 = 8564 - 8 * (10^3)
        int RL = (int)Math.pow(R, len - 1);

        int windowHash = 0;

        int left = 0, right = 0;

        while(right < s.length()){
        	//向右扩展窗口，增加位数	
            windowHash = windowHash * R + nums[right];
            right++;
			//当长度为 10 再进行操作
            if(right - left == len){
                if(seen.contains(windowHash))
                    res.add(s.substring(left, right));
                else
                    seen.add(windowHash);
               	//窗口收缩，左边缘右移
                windowHash = windowHash - nums[left] * RL;
                left++; 
            }

        }
        return new LinkedList<>(res);
    }
}
  • windowHash = windowHash - nums[left] * RL; left++; 这两句一定要当字符串长度为 10 的时候再做，要不然滑动窗口就没有意义，一定要在 if(right - left == len){ }里面进行操作
  • 本质上，将字符串操作转换成了数字的操作，这种想法以后可以借鉴！大大降低了时间复杂度
  • 时间复杂度：O(N)
  • 空间复杂度：O(N)

二. Rabin-Karp 算法

// Rabin-Karp 指纹字符串查找算法
int rabinKarp(String txt, String pat) {
    // 位数
    int L = pat.length();
    // 进制（只考虑 ASCII 编码）
    int R = 256;
    // 取一个比较大的素数作为求模的除数
    long Q = 1658598167;
    // R^(L - 1) 的结果
    long RL = 1;
    for (int i = 1; i <= L - 1; i++) {
        // 计算过程中不断求模，避免溢出
        RL = (RL * R) % Q;
    }
    // 计算模式串的哈希值，时间 O(L)
    long patHash = 0;
    for (int i = 0; i < pat.length(); i++) {
        patHash = (R * patHash + pat.charAt(i)) % Q;
    }
    
    // 滑动窗口中子字符串的哈希值
    long windowHash = 0;
    
    // 滑动窗口代码框架，时间 O(N)
    int left = 0, right = 0;
    while (right < txt.length()) {
        // 扩大窗口，移入字符
        windowHash = ((R * windowHash) % Q + txt.charAt(right)) % Q;
        right++;

        // 当子串的长度达到要求
        if (right - left == L) {
            // 根据哈希值判断是否匹配模式串
            if (windowHash == patHash) {
                // 当前窗口中的子串哈希值等于模式串的哈希值
                // 还需进一步确认窗口子串是否真的和模式串相同，避免哈希冲突
                if (pat.equals(txt.substring(left, right))) {
                    return left;
                }
            }
            // 缩小窗口，移出字符
            windowHash = (windowHash - (txt.charAt(left) * RL) % Q + Q) % Q;
            // X % Q == (X + Q) % Q 是一个模运算法则
            // 因为 windowHash - (txt[left] * RL) % Q 可能是负数
            // 所以额外再加一个 Q，保证 windowHash 不会是负数

            left++;
        }
    }
    // 没有找到模式串
    return -1;
}

三. 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][256];
        // 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 < 256; 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;
    }
}
Marry Andy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
热-KMP算法：字符串匹配的高效利器
04-03
除了KMP算法，还有其他字符串匹配算法，如Boyer-Moore算法、Rabin-Karp算法等。它们各有特点，适用于不同的场景。比如Boyer-Moore算法利用坏字符规则和好后缀规则，比KMP更高效但实现相对复杂；Rabin-Karp算法则基于...
使用模运算改进的字符串匹配Rabin-Karp算法
03-31
**字符串匹配Rabin-Karp算法**是一种在文本中查找子串出现位置的高效算法，它由Rabin和Karp在1987年提出。在传统的字符串匹配算法中，如朴素算法，每次比较一个字符，如果发现不匹配则需要从头开始检查下一个位置，...
Rabin-Karp算法，超全解释
m0_72410588的博客
06-14 1714
Rabin-Karp算法是一种高效的字符串匹配算法，采用滑动窗口和哈希函数的方法，在平均情况下仅需O(n+m)次比较操作就可以完成匹配过程。Rabin-Karp算法包含两个步骤：预处理和匹配。在实际应用中，可以通过多重哈希、指纹压缩、字符串预处理等优化策略进一步提高Rabin-Karp算法的运行效率。
【leetcode】字符串（KMP、滑动窗口）算法
myaijarvis notebook
01-18 619
参考自 代码随想录 Java、Python的String字符串是不可变的 KMP 实例：28. 实现 strStr - 力扣（LeetCode） 参考：有限状态机之 KMP 字符匹配算法 :: labuladong的算法小抄 用一个二维的 dp 数组（但空间复杂度还是 O(M)），重新定义其中元素的含义. 视频必看 参考：帮你把KMP算法学个通透！（理论篇）_哔哩哔哩_bilibili 参考：帮你把KMP算法学个通透！（求next数组代码篇）_哔哩哔哩_bilibili 前缀表不减一也不右移 容易理解 h
探索字符串匹配算法：Rabin-Karp算法
laterstage的博客
08-27 431
Rabin-Karp算法是一种基于哈希的字符串匹配算法，可以高效地在文本中查找特定模式的出现。本文通过深入介绍Rabin-Karp算法的原理和实现，希望读者能够更好地理解和应用这一强大的字符串匹配工具。
LeetCode算法小抄--Rabin-Karp 算法
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
04-08 372
拉宾-卡普算法（英语：Rabin–Karp algorithm）或卡普-拉宾算法（Karp–Rabin algorithm），是一种由理查德·卡普与迈克尔·拉宾于1987年提出的、使用散列函数以在文本中搜寻单个模式串的字符串搜索算法单次匹配。该算法先使用旋转哈希以快速筛出无法与给定串匹配的文本位置，此后对剩余位置能否成功匹配进行检验。此算法可推广到用于在文本搜寻单个模式串的所有匹配或在文本中搜寻多个模式串的匹配。若要在一段文本中找出单个模式串的一个匹配，此算法具有线性时间。
(Rabin-Karp算法)匹配字符串（滚动哈希）
田埂、の技术博客
07-14 640
(Rabin-Karp算法)匹配字符串（滚动哈希） Rabin-Karp算法的思路是将字符串的比较转换成数字的比较。比较两个长度为m的字符串是否相等需要O(m)的时间，而比较两个数字是否相等通常可以是O(1)。为了将字符串映射到对应的数字，故此需要用到哈希函数。 接下来的问题是，如何快速将字符串映射到对应的数字呢？如果需要在 O(L)的时间内算出编码，这种方法就没有意义了，因为这个直接进行字符串比较需要的时间相同。为了能够快速计算出字符串编码，我们可以将字符串看成一个 26 进制的数（因为字符串中仅
立体匹配算法_自适应窗口_Cross Based Support Region
EasyWater
07-20 3766
1 自适应窗口 对于立体匹配局部算法而言，匹配代价计算 和 支持窗口选择是很重要的两个问题：匹配代价计算通过前面的文章已经介绍了关于Adaptive Support-Weight和Rank Transform两种方法，对于支持窗口来说的，通常我们选取一个矩形窗，既然要自适应通常有一下几个思路： 1）自适应大小：通过参数自适应调整矩形的长和宽来改变窗口，例如对于重复纹理区域我们可以采用较大的支持
【算法】Rabin-Karp 算法
代码星辰的博客
12-01 458
本文介绍了 Rabin-Karp 算法的相关知识。
字符串匹配算法之Rabin-Karp,KMP算法
vinojie的博客
09-14 1017
Rabin-Karp算法 Rabin-Karp算法是由M.O.Rabin和R.A.Karp发明的一种基于散列的字符串查找算法。 Rabin_karp算法的思想是通过将字符串的比较转回成数字的比较。比较两个长度为m的字符串是否相等需要O(m)时间，而比较两个数字是否相等通常可以是O(1)。为了将字符串映射称对应的数字，需要用到哈希函数。 这里存在一个问题就是利用哈希函数将字符串映射成对应的数字有可能发生哈希冲突，也就是说两个字符串通过哈希函数得到数字相等，但是这两个字符不同。Rabin-Karp的解决方法是，
java 中模式匹配算法-KMP算法实例详解
08-30
"java 中模式匹配算法-KMP 算法实例详解...10. KMP 算法的扩展：KMP 算法可以扩展到其他模式匹配算法，例如 BM 算法、Rabin-Karp 算法等。 KMP 算法是一种高效的模式匹配算法，广泛应用于字符串匹配、文本搜索等领域。
String-matching-algorithms:字符串匹配算法
06-26
在Java编程语言中，实现字符串匹配算法可以帮助我们高效地在文本数据中查找特定的子串。以下是一些常见的字符串匹配算法及其在Java中的实现细节： 1. **朴素匹配算法**： - **基本思想**：从文本串的起始位置开始...
kmp算法-基于Python实现的kmp字符串搜索算法.zip
05-16
而与Boyer-Moore算法和Rabin-Karp算法相比，KMP在某些特定情况下可能稍逊一筹，但其简单性和易于理解使其成为初学者学习字符串匹配算法的良好起点。 在压缩包中的文件"**kmp算法_基于Python实现的kmp字符串搜索算法...
函数模板与类模板
程序员_小兵
07-12 1565
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 414
算法014：找到字符串中所有字母异位词
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 379
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 818
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
树与二叉树
最新发布
2201_76027754的博客
07-15 699
树和二叉树
算法原理与实践课件2_数组与字符串1
08-03
6. 除了上述的Rabin-Karp算法，还有其他高效的字符串匹配算法，如KMP算法和Boyer-Moore算法，它们通过预处理模式串来减少不必要的字符比较，从而进一步提高匹配效率。KMP算法利用部分匹配表避免回溯，Boyer-Moore...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值