代码随想录Day7：哈希

哈希

454 四数相加II

454 四数相加II

题目描述

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

代码

nums1 + nums2 一组，nums3 + nums4一组，往“二元”靠。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> umap;
        for(int i = 0; i < nums1.size(); i++)
        {
            for(int j = 0; j < nums2.size(); j++)
            {
                int sum_ab = nums1[i] + nums2[j];
                auto iter = umap.find(sum_ab);
                if(iter != umap.end())
                {
                    iter->second++;
                }
                else
                {
                    umap.insert(pair<int,int>(sum_ab,1));
                }
            }
        }
        int count = 0;
        for(int i = 0; i < nums3.size(); i++)
        {
            for(int j = 0; j < nums4.size(); j++)
            {
                int sum_cd = nums3[i] + nums4[j];
                auto iter = umap.find(0 - sum_cd);
                if(iter != umap.end())
                {
                    count += iter->second;
                }
            }
        }
        return count;
    }
};

复杂度

时间复杂度：O(n^2)

空间复杂度：O(n^2)

赎金信

383 赎金信

题目描述

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

代码

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        if(ransomNote.size() > magazine.size())
        {
            return false;
        }
        int record[26] = {0};
        for(int i = 0; i < magazine.size(); i++)
        {
            record[magazine[i] - 'a']++;
        }
        for(int j = 0; j < ransomNote.size(); j++)
        {
            record[ransomNote[j] - 'a']--;
            if(record[ransomNote[j] - 'a'] < 0)
            {
                return false;
            }
        }
        return true;
    }
};

复杂度

时间复杂度：O(m+n)，其中 m 是字符串 ransomNote 的长度，n 是字符串 magazine 的长度，我们只需要遍历两个字符一次即可。

空间复杂度：O(∣S∣)，S 是字符集，这道题中 SSS 为全部小写英语字母，因此 ∣S∣=26。

15 三数之和

15 三数之和

题目描述

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

代码

i 遍历数组，作为外层元素，l 和 r 用于得到另外两个元素的和。题目要求不包含重复三元组，注意去重。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        sort(nums.begin(),nums.end());
        for(int i = 0; i < nums.size(); i++)
        {
            if(i > 0 && nums[i] == nums[i-1])
            {
                continue;
            }
            int l = i + 1;
            int r = nums.size() - 1;
            int target = 0 - nums[i];
            while(l < r)
            {
                if(nums[l] + nums[r] == target)
                {
                    res.push_back({nums[i],nums[l],nums[r]});
                    //去重
                    while(l < r && nums[l] == nums[l+1]) l++;
                    while(l < r && nums[r] ==nums[r-1]) r--;
                    l++;
                    r--;
                }
                else if(nums[l] + nums[r] < target)
                {
                    l++;
                }
                else
                {
                    r--;
                }
            }
        }
        return res;
    }
};

复杂度

时间复杂度:O(N^2)，其中 N 是数组nums 的长度。

空间复杂度：O(log⁡N)。我们忽略存储答案的空间，额外的排序的空间复杂度为 O(log⁡N)。然而我们修改了输入的数组 nums，在实际情况下不一定允许，因此也可以看成使用了一个额外的数组存储了 nums 的副本并进行排序，空间复杂度为 O(N)。

18 四数之和

18 四数之和

题目描述

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target

代码

i 遍历数组，作为最外层元素， 其后与 “ 三数之和 ” 思路相同。j 遍历次外层元素，l 和 r 用于得到另外两个元素的和。题目要求不包含重复四元组，注意去重。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++)
        {
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            for (int j = i + 1; j < nums.size(); j++)
            {
                if (j > i + 1 && nums[j] == nums[j - 1]) continue;
                int l = j + 1;
                int r = nums.size() - 1;
                //若sum类型为int，测试用例会溢出，修改如下
                long sum = (long)target - nums[i] - nums[j];
                while (l < r)
                {
                    if (nums[l] + nums[r] == sum)
                    {
                        res.push_back({nums[i],nums[j],nums[l],nums[r]});
                        while (l < r && nums[l] == nums[l + 1]) l++;
                        while (l < r && nums[r] == nums[r - 1]) r--;
                        l++,r--;
                    } else if (nums[l] + nums[r] < sum)
                    {
                        l++;
                    }
                    else{
                        r--;
                    }
                }
            }
        }
        return res;
    }
};

复杂度

时间复杂度：O(n^3)，其中 n 是数组的长度。
空间复杂度：O(log⁡n)。