leetcode: 4Sum-优快云博客

本文介绍了一种优化的四数之和求解算法，通过使用集合和指针来实现去重，有效避免了重复计算。同时，详细讨论了如何在不同情况下正确处理指针，并提供了两种版本的实现代码，一种使用集合去重，另一种采用标志位去重，以应对特定场景如[5,7,7,7,7],28的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

两个循环，加两个指针

去重，用的集合

用flag的有问题，先吃饭吧

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        if(num.size() < 4)
            return vector< vector< int> >();
        vector< vector< int> > res;
        set< vector< int> > unique;
        sort( num.begin(), num.end());
        for( int i = 0; i < num.size(); ++i){
            for( int j = i + 1; j < num.size(); ++j){
                int p = j + 1;
                int q = num.size() - 1;
                while( p < q){
                    if( num[i] + num[j] + num[p] + num[q] == target){
                        vector< int> tmp;
                        tmp.push_back( num[i]);
                        tmp.push_back( num[j]);
                        tmp.push_back( num[p]);
                        tmp.push_back( num[q]);
                        if( !unique.count(tmp)){
                            res.push_back(tmp);
                            unique.insert(tmp);
                        }
                        --q;
                        ++p;
                    }
                    else if( num[i] + num[j] + num[p] + num[q] > target){
                        --q;
                    }
                    else
                        ++p;
                }
            }
        }
        return res;
    }
};

少用个set的版本，用flag去重，记得每个指针用完要重置flag不然会漏掉类似[5,7,7,7,7], 28这种情况

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        if(num.size() < 4)
            return vector< vector< int> >();
        vector< vector< int> > res;
        sort( num.begin(), num.end());
        int flagi = INT_MAX, flagj = INT_MAX, flagp = INT_MAX, flagq = INT_MAX;
        for( int i = 0; i < num.size(); ++i){
            if( num[i] == flagi)//去重
                continue;
            flagi = num[i];//去重
            flagj = INT_MAX;//每次循环结束需要重置
            for( int j = i + 1; j < num.size(); ++j){
                if( flagj == num[j])//去重
                    continue;
                flagj = num[j];//去重
                int p = j + 1;
                int q = num.size() - 1;
                flagp = INT_MAX;//每次循环结束需要重置
                flagq = INT_MAX;//每次循环结束需要重置
                while( p < q){
                    flagq = num[q];//去重
                    flagp = num[p];//去重
                    if( num[i] + num[j] + num[p] + num[q] == target){
                        vector< int> tmp;
                        tmp.push_back( num[i]);
                        tmp.push_back( num[j]);
                        tmp.push_back( num[p]);
                        tmp.push_back( num[q]);
                        res.push_back(tmp);
                        while( flagq == num[q])//去重
                            --q;
                        while( flagp == num[p])//去重
                            ++p;
                        
                    }
                    else if( num[i] + num[j] + num[p] + num[q] > target){
                        while( flagq == num[q])//去重
                            --q;
                    }
                    else{
                        while( flagp == num[p])//去重
                            ++p;
                    }
                }
            }
        }
        return res;
    }
};