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

思路：排序 + 双指针。

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int>> result;
        if (num.size() < 4) return result;
        sort(num.begin(), num.end());
        for (int i = 0; i < (int)num.size() - 3; ++i) {
            if (i > 0 && num[i] == num[i-1]) continue;   //avoid duplicate num[i]
            for (int j = i + 1; j < num.size(); ++j) {
                if (j > i + 1 && num[j] == num[j-1]) continue;   //avoid duplicate num[j]
                int start = j + 1;
                int end = (int)num.size() - 1;
                while (start < end) {
                    int current_sum = num[i] + num[j] + num[start] + num[end];
                    if (current_sum == target) {   //find target, add to the result
                        vector<int> new_result;
                        new_result.push_back(num[i]);
                        new_result.push_back(num[j]);
                        new_result.push_back(num[start]);
                        new_result.push_back(num[end]);
                        result.push_back(new_result);
                        do {   //move start to next different value
                            start++;
                        } while (start < end && num[start] == num[start-1]);
                        do {   //move end to next different value
                            end--;
                        } while (end > start && num[end] == num[end+1]);
                    } else if (current_sum < target) {
                        start++;
                    } else {
                        end--;
                    }
                }
            }
        }
        return result;
    }
};

总结：避免重复: i每次递增到一个新的num[i]值为止；j每次递增到一个新的num[j]值为止；start end 递增到一个新的num[start] num[end]值为止。复杂度O(n^3)，brute force复杂度O(n^4).