每日算法总结——力扣15.三数之和、力扣18.四数之和、引出n数之和

原题：15. 三数之和 - 力扣（LeetCode）

题目难点：不可以包含重复的三元组

看到题目的第一思路就是，三重for循环从头到尾遍历所有可能的三元组组合，但是不能包含重复的三元组，而且这三元组指的不是下标的三元组，而是值的三元组，也就是说，对于[0,0,0,0]，只能有一个[0,0,0]，所以我们需要去重，如何去重？显然可以遍历每个三元组，然后查HashMap的方式去重。这种方法可以解题，但是复杂度太高，达到$O(N^3)$

解题思路：利用三重指针

• 首先对nums排序（升序）
• 第一个指针i用于遍历整个nums，同时nums[i]也是三元组的第一个数（最小的数），另外两个指针l=i+1和r=nums.length-1，一个在左（中值），一个在右（最大值）
• 计算它们仨的总和sum=nums[i]+nums[l]+nums[r]，根据sum的大小调整l和r，使得整个值接近于0。
• 去重操作：
  • 首先如果nums[i] == nums[i-1]，说明nums[i]会走上nums[i-1]的老路，这时我们应直接跳过。
  • 如果nums[l+1]=nums[l]，说明此时nums[l+1]会走上nums[l]的老路，这时我们也应直接跳过。
  • 如果nums[r-1]=nums[r]，说明此时nums[r-1]会走上nums[r]的老路，这时我们也应直接跳过。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);// O(NlogN)
        int i, l, r;
        for (i = 0; i < nums.length - 2; i++) {
            if (nums[i] > 0) {
                // 如果num[i]>0，说明后续所有i的sum都会大于0，直接跳出循环
                break;
            }
            if (i != 0 && nums[i] == nums[i - 1]) {
                // num[i]和num[i-1]重复了，直接跳过
                continue;
            }
            l = i + 1;
            r = nums.length - 1;
            int sum;
            while (l < r) {
                // 左右指针相向而行
                sum = nums[i] + nums[l] + nums[r];
                if (sum == 0) {
                    ArrayList<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[l]);
                    list.add(nums[r]);
                    res.add(list);
                    while (l < r && nums[l + 1] == nums[l]) {
                        // nums[l + 1]和nums[l]重复了，直接跳过
                        l++;
                    }
                    while (l < r && nums[r - 1] == nums[r]) {
                        // nums[r - 1]和nums[r]重复了，直接跳过
                        r--;
                    }
                    l++;
                    r--;
                } else if (sum > 0) {
                    r--;
                } else {
                    l++;
                }
            }
        }
        return res;
    }
}

上面是求三个数之和的方法，下面是四数之和：

原题：18. 四数之和 - 力扣（LeetCode）

题目难点：不可以包含重复的四元组

这道题是比三数之和要复杂一点的，首先它的目标值由外界提供，不再是统一为0了，而且是四个树的组合，去重和剪枝操作相对较难。

整体思路是和三数之和一样，也是使用双指针，基本解法就是在三数之和的基础上再套一层 for 循环，也就是需要先找出前两个数的组合，再去确定后两个数。

但是有一些细节需要注意，例如： 不要判断 nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target 是任意值。比如：数组是[-4, -3, -2, -1]，target 是-10，不能因为 -4 > -10 而跳过。但是我们依旧可以去做剪枝，逻辑变成 nums[i] > target && (nums[i] >=0 || target >= 0) 就可以了。

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++) {
		
            // nums[i] > target 直接返回, 剪枝操作
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
		
            if (i > 0 && nums[i - 1] == nums[i]) {    // 对nums[i]去重
                continue;
            }
            
            for (int j = i + 1; j < nums.length; j++) {

                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                    continue;
                }

                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
		    		// nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}

四数之和的双指针解法是两层 for 循环 nums[k] + nums[i] 为确定值，依然是循环内有left和right下标作为双指针，找出 nums[k] + nums[i] + nums[left] + nums[right] == target 的情况，三数之和的时间复杂度是$O(n^2)$，四数之和的时间复杂度是$O(n^3)$。

那么一样的道理，五数之和、六数之和等等都采用这种解法。