Leetcode560. Subarray Sum Equals K

链接

link

思路

暴力解法，起点是每个数，终点是最后一个数。中途遇到符合结果的，结果+=1。这样做并不难。
还有更高效的方法，就是hashmap。记录和的累加值。这样的话，就有两种情况是符合条件的。
1.hashmap[sum] = target
2.hashmap[sum - target]存在 (sum - (sum - target) ) = target
所以，可以利用hashmap记录和的累加值来避免重复计算

hashmap

hashmap是个啥？

综合了数组和链表优势的数据结构，既能有数组的快速查找优势，又有链表的方便添加优势。

嗯，还是没搞懂。而且我并没有觉得题解中用到了hashmap。用到了链表吗？我只看到了字典。（笑哭

javascript

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var subarraySum = function(nums, k) {
    const hashmap = {};
    let sum = 0;
    let count = 0;
    for(let i = 0; i < nums.length; i++){
        sum += nums[i];
        //修改hashmap字典
        if(sum === k){
            count++;
        }
        //下面这一步必须放在这里
        if(hashmap[sum - k] !== void 0){
            count += hashmap[sum - k];
        }
        if(hashmap[sum] === void 0){
            hashmap[sum] = 1;
        }
        else{
            hashmap[sum] += 1;
        }
        
    }
    return count;
};

这里又犯了错误了QAQ。就是这几步是有顺序的，否则会出现数组长度为0，然后和为0的情况。所以判断hashmap[sum - target]是否存在必须放在前面。

cpp

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