LeetCode HOT 100 --- 2021/8/12

寻找重复数

分析：
  要求不能改变原数组且额外空间为常量级，难度较大，参考官方题解。
代码：

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int slow = 0, fast = 0;
        do {
            slow = nums[slow];
            fast = nums[nums[fast]];
        } while (slow != fast);
        slow = 0;
        while (slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
        }
        return slow;
    }
};

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

方法一：
  暴力求解：枚举出所有子串，然后排序判断是不是满足要求，最后超时。
代码：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int n = s.size(), m = p.size();
        sort(p.begin(), p.end());
        vector<int> res;
        for(int i = 0; i <= n - m; i++) {
            string sub = s.substr(i, m);
            sort(sub.begin(), sub.end());
            if(sub == p) {
                res.push_back(i);
            }
        }
        return res;
    }
};

方法二：
  根据定义，两个字符串互为异位词说明两个字符串中各个字母出现的次数是相同的。据此我们可以利用滑动窗口的思想，每滑动一个位置，窗口左边离开的字母出现次数-1，右边进入窗口的字母次数+1，每滑动一次就判断当前窗口内各个字母出现的次数是否等于p，等于计数器就+1。
代码：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int n = s.size(), m = p.size();
        vector<int> res, s1(26, 0), s2(26, 0);
        if(m > n) {
            return res;
        }
        for(int i = 0; i < m; i++) {
            s1[s[i] - 'a']++;
            s2[p[i] - 'a']++;
        }
        if(s1 == s2) {
            res.push_back(0);
        }
        for(int i = m; i < n; i++) {
            s1[s[i] - 'a']++;
            s1[s[i - m] - 'a']--;
            if(s1 == s2) {
                res.push_back(i - m + 1);
            }
        }
        return res;
    }
};

和为K的子数组

方法一：
  根据定义，我们可以枚举满足条件的区间：以区间的右边界为例，我们枚举右边界，然后从当前边界向前累加，如果累加后和为k计数器就加1，由于数组中存在负数，所以窗口的左边界必须枚举到0。
代码：

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int ans = 0, n = nums.size();
        for(int i = 0; i < n; i++) {
            int sum = 0;
            for(int j = i; j >= 0; j--) {
                sum += nums[j];
                if(sum == k) {
                    ans++;
                }
            }
        }
        return ans;
    }
};

方法二：
  方法一超时，需要对左边界枚举进行优化。考虑使用前缀和，设当前右边界为i，枚举的左边界为j，如果pre[i]-pre[j] = k，说明(j, i]区间内的数和为k，所以我们需要枚举j然后统计次数。不过此思想与方法一一样，并没有得到优化，所以我们可以利用哈希表事先存储好前序和为pre[i]-k的次数，然后直接相加。
代码：

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        int ans = 0, n = nums.size();
        int pre = 0;  //前缀和
        mp[0] = 1;
        for(int i = 0; i < n; i++) {
            pre += nums[i];
            if(mp.find(pre - k) != mp.end()) {
                ans += mp[pre - k];
            }
            mp[pre]++;  //记录前缀和出现了几次
        }
        return ans;
    }
};