day7 哈希表part2

前置知识

Map map = new HashMap();

getOrDefault的用法（函数名已经告诉了一切，要么得到想要的，要么给你一个默认的）
// key 的映射不存在于 HashMap 中
// Not Found - 如果 HashMap 中没有该 key，则返回默认值
String value2 = sites.getOrDefault(4, “Not Found”);

题外话： List>的作用是什么???
首先List指的是存int类型数据的列表，List指的是存【int类型数据的列表】类型数据的列表------有点“套娃”，大概意思就是这个母列表存子列表，其子列表存int类型的数据

Arrays.sort(int[] a)
这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。

383. 赎金信

简单

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次
比较简单，就不多说了，这是我的解法：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int record[] = new int[26];

        for (int i = 0; i < magazine.length(); i++){
            record[magazine.charAt(i) - 'a']++;
        }
        for (int i = 0; i < ransomNote.length(); i++){
            record[ransomNote.charAt(i) - 'a']--;
        }
        for (int i : record){
            if (i < 0){
                return false;
            }
        }

        return true;
    }
}

下面是代码随想录的解法，也有启发性：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        // shortcut
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        // 定义一个哈希映射数组
        int[] record = new int[26];

        // 遍历
        for(char c : magazine.toCharArray()){
            record[c - 'a'] += 1;
        }

        for(char c : ransomNote.toCharArray()){
            record[c - 'a'] -= 1;
        }
        
        // 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
        for(int i : record){
            if(i < 0){
                return false;
            }
        }

        return true;
    }
}

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

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;

        Map<Integer,Integer> map = new HashMap<Integer, Integer>();
        //统计两个数组中的元素之和，同时统计出现的次数，放入map
        for (int i : nums1){
            for (int j : nums2) {
                int sum = i + j;
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            } 
        }
        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for (int i : nums3){
            for (int j : nums4){
                int sum = i + j;
                res += map.getOrDefault(0 - sum, 0);
            }
        }
    return res;
    }
}

15. 三数之和

中等
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。注意：答案中不可以包含重复的三元组
图源自：图解LeetCode——15. 三数之和 - 爪哇缪斯的文章 - 知乎
https://zhuanlan.zhihu.com/p/626349140

难点1： i < j < k 不会漏掉吗？比如 i = 2时，j = 1, k = 5

不会漏掉，因为i是从最左边移过来的，已经把三元组中有个位置为1的情况排除了，换句话说，i = 2时，i = 0 和i = 1的情况已经被考虑进去了，现在把这俩删了都行，不影响结果。

难点2： 为什么找到一个3元组为0后left和right两个都可以收缩了？（同时收缩）

因为此时数组时有序的，他们3个相加此时等于0，因为数组有序，left右移会让和变大，排除left，right左移会让和变小，排除right。所以两个同时都被排除了，可以同时收缩。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.length; i++){
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) {
                return result;
            }

            if (i > 0 && nums[i] == nums[i - 1]){ // 去重a
                continue;
            }

            int left = i + 1;
            int right = nums.length - 1;
            while (left < right){
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {
                    right--;
                } else if(sum < 0){
                    left++;
                } else {
                    result.add(Arrays.asList(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++;

                    //同时收缩，再继续找nums[i] 其他满足的元组
                    right--;
                    left++;
                 }
            }

        }
        return result;
    }
}

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：减枝的细节（实在不行别减了）

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums); //排序是从小到大

        for (int i = 0; i < nums.length; i++){
            //剪枝
            if (nums[i] > 0 && nums[i] > target){ //nums[i] > 0 意味着不会出现这种问题了“数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过”
                return result;
            }
            //去重 i
            if (i > 0 && nums[i] == nums[i - 1]){
                continue;
            }

            for (int j = i + 1; j < nums.length; j++){
                //去重 j
                if (j > i + 1 && nums[j] == nums[j - 1]){ //注意这里不是if (j > 0 && nums[j] == nums[j - 1])
                    continue;
                }

                int left = j + 1;
                int right = nums.length - 1;

                while (left < right){
                    // nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
                    long sum =(long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target){
                        right--;
                    } else if (sum < target){
                        left++;
                    }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;
    }
}