leetcode 4sum java_[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> ret = new ArrayList>();

public ArrayList> fourSum(int[] nums, int target)

{

int newtarget=0;

ArrayList> finalres = new ArrayList>();

Arrays.sort(nums);

for (int i = 0; i < nums.length; i++)

{

ArrayList> temlist= new ArrayList>();

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

inputnums[ii]=nums[ii+1+i];//每次选取该元素后面的数组作为《3sum》算法的输入数组

temlist=threeSum(inputnums,newtarget,nums[i]);

finalres.addAll(temlist);

ret.clear();

}

return finalres;

}

public static ArrayList> 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 ans = new ArrayList();

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--;

}

}

}