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

一、454.四数相加II

力扣

思路：第一眼还没反应过来，真是缺练。在四个数组中分别寻找，可以先把前两个数组的和先存入map中，再计算后两个数组元素的和，看一下相反数在map中出现没有，出现过就res加上这个相反数的个数。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int temp;
        int result = 0;
        for (int i : nums1) {
            for (int j : nums2) {
                temp = i + j;
                if (map.containsKey(temp)) {
                    map.put(temp, map.get(temp) + 1);
                }else {
                    map.put(temp, 1);
                }
            }
        }
        for (int i : nums3) {
            for (int j : nums4) {
                temp = i + j;
                if (map.containsKey(0 - temp)) {
                    result += map.get(0 - temp);
                }
            }
        }
        return result;
    }
}

二、赎金信

力扣

思路：和昨天的题目类似，统计字符出现的频率，然后在另一个字符串中判断是否出现过。

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] record = new int[26];
        for (char c : magazine.toCharArray()) {
            record[c - 'a'] += 1;
        }
        for (char c : ransomNote.toCharArray()) {
            record[c - 'a'] -= 1;
            if (record[c - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
}

三、三数之和

梦破碎的地方

思路：刚开始还是写不出，然后看了视频讲解，现在对这个题目有进一步的了解。

        思考1:两数之和我们直接在map中查找 0 - num[i]，这里可不可以进行相同操作？用两个for循环记录前两个数的和，然后在map中寻找？这里涉及到去重，用此种方法很难实现。

        思考2:对于遍历数组除了暴力for循环，我们还可以使用双指针来降时间复杂度，这里不需要元素的下标，所以可以将数组排序之后用一个for循环来遍历元素，三元组分别为[i, left, right] ，这里的去重逻辑值得注意，应该是nums[i] == nums[i - 1]，而不是nums[i] == nums[i + 1]。去重i，left，和right都得考虑去重

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        int left, right;
        for (int i = 0; i < nums.length; i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                return result;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {//三元组元素a去重。用了i-1,所以加个条件i>0
                continue;
            }
            left = i + 1;
            right = nums.length - 1;
            while (right > left) {//因为是三元组，所以不能left=right
                if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                }else if (nums[i] + nums[left] + nums[right] < 0) {
                    left++;
                }else {
                    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;
    }
}

四、四数之和 

四数之和

思路：做会了三数之和，这道题便so easy了，无非一个for循环变成两个for循环，统计前两个数字的和，然后再使用双指针遍历，需要注意的是每个四元组的每个元素都得去重。换成五数之和也可以，换成三个for循环遍历。

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;
            }
            //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]) {
                    continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
                    if (nums[i] + nums[j] + nums[left] + nums[right] > target) {
                        right--;
                    }else if (nums[i] + nums[j] + nums[left] + nums[right] < target) {
                        left++;
                    }else {
                        result.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++;

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