【代码随想录】刷题笔记Day11

前言

今天趁瑞幸新品9.9【冰吸生椰拿铁】，家人们，谁懂啊，直接一个精神气爽，来刷题效率upup！

202. 快乐数

• 跟数学相关的题哪里快乐了......这道题把握一定会循环/变成1，加上哈希表就OK了

• class Solution {
  public:
      int getSum(int n){  // 取各个位相加
          int sum = 0;
          while(n){
              sum += (n % 10) * (n % 10);
              n /= 10; 
          }
          return sum;
      }
      bool isHappy(int n) {  
          unordered_set hash;
          while(n != 1){
              if(hash.find(n) != hash.end()){  // 如果重复，说明进循环了
                  return false;
              }
              hash.insert(n); 
              n = getSum(n);
          }
          return true;  // 最后为1，说明是快乐数
      }
  };

1. 两数之和

• 这道题用unordered_map，存数字和下标的映射，再熟悉熟悉用法

• class Solution {
  public:
      vector twoSum(vector& nums, int target) {
          std::unordered_map  map;
          for(int i = 0; i < nums.size(); i++) {
              // 遍历当前元素，并在map中寻找是否有匹配的key
              auto iter = map.find(target - nums[i]); 
              if(iter != map.end()) {
                  return {iter->second, i};
              }
              // 如果没找到匹配对，就把访问过的元素和下标加入到map中
              map.insert(pair(nums[i], i)); 
              // map[nums[i]] = i;  // 也可以用这一句存下标
          }
          return {};
      }
  };

454. 四数相加 II

• a+b的频次存入map，遍历c+d，如果有相加为0则count+=频次

• class Solution {
  public:
      int fourSumCount(vector& A, vector& B, vector& C, vector& D) {
          unordered_map umap; //key:a+b的数值，value:a+b数值出现的次数
          // 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
          for (int a : A) {
              for (int b : B) {
                  umap[a + b]++;
              }
          }
          int count = 0; // 统计a+b+c+d = 0 出现的次数
          // 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
          for (int c : C) {
              for (int d : D) {
                  if (umap.find(0 - (c + d)) != umap.end()) {
                      count += umap[0 - (c + d)];
                  }
              }
          }
          return count;
      }
  };

15. 三数之和

• 这一题用哈希考虑去重比较麻烦，考虑用双指针法，卡哥真的讲的好详细，i了i了
• 先排序，遍历i，移动left和right看相加是否为相应值，去重要考虑超多细节
• 

• class Solution {
  public:
      vector> threeSum(vector& nums) {
          vector> result;
          sort(nums.begin(), nums.end());
          // 找出a + b + c = 0
          // a = nums[i], b = nums[left], c = nums[right]
          for (int i = 0; i < nums.size(); i++) {
              // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
              if (nums[i] > 0) {
                  return result;
              }
              // 错误去重a方法，将会漏掉-1,-1,2 这种情况
              /*
              if (nums[i] == nums[i + 1]) {
                  continue;
              }
              */
              // 正确去重a方法
              if (i > 0 && nums[i] == nums[i - 1]) {
                  continue;
              }
              int left = i + 1;
              int right = nums.size() - 1;
              while (right > left) {
                  // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                  /*
                  while (right > left && nums[right] == nums[right - 1]) right--;
                  while (right > left && nums[left] == nums[left + 1]) 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{nums[i], nums[left], nums[right]});
                      // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                      while (right > left && nums[right] == nums[right - 1]) right--;
                      while (right > left && nums[left] == nums[left + 1]) left++;
  
                      // 找到答案时，双指针同时收缩
                      right--;
                      left++;
                  }
              }
  
          }
          return result;
      }
  };

18. 四数之和

• 这一题不过是上一题外面多套个循环（i、k、left、right），注意剪枝和去重的细节

• class Solution {
  public:
      vector> fourSum(vector& nums, int target) {
          vector> result;
          sort(nums.begin(), nums.end());
          for (int k = 0; k < nums.size(); k++) {
              // 剪枝处理
              if (nums[k] > target && nums[k] >= 0) {
              	break; // 这里使用break，统一通过最后的return返回
              }
              // 对nums[k]去重
              if (k > 0 && nums[k] == nums[k - 1]) {
                  continue;
              }
              for (int i = k + 1; i < nums.size(); i++) {
                  // 2级剪枝处理
                  if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                      break;
                  }
  
                  // 对nums[i]去重
                  if (i > k + 1 && nums[i] == nums[i - 1]) {
                      continue;
                  }
                  int left = i + 1;
                  int right = nums.size() - 1;
                  while (right > left) {
                      // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                      if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                          right--;
                      // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                      } else if ((long) nums[k] + nums[i] + nums[left] + nums[right]  < target) {
                          left++;
                      } else {
                          result.push_back(vector{nums[k], nums[i], nums[left], nums[right]});
                          // 对nums[left]和nums[right]去重
                          while (right > left && nums[right] == nums[right - 1]) right--;
                          while (right > left && nums[left] == nums[left + 1]) left++;
  
                          // 找到答案时，双指针同时收缩
                          right--;
                          left++;
                      }
                  }
              }
          }
          return result;
      }
  };
  

后言

哎呀毕设论文快要交了，得忙毕设那边了，刷题可能就少搞点哈（