Leetcode 30 Substring with Concatenation of All Words

最新推荐文章于 2021-01-05 17:33:28 发布

原创最新推荐文章于 2021-01-05 17:33:28 发布 · 231 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种在给定字符串中寻找由多个固定长度单词组成的子串的算法，通过使用哈希映射来跟踪单词出现次数，实现高效查找。文章提供了两种解决方案，详细解释了算法原理和代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.

Example 1:

Input:
  s = "barfoothefoobarman",
  words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.

Example 2:

Input:
  s = "wordgoodstudentgoodword",
  words = ["word","student"]
Output: []

这个题目的意思是在原始串中找到连续子串的位置，注意每个子串的长度是唯一的。

1）

class Solution {
    public List<Integer> findSubstring(String S, String[] L) {
        List<Integer> result = new ArrayList<>();
        if (S == null || L == null || L.length == 0) return result;
        int size = L[0].length();
        if (L.length == 0 || L[0].isEmpty() || L[0].length() > S.length()) 
            return result;
        Map<String, Integer> hist = new HashMap<>();
        for (String w : L) {
            hist.put(w, !hist.containsKey(w) ? 1 : hist.get(w)+1);
        }
        for (int i = 0; i+size*L.length <= S.length(); i++) {
            if (hist.containsKey(S.substring(i, i+size))) {
                Map<String, Integer> currHist = new HashMap<>();
                for (int j = 0; j < L.length; j++) {
                    String word = S.substring(i+j*size, i+(j+1)*size);
                    currHist.put(word, !currHist.containsKey(word) ? 
                            1 : currHist.get(word)+1);
                }
                if (currHist.equals(hist)) result.add(i);
            }
        }
        return result;
    }
}

2）

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        int n = s.length(), m = words.length;
        List<Integer> result = new ArrayList<>();
        if (m == 0 || n == 0) return result;
        int l = words[0].length();                              //请注意，题目中说明了，每个word的长度是相同的
        
        Map<String, Integer> map = new HashMap<>();
        for (String w : words) {
            map.put(w, map.getOrDefault(w, 0) + 1);
        }
        
        for (int i = 0; i < l; i++) {          // 最初起点为 0,1,.... l-1 不用的offset
            for (int j = i; j + m * l <= n; j = j + l) {          // 确保整个substring长度不会超出
                String ss = s.substring(j, j + m * l);            // 拿到整个substring
                Map<String, Integer> temp = new HashMap<>();
                for (int k = m - 1; k >= 0; k--) {
                    String w = ss.substring(k * l, (k + 1) * l);
                    int count = temp.getOrDefault(w, 0) + 1;
                    
                    if (count > map.getOrDefault(w, 0)) {    // 这个是关键trick这也是为什么要从末尾开始，break的时候可以把指针大幅向前
                        j = j + k * l;                    // 跳到当前check的下一个，因为父循环有 j = j+l,这里只要 跳到check的那个就行了 j +k*l +l-l
                        //j = j+m*l-l;
                        break;
                    } else if (k == 0) {
                        result.add(j);
                    } else {
                        temp.put(w, count);
                    }
                }
            }
        }
        return result;        
    }

}