Leetcode做题记录（第一天）----560

560 和为K的子数组

标签：数组，哈希表，前缀和
题目：

题目要求返回数组中和为k的连续子数组的个数，
首先我们可以想想暴力做法：
挨个作为起点，然后往后推，一直到结尾，和为k则记录一次：

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

这样很暴力，用时也很多。

那么该怎么优化呢？
可以想想，我们有两层循环，第一层循环是挨个取值，第二层是取了值后开始遍历。
优化的话就可以往一层循环优化，怎么让这个代码只有一层循环。
这里就不得不提到前缀和了。
什么是前缀和？前缀和，可以这样举例，有一个数组nums[100]，前缀和3，则是下标0到3的和。
nums数组的前缀和n，则是前n个数的和。
令前缀和为pre，那么pre[0]=nums[0]，pre[i]=pre[i-1]+nums[i]
这样就可以初始化一个数组的前缀和。有了前缀和后，这道题改怎么做呢？
画个图：

我们要求这一圈的值：

改怎么求？
很简单：用蓝色大圈的值减去橘色小圈的值就可以得出。

换到前缀和里：

那么这一题怎么搞呢？
可以转化成这样：子数组就是pre[j] - pre[j-i]，目标和是k，只要pre[j]-pre[j-i]==k就能成立
这样后代码成了这样：

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

但是没太大改变，顶多就是看起来像样子了，但其核心还是暴力，那么还能不能继续优化，让它只有一层遍历呢？再想想，再想想。
pre[j]-pre[j-i]==k， 这里面遍历器有i，j。所以有两层遍历，那么能不能优化成只有一次遍历呢？
pre[j-i] == pre[j] - k。变成这样，那么就只用遍历j，pre[j]-k要等于某个值的时候，就代表着有这个数组。
我们要记住，pre[j-i]也是前缀和。我们要记录pre出现的次数诶。
那么此时就要用到哈希了。
哈希，结构是键值对，Map<object,object>很像python的字典。
我们从0开始遍历前缀和数组，用哈希表来记录每个前缀和出现的次数，而当pre[j]-k恰好等于pre[j-i]的时候，就用结果计数器加这个pre[j-i]出现的次数。
有同学会问了，这样不就会出现重复吗？其实不是的，看起来可能会有重复，但实际上一点都不重复：
若pre[5]-k和pre[4]-k都等于22，而22出现了3次，这个22可能对应了p[0],p[1],p[3]，这样和p[5]来运算，就是3种不同的子数组；对p[4]而言，又是3种不同的子数组。
就可以这样优化：

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int sum = 0;
        int n = nums.size();
        vector<int>pre(n,0);
        pre[0]=nums[0];
        for(int i=1;i<n;i++){
            pre[i] = pre[i-1]+nums[i];
        }
        map<int,int>mp;
        mp[0]=1;//k等于pre[i]
        for(int i=0;i<n;i++){
            if(mp[pre[i]-k]!=0){
                sum+=mp[pre[i]-k];
            }
            mp[pre[i]]++;
            //为什么要在判断了以后再记录pre[i]呢?
            //考虑到nums = [1]，k=0的情况。
        }
        return sum;
    }
};