代码随想录算法训练营第7天 | 哈希表理论基础，454.四数相加II，383. 赎金信，15. 三数之和，18. 四数之和

454.四数相加II

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

• 先将四个数组两两分组，时间复杂度n^2,在运用map哈希表，key存放值，value存放出现次数，遍历寻找即可
• 不能用set，set只可放入数值，无法统计出现次数

代码

1. 分组+哈希表

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0; // 用于记录符合条件的四元组数量
        Map<Integer, Integer> map = new HashMap<>(); // 创建一个HashMap来存储和及其出现次数

        // 统计两个数组中的元素之和，同时统计出现的次数，放入map中
        for (int i : nums1) {
            for (int j : nums2) {
                int sum = i + j; // 当前两个元素之和
                if (map.containsKey(sum)) { // 如果map中已经存在该和
                    map.put(sum, map.get(sum) + 1); // 将和对应的次数加1
                } else {
                    map.put(sum, 1); // 否则将和作为键，次数初始化为1存入map
                }
            }
        }

        // 统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for (int i : nums3) {
            for (int j : nums4) {
                int sum = i + j; // 当前两个元素之和
                if (map.containsKey(0 - sum)) { // 如果map中存在与当前和相反的值
                    count += map.get(0 - sum); // 将相反值对应的次数累加到count中
                }
            }
        }
        return count; // 返回最终的符合条件的四元组数量
    }
}

---

383. 赎金信

题目链接：LeetCode
文章讲解：代码随想录
编写语言：Java
完成状态：已完成

解题思路

• 两个字符串匹配问题，只有26个字母，优先考虑数组
• 也可以使用暴力法，通过双重循环的方式，找到的话逐一去除，最后判断字符串长度是否为0即可

代码

1. 哈希表+数组

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        // 如果R信的长度大于杂志的长度，则无法构建，返回false
        if (ransomNote.length() > magazine.length()) {
            return false;
        }

        // 创建一个记录数组，用于统计每个字符出现的次数，ASCII码范围为0-200
        int[] record = new int[200];

        // 统计M信每个字符出现的次数
        for (int i = 0; i < magazine.length(); i++) {
            char ch = magazine.charAt(i);
            record[ch]++; // 记录字符ch出现次数加1
        }

        // 遍历R信中的每个字符
        for (int i = 0; i < ransomNote.length(); i++) {
            char ch = ransomNote.charAt(i);
            record[ch]--; // 每遇到一个R信的字符，将记录中对应字符的次数减1
        }

        // 遍历小写字母a到z的ASCII码范围(97-122)
        for (int i = 97; i <= 122; i++) {
            // 如果某个字符的出现次数为负数，表示该字符在M信中出现的次数不足以构建勒索信
            if (record[i] < 0) {
                return false;
            }
        }

        // 所有字符都能够被正确构建，返回true
        return true;
    }
}

---

15. 三数之和

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

• 本题可先固定i,然后设置双指针遍历寻找，难度在于如何去重，使用二维数组哈希结构

代码

1. 双指针

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) { // 如果当前数大于0，则后续的数都会大于0，因此可以直接跳出循环
                return result;
            }

            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) { // 如果和大于0，说明右边的数太大，需要将右指针左移
                    right--;
                } else if (sum < 0) { // 如果和小于0，说明左边的数太小，需要将左指针右移
                    left++;
                } else { // 和为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. 四数之和

题目链接：LeetCode
文章讲解：代码随想录
视频讲解：哔哩哔哩
编写语言：Java
完成状态：已完成

解题思路

• 本题在三数之和的基础上加一层k循环，然后固定i,然后设置双指针遍历寻找，难度在于如何去重，使用二维数组哈希结构需要注意target可能为负数，去重时要考虑到，也要先对数组进行排序

代码

1. 双指针

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 && target > 0 && nums[i] > target) { // 如果当前数大于目标值，直接返回结果（剪枝操作）
                return result;
            }

            if (i > 0 && nums[i] == nums[i - 1]) { // 对于重复的第一个数，跳过本次循环，避免重复结果
                continue;
            }

            for (int j = i + 1; j < nums.length; j++) { // 四数之和的第二个数
                if (j > i + 1 && nums[j] == nums[j - 1]) { // 对于重复的第二个数，跳过本次循环，避免重复结果
                    continue;
                }

                int left = j + 1; // 左指针
                int right = nums.length - 1; // 右指针

                while (left < right) { // 使用双指针法找到满足条件的四个数之和
                    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]));

                        while (left < right && nums[right] == nums[right - 1]) { // 对于重复的右指针值，跳过本次循环，避免重复结果
                            right--;
                        }
                        while (left < right && nums[left] == nums[left + 1]) { // 对于重复的左指针值，跳过本次循环，避免重复结果
                            left++;
                        }

                        right--; // 更新右指针
                        left++; // 更新左指针
                    }
                }
            }
        }
        return result; // 返回结果列表
    }
}