Leetcode 3Sum Closest和4Sum问题

这两道问题都是15题3Sum的变式，可以通过套用3Sum的方法做出来，不过运行的速度不是很快，需要进一步优化，在这里说一下可以优化的情况，如果不知道3Sum题的做法的话，可以看下我上一篇博客，在这里附上链接：Leetcode 15.3Sum

16. 3Sum Closest

题目描述

Given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

Example:

Given array nums = [-1, 2, 1, -4], and target = 1.

The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

题意

给出一组无序序列和一个target，从序列中选出三个元素相加，求与target最相近的值。

一般做法

与3Sum题的做法一致，只不过是判断条件变了
这里附上代码：

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        //与target的最小差
        int cha=Integer.MAX_VALUE;
        int ans=0;
        for (int i=0;i<nums.length-2;i++)
        {
            if(i>0&&nums[i]==nums[i-1]) continue;
            int left=i+1,right=nums.length-1;
            while(left<right)
            {
                int x=nums[i]+nums[left]+nums[right];
                if(cha>Math.abs(x-target))
                {
                    cha=Math.abs(x-target);
                    ans=x;
                }
                if(x==target)
                {
                    ans=target;
                    break;
                }
                else if(x>target)
                {
                    right--;
                }
                else
                {
                    left++;
                }
                
            }
            if(ans==target) break;
        }
        return ans;
    }
}

运行速度上只是超过了61%的提交。

一般做法的优化

上面的代码其实可以进一步优化，向搜索中的剪枝一样，把不必要的搜寻去掉。
当我们确定了第一个元素a的值后，我们可以将剩余序列中最大的两个数取出来(也就是排序后序列的最后两个数字)，将这三个数字相加，如果这三个数字相加的值小于target的值，那么就没有必要执行下面的代码了(因为这三个数相加是这一层的最优情况)。如果等于，相当于找到了题目的最优解，那么就可以直接返回值了。
加上上面的两条判断语句，发现运行速度已经超过了99%的用户了。
下面是加上优化的代码：

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int cha=Integer.MAX_VALUE;
        int ans=0;
        for (int i=0;i<nums.length-2;i++)
        {
            if(i>0&&nums[i]==nums[i-1]) continue;
            int left=i+1,right=nums.length-1;
            int tar_cha=target-nums[i];
            int Max=nums[i]+nums[nums.length-1]+nums[nums.length-2];
            //两条优化
            if(Max==target)
            {
                ans=target;
                break;
            }
            else if(Max<target)
            {
                if(cha>target-Max)
                {
                    cha=target-Max;
                    ans=Max;
                }
                continue;
            }
            while(left<right)
            {
                int x=nums[i]+nums[left]+nums[right];
                if(cha>Math.abs(x-target))
                {
                    cha=Math.abs(x-target);
                    ans=x;
                }
                if(x==target)
                {
                    ans=target;
                    break;
                }
                else if(x>target) right--;
                else left++;
                
            }
            if(ans==target) break;
        }
        return ans;
    }
}

18. 4Sum

题目描述

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 duplicate quadruplets.

Example:

Given array nums = [1, 0, -1, 0, -2, 2], and target = 0.

A solution set is:
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]

题意

给出一个序列，找出序列中能使a+b+c+d=target的所有元素

一般做法

只是在3Sum上多了一个数，也就多了一层循环，选取a和b，找c+d=target-a-b,时间复杂度为n^3
运行速度只超过了56%的用户
代码如下：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        Arrays.sort(nums);
        for (int i=0;i<nums.length-3;i++)
        {
            if(i>0&&nums[i]==nums[i-1]) continue;
            for (int j=i+1;j<nums.length-2;j++)
            {
                if(target>0&&nums[i]+nums[j]>target) break;
                if(j>i+1&&nums[j]==nums[j-1]) continue;
                int tar_cha = target-nums[j]-nums[i];
                int left=j+1,right=nums.length-1;
                while(left<right)
                {
                    int x = nums[left]+nums[right];
                    if(x==tar_cha)
                    {
                        list.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        left++;right--;
                        while(left<right&&nums[left]==nums[left-1]) left++;
                        while(left<right&&nums[right]==nums[right+1]) right--;
                    }
                    else if(x>tar_cha) right--;
                    else left++;
                }
            }
        }
        return list;
    }
}

一般做法的优化

1.在选完第一个数a后，如果a+nums中的最后一个数3小于target的话，直接continue执行下一层
2.在选完第一个数a后，当4a大于target的话，直接跳出循环
3.选完a和b后，如果a+b+nums最后一个数2小于target，直接continue执行下一层
4.选完a和b后，如果a+3b大于target，直接跳出循环
代码如下：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        Arrays.sort(nums);
        for (int i=0;i<nums.length-3;i++)
        {
            if(i>0&&nums[i]==nums[i-1]) continue;
            // 1,2条判断规则
            if(nums[i]+3*nums[nums.length-1]<target) continue;
            if(nums[i]*4>target) break;
            for (int j=i+1;j<nums.length-2;j++)
            {
                if(j>i+1&&nums[j]==nums[j-1]) continue;
                //3,4条判断规则
                if(nums[i]+nums[j]+nums[nums.length-1]*2<target) continue;
                if(nums[i]+nums[j]*3>target) break;
                int tar_cha = target-nums[j]-nums[i];
                int left=j+1,right=nums.length-1;
                while(left<right)
                {
                    int x = nums[left]+nums[right];
                    if(x==tar_cha)
                    {
                        list.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        left++;right--;
                        while(left<right&&nums[left]==nums[left-1]) left++;
                        while(left<right&&nums[right]==nums[right+1]) right--;
                    }
                    else if(x>tar_cha) right--;
                    else left++;
                }
            }
        }
        return list;
    }
}

运行速度超过了99%的用户。