算法之N数之和

简述

从例题的角度出发，一次解决所有的N数之和问题。

例题目录

• 1. T1. 两数之和 简单
• 2. T15. 三数之和 中等
• 3. T18. 四数之和 中等
• 4. T16. 最接近的三数之和 中等
• 5. T633. 平方数之和 中等
• 6. T剑指 Offer 57. 和为s的两个数字 简单
• 7. T剑指 Offer 57 - II. 和为s的连续正数序列 简单

以上题目均来自leetcode

详细

1. 两数之和

题目描述

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

分析

1. 暴力枚举。两层遍历，寻找两个数的和为target的组合。时间复杂度$O(n^2)$
2. HashMap。一边遍历，一边记录遍历过的值，同时检查$target-nums[i]$是否在HashMap中。时间复杂度$O(n)$，空间复杂度$O(n)$

代码

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

2. 三数之和

题目描述

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

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

示例 1：

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

分析

1. 暴力枚举。需要三层遍历。时间复杂度$O(n^3)$
2. 排序+双指针。先对nums进行排序。对于nums中的每一个元素，对后面的数用双指针寻找满足条件的组合。时间复杂度O(nlogn) + O(n^2) = O(n^2)。注意需要去除重复

代码

public class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        // 先排序
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            // 如果与前一个数相同，则continue
            if (i > 0 && nums[i] == nums[i - 1]) continue;
            // 如果大于0，则后面的数都大于0，找不到和为0的组合了
            if (nums[i] > 0) break;
            int left = i + 1, right = nums.length - 1;
            while (left < right) {
                int total = nums[i] + nums[left] + nums[right];
                if (total < 0) {
                    left++;
                } else if (total > 0) {
                    right--;
                } 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;
    }
}

3. 四数之和

题目描述

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

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

示例 1：

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

分析

1. 暴力枚举。需要四层循环，时间复杂度为$O(n^4)$
2. 排序+双指针。和上个问题的思路类似。先对数组进行排序，然后两层循环，对于第一层循环中的$i$和第二层循环中的$j$，用双指针寻找剩下的两个满足条件的数。另外加上一些剪枝操作。

代码

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        int n = nums.length;
        List<List<Integer>> res = new ArrayList<>();
        if (n < 4) {
            return res;
        }
        Arrays.sort(nums);

        for (int i = 0; i < n - 3; i++) {
            // 剪枝
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            if (nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
                break;
            }
            if (nums[i] + nums[n - 1] + nums[n - 2] + nums[n - 3] < target) {
                continue;
            }
            for (int j = i + 1; j < n - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j-1]) {
                    continue;
                }
                int left = j + 1, right = n - 1, total;
                while (left < right) {
                    total = nums[i] + nums[j] + nums[left] + nums[right];
                    if (total < target) {
                        left++;
                    } else if (total > target) {
                        right--;
                    } else {
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        left++;
                        while (left < right && nums[right] == nums[right-1]) {
                            right--;
                        }
                        right--;
                    }
                }
            }
        }
        return res;
    }
}

4. 最接近的三数之和

题目描述

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

分析

1. 暴力枚举。需要三层循环，时间复杂度为$O(n^3)$
2. 排序+双指针。和三数之和解法类似。先对nums进行排序。对于nums中的每一个元素，对后面的数用双指针寻找满足条件的组合。时间复杂度$O(nlogn)+O(n^2)=O(n^2)$。
   如果三数之和等于target，则可以直接返回了，因为没有更接近的组合了。用$best$记录最接近target的三数之和，同时不断更新$best$

代码

public class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int n = nums.length;
        int best = 10000;
        if (n < 3) {
            return -1;
        }
        Arrays.sort(nums);

        for (int i = 0; i < n - 2; i++) {
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int left = i + 1, right = n - 1, total;
            while (left < right) {
                total = nums[i] + nums[left] + nums[right];
                if (total == target) {
                    return total;
                } else if (total > target) {
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }
                    right--;
                } else {
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    left++;
                }
                if (Math.abs(total - target) < Math.abs(best - target)) {
                    best = total;
                }
            }
        }
        return best;
    }
}

5. 平方数之和

题目描述

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 $a^2+b^2=c$ 。

示例 1：

输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5

分析

1. 二分查找。对于每一个数$a$，二分查找满足$a^2+b^2=c$的，时间复杂度为$O(\sqrt{c}log\sqrt{c})$.
2. 双指针法。左右两个指针 $left$ 和 $right$ 分为从 $0$ 和 $\sqrt{c}$ 开始，如果 $lef{t}^2+righ{t}^2>c$，$right$ 减一，否则 $left$ 加一。时间复杂度为 $O(\sqrt{c})$

代码

class Solution {
    public boolean judgeSquareSum(int c) {
        int left = 0, right = (int) Math.sqrt(c) + 1, total;
        while (left <= right) {
            total = left * left + right * right;
            if (total == c) {
                return true;
            } else if (total < c) {
                left++;
            } else {
                right--;
            }
        }
        return false;
    }
}

6. 剑指 Offer 57. 和为s的两个数字

题目描述

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]

分析

1. 双指针。由于是排序后的数组，设置左右两个指针，根据两数之和不断调整指针位置，直到找到满足条件的两个数。时间复杂度为O(n)

代码

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int n = nums.length;
        int left = 0, right = n - 1, total;
        while (left < right) {
            total = nums[left] + nums[right];
            if (total < target) {
                left++;
            } else if (total > target) {
                right--;
            } else {
                return new int[]{nums[left], nums[right]};
            }
        }
        return new int[]{-1, -1};
    }
}

7. 剑指 Offer 57 - II. 和为s的连续正数序列

题目描述

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]

分析

1. 双指针。上一道题的进阶，但是两个指针的起始位置有点变化。左右两个指针的起始位置分别为1和2。时间复杂度为O(target)。

代码

class Solution {
    public int[][] findContinuousSequence(int target) {
        List<int[]> res = new ArrayList<>();
        int left = 1, right = 2, total;
        while (left < (target / 2 + 1)) {
            total = (left + right) * (right - left + 1) / 2;
            if (total < target) {
                right++;
            } else if (total > target) {
                left++;
            } else {
                int[] tmp = new int[right - left + 1];
                for (int i = left; i <= right; i++) {
                    tmp[i - left] = i;
                }
                res.add(tmp);
                left++;
                right++;
            }
        }
        return res.toArray(new int[res.size()][]);
    }
}