【算法学习】LeetCode 18.四数之和

题目链接

18. 四数之和

题目描述

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

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

解题思路

1. 双指针 + 多层循环

在三数之和的基础上增加一层循环，nums[i]：代表当前元素；设置指针 j = i + 1 开始进行第二层循环，设置指针left = j + 1，指针right = nums.length - 1。

通过增加一层循环的方式来保证不漏掉每一种组合。

public List<List<Integer>> fourSum(int[] nums, int target) {
    List<List<Integer>> res = new ArrayList<>();
    Arrays.sort(nums);
    for (int i = 0; i < nums.length - 3; i++) {
        if (i > 0 && nums[i] == nums[i - 1]) {
            continue;   // 去重
        }
        for (int j = i + 1; j < nums.length - 2; j++) {
            if (j > i + 1 && nums[j] == nums[j - 1]) {
                continue;   // 去重
            }
            int left = j + 1;
            int right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[j] + nums[left] + nums[right];
                if (sum == target) {
                    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--;
                } else if (sum > target) {
                    right--;
                } else {
                    left++;
                }
            }
        }
    }
    return res;
}

• 时间复杂度：$O(N^3)$​，三层循环，每层都需要遍历 N 次
• 空间复杂度：$O(1)$

2. 对方法一进行剪枝优化

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;   // 去重
            }
            // 以下为剪枝部分
            // 获取当前最小值
            int min1 = nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3];
            if (min1 > target) {    // 如果当前最小值都比 target 大，因为已经有序，所有后面不可能出现 target 了
                break;
            }
            // 获取当前最大值
            int max1 = nums[i] + nums[nums.length - 1] + nums[nums.length - 2] + nums[nums.length - 3];
            if (max1 < target) {
                continue;           // 当前已经不可能出现 target 直接进行下一轮循环
            }
            for (int j = i + 1; j < nums.length - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;   // 去重
                }
                int left = j + 1;
                int right = nums.length - 1;
                // 以下为剪枝部分
                int min2 = nums[i] + nums[j] + nums[left] + nums[left + 1];
                if (min2 > target) {
                    break;
                }
                int max2 = nums[i] + nums[j] + nums[right] + nums[right - 1];
                if (max2 < target) {
                    continue;
                }
                while (left < right) {
                    int sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum == target) {
                        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--;
                    } else if (sum > target) {
                        right--;
                    } else {
                        left++;
                    }
                }
            }
        }
        return res;
    }
}