多数之和问题

多数求和问题

针对给一组用例,和一个目标数target,求用例中多数相加等于target的所有数,且不能重复问题,一般有两种解法:

• 集合(不要求排序)
• 双指针(要求排序);

利用集合一般求解两数之和问题,时间复杂度达到O(n);

而双指针问题可以把N数之和问题从时间复杂度O(N^{n)降低到O(N}(n-1));

此两种解法的具体思路在第一题和第二题分别会进行详细叙述,后面的题便直接使用,不再赘述

1两数之和(无序)

链接

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

题解

如果 a + b = target,当我们从头开始遍历数组碰到a(或者b)时,b(或者a)一定在a(或者b)后面,那么我们每遍历一个数a,就先检查集合中是否存在target-a,如果有,返回结果 ; 如果没有,则将a添加进集合,当后面碰到b时候,a肯定已经在集合里面,可以查找到结果,整个时间复杂度为O()

下面以数组[3,5,4,7,6,2,11,8],target=16为例,进行演示过程:

不过此题是要求写索引,所以我们用map将值和索引进行映射;

vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int,int> umap;    //用来映射值和索引
    for(int i = 0;i<nums.size();i++){
        auto ret = umap.find(target - nums[i]);  //先检查target-nums[i]的值是否在集合里面
        if(ret != umap.end()){                   //如果在,就返回正确结果
            return {ret->second,i};              
        }
        umap[nums[i]] = i;                      //如果不在,就将CUR值放进集合
    }
    return {};
}

2两数之和(有序)

链接

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

题解

此题有序,我们可以采用双指针解法,即一开始left指向最左边,right指向最右边,那么

• 当nums[left]+ nums[right] > target时候,那么其中一个目标值一定不是nums[right],所以right应该左移
• 当nums[left]+ nums[right] < target时候,那么其中一个目标值一定不是nums[left],所以left应该右移

最终便一定可以找到目标值

以数组[1,3,4,7,8,13,18,21,23,26],target=20为例,看下图:

    vector<int> twoSum(vector<int>& numbers, int target) {
        int low = 0, high = numbers.size() - 1;
        while (low < high) {
            int sum = numbers[low] + numbers[high];
            if (sum == target) {
                return {low + 1, high + 1};
            } else if (sum < target) {
                ++low;
            } else {
                --high;
            }
        }
        return {-1, -1};
    }

3两数之和(二叉搜索树)

链接

给定一个二叉搜索树 root 和一个目标结果 k，如果二叉搜索树中存在两个元素且它们的和等于给定的目标结果，则返回 true。

示例 1：

输入: root = [5,3,6,2,4,null,7], k = 9
输出: true

示例 2：

输入: root = [5,3,6,2,4,null,7], k = 28
输出: false

题解

此题是一个二叉搜索树,其本质两数之和(无序)没有什么区别,都是在遍历当前结点时候,检查集合是否存在target剪去当前结点值,如果有就返回结果,如果没有,就存下当前值,因此当下一次遍历到target剪去之前值时候,就一定会存在集合中;

class Solution {
public:
    unordered_set<int> hashTable;

    bool findTarget(TreeNode *root, int k) {
        if (root == nullptr) {    //如果集合本身为空,说明不存在
            return false;
        }
        if (hashTable.count(k - root->val)) {     //检查target-当前值是否存在集合
            return true;
        }
        hashTable.insert(root->val);         //如果不存在就加入集合
        return findTarget(root->left, k) || findTarget(root->right, k);        //然后分别去左右子树检查结果
    }
};

4 三数之和

链接

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足i != j、i != k 且 j != k，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

题解

此题并没有太高级的算法,本质其实是暴力解,不过却可以利用双指针将时间 复杂度从O(n^{3)降低到O(n}2),因为双指针分别从两边向中间走,本该两次的事情,却一次达到了;

此题怎么使用双指针呢?

首先进行排序,然后让第二层循环和第三层循环分别进行双指针算法,第一层进行遍历;

当然此题涉及比较多的数字之和,就需要考虑一些特殊情况了,比如数字全部一样[0,0,0,0,0,0,0,0,0,0,0],target = 0,那么怎么进行去重结果呢?

答案很简单,分别满足连个条件:

• 索引First<Second<Third
• 每一层访问的数字和其上一次访问的不一样,注意哦,这里说的是 层

    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());      //排序
        vector<vector<int>> ret;            //存储结果
        
        for(int first = 0;first<nums.size()-2;first++){   //第一层循环,即图中的指针F
            if(nums[first] > 0) break;		//因为已经排好序,如果第一个数就大于0,那么后面所有数字相加都不可能有等于0
         //第一层访问的数字不能和该层上一次访问的数字一样,有个条件first>0是因为该层第一次访问时,上一次没有可访问的数字
            if(first && nums[first] == nums[first-1]) continue;

            int second = first+1;   
            int third = nums.size()-1;
            while(second<third){   //双指针算法
                int tmp = nums[first] + nums[second] + nums[third];
                if(tmp == 0){
                    ret.push_back({nums[first],nums[second],nums[third]});
                    //第二层访问的数字不能和该层上一次访问的数字一样
                    while(second < third && nums[second]==nums[second+1]) second++;   
                    //第三层访问的数字不能该层上一次访问的数字一样
                    while(second < third && nums[third]==nums[third-1]) third--;
                    
                    //如果找到结果了,双指针同时向中间走
                    second++;
                    third--;
                }
                else if(tmp > 0){   //如果结果集大于target,第二个指针向右走
                    third--;
                }
                else{            //如果结果集小于target,第三个指针向左走
                    second++;
                }
            }
        }
        return ret;
    }

5四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

题解

此题没有什么好在画图的必要和解释了,和第四题本质一样,只是多了个循环而已,直接上代码

(代码中用long long代替是因为出题人的样例有点恶心,明明考算法,却弄了个整型溢出)

    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        if(nums.size() < 4){
            return {};
        }
        long long target1 = target;
        sort(nums.begin(),nums.end());
        vector<vector<int>> ret;
        for(int first = 0;first<nums.size()-3;first++){
            if(first && nums[first] == nums[first-1]) continue;

            for(int second = first+1;second<nums.size()-2;second++){
                if(second > first+1 && nums[second] == nums[second-1]) continue;

                int third = second+1;
                int fourth = nums.size()-1;
                while(third < fourth){
                    long long tmp = (long long)nums[first] + (long long)nums[second] + (long long)nums[third] + (long long)nums[fourth];
                    if(tmp == target1){
                        ret.push_back({nums[first] , nums[second] , nums[third] , nums[fourth]});
                        while(third<fourth && nums[third] == nums[third+1]) third++;
                        while(third<fourth && nums[fourth] == nums[fourth-1]) fourth--;
                        third++;
                        fourth--;
                    }
                    else if(tmp > target1){
                        fourth--;
                    }
                    else{
                        third++;
                    }
                }
            }
        }
        return ret;
    }