[leetcode]4Sum

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)

思路1：
与之前的[leetcode]3Sum类似，加一层外部循环，时间复杂度为O(n ^ 3)
代码如下：

public class Solution {
    public List<List<Integer>> fourSum(int[] num, int target) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(num == null || num.length < 4) return result;
        int length = num.length;
        Arrays.sort(num);
        for (int i = 0; i < length - 3; i++) {
            if(i > 0 && num[i] == num[i - 1])continue;
            int one = i;
            for (int j = i + 1; j < length - 2; j++) {
                if(j > i + 1 && num[j] == num[j - 1])continue;
                int two = j;
                int three = j + 1;
                int four = length - 1;
                while (three < four) {
                    int sum = num[one] + num[two] + num[three] + num[four];
                    if(sum < target) three++;
                    else if(sum > target) four--;
                    else{
                        List<Integer> list = new ArrayList<Integer>();
                        list.add(num[one]);
                        list.add(num[two]);
                        list.add(num[three]);
                        list.add(num[four]);
                        result.add(list);
                        three++;
                        four--;
                    while(three < four && num[three] == num[three-1]) three++;
                        while(three < four &&num[four] == num[four+1]) four--;
                    }
                }
            }
        }
        return result;
    }
}

【吐槽】第一次做这道题的时候，怎么也想不到O(n ^ 3)居然能过，绞尽乳汁【(⊙o⊙)好邪恶】想怎么才能把时间复杂度压缩到O(n ^ 2)，我相信面试的时候要求肯定也是O(n^2)，因此查了网上的一些大神的思路，对本题做了进一步的优化

思路2:

1. 计算出数组中两两元素的和，把这种二度元素成为nodeOfTwo（学过排列组合的话，应该可以想象到这个数有多大，没办法，空间换时间吧）

2. 对每一个nodeOfTwo元素进行遍历，类似于求[leetcode]Two Sum

2.1 如果存在两个nodeOfTwo元素的和为target，即找到了满足条件的四个元素。

2.2 nodeOfTwo的value毫无疑问是一个list

疑问：

1. 如何去除相同元素？对于nodeOfTwo - 3【何为3的元素对组合】中可能包含两对或以上（0,3）

2. 如何去除重复元素？对于不同的nodeOfTwo节点的组合，还可能有重复，例如nodeOfTwo - 1 和nodeOfTwo - 4包含一个组合（0，1，1，3）但是nodeOfTwo - 3 和nodeOfTwo - 2 中可能包含（0,3,1,1）事实上是重复元素。

代码如下：

public List<List<Integer>> fourSum(int[] num, int target) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(num == null || num.length < 4) return result;
        int length = num.length;
        Arrays.sort(num);
        Map<Integer,List<int[]>> hash = new HashMap<Integer,List<int[]>>();
        for(int i = 0; i < length - 1;i++){
            for(int j = i + 1; j < length; j++){
                int sum = num[i] + num[j];
                if(hash.get(sum) == null){
                    List<int[]> list = new ArrayList<int[]>();
                    list.add(new int[]{i,j});
                    hash.put(sum, list);
                }else{
                    hash.get(sum).add(new int[]{i,j});
                }
            }
        }
        for(int nodeOfTwo : hash.keySet()){
            if(hash.containsKey(target - nodeOfTwo)){
                for(int[] oneAndTwo : hash.get(nodeOfTwo)){
                    for(int[] threeAndFour : hash.get(target - nodeOfTwo)){
                        if(oneAndTwo[0] == threeAndFour[0] || oneAndTwo[0] == threeAndFour[1] || oneAndTwo[1] == threeAndFour[0] || oneAndTwo[1] == threeAndFour[1] )continue;//去除重复元素
                        int[] node = {num[oneAndTwo[0]],num[oneAndTwo[1]],num[threeAndFour[0]],num[threeAndFour[1]]};
                        Arrays.sort(node);
                        boolean exist = false;
                        for(List<Integer> tem : result){//去除相同元素
                            int count = 0;
                            for(int i = 0; i < 4; i++){
                                if(node[i] == tem.get(i))count++;
                            }
                            if(count == 4) exist = true;
                        }
                        if(!exist) {
                            List<Integer> list = new ArrayList<Integer>();
                            for(int i = 0; i < 4; list.add(node[i++]));
                            result.add(list);
                        }
                    }
                }
            }
        }
        return result;
    }

【吐槽】代码还是太丑了，哎，不过与之前的相比还是稍微好点的，慎重点击->[leetcode]4Sum