3Sum

https://oj.leetcode.com/problems/3sum/

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

Note:

• 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.

 

    For example, given array S = {-1 0 1 2 -1 -4},

    A solution set is:
    (-1, 0, 1)
    (-1, -1, 2)

解题思路：

三个加数，首先想到排序，快排花费时间O(n*logn)。然后想到从头和尾各确定一个数字，在他们中间用二分法找第三个加数。时间复杂度O(n*logn + n^2 * logn)，超时。

于是想到，由之前的two sum那道题，已知一个加数，求另一个加数，很容易想到用hashmap，在O(n)的时间内求解。这样就可以省去找第三个数字的对数时间。将时间复杂度减少到O(n^2)。

public class Solution {
    public List<List<Integer>> threeSum(int[] num) {
        Arrays.sort(num);
        
        HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();
        
        for(int i = 0; i < num.length; i++){
            hashMap.put(num[i], i);
        }
        
        Set<Integer> leftSet = new HashSet<Integer>();
        Set<Integer> rightSet = new HashSet<Integer>();
        
        List<List<Integer>> resultList = new ArrayList<List<Integer>>();
        for(int i = 0; i < num.length / 2; i++){
            for(int j = num.length - 1; j > i; j--){
                int left = 0 - num[i] - num[j];
                //用二分法查找第三个元素，超时
                // int start = i + 1;
                // int end = j - 1;
                // while(start <= end){
                //     int mid = (start + end) / 2;
                //     if(num[mid] > left){
                //         end = mid - 1;
                //     }
                //     if(num[mid] < left){
                //         start = mid + 1;
                //     }
                //     if(num[mid] == left){
                //         List<Integer> list = new ArrayList<Integer>();
                //         list.add(num[i]);
                //         list.add(num[mid]);
                //         list.add(num[j]);
                //         resultList.add(list);
                //         break;
                //     }
                // }
                
                //用hashmap查找第三个元素
                if(hashMap.containsKey(left) && hashMap.get(left) != i && hashMap.get(left) != j 
                && !leftSet.contains(num[i]) && !rightSet.contains(num[j])){
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(num[i]);
                    list.add(left);
                    list.add(num[j]);
                    resultList.add(list);
                    leftSet.add(num[i]);
                    rightSet.add(num[j]);
                    // break;
                }
            }
        }
        return resultList;
    }
}

但是这个解法会遇到一个很复杂的问题，HashMap无法确定重复元素的位置。于是重新找思路。

下面是一个可行的解法。和上面的解法思路类似，但是不同。也是先排序，从头至尾遍历数组，只确定一个数num[i]，然后找剩下的两个数。那么这两个数一定在[i + 1, num.length - 1]。如果这三个数字和==0，那么就是解答了，如果>0，证明end--，如果<0，那么start++。这很容易理解。

需要注意的就是去除重复答案的处理过程。第一个遍历加数，如果当前处理数字和前一个相等，也就是num[i] == num[i - 1]，就可以跳过了。因为num[i]已经在[i + 1, num.length - 1]的区间内求解结束了。num[i + 1]和num[i]相等，在后面更小的一个区间内，即使有解，也一定是重复的。

注意这里一定是判断num[i] == num[i - 1]，而不是num[i] == num[i + 1]，因为要和前面已经求过解的元素比较，而不是后面为求解的元素。同理对于start和end的处理。

public class Solution {
    public List<List<Integer>> threeSum(int[] num) {
        Arrays.sort(num);
        
        List<List<Integer>> resultList = new ArrayList<List<Integer>>();
        
        for(int i = 0; i < num.length - 2; i++){
            //必须与前一个数字相比，和已经处理过的数字比，如果重复，就跳过
            if(i > 0 && num[i] == num[i - 1]){
                continue;
            }
            int start = i + 1;
            int end = num.length - 1;
            
            while(start < end){
                if(start > i + 1 && num[start] == num[start - 1]){
                    start++;
                    continue;
                }
                if(end < num.length - 1 && num[end] == num[end + 1]){
                    end--;
                    continue;
                }
                if(num[i] + num[start] + num[end] == 0){
                    List list = new ArrayList();
                    list.add(num[i]);
                    list.add(num[start]);
                    list.add(num[end]);
                    resultList.add(list);
                    start++;
                    end--;
                }else if(num[i] + num[start] + num[end] > 0){
                    end--;
                }else if(num[i] + num[start] + num[end] < 0){
                    start++;
                }
            }
        }
        return resultList;
    }
}

 由上面的解法我们可以知道，对于一个已经排序的数组，找两个sum确定的数字，是一个在O(n)的时间内求解的。