算法训练营Day7 第三章 哈希表part2

第一题： 454.四数相加II 

        第一次写这道题的时候，没有想到其他思路，就用了暴力解法，相当于三层for循环，再加上while的寻找过程，算法的时间复杂度为O()，导致代码运行时直接报错，超时了！看了题解后，发现巧妙的解法，将时间复杂度能够降到O()。

        该解法思路如下：首先我们将前两个数组中的元素之和以及这个和的出现次数存放到一个unordered_map<int, int> mp中，first表示数组A和数组B中任意两个元素之和（a+b），second表示（a+b）一共出现了多少次。这一过程用了嵌套的for循环，时间复杂度为O()；接下来，我们再去数组C和数组D中进行for循环遍历得到任意两个元素的和（c+d），可以令target = -（c+d），再去mp中寻找是否有target对应的次数存在，找到的话，就cnt += mp[target]。经过这样的处理，我们就得到了cnt的值，返回cnt即可。

        实现代码如下所示：

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> mp;
        int cnt = 0;
        for(int a : nums1) {
            for(int b : nums2) {
                mp[a + b]++;
            }
        }
        for(int c : nums3) {
            for(int d : nums4) {
                int target = 0 - (c + d);
                if(mp.find(target) != mp.end()) {
                    cnt += mp[target];
                }
            }
        }
        return cnt;
    }
};

 第二题： 383. 赎金信  

        这道题比较简单，可以利用数组来解决，因为ransomNote和magazine均由小写英文字母组成

，所以可以用一个vector<int> v来记录magazine中每个字母出现的次数，某个字母出现一次，就令对应的v[c - 'a']++；之后再遍历ransomNote，令ransomNote中出现的每一个元素对应的值-1，即：v[c - 'a']--，如果在这一过程中发现某个数字小于0，则说明不符合条件返回false，遍历完之后都符合条间，那么就返回true。

        代码实现如下所示：

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> v1(26, 0);
        for(char c : magazine) {
            ++v1[c - 'a'];
        }
        for(char c : ransomNote) {
            if(--v1[c - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

第三题： 15. 三数之和 

        这道题一开始我考虑使用哈希表来解题，但是后面操作很复杂，写不出来了，看了题解发现了排序+双指针这个解法非常巧妙，记录一下这种思路：首先，将数组按照从小到大进行排序，之后，利用for循环遍历数组，如果nums[i] > 0，说明此后不会有符合条件的元组了，break跳出循环；还需要对i进行去重，若nums[i] == nums[i-1]，continue；然后while(left < right)，如果此时三者相加小于0，则令right--，三者相加大于0，则left++，否则就是找到了符合题意的元组，接下来还需要进行去重操作，分别对left和right进行移动，判断是否与他们之前对应的值相同，若相同就移动，直到不再相同。以上就是这道题的解题思路，算法的时间复杂度为O()，代码如下所示：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size(); ++i) {
            if(nums[i] > 0)
                return result;
            if(i > 0 && nums[i] == nums[i - 1])
                continue;
            int left = i + 1;
            int right = nums.size() - 1;
            while(left < right) {
                if(nums[i] + nums[left] + nums[right] < 0)
                    left++;
                else if(nums[i] + nums[left] + nums[right] > 0)
                    right--;
                else{
                    //此时找到了符合题意的三元组
                    result.push_back({nums[i], nums[left], nums[right]});
                    left++;
                    right--;
                    while(left < right && nums[left] == nums[left - 1])
                        left++;
                    while(left < right && nums[right] == nums[right + 1])
                        right--;
                }
            }
        }
        return result;
    }
};

第四题： 18. 四数之和  

        这道题可以在第三题的基础上进行处理，也就是多加了一层for循环，该算法的时间复杂度为

O()，需要注意几个细节问题：

        ①. 剪枝处理时，不能因为nums[k] > target就直接break跳出循环，因为可能是负数，负数相加会变小，因此判断的条件应该改为：nums[k] > target && nums[k] >= 0;

        ②. 还需要小心nums[k] + nums[i] + nums[left] + nums[right]的结果超出int，因此要转为long；

代码如下：

       

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        for(int k = 0; k < nums.size(); ++k) {
            if(nums[k] > target && nums[k] >= 0) break;
            if(k > 0 && nums[k] == nums[k - 1]) continue;
            for(int i = k + 1; i < nums.size(); ++i) {
                if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) break;
                if(i > k + 1 && nums[i] == nums[i - 1]) continue;
                int left = i + 1, right = nums.size() - 1;
                while(left < right) {
                    if((long)nums[k] + nums[i] + nums[left] + nums[right] < target)
                        left++;
                    else if((long)nums[k] + nums[i] + nums[left] + nums[right] > target)
                        right--;
                    else{
                        result.push_back({nums[k], nums[i], nums[left], nums[right]});
                        left++;
                        right--;
                        while(left < right && nums[left] == nums[left - 1]) left++;
                        while(left < right && nums[right] == nums[right + 1]) right--;
                    }
                }
            }
        }
        return result;
    }
};

Day7完结撒花！！！