算法训练day6| 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

• 四数相加

  class Solution {
  public:
      int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
          unordered_map<int,int> umap;
          for(int a : nums1){
              for(int b : nums2){
                  umap[a + b]++;  //注意，这里的键每次在a循环一次的时候，就更新一下a+b，相应的值就增加一,注意，这个值为 a+b唯一的值出现的次数，而不是让值加一，比如a+b的组合为3，而3出现了几次，这个值就为几，这个值并不是每次都加一
              }
          }
          int count = 0;
          for(int c : nums3){
              for(int d : nums4){
                  if(umap.find(0 - (c + d)) != umap.end()){.  //注意umap的经典用法
                      count += umap[ 0 - (c + d)];
                  }
              }
          }
          return count;
      }
  };

• 三数之和

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){   //注意：这里是nums[i],而不是nums[0]!!!!
            return result;   //这种情况下返回的结果就是[];
        }
        if((i > 0) && nums[i] == nums[i - 1]) //去重的目的是因为题目要求不可包含重复的三元组，因为三元组由a、b、c三个元素构成，而我们现在遍历的i就代表着a，如果a第一遍是-2，第二遍还是-2，那么就有可能构成[-2 0 2] [-2 0 2]这两组同样的三元组，形成重复，因此要避免第一个元素的重复，只允许它出现一次，后面对于b c会和这唯一的一个a进行不同的排列组合，构成三者之和等于0，比如：[-2 0 2][-2 1 1][-2 -1 3] 
        {
            continue;   //这个continue就是直接跳过该循环当前的代码，直接进入下一个循环。
        }
         int left = i + 1;
         int right = nums.size() - 1;
         while(left < right){
            if(nums[i] + nums[left] + nums[right] > 0){
                right--;    //需要对除了i以外的其他元素去重，但不是现在，如果是现在可能导致，right<=left，等到凑齐了三元组再去重来的及
            }
            else if(nums[i] + nums[left] + nums[right] < 0){
                left++;
            }
            else{
                result.push_back(vector<int>{nums[i],nums[left],nums[right]});  //vector是push_back操作
                while((right > left) && (nums[right] == nums[right - 1])) {
                    right--;
                }
                //一定要清楚这里为什么是right + 1因为right是从右往左收缩的，如果是加一，意味着此时right + 1这一位已经遍历完了，现在来到了right，这样的话，比如a是-2，b是1，c是1，那么此时如果是[right - 1]的判断逻辑，那么就会跳过[-2，1，1]这种可能，如果是[right + 1]这种选项，那么会先把right+1走完，此时就可以是遍历了-2，1，1这种情况后，再去重. !!!!!!错错错错错错错错错错错错错错错错！！！！！！！！！我最开始写的nums[right] == nums[right + 1],完全错误
                //实际上此时的去重，是在写入到result后，对right的一个操作，此时已经在i的时候就把-2 1 1这种情况考虑进去了，我们现在要做的就是在存入result后，进行下一步的判断，确保right没有重复的元素即可。
                while((right > left) && (nums[left] == nums[left + 1])) {
                    left++;
                }
                left++;
                right--;
            }
         }
        }
       return result;
    }
};

• 四数之和

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]){   //注意这里有一个k>0的条件,如果k=0,则没有k-1,去重操作
                    continue;
                }
                for(int i = k + 1; i < nums.size() ; i++ ){
                    if(nums[i] + nums[k] > target && (nums[i] + nums[k] >= 0)){ //这里为什么有=0呢，是因为，如果nums[i]+nums[k]=0,此时他们两个的和还比target大，那么说明target是负数，后面两个数肯定要比0要么大，要么相等，所以和肯定是要比target大的
                        break;
                    }
                    if(i > k + 1 && nums[i] == nums[i - 1]){ //别忘了还有i>k+1的判断，因为i如果是k+1，并没有k这一项
                        continue;
                    }
                    int left = i + 1;
                    int right = nums.size() - 1;
                    while(left < right){
                        if((long)nums[k] + nums[i] + nums[left] + nums[right] > target){ //加long防止溢出
                            right--;
                        }
                        else if((long)nums[k] + nums[i] + nums[left] + nums[right] < target){
                            left++;
                        }
                        else{
                            result.push_back(vector<int>{nums[i],nums[k],nums[left],nums[right]});
                            while(left < right && nums[right] == nums[right - 1]){ //这里不要忘了判断left < right
                                right--;
                            }
                            while(left < right && nums[left] == nums[left + 1]){
                                left++;
                            }
                            left++;
                            right--;
                        }
                    }
                }
            }
            return result;
        }
};