4数之和__牛客网

lollipop😈😈

import java.util.*;

public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] nums, int target) {
        ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
        Arrays.sort(nums);
        int len = nums.length;
        for(int i = 0; i < len - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int j = i + 1; j < len - 2;) {
                int l = j + 1;
                int r = len - 1;
                while (l < r) {
                    int sum = nums[i] + nums[j] + nums[l] + nums[r];
                    if (sum == target) {
                        ans.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[l++], nums[r--])));
                        while (l < r && nums[l - 1] == nums[l]) {
                            l++;
                        }
                        while (l < r && nums[r + 1] == nums[r]) {
                            r--;
                        }
                    } else if (sum > target) {
                        r--;
                    } else {
                        l++;
                    }
                }
                j++;
                while (j < len - 2 && nums[j] == nums[j - 1]) {
                    j++;
                }
            }
        }
        return ans;
    }
}

发表于 2019-01-28 15:55:53 回复(0)

liuyang2016

//与3sum思路类似，只不过这次需要先固定两个数，然后双指针找，用set去除重复组合
class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > res;
        vector<int> temp(4,0);
        set<vector<int> > st;
        sort(num.begin(),num.end());
        int n=num.size();
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                int left=j+1,right=n-1;
                while(left<right){
                    int sum=num[i]+num[j]+num[left]+num[right];
                    if(sum==target){
                        temp[0]=num[i];
                        temp[1]=num[j];
                        temp[2]=num[left];
                        temp[3]=num[right];
                        st.insert(temp);
                    }
                    if(sum<target)
                        left++;
                    else 
                        right--;
                }
            }
        }
        set<vector<int> >::iterator it;
        for(it=st.begin();it!=st.end();it++)
            res.push_back(*it);
        return res;
    }
};

发表于 2018-08-14 11:01:31 回复(1)

C/C++

nbgao

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        sort(num.begin(),num.end());
        vector<vector<int> > result;
        int n = num.size();
        for(int i=0;i<n-3;i++)
        {
        	for(int j=i+1;j<n;j++)
        	{
        		int s = target - num[i] - num[j];
        		int l = j+1;
        		int r = n-1;
        		while(l<r)
        		{
        			while(l<r && num[l]+num[r]>s)
        				r--;
        			if(l==r)
        				break;
        			if(num[l]+num[r] == s)
        			{
        				vector<int> v;
        				v.push_back(num[i]);
        				v.push_back(num[j]);
        				v.push_back(num[l]);
        				v.push_back(num[r]);
        				result.push_back(v);
        				
        				while(l<r && num[l]==num[l+1])
        					l++;
					}
					l++;
				}
				while(j<n-1 && num[j]==num[j+1])
					j++;				
			}
			while(i<n-1 && num[i]==num[i+1])
				i++;
		}
		return result;
    }
};

发表于 2017-09-13 01:05:15 回复(0)

BrainerGao

用一个hashmap,先缓存两个数的和

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_multimap<int, pair<int, int> > multimap;
        for(int i=0; i+1<num.size(); i++){
            for(int j=i+1; j<num.size(); j++)
                multimap.insert(make_pair(num[i]+num[j], make_pair(i,j)));
        }

        for(auto i=multimap.begin(); i!=multimap.end(); i++){
            int x = target - i->first;
            auto range = multimap.equal_range(x);
            for(auto j = range.first; j!=range.second; j++){
                auto a = i->second.first;
                auto b = i->second.second;
                auto c = j->second.first;
                auto d = j->second.second;
                if(a!=c && a!=d && b!=c && b!=d){
                    vector<int> vec = {num[a], num[b], num[c], num[d]};
                    sort(vec.begin(),vec.end());
                    result.push_back(vec);
                }
            }
        }
        sort(result.begin(),result.end());
        result.erase(unique(result.begin(),result.end()),result.end());
        return result;
    }
};

发表于 2016-06-28 10:29:09 回复(1)

科学xx

import java.util.*;
public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] nums, int target) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if (nums == null || nums.length < 4){
            return res;
        }
        //先排序
        Arrays.sort(nums);
        int len = nums.length;
        for (int i = 0; i < len-3; i++) {
            //跳过相同的
            if (i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            //跳过大于target的，从小到大已排序，说明后序都大于
            if (nums[i] + nums[i+1] + nums[i+2] + nums[i+3] > target){
                break;
            }
            //四数之和（加上最后三个最大的）一定小于 target，因此第一重循环直接进入下一轮
            if (nums[i] + nums[len-1] + nums[len-2] + nums[len-3] < target){
                continue;
            }
            for (int j = i+1; j < len-2; j++) {
                if (j > i+1 && nums[j] == nums[j-1]){
                    continue;
                }
                if (nums[i] + nums[j] + nums[j+1] + nums[j+2] > target){
                    break;
                }
                //加上最后两个
                if (nums[i] + nums[j] + nums[len-1] + nums[len-2] < target){
                    continue;
                }
                //双指针
                int left = j + 1;
                int right = len - 1;
                while (left < right){
                     int sum = nums[i] + nums[j] + nums[left] + nums[right];
                     if (sum == target){
                         res.add(new ArrayList<>(Arrays.asList(nums[i] , nums[j] , nums[left] , nums[right])));
                         //跳过相同的
                         while (left < right && nums[left] == nums[left+1]){
                             left++;
                         }
                         left++;
                         while (left < right && nums[right] == nums[right-1]){
                             right--;
                         }
                         right--;
                     }else if (sum < target){
                         left++;
                     }else {
                         right--;
                     }
                }
            }
        }
        return res;
    }
}

发表于 2020-10-11 14:27:23 回复(0)

C/C++

努力的牛牛

    /*
    * 目的：找出数组S中所有满足条件的四元组
    * 方法1：回溯法
    * 方法2：与3sum思路类似，只不过这次需要先固定两个数，然后双指针找，用set去除重复组合
    */
    void getres(vector<vector<int>>&res, vector<int>&cur,int index, int m, vector<int>&num,int sum, int target){
        if (m==4){
            if (sum==target){
                sort(cur.begin(),cur.end());
                res.push_back(cur);
            }
            return;
        }
        for (int i = index; i < num.size();++i){
            cur.push_back(num[i]);
            getres(res,cur,i+1, m+1,num,sum+num[i],target);
            cur.pop_back();
        }
    }
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<int>cur;
        vector<vector<int>>res;
        sort(num.begin(),num.end());
        getres(res,cur, 0, 0, num, 0, target);
        sort (res.begin(),res.end());
        res.erase(unique(res.begin(),res.end()),res.end());
        return res;
    }

发表于 2019-12-11 10:25:48 回复(0)

llch__

    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        Arrays.sort(num);
        for(int sum1 = 0; sum1 < num.length; sum1++){
            if((sum1 != 0 && num[sum1-1] == num[sum1])) continue;
            if(num[sum1] > target && num[sum1] >= 0) break;
            for(int sum2 = sum1+1; sum2 < num.length; sum2++){
                if(sum2 != sum1+1 && num[sum2-1] == num[sum2]) continue;
                if(num[sum1]+num[sum2] > target && num[sum2] >= 0) break;
                for(int sum3 = sum2+1; sum3<num.length; sum3++){
                    if(sum3 != sum2+1 && num[sum3-1] == num[sum3]) continue;
                    if(num[sum1]+num[sum2]+num[sum3] > target && num[sum3] >= 0) break;
                    for(int sum4 = sum3+1; sum4 <num.length; sum4++){
                        if(sum4 != sum3+1 && num[sum4-1] == num[sum4]) continue;
                        if(num[sum1]+num[sum2]+num[sum3]+num[sum4] > target && num[sum4] >= 0) break;
                        if(num[sum1] + num[sum2] + num[sum3] + num[sum4] == target){
                            ArrayList<Integer> list = new ArrayList<Integer>();
                            list.add(num[sum1]);
                            list.add(num[sum2]);
                            list.add(num[sum3]);
                            list.add(num[sum4]);
                            result.add(list);
                        }        
                    }
                }
            }
        }
        return result;
    }

发表于 2018-08-02 17:16:13 回复(0)

OFFER死哪去了

回溯dfs 超市啊

发表于 2018-07-25 14:07:32 回复(0)

C/C++

F-L

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        set<vector<int>> res;
        
        unordered_map<int, set<Record> > record; 
        int len = nums.size();
       
        for(int i = 0; i < len; ++i){
            for(int j = i+1; j < len; ++j){
                record[nums[i]+nums[j]].insert(Record(i, j));
            }
        }
        
        for(int i = 0; i < len; ++i){
            for(int j = i+1; j < len; ++j){
                int tmp = target - nums[i] - nums[j];
                for(const auto & rec : record[tmp]){
                    if(Record(i, j) == rec){
                        continue;
                    }else{
                        int arr[] = {nums[i], nums[j], nums[rec.get_a()], nums[rec.get_b()]};
                        sort(arr, arr+4);
                        res.insert(vector<int>(arr, arr+4));
                      
                    }
                }
            }
        }
        
        return vector<vector<int>> (res.begin(), res.end());
        
    }
    
private:
    struct Record{
        int a;
        int b;
        Record(const int a, const int b): a(a), b(b){}
        
        bool operator == (const Record & rec) const {
            return a == rec.a || b == rec.b || a == rec.b || b == rec.a;
        }
        
        bool operator < (const Record & rec) const {
            
            return a < rec.a;
        }
        
        int get_a() const { return a; }
        int get_b() const { return b; }
    };
};

发表于 2018-04-04 12:51:30 回复(0)

sky_

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
              sort(num.begin(),num.end());
              vector<vector<int> > ans;
              for(int i=0;i+3<num.size();i++){
               for(int j=i+1;j<num.size();j++){
                   int sum=target-num[i]-num[j];
                   int l=j+1,r=num.size()-1;
                   while(l<r){
                        while(l<r&&num[l]+num[r]>sum) r--;
                        if(l==r) break;
                        if(num[l]+num[r]==sum){
                           ans.push_back(vector<int>{num[i],num[j],num[l],num[r]}); 
                           while(l<r&&num[l+1]==num[l]) l++;
                        }
                        l++;
                   }
                   while(j+1<num.size()&&num[j+1]==num[j]) j++;     
                   }
                   while(i+1<num.size()&&num[i+1]==num[i]) i++;
              }
              return ans;
    }
};

发表于 2017-08-06 10:42:17 回复(0)

LinuX18

class Solution {
public:
   vector<vector<int> > fourSum(vector<int> &num, int target) 
   {
    int len = num.size();
    vector<vector<int>> res;
    if(len<4) return res;
    sort(num.begin(),num.end());
    for(int i=0;i<len;i++)
    {
        int threeSum = target-num[i];
        for(int j=i+1;j<len;j++)
        {
            int twoSum = threeSum-num[j];
            int left=j+1,right=len-1;
            while(left<right)
            {
                int curSum = num[left]+num[right];
                if(curSum < twoSum)
                    left++;
                else if(curSum > twoSum)
                    right--;
                else
                {
                    vector<int> temp={num[i],num[j],num[left],num[right]};
                    //temp[0] = num[i],temp[1]=num[j],temp[2]=num[left],temp[3]=num[right];
                    res.push_back(temp);
                    while(left<right && num[left]== temp[2])
                        ++left;
                    while(left<right && num[right]==temp[3])
                        --right;
                }
            }
            while(j<len-1 && num[j] == num[j+1])
                ++j;
        }
        while(i<len-1 && num[i]==num[i+1])
              ++i;
    }
    return res;  
  }
};

编辑于 2017-07-13 15:29:19 回复(0)

元气の悟空

class Solution {
    vector<int> d;
    vector<vector<int> > z;
    set<vector<int> > da;
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        int i,j,k,q,t;
        sort(num.begin(),num.end());
        for(k=0;k<num.size();k++)
            for(q=k+1;q<num.size();q++)
           	{
            	t=target-num[k]-num[q];
            	for(i=0,j=num.size()-1;i<j;)
                    if(i==q||i==k) i++;
                    else if(j==q||j==k) j--;
                    else
                    {
                    	if(num[i]+num[j]==t)
                        {
                            d.push_back(num[k]);d.push_back(num[q]);
                            d.push_back(num[i]);d.push_back(num[j]);
                            sort(d.begin(),d.end());
                            da.insert(d);
                            d.clear();
                            i++;j--;
                        }
                    	else if(num[i]+num[j]<t) i++;
                        else j--;
                	}
        	}
        set<vector<int> >::iterator it;
        for(it=da.begin();it!=da.end();z.push_back(*it),it++);
        return z;
    }
};

发表于 2016-08-20 11:02:32 回复(0)

ponmmains

import java.util.*;

public class Solution {
public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
ArrayList<ArrayList<Integer>> resList = new ArrayList<ArrayList<Integer>>();
Arrays.sort(num);
int sum = 0;
for (int i = 0; i < num.length; i++) {
if (i != 0 && num[i] == num[i - 1]) continue;
sum = num[i];
if (num[i] >0 && sum > target) break;
for (int j = i + 1; j < num.length; j++) {
if (j != i + 1 && num[j] == num[j - 1]) continue;
sum += num[j];
if (num[j] >0 && sum > target) {
sum -= num[j];
break;
}
for (int k = j + 1; k < num.length; k++) {
if (k != j + 1 && num[k] == num[k - 1]) continue;
sum += num[k];
if (num[k] >0 && sum > target) {
sum -= num[k];
break;
}
for (int p = k + 1; p < num.length; p++) {
if (p != k + 1 && num[p] == num[p - 1]) continue;
sum += num[p];
if (num[p] >0 && sum > target) {
sum -= num[p];
break;
}
if (sum == target) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(num[i]);
list.add(num[j]);
list.add(num[k]);
list.add(num[p]);
resList.add(list);
}
sum -= num[p];
}
sum -= num[k];
}
sum -= num[j];
}
}

return resList;
}
}

发表于 2020-10-16 11:32:34 回复(0)

Java

HW柯可

import java.util.Arrays;
import java.util.ArrayList;

public class Solution {
   ArrayList<ArrayList<Integer>> res= new ArrayList<ArrayList<Integer>>();
    int sum = 0;
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
        if(num == null || num.length < 4)
            return res;
        ArrayList<Integer> list =  new ArrayList<>();
        Arrays.sort(num);
        combine(num, target, 0, list);
        return res;
    }
//回溯法
    public void combine(int[] num, int target, int start, ArrayList<Integer> list){
        if(list.size() == 4 ){
            if(sum == target && !res.contains(list)){
                res.add(new ArrayList<>(list));
            }
            return;
        }
            for(int i = start; i < num.length; i++){
                sum += num[i];
                list.add(num[i]);
                combine(num, target, i + 1, list);
                sum -= list.get(list.size()-1);
                list.remove(list.size()-1);
            }
    }
}

编辑于 2020-07-16 15:22:53 回复(0)

merlinssea

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        sort(num.begin(),num.end());
        int len = num.size();
        vector<vector<int> > res;
        for(int i=0;i<len-3;i++){
            if(i>0&& num[i]==num[i-1])
                continue;/*重复即跳过本轮循环*/
            for(int j=i+1;j<len-2;j++){
                if(j>i+1 && num[j]==num[j-1])
                    continue;
                int  left  = j+1;
                int right = len-1;
                while(left < right){
                    int sum = num[i]+num[j]+num[left]+num[right];
                    if(sum == target){
                        vector<int> ans = {num[i],num[j],num[left],num[right]};
                        res.push_back(ans);
                        while(left<right && num[left+1]==num[left])
                            left++;
                        left++;
                        while(left<right && num[right-1]==num[right])
                            right--;
                        right--;
                    }else if(sum>target){
                        right--;
                    }
                    else{
                        left++;
                    }
                }
            }
        }
        return res;
    }
};

发表于 2020-05-04 11:10:44 回复(0)

C/C++

hello古斯卡

class Solution {
public:
    
vector<vector<int>> fourSum(vector<int> &nums, int target) {
    vector<vector<int>> res;
    int n = nums.size();
    if (n < 4) {
        return res;
    }

    sort(nums.begin(), nums.end());
    for (int k = 0; k < n - 3; ++k) {
        if (nums[k] + nums[k + 1] + nums[k + 2] + nums[k + 3] > target) {
            break;
        }
        if (k > 0 && nums[k - 1] == nums[k]) {
            continue;
        }

        for (int i = k + 1; i < n - 2; ++i) {
            int pre = i + 1;
            int next = n - 1;
            if (nums[k] + nums[i] + nums[i + 1] + nums[i + 2] > target) {
                break;
            }

            if (i > k + 1 && nums[i - 1] == nums[i]) {
                continue;
            }

            while (next > pre) {
                int sum = nums[k] + nums[i] + nums[pre] + nums[next];
                if (sum == target) {
                    vector<int> tmp;
                    tmp.push_back(nums[k]);
                    tmp.push_back(nums[i]);
                    tmp.push_back(nums[pre]);
                    tmp.push_back(nums[next]);
                    res.push_back(tmp);
                    while (pre < next && nums[pre] == nums[pre + 1]) {
                        pre++;
                    } // 去重
                    while (pre < next && nums[next] == nums[next - 1]) {
                        next--;
                    } // 去重
                    pre++;
                    next--;
                } else if (sum > target) {
                    next--;
                } else if (sum < target) {
                    pre++;
                }
            }
        }
    }
    return res;
}
};

发表于 2019-11-09 16:34:36 回复(0)

C/C++

Wild_pointer

递归和迭代两种解法

class Solution {
public:
    //recursive solution
    //递归
    vector<vector<int> > fourSum(vector<int> &num,int target) {
        vector<vector<int>> res;
        if(num.size()<4)
            return res;
        sort(num.begin(),num.end());
        vector<int> pre;
        dfs(res,pre,num,-target,0);
        return res;
    }
    void dfs(vector<vector<int>> &res,vector<int>& pre,vector<int> &num,int sum,int index){
        if(pre.size()>4)
            return;
        if(pre.size()==4){
            if(sum==0&&find(res.begin(),res.end(),pre)==res.end())
                res.push_back(pre);
            return ;
        }
        if(pre.size()+num.size()-index<4)
            return;
        for(int i=index;i<num.size();i++){
                pre.push_back(num[i]);
                dfs(res,pre,num,sum+num[i],i+1);
                pre.pop_back();
        }
    }
    
    //迭代，先确定两个数再去搜索另外两个数
    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;){
                int left2=j+1;
                int right2=num.size()-1;
                while(left2<right2){
                    int sum=num[j]+num[left2]+num[i]+num[right2];
                    if(sum==target){
                        vector<int> temp(4,0);
                        temp[0]=num[i];
                        temp[1]=num[j];
                        temp[2]=num[left2];
                        temp[3]=num[right2];
                        res.push_back(temp);
                        while (++left2 < right2 && num[left2] ==num[left2-1]);
                        while (--right2 > left2 && num[right2] ==num[right2+1]);
                    }
                    else if(sum>target)
                        while (--right2 > left2 && num[right2] ==num[right2+1]);
                    else
                        while (++left2 < right2 && num[left2] ==num[left2-1]);
                }
                while (++j != num.size() - 2 && num[j] == num[j-1]);
            }
            while (++i != num.size() - 3 && num[i] == num[i-1]);
        }
        return res;
    }
    
};

发表于 2019-10-21 22:22:41 回复(0)

Dracula201902211242561

1. DFS深度搜索

2. flag标志位去重

3.排序保证非降序

class Solution {
public:
    vector<vector<int> > res;
    void dfs(vector<int> &num,int idx,int cnt,int target,vector<int>& temp,vector<bool>& flag){
        if(target==0&&cnt==0){
            res.push_back(temp);
            return;
        }
        if(cnt<=0)
            return;
        for(int i=idx;i<num.size();i++){
            if(i==0||(i>0&&(num[i]!=num[i-1]||(num[i]==num[i-1]&&flag[i-1])))){
                flag[i]=true;
                temp.push_back(num[i]);
                dfs(num,i+1,cnt-1,target-num[i],temp,flag);
                temp.pop_back();
                flag[i]=false;
            }
        }
    }
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<bool> flag(num.size(),false);
        sort(num.begin(),num.end());
        vector<int> temp;
        dfs(num,0,4,target,temp,flag);
        return res;
    }
};

发表于 2019-09-02 19:55:33 回复(0)

成小呆

import java.util.*;
public class Solution {
    /**
    * 速度很慢但是代码很好看的做法😂
    * 想了一下3sum的做法,固定2个数用一个指针去找,但是固定的那两个数其实也要变,所以本质上也是每个数都要变的,于是索性把每个数都看成会变的
    * 每个while循环结束后,直接跳到下一个与当前不重复的数上
    * 每一层循环创建了一个target变量,其实到最后一层相加与target比较也行,但是速度实在是太慢了,是排行榜大佬的几倍,所以用空间换了一点点时间(虽然还是很慢)
    */
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
        if (num.length < 4) return new ArrayList<>();
        int a = 0, len = num.length;
        ArrayList<ArrayList<Integer>> r = new ArrayList<>();
        Arrays.sort(num);
        while (a < len - 3) {
            int b = a + 1;
            int target2 = target - num[a];
            while (b < len - 2) {
                int c = b + 1;
                int target3 = target2 - num[b];
                while (c < len - 1) {
                    int d = c + 1;
                    int target4 = target3 - num[c];
                    while (d < len) {
                        if (num[d] == target4) {
                            ArrayList<Integer> item = new ArrayList<>();
                            item.add(num[a]);
                            item.add(num[b]);
                            item.add(num[c]);
                            item.add(num[d]);
                            r.add(item);
                        }
                        do { d ++; } while (d < len && num[d] == num[d - 1]);
                    }
                    do { c ++; } while (c < len - 1 && num[c] == num[c - 1]);
                }
                do { b ++; } while (b < len - 2 && num[b] == num[b - 1]);
            }
            do { a ++; } while (a < len - 2 && num[a] == num[a - 1]);
        }
        return r;
    }
}

发表于 2019-08-14 17:39:43 回复(0)

C/C++

(:∇:)我太难了

class Solution {
public:
vector<vector<int> > fourSum(vector<int> &num, int target) {
    vector<vector<int>> results;
if(num.size()<4)
        return results;
    int length = num.size();
    //sort(num.bengin(), num.end());
    int sum = 0;
    vector<int> temp;
    set<vector<int>> setVec;
    for(int i=0; i<length; i++){
        for(int j=i+1; j<length; j++){
            for(int k=j+1; k<length; k++){
                for(int m = k+1; m<length; m++){
                    sum = num[i]+num[j]+num[k]+num[m];
                    if(sum == target){
                        temp.push_back(num[i]);
                        temp.push_back(num[j]);
                        temp.push_back(num[k]);
                        temp.push_back(num[m]);
                        sort(temp.begin(), temp.end());
                        setVec.insert(temp);
                        temp.clear();
                    }
                }
            }
        }
    }
    set<vector<int>>::iterator it;
    for(it=setVec.begin(); it!=setVec.end(); it++){
        results.push_back(*it);
    }
    return results;
}
};

发表于 2019-08-07 22:25:04 回复(0)

4数之和

问题信息

热门推荐

通过挑战的用户

相关试题