leetcode hot 100-438. 找到字符串中所有字母异位词

438. 找到字符串中所有字母异位词

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。

示例 1:

输入:
s: "cbaebabacd" p: "abc"

输出:
[0, 6]

解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。

 示例 2:

输入:
s: "abab" p: "ab"

输出:
[0, 1, 2]

解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。

思路一：暴力法

对 p 串的每个字符进行hash计数 从下标0开始遍历字符串s,对于每个下标，判断接下来长度为pLength的子串是否为目标串的字母异位词：

• 判断过程为临时拷贝一份新的技术数组，然后遍历到的子串的每个字符的计数器减一，出现负数则 break 结束当前子串的统计，进入下个子串的统计。

• 如果统计了长度为 pLength的子串仍没有发现计数器减为负数的情况，说明找到了一个符合条件的字母异位词，把子串的第一个字符下标存下来

 1 class Solution {
 2     public List<Integer> findAnagrams(String s, String p) {
 3 
 4         // 对p串的每个字符进行hash计数
 5         int pLength = p.length();
 6         int sLength = s.length();
 7         int[] counts = new int[26];
 8         for(int i = 0; i < pLength; i++){
 9             counts[p.charAt(i) - 'a']++;
10         }
11 
12         ArrayList<Integer> res = new ArrayList<>();
13         
14         // 从下标0开始遍历字符串s,对于每个下标，判断接下来长度为pLength的子串是否为目标串的字母异位词
15         for(int i = 0; i <= sLength - pLength; i++){
16             int[] tempCounts = Arrays.copyOf(counts, 26);
17             int j = i;
18             // 内部每次遍历p的长度个数的子串，把子串中每个字符的计数器减一，出现负数则进入下个子串的统计
19             for(; j < sLength && j < pLength + i; j++){
20                 if(--tempCounts[s.charAt(j) - 'a'] < 0){
21                     break;
22                 }
23             }
24             if(j >= pLength + i){  // 说明找到了一个符合条件的字母异位词
25                 res.add(i);
26             }
27         }
28         return res;
29     }
30 }

leetcode 执行用时：505 ms > 12.85%, 内存消耗：39.1 MB > 98.97%

复杂度分析：

时间复杂度：O(pLength * sLength)。时间开销主要来自双层循环，循环的迭代次数分别是(sLength-pLength+1)和 pLength, 所以时间复杂度为O((sLength-pLength+1) * pLength), 去除低阶复杂度，最终的算法复杂度为 O(pLength * sLength)。

空间复杂度：O(1)。需要一个大小为 26 的计数数组，循环迭代过程中虽然不断申请新的空间，但是上一次申请的数组空间应该可以得到复用，所以实际上一共花费了2个数组的空间，因为数组大小是确定的，所以空间复杂度为O(1)。

思路二：双指针 + 滑动窗口

思路参考：https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/solution/20200321438median-by-jasion_han-r/

先对目标串p每个字符进行字符计数，统计出每个字符的出现次数。 使用滑动窗口在s串中寻找符合条件的字母异位词，创建一个临时计数数组 tempCounts[ ]，用于记录窗口内每种字符的出现次数。 滑动窗口的左右指针初始均为0， 左指针指向窗口的第一个字符，右指针指向下个待移入窗口的字符。 把右指针不断后移，每移入一个字符，把此次移入的这个字符的计数器加一，因为移入了一个字符，所以右指针需要后移一位。如果此次移入某字符后导致窗口内该字符的出现次数超过了字母异位词的该字符本应该出现的次数，应该把窗口内最左边的超标字符滑出该窗口以维持数量平衡，使得该字符不超标，也就是让窗口的左指针不断右移，把碰到的字符的计数器都减一，直到这个超标的字符被移出去一个。 如果窗口大小刚好是p串的长度，说明窗口内的子串刚好构成 p 的字母异位词，原因是窗口内的每种字符个数都没有超过p,但是总的字符个数却刚好等于p, 说明这两个字符串每种字符出现的次数完全一致。这时把窗口的左指针存入结果集中

 1 class Solution {
 2     public List<Integer> findAnagrams(String s, String p) {
 3 
 4        // 先对目标串p每个字符进行字符计数，统计出每个字符的出现次数
 5        int pLength = p.length();
 6        int sLength = s.length();
 7 
 8        int[] counts = new int[26];
 9        for(int i = 0; i < pLength; i++){
10             counts[p.charAt(i) - 'a']++; 
11        }
12 
13        ArrayList<Integer> res = new ArrayList<>();  // 存储结果的结果集
14        
15         int[] tempCounts = new int[26]; // 记录窗口内每种字符的出现次数
16         int left = 0, right = 0;
17         while(right < sLength){
18             int curR = s.charAt(right++) - 'a';
19             tempCounts[curR]++;        // curR字符的出现次数加一
20             right++;    // 新增一个字符后，窗口右指针右移一位
21             while(tempCounts[curR] > counts[curR]){ // 不断缩小窗口大小，直到把超标字符移出去一个，使得不超标
22                 tempCounts[s.charAt(left) - 'a']--;
23                 left++;     // 移走一个字符后窗口左指针右移一位
24             }
25             if(right - left == pLength){
26                 res.add(left);
27             }
28         }
29         return res;
30     }
31 }

leetcode 执行用时：5 ms > 94.05%, 内存消耗：39.4 MB > 92.35%

复杂度分析：

时间复杂度：O(n)。 窗口的左右指针最多都到达 s  串结尾，s 串每个字符最多被左右指针都经过一次，所以时间复杂度为O(n)。 空间复杂度：O(1)。只需要两个大小为 26 的计数数组，大小均是确定的常量，所以空间复杂度为O(1)。

标签：子串,字符,pLength,int,异位,复杂度,hot,438,100
来源： https://blog.51cto.com/u_14201949/2825905