2023秋招算法题每日学习（6）

不爱吃核桃的阿伟

已于 2022-11-24 16:19:06 修改

阅读量159

点赞数 3

分类专栏：秋招准备数据结构与算法文章标签：算法 c++ 数据结构 leetcode

于 2022-11-24 16:19:03 首次发布

本文链接：https://blog.csdn.net/weixin_44979918/article/details/128012266

版权

秋招准备数据结构与算法专栏收录该内容

13 篇文章 3 订阅

订阅专栏

DAY 6

1.leetcode 15 三数之和

考察点：哈希解法双指针法

对于哈希解法比较费时，而且针对去重的操作有很多细节需要考虑，不方便做剪枝操作，该题不推荐使用哈希解法。采用双指针法

双指针法(思路简单，去重操作是关键)：时间复杂度：O(n^2)。

解题步骤：

1.先进行排序操作

2. 进行一次for循环，i为下标0的点，left为i+1的点，right 为数组结尾的点

3.在遍历i的时候，首先要进行去重操作，i要与之前出现的数据进行比对，不应该和后面的数据比较。我们要做的是不能有重复的三元组，但三元组内的元素是可以重复的！

 // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1])
             {
                continue;
            }
            */
 // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) 
            {
                continue;
            }

4.三个指针的数相加，如果数据之和大于零，则将right左移，反之则将left右移，直到left与right相遇为止。（left与right的去重与i的思路一致,但是有一点需要注意，去重逻辑应该在找到一个三元数之后，防止漏掉[0,0,0]这样的三元组）

实现代码如下：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) 
    {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        //找出a+b+c = 0
        //a = nums[i],b = nums[left],c = nums[right]
        for(int i = 0;i<nums.size();i++)
        {
            //排序之后如果第一个元素已经大于0.那么无论任何组合都不可能凑成三元数，直接返回结果即可
            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(right>left)
            {
                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]});
                    //去重逻辑应该放在找到一个三元数之后
                    while(right>left&&nums[right] == nums[right-1]) right--;
                    while(right>left&&nums[left] == nums[left+1]) left++;
                    //找到答案后，双指针同时收缩
                    right--;
                    left++;
                }
              
            }
            
        }
        return result;
    }
};

2.leetcode 18 四数之和

考察点：双指针法

解题思想：和三数之和是一个思路，都是用双指针法，基本解法就是在三数之和的解法基础上再套一层循环

但是有一些细节需要注意，例如：不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。（因为target可能存在负数）

四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n^2)，四数之和的时间复杂度是O(n^3) 。（其中两重剪枝与去重操作是重点，具体操作见代码）

具体实现代码：

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();k++)
        {
            //一级剪枝
            if(nums[k] > target && (nums[k] >=0||target>=0))
            {
                break;// 这里使用break，统一通过最后的return返回
            }
            //一级去重
            if(k>0 && nums[k] == nums[k-1])
            {
                continue;
            }
            //第二层循环
            for(int i = k+1;i<nums.size();i++)
            {
                //二级剪枝操作
                if(nums[k]+nums[i]>target&&(nums[i]+nums[k]>=0||target>=0))
                {
                    break;
                }
                //二级去重操作
                if(i>k+1&&nums[i] == nums[i-1])
                {
                    continue;
                }
                int left = i+1;
                int right = nums.size()-1;
                while(right>left)
                {
                    // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                    if((long)nums[k]+nums[i]+nums[left]+nums[right]>target)
                    {
                        right--;
                    }
                    // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    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]});
                        //去重逻辑应该放在找到一个四元数之后
                        // 对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 result;
    }
};

3.AcWing 854 Floyd求最短路

考察点：Floyd算法多源汇最短路

原理是基于动态规划不能有负权回路

解题步骤：（1）用邻接矩阵存储所有边

（2）三层循环求出dist[i,j]

d[k,i,j] 求解从i到j，经过k条边的最短距离(动态规划简单示意)

优化后

具体代码实现：

#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int N = 210,INF = 1e9;

int n,m,Q;
int d[N][N];

void floyd()
{
    for(int k = 1;k<=n;k++)
        for(int i = 1;i<=n;i++)
            for(int j = 1;j<=n;j++)
            d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
}

int main()
{
    scanf("%d%d%d",&n,&m,&Q);
    //初始化
    for(int i = 1;i<=n;i++)
        for(int j = 1;j<=n;j++)
        if(i == j)d[i][j] = 0;
        else d[i][j] = INF;
    
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        d[a][b] = min(d[a][b],c);
    }
    floyd();
    
    while(Q--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        int t = d[a][b];
        if(t>INF/2 ) puts("impossible");
        else printf("%d\n",t);
    }
    return 0;
}

截止到此，已经将AcWing 上的所以图论求解最短路的方法已经全部学习结束，现在进行一些总结性的复习

4.leetcode 383 赎金信

考察点：哈希解法

本题相当于求字符串a 和字符串b 是否可以相互组成，而这道题目是求字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a。

本题判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成，但是这里需要注意两点。

第一点“为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思” 这里说明杂志里面的字母不可重复使用。
第二点 “你可以假设两个字符串均只含有小写字母。” 说明只有小写字母，这一点很重要

因为题目所只有小写字母，那可以采用空间换取时间的哈希策略，用一个长度为26的数组还记录magazine里字母出现的次数。然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。依然是数组在哈希法中的应用。

具体实现代码：

（1）利用map进行哈希求解(不适合数据量大的情况)

//利用map求解哈希表
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine)
     {
         unordered_map<char,int>hash;
         for(auto c:magazine) hash[c]++;
            for(auto c:ransomNote)
            {
                if(!hash[c]) return false;
                else hash[c]--;
            }
            return true;
    }
};

（2）利用数组进行哈希求解

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

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++) 
        {
            // 通过recode数据记录 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;
    }
};