Day06 | 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

086小包字

于 2024-07-09 12:55:01 发布

阅读量870

点赞数 21

文章标签：算法数据结构 java leetcode

本文链接：https://blog.csdn.net/q864508127/article/details/140288611

版权

语言

Java

454.四数相加II

题目链接：四数相加II

题目

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

思路

四个数组想到，先遍历AB两个数组，用Map存他们相加的值作为key,把他们出现的次数作为value.定义count用来统计a+b+c+d = 0的次数，再遍历另外两个数组，把他们也相加，最后看0 - (c + d) 是否在map中出现过，返回count 。

代码

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 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) {
                count += map.getOrDefault(0 - i - j, 0);
            }
        }
        return count;
    }
}

易错点

map.getOrDefault（）方法是用来获取map中的值的如果不存在返回默认值0。

时间复杂度

由于是两层for循环所以是

时间复杂度: O(n^2)
空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2

383. 赎金信

题目链接：赎金信

题目

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

思路

与有效字母异位词的做法大同小异，先判断ransomNote 和 magazine，若ransomNote > magazine返回false,循环ransomNote 和 magazine，ransomNote--，magazine++。具体细节看代码

代码

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

易错点

判断时ransomNote > magazine返回false.

注意是magazine数组值++，ransomNote数组值减小。判断小于0就返回false

时间复杂度

时间复杂度: O(n)
空间复杂度: O(1)

15. 三数之和

题目链接：三数之和

题目

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

思路

由于哈希法比较容易错误，采取双指针法便于理解，先将数组进行排序，然后开始循环i从第一个数开始，设置i + 1 为左指针，nums.length - 1 为右指针，再对i进行去重，然后找到相加等于零的数添加到元组中，再对left与right进行去重。具体细节看代码。

代码

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                return res;
            }
            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 {
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    while (left < right && nums[left] == nums[left + 1]) left++;
                    while (left < right && nums[right] == nums[right - 1]) right--;
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
}

易错点

对i去重的时候要保证索引大于0，并且是对前一个进行去重。

对left去重的时候对比后一个，right去重则是对比前一个。

并且是先添加元组后去重。

时间复杂度

时间复杂度: O(n^2)
空间复杂度: O(1)

18. 四数之和

题目链接：四数之和

题目

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按任意顺序返回答案。

思路

与三数不同的是三数之和为0，四数之和为target，剪枝操作更加繁琐了，而且我们要定两个数i,j再用双指针法进行移动，先遍历i，进行去重，因为target可能为负数，所以我先把他大于零的部分进行剪枝，然后再剪枝j，他的初始值为i + 1。剩下左右指针的部分与三数之和一样了，具体细节看代码。

代码

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0 && nums[i] > target) {
                return res;
            }
            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) {
                    int sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while (left < right && nums[left] == nums[left + 1]) left++;
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
}