leetcode journal《微软题库》- 四数之和--＞扩展至n数之和

题目：

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组
[nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n

• a、b、c 和 d 互不相同

• nums[a] + nums[b] + nums[c] + nums[d] == target

  你可以按 任意顺序 返回答案 。

示例输入：

示例1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

• 1 <= nums.length <= 200
• -10^9 <= nums[i] <= 10^9
• -10^9 <= target <= 10^9
  
  

题解：

​ 在解决四数之和之前，题库里已经有了两数之和、三数之和的题目，解决方法的大致框架都是排序+双指针，即：

1. 将列表中的数据按照从小到大的顺序进行排序
2. 在循环过程中，遵循以下两点：

• 每一种循环枚举到的下标必须大于上一重循环枚举到的下标；
• 同一重循环中，如果当前元素与上一个元素相同，则跳过当前元素。

3. 使用循环先枚举前面的数，再使用双指针枚举后面的数，从而去掉一层循环

   ​ 假设两重循环枚举到的前两个数分别位于下标 i 和 j，其中 i< j。初始时，左右指针分别指向下标 j+1 和下标 n-1。每次计算四个数的和，并进行如下操作：

   • ​ 如果和等于 target，则将枚举到的四个数加到答案中，然后将左指针右移直到遇到不同的数，将右指针左移直到遇到不同的数；

   • ​ 如果和小于target，则将左指针右移一位；

   • ​ 如果和大于target，则将右指针左移一位。

根据以上思想，可以将四数之和扩展到n数之和，从而得到一种普适性的算法解法。

​ 首先，可以构造一个函数NSum(vector<int>& nums, long n, long start, long target) 来作为接口，nums表示数组，n表示数字的个数， start表示数组中开始计数的下标， target表示目标数值。

​ 在函数中，先对数组进行从小到大的排序，利用递归的思想，结束的条件是：n==2

​ 在n==2的情况下，就是用最朴素的二数之和的思想，设置left, right两个指针，寻找等于target的数组项；

​ 在n>2的情况下，利用一层循环，从start开始，从数组中提取出一项nums[i]，寻找剩下的数组中的n-1数之和等于target-nums[i]的数组项，并将函数返回的数组项与nums[i]合并后统一返回。

代码：

​ 首先是NSum函数：

vector<vector<int>> NSum(vector<int>& nums, long n, long start, long target){
        sort(nums.begin(),nums.end());//对数组进行升序排序
        vector<vector<int>> res;
        if(nums.size()<n||n<2){//排除边界情况
            return res;
        }
        if(n==2){//递归结束条件：数n==2
            int l=start,r=nums.size()-1;//设置左右指针
            while(l<r){
                long low=nums[l],high=nums[r],sum=low+high;
                if(sum<target){//二数之和小于目标数值，左指针右移
                    while(l<r&&nums[l]==low){
                        l++;
                    }
                }
                else if(sum>target){//二数之和大于目标数值，右指针左移
                    while(l<r&&nums[r]==high){
                        r--;
                    }
                }
                else{二数之和等于目标数值，将数组项存入结果，并移动指针
                    res.push_back({nums[l],nums[r]});
                    while(l<r&&nums[l]==low){
                        l++;
                    }
                    while(l<r&&nums[r]==high){
                        r--;
                    }
                }
            }
        }
        else{//n>2，进行递归操作
            for(int i=start;i<nums.size();i++){//遍历数组中的每一项，寻找n-1个数组项之和等于target-nums[i]
                vector<vector<int>> tmp=NSum(nums, n-1, i+1, target-nums[i]);
                for(auto it:tmp){
                    vector<int> newelm=it;
                    newelm.push_back(nums[i]);//合并数组项至同一个容器中
                    res.push_back(newelm);
                }
                while(i<nums.size()-1&&nums[i]==nums[i+1]){i++;}//循环排除掉数值相同的项
            }
        }
        return res;//返回结果
    }

​ 四数之和：

//直接调用上述的函数接口，得到四数之和
vector<vector<int>> fourSum(vector<int>& nums, int target) {
        return NSum(nums, (long)4, (long)0, (long)target);
    }

另：由于奇怪的测试用例**[1000000000,1000000000,1000000000,1000000000] -294967296**，所以在编写函数的时候把int类型修改成了long，才能够执行通过