#18：四数之和_if(nums[i]=nums[i-1]){continue}-CSDN博客

本文链接：https://blog.csdn.net/weixin_44065652/article/details/121143771

该博客讨论了如何在给定整数数组中找到和为目标值的不重复四元组。提供了两种方法，一种是排序加双指针的高效算法，另一种是三重循环的解决方案，但可能会导致时间超时。主要涉及数组操作、排序、双指针和循环优化等概念。

摘要由CSDN通过智能技术生成

给一个由 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]]

方法一：排序 + 双指针

class Solution{
    public List<List<Integer>> fourSum(int[] nums,int target){
        List<List<Integer>> quadruplets=new ArrayList<List<Integer>>();
        if(nums==null || nums.length<4){
            return quadruplets;
        }

        Arrays.sort(nums);
        int length=nums.length;

        for(int i=0;i<length-3;i++){
            if(i>0 && nums[i]==nums[i-1]){
                continue;//数一样得出相同结果，跳出本次循环
            }
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target){
                break;//
            }
            if(nums[i]+nums[length-3]+nums[length-2]+nums[length-1]<target){
                continue;//和最大的比较，小于跳出本次循环，i+1
            }

            for(int j=i+1;j<length-2;j++){
                if(j>i+1 && nums[j]==nums[j-1]){
                    continue;
                }
                if(nums[i]+nums[j]+nums[j+1]+nums[j+2]>target){
                    break;
                }
                if(nums[i]+nums[j]+nums[j+1]+nums[j+2]>target){
                    continue;
                }

                int left=j+1,right=length-1;
                while(left<right){
                    int sum=nums[i]+nums[j]+nums[left]+nums[right];
                    if(sum==target){
                        quadruplets.add(Arrays.asList(nums[i]，nums[j],nums[left],nums[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){
                        left++;
                    }else{
                        right--
                    }
                }
            }
        }
        return quadruplets;
    }
}

三重循环（时间超时）

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> four=new ArrayList<>();
        int len=nums.length;
        
        if(len<=3){
            return four;
        }
        for(int i=0;i<len;i++){
            for(int j=i+1;j<len;j++){
                for(int k=j+1;k<len;k++){
                    for(int m=k+1;m<len;m++){
                        if(nums[i]+nums[j]+nums[k]+nums[m]==target){
                           
                            List<Integer> one=new ArrayList<>();
                            one.add(nums[i]);
                            one.add(nums[j]);
                            one.add(nums[k]);
                            one.add(nums[m]);
                            Collections.sort(one);
                            if(!four.contains(one)){
                                four.add(one);
                            }
                        }
                    }            
               }
            }
        }
        return four;        
    }
}