LeetCode medium 18.四数之和

题目描述：

给你一个由 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
• -109 <= nums[i] <= 109
• -109 <= target <= 109

思路：
将复杂的问题转化为小些的问题，和三数之和的解法类似，较难的是需要思考如何去掉重复的。先用一层for将四数之和转化为三数之和问题，再一层for循环转化为两数之和问题；
另需要注意的是要考虑极端的测试用例，如:

输入： [0,0,0,1000000000,1000000000,1000000000,1000000000]
1000000000

或

[0,0,0,-1000000000,-1000000000,-1000000000,-1000000000]
-1000000000

容易溢出。

class Solution {
     public List<List<Integer>> fourSum(int[] nums, int target) {
         int length = nums.length;
         List<List<Integer>> res = new ArrayList<List<Integer>>();
         if (nums == null || length < 4)
             return res;
         Arrays.sort(nums);//排序升序


         for (int i = 0; i < length - 3; i++) {
             //避免重复
             if (i > 0 && nums[i] == nums[i-1]) continue;

             //从i开始的连续四个数和大于target，则之后的遍历一定大于target，所以不用继续遍历，跳出循环
             //nums[i] + nums[i+1] + nums[i+2] + nums[i+3]的写法会溢出
             if (nums[i] + nums[i+1] > target - nums[i+3] -nums[i+2]) break;

             //i与最后三个数(即最大的3个数)和已经小于target，则内层循环后结果一定小于target，所以不必继续此轮循环
             if (nums[i] + nums[length-1] < target - nums[length-2] - nums[length-3]) continue;//同样注意避免溢出

             int threeSum = target - nums[i];//剩下三数之和
             for (int j = i + 1; j < length - 2; j++){
                 //和i层循环同理
                 if (j > i + 1 && nums[j] == nums[j-1]) continue;
                 if(nums[j] + nums[j+1] > threeSum - nums[j+2]) break;
                 if(nums[j] + nums[length-1] < threeSum - nums[length-2]) continue;

                 int left = j + 1;
                 int right = length - 1;
                 int twoSum = threeSum - nums[j];//剩下两数之和
                 //双指针
                 while (left < right) {
                     if (nums[left] + nums[right] == twoSum) {
                         res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                         while (left < right && nums[left] == nums[left+1])
                             left++;//避免重复
                         while (left < right && nums[right] == nums[right-1])
                             right--;//避免重复
                         left++;
                         right--;
                     } else if (nums[left] + nums[right] < twoSum) {
                         left++;//比twoSum小，右移left以增大和
                     } else {
                         right--;
                     }
                 }//while
             }//for(j)
         }//for(i)
         return res;
     }//fourSum()
 }//class Solution

时间复杂度：O(n^3)
空间复杂度：O(log n)