day7-454.四数相加II |383. 赎金信|15. 三数之和|18. 四数之和

454.四数相加II

题目链接：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

🤔解题思路

将四个数组，两两分组计算和，再从两个和中计算符合条件的数量

易错点：value存放的是数组和对应的数量，第二个循环匹配到时，要加上对应的value值，不能单纯的加一

💻分组+哈希表Map

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap();
        int count = 0;
        //遍历数组，将nums1和nums2的和存放到集合的key中，value存放和相等情况的数量
        for(int i : nums1){
            for(int j : nums2){
                map.put(i + j,map.getOrDefault(i + j,0) + 1);
            }
        }

        //循环遍历数组nums3和nums4得到对应元素的和，判断集合中是否存在与该值对应的目标值
        for(int i : nums3){
            for(int j : nums4){
                //若是存在，则加上该值的数量
                if(map.containsKey(0 - i - j)){
                    count += map.get(0 - i - j);
                }
            }
        }
        return count;
    }
}

383. 赎金信

题目链接：383. 赎金信

题目要求：

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

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

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

🤔解题思路

所需空间固定，并且不大，就可以考虑使用数组；也可以使用map集合，但是由于map集合底层映射关系，执行的时间会慢很多      

💻I.哈希法-数组

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(magazine.length() < ransomNote.length()){
            return false;
        }
        int[] hash = new int[26];
        char[] s = ransomNote.toCharArray();
        //统计ransomNote中每个字符数量
        for(int i : s){
            hash[i - 'a']++;
        }
        char[] m = magazine.toCharArray();
        //扣除magazine中对应字符的数量
        for(int i : m){
            hash[i - 'a']--;
        }
        //如果集合中有大于0的字符，说明在ransomNote存在不能由magazine构成的字符
        for(int i : hash){
            if(i > 0){
                return false;
            }
        }
        return true;
    }
}

15. 三数之和

题目链接：15. 三数之和

题目要求：

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

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

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

🤔解题思路

循环遍历得到第一个元素，再使用双指针滑动窗口来确定另外两个元素，滑动窗口不明白的可以看看 day2 中209.长度最小的子数组的滑动窗口解法

💻排序+双指针

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //对数组排序
        Arrays.sort(nums);
        //创建集合，用于存放结果集合
        List<List<Integer>> res = new ArrayList();
        //第一层循环，用于获取元组中第一个元素
        for(int i = 0;i < nums.length;i++){
            //由于数组已经排序，如果第一个元素已经大于0，加上后面的任何数都会大于0
            if(nums[i] > 0) return res;
            //对元组中第一个元素去重
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            //左右指针，使用滑动窗口来确定另外两个元素的值
            int left = i + 1;
            int rigth = nums.length - 1;
            while(left < rigth){
                int sum = nums[i] + nums[left] + nums[rigth];
                if(sum > 0){
                    rigth--;
                    
                }else if(sum < 0){
                    left++;
                    
                }else{
                    //目标元组，创建集合，将结果存放到结果集合中
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[rigth]);
                    res.add(list);
                    //对第二个和第三个元素进行去重
                    while(rigth > left && nums[rigth] == nums[rigth - 1]){
                        rigth--;
                    }
                    while(rigth > left && nums[left] == nums[left + 1]){
                        left++;
                    }
                    left++;
                    rigth--;
                }         
            }
        }
        return res;
    }
}

18. 四数之和

题目链接：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

你可以按 任意顺序 返回答案 。

🤔解题思路

和三数之和的解题思路差不多，先对数组进行排序，再使用双层for循环确定前两个元素，再使用双指针滑动窗口确定后两个元素；本质上就是在三数之和外面再嵌套一个循环

💻双层for循环+双指针

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList();
        //对数组排序
        Arrays.sort(nums);
        //确定第一个元素
        for(int i = 0;i < nums.length;i++){
            //进行剪枝
            if(nums[i] > target && nums[i] > 0){
                return res;
            }
            //第一个元素去重
            if(i > 0 && nums[i] == nums[i - 1]){
                continue;
            }
            //确定第二个元素
            for(int j = i + 1;j < nums.length;j++){
                if(nums[i] + nums[j] > target && nums[j] > 0){
                    break;
                }
                //对第二个元素进行去重
                if(j > i + 1 && nums[j] == nums[j - 1]){
                    continue;
                }
                //双指针滑动窗口，确定第三四个元素
                int left = j + 1;
                int rigth = nums.length - 1;
                while(left < rigth){
                    int sum = nums[i] + nums[j] + nums[left] + nums[rigth];
                    if(sum > target){
                        rigth--;
                    }else if(sum < target){
                        left++;
                    }else{
                        List<Integer> list = new ArrayList();
                        res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[rigth]));
                        //左右指针进行去重
                        while(left < rigth && nums[left] == nums[left + 1]){
                            left++;
                        }
                        while(left < rigth && nums[rigth] == nums[rigth - 1]){
                            rigth--;
                        }
                        left++;
                        rigth--;
                    }
                }
            }
        }
        return res;
    }
}