Leetcode-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)

Have you met this question in a real interview?

 

Analysis:

 

Solution:

public class Solution {
    public List<List<Integer>> threeSum(int[] num) {
        List<List<Integer>> resList = new ArrayList<List<Integer>>();
        if (num.length<3) return resList;        

        Arrays.sort(num);
        Map<Integer,Integer> numMap = new HashMap<Integer,Integer>();
        for (int i=0;i<num.length;i++)
            if (numMap.containsKey(num[i]))
                numMap.put(num[i],numMap.get(num[i])+1);
            else numMap.put(num[i],1);

        int first = 0;
        int second = -1;
        while (first<num.length-2){            
            numMap.put(num[first],numMap.get(num[first])-1);
            second = first+1;
            while (second<num.length-1){
                numMap.put(num[second],numMap.get(num[second])-1);
                int left = 0-num[first]-num[second];
                if (left>=num[second] && numMap.containsKey(left) && numMap.get(left)>0){
                    List<Integer> temp = new LinkedList<Integer>();
                    temp.add(num[first]);
                    temp.add(num[second]);
                    temp.add(left);
                    resList.add(temp);
                }
                numMap.put(num[second],numMap.get(num[second])+1);
                if (left<num[second]) break;
                while (second< num.length-1 && num[second]==num[second+1]) second++;
                second++;
            }
            numMap.put(num[first],numMap.get(num[first])+1);
            while (first<num.length-2 && num[first]==num[first+1]) first++;
            first++;

        }

        return resList;       
    }
}

 NOTE: There is a way to solve this problem without using hashmap. Practice it!

Solution2: Two pointers.

The key point here is that:

if p1+p2+p3==0, then p2++ and p3--.

public class Solution {
    public List<List<Integer>> threeSum(int[] num) {
       List<List<Integer>> res = new ArrayList<List<Integer>>();
       if (num.length<3) return res;
       Arrays.sort(num);
    
       
 
       //Find each solution.
       int p1 = 0;
       int p2,p3;
       while (p1<num.length-2 && num[p1]<=0){
           p2 = p1+1;
           p3 = num.length-1;
           while (p2<p3 && -num[p1]-num[p2]>=num[p2]){
               int sum = num[p1]+num[p2]+num[p3];
               if (sum==0){
                   List<Integer> sol = new ArrayList<Integer>();
                   sol.add(num[p1]);
                   sol.add(num[p2]);
                   sol.add(num[p3]);
                   res.add(sol);
               }

               if (sum<=0){
                   p2++;
                   while (p2<p3 && num[p2]==num[p2-1]) p2++;
               } 

               if (sum>=0){
                   p3--;
                   while (p2<p3 && num[p3]==num[p3+1]) p3--;
               }
          }          
          p1++;
          while (p1<num.length-2 && num[p1]==num[p1-1]) p1++;
       }

       return res;
        
    }
}