【算法训练 day7 哈希表与双指针】

最新推荐文章于 2024-07-22 22:47:14 发布

Hollow!

最新推荐文章于 2024-07-22 22:47:14 发布

阅读量966

点赞数 8

分类专栏：算法训练文章标签：算法数据结构

本文链接：https://blog.csdn.net/m0_67540113/article/details/138129303

版权

算法训练专栏收录该内容

41 篇文章 1 订阅

订阅专栏

一、四数相加Ⅱ-LeetCode 454

Leecode链接: leetcode 454
文章链接: 代码随想录

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n

nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

思路

其实跟两数之和那道题很像，只不过这道题需要将其中前两个数组的和穷举出来并记录到哈希表中，然后再与后两个数组的和一一对比。因为考虑到组和问题，前两个数组的和中可能有重复值，在count计数时，如果后两个数组中的和与前两个数组的和重复匹配，需要都计算进去。

实现代码

//cpp
class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int>hash;
        int count = 0;

        for(int i = 0;i<nums1.size();i++){
            for(int j = 0;j<nums2.size();j++){
                hash[nums1[i]+nums2[j]]++;
            }
        }

        for(int a = 0;a<nums3.size();a++){
            for(int b = 0;b<nums4.size();b++){
                if(hash.find(0-(nums3[a]+nums4[b])) != hash.end()){
                    count += hash[0-(nums3[a]+nums4[b])];
                }
            }
        }

        return count;
    }
};

个人问题

没有想到解题思路，本质还是两数之和。

总结

两数之和的进阶版，算法时间复杂度为O(n)，空间复杂度为O(1)。

二、赎金信-LeetCode 19

Leecode链接: LeetCode 19
文章链接: 代码随想录

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例：

输入：ransomNote = "a", magazine = "b"
输出：false

思路

记录字母类型以及个数，然后与另一个字符串逐个对比。

实现代码

1.使用map

//cpp
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char,int>hash;

        for(int i = 0;i<magazine.size();i++){
            hash[magazine[i]]++;
        }

        for(int j = 0;j<ransomNote.size();j++){
            hash[ransomNote[j]]--;
        }

        for(auto it = hash.begin();it != hash.end();it++){
            if(it->second < 0){
                return false;
            }
        }
        return true;
    }
};

2.使用数组

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        //add
        if (ransomNote.size() > magazine.size()) {
            return false;
        }
        for (int i = 0; i < magazine.length(); i++) {
            // 通过record数据记录 magazine里各个字符出现次数
            record[magazine[i]-'a'] ++;
        }
        for (int j = 0; j < ransomNote.length(); j++) {
            // 遍历ransomNote，在record里对应的字符个数做--操作
            record[ransomNote[j]-'a']--;
            // 如果小于零说明ransomNote里出现的字符，magazine没有
            if(record[ransomNote[j]-'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

个人问题

没有考虑到map带来的开销。

总结

简单题，时间复杂度O(n)，空间复杂度为O(1)。

三.三数之和-LeeCode 15

Leecode链接: LeetCode 15
文章链接: 代码随想录

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

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

示例：

输入：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] 。
注意，输出的顺序和三元组的顺序并不重要。

思路

使用双指针并进行从小到大排序，i、left、right，i从数组下标0开始逐渐增加，left取i+1，right取数组最后一个元素，当nums[i]的值大于零时直接退出，当nums[i]+nums[left]+nums[right]>0时，右指针左移，需要让和减少；同理当nums[i]+nums[left]+nums[right]<0时，左指针右移。我个人加了个len-2，是因为left与right与i不重复，避免重复判断。此处使用len-2不使用nums.size()-2的原因是：直接使用nums.size()-2的返回值是一个无符号整型，如果出现负数，它将转化为一个很大的数，会导致后续i可能取到超出数组长度的下标值。

实现代码

//cpp
class Solution
{
public:
    vector<vector<int>> threeSum(vector<int> &nums)
    {
        vector<vector<int>> res; // 返回结果
        sort(nums.begin(), nums.end());

        int len = nums.size();

        for (int i = 0; i < len-2; i++)
        {
            if (nums[i] > 0)
            {
                return res;
            }

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

            int left = i + 1;
            int right = len - 1;

            while (right > left)
            {
                if (nums[i] + nums[left] + nums[right] > 0)
                {
                    right--;
                }
                else if (nums[i] + nums[left] + nums[right] < 0)
                {
                    left++;
                }
                else
                {
                    res.push_back({nums[i], nums[left], nums[right]});
                    while (right > left && nums[right] == nums[right - 1])
                    {
                        right--;
                    }
                    while (right > left && nums[left] == nums[left + 1])
                    {
                        left++;
                    }

                    right--;
                    left++;
                }
            }
        }

        return res;
    }
};

个人问题

没有写出代码，已经忘记了解题方法。

总结

题目是双指针的应用，要把握好外循环for是移动i指针，内循环while是移动left与right指针。本题考验对细节的的把握，什么时候移动左指针，什么时候移动右指针，以及避免多余判断进行剪枝。时间复杂度O(n^2),空间复杂度O(1)。

四.四数之和-LeeCode 18

Leecode链接: LeetCode 18
文章链接: 代码随想录

给你一个由 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

示例：

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

思路

本体与三数之和类似，只不过需要多加一个指针，也就是多加一个for循环，其余基本一致。

实现代码

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>>res;
        sort(nums.begin(),nums.end());

        for(int i = 0;i<nums.size();i++){
            if(nums[i]>target&&nums[i]>0){
                break;
            }

            if(i>0&&nums[i] == nums[i-1]){//去重
                continue;
            }

            for(int k = i+1;k<nums.size();k++){
                if(nums[k] + nums[i]>target&&nums[k]>0){
                    break;
                }

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

                int left = k+1;
                int right = nums.size()-1;

                while(left<right){
                    if((long)nums[i] + nums[k] + nums[left] + nums[right]>target){
                        right--;
                    }
                    else if((long)nums[i] + nums[k] + nums[left] + nums[right]<target){
                        left++;
                    }
                    else{
                        res.push_back(vector<int>{nums[i],nums[k],nums[left],nums[right]});
                        while((right>left)&&nums[right] == nums[right-1]){
                            right--;
                        }
                        while((right>left)&&nums[left] == nums[left+1]){
                            left++;
                        }

                        right--;
                        left++;
                    }
                }
            }
        }

        return res;
    }
};

个人问题

没有考虑到target可能是负数的问题，在if(nums[i]>target&&nums[i]>0)判断时漏掉nums>0。即当target为-11，数组为[-5,-4,-3,-2,1,3,3,5]，第一个元素就是大于target立马退出循环，导致输出为空的vector。如果不加nums>0,这在target为正数时是没问题的，但是在负数时会出现遗漏。

总结

三数之和的进阶版，算法时间复杂度为O(n^3),空间复杂度为O(1)。

Hollow!

关注

8
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
【算法训练 day7 哈希表与双指针】

两数之和的进阶版，算法时间复杂度为O(n)，空间复杂度为O(1)。简单题，时间复杂度O(n)，空间复杂度为O(1)。题目是双指针的应用，要把握好外循环for是移动i指针，内循环while是移动left与right指针。本题考验对细节的的把握，什么时候移动左指针，什么时候移动右指针，以及避免多余判断进行剪枝。时间复杂度O(n^2),空间复杂度O(1)。三数之和的进阶版，算法时间复杂度为O(n^3),空间复杂度为O(1)。
复制链接

扫一扫