leetcode 18 --- 4sum

1  题目

给出一个有n个元素的数组S，S中是否有元素a,b,c和d满足a+b+c+d=目标值？找出数组S中所有满足条件的四元组。

注意：

1. 四元组（a、b、c、d）中的元素必须按非降序排列。（即a≤b≤c≤d）
2. 解集中不能包含重复的四元组。

    例如：给出的数组 S = {1 0 -1 0 -2 2}, 目标值 = 0.↵↵    给出的解集应该是：↵    (-1,  0, 0, 1)↵    (-2, -1, 1, 2)↵    (-2,  0, 0, 2)

2  解法

2.1  我的第一版解法

写思路：

用循环的方法尝试所有的四个数组合。

我的第一版代码：

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > res;
        if (num.size() < 4) {
            return res;
        }
        sort(num.begin(), num.end());
        for (int i = 0; i < num.size() - 3; i++) {
            for (int j = i + 1; j < num.size() - 2; j ++) {
                for (int k = j + 1; k < num.size() - 1; k ++) {
                    for (int n = k + 1; n < num.size(); n ++) {
                        if (num[i] + num[j] + num[k] + num[n] == target) {
                            vector<int> tmp_res = {num[i], num[j], num[k], num[n]};
                            res.push_back(tmp_res);
                        }
                    }
                }
            }
        }
        return res;
    }
};

结果发现过不了：

因为结果中有相同的数组：[-3,0,1,2],[-3,0,1,2]，原因是有多个0实例，第一个[-3,0,1,2]用的一号0,第二个[-3,0,1,2]用的二号0.

2.2  我的第二版解法

思路：

因为先把数组从小到大排序完成了，所以相同的数只用第一个，用完之后执行检查直到下一个不一样的数。

代码：

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > res;
        if (num.size() < 4) {
            return res;
        }
        sort(num.begin(), num.end());
        for (int i = 0; i < num.size() - 3;) {
            for (int j = i + 1; j < num.size() - 2;) {
                for (int k = j + 1; k < num.size() - 1;) {
                    for (int n = k + 1; n < num.size();) {
                        if (num[i] + num[j] + num[k] + num[n] == target) {
                            vector<int> tmp_res = {num[i], num[j], num[k], num[n]};
                            res.push_back(tmp_res);
                        }
                        while (++n < num.size() && num[n] == num[n - 1]){}
                    }
                    while (++k < num.size() - 1 && num[k] == num[k - 1]){}
                }
                while (++j < num.size() - 2 && num[j] == num[j - 1]){}
            }
            while (++i < num.size() - 3 && num[i] == num[i - 1]){}
        }
        return res;
    }
};

结果发现性能很差：

2.3  我的第三版解法

思路：

后来想出来一个点，因为这个数列是递增的，所以第一个数要不大于target的1/4,前两个数之和要不大于一半，前三个不大于3/4。

代码：

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > res;
        if (num.size() < 4) {
            return res;
        }
        sort(num.begin(), num.end());
        for (int i = 0; i < num.size() - 3;) {
            if (num[i] * 4 > target)
                break;
            for (int j = i + 1; j < num.size() - 2;) {
                int sumij = num[i] + num[j];
                if (sumij * 2 > target)
                    break;
                for (int k = j + 1; k < num.size() - 1;) {
                    int sumijk = sumij + num[k];
                    if (sumijk * 4 > target * 3)
                        break;
                    for (int n = k + 1; n < num.size();) {
                        int sumijkn = sumijk + num[n];
                        if (sumijkn > target)
                            break;
                        if (sumijk + num[n] == target) {
                            vector<int> tmp_res = {num[i], num[j], num[k], num[n]};
                            res.push_back(tmp_res);
                            break;
                        }
                        while (++n < num.size() && num[n] == num[n - 1]){}
                    }
                    while (++k < num.size() - 1 && num[k] == num[k - 1]){}
                }
                while (++j < num.size() - 2 && num[j] == num[j - 1]){}
            }
            while (++i < num.size() - 3 && num[i] == num[i - 1]){}
        }
        return res;
    }
};

性能好了一些：

2.4  我的第四版解法

思路：

其实是看了讨论，发现最后两个数可以通过双指针查找。

代码：

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > res;
        if (num.size() < 4) {
            return res;
        }
        sort(num.begin(), num.end());
        int n = num.size();
        for (int i = 0; i < n - 3;) {
            if (num[i] * 4 > target)
                break;
            for (int j = i + 1; j < n - 2;) {
                int sumij = num[i] + num[j];
                if (sumij * 2 > target)
                    break;
                int l = j + 1;
                int r = n - 1;
                int target_sum = target - sumij;
                while (l < r) {
                    int sumlr = num[l] + num[r];
                    if (sumlr < target_sum) {
                        while (++l < r && num[l] == num[l - 1]){}
                    }
                    if (sumlr == target_sum) {
                        vector<int> tmp_res;
                        tmp_res.push_back(num[i]);
                        tmp_res.push_back(num[j]);
                        tmp_res.push_back(num[l]);
                        tmp_res.push_back(num[r]);
                        res.push_back(tmp_res);
                        while (++l < r && num[l] == num[l - 1]){}
                        while (--r > l && num[r] == num[r + 1]){}
                    }
                    if (sumlr > target_sum) {
                        while (--r > l && num[r] == num[r + 1]){}
                    }
                }
                while (++j < num.size() - 2 && num[j] == num[j - 1]){}
            }
            while (++i < num.size() - 3 && num[i] == num[i - 1]){}
        }
        return res;
    }
};

最终性能还凑活：