代码随想录算法训练营第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; // 返回结果列表
    }
}

你可能感兴趣的:(代码随想录算法训练营24期,算法,散列表,哈希,java,leetcode,数据结构)