6.1+6.2——day11+day12——计科大一0基础面向工作式学习

原创 已于 2025-06-03 00:55:40 修改 · 1.4k 阅读 · 32 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#算法 #数据结构 #c++ #leetcode #代码随想录
#哈希算法
于 2025-06-03 00:55:27 首次发布

学习概要：

代码随想录：哈希表

        6.四数相加Ⅱ：leetcode454

本题解题步骤：

  1. 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
  2. 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
  3. 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
  4. 再遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
  5. 最后返回统计值 count 就可以了

方法一：

这是我自己想的使用两个unordered_map来解决问题，但是呢逐个访问unordered_map的语法我不会，是网上查的

时间复杂度o(n*n)

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int n=nums1.size();
        int sum=0;
        unordered_map<int,int> sum12;
        unordered_map<int,int> sum34;
        
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(sum12.find(nums1[i]+nums2[j])!=sum12.end()){
                    sum12[nums1[i]+nums2[j]]++;
                }else{
                    sum12[nums1[i]+nums2[j]]=1;
                }
            }
        }

        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(sum34.find(nums3[i]+nums4[j])!=sum34.end()){
                    sum34[nums3[i]+nums4[j]]++;
                }else{
                    sum34[nums3[i]+nums4[j]]=1;
                }
            }
        }

        for(auto it = sum12.begin();it!=sum12.end();it++)
        {
            if(sum34.find(-(it->first))!=sum34.end()){
                sum+=sum12[it->first]*sum34[-(it->first)];
            }
        }

        return sum;
    }
};

方法二：

优化了空间复杂度的常数因子，并且避开了迭代器逐个访问unordered_map里面所有键值对的步骤

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int n=nums1.size();
        int sum=0;
        unordered_map<int,int> sum12;
        
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                sum12[nums1[i]+nums2[j]]++;
            }
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(sum12.find(-(nums3[i]+nums4[j]))!=sum12.end()){
                    sum+=sum12[-(nums3[i]+nums4[j])];
                }
            }
        }
        return sum;
    }
};

        7.赎金信leetcode383

方法一：自己想出来的耶耶耶，依旧是使用unordered_map，不过使用的键值对类型是<char,int>,分别统计每个字符出现的个数，最后保证ran中需要的字符小于等于mag中的字符（好像可以优化，我自己再优化看看，见方法二）

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char,int> mag;
        unordered_map<char,int> ran;
        for(int i=0;i<ransomNote.length();i++)
        {
            ran[ransomNote[i]]++;
        }

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

        for(auto it=ran.begin();it!=ran.end();it++)
        {
            if(it->second > mag[it->first]){
                return false;
            }
        }
        return true;
    }
};

 方法二：

优化思路同上提一样，减少了一个unordered_map的使用，并且避免了使用迭代器去访问unordered_map的每一个元素。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char,int> mag;
        for(int i=0;i<magazine.length();i++)
        {
            mag[magazine[i]]++;
        }

        for(int i = 0;i<ransomNote.length();i++)
        {
            mag[ransomNote[i]]--;
            if(mag[ransomNote[i]]<0){
                return false;
            }
        }

        return true;
    }
};

方法三：

因为题目说只有小写字母，那可以采用空间换取时间的哈希策略，用一个长度为26的数组来记录magazine里字母出现的次数。

然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。

依然是数组在哈希法中的应用。

一些同学可能想，用数组干啥，都用map完事了，其实在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！

就是使用数组映射

a->0

b->1

以此类推。

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

    }
};
  • 时间复杂度: O(m+n)，其中m表示ransomNote的长度，n表示magazine的长度
  • 空间复杂度: O(1)

8.三数之和leetcode15

方法一：

是可以用哈希法解决的，具体见代码随想录网站题解和力扣上题解。——我暂时放过这种方法了，我去寻找其他方法吧,但是到时候重新做的时候要把这种方法搞懂。you know？

方法二：

使用set<vector<int>>容器，将每一个三元组排序后再插入，这样就可以利用set的自动去重功能，达到去重的效果。方法是自己想的，但是过程中一些语法是问AI的。但是好像时间复杂度有点过于高了，过了311/314个测试点，那个最后执行的输入有点太复杂了，时间超限了

好好看好好学，里面有很多语法细节

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        set<vector<int>> result;
        unordered_map<int,int> hash;
        for(int i=0;i<nums.size();i++)
        {
            hash[nums[i]]=i;
        }
        for(int i=0;i<nums.size();i++)
        {
            for(int j=0;j<nums.size();j++)
            {
                if(hash.find(-(nums[i]+nums[j]))!=hash.end()){
                    int target=-nums[i]-nums[j];
                    if(hash[target]!=i&&i!=j&&j!=hash[target]){
                        vector<int> tmp={nums[i],nums[j],-nums[i]-nums[j]};
                        sort(tmp.begin(),tmp.end());
                        result.insert(tmp);
                    }
                }
            }
        }
        return vector<vector<int>> (result.begin(),result.end());
    }
};

把代码给AI后确实发现很多问题，如下：

代码分析

时间复杂度
  • ​​双重循环​​：外层循环遍历数组 (O(n))，内层循环遍历数组 (O(n))，组合为 ​​O(n²)​​
  • ​​哈希查找​​：每次查找操作平均 O(1)，最坏 O(n)
  • ​​排序三元组​​：每次对固定大小的三元组排序 (O(1))，但执行 O(n²) 次
  • ​​set插入​​：红黑树插入时间复杂度为 O(log k)，k 为当前元素数量
  • ​​总体时间复杂度​​：​​O(n² log n)​​（log n 来自 set 插入）//时间复杂度确实有点过于高了
空间复杂度
  • ​​哈希表​​：存储 n 个元素 → ​​O(n)​​
  • ​​结果集​​：最坏情况需存储 O(n²) 个三元组 → ​​O(n²)​​
缺陷
  1. ​​索引覆盖​​：哈希表只存储最后出现的索引，当存在重复元素时可能漏解//这个是必须要解决的并且还没想到什么好方法解决
    示例：[0,0,0]，哈希表只记录最后一个 0 的索引
  2. ​​重复解​​：依赖排序三元组 + set 去重，代价高
  3. ​​冗余计算​​：双重循环产生大量重复检查
  4. ​​边界无效​​：当元素不足 3 个时仍执行计算

方法三：

排序+双指针+剪枝

剪枝的操作确实蛮繁琐的也很难想完全，还是要自己多画图多想，多实践，还是要自己分析具体输入的时候为什么输出会出错，而不是一直依赖AI；

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){return result;}
            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({nums[i],nums[left],nums[right]});
                    while(left<right&&nums[right]==nums[right-1]){right--;}
                    while(left<right&&nums[left]==nums[left+1]){left++;}
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

方法四：排序+半剪枝

在方法三的基础上巧妙的使用set<vector<int>>来实现不遗漏的去重，这样好像会增加时间复杂度，不过也可以通过所有测试点就是了

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        set<vector<int>> result;
        sort(nums.begin(),nums.end());

        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]>0){return vector<vector<int>> (result.begin(),result.end());}
            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.insert({nums[i],nums[left],nums[right]});
                    //while(left<right&&nums[right]==nums[right-1]){right--;}
                    //while(left<right&&nums[left]==nums[left+1]){left++;}
                    right--;
                    left++;
                }
            }
        }
        return vector<vector<int>> (result.begin(),result.end());
    }
};

方法五：双指针+排序+完全不剪枝也是可以过的

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        set<vector<int>> result;
        sort(nums.begin(),nums.end());

        for(int i=0;i<nums.size();i++)
        {
            //if(nums[i]>0){return vector<vector<int>> (result.begin(),result.end());}
            //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.insert({nums[i],nums[left],nums[right]});
                    //while(left<right&&nums[right]==nums[right-1]){right--;}
                    //while(left<right&&nums[left]==nums[left+1]){left++;}
                    right--;
                    left++;
                }
            }
        }
        return vector<vector<int>> (result.begin(),result.end());
    }
};

        8.四数之和leetcode18

方法1；排序+双指针+剪枝

我觉得比三数之和麻烦太多了，特别是剪纸操作，还有一些代码的逻辑其实我还不是很清楚，明天复习三数之和和四数之和，要都重新做一遍，特别是四数之和的剪纸操作！！

在AI和代码随想录的帮助下也勉强AC（我自己写的代码，去交给AI改错，以及和代码随想录比对，但是一些不一样的我不觉得我有错，但是修改了那个地方就是有一些测试点过不了，所以明天我要搞懂这些不一样的地方到底有什么问题）

AC代码如下

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

        for(int i=0;i<nums.size();i++)
        {
   
            if(i>0&&nums[i]==nums[i-1]){continue;}
            if(target>=0&&nums[i]>target){return result;}


            for(int j=i+1;j<nums.size();j++)
            {
                if(j>i+1&&nums[j]==nums[j-1]){continue;}
                if(target>=0&&nums[i]+nums[j]>target){break;}
                int left=j+1;
                int right=nums.size()-1;
                
                while(left<right){
                    if((long)nums[i]+nums[j]+nums[left]+nums[right]>target){
                        right--;
                    }else if((long)nums[i]+nums[j]+nums[left]+nums[right]<target){
                        left++;
                    }else{
                        result.push_back({nums[i],nums[j],nums[left],nums[right]});
                        while(left<right&&nums[left]==nums[left+1]){left++;}
                        while(left<right&&nums[right]==nums[right-1]){right--;}
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;   
    }
};

cimo_1
关注
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 465
超详细的Floyd算法教程，一看就懂！
医用超声图像模拟系统算法：线密度详解
alxraves的博客
06-23 467
在超声成像中，线密度（Line Density）是指单位扫描角度或单位扫描宽度内超声扫描线的数量。简单来说，它描述了超声探头在扫描区域内发射和接收声波线的密集程度。核心概念扫描线：超声探头发射的每一条声波束，对应图像中的一条垂直线（A-mode）或图像重建的一个数据采集通道（B-mode）。线间距：相邻两条扫描线中心之间的距离，是线密度的倒数。单位：通常表示为线/度（对于扇形扫描）或线/厘米（对于线性扫描）。更高的线密度意味着更密集的采样，理论上能获得更丰富的图像细节和更好的横向分辨率。
CodeQUEEN 2026 -qual- (AtCoder Beginner Contest 462)题解
Timmylyx0518的博客
06-20 262
第六次 AK，记录一下。
算法日记 | 二分查找
在读大学生
06-23 96
本文介绍了二分查找算法的核心思想与实战应用，通过三道经典题目由浅入深地讲解： 基础入门：通过洛谷P1833模拟二分查找过程，展示如何通过中间值比较收缩区间，时间复杂度O(log n)。关键是用变量维护查找区间，注意大数溢出问题。 STL实战：在P1678高考志愿题中，利用lower_bound快速定位最接近分数线的学校，强调预处理排序和边界处理（如估分超出所有学校范围的情况）。
数据结构基础复习——排序算法的关键代码片段
2301_80025611的博客
06-22 324
针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空或。
linux内核内存二次机会算法&refualt算法
Network, Linux Kernel
06-23 115
linux 内核传统LRU的二次机会算法实现细节
【leetcode】983.最低票价js
2402_83244812的博客
06-23 926
本文介绍了两种动态规划方法解决旅行购票问题。第一种方法基于自然日定义dp数组，dp[i]表示从第i天到最后一天覆盖所有旅行日的最小花费，分当天是否旅行两种情况处理。第二种方法基于旅行日索引定义dp数组，dp[i]表示处理前i个旅行日的最小花费，通过三种购票方式（1天/7天/30天票）寻找最优解。两种方法都通过状态转移方程和边界条件实现，代码示例展示了具体实现逻辑。
【STL】算法
呆瓜的博客
06-22 269
本文介绍了C++标准库算法的术语规范与基本要求。主要内容包括：1) 标准区间表示法如[A,B)及其遍历规则；2) 等值判断二元谓词的三项强制要求；3) 排序/堆算法中严格弱序的定义及合法谓词示例；4) 升序序列和大顶堆的具体判定标准；5) 算法头文件<algorithm>和<numeric>的功能划分。特别强调所有比较函数必须满足不修改参数、结果一致性和严格弱序等核心规范。
现代CAD几何内核中的求交算法——从曲线求交到曲面求交的原理与实现
m0_53082780的博客
06-21 222
无论是模型布尔运算、特征建模、曲面修剪、装配分析，还是数控加工中的刀具路径规划，其底层都离不开各种形式的几何求交。然而在工业级CAD内核中，由于大量采用NURBS曲线与曲面表示复杂几何对象，传统解析求解方法已经难以适用，取而代之的是基于参数空间、数值迭代以及拓扑重建的一整套工程化算法体系。本文从CAD几何内核的角度出发，系统介绍曲线求交、曲线曲面求交以及曲面曲面求交的数学本质和工程实现流程，并结合OpenCASCADE等主流CAD内核的实现思想，帮助读者建立完整的几何求交知识框架。
C语言学习笔记 - 55.流程控制9 - 选择5 - if...else if多分支语句
weixin_57913829的博客
06-17 334
本文介绍了C语言中if-elseif多分支语句的核心概念和应用。该语句专门用于处理多个互斥条件的选择问题，通过自上而下依次判断表达式，从多个分支中选择且仅执行一个语句块。文章详细阐述了语法格式、执行逻辑，并提供了成绩等级划分和一元二次方程求解两个典型示例。同时指出了常见错误，如条件判断顺序错误、单独的else语句等，并对比了if-elseif与嵌套if语句的优劣，强调前者在代码简洁性和可读性方面的优势。
[LC优选算法#7] 分治:快排&归并 | 库存管理 III | 排序数组 | 交易逆序对的总数
C++开发
06-22 214
本文介绍了两种经典的分治排序算法——快速排序和归并排序，并结合LeetCode题目展示了它们的应用。 快速排序部分： 通过库存管理III问题，展示了快速选择算法解决TopK问题的思路，时间复杂度O(N)。 使用随机选key和数组三块分区的方法实现快速排序变种。 归并排序部分： 以排序数组题目为例，展示了标准归并排序的实现，时间复杂度O(NlogN)。 重点分析了交易逆序对问题，提出利用归并排序过程中计算逆序对数量： 通过升序/降序版本归并排序统计逆序对巧妙利用已排序子数组的性质优化计算。
C语言学习笔记20260620-数字筛选算法：排除4的倍数与含4数字
2503_92342417的博客
06-20 644
本文介绍了C语言中处理数字筛选问题的三种方法，目标是排除1到n之间4的倍数和含数字4的数。方法一使用数学取模运算逐位检查；方法二通过封装函数提高代码模块化和可读性；方法三将数字转为字符串处理。三种方法各具特点：方法一基础但效率高，方法二可读性最佳，方法三适合复杂判断条件。文章建议根据实际需求选择合适方法，其中方法二的函数封装方式在算法竞赛中最具实用性。
算法：前缀和、差分
2502_92963723的博客
06-23 85
pre[i][j]
LeetCode 3264.K次乘运算后的最终数组I
tus00000的博客
06-17 253
如果nums的大小为n，数组中最大值为U，multiplier为m，则此算法时间复杂度为O(nlognlog。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。输入：nums = [1,2], k = 3, multiplier = 4。1 次操作后 [2, 2, 3, 5, 6]2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]5 次操作后 [8, 4, 6, 5, 6]
LeetCode热题100（每日温度）
最新发布
m0_46433333的博客
06-23 203
那在遍历的时候自然需要把当前元素和栈中的元素对比，脑中过一遍你自然知道，如果当前元素大于栈顶元素该怎么做，如果小于栈顶元素直接入栈就行。3.现在碰到比较难的的题目，我的第一反应往往不是去看题解，而是尝试自己去写一遍，前提是确实之前不懂的时候看过题解，看到题目时候会有一个大概的思路，写着写着就明白了。写到这里还是很开心的，从第一次做的时候有点懵，看视频题解可能也有点不理解，到现在拿到题目可以按自己的理解敲出来。2.这里唯一需要注意的你往栈中存的是数组的下标，比较的时候比的是具体的值。
【算法】专题一：双指针之呈最多水的容器，有效三角型的个数，和为 s 的两个数字，三数之和，四数之和
2501_93351213的博客
06-17 291
3.当 price[left] + price[right] > target 时，同理我们可以舍去price[right] （最⼩的数都满⾜不了你，你也没救了）。根据解法⼀中的优化思想，我们可以固定⼀个最⻓边，然后在⽐这条边⼩的有序数组中找出⼀个⼆元组，使这个⼆元组之和⼤于这个最⻓边。v = (right - left) * min( height[right], height[left])容器的左边界为 height[left] ，右边界为 height[right]。为了⽅便叙述，我们假设。
算法总结（链表、哈希）
2503_93247646的博客
06-17 639
在文章的最后，还有一个细节需要被提及，就是虚拟头节点。无论是我们构建链表，还是做链表的算法题也好，虚拟头节点一直是我们无法回避的一个点，不是说没有虚拟头节点我们做不了，而是可以更加的方便，可以把所有的操作全部统一而且不需要考虑空链表报错的情况本篇文章就到这里结束了，希望可以对大家有所帮助~~~
玉石五轴机加工痛点与对策：从0.5秒延迟到0.08秒响应的算法演进
2401_85950624的博客
06-21 275
在服务超过200家玉石加工厂的调研中，我们发现一个普遍现象：用户从三轴升级到五轴后，并非“一步到位”解决问题，反而遇到了新的加工困境——高曲面、薄壁件、深腔结构下的共振断裂、路径抖动、刀纹残留。同一把刀具在不换刀的情况下，完成了从粗加工到精加工的全流程（共计8.5小时），而对比机需要中途停机校准3次。采用新架构设备后，在加工参数不变的情况下（主轴16000rpm，进给200mm/min），裂纹率降至。对于玉石加工，建议废品率应低于百分之二，超过这个比例的设备，长期运营成本会显著高于采购时的“账面节省”
【算法六十一】75. 颜色分类
IronMurphy的博客
06-22 44
时间复杂度：O(N)空间复杂度：O(1)时间复杂度：O（N）空间复杂度：O（1）
亚马逊SEO推广怎么做Listing关键词优化？2026年亚马逊算法实操指南
wingie5的博客
06-23 149
很多卖家把时间花在后台关键词上反复调整，但A9对标题已出现的关键词会自动匹配，后台再去堆同样的词等于浪费字节空间。Listing优化真正的价值不在"搜得到"这一步——搜索排名只决定曝光量，曝光到点击靠主图和价格，点击到成交靠五点、A+和Review。三个环节各自独立，优化任何一个环节的效果会被前一个环节的效率上限卡住。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值