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)

【解析】

3Sum 和 3Sum Closest 的扩展，同样思路，加强理解。

K Sum 问题的时间复杂度好像为 O(n^(k-1)) ？！如果有更好的，欢迎指教！

【Java代码】

[java]  view plain  copy

1. public class Solution {  
2.     List<List<Integer>> ret = new ArrayList<List<Integer>>();  
3.       
4.     public List<List<Integer>> fourSum(int[] num, int target) {  
5.         if (num == null || num.length < 4) return ret;  
6.         Arrays.sort(num);  
7.         int len = num.length;  
8.         for (int i = 0; i < len-3; i++) {  
9.             if (i > 0 && num[i] == num[i-1]) continue;  
10.             for (int j = i+1; j < len-2; j++) {  
11.                 if (j > i+1 && num[j] == num[j-1]) continue;  
12.                 findTwo(num, j+1, len-1, target, num[i], num[j]);  
13.             }  
14.         }  
15.         return ret;  
16.     }  
17.       
18.     public void findTwo(int[] num, int begin, int end, int target, int a, int b) {  
19.         if (begin < 0 || end >= num.length) return;  
20.         int l = begin, r = end;  
21.         while (l < r) {  
22.             if (a+b+num[l]+num[r] < target) {  
23.                 l++;  
24.             } else if (a+b+num[l]+num[r] > target) {  
25.                 r--;  
26.             } else {  
27.                 List<Integer> ans = new ArrayList<Integer>();  
28.                 ans.add(a);  
29.                 ans.add(b);  
30.                 ans.add(num[l]);  
31.                 ans.add(num[r]);  
32.                 ret.add(ans);  
33.                 l++;  
34.                 r--;  
35.                 while (l < r && num[l] == num[l-1]) l++;  
36.                 while (l < r && num[r] == num[r+1]) r--;  
37.             }  
38.         }  
39.     }  
40. }