leetcode 18:四数之和

leetcode 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

Related Topics

数组

双指针

排序

排序+双指针

首先把数组排序。

1. 根据循环选择第一个，注意重复的数只能选取一次。
2. 根据循环选择第二个数，注意重复的数只能选取一次。
3. 根据双指针遍历后面的范围选取最后2个数。
   1. 如果这四个数的和等于target，添加到结果集中，需要去除掉重复的left和right的数。
   2. 如果大于target，需要将right–
   3. 如果小于target，需要将left++

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        int len = nums.length;
        List<List<Integer>> lists = new ArrayList<>();
        //选择第一个数
        for(int i = 0 ; i < len-3;i++){
            //重复的数不选取
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            //因为是有序的 如果连续的四个数加起来和大于target 那么升序的所有数都没有可能
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target){
                break;
            }
            //如果当前数 和最后三个数的和都小于target 那么当前数无法构成
            if(nums[i]+nums[len-3]+nums[len-2]+nums[len-1] < target){
                continue;
            }

            //选择第二个数
            for(int j = i+1;j<len-2;j++){
                //重复的数不选取
                if(j > i+1 && nums[j] == nums[j-1]){
                    continue;
                }
                //双指针 选取剩下2个数
                int left = j + 1;
                int right = len-1;
                while (left < right){
                    int sum = nums[i]+nums[j] + nums[left] + nums[right];
                    //四数之和刚好符合
                    if(sum == target){
                        lists.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        //去除掉重复的left和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){ //sum太高 right向左移动
                        right--;
                    }else{ //sum太小 left向右移
                        left++;
                    }
                }
            }
        }
        return lists;
    }
}
解答成功:
			执行耗时:14 ms,击败了52.46% 的Java用户
			内存消耗:41.7 MB,击败了38.88% 的Java用户

改进：

优化：

1. 当我们确定第一个数的时候：
   1. 如果从这个位置连续的四个数和大于target，那么后面的所有数的组合都肯定大于target，因为数组是有序的，直接返回结果。
   2. 当我们确定第一个数的时候，如果这个位置的数加上末尾的三个数的和小于target，那么以这个数为起点的所有组合，都不可能。
   3. 注意上述2者的区别，需要分别用break和continue。
2. 当我们确定第二个数时：
   1. 如果这个位置连续的3个数再加上第一个数的和大于target，那么后面的所有数组合都肯定大于target，直接break
   2. 如果这个位置加上第一个元素再加上末尾的2个数的和小于target，说明以第二个数为起点的组合都无法构成，直接continue

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        int len = nums.length;
        List<List<Integer>> lists = new ArrayList<>();
        //选择第一个数
        for(int i = 0 ; i < len-3;i++){
            //重复的数不选取
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            //因为是有序的 如果连续的四个数加起来和大于target 那么升序的所有数都没有可能
            if((long)nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target){
                break;
            }
            //如果当前数 和最后三个数的和都小于target 那么当前数无法构成
            if((long)nums[i]+nums[len-3]+nums[len-2]+nums[len-1] < target){
                continue;
            }

            //选择第二个数
            for(int j = i+1;j<len-2;j++){
                //重复的数不选取
                if(j > i+1 && nums[j] == nums[j-1]){
                    continue;
                }
                //如果从j连续的三个数和i的和大于target  后面的都无法构成
                if((long)nums[i] + nums[j] + nums[j+1]+nums[j+2] > target){
                    break;
                }
                //从j开始 加上末尾的2个数的和小于target 那么也无法构成
                if((long)nums[i]+nums[j] + nums[len-2]+nums[len-1] < target){
                    continue;
                }
                //双指针 选取剩下2个数
                int left = j + 1;
                int right = len-1;
                while (left < right){
                    int sum = nums[i]+nums[j] + nums[left] + nums[right];
                    //四数之和刚好符合
                    if(sum == target){
                        lists.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        //去除掉重复的left和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){ //sum太高 right向左移动
                        right--;
                    }else{ //sum太小 left向右移
                        left++;
                    }
                }
            }
        }
        return lists;
    }
}
解答成功:
			执行耗时:2 ms,击败了100.00% 的Java用户
			内存消耗:41.5 MB,击败了49.89% 的Java用户