算法训练营第七天|454.四数相加II、383.赎金信、15.三数之和、18.四数之和-优快云博客

今天是第七天，还是关于哈希这一个章节的。

先把总结写在前面吧，今天的这四个题，前两个相对简单，思路也容易想清楚，就不多说了，主要是后两个题，因为涉及到去重，我看了半天Carl老师的题解还是不理解，主要是数b的去重为什么是j>i+2 && nums[j-1] == nums[j] && nums[j-1] == nums[j-2]，以及数c在set里的去重，今天事情有点多，这两个题目的坑先挖在这，后面抽时间看下视频讲解看看能不能把坑填了。

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

这一题我一上来就将nums1和nums2的和暴力穷举后放到一个map1了，然后将nums3和nums4的和同样暴力穷举后放到map2里，然后针对两个map，双层循环看和是否等于0，然后。。。果不其然的悲剧了，超时。。。。

看了下Carl老师的题解，用一个map就够了，在第二次暴力穷举nums3和num4的和时，直接用map1里的值跟nums3和nums4的和做比较就行了，并且把次数也记录了下来，实在是太巧妙了。

主要是这个map.getOrDefault()方法，学到了。

虽然我的超时了，也把这个代码一起贴上吧。

   public static int fourSumCount(int[] nums1,int[] nums2, int[] nums3, int[] nums4) {
        HashMap<String,Integer> map1 = new HashMap<String,Integer>();
        HashMap<String,Integer> map2 = new HashMap<String,Integer>();

        int result = 0;

        for(int i = 0; i < nums1.length; i++) {
            for(int j = 0; j < nums2.length; j++) {
                map1.put(String.valueOf(i) + "" + String.valueOf(j), nums1[i] + nums2[j]);
            }
        }

        for(int i = 0; i < nums3.length; i++) {
            for(int j = 0; j < nums4.length; j++) {
                map2.put(String.valueOf(i) + "" + String.valueOf(j), nums3[i] + nums4[j]);
            }
        }

        for(Integer x : map1.values()) {
            for(Integer y : map2.values()) {
                if(x + y == 0) {
                    result++;
                }
            }
        }
        return result;
    }

    public static int fourSumCount2(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) {
                res += map.getOrDefault(0 - i - j, 0);
            }
        }
        return res;
    }
}

383.赎金信

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

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

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

解答：这题上来直接秒了，用一个map记录magazine里每个字符出现的次数，key为字符，value是次数，然后遍历ransomNote，map里无该字符的key直接返回false，有的话，每一个字符扣减一次map里的value，最后检查map里是否有value<0的key，有就返回false。

不过我看了Carl老师的文字解答，还是用的int[]数组，用数组下标0~25表示对应的26个字符，也可以解决，就是有点不太认同的是讲解里说用int[]数组会比用map高效，仅就这个题目来说，用map的话，如果magazine里的不同字符数超过12个的话，map占用的空间并不会更多吧，毕竟只用维护一个16长度的数组并且这些字符出现哈希碰撞的可能性几乎没有，也不存在维护红黑树的情况吧，链表上也只有一个数值，都不会出现链表转红黑树的情况。

public boolean canConstruct(String ransomNote, String magazine) {
        Map<String,Integer> map = new HashMap<String,Integer>();
        for(int i = 0; i < magazine.length(); i++) {
            String s = magazine.substring(i,i+1);
            map.put(s,map.getOrDefault(s, 0) + 1);
        }

        for(int i = 0; i < ransomNote.length(); i++) {
            String s = ransomNote.substring(i,i+1);
            if(!map.containsKey(s)) {
                return false;
            }else {
                map.put(s,map.get(s) - 1);
            }
        }

        for(Integer x : map.values()) {
            if(x < 0) {return false;}
        }
        //check is map has value -1
        return true;
    }

15.三数之和

来填坑了，昨天没有理解的是关于使用哈希法时去重的操作，哈希法太复杂了，决定抛弃掉，而用双指针法还是相对易懂的，先确定a的去重逻辑，a要和前面一个数去比，这样表示第一个数等于a的情况已经收集过了，所以再碰到a就不用收集了，后面b和c的去重也很好理解了，有个注意点就是b和c去重之前应该先把满足条件的集合收集起来。

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        // 找出a + b + c = 0
        // 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 (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;
    }

18.四数之和

四数之和和上面一题思路是一样的，区别是在原来的for i的循环外面再套一个for循环，里面去重逻辑是一样的。

public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);  // 排序数组
        List<List<Integer>> result = new ArrayList<>();  // 结果集
        for (int k = 0; k < nums.length; k++) {
            // 剪枝处理
            if (nums[k] > target && nums[k] >= 0) {
                break;
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.length; i++) {
                // 第二级剪枝
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }
                // 对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.length - 1;
                while (right > left) {
                    long sum = (long) nums[k] + nums[i] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        result.add(Arrays.asList(nums[k], nums[i], 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++;
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }