代码随想录算法训练营day06

最新推荐文章于 2024-04-26 21:55:28 发布

peach2580

最新推荐文章于 2024-04-26 21:55:28 发布

阅读量63

点赞数

文章标签：算法数据结构 Powered by 金山文档

本文链接：https://blog.csdn.net/peach2580/article/details/128876815

版权

Day06

454.四数相加II

力扣题目链接

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

思路

可以把四个数组两两分组，先遍历前两个数组，构造一个HashMap，key存放遍历元素的和，value是元素出现次数（因为最好要返回元素出现次数，所以是value）

遍历的时候把键值对存放进map中，注意可能value一样，那就累加，使用到getOrDefault这个函数，如果能找到value就返回value，找不到就返回默认的值

这样构建好了map，key是前两个数组元素的和，value是和出现的次数

然后遍历剩下两个数组，看看map中有没有和的相反数，如果有那就找到了，把res加上出现的次数

循环结束，返回res即可

时间复杂度O(n2)，两层循环

空间复杂度O(n2)，主要是哈希映射需要使用的空间。在最坏的情况下，A[i]+B[j]的值均不相同，因此值的个数为 n2

代码

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int res = 0;
        for (int i : nums1) {
            for (int j : nums2) {
                map.put(i + j, map.getOrDefault(i + j, 0) + 1);//不能是++，value是Integer类型
            }
        }
        for (int i : nums3) {
            for (int j : nums4) {
                if (map.containsKey(-i - j)) {
                    res += map.get(-i - j);
                }
            }
        }
        return res;
    }
}

383. 赎金信

力扣题目链接

思路

使用HashMap，key是每个字母，value是这个字母在m中的出现次数

遍历m，存放key，注意value要用到map.getOrDefault()方法

然后遍历r，如果发现某个char不在map的key中，返回false

因为map是覆盖之前的，key一样的话替换了value，因此每在r中找到一个字母，就进行替换

如果替换之后发现这个题目的value小于0了，说明r中某个字母比m多，返回false

循环结束仍然满足要求，返回true

使用数组也可以试试

因为全是小写字母，使用一个长度为26的数组存放字母的出现次数

索引是距离a的距离

先遍历m，完成元素存放

再遍历r，把索引减一，如果减一后发现索引小于零了，返回false

循环结束之后，返回true

时间复杂度O(m + n)

空间复杂度O(26)

在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。所以数组更加简单直接有效！

代码

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

        HashMap<Character, Integer> map = new HashMap();
        for (int i = 0; i < magazine.length(); i++) {
            map.put(magazine.charAt(i), map.getOrDefault(magazine.charAt(i), 0) + 1);
        }
        for (int i = 0; i < ransomNote.length(); i++) {
            if (!map.containsKey(ransomNote.charAt(i))){
                return false;
            }
            map.put(ransomNote.charAt(i),map.get(ransomNote.charAt(i)) - 1);
            if (map.get(ransomNote.charAt(i)) < 0){
                return false;
            }
        }
        return true;
    }
}

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

        int[] arr = new int[26];
        for (int i = 0; i < magazine.length(); i++) {
            arr[magazine.charAt(i) - 'a']++;
        }
        for (int i = 0; i < ransomNote.length(); i++) {
            arr[ransomNote.charAt(i) - 'a']--;
            if (arr[ransomNote.charAt(i) - 'a'] < 0){
                return false;
            }
        }
        return true;
    }
}

15. 三数之和

力扣题目链接

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

思路

这道题难度较大

这个题不能使用传统的哈希表，因为要进行去重操作，如果进行遍历的话会有重复元素，不好处理

可以采用双指针，

先将数组进行排序

之后遍历数组，l指针放在要遍历元素的下一个位置，r指针放在数组最右侧

如果三数之和大于0，说明大了，把r左移

如果小于0，说明小了，把l右移

如果等，就是我要的，输出

疑问：这样还是可能重复，比如0 0 0 0 0，会输出很多个重复的三元组

因此，在每次遍历到某个元素时，先看看和上一个元素是否相等，如果相等，就continue，直接进行下一次循环（对a处理）

对左右指针，如果a + b + c = 0了，需要看看l的右边和l是否相等，如果相等就移动，r同理

时间复杂度：O(N2)

空间复杂度：O(logN)。我们忽略存储答案的空间，额外的排序的空间复杂度为 O(logN)。然而我们修改了输入的数组，在实际情况下不一定允许，因此也可以看成使用了一个额外的数组存储了 nums 的副本并进行排序，空间复杂度为 O(N)。

代码

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        for (int i = 0; i < nums.length - 1; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) continue;//这里有细节，不比较num[i]和num[i+1]，可能少情况
            int l = i + 1;
            int r = nums.length - 1;
            while (l < r){
                if (nums[i] + nums[l] + nums[r] < 0) l++;
                else if (nums[i] + nums[l] + nums[r] > 0) r--;
                else {
//                    List<Integer> list = new ArrayList<>();
//                    list.add(nums[i]);
//                    list.add(nums[l]);
//                    list.add(nums[r]);
//                    ans.add(list);
                    ans.add(Arrays.asList(nums[i],nums[l],nums[r]));
                    while (l < r && nums[r] == nums[r - 1]) r--;
                    while (l < r && nums[l] == nums[l + 1]) l++;
                    l++;
                    r--;
                }
            }
        }
        return ans;
    }
}

这个题有难度的，二刷的时候再好好想想

遗留的问题：注释的写法不能通过？而使用Arrays工具类中的asList，把数组转换为集合却可以？

补充关于Arrays.asList()方法

【1. 要点】

该方法是将数组转化成List集合的方法。

List<String> list = Arrays.asList("a","b","c");

注意：

（1）该方法适用于对象型数据的数组（String、Integer...）

（2）该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）

（3）该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新

（4）不支持add()、remove()、clear()等方法

【2.Arrays.asList()是个坑】

用此方法得到的List的长度是不可改变的，

当你向这个List添加或删除一个元素时（例如 list.add("d");）程序就会抛出异常（java.lang.UnsupportedOperationException）。怎么会这样？只需要看看asList()方法是怎么实现的就行了：

public static <T> List<T> asList(T... a) {return new ArrayList<>(a);}

当你看到这段代码时可能觉得没啥问题啊，不就是返回了一个ArrayList对象吗？问题就出在这里。

这个ArrayList不是java.util包下的，而是java.util.Arrays.ArrayList

它是Arrays类自己定义的一个静态内部类，这个内部类没有实现add()、remove()方法，而是直接使用它的父类AbstractList的相应方法。

而AbstractList中的add()和remove()是直接抛出java.lang.UnsupportedOperationException异常的！

public void add(int index, E element) { throw new UnsupportedOperationException();}

public E remove(int index) {throw new UnsupportedOperationException();}

总结：如果你的List只是用来遍历，就用Arrays.asList()。

如果你的List还要添加或删除元素，还是乖乖地new一个java.util.ArrayList，然后一个一个的添加元素。

18. 四数之和

力扣题目链接

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

思路

这个题和三数之和很像，区别是三数之和外面一层循环，里面双指针，但这个题是外面两层循环，里面双指针，需要单独再进行去重操作

代码

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 - 2; i++) {
            if (i > 0 && nums[i - 1] == nums[i]) continue;
            for (int j = i + 1; j < nums.length - 1; j++) {
                if (j > i + 1 && nums[j - 1] == nums[j]) continue;
                int l = j + 1;
                int r = nums.length - 1;
                while (l < r) {
                    long sum = (long)nums[i] + nums[j] + nums[l] + nums[r];
                    if (sum < target) l++;
                    else if (sum > target) r--;
                    else {
                        res.add(Arrays.asList(nums[i], nums[j], nums[l], nums[r]));
                        while (l < r && nums[l] == nums[l+1]) l++;
                        while (l < r && nums[r] == nums[r-1]) r--;
                        l++;
                        r--;
                    }
                }
            }
        }
        return res;
    }
}