Leetcode 算法面试冲刺 热题 HOT 100 刷题（75 76 78 79 84）（五十八）

已于 2022-05-13 09:33:15 修改
阅读量1.2k 收藏
点赞数
分类专栏： 算法面试冲刺 文章标签： leetcode 算法 职场和发展
于 2022-05-06 10:22:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43716712/article/details/124602791
版权
本文介绍了几种经典的算法问题，包括颜色分类的排序算法实现，如双指针和冒泡排序；最小覆盖子串问题，涉及字符串查找策略；子集生成，采用递归回溯法；单词搜索，利用深度优先搜索解决；以及柱状图中寻找最大矩形面积的算法，通过扫描线法求解。文章通过实例解析和代码展示，深入浅出地探讨了这些算法的应用。
摘要由CSDN通过智能技术生成

文章目录


75 78 79

75. 颜色分类

在这里插入图片描述
就用了一个排序算法。

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        if not nums or len(nums) == 0:
            return
        n = len(nums)
        for i in range(n - 1):
            for j in range(i + 1, n):
                if nums[i] > nums[j]:
                    nums[i], nums[j] = nums[j], nums[i]
        return nums

双指针的方法，回头再翻回来看吧。

第二遍复盘，两遍双指针。

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        if not nums or len(nums) == 0:
            return
        
        left, right = 0, len(nums) - 1
        while left < right:
            while left < right and nums[left] == 0:
                left += 1
            while left < right and (nums[right] == 2 or nums[right] == 1):
                right -= 1
            nums[left], nums[right] = nums[right], nums[left]
        right = len(nums) - 1

        while left < right:
            while left < right and nums[left] == 1:
                left += 1
            while left < right and nums[right] == 2:
                right -= 1
            nums[left], nums[right] = nums[right], nums[left]
        return nums

在这里插入图片描述
在这里插入图片描述

76. 最小覆盖子串

在这里插入图片描述
在这里插入图片描述

看了答案，挺难的，先跳过吧。

78. 子集

在这里插入图片描述
知道要用回溯，但是不会写

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        if not nums or len(nums) == 0:
            return 
        n = len(nums)
        pth = []
        res = []
        for i in nums:
            if i not in pth:
                pth.append(i)
                
            pth.pop()

        def backtracking(nums, pth, res):

下面是答案：

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []
        n = len(nums)
        
        def helper(i, tmp):
            res.append(tmp)
            for j in range(i, n):
                helper(j + 1,tmp + [nums[j]] )
        helper(0, [])
        return res

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res = []
        tmp = []
        def backtrace(nums, startindex):
            #if startindex >= len(nums):
            res.append(tmp[:])
            for i in range(startindex, len(nums)):
                tmp.append(nums[i])
                backtrace(nums, i + 1)
                tmp.pop()

        nums = sorted(nums)
        backtrace(nums, 0)
        return res

写出来了，还得复习

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        if not nums or len(nums) == 0:
            return 
        n = len(nums)
        pth = []
        res = []
        def backtracking(pth, start):
            res.append(pth[:])
            for i in range(start, n):
                pth.append(nums[i])
                backtracking(pth, i + 1)
                pth.pop()
        backtracking(pth, 0)
        return res

在这里插入图片描述
第二遍写了，还是懵懵懂懂，递归九讲，必须再复习刷一下题。

class Solution:
    def subsets(self, nums: List[int]):
        if not nums or len(nums) == 0:
            return 
        res, tmp = [], []
        def helper(start):
            res.append(tmp[:])
            for i in range(start, len(nums)):
                tmp.append(nums[i])
                helper(i + 1)
                tmp.pop()
        nums = sorted(nums)
        helper(0)
        return res

79. 单词搜索

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
面试考过，不会。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

const exist = (board, word) => {
    const m = board.length;
    const n = board[0].length;
    const used = new Array(m);    // 二维矩阵used，存放bool值
    for (let i = 0; i < m; i++) {
        used[i] = new Array(n);
    }
    // canFind 判断当前点是否是目标路径上的点
    const canFind = (row, col, i) => { // row col 当前点的坐标，i当前考察的word字符索引
        if (i == word.length) {        // 递归的出口 i越界了就返回true
            return true;
        }
        if (row < 0 || row >= m || col < 0 || col >= n) { // 当前点越界 返回false
            return false;
        }
        if (used[row][col] || board[row][col] != word[i]) { // 当前点已经访问过，或，非目标点
            return false;
        }
        // 排除掉所有false的情况，当前点暂时没毛病，可以继续递归考察
        used[row][col] = true;  // 记录一下当前点被访问了
        // canFindRest：基于当前选择的点[row,col]，能否找到剩余字符的路径。
        const canFindRest = canFind(row + 1, col, i + 1) || canFind(row - 1, col, i + 1) ||
            canFind(row, col + 1, i + 1) || canFind(row, col - 1, i + 1); 

        if (canFindRest) { // 基于当前点[row,col]，可以为剩下的字符找到路径
            return true;    
        }
        used[row][col] = false; // 不能为剩下字符找到路径，返回false，撤销当前点的访问状态
        return false;
    };

    for (let i = 0; i < m; i++) { // 遍历找起点，作为递归入口
      for (let j = 0; j < n; j++) {
        if (board[i][j] == word[0] && canFind(i, j, 0)) { // 找到起点且递归结果为真，找到目标路径
          return true; 
        }
      }
    }
    return false; // 怎么样都没有返回true，则返回false
};

在这里插入图片描述
这个想法太优美了。

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        m, n = len(board), len(board[0])
        used = [[False] * n for _ in range(m)]
        def dfs(row, col, i): # 判断当前点是否是目标路径上的点. row col 当前点的坐标，i当前考察的word字符索引
            if i == len(word): # 递归结束条件 : 找到了单词的最后一个
                return True
            if row < 0 or row >= m or col < 0 or col >= n: # 越界
                return False
            if used[row][col] or board[row][col] != word[i]:# 已经访问过,或者不是word里的字母
                return False
            # 排除掉上面的false情况，当前点是合格的，可以继续递归考察
            used[row][col] = True #  记录一下当前点被访问了
            if dfs(row+1, col, i+1) or dfs(row-1, col, i+1) or dfs(row, col+1, i+1) or dfs(row, col-1, i+1): # 基于当前点[row,col]，可以为剩下的字符找到路径
                return True
            used[row][col] = False # 不能为剩下字符找到路径，返回false，撤销当前点的访问状态，继续考察别的分支
            return False


        for i in range(m):
            for j in range(n):
                if board[i][j] == word[0] and dfs(i, j, 0):
                    return True
        return False

尝试自己写了下，还要复习第二遍。

class Solution:
    def exist(self, board: List[List[str]], word: str):
        m, n = len(board), len(board[0])
        print(m, n)
        visited = [[False] * n for _ in range(m)]
        def dfs(row, col, i):
            if i == len(word):
                return True
            if row < 0 or row >= m or col < 0 or col >= n:
                return False
            if visited[row][col] or board[row][col] != word[i]:
                return False
            visited[row][col] = True
            if dfs(row + 1, col, i + 1) or dfs(row - 1, col, i + 1) or dfs(row, col + 1, i + 1) or dfs(row, col - 1, i + 1):
                return True
            visited[row][col] = False
            return False
        for i in range(m):
            for j in range(n):
                if board[i][j] == word[0] and dfs(i, j, 0):
                    return True
        return False

在这里插入图片描述

84. 柱状图中最大的矩形

在这里插入图片描述
在这里插入图片描述
不会。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

from typing import List


class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        size = len(heights)
        res = 0

        for i in range(size):
            left = i
            cur_height = heights[i]
            while left > 0 and heights[left - 1] >= cur_height:
                left -= 1

            right = i
            while right < size - 1 and heights[right + 1] >= cur_height:
                right += 1

            max_width = right - left + 1
            res = max(res, max_width * cur_height)
        return res

我写的暴力解法：

class Solution:
    def largestRectangleArea(self, heights: List[int]):
        if not heights or len(heights) == 0:
            return 0
        n = len(heights)
        res = 0
        for i in range(n):
            cur_height = heights[i]
            left = i
            while left > 0 and heights[left - 1] >= cur_height:
                left -= 1
            right = i
            while right < n - 1 and heights[right + 1] >= cur_height:
                right += 1
            max_width = right - left + 1
            res = max(res, max_width * cur_height)
        return res

在这里插入图片描述

大叔爱学习.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode hot 100(刷题篇1)(1/3/2/206/20/19/5/21/34/53)
weixin_44786370的博客
07-13 619
leetcode hot 100(刷题篇1)
【算法】LeetCode 热题 HOT 100 整理
weixin_37779325的博客
03-05 2574
目录23.合并K个升序链表 这里没太多花里胡哨的了，暂时就是把做过的值得记录的题整理一下。 23.合并K个升序链表 这个题。。你说它是hard吧，我觉得并不没达到，但你说不是hard吧，我自己做还真没AC，一直在超时，用了 优先队列 之后才成功AC，排在88%左右。 所以这个题主要是为了记录一下 优先队列 的这个概念，以及使用方式。 不过首先还是说一下题目思路，一下有几种题解： 每次合并两个链表，对于k个链表，合并k-1次 每次合并两个链表，对于k个链表，合并log2klog_2klog2​k次 优先队
算法刷题笔记-hot100-1-10（进行中）
xingzhes_的博客
05-28 238
文章目录[1. 两数之和](https://leetcode.cn/problems/two-sum/)题意题解[2. 两链表数相加](https://leetcode.cn/problems/add-two-numbers/)题意题解方法1：不适用虚拟头节点方法2：代码优化：使用虚拟头节点[3. 无重复字符的最长子串](https://leetcode.cn/problems/longest-substring-without-repeating-characters/)题意题解[4. 寻找两个正序数组的
LeetCode Hot100题刷题笔记
weixin_51495617的博客
03-11 290
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。因为 nums[0] + nums[1] == 9 ，返回 [0, 1]。整数，并返回它们的数组下标。你可以按任意顺序返回答案。，请你在该数组中找出。
LeetCode 热题 HOT 100【题型归类汇总，助力刷题】
梦~'
03-18 6761
LeetCode 热题 HOT 100🔥【题型归类汇总】，超详细，不断优化ing ...
LeetCode 热题Hot100 刷题历程
qq_43031201的博客
05-12 623
@[TOC]LeetCode 热题Hot100 刷题历程 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdo
leetcode hot100，面试真题解析
2401_84141210的博客
04-17 453
【代码】leetcode hot100，面试真题解析。
leetcode答案-Leetcode:Leetcode算法题，刷题心得
06-30
leetcode 答案 自己 Leetcode 刷题 的 代码 分各种类别 --》每个不同的数据结构、不同的算法思想 大都 记录了 自己的理解，心得 后期开始，也 督促下 自己 做题 要有 时间概念，所以 记录了 几个时间点 第一遍 做的...
Leetcode以及一些常见的面试题，刷题详解，透彻解析
05-26
Leetcode以及一些常见的面试题，刷题详解，透彻解析。适用人群：计算机，软件工程等专业的大学生，找工作，找实习，提升能力，作为练习使用，高分通过OJ测试。 Leetcode以及一些常见的面试题，刷题详解，透彻解析。...
lrucacheleetcode-leetcode-hot-100:LeetCode热题HOT100
06-29
热题100的思路及解决方法 简单 1. 两数之和 LeetCode地址: class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: if not nums: return [] usedNums = {} for index, num in enumerate...
算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip
10-03
这份压缩包文件“算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip”包含了一系列关于算法、数据结构、LeetCode刷题以及Go和Java语言在解决面试问题中的应用。以下是这些主题的详细讨论...
LeetCode热题HOT-100 刷题记录
weixin_45883188的博客
03-30 306
LeetCode 热题 Hot 100 😍😍😍
hot 100刷题小结 1
leisure_SU的博客
08-14 1440
力扣hot100的前三分之一，记录下做题和思考的过程。
leetcode-hot100刷题第四天
qq_41820217的博客
04-11 687
文章目录一、最长有效括号(leetcode-32)问题描述示例解法分析代码实现二、搜索旋转排序数组(leetcode-33)问题描述示例解法分析代码实现三、在排序数组中查找元素第一个和最后一个位置(leetcode-34)问题描述示例解法分析代码实现四、组合总和(leetcode-39)问题描述示例解法分析代码实现五、接雨水(leetcode-42)问题描述示例解法分析代码实现总结 一、最长有效括...
Leetcode 算法面试冲刺 热题 HOT 100 刷题（300 301 309 312 322）（六十七）
爱学习的大叔的博客
08-05 634
Leetcode 算法面试冲刺 热题 HOT 100 刷题（300 301 309 312 322）（六十七）
力扣算法 Java 刷题笔记【快速排序】hot100（一）快速排序 快速选择算法 1
心海非海_のBlog
07-27 438
方法一：二叉堆（优先队列）【推荐】 方法二：快排 洗牌算法 加随机打乱后： ......
Leetcode 算法面试冲刺 热题 HOT 100 刷题（160 169 198 200 206）（六十三）
爱学习的大叔的博客
05-18 242
文章目录160. 相交链表169. 多数元素198. 打家劫舍动态规划4步法：1、确定状态最后一步子问题2、转移方程3、初始条件和边界情况4、计算顺序200. 岛屿数量206. 反转链表 160. 相交链表 尝试写了下，没写出来。 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None
【Leetcode56】合并区间（数组 | 排序）
最新发布
发现问题，并解决问题，批判性思维
09-07 203
# 二、思路 - 先将所有子列表按照`start_pos`进行排序，有利于保持顺序性，每次处理新子列表时，只用和结果列表`ans_lst`的最后一个子列表对比，如果有重合则合并，然后将合并的新子列表插入结果列表 - 排序可以使用`lambda`函数，`intervals.sort(key=lambda x: x[0])` - 时间复杂度O(n)，空间复杂度O(n) # 三、代码 ```python class Solution(object): def merge(self, intervals):
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值