代码随想录算法训练营第七天|哈希表+454.四数相加II+赎金信+三数之和+四数之和+总结

454.四数相加

思路：

本题是使用哈希法的经典题目，而0015.三数之和 (opens new window)，0018.四数之和 (opens new window)并不合适使用哈希法，因为三数之和和四数之和这两道题目使用哈希法在不超时的情况下做到对结果去重是很困难的，很有多细节需要处理。

而这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于题目18. 四数之和，题目15.三数之和，还是简单了不少！
- 本题解题步骤：

1. 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。

2. 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。 定义int变量count，用来统计 a+b+c+d = 0
   出现的次数。

3. 在遍历大C和大D数组，找到如果 0-(c+d)在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。

4. 最后返回统计值 count 就可以了

代码：

• 注意：
• map.getOrDefault(i+j,0)函数不能直接用 应该用hashmap对象 map来调用

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        int res=0;
        for(int i:nums1){
            for(int j:nums2){
                map.put(i+j,map.getOrDefault(i+j,0)+1);
                //判断map里是否有这个元素，有的话就数量+1
            }
        }
        for(int i:nums3){
            for(int j:nums4){
                res+=map.getOrDefault(0-i-j,0);
                //如果存在0-i-j（也就是四个数相加为0的情况），则说明有了一种结果，那么res++
            }
        }
        return res;//最后返回储存的结果
    }
}

383. 赎金信

代码：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] res = new int[26];
        for(int i=0;i<ransomNote.length();i++){
            res[ransomNote.charAt(i)-'a']++;
        }
        for(int i=0;i<magazine.length();i++){
            res[magazine.charAt(i)-'a']--;
        }
        for(int i:res){
            if(i>0){
                return false;
            }
        }
        return true;
    }
}

15. 三数之和

思路：双指针

双指针
其实这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码。

而且使用哈希法 在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)，也是可以在leetcode上通过，但是程序的执行时间依然比较长 。

接下来我来介绍另一个解法：双指针法，这道题目使用双指针法 要比哈希法高效一些，那么来讲解一下具体实现的思路。

拿这个nums数组来举例，首先将数组排序，然后有一层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相遇为止。

去重逻辑的思考

• a的去重
  说到去重，其实主要考虑三个数的去重。 a, b ,c, 对应的就是 nums[i]，nums[left]，nums[right]
  a 如果重复了怎么办，a是nums里遍历的元素，那么应该直接跳过去。
  但这里有一个问题，是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同。
  都是和 nums[i]进行比较，是比较它的前一个，还是比较它的后一个。
  如果我们的写法是 这样：

  if (nums[i] == nums[i + 1]) { // 去重操作
      continue;
  }
  

  那我们就把 三元组中出现重复元素的情况直接pass掉了。 例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断 下一个也是-1，那这组数据就pass了。
  我们要做的是 不能有重复的三元组，但三元组内的元素是可以重复的！
  所以这里是有两个重复的维度。
  那么应该这么写：

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

  这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到 第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到 结果集里。

• b与c的去重
  去掉left和right遇到的重复数值的数据

代码

• 注意：
• List<List<Integer>> result 的声明表示一个包含整数列表的列表，这种嵌套列表的结构通常在处理二维数据时非常有用。具体来说，result 是一个列表，其中的每个元素都是一个整数列表。
• 定义动态数组 List<List> res = new ArrayList<>();
• Arrays.sort(nums); //arrays.sort是快排
• Arrays.asList(nums[i], nums[left], nums[right])转为list
• list和array int[]的区别
  • 数组是固定大小、类型相同的数据结构。
  • List 是 Java 集合框架的一部分，允许存储不同类型的元素，并且大小可以动态变化。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);        //arrays.sort是快排
        //使用双指针，先对原始数组进行排序
        //i+left+right
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]>0){
                //当此时nums[i]>0时，根据排序可知后面全是＞0的数，所以直接返回结果
                return result;
            }
            //三个数a+b+c=0,循环的i就是a，第一个数值

`           // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {因为这样比较的是i和i+1,i+1可能是left,
            那么假如结果集里是-1和-1的话，就把这个结果给过滤了
                continue;
            }
            */
            // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) { 
                //这样就可以比较i和前一位已经计算过的i是否相同
                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 if(sum==0){
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    while (right > left && nums[right] == nums[right - 1]){
                        right--;
                    } 
                    while (right > left && nums[left] == nums[left + 1]){
                        left++;
                    }
                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }

        }
        return result;
    }
}

18. 四数之和

思路：

代码

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        // i,j,left,right
        for(int i=0;i<nums.length;i++){
            // nums[i] > target 直接返回, 剪枝操作
            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(j>i+1&&nums[j-1]==nums[j]){
                    continue;
                }
                // int sum1 = nums[i]+nums[j];
                int left=j+1,right=nums.length-1;
                while(left<right){
                    // int sum = sum1+nums[left]+nums[right];
                    int sum = nums[i]+nums[j]+nums[left]+nums[right];
                    if(sum>target){
                        right--;
                    }else if(sum<target){
                        left++;
                    }else{
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while (right > left && nums[right] == nums[right - 1]){
                            right--;
                        } 
                        while (right > left && nums[left] == nums[left + 1]){
                            left++;
                        }
                        // 找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }
                // ij去重要在循环开始的时候
                // if(j>i+1&&nums[j-1]==nums[j]){
                //     continue;
                // }
            }
        }
        return res;
    }
}

哈希表总结

代码随想录哈希表总结

1.数组做哈希

2.set做哈希

3.map做哈希