算法通关村——n数之和问题解析

n数之和问题

1、两数之和

1.1、问题描述

​ 本题来自LeetCode1. 给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

示例1：

输入：nums = [2, 7, 11, 15]，target = 9

输出：[0, 1]

解释：因为nums[0] + nums[1] == 9 ，返回[0, 1]。

示例2：

输入：nums = [3, 2, 4]，target = 6

输出：[1, 2]

1.2、问题解答

​ 本题可以直接暴力遍历解决，即用两层循环，第一层确定一个数，从2，7，一直到11，然后内层循环去继续遍历后续的元素，判断是否存在target - x的数即可，代码如下：

public int[] twoSum(int[] nums, int target) {
    int n = nums.length;
    for	(int i = 0; i < n; i++){
        for (int j = i + 1; j < n; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[]{i, j};
            }
        }
    }
    return new int[0];
}

​ 这种方法的不足之处在于寻找target - x的时间复杂度过高，我们可以使用哈希表，将寻找target - x的时间复杂度从O(N)降低到O(1)。这样我们创建一个哈希表，对于每一个x，我们首先查询哈希表中是否存在target - x，然后将x插入到哈希表中，即可保证不会让x和自己匹配。代码实现如下：

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

2、三数之和

2.1、问题描述

​ 如果将两个数换成三个会怎么样？

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

示例：

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

输出：[[-1, -1, 2], [-1, 0, 1]]

2.2、问题解答

​ 本题看似就是两数增加了一个数，但是难度增加了很多，我们可以使用三层循环直接找，时间复杂度为O(n^3)，太高了。也可以使用双层循环 + Hash来实现，首先按照第一题两数之和的思路，我们可以固定一个数target，再利用两数之和的思想去map中存取或查找(-1)*target - num[j]，但是这样的问题是无法消除重复结果。

​ 本题公认的最好方式是“排序 + 双指针”。我们可以先将数组排序来处理重复结果，然后还是固定一位元素，由于数组是排好序的，所有我们用双指针来不断寻找即可求解，代码如下：

public List<List<Integer>> threeSum (int[] nums) {
    int n = nums.length;
    Arrays.sort(nums);
    List<List<Integer>> ans = new ArrayList<List<Integer>>();
    //枚举 a
    for	(int first = 0; first < n; first++) {
        //需要和上一次枚举的数不相同
        if (first > 0 && nums[first] == nums[first - 1]) {
            continue;
        }
        // c 对应的指针初始指向数组最右端
        int third = n - 1;
        int target = -nums[first];
        //枚举 b
        for (int second = first + 1; second < n; second++) {
            //需要和上一次枚举的数不相同
            if (second > first + 1 && nums[second] == nums[second - 1]) {
                continue;
            }
            while (second < thrid && nums[second] + nums[third] > target) {
                third--;
            }
            //如果指针重合，随着b后续的增加
            //就不会有满足a+b+c=0并且b<c的c了，可以推出循环
            if (second == third) {
                break;
            }
            if (nums[second] + nums[third] == target) {
                List<Integer> list = new ArrayList<Integer>();
                list.add(nums[first]);
                list.add(nums[second]);
                list.add(nums[third]);
                ans.add(list);
            }
        }
    }
    return ans;
}

3、总结

​ 对于n数之和问题，解决思路其实就是定一个锚点，在根据这个锚点去找接下来的数。在两数之和的第一种解法中，我们是先确定了一个数，然后再去遍历后续的数组来寻找题目需要的数，因为是遍历，所以时间复杂度是O(n)，为了优化这个O(n)的时间复杂度，我们使用hash去将O(n)转化成O(1)，得到了最后的解答。

​ 对于三数之和问题，我们也是想着先确定锚点，最简单直接的想法是遍历三次数组，但是时间复杂度太高，所以又想到两数之和的hash解法，先确定一个数的话，就转变成了两数之和问题，可以直接用hash去解，不过这种方法无法去除重复的结果。我们提出的最后一种方法，是先将数组排序，有序的数组便于去重，再确定锚点，锚点之后的数组再用双指针去遍历得到需要的值。