LeetCode 4Sum(backtrace+剪枝)

最新推荐文章于 2022-05-06 22:19:10 发布

原创最新推荐文章于 2022-05-06 22:19:10 发布 · 537 阅读

0 ·

CC 4.0 BY-SA版权

OJ 专栏收录该内容

986 篇文章

订阅专栏

本文介绍了一种解决四数之和问题的有效算法。通过使用回溯法，并结合剪枝策略减少无效搜索，实现了对整数数组中寻找四个数相加等于特定目标值的所有唯一组合。文中详细解释了算法步骤及其实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note:

Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ≤ b ≤ c ≤ d)
The solution set must not contain duplicate quadruplets.

    For example, given array S = {1 0 -1 0 -2 2}, and target = 0.

    A solution set is:
    (-1,  0, 0, 1)
    (-2, -1, 1, 2)
    (-2,  0, 0, 2)

题意：给出一个数组，求由4个数组成的和为0的所有组合

思路：回溯法，在回溯时注意剪枝

（1）剩余的可取区间中，如果第一个元素的连续和大于目标值或者最后一个元素的连续和小于目标值，递归不继续

（2）在剩余的可取区间中，如果后续的取值与上次相同，不继续

（3）在剩余层次为2层时，根据与目标值的关系来决定区间的起始值和结束值

代码如下：

class Solution {
    private void kSum(int[] nums, int start, int k, int target, List<Integer> arr, List<List<Integer>> ans)
    {
        int len = nums.length;
        if (start >= len || 0 == k) return;

        if (1 == k)
        {
            for (int i = start; i < len; i++)
            {
                if (nums[i] == target)
                {
                    arr.add(nums[i]);
                    ans.add(new ArrayList<Integer>(arr));
                    arr.remove(arr.size() - 1);
                }
            }
            return;
        }

        if (2 == k)
        {
            int end = len - 1;
            while (start < end)
            {
                int sum = nums[start] + nums[end];
                if (sum == target)
                {
                    arr.add(nums[start]);
                    arr.add(nums[end]);
                    ans.add(new ArrayList<Integer>(arr));
                    arr.remove(arr.size() - 1);
                    arr.remove(arr.size() - 1);

                    while (start < end && nums[start] == nums[start + 1]) start++;
                    start++;
                    while (start < end && nums[end] == nums[end - 1]) --end;
                    --end;
                }
                else if (sum < target)
                {
                    while (start < end && nums[start] == nums[start + 1]) start++;
                    start++;
                }
                else
                {
                    while (start < end && nums[end] == nums[end - 1]) end--;
                    end--;
                }
            }
            return;
        }

        if (k * nums[start] > target || k * nums[len - 1] < target) return;

        for (int i = start; i <= (len - k); i++)
        {
            if (i > start && nums[i] == nums[i - 1]) continue;

            if (k * nums[i] <= target)
            {
                arr.add(nums[i]);
                kSum(nums, i + 1, k - 1, target - nums[i], arr, ans);
                arr.remove(arr.size() - 1);
            }
        }
    }

    public List<List<Integer>> fourSum(int[] nums, int target)
    {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        List<Integer> arr = new ArrayList<Integer>();

        Arrays.sort(nums);

        kSum(nums, 0, 4, target, arr, ans);

        return ans;
    }

}