代码随想录算法训练营第六天｜454.四数相加II、383.赎金信、15.三数之和、18.四数之和

454. 四数相加II

本题如果用暴力法，时间复杂度为O($n^4$)，太高了。通过将数组两两组和，使用哈希法，可以将复杂度降到O($n^{2}log(n)$).

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer, Integer> myMap = new HashMap<>();
        int count = 0;
        for (int item1 : nums1) {
            for (int item2 : nums2) {
                int sum = item1 + item2;
                myMap.put(sum, myMap.getOrDefault(sum, 0)+1);
            }
        }
        for (int item3 : nums3) {
            for (int item4 : nums4) {
               int temp = item3+item4;
               if(myMap.containsKey(-temp)){
                   count+=myMap.get(-temp);
               }
            }
        }
        return count;
    }
}

383. 赎金信

本题和有效字母异位词差不多，同样的思路。注意Java中String不是可迭代对象。

public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character,Integer>myMap = new HashMap<>();
        for(char item :magazine.toCharArray()){
            myMap.put(item, myMap.getOrDefault(item,0)+1);
        }
        for(char item :ransomNote.toCharArray()){
            myMap.put(item, myMap.getOrDefault(item,0)-1);
            if(myMap.get(item)<0) return false;
        }
        return true;
    }

15. 三数之和

本题使用暴力法会导致超时，应思考如何优化：

如下是暴力法

 public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Set<List<Integer>> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                for (int k = j + 1; k < nums.length; k++) {
                    if (nums[i] + nums[j] + nums[k] == 0) {
                        List<Integer> tmp = Arrays.asList(nums[i], nums[j], nums[k]);
                        Collections.sort(tmp);
                        set.add(tmp);
                    }
                }
            }

        }
        return new ArrayList<>(set);
    }

因为要去重，且最后返回的是value不是下标，所以首先可以对数组进行排序，排序之后再进行遍历。

对于第一个数a，因为有可能第二个数和第一个数一样，所以去重时不能直接将第一个数挪到相同数的最后一个位置，而是应该将其和前面一个数相比，如果相等就可以往后挪，因为前一个数相等就意味着上一轮遍历所包含的情况一定是多于当前这个位置可能的情况的。

对于b和c的去重，应该在找到1组数之后，将相同的去掉。

class Solution {
public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        if (nums.length == 0 || nums[0] > 0) return new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            // 对 a 去重,注意去重逻辑，要避免将[-1,-1,2]这种情况排除掉。
            if (i > 0 && nums[i] == nums[i - 1]) 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++;

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

18. 四数之和

逻辑和本质和三数之和一样。加一层循环即可。注意开始剪枝的情况，target为负数的时候不能单纯判断第一个元素小于target就返回，因为负数越加越小。-4±3±2±1=-10.

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)
                return result;
            // 对 a 去重,注意去重逻辑，要避免将[-1,-1,2]这种情况排除掉。
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            for (int j = i + 1; j < nums.length; j++) {
                //对 b 去重
                if (j > i+1 && nums[j] == nums[j - 1]) continue;
                int left = j + 1;
                int right = nums.length - 1;
                while (left < right) {
                    int sum = 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]));
                        // 去重逻辑应该放在找到一个四元组之后，对b 和 c去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        right--;
                        left++;
                    }
                }
            }

        }
        return result;
    }
}