代码随想录day07|454.四数相加、383赎金信、15.三数之和、18.四数之和

LluckyYH

已于 2024-08-07 00:02:59 修改

阅读量964

点赞数 17

文章标签：算法 c++ leetcode 数据结构

于 2024-08-06 23:54:55 首次发布

本文链接：https://blog.csdn.net/LuckyYH__/article/details/140968899

版权

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

哈希表Part02
题目
题目一：**454.四数相加II**
**思路：**

题目二：383. 赎金信
思路：

题目三：15.三数之和
思路：

题目四：18.四数之和
思考：

总结

哈希表Part02

今日份刷题

题目

题目一：454.四数相加II

思路：

本题目的思路和有效的字母异位词是类似的思路。需要哈希的地方都能找到map的身影

四个数组，分为两组进行遍历。
因为不需要结果有序，又因为要记录key，value，所以采用unordered_map类型的数据结构。key用来记录a+b的和，value用来记录a+b出现的次数。
先遍历前两个数组，得到遍历后的map，再遍历后两个数组，利用总和为0，去找（0 -（c+d））是否在map中出现过。使用count变量加上对应的出现的次数value。

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C,
                     vector<int>& D) {
        unordered_map<int, int> map; // 用来记录key，value
        int count = 0;

        for (int a : A) {
            for (int b : B) {
                map[a + b]++;
            }
        }

        for (int c : C) {
            for (int d : D) {
                int target = 0 - (c + d);
                if (map.find(target) != map.end()) {
                    // 方法一：结果是一个迭代器，可以通过first和second来获取key和value
                    // count += map.find(target)->second;
                    // 方法二 直接获取键值对。
                    count += map[target];
                }
            }
        }
        return count;
    }
};

时间复杂度: O( $n^2$ )
空间复杂度: O $n^2$ )，最坏情况下A和B的值各不相同，相加产生的数字个数为 $n^2$

题目二：383. 赎金信

思路：

采用和有效的字母异位词同样的思路，

初始化一个的26字母数组，定义为0。
遍历操作：先遍历目标数组，对对应的字符进行加的操作，后面遍历构造数组进行减的操作。
最后判断数组中如果对应的字母有大于1，则无法构成。

细节学习：

计算数组元素数量
int arraySize = sizeof(record) / sizeof(record[0]);
int record[26] = {0}; 这行代码定义了一个包含 26 个整数的数组，并且使用 {0} 初始化器将每个元素初始化为 0。这是一个基本数据类型的数组，而不是一个容器类型的数组，比如 std::vector<int>对于这样的基本数据类型数组，不能使用 .size() 方法，因为 .size() 不是 int 类型的成员函数。数组本身也没有成员函数。

length()和size()使用:
length() 和 size() 都是用来获取序列类型数据（如字符串、数组、容器等）中元素个数的方法。size() 是 C++ STL 容器的标准方法，用于返回容器中元素的数量；而 length() 在 C++ 中不是标准容器方法，但 std::string 类型使用它来返回字符串中的字符数。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        for (int i = 0; i < ransomNote.length(); i++) {
            record[ransomNote[i] - 'a']++;
        }

        for (int i = 0; i < magazine.length(); i++) {
            record[magazine[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] > 0)
                return false;
        }
        return true;
    }
};

// class Solution {
// public:
//     bool canConstruct(string ransomNote, string magazine) {
//         int record[26] = {0};
//         for (char s : ransomNote) { //遍历时前面要写上类型
//             record[s - 'a']++;
//         }

//         for (char t : magazine) {
//             record[t - 'a']--;
//         }
//         for (int i = 0; i < 26; i++) {
//             if (record[i] > 0)
//                 return false;
//         }
//         return true;
//     }
// };
//};

时间复杂度: O(n)
空间复杂度: O(1）

题目三：15.三数之和

思路：

要存储唯一的结果，首先将向量排序。利用一个for循环，遍历a，利用双指针技巧，left 和 right 分别遍历向量（b和c），通过比较相邻元素 nums[i] 和 nums[i - 1] 来识别重复项。只有当当前元素与前一个不同，即 nums[i] != nums[i - 1] 时，才认为找到了一个新的不重复的结果集。在满足 left < right 的条件下，继续这个过程，以收集所有不重复的结果集。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > 0) { //排序后如果第一个元素都大于0，相加必定大于0，则返回。
                return result;
            }

            // 去重，因为要使用i-1，所以i>0;
            // 不能有重复的三元组，但三元组内的元素是可以重复的！
            // 和后一个数比较相当于判断一个结果集里面是否有重复的元素（nums[i]和nums[i+1]也就是nums[i]和nums[left]对应的值），
            // 和前一个数比较才是不重复的结果集（比较的都是nums[i]的值）。
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (left < right) {
                if (nums[i] + nums[left] + nums[right] > 0)
                    right--;
                else if (nums[i] + nums[left] + nums[right] < 0)
                    left++;
                else {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    //这里也是去重操作，去除b和c的重复元素。
                    while (left < right && nums[right] == nums[right - 1]) right--;
                    while (left < right && nums[left] == nums[left + 1]) left++;

					//找到正确答案，两个都收缩一下。
                    left++;
                    right--;    
                }
                
            }
        }
        return result;
    }
};

时间复杂度: O( $n^2$ )
空间复杂度: O(1)

题目四：18.四数之和

思考：

也是使用双指针法，在三数之和的基础上进行操作，多加了一层for循环。

那么一样的道理，五数之和、六数之和等等都采用这种解法。

注意：

target可能为负数，剪枝的时候要注意条件。三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。

比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出，所以要加(long)转换为long类型的。

代码细节：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size() - 1; k++) {
            // 一级剪枝
            if (nums[k] > target && nums[k] >= 0) {
                break;
            }
            // 一级去重，对k进行去重。
            if (k > 0 && nums[k] == nums[k - 1]) continue;
            for (int i = k + 1; i < nums.size(); i++) { //i的取值要注意下
                // 二级剪枝
                if (nums[i] + nums[k] > target && nums[i] >= 0) {
                    break;
                }
                // 二级去重，对i进行去重。
                if (i > k + 1 && nums[i] == nums[i - 1])  continue;
                int left = i + 1;
                int right = nums.size() - 1;
                while (left < right) {
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) right--;
                    else if ((long) nums[k] + nums[i] + nums[left] + nums[right] < target) left++;
                    else {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        // 对c和d元素进行去重操作
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        while (left < right && nums[left] == nums[left + 1]) left++;

                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }
};

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

总结

学习使用在循环中的剪枝和去重操作。
双指针的使用在三数之和，四数之和。降低时间复杂度，降低一个数量级。（怎么判断的时间复杂度）
哈希表的使用完结。

LluckyYH

关注

17
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
代码随想录day07|454.四数相加、383赎金信、15.三数之和、18.四数之和

学习使用在循环中的剪枝和去重操作。双指针的使用在三数之和，四数之和。降低时间复杂度，降低一个数量级。（怎么判断的时间复杂度）哈希表的使用完结。
复制链接

扫一扫