代码随想录算法训练营第六天|LeetCode 454，383，15，18

原创已于 2023-09-24 17:49:47 修改 · 223 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法

于 2023-07-04 23:06:34 首次发布

文章介绍了使用哈希表和双指针解决LeetCode上的四数相加II、三数之和、赎金信等题目，强调了在处理这类问题时如何优化时间复杂度，避免超时，并提供了详细的Java代码实现。

LeetCode 454.四数相加 II

文章讲解：代码随想录

视频讲解：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

力扣题目：LeetCode 454.四数相加 II

题目分析：

第一种思路可以使用四个for循环逐一遍历，时间复杂度为O(n^4)，在leetcode上会超出时间限制，所以可以作为一种思路参考。

第二种思路先求nums1和nums2的元素之和，并记录两数之和出现的次数，这就意味着要使用key来记录两数之和的值，value来记录两数之和出现的次数，这就联想到了要用map。之后再比较nums3和nums4的元素之和与map中出现的元素是否匹配即可。

相关函数知识：

代码如下（Java）：代码随想录

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

        int res = 0;
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();

        for(int i : nums1){
            for(int j : nums2){
                int sum = i + j;
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }

        for(int i : nums3){
            for(int j : nums4){
                res += map.getOrDefault(0-i-j, 0);
            }
        }

        return res;
    }
}

LeetCode 383.赎金信

文章讲解：代码随想录

力扣题目：LeetCode 383. 赎金信

题目分析：首先我们可以设置一个长度为26的数组，把magazine字符串中出现的字符做一个统计。数组下标为相对应的字符，数组中的元素为字符出现的次数。之后再遍历ransomNote数组中出现的元素是否在数组中出现，如果出现做对应的次数减1操作。最后遍历数组中是否出现元素小于0的情况，如果出现就证明了magazine字符串中缺少了ransoNote字符串中的某些字符。

代码如下（Java）：代码随想录

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {

        if(ransomNote.length() > magazine.length()){
            return false;
        }

        int[] record = new int[26];

        for(char c : magazine.toCharArray()){
            record[c - 'a'] += 1;
        }

        for(char c : ransomNote.toCharArray()){
            record[c - 'a'] -= 1;
        }

        for(int i : record){
            if(i < 0){
                return false;
            }
        }

        return true;
    }
}

LeetCode 15.三数之和

文章讲解：代码随想录

视频讲解：梦破碎的地方！| LeetCode：15.三数之和_哔哩哔哩_bilibili

力扣题目：LeetCode 15.三数之和

先简单记录一下，去重的逻辑还得再看看

代码如下（Java）：代码随想录

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){
                return result;
            }

            if(i > 0 && nums[i] == nums[i - 1]){
                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]));
                    while(right > left && nums[right] == nums[right - 1]) right--;
                    while(right > left && nums[left] == nums[left + 1]) left++;

                    right--;
                    left++;
                }
            }
        }

        return result;
    }
}

LeetCode 18.四数之和

文章讲解：代码随想录

视频讲解：难在去重和剪枝！| LeetCode：18. 四数之和_哔哩哔哩_bilibili

力扣题目：LeetCode 18.四数之和

代码如下（Java）：代码随想录

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;
            }

            //对nums[i]去重
            if(i > 0 && nums[i - 1] == nums[i]){
                continue;
            }

            //再固定i的位置的前提下，再移动j的位置
            for(int j = i + 1; j < nums.length; j++){

                //对nums[j]去重
                if(j > i + 1 && nums[j - 1] == nums[j]){
                    continue;
                }

                int left = j + 1;
                int right = nums.length - 1;

                while(right > left){
                    
                    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(right > left && nums[right] == nums[right - 1]) right--;
                        while(right > left && nums[left] == nums[left + 1]) left++;
                        left++;
                        right--;
                    }

                }
            }

        }

        return result;
    }
}