代码随想录算法训练营第七天| 454. 四数相加 II 383. 赎金信 15. 三数之和 18. 四数之和

合集 - 算法(18)

1.代码随想录算法训练营第二天| 977.有序数组的平方、 209.长度最小的子数组、 59.螺旋矩阵II2024-03-07 2.代码随想录算法训练营第三天| 203. 移除链表元素 707.设计链表 206.反转链表2024-03-08 3.代码随想录算法训练营第四天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点面试题 02.07. 链表相交 142. 环形链表 II2024-03-09 4.代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素。2024-03-06 5.代码随想录算法训练营第六天| 242. 有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和2024-03-11

6.代码随想录算法训练营第七天| 454. 四数相加 II 383. 赎金信 15. 三数之和 18. 四数之和2024-03-12

454. 四数相加 II
https://leetcode.cn/problems/4sum-ii/description/、

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i : nums1) {
            for (int i1 : nums2) {
                int sum = i + i1;
                map.put(sum,map.getOrDefault(sum,0) + 1);
            }
        }
        for (int i : nums3) {
            for (int i1 : nums4) {
                int sum = i + i1;
                res += map.getOrDefault(-sum,0);
            }
        }
        return res;
    }

总结：四个数组的遍历可以划分为两组两个数组的遍历，这种在两组中去遍历一组寻找另一组的模式，就是hash。
383. 赎金信
https://leetcode.cn/problems/ransom-note/description/

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)) && map.get(ransomNote.charAt(i)) != 0){
                map.put(ransomNote.charAt(i),map.get(ransomNote.charAt(i)) - 1);
            }else {
                return false;
            }
        }
        return true;

总结：map的key存字符，value存出现的次数，再去遍历。
15. 三数之和
https://leetcode.cn/problems/3sum/description/

public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> resList = new ArrayList<>();
        for (int k = 0; k < nums.length - 2; k++) {
            if (nums[k] > 0) break;
            if (k > 0 && nums[k] == nums[k - 1]) continue;
            int i = k + 1;
            int j = nums.length - 1;
            while (i < j){
                int sum = nums[i] + nums[j] + nums[k];
                if (sum == 0){
                    resList.add(new ArrayList<>(Arrays.asList(nums[k],nums[i],nums[j])));
                    do {
                        j--;
                    }while (i < j && nums[j] == nums[j + 1]);
                    do {
                        i++;
                    }while (i < j && nums[i] == nums[i - 1]);
                }else if (sum > 0){
                    do {
                        j--;
                    }while (i < j && nums[j] == nums[j + 1]);
                }else {
                    do {
                        i++;
                    }while (i < j && nums[i] == nums[i - 1]);
                }
            }
        }
        return resList;
    }

总结：这道题我昨天做了，但还是很费劲，主要就在于排序之后 k遍历到>0时就不需要遍历了写个判断能省很多时间，而且K也需要每次走到不一样的值才行。总之就是菜就多练！
18. 四数之和
https://leetcode.cn/problems/4sum/description/

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

总结：四数之和就是三数之和的思路，外面再套一层for循环。留意target为负数的情况。

posted @ 2024-03-12 13:40 jeasonGo 阅读(5) 评论(0) 编辑收藏举报

代码随想录算法训练营第七天| 454. 四数相加 II 383. 赎金信 15. 三数之和 18. 四数之和

公告

搜索

常用链接

合集

随笔档案

阅读排行榜