[leetcode]4Sum

这道4Sum，如果用3Sum类似的方法，是O(n^3)的复杂度。现在使用O(n^2)的空间呢，能达到O(n^2)的时间复杂度。但实现起来坑还是不少，一是要去重，用了string来表示集合的key；二是不能同一个索引位置的数（num[i]）出现两次，所以要做下标的检查；三是当左右相加等于target的时候，现在不能直接跳过大小一样的，因为同样大小的可能是a+b也可能是c+d，就要l++和r--递归来做。但用递归有可能爆栈（Runtime Error），就用了Stack来模拟递归。最终Java 1472ms过。

后来参考方勤的版本，如果用map来存sum=>pair，在只求解（而非全部解）的情况下，可以O(n^2)写得更简洁。

import java.util.*;

public class Solution {

    private ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();

    private HashSet<String> ansSet = new HashSet<String>();

    private HashSet<String> posSet = new HashSet<String>();

    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {

        ans.clear();

        ansSet.clear();

        posSet.clear();

        Arrays.sort(num);

        int len = num.length;

        ArrayList<Pair> pairs = new ArrayList<Pair>();

        for (int i = 0; i < len; i++)

        {

            for (int j = i+1; j < len; j++)

            {

                pairs.add(new Pair(num[i], num[j], i, j));

            }

        }

        Collections.sort(pairs);

        Stack<Integer> stack = new Stack<Integer>();

        stack.push(0); stack.push(pairs.size()-1);

        while (!stack.empty())

        {

            int r = stack.pop();

            int l = stack.pop();

            if (l >= r) continue;

            String posKey = "" + l + "_" + r;

            if (posSet.contains(posKey)) continue;

            else posSet.add(posKey);

            int sum = pairs.get(l).sum + pairs.get(r).sum;

            if (sum < target)

            {

                stack.push(l+1);

                stack.push(r);

            }

            else if (sum > target)

            {

                stack.push(l);

                stack.push(r-1);

            }

            else // ==

            {

                if (pairs.get(l).aIdx != pairs.get(r).aIdx &&

                    pairs.get(l).aIdx != pairs.get(r).bIdx &&

                    pairs.get(l).bIdx != pairs.get(r).aIdx &&

                    pairs.get(l).bIdx != pairs.get(r).bIdx)

                {

                    // add to result;

                    ArrayList<Integer> arr = new ArrayList<Integer>();

                    arr.add(pairs.get(l).a);

                    arr.add(pairs.get(l).b);

                    arr.add(pairs.get(r).a);

                    arr.add(pairs.get(r).b);

                    Collections.sort(arr);

                    String key = "";

                    for (int k = 0; k < 4; k++)

                    {

                        key = key + arr.get(k) + "_";

                    }

                    if (!ansSet.contains(key))

                    {

                        ansSet.add(key);

                        ans.add(arr);

                    }

                }     

                stack.push(l);

                stack.push(r-1);

                stack.push(l+1);

                stack.push(r);

            }

        }

        return ans;

    }

}



class Pair implements Comparable<Pair>

{

    int a;

    int b;

    int sum;

    int aIdx;

    int bIdx;

    

    public Pair (int a, int b, int aIdx, int bIdx)

    {

        this.a = a;

        this.b = b;

        this.sum = a + b;

        this.aIdx = aIdx;

        this.bIdx = bIdx;

    }

    

    public int compareTo(Pair that)

    {

        return this.sum - that.sum;

    }

}