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

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
 

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/4sum-ii

 map记录数组nums1和nums2相加的和（key）以及和出现过的次数（value），遍历访问nums3和nums4，当map中存在key为0-nums3[i]-nums4[j]的差，说明之前出现过map.get(key)次四个数组中元素相加为0的情况，计数器count+map.get(key)。

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
         int count=0;
         HashMap<Integer,Integer> sum1=new HashMap<>();
         for(int i=0;i<nums1.length;i++) {
        	 for(int j=0;j<nums2.length;j++) {
        		 int sum=nums1[i]+nums2[j];
        		 if(sum1.containsKey(sum)) sum1.put(sum, sum1.get(sum)+1);
        		 else sum1.put(sum, 1);
        	 }
         }
         for(int i=0;i<nums3.length;i++) {
        	 for(int j=0;j<nums4.length;j++) {
        		 int sum=0-nums3[i]-nums4[j];
        		 if(sum1.containsKey(sum)) {
        			 count+=sum1.get(sum);
        		 }
        	 }
         }
         return count;
    }

383. 赎金信

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/ransom-note

 遍历magazine字符串，使用数组记录magazine里面的字母构成（recode[ch-'a']++），遍历ransomNote，如果当前字母对应数组下标的值<1，说明magazine字符串不存在该字母，直接返回false，否则更新数组（recode[ch-'a']--），最后返回true。

 public boolean canConstruct(String ransomNote, String magazine) {
          int[] record=new int[26];
         for(char ch:magazine.toCharArray()) {
        	 record[ch-'a']++;
         }
         for(char ch:ransomNote.toCharArray()) {
        	 if(record[ch-'a']<1) return false;
        	 record[ch-'a']--;
         }
    	 return true;
    }

15. 三数之和

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

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

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/3sum

 先对数组进行排序，遍历数组，指针l指向当前遍历的下标+1，指针r指向数组的最后最后一个元素的下标，当l<r，做以下操作：当nums[i]+nums[l]+num[r]==0，收取结果，l++,r--；当nums[i]+nums[l]+num[r]>0，r--，nums[i]+nums[l]+num[r]<0，l++。

题目中答案中不可以包含重复的三元组，需要对i,l和r进行去重，当遍历数组时，如果nums[i]==nums[i-1]，说明当前的元素之前出现过，直接跳过continue，；当nums[i]+nums[l]+num[r]==0时，l和r缩进取不等于当前l和r的元素作为新的l和r。

public static List<List<Integer>> threeSum(int[] nums) {
         Arrays.sort(nums);
         List<List<Integer>> res=new ArrayList<>();
         for(int i=0;i<nums.length;i++) {
        	 //数组有重复的元素，跳过该元素 1,1,2,3
        	 if(nums[i]>0) return res;//3个正整数的和不可能等于0
        	 if(i>0&&nums[i]==nums[i-1]) continue;
        	 int l=i+1,r=nums.length-1;
        	 while(l<r) {
        		 int sum=nums[i]+nums[l]+nums[r];
        		 if(sum==0) {
        			 List<Integer>tres=new ArrayList<>();
        			 Collections.addAll(tres, nums[i],nums[l],nums[r]);
        			 res.add(tres);
        			 //l,r去重 -3,1,1,2,2
        			 while(l<r&&nums[r-1]==nums[r]) {
        				 r--;
        			 }
        			 while(l<r&&nums[l+1]==nums[l]) {
        				 l++;
        			 }
        			 r--;l++;
        		 }else if(sum>0) r--;
        		 else l++;
        	 }
         }
         return res;
    }

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
你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/4sum

 与上一题思路相同，多加一层for循环，固定i和j，双指针l和r移动，题目给出的目标值有可能是负数，因此在判断当前访问元素是否已经大于目标值时，要加上target>=0这个条件，如果target<0，两个负数相加和会变少。判断四个数字相加是否等于目标值时，四个10的九次方相加会溢出，需要转化为long类型。

public List<List<Integer>> fourSum(int[] nums, int target) {
    	  Arrays.sort(nums);
    	  List<List<Integer>> res=new ArrayList<>();
          for(int i=0;i<nums.length;i++) {
        	  //a去重
        	  if(i>0&&nums[i]==nums[i-1]) continue;
        	  //一级剪枝,当目标值为整数而且当前数字大于目标值，跳出循环
              //(目标值为负数，两个负数相加越来越少，可能-3,-1,0,0 目标-4）
        	  if(nums[i]>target&&target>=0) break;
        	  for(int j=i+1;j<nums.length-1;j++) {
        		  //b去重
        		  if(j>i+1&&nums[j]==nums[j-1]) continue;
        		  //二级剪枝
        		  if(nums[i]+nums[j]>target&&target>=0) {
        			  //退出当前i,重新赋值i
        			  break;
        		  }
        		  int l=j+1,r=nums.length-1;
        		  while(l<r) {
        			  //防溢出
        			  long sum=(long)nums[i]+nums[j]+nums[l]+nums[r];
        			  System.out.println(sum);
        			  if(sum>target) r--;
        			  else if(sum<target) l++;
        			  else {
        				  List<Integer> tres=new ArrayList<>();
        				  Collections.addAll(tres,nums[i],nums[j],nums[l],nums[r]);
        				  res.add(tres);
        				  //l,r去重
        				  while(l<r&&nums[l]==nums[l+1]) l++;
        				  while(l<r&&nums[r]==nums[r-1]) r--;
        				  l++;r--;
        			  }
        		  }
        	  }
          }
          return res;
    }