3Sum & 4Sum

3 Sum

Given an array S of n integers, are there elements a, b, c in Ssuch that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Notice

Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)

The solution set must not contain duplicate triplets.

Example

For example, given array S = {-1 0 1 2 -1 -4}, A solution set is:

(-1, 0, 1)
(-1, -1, 2)

分析：

这题还是很简单的，使用3个指针即可解决问题。关键是里面重复数字的处理需要当心。

 public class Solution {
     /**
      * @param numbers : Give an array numbers of n integer
      * @return : Find all unique triplets in the array which gives the sum of zero.
      */
     public ArrayList<ArrayList<Integer>> threeSum(int[] num) {
         ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
         if(num == null || num.length < ) {
             return rst;
         }
         Arrays.sort(num);
         for (int i = ; i < num.length - ; i++) {
13             if (i != 0 && num[i] == num[i - 1]) {
14                 continue; // to skip duplicate numbers; e.g [0,0,0,0]
15             }

             int left = i + ;
             int right = num.length - ;
             while (left < right) {
                 int sum = num[left] + num[right] + num[i];
                 if (sum == ) {
                     ArrayList<Integer> tmp = new ArrayList<Integer>();
                     tmp.add(num[i]);
                     tmp.add(num[left]);
                     tmp.add(num[right]);
                     rst.add(tmp);
                     left++;
                     right--;
                     while (left < right && num[left] == num[left - 1]) { // to skip duplicates
30                         left++;
31                     }
32                     while (left < right && num[right] == num[right + 1]) { // to skip duplicates
33                         right--;
34                     }
                 } else if (sum < ) {
                     left++;
                 } else {
                     right--;
                 }
             }
         }
         return rst;
     }
 }

4Sum

Given an array S of n integers, are there elements a, b, c, andd in S such that a + b + c + d = target?

Find all unique quadruplets in the array which gives the sum of target.

Notice

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.

 

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)

分析：原理同上

 public class Solution {
     /**
      * @param numbers : Give an array numbersbers of n integer
      * @param target : you need to find four elements that's sum of target
      * @return : Find all unique quadruplets in the array which gives the sum of
      *           zero.
      */
     public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
         ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
         if(num == null || num.length < ) {
             return rst;
         }
         Arrays.sort(num);
         for (int i = ; i <= num.length - ; i++) {
             if (i !=  && num[i] == num[i - ]) {
                 continue; // to skip duplicate numbers; e.g [0,0,0,0]
             }
             for (int j = i + ; j <= num.length - ; j++) {
                 if (j != i +  && num[j] == num[j - ]) {
                     continue; // to skip duplicate numbers; e.g [0,0,0,0]
                 }
                 int left = j + ;
                 int right = num.length - ;
                 while (left < right) {
                     int sum = num[left] + num[right] + num[i] + num[j] - target;
                     if (sum == ) {
                         ArrayList<Integer> tmp = new ArrayList<Integer>();
                         tmp.add(num[i]);
                         tmp.add(num[j]);
                         tmp.add(num[left]);
                         tmp.add(num[right]);
                         rst.add(tmp);
                         left++;
                         right--;
                         while (left < right && num[left] == num[left - ]) { // to skip duplicates
                             left++;
                         }
                         while (left < right && num[right] == num[right + ]) { // to skip duplicates
                             right--;
                         }
                     } else if (sum < ) {
                         left++;
                     } else {
                         right--;
                     }
                 }
             }

         }
         return rst;
     }
 }

转载请注明出处: cnblogs.com/beiyeqingteng/