代码随想录day07：第454题.四数相加II、383. 赎金信、第15题. 三数之和、第18题. 四数之和

本文介绍了如何利用双指针和哈希表优化四数之和问题的解法，通过将数组分成两组，借鉴两数之和的思路，并讨论了哈希表在存储和查找过程中的作用，以及空间复杂度的考虑。

#第454题.四数相加II

题目链接
 代码随想录讲解
思路：四个独立的数组，找到A[i] + B[j] + C[k] + D[l] = 0，不用考虑有重复的四个元素相加等于0的情况。我们可以将四个数组分成两部分，A和B为一组，C和D为另外一组，这样思路就可以沿用两数之和的思路。两数之和.plus。
解题步骤：
首先定义一个hashmap，key放a和b两数之和，value 放a和b两数之和出现的次数。
遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。

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

    }
}

时间复杂度: O(n^2)
空间复杂度: O(n^2)

383. 赎金信

题目链接
 代码随想录
思路：从b中找到a中所需要的字母，且b中的每个字母只能使用一次。用hash表存b中所有的字母，并统计字母出现的次数。我一开始用的map。

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character,Integer>map=new HashMap<Character,Integer>();
        //将magazine中的每个字母以及出现的次数存入map中
        for(int i=0;i<magazine.length();i++){
            char word=magazine.charAt(i);
            map.put(word,map.getOrDefault(word,0)+1);
        }
        //假如在map中找不到ransoNote的字母，则返回false，找到了就将对应的value-1
        for(int j=0;j<ransomNote.length();j++){
            char word=ransomNote.charAt(j);
            if(map.getOrDefault(word,0)==0)return false;
            else{
                map.put(word,map.get(word)-1);
            }
        }
        return true;
    }
}

时间复杂度: O(n)
空间复杂度: O(1)
字母这种，可以用数组hash，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的。数据量大的话就能体现出来差别了。所以数组更加简单直接有效。

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;
    }
}

时间复杂度: O(n)
空间复杂度: O(1)
虽然时间复杂度和空间复杂度与使用map一样，但在力扣中很容易看到，用时差距很大。

第15题. 三数之和

题目链接
 代码随想录
思路：首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。接下来如何移动left 和right呢，如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。突然发现和我之前两数之和的思路一样。

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

时间复杂度: O(n^2)
空间复杂度: O(1)
去重逻辑：
a的去重：
是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同？
如果我们的写法是这样：
if (nums[i] == nums[i + 1]) { // 去重操作
continue;
}
那我们就把三元组中出现重复元素的情况直接pass掉了。例如{-1, -1 ,2} 这组数据，当遍历到第一个-1的时候，判断一个也是-1，那这组数据就pass了。（我自己写就犯了这个错误）
思考题
既然三数之和可以使用双指针法，我们之前讲过的1.两数之和 (opens new window)，可不可以使用双指针法呢？
如果不能，题意如何更改就可以使用双指针法呢？大家留言说出自己的想法吧！
两数之和就不能使用双指针法，因为1.两数之和 (opens new window)要求返回的是索引下标，而双指针法一定要排序，一旦排序之后原数组的索引就被改变了。
如果1.两数之和要求返回的是数值的话，就可以使用双指针法了。
答：可以在排序前copy原数组，但是会多循环一遍，还会多O(n)的空间复杂度。

第18题. 四数之和

题目链接
 代码随想录
思路：四数之和和三数之和是一个思路，都是使用双指针法。
但是有一些细节需要注意，例如：不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。
那么一样的道理，五数之和、六数之和等等都采用这种解法。对于三数之和双指针法就是将原本暴力O(n³)降为O(n²)的解法，四数之和的双指针解法就是将原本暴力O(n⁴)的解法，降为O(n³)的解法。

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++) {
		
            // nums[i] > target 直接返回, 剪枝操作
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
		
            if (i > 0 && nums[i - 1] == nums[i]) {    // 对nums[i]去重
                continue;
            }
            
            for (int j = i + 1; j < nums.length; j++) {

                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                    continue;
                }

                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
		    // 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]));
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}

时间复杂度: O(n^3)
空间复杂度: O(1)

总结

一般来说哈希表都是用来快速判断一个元素是否出现集合里。
对于哈希表，要知道哈希函数和哈希碰撞在哈希表中的作用。
哈希函数是把传入的key映射到符号表的索引上。
哈希碰撞处理有多个key映射到相同索引上时的情景，处理碰撞的普遍方式是拉链法和线性探测法。
常见的三种哈希结构：
数组
set（集合）
map（映射）
数组作为哈希表
所以当hash值多的时候且紧密的时候用数组，比如统计字母；
set作为哈希表
当hash值少，跨度大的时候用set。比如两个数组的交集一题：
主要因为如下两点：
数组的大小是有限的，受到系统栈空间（不是数据结构的栈）的限制。
如果数组空间够大，但哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。
所以此时一样的做映射的话，就可以使用set了。
map作为哈希表
使用数组和set来做哈希法的局限：
数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。