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

最新推荐文章于 2024-08-24 17:09:16 发布

tttowo

最新推荐文章于 2024-08-24 17:09:16 发布

阅读量78

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_56579820/article/details/127065759

版权

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

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

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

454.四数相加II

这是第二次做了，但是自己看到题后依然没有思路，看了大概题解后知道应该将四数之和转换为两数之和，自己写了两个map集合，key值为数字和，value值为出现次数。

第一个map存放前两个数组之和，第二个map存放后两个。但是判断次数的时候相对麻烦一些。

        Map<Integer,Integer> map1 =new HashMap<>();
        Map<Integer,Integer> map2 =new HashMap<>();
        for(int i:nums1){
            for(int j:nums2){
                map1.put(i+j, map1.getOrDefault(i+j,0)+1);
            }
        }

        for(int i:nums3){
            for(int j:nums4){
                map2.put(i+j, map2.getOrDefault(i+j,0)+1);
            }
        }
        int count=0;

        Set<Integer> set= map1.keySet();
        for(Integer key:set){
            if(map2.containsKey(0-key)){
                if(map1.get(key)==1){
                    count+=map2.get(0-key);
                }
                else if(map2.get(0-key)==1){
                    count+=map1.get(key);
                }
                if(map2.get(0-key)>1&&map1.get(key)>1){
                    count+=map1.get(key)*map2.get(0-key);
                }
            }
        }
        return count;

优化后：一个map集合

只定义一个map集合存放前两个数组之和，然后遍历后两个数组进行判断，如果后两个数组和与前两个数组之和互为相反数，则给结果添加map中的value值（前两个数组和的出现次数）即可。

        Map<Integer, Integer> map1 = new HashMap<>();
        for (int i : nums1) {
            for (int j : nums2) {
                map1.put(i + j, map1.getOrDefault(i + j, 0) + 1);
            }
        }
        int res = 0;
        for (int i : nums3) {
            for (int j : nums4) {
                if (map1.containsKey(0 - (i + j))) {
                    res += map1.get(0 - (i + j));
                }
            }
        }
        return res;

383. 赎金信

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

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

magazine 中的每个字符只能在 ransomNote 中使用一次。
输入：ransomNote = "a", magazine = "b"
输出：false

方法一：map记录次数

        Map<Character, Integer> map1 = new HashMap<>();
        Map<Character, Integer> map2 = new HashMap<>();
        int len1 = ransomNote.length();
        int len2 = magazine.length();
        if (len1 > len2) return false;
        for (int i = 0; i < len2; i++) {

            char ch2=magazine.charAt(i);
            if (i < len1) {
                char ch=ransomNote.charAt(i);
                map1.put(ch, map1.getOrDefault(ch, 0) + 1);
            }
            map2.put(ch2, map2.getOrDefault(ch2, 0) + 1);
        }

        for (int i = 0; i < ransomNote.length(); i++) {
            char ch = ransomNote.charAt(i);
            if (!map2.containsKey(ch)) return false;
            else {
                map2.put(ch, map2.get(ch) - 1);
            }
            if (map2.get(ch) < 0) return false;
        }
        return true;

方法二：数组记录次数

        int[] count=new int[26];
        for(char ch:magazine.toCharArray()){
            count[ch-'a']++;
        }

        for(char ch:ransomNote.toCharArray()){
            if(count[ch-'a']<=0)return false;
            count[ch-'a']--;
        }
return true;

15. 三数之和

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

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

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

这道题之前做过，但第一次拿到题还是没有什么思路，看了视频后了解了大概解题思路，但最终还是遇到了一些问题。

排序+双指针法

首先定义三个指针，i，left（从i+1往右走），right（从数组末尾往左走）。

 sum = nums[i] + nums[left] + nums[right];

i确定好后每次都对sum进行判断，若小于0则left+1，大于0则right-1。等于0则当前三个指针对应元素值则为一组答案。

注意，当num[i]大于0时，意味着所有指针所指的数都大于0，此时直接返回结果集即可。

本题难点：去重。

①i去重：

如果是i与i+1比较，则相当于i与left进行比较，没有意义。因此i与前一次的i进行比较（注意i>0防止下标越界），若相同，则进入下一次循环。

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

②left和right去重：

假设nums=[-1,-1,-1,2,2]当sum=0时，可能出现记录了重复元祖[-1,-1,2]的情况。因此当sum=0时对left和right进行判断。若left+1/right-1的值与left/right值相等，则说明会出现重复元素，此时再进行left+1/right-1即可。

        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                return list;
            }
            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 {
                    list.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 list;

18. 四数之和

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

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

排序+双指针法

本题延续三数之和的思路。难点为去重和剪枝。

定义4个指针i、j（i+1）、left（j+1）、right（nums.len-1）。

①剪枝：与三数之和不同的是，三数之和的和为0，而四数之和为任意target值。因此不能利用nums[i]>0就剪枝。若nums[i]>0&&nums[i]>target时，和一定会越来越大，此时进行剪枝直接返回结果集即可。

②去重：

i、left、right的去重：和三数之和相同

j的去重：首先保证j>i+1（j-1！=i），然后当nums[j]==nums[j-1]时，跳过当前j即可。

        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if( 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){
                        left++;
                    }
                    else if (sum>target){
                        right--;
                    }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;