LeetCode 30. 串联所有单词的子串

最新推荐文章于 2024-11-06 23:21:54 发布

Sasakihaise_

最新推荐文章于 2024-11-06 23:21:54 发布

阅读量2.3k

点赞数

分类专栏： LeetCode 文章标签： leetcode 滑动窗口

本文链接：https://blog.csdn.net/Sasakihaise_/article/details/125426208

版权

LeetCode 专栏收录该内容

438 篇文章 1 订阅

订阅专栏

这篇博客介绍了两种优化方法来查找一个字符串中包含所有给定单词的连续子串。第一种是暴力加哈希表的方法，对每个字符遍历可能的子串并检查其是否存在哈希表中。第二种方法利用滑动窗口，当遇到不匹配的字符串时，只需移动到下一个单词的位置，减少了无效的检查，显著提高了效率。这两种方法都利用了哈希表来存储和验证单词出现的次数。

摘要由CSDN通过智能技术生成

30. 串联所有单词的子串

【暴力+哈希表】对于每一个字符，都暴力遍历从他开始到一直到后面能组成整个字符串的长度，每次移动words[i]长度的位置就判断是否在哈希表中。

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        int m = words.length, n = words[0].length();
        Map<String, Integer> map = new HashMap();
        for(var str: words) map.put(str, map.getOrDefault(str, 0) + 1);
        int l = s.length() - m * n;
        List<Integer> ans = new ArrayList();
        for(var i = 0; i <= l; i++){
            Map<String, Integer> tab = new HashMap(map);
            int flag = 1;
            for(var j = 1; j <= m; j++){
                String tmp = s.substring(i + (j - 1) * n, i + j * n);
                if(tab.containsKey(tmp)) {
                    if(tab.get(tmp) == 1) tab.remove(tmp);
                    else tab.put(tmp, tab.get(tmp) - 1);
                }
                else{
                    flag = 0; break;
                }
            }
            if(flag == 1) ans.add(i);
        }
        return ans;
    }
}

【滑动窗口+哈希】我们发现当一个字符串不匹配的时候我们可以先跳到下一个字符串的位置，这样哈希表只去掉之前那一个字符就行。

class Solution {

    // 滑动窗口+哈希 

    public List<Integer> findSubstring(String s, String[] words) {
        int m = s.length(), n = words.length, l = m - n, k = words[0].length();
        Map<String, Integer> map = new HashMap();
        List<Integer> ans = new ArrayList();
        for(var str: words) map.put(str, map.getOrDefault(str, 0) + 1);
        for(var i = 0; i < k; i++){
            int j = i;
            Map<String, Integer> tmp = new HashMap();
            while(j + k * n <= m){
                // System.out.println(j);
                if(j == i){
                    for(var p = 0; p < n; p++){
                        var str = s.substring(j + p * k, j + (p + 1) * k);
                        tmp.put(str, tmp.getOrDefault(str, 0) + 1);
                    }
                    if(map.equals(tmp)) {
                        ans.add(j);
                    }
                    // tmp.forEach((x, y) -> {
                    //     System.out.print(x + " " + y + ", ");
                    // });
                    // System.out.println();
                }else{
                    var old = s.substring(j - k, j);
                    if(tmp.get(old) == 1) tmp.remove(old);
                    else tmp.put(old, tmp.getOrDefault(old, 0) - 1);
                    var neww = s.substring(j + (n - 1) * k, j + n * k);
                    tmp.put(neww, tmp.getOrDefault(neww, 0) + 1);
                    if(map.equals(tmp)) {
                        ans.add(j);
                    }
                    // tmp.forEach((x, y) -> {
                    //     System.out.print(x + " " + y + ", ");
                    // });
                    // System.out.println();
                }
                j += k;
            }
        }
        return ans;
    }
}

果然要快很多。