LeetCode—几数之和系列

在LeetCode的ArrayTag中，有一系列的__数之和题，这几道题都有一些相似之处，在这里做一下总结。

总览

• 两数之和
• 三数之和
• 最接近的三数之和
• 四数之和

求解方法

1. 暴力法（不可取），时间复杂度往往为n的“几数”次方（如两数之和为$O(n^2)$）。
2. HashTable减少循环次数，降低时间复杂度。
3. 排序+双指针（推荐）。

两数之和

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

此题是LeetCode入坑第一题，作为一名算法小白，首先就想到了暴力求解法，方法也是简单粗暴，不做解释。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //暴力求解
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[] {i ,j};
                }    
            }
        }
        throw new IllegalArgumentException("no sulotion!");
    }
}

暴力终究不可取，此题还可以使用HashTable求解，减少了一次循环；上一种解法相当于是每个数都要去找一个能和别人配对的数，而利用HashTable的解法是将每个数想要配对的数存起来，并且在存起来之前，检查一遍当前的HashTable中是否已经存在了想要配对的数，如果配对成功，直接返回结果。

class Solution {
    public int[] twoSum(int[] nums, int target) {        
        //HashMap
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int a = target - nums[i]; //想要配对的数
            if (hashMap.containsKey(a) ) {
                return new int[] {hashMap.get(a),i};
            }
            hashMap.put(nums[i], i);
        }
        throw new IllegalArgumentException("no sulotion!");
    }
}

三数之和

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

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

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

此题可以参照两数之和的解法继续使用暴力法或者是HashTable解法，但是题目要求不可以包含重复的三元组，所以去重是个大问题，目前除了想到对每个三元组进行排序再使用HashSet去重外，还没有想到别的好办法。

接下来主要介绍排序+双指针的方法。

此题最合适的方法是采用双指针的方法求解，关于双指针在之前的一道题已经使用过了，最主要的一点就是关于指针如何移动的问题。

算法详解

1. 对数据进行排序，一般使用双指针求解都要先对数据进行排序。
2. 确定三个指针的初始位置，k指向最左边也就是最小的数，i和j分别指向除了k处的两端，分别向中间移动，也就是说，移动方式为i++或者j–。
3. 计算三数之和sum，如果sum = 0，直接返回结果；如果sum > 0，应该向右移动i指针，解释一下，我们的目的是需要让当前的sum值减小慢慢向0趋近，i++的方式会让sum的值增大，而j–的方式会让sum的值减小，所以应该向右移动i指针；如果sum < 0，应该向左移动j指针。
4. 由于事先对数据进行了排序，去重也变得有迹可循，首先，我们需要分析重复数据是如何产生的。看下面一个例子。
5. 去除重复数据

拿示例数据[-1, 0, 1, 2, -1, -4]来说，首先对数据排序，当前k指向-1，i指向0，j指向1，当前结果就是一个符合条件的结果

	k		i	j
-4	-1	-1	0	1	2

当k继续移动一位以后，发现当前的情况也是一个符合条件的结果，但是很明显和上一种结果重复了。由此，产生重复结果的原因就在于k了，如果存在两个k指针所指的数重复，那么下一次循环就可以直接跳过，这样就避免了重复结果的产生。

		k	i	j
-4	-1	-1	0	1	2

另外，对于其他两个指针，同样会产生重复的情况，分析过程和上面对k指针的分析相同。

代码：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //排序 + 双指针
        List<List<Integer>> ternaryList = new ArrayList<>();
        Arrays.sort(nums);
        //[-4, -1, -1, 0, 1, 2]
        //[-1, -1, 0, 1]
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) break;
            if (i > 0 && nums[i] == nums[i - 1]) continue; //去重
            int i = i + 1;
            int j = nums.length - 1;
            while (i < j) {
                int sum = nums[i] + nums[i] + nums[j];
                if (sum == 0) {
                    ternaryList.add(Arrays.asList(nums[i], nums[i], nums[j]));
                    while (i < j && nums[i] == nums[i + 1]) i++; // 去重
                    while (i < j && nums[j] == nums[j - 1]) j--; // 去重
                    j--;
                    i++;
                }
                else if (sum < 0) {
                    i++;
                }
                else if (sum > 0) {
                    j--;
                }
            }
        }
        return ternaryList;
    }
}

剩下的两道题解法和三数之和基本相同，只给出代码。

最接近的三数之和

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int result = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < nums.length; i++) {
            int j = i + 1, k = nums.length - 1;
            while (j < k) {
                int sum = nums[i] + nums[j] + nums[k];
                if (Math.abs(sum - target) < Math.abs(result - target)) {
                    result = sum;
                }
                // 移动指针
                if (sum == target) {
                    return sum;
                }
                if (sum > target) {
                    k--;
                } else {
                    j++;    
                }
            }
        }
        return result;
    }
}

四数之和

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) continue; //去重
            for (int j = i + 1; j < nums.length; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) continue; //去重
                int k = j + 1, l = nums.length - 1;
                while (k < l) {
                    int sum = nums[i] + nums[j] + nums[k] + nums[l];
                    if (sum == target) {
                        result.add(Arrays.asList(nums[i], nums[j], nums[k], nums[l]));
                        while (k < l && nums[k] == nums[k + 1]) k++;
                        while (k < l && nums[l] == nums[l - 1]) l--;
                        k++;
                        l--;
                    }
                    else if (sum > target) {
                        l--;
                    } 
                    else if (sum < target){
                        k++;
                    }
                }

            }
        }
        return result;
    }