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

15.三数之和

思路：

• 对数组进行排序，从小到大。
• 定义两个指针，left，right。left指针指在当前元素的下一个数字，right指针指在数组的最后一个数字（也就是最大的数）。红色表示当前元素。

-把nums[left]和nums[right]的和看作一个整体b，当前的元素看作a。a+b>0,红色指针往左移动，让b减小。如果a+b<0那么不存在这个b使得a+b=0，就pass现在的数字，移动到下一个数字，移动完再移动蓝色指针，让它再次指向新元素的下一个元素。

• 思考：为什么要跳过和前一个数字重复的数字呢？
• 我们需要确保第一个前一个数字已经覆盖了所有可能的情况，所以才会跳过第二个数字。
• 写一个不太严谨的数学证明。。。
• 因为数组是按顺序排列的，而我们要找的另外两个数字是处于当前数字右边（就是比当前数字更大）
• 那么如果当前数字a，右边已经有满足a+b=0的b了，那么如果下一个数字a’，a=a’，a’的右边，假设a’+b’=0。
• 如图，红色椭圆框内就是可能的b’值，而绿框内就i是可能的b值，b很明显是包括了b’的。所以可以直接跳过a’，不需要再计算b’了，因为b’已经包括在b中，而b，我们计算a的时候已经算过了。
  

• a=-4,b=1，此时a+b<0，需要增大，蓝色指针往左移动，移动到如图下位置的时候都无法满足a+b==0,这个元素就pass了。

此时a=-1，b=1，a+b=0。记录下这三个元素的值

记录完后，left和right一起移动。此时a+b也等于0，记录。

本来应该到图中标红的元素了，也就是-1，和前一个-1相同，也就是说，还会有b=1的情况，使得a+b=0，这个已经存在我们的result里的，就不再重复记录，所以跳过这个-1。


后面就不符合条件了，不再演示。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //对nums排序
        Arrays.sort(nums);//-4,-1,-1,0,1,2,
        //存储a+b+c的结果
        List<List<Integer>> result=new ArrayList<>();
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0){
                return result;
            }
             if(i>0&&nums[i-1]==nums[i]){
                    continue;
                }
            int left=i+1;
            int right=nums.length-1;
            while(left<right) {
               
                if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                } else if (nums[i] + nums[left] + nums[right] < 0) {
                    left++;
                } else {
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }
                    left++;
                    right--;
                }
            }

        }
        return result;
    }
}

18.四数之和

思路：双指针法，类似三数之和。

多嵌套一层for循环，固定两个数，a和b，接着用双指针寻找剩下的两个数字。
用long类型防止移除问题

import java.util.*;

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<>();
        long targetLong = (long) target; // 使用long来避免溢出问题

        for (int i = 0; i < nums.length - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue; // 避免重复
            }
            for (int j = i + 1; j < nums.length - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue; // 避免重复
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (left < right) {
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right]; // 使用long进行求和
                    if (sum < targetLong) {
                        left++;
                    } else if (sum > targetLong) {
                        right--;
                    } else {
                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while (left < right && nums[left] == nums[left + 1]) left++; // 避免重复
                        while (left < right && nums[right] == nums[right - 1]) right--; // 避免重复
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}

454.四数之和2

和18题的区别是，这是四个数组，而非数组内部。
四数之和可以看成-两数之和的变形，我们可以把数组两两结合变成一个，就是数学上很常见的整体法思维。
首先，假设nums1的数为a,nums2的为b，nums3为c，nums4为d。
map1存a+b，还有出现的次数。map2存c+d和出现的次数。此时的map1和map2可以看作两个整体了。接下来的逻辑处理就是两数之和的逻辑。
还有一点，我们看下图，我在idea里debug后，map1和map2中的key-value是这样的，map1中的0，我们要去map2也寻找0，这两个0的出现次数分别是2，我一开始是把次数相加，但是这种测试案例就过不了，后来想了一下，应该这样理解，map1中的0可以和map2中的两个0组合，同理，map2的也是一样。不能用加法，要用乘法。

class Solution {
         public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map1=new HashMap<>();
        Map<Integer,Integer> map2=new HashMap<>();
        int count=0;
        for(int a:nums1){
            for(int b:nums2){
                map1.put(a+b, map1.getOrDefault(a+b,0)+1);
            }
        }
        for(int c:nums3){
            for(int d:nums4){
                map2.put(c+d, map2.getOrDefault(c+d,0)+1);
            }
        }
        //遍历map
        for (Map.Entry < Integer, Integer > entry: map1.entrySet()) {
            int num=entry.getKey();
            int need=0-num;
            if(map2.containsKey(need)){
                //取出num和need在两个数组的出现次数，取最小值。
                int times=entry.getValue()*map2.get(need);
                count=count+times;
            }
        }
        return count;
    }
}

383.赎金信

● 也是把两个字符串各自存在map里，value是字符出现次数
● 遍历map1（一定要遍历这个），组成一个字符串，只要保证每个字符都可以总map2中取到，且字符的量足够就行。比如ransomNodte是"abc"，那么map2里a,b,c三个字符至少各有1个。
● 重点！如果map1里"a"出现的次数小于map2"a"出现的次数就ok，说明map2中有足够的字母"a"可以提供给map1

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        char[] ran=ransomNote.toCharArray();
        char[] ma=magazine.toCharArray();
        Map<Character,Integer> map1=new HashMap<>();
        for(char a:ran){
            map1.put(a, map1.getOrDefault(a, 0)+1);
        }

        Map<Character,Integer> map2=new HashMap<>();
        for(char b:ma){
            map2.put(b, map2.getOrDefault(b, 0)+1);
        }
        for (Map.Entry <Character,Integer > entry:map1.entrySet()) {
            Character letter=entry.getKey();
            if(!map2.containsKey(letter)){
                return false;
            }else{
                int times1=entry.getValue();
                int times2=map2.get(letter);
                if(times1>times2){
                    return false;
                }
            }
        }
        return true;
    }
}