leetcode | 4Sum

最新推荐文章于 2020-06-30 12:03:28 发布

曲小鑫

最新推荐文章于 2020-06-30 12:03:28 发布

阅读量589

点赞数

分类专栏： LeetCode 文章标签： leetcode array sum

本文链接：https://blog.csdn.net/quzhongxin/article/details/46010781

版权

LeetCode 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

4Sum: https://leetcode.com/problems/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）夹逼

根据 3Sum 的夹逼思想，容易联想到4Sum的解决办法：
多加一层循环 i, j, p, q; 固定i，j; 移动 p、q夹逼；但是对于重复的元素构成，难以解决

因此可用两种解决方法

传统方法，重复时跳过
无视重复，得到所有可能，最后用 unique 和 erase 函数去除重复

时间复杂度 $O(n^3)$ ; 空间复杂度 $O(1)$

class Solution {
public:
    //时间复杂度 O(n^3); 空间复杂度 O(1)
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        if (nums.size() < 4)
            return result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size()-3; i++) {
            if (i > 0 && nums[i] == nums[i-1])
                continue;
            int t = target-nums[i];
            for (int j = i+1; j < nums.size()-2; j++) {
                if (j > i+1 && nums[j] == nums[j-1]) //注意此处 j > i+1;不是j > 1
                    continue;
                int p = j+1;
                int q = nums.size()-1;
                while (p < q) {
                    int sum = nums[j]+nums[p]+nums[q];
                    if (sum < t) {
                        p++;
                        while (p < q && nums[p] == nums[p-1])
                            p++;
                    } else if (sum > t) {
                        q--;
                        while (p < q && nums[q] == nums[q+1])
                            q--;
                    } else {
                        vector<int> temp;
                        temp.push_back(nums[i]);
                        temp.push_back(nums[j]);
                        temp.push_back(nums[p]);
                        temp.push_back(nums[q]);
                        result.push_back(temp);

                        p++;
                        q--;
                        while (p < q && nums[p] == nums[p-1] && nums[q] == nums[q+1])
                            p++;
                    }

                }
            }

        }
        return result;
    }
};

利用现有函数去除重复元素：

//时间复杂度 O(n^3); 空间复杂度 O(1)
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        if (nums.size() < 4)
            return result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size()-3; i++) {
            int t = target-nums[i];
            for (int j = i+1; j < nums.size()-2; j++) {
                int p = j+1;
                int q = nums.size()-1;
                while (p < q) {
                    int sum = nums[j]+nums[p]+nums[q];
                    if (sum < t) {
                        p++;
                    } else if (sum > t) {
                        q--;
                    } else {
                        vector<int> temp;
                        temp.push_back(nums[i]);
                        temp.push_back(nums[j]);
                        temp.push_back(nums[p]);
                        temp.push_back(nums[q]);
                        result.push_back(temp);

                        p++;
                        q--;
                    }
                }
            }
        }
        //将result排序，为unique作准备
        sort(result.begin(), result.end());  
        //unique: 移除连续且重复的元素；返回值：最后一个未被删除元素的下一个位置
        //erase: 释放一定范围内的数据（内存）
        result.erase(unique(result.begin(), result.end()), result.end());
        return result;
    }
};

（2）hash-table

由求和等于target两个数中，将所有元素压入hash-table，寻找target-nums[i]，时间复杂度是 $O(n)$ 的方法可联想：
用一个hash-table缓存所有两个数的和，枚举两个数，在hash-table中查找target-nums[i]-nums[j]，得到满足条件的另外两个数，时间复杂度为 $O(n^2)$ ,空间复杂度 $O(n^2)$

计算时间复杂度： $O(n^2)$
排序 $O(n\ lg n)$ + 建立hash-table $O(n^2)$ + 枚举并查找 $O(n^2) * O(1)$ + 排序 $O(n\ lg n)$

最坏时间复杂度为 $O(n^4)$ ，因为 v.size() 可能为 $n^2$ ，此时所有组合对的key全相等

// LeetCode, 4Sum
// 先排序，用hash-table缓存2个数的和，枚举2个数，在hash-table查找另外2个数
// 时间复杂度O(n^2)，空间复杂度O(n^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());

        unordered_map<int, vector<pair<int, int>> > cache;  //无序 hash-table
        for (int i = 0; i < num.size()-1; i++) {
            for (int j = i+1; j < num.size(); j++)
                cache[num[i]+num[j]].push_back(make_pair(i, j));
        }
        for (int p = 0; p < num.size()-1; p++) {
            for (int q = p+1; q < num.size(); q++) {
                const int key = target-num[p]-num[q];
                if (cache.find(key) == cache.end()) //没有找到
                    continue;
                auto v = cache[key];  //对应key值，所有的组合对, v.size()常数大小
                for (int k = 0; k < v.size(); k++) {
                    //if (num[v[k].second] > num[p])
                    if (v[k].second >= p)  //存在重复，注：应比较脚标，而不是值
                        continue;
                    vector<int> temp;
                    temp.push_back(num[v[k].first]);
                    temp.push_back(num[v[k].second]);
                    temp.push_back(num[p]);
                    temp.push_back(num[q]);
                    result.push_back(temp);
                }
            }
        }

        sort(result.begin(), result.end());
        result.erase(unique(result.begin(), result.end()), result.end());
        return result;
    }
};

测试代码

#include <vector>
#include <iostream>
#include <stdlib.h>
#include <algorithm>
#include <unordered_map>
using namespace std;

void PrintVector2D(vector<vector<int>>& v)
{
    for (int i = 0; i < v.size(); i++) {
        for (int j = 0; j < v[i].size(); j++)
            cout << v[i][j] << "  ";
        cout << endl;
    }
}
// LeetCode, 4Sum
// hash-table
class Solution2 {
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());

        unordered_map<int, vector<pair<int, int>> > cache;
        for (int i = 0; i < num.size()-1; i++) {
            for (int j = i+1; j < num.size(); j++)
                cache[num[i]+num[j]].push_back(make_pair(i, j));
        }
        for (int p = 0; p < num.size()-1; p++) {
            for (int q = p+1; q < num.size(); q++) {
                const int key = target-num[p]-num[q];
                if (cache.find(key) == cache.end()) //没有找到
                    continue;
                auto v = cache[key];
                for (int k = 0; k < v.size(); k++) {
                    //if (num[v[k].second] > num[p])
                    if (v[k].second >= p)  //重复，注：应比较脚标，而不是值
                        continue;
                    vector<int> temp;
                    temp.push_back(num[v[k].first]);
                    temp.push_back(num[v[k].second]);
                    temp.push_back(num[p]);
                    temp.push_back(num[q]);
                    result.push_back(temp);
                }
            }
        }

        sort(result.begin(), result.end());
        result.erase(unique(result.begin(), result.end()), result.end());
        return result;
    }
};
// 夹逼
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        if (nums.size() < 4)
            return result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size()-3; i++) {
            if (i > 0 && nums[i] == nums[i-1])
                continue;
            int t = target-nums[i];
            for (int j = i+1; j < nums.size()-2; j++) {
                if (j > i+1 && nums[j] == nums[j-1])
                    continue;
                int p = j+1;
                int q = nums.size()-1;
                while (p < q) {
                    int sum = nums[j]+nums[p]+nums[q];
                    if (sum < t) {
                        p++;
                        while (p < q && nums[p] == nums[p-1])
                            p++;
                    } else if (sum > t) {
                        q--;
                        while (p < q && nums[q] == nums[q+1])
                            q--;
                    } else {
                        vector<int> temp;
                        temp.push_back(nums[i]);
                        temp.push_back(nums[j]);
                        temp.push_back(nums[p]);
                        temp.push_back(nums[q]);
                        result.push_back(temp);

                        p++;
                        q--;
                        while (p < q && nums[p] == nums[p-1] && nums[q] == nums[q+1])
                            p++;
                    }

                }
            }

        }
        return result;
    }
};

int main()
{
    int num[] = {-3,-2,-1,0,0,1,2,3};
    vector<int> nums(num, num+sizeof(num)/sizeof(num[0]));
    Solution sol;
    Solution2 sol2;
    vector<vector<int>>res = sol.fourSum(nums, 0);
    vector<vector<int>>res2 = sol2.fourSum(nums, 0);

    PrintVector2D(res);
    cout << endl << endl;
    PrintVector2D(res2);
    getchar();
}

曲小鑫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode | 4Sum

3Sum Closest ： https://leetcode.com/problems/3sum-closest/Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three in
复制链接

扫一扫