[LeetCode][Java] 4Sum

题目：

Given an array S of n integers, are there elements a, b, c, and d in S such
that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note:

• Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ≤ b ≤ c ≤ d)
• The solution set must not contain duplicate quadruplets.

    For example, given array S = {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)

题意：

给定一个包括n个整数的数组S,在数组S中是否存在元素a,b,c和d,使得 a + b + c + d =
target.找出数组S中全部这种组合。

注意：

1.这四个元素必须是升序排列(ie, a ≤ b ≤ c ≤ d)

2.终于结果中不嫩包括反复的解。

    For example, given array S = {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)

算法分析：

* 利用了题目《3Sum》的代码 https://leetcode.com/problems/3sum/

 * 首先升序排列数组，然后从第一个元素開始依次遍历《3Sum》算法，目标值为（target-nums[i]）,遍历的数组为该元素后面的数组

 * 这样既满足终于的arraylist中元素升序排列，也不会出现反复。由于每次以其为開始。进行遍历的元素都是数组中的最小的元素

AC代码：

public class Solution
{
    private static ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();

    public ArrayList<ArrayList<Integer>> fourSum(int[] nums, int target)
    {
        int newtarget=0;

        ArrayList<ArrayList<Integer>> finalres = new ArrayList<ArrayList<Integer>>();
        Arrays.sort(nums);
    	for (int i = 0; i < nums.length; i++)
        {
    		 ArrayList<ArrayList<Integer>> temlist= new ArrayList<ArrayList<Integer>>();
    		if (i > 0 && nums[i] == nums[i-1]) continue;//避免结果反复，其后面和它相等的直接被跳过。
            newtarget=target-nums[i];
            int inputnums[]=new int[nums.length -i-1];
            for(int ii=0;ii<nums.length -i-1;ii++)
            	inputnums[ii]=nums[ii+1+i];//每次选取该元素后面的数组作为《3sum》算法的输入数组
            temlist=threeSum(inputnums,newtarget,nums[i]);

            finalres.addAll(temlist);
            ret.clear();
        }
		return finalres;

    }
    public static ArrayList<ArrayList<Integer>> threeSum(int[] num,int newtarget,int firstnum)
    {
        if (num == null || num.length < 3) return ret;

        Arrays.sort(num);

        int len = num.length;
        for (int i = 0; i < len-2; i++)
        {
            if (i > 0 && num[i] == num[i-1]) continue;//避免结果反复，其后面和它相等的直接被跳过。
            find(num, i+1, len-1, num[i],newtarget, firstnum); //寻找两个数与num[i]的和为0
        }

        return ret;
    }

    public static void find(int[] num, int begin, int end, int target,int newtarget,int firstnum)
    {
        int l = begin, r = end;
        while (l < r)
        {
            if (num[l] + num[r] + target == newtarget)
            {
                ArrayList<Integer> ans = new ArrayList<Integer>();
                ans.add(firstnum);//与原始的《3Sum》算法不同的地方为:记得把每次的启发遍历元素增加进去。就是4个数中的最小的那一个
                ans.add(target);
                ans.add(num[l]);
                ans.add(num[r]);
                ret.add(ans); //放入结果集中
                while (l < r && num[l] == num[l+1]) l++;//避免结果反复，其后面和它相等的直接被跳过。
                while (l < r && num[r] == num[r-1]) r--;////避免结果反复，其后面和它相等的直接被跳过。
                l++;
                r--;
            }
            else if (num[l] + num[r] + target < newtarget)
                l++;
            else
                r--;
        }
    }
}