剑指 Offer II 010. 和为 k 的子数组 Offer II 011 0和1相同的子数组（前缀和+哈希表）

【010】
给定一个整数数组和一个整数 k ，请找到该数组中和为 k 的连续子数组的个数。()

示例 1：

输入:nums = [1,1,1], k = 2
输出: 2
解释: 此题 [1,1] 与 [1,1] 为两种不同的情况

示例 2：

输入:nums = [1,2,3], k = 3
输出: 2

思路一：双循环：

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

时间复杂度O(N2)会超时

思路二：针对循环i (左边的标)进行优化
采用前缀和+哈希

设pre[j] 为 0~j 数组区间的总和
则计算[i:j]区间的总和则为pre[j] - pre[i-1]
因此题目的要求可以转换为下面的公式
pre[j]-pre[i-1] = k
我们可以先用hash表先记录左边的标前面的数组之和pre[i-1]，作为键 ；出现的数组次数之和记作值
然后 寻找hash表中的pre[i-1]，使得pre[i-1]=pre[j]-k
因此 寻找的伪代码可以表示为 find_hash(pre[j]-k)

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        mp[0] = 1;
        int res = 0; int pre = 0;
        for(int j = 0;j < nums.size();j++)
        {
            pre += nums[j];

            if(mp.find(pre - k)!=mp.end())
            {
                res += mp[pre - k];
            }

            //记录hash值
            mp[pre]++;
        }
        return res;
    }
};

【011】
给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。
示例 1：

输入: nums = [0,1]
输出: 2
说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。

示例 2：

输入: nums = [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量 0 和 1 的最长连续子数组。

一样的思路

设pre[j] 为 0~j 数组区间的总和
则计算[i:j]区间的总和则为pre[j] - pre[i-1]
由于只有0和1，因此，可以将0作为-1计算
因此题目的要求可以转换为下面的公式
pre[j]-pre[i-1] = 0
我们可以先用hash表先记录左边的标前面的数组之和pre[i-1]，作为键 ；出现的最早的index作为指
然后 寻找hash表中的pre[i-1]，使得pre[i-1]=pre[j]-0
也就是pre[i-1]=pre[j]

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        int maxlong = 0;
        int pre = 0;
        unordered_map<int,int> hashmap;
        hashmap[0] = 0;
        int index = 0;
        for(auto num : nums)
        {
            pre += (num == 1) ? 1 : -1;
            if(hashmap.find(pre)!=hashmap.end())
            {
                int res =  index - hashmap[pre] +1;
                if(res > maxlong)
                    maxlong = res;
            }
            else
                hashmap[pre] = index+1;
            index++;
        }
        return maxlong;
    }
};