Leetcode N数之和

最新推荐文章于 2024-08-02 01:24:59 发布

科比的缪斯

最新推荐文章于 2024-08-02 01:24:59 发布

阅读量398

点赞数

分类专栏： Leetcode

本文链接：https://blog.csdn.net/qq_44645822/article/details/115730519

版权

这篇博客主要探讨了LeetCode中与数之和相关的题目，包括两数、三数、四数之和的多种解法，涉及哈希映射、二分查找等算法，并提到了针对有序数组和BST的特定解决方案。

摘要由CSDN通过智能技术生成

题库

1 两数之和
15 三数之和
16 最接近的三数之和
18 四数之和
167两数之和-输入有序数组
170 两数之和-数据结构设计
259 较小的三数之和
371 两整数之和
633 平方数之和
653两数之和-输入BST
923三数之和的多种可能
1022 从根到叶的二进制数之和
1099 小于K的两数之和

模板

哈希map

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> hash = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            if(hash.containsKey(target - nums[i])){
                return new int[]{hash.get(target - nums[i]),i};
            }
            hash.put(nums[i],i);
        }
        return new int[] {-1,-1};
    }
}

二分

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new LinkedList<>();
        // sort
        Arrays.sort(nums);
        // 3 foreach
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            int t = -nums[i];
            int j = i + 1, k = n - 1;
            while (j < k) {
                if (nums[j] + nums[k] > t) {
                    k--;
                } else if (nums[j] + nums[k] < t) {
                    j++;
                } else {
                    // find
                    List<Integer> ans = new LinkedList<>();
                    ans.add(nums[i]);
                    ans.add(nums[j]);
                    ans.add(nums[k]);
                    result.add(ans);
                    // 去除临近相同的元素
                    while (j < k && nums[j] == nums[j + 1]) j++;
                    while (j < k && nums[k] == nums[k - 1]) k--;
                    j++;
                    k--;
                }
            }
        }
        return result;
    }
}

Nsums模板

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        return nSumTarget(nums, 4, 0, target);
    }

    public List<List<Integer>> nSumTarget(int[] nums, int n, int start, int target){
        int sz = nums.length;
        List<List<Integer>> res = new ArrayList<>();
        if(n < 2 || sz < n){
            return res;
        }
        if(n == 2){
            int lo = start, hi = sz - 1;
            while(lo < hi){
                int sum = nums[lo] + nums[hi];
                int left = nums[lo], right = nums[hi];
                if(sum < target){
                    lo++;
                }else if(sum > target){
                    hi--;
                }else{
                    List<Integer> ans = new ArrayList<>();
                    ans.add(left);
                    ans.add(right);
                    res.add(ans);
                    while(lo < hi && nums[lo] == left) lo++;
                    while(lo < hi && nums[hi] == right) hi--;
                }
            }
        }else{
            for(int i = start; i < sz; i++){
                List<List<Integer>> sub = nSumTarget(nums, n - 1, i + 1, target - nums[i]);
                for(List<Integer> arr : sub){
                    arr.add(nums[i]);
                    res.add(arr);
                }
                while(i < sz - 1 && nums[i] == nums[i + 1]) i++;
            }
        }
        return res;
    }
}

树

class Solution {
    public int sumRootToLeaf(TreeNode root) {
        return dfs(root, 0);
    }

    private int dfs(TreeNode root, int sum){
        if(root == null) return 0;
        sum = 2 * sum + root.val;
        if(root.left == null && root.right == null){
            return sum;
        }
        return dfs(root.left, sum) + dfs(root.righ