Leetcode(18)-四数之和

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

注意:

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

示例:

给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0。

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

思路:

(1)我们可以用递归的方法。将四数之和转换为三数之和,然后转换为两数之和。先将数组中的数排序,然后调用函数处理。这样就需要一个函数,个数和目标值都通过传参的方式获取。还需要一个开始的位置,也通过参数传递进去。如果刚好转换的是两数之和,那么我们可以利用前面已经解决过的两数之和的方法来处理,用unordered_set来处理重复的元素,判断有没有被访问过,以免一个元素重复使用。如果不是两个数的和,那么我们将这个数先记下来,直到是判断两个数的和。总之就是先固定两个数,然后用two-sum的方法来找另外两个数。

  vector<vector<int>> k_Sum(vector<int> &nums, int begPos, int count, int target)
    {
        if (nums.empty())
            return vector<vector<int>>();
        /*所输入序列为已排序*/
        int len = nums.size();
        unordered_set<int> visited;
        vector<vector<int>> ret;
        vector<int> tmp;
        /*2-sum 处理*/
        if (2 == count)
        {
            int i = begPos, j = len - 1;
            while (i < j)
            {
                int sum = nums[i] + nums[j];
                if (sum == target && visited.find(nums[i]) == visited.end())
                {
                    tmp.clear();
                    tmp.push_back(nums[i]);
                    tmp.push_back(nums[j]);
                    ret.push_back(tmp);

                    /*加入已访问set*/
                    visited.insert(nums[i]);
                    visited.insert(nums[j]);

                    ++i;
                    --j;
                }//if
                else if (sum < target)
                    ++i;
                else
                    --j;
            }//while
        }//if
        else{
            for (int i = begPos; i < len; ++i)
            {
                if (visited.find(nums[i]) == visited.end())
                {
                    visited.insert(nums[i]);
                    /*得到k-1 sum的序列*/
                    vector<vector<int>> subRet = k_Sum(nums, i+1, count - 1, target-nums[i]);
                    if (!subRet.empty())
                    {
                        int sz = subRet.size();
                        for (int j = 0; j < sz; ++j)
                        {
                            subRet[j].insert(subRet[j].begin(), nums[i]);
                        }//for
                        ret.insert(ret.end(), subRet.begin(), subRet.end());
                    }//if
                }//if
            }//for
        }//else
        /*返回结果集*/
        return ret;
    }
    /*4-sum算法,递归实现,TLE*/
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        if (nums.empty())
            return vector<vector<int>>();

        sort(nums.begin(), nums.end());

        return k_Sum(nums, 0, 4, target);
    }

(2)思路是一样的,但是没有用递归的方式

    vector<vector<int>> fourSum(vector<int>& nums, int target)
    {
        if (nums.empty() || nums.size() < 4)
            return vector<vector<int>>();

        sort(nums.begin(), nums.end());
        int len = nums.size();
        set<vector<int>> tmpRet;
        vector<vector<int>> res;

        for (int i = 0; i < len; ++i)
        {
            for (int j = i + 1; j < len; ++j)
            {
                int beg = j + 1, end = len - 1;
                while (beg < end)
                {
                    int sum = nums[i] + nums[j] + nums[beg] + nums[end];
                    if (sum == target)
                    {
                        vector<int> tmp;
                        tmp.push_back( nums[i]);
                        tmp.push_back( nums[j]);
                        tmp.push_back( nums[beg]);
                        tmp.push_back( nums[end]);

                        tmpRet.insert(tmp);

                        ++beg;
                        --end;
                    }
                    else if (sum < target)
                    {
                        ++beg;
                    }
                    else
                        --end;
                }//while
            }//for
        }//for
        auto iter = tmpRet.begin();
        while (iter != tmpRet.end())
        {
            res.push_back(*iter);
            ++iter;
        }//while
        return res;
    }

原文地址:https://www.cnblogs.com/mini-coconut/p/9193206.html

时间: 2024-10-07 14:20:21

Leetcode(18)-四数之和的相关文章

LeetCode 18. 四数之和(4Sum)

题目描述 给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c 和 d ,使得 a + b + c + d 的值与 target 相等?找出所有满足条件且不重复的四元组. 注意: 答案中不可以包含重复的四元组. 示例: 给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0. 满足要求的四元组集合为: [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

[Leetcode 18]四数之和 4 Sum

[题目] Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target. Note:The solution set must not contain d

LeetCode 18. 四数之和

题意 从数组中找出满足和为target的四元组. 思路 想法1:暴力,\(O(n^4)\). 想法2:排序 + 指针.思路类似前面的三数之和,只不过这里的指针多了一个,后两个指针相遇时第二个指针后移一个单位.时间复杂度:\(O(n^3)\),空间复杂度:\(O(1)\). 代码 class Solution { public: vector<vector<int>> fourSum(vector<int>& nums, int target) { int len

LeetCode:四数之和【18】

LeetCode:四数之和[18] 题目描述 给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c 和 d ,使得 a + b + c + d 的值与 target 相等?找出所有满足条件且不重复的四元组. 注意: 答案中不可以包含重复的四元组. 示例: 给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0. 满足要求的四元组集合为:[ [-1, 0, 0, 1], [-2, -1, 1, 2]

[LeetCode] 4Sum 四数之和

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.

18. 四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c 和 d ,使得 a + b + c + d 的值与 target 相等?找出所有满足条件且不重复的四元组. 注意: 答案中不可以包含重复的四元组. 示例: 给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0. 满足要求的四元组集合为:[ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2]] /* 解题思

[LeetCode] 454. 4Sum II 四数之和II

Given four lists A, B, C, D of integer values, compute how many tuples (i, j, k, l) there are such that A[i] + B[j] + C[k] + D[l] is zero. To make problem a bit easier, all A, B, C, D have same length of N where 0 ≤ N ≤ 500. All integers are in the r

LeetCode第十八题-四数之和

4Sum 问题简介:定n个整数和整数目标的数组nums,是否有元素a,b,c,d在nums中,使a+b+c+d=target? 举例: 给定数组 nums = [1, 0, -1, 0, -2, 2], 目标值 target = 0. 结果: [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ] 解法一:先将数组排序,通过三层循环,寻找是否符合四数之和的结果 注: 1.contains方法使用场景 list/Set - contains() Map -

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

LeetCode有一系列做法套路相同的题目,N数之和就可以算一个 两数之和 给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标. 你可以假设每种输入只会对应一个答案.但是,你不能重复利用这个数组中同样的元素. 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 第一个解决办法,简单暴力,堆for循环就是,但