代码随想录算法训练营第六天 454. 四数相加 II 383. 赎金信 15. 三数之和 18. 四数之和

454. 四数相加 II - 力扣（LeetCode）

看到题目的第一想法：用一个for循环对第一个整数数组进行遍历同时存入哈希表，嵌套for循环，都进行一个判断是否等于-numsX[i]的过程同时分别存入哈希表，如果成立就跳出这一次循环并count++

看完代码随想录之后的想法：没有想到对半分

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> umap;//key:a+b;value:a+b出现的次数
        for(int a : nums1){
            for(int b : nums2){
                umap[a+b] ++ ;
            }
        }
        int count = 0;//用于统计a+b+c+d=0出现的次数
        //遍历nums3和nums4数组，如果0-（c+d）在map中出现过的话就把map中key对应的value也就是出现次数统计出来
        for(int c : nums3){
            for(int d : nums4){
                if(umap.find(0-(c+d)) != umap.end()){
                    count += umap[0-(c+d)];
                }
            }
        }
        return count;
    }
};

注意：时间复杂度为n方，空间复杂度也为n方

383. 赎金信 - 力扣（LeetCode）

看到题目的第一想法：判断第一个字符串能否由第二个字符串里的字符构成就是要判断是否第二个字符串中含有所有的第一个字符串中的字母，且要考虑重复问题，因为每个字符只能使用一次。在这里因为只有二十六个字母所以选择数组作为容器就可以，考虑重复就是在储存的时候用++，接着在判断时用--；最后判断数组里是否含有小于零的值，如果有就返回false

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

注意：数组声明不要=0；首先判断长度，长度比第一个字符串小则必定不行；注意<=会索引越界；空间复杂度为1，因为用的是常量大小的辅助数组

15. 三数之和 - 力扣（LeetCode）

看到题目的第一想法：第二个条件用map实现，判断三个角标不相等的话在循环遍历的起始上改一下

看完代码随想录之后的想法：没有注意到题目的一个条件——输出三元组的顺序不重要，因为这个条件就可以对数组进行排序；我想的也有双指针是双指针加哈希但是对于单独的第三数不好进行判断。

双指针方法：

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;//跳过当前循环剩余的部分立即开始下一次的循环
            }//如果现在这个元素跟前一个已遍历的元素相等就跳过这个元素，用于去重；i>0是一个边界条件，保证i=0时不做这个判断，确保i-1在数组的有效索引范围内
            int left = i + 1;
            int right = nums.size() - 1;
            while(right >left){
                if (nums[i] + nums[left] +nums[right] > 0) right--;
                else if (nums[i] + nums[left] +nums[right] < 0) left++;
                else{
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});//push_back(..)，将这个临时的vector对象添加到result容器的末尾，即将找到的三元组添加到结果容器中
                    while(right > left && nums[right] == nums[right - 1]) right--;//去重
                    while (right > left && nums[left] == nums[left + 1]) left++;//去重
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

注意：continue,pushi_back方法；三个去重的操作

哈希方法

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[j], c = -(a + b)
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
                continue;
            }
            unordered_set<int> set;
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2
                        && nums[j] == nums[j-1]
                        && nums[j-1] == nums[j-2]) { // 三元组元素b去重
                    continue;
                }
                int c = 0 - (nums[i] + nums[j]);
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c});
                    set.erase(c);// 三元组元素c去重
                } else {
                    set.insert(nums[j]);
                }
            }
        }
        return result;
    }
};

18. 四数之和 - 力扣（LeetCode）

看到题目的第一想法：不重复，说明需要去重，想要用三数之和时用到的双指针类似思想的话需要四个指针，缩紧方向不好确定；因此想要用哈希，首先时用sort排序目的时方便去重，对半分，将a b存入哈希，用i=0 j=i+1作为初始化，去重操作如上题，然后后面的c d用双指针分别指向两端进行缩紧和判断操作

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;//对nums[k]去重
            }
            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;
                int right = nums.size() - 1;
                while(right > left){
                    if ((long)nums[k] + nums[i] + nums[left] +nums[right] > target){
                        right--;
                }
                    else if((long)nums[k] + nums[i] + nums[left] + nums[right] < target){
                    left++;
                }
                    else{
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;//对left和right去重
                        right--;
                        left++;
                    }
            
                }
            }

        }
        return result;
    }
};

注意：要写(long)，因为-10^9 <= nums[i] <= 10^9,int型是32位的取值是-2 147 483 648-2 147 483 647最大可达到10^9，多个相加可能会出现溢出，long型是64位的；每个下标所指向的元素都要进行去重操作