【LeetCode 刷题笔记 2022-10-19】

最新推荐文章于 2024-07-14 16:07:02 发布
最新推荐文章于 2024-07-14 16:07:02 发布
阅读量277 收藏 1
点赞数
文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/David_0925/article/details/127422897
版权

2022-10-19 笔记

1700. 无法吃午餐的学生数量

1.注意事项

  • 简单题目，直接模拟就行
  • 来源：力扣（LeetCode）
  • 链接：题目传送门

2. 代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/10/19 8:38
# @Author  : David
# @File    : 1700. 无法吃午餐的学生数量.py
# @Description : 1700. 无法吃午餐的学生数量
from typing import List

"""
    学校的自助午餐提供圆形和方形的三明治，分别用数字 0 和 1 表示。所有学生站在一个队列里，每个学生要么喜欢圆形的要么喜欢方形的。
    餐厅里三明治的数量与学生的数量相同。所有三明治都放在一个 栈 里，每一轮：

    如果队列最前面的学生 喜欢 栈顶的三明治，那么会 拿走它 并离开队列。
    否则，这名学生会 放弃这个三明治 并回到队列的尾部。
    这个过程会一直持续到队列里所有学生都不喜欢栈顶的三明治为止。
    
    给你两个整数数组 students 和 sandwiches ，其中 sandwiches[i] 是栈里面第 i 个三明治的类型（i = 0 是栈的顶部），
     students[j] 是初始队列里第 j 名学生对三明治的喜好（j = 0 是队列的最开始位置）。请你返回无法吃午餐的学生数量。

    提示:
        1 <= students.length, sandwiches.length <= 100
        students.length == sandwiches.length
        sandwiches[i] 要么是 0 ，要么是 1 。
        students[i] 要么是 0 ，要么是 1 。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/number-of-students-unable-to-eat-lunch
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
"""


def func_1(students: List[int], sandwiches: List[int]) -> int:
    """
        方法一,模拟执行的过程
        :param students: 学生列表
        :param sandwiches: 三明治列表
        :return: 返回吃不到午餐的学生数量
    """

    def insert():
        """
            将 students 中第一个数 (下标为 0) 插入到 students 最后 (下标为len(students))
            :return:None
        """
        t = students[0]
        for i in range(len(students) - 1):
            students[i] = students[i + 1]
        students[-1] = t

    if sum(students) == sum(sandwiches):
        # 没有学生吃不到午餐
        return 0
    else:
        # 有学生吃不到午餐
        result = 0  # 吃不到午餐的学生的数量

        k = j = len(students)  # 剩余学生数量
        while j > 0:
            if students[0] == sandwiches[0]:
                j -= 1  # 有一个学生已经拿到了午餐, 剩余学生数量 -1
                students.pop(0)  # 第一个学生删除
                sandwiches.pop(0)  # 第一份午餐删除
                k = j  # 记录剩余学生数量, 开始将第一个学生插入到 students 的末尾
            else:
                if k == 0:
                    # 如果所有剩余的学生都插入到 students 最后, 还有学生没有拿到午餐
                    # 则可以认为剩余的这些学生不可能拿到午餐, 记录学生的数量, 跳出循环
                    result = j
                    break
                else:
                    # 剩余没有插入到 students 末尾的学生数量
                    k -= 1
                    # 将 students 的第一个元素插入到 students 的末尾
                    insert()
        # 返回结果
        return result


class Solution(object):
    def Main(self):
        students, sandwiches = [1, 1], [0, 1]
        print(self.countStudents(students, sandwiches))

    def countStudents(self, students: List[int], sandwiches: List[int]) -> int:
        return func_1(students, sandwiches)


if __name__ == '__main__':
    Solution().Main()

60. 排列序列

1. 注意事项

  • 困难题
    • 回溯会超时
    • 需要使用数学的特点，计算第 k 个排列
  • 来源：力扣（LeetCode）
  • 链接：题目传送门

2. 代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/10/19 9:46
# @Author  : David
# @File    : 60. 排列序列.py
# @Description : 60. 排列序列

"""
    给出集合 [1,2,3,...,n]，其所有元素共有 n! 种排列。

    按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
        1. "123"
        2. "132"
        3. "213"
        4. "231"
        5. "312"
        6. "321"
    给定 n 和 k，返回第 k 个排列。

    方法一：回溯，但是容易超时

    方法二：使用数学公式直接计算
        直接用回溯法做的话需要在回溯到第k个排列时终止就不会超时了, 但是效率依旧感人
        可以用数学的方法来解, 因为数字都是从1开始的连续自然数, 排列出现的次序可以推
        算出来, 对于n=4, k=15 找到k=15排列的过程:

        1 + 对2,3,4的全排列 (3!个)
        2 + 对1,3,4的全排列 (3!个)         3, 1 + 对2,4的全排列(2!个)
        3 + 对1,2,4的全排列 (3!个)-------> 3, 2 + 对1,4的全排列(2!个)-------> 3, 2, 1 + 对4的全排列(1!个)-------> 3214
        4 + 对1,2,3的全排列 (3!个)         3, 4 + 对1,2的全排列(2!个)         3, 2, 4 + 对1的全排列(1!个)

        确定第一位:
            k = 14(从0开始计数)
            index = k / (n-1)! = 2, 说明第15个数的第一位是3
            更新k
            k = k - index*(n-1)! = 2
        确定第二位:
            k = 2
            index = k / (n-2)! = 1, 说明第15个数的第二位是2
            更新k
            k = k - index*(n-2)! = 0
        确定第三位:
            k = 0
            index = k / (n-3)! = 0, 说明第15个数的第三位是1
            更新k
            k = k - index*(n-3)! = 0
        确定第四位:
            k = 0
            index = k / (n-4)! = 0, 说明第15个数的第四位是4
        最终确定n=4时第15个数为3214

    提示：
        1 <= n <= 9
        1 <= k <= n!

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/permutation-sequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
"""
from functools import cache


class Solution(object):
    def Main(self):
        n = 3
        k = 3
        print(self.getPermutation(n, k))

    def getPermutation(self, n: int, k: int) -> str:
        @cache
        def factorial(x):
            """
            求 x 的阶乘
            :param x: x
            :return: x 的阶乘
            """
            if x < 3:
                return x
            else:
                return x * factorial(x - 1)

        k -= 1  # k 需要从 0 开始计数

        result = ""  # 排列结果
        ln = list(range(1, n + 1))  # 可选择的数的集合
        for i in range(1, n + 1):
            # i 需要从 1 到 n, 包括 n
            t = factorial(n - i)  # n-1 的阶乘

            if k == 0 or t == 0:
                # 计算 index(下标) 排除除零错误
                index = 0
            else:
                index = k // t

            # 保存每一次选择的结果
            result = f"{result}{ln[index]}"

            # 删除已经选择的数
            ln.pop(index)

            # 更新 k, 继续下一次循环
            k -= (index * t)

        # 返回结果
        return result


if __name__ == '__main__':
    Solution().Main()

1455. 检查单词是否为句中其他单词的前缀

1. 注意事项

2. 代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/10/19 11:24
# @Author  : David
# @File    : 1455. 检查单词是否为句中其他单词的前缀.py
# @Description : 1455. 检查单词是否为句中其他单词的前缀

"""
    给你一个字符串 sentence 作为句子并指定检索词为 searchWord ，其中句子由若干用 单个空格 分隔的单词组成。
    请你检查检索词 searchWord 是否为句子 sentence 中任意单词的前缀。

    如果 searchWord 是某一个单词的前缀，则返回句子 sentence 中该单词所对应的下标（下标从 1 开始）。
    如果 searchWord 是多个单词的前缀，则返回匹配的第一个单词的下标（最小下标）。如果 searchWord 不是任何单词的前缀，则返回 -1 。

    字符串 s 的 前缀 是 s 的任何前导连续子字符串。

    提示：
        1 <= sentence.length <= 100
        1 <= searchWord.length <= 10
        sentence 由小写英文字母和空格组成。
        searchWord 由小写英文字母组成。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
"""


class Solution(object):
    def Main(self):
        sentence = "i love eating burger"
        search_word = "burg"
        print(self.isPrefixOfWord(sentence, search_word))

    def isPrefixOfWord(self, sentence: str, search_word: str) -> int:
        word_list = sentence.split(" ")  # 切分句子, 获得句子中的所有单词
        for index, word in enumerate(word_list):
            if word.startswith(search_word):
                # 如果 search_word 是 word 的前缀, 返回 index +1
                return index + 1
        # 如果 search_word 不是 所有word 的前缀, 返回 -1
        return -1


if __name__ == '__main__':
    Solution().Main()

1450. 在既定时间做作业的学生人数

1. 注意事项

2. 代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/10/19 11:35
# @Author  : David
# @File    : 1450. 在既定时间做作业的学生人数.py
# @Description : 1450. 在既定时间做作业的学生人数
from typing import List

"""
    给你两个整数数组 startTime（开始时间）和 endTime（结束时间），并指定一个整数 queryTime 作为查询时间。
    
    已知，第 i 名学生在 startTime[i] 时开始写作业并于 endTime[i] 时完成作业。
    
    请返回在查询时间 queryTime 时正在做作业的学生人数。
    形式上，返回能够使 queryTime 处于区间 [startTime[i], endTime[i]]（含）的学生人数。
    
    提示：
        startTime.length == endTime.length
        1 <= startTime.length <= 100
        1 <= startTime[i] <= endTime[i] <= 1000
        1 <=queryTime <= 1000

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
"""


class Solution(object):
    def Main(self):
        start_time, end_time, query_time = [1, 2, 3], [3, 2, 7], 4
        print(self.busyStudent(start_time, end_time, query_time))

    def busyStudent(self, start_time: List[int], end_time: List[int], query_time: int) -> int:
        res = 0  # 结果, query_time 时, 正在学习的学生数量
        for i in range(len(start_time)):
            if start_time[i] <= query_time <= end_time[i]:
                res += 1
        return res


if __name__ == '__main__':
    Solution().Main()

977. 有序数组的平方

1. 注意事项

2. 代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/10/19 11:46
# @Author  : David
# @File    : 977. 有序数组的平方.py
# @Description : 977. 有序数组的平方
from typing import List

"""
    给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
    
    提示：
        1 <= nums.length <= 10^4
        -10^4 <= nums[i] <= 10^4
        nums 已按 非递减顺序 排序
"""


def func_1(nums: List[int]) -> List[int]:
    """
        方法一：模拟，但是会出现超时
        :param nums: 目标数组
        :return: 每个数字的平方 组成的新数组
    """

    def insert_sort(val: int) -> None:
        """
            插入排序
            :param val: 待插入的数
            :return: None
        """
        flag = True  # 表示 val 需要插入数组的末尾
        for i in range(1, len(nums)):
            if nums[i] < val:
                nums[i - 1] = nums[i]
            else:
                nums[i - 1] = val
                flag = False  # 表示 val 已经插入到数组种
                break

        if flag:
            # 如果 val 是数组中的最大值时，需要特殊处理一下
            nums[-1] = val

    if len(nums) >= 2:
        # 如果数组长度大于等于2
        while nums[0] < 0:
            t = nums[0] * -1  # 取 nums[0] 的相反数
            insert_sort(t)

    for i in range(len(nums)):
        nums[i] *= nums[i]

    return nums


def func_2(nums: List[int]) -> List[int]:
    """
        方法二：直接求平方，然后排序
        :param nums: 目标数组
        :return: 每个数字的平方 组成的新数组
    """
    for i in range(len(nums)):
        nums[i] *= nums[i]
    nums.sort()

    return nums


class Solution(object):
    def Main(self):
        nums = [-1,-2,-3,1,2,3]
        print(self.sortedSquares(nums))

    def sortedSquares(self, nums: List[int]) -> List[int]:
        return func_2(nums)


if __name__ == '__main__':
    Solution().Main()

1929. 数组串联

1. 注意事项

2. 代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/10/19 12:42
# @Author  : David
# @File    : 1929. 数组串联.py
# @Description : 1929. 数组串联
from typing import List

"""
    给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，
    对于所有 0 <= i < n 的 i ，满足下述所有要求：
    
    ans[i] == nums[i]
    ans[i + n] == nums[i]
    具体而言，ans 由两个 nums 数组 串联 形成。
    
    返回数组 ans 。
    
    提示：
        n == nums.length
        1 <= n <= 1000
        1 <= nums[i] <= 1000

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/concatenation-of-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
"""


class Solution(object):
    def Main(self):
        nums = [1, 2, 1]
        print(self.getConcatenation(nums))

    def getConcatenation(self, nums: List[int]) -> List[int]:
        nums.extend(nums)
        return nums


if __name__ == '__main__':
    Solution().Main()

1351. 统计有序矩阵中的负数

1. 注意事项

2. 代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/10/19 12:51
# @Author  : David
# @File    : 1351. 统计有序矩阵中的负数.py
# @Description : 1351. 统计有序矩阵中的负数
from typing import List

"""
    给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。 请你统计并返回 grid 中 负数 的数目。
    
    提示：
        m == grid.length
        n == grid[i].length
        1 <= m, n <= 100
        -100 <= grid[i][j] <= 100

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/count-negative-numbers-in-a-sorted-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
"""


def binary_search(arr: List[int], left: int, right: int, target: int):
    """
        二分查找
        返回 x 在 arr 中的索引，如果不存在返回 -1
        :param arr: 目标数组
        :param left: 左边开始位置
        :param right: 右边结束位置
        :param target: 目标值
        :return: 返回 x 在 arr 中的索引
    """
    # 基本判断
    if right >= left:
        # mid = int(l + (r - l) / 2)
        mid = (right + left) // 2
        # 元素整好的中间位置
        if arr[mid] == target:
            return mid
            # 元素小于中间位置的元素，只需要再比较左边的元素
        elif arr[mid] > target:
            # 元素大于中间位置的元素，只需要再比较右边的元素
            # return binary_search(arr, left, mid - 1, target)
            return binary_search(arr, mid + 1, right, target)
        else:
            # return binary_search(arr, mid + 1, right, target)
            return binary_search(arr, left, mid - 1, target)
    else:
        # 不存在
        return -1


def func_1(grid: List[List[int]]) -> int:
    """
        统计并返回 grid 中 负数 的数目
        解决方案:
            1. 遍历矩阵的每一行
            2. 在每一行中使用二叉查找, 找到 "-1" 的下标
            3. 记录负数的个数
            4. 返回结果

        :param grid: 目标矩阵
        :return: grid 中负数的数目
    """
    n = len(grid)
    m = len(grid[0])
    ans = 0
    if grid[n - 1][m - 1] >= 0:
        # 特殊情况, 矩阵中没有负数
        return ans
    else:
        # m 大于等于 3, 使用二分查找进行统计
        for i in range(n):
            if grid[i][0] < 0:
                # 第 i 行, 第一个数小于零, 直接判定整行都是负数
                index = 0
            elif grid[i][m - 1] < 0:
                # 如果矩阵的第 i 行的最后一个数小于 0, 表示这一行种存在负数
                index = binary_search(grid[i], 0, m, - 1)  # 找到最后一个 -1 的下标

                if index == -1:
                    # 第 i 行中不存在 -1
                    for j in range(m - 1, -1, -1):
                        # 反向遍历 grid[i], 找到第一个负数
                        if grid[i][j] < 0:
                            index = j
                else:
                    # 找到第一个 -1 的下标
                    while grid[i][index - 1] == -1:
                        index -= 1
            else:
                # 第 i 行, 第一个数大于零, 并且最后一个数大于零
                index = m

            # 统计负数的个数
            ans += (m - index)
    return ans


def func_2(grid: List[List[int]]) -> int:
    """
        统计并返回 grid 中 负数 的数目
        解决方案:暴力破解
        :param grid: 目标矩阵
        :return: grid 中负数的数目
    """
    ans = 0
    for row in grid:
        for col in row:
            if col < 0:
                ans += 1
    return ans


class Solution(object):
    def Main(self):
        # grid = [[4, 3, 2, -1], [3, 2, 1, -1], [1, 1, -1, -2], [-1, -1, -2, -3]]
        # grid = [[3, 2], [1, 0]]
        # grid = [[1, -1, -1], [-1, -1, -2]]
        grid = [[7, -3]]
        print(self.countNegatives(grid))

    def countNegatives(self, grid: List[List[int]]) -> int:
        return func_2(grid)


if __name__ == '__main__':
    Solution().Main()
    # nums = [4, 3, 2, -1]
    # print(binary_search(nums, 0, len(nums) - 1, -1))
David Deng 01
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode 第 42 场双周赛题解（Python）
blowfire123的博客
01-24 865
Leetcode 第 42 场双周赛题解 周赛日期：2020/12/26 题目1：5625. 比赛中的配对次数难度: 简单 给你一个整数 n ，表示比赛中的队伍数。比赛遵循一种独特的赛制： 如果当前队伍数是 偶数 ，那么每支队伍都会与另一支队伍配对。总共进行 n / 2 场比赛，且产生 n / 2 支队伍进入下一轮。 如果当前队伍数为 奇数 ，那么将会随机轮空并晋级一支队伍，其余的队伍配对。总共进行 (n - 1) / 2 场比赛，且产生 (n - 1) / 2 + 1 支队伍进入下一轮。 返..
谷歌师兄的leetcode刷题笔记-google-doodle:我的谷歌涂鸦
06-30
谷歌师兄的leetcode刷题笔记塞尔达传说：35 周年谷歌涂鸦 《塞尔达传说》将于 2021 年 2 月 21 日满 35 岁。多年来，这个系列对无数人来说真的很特别，我也不例外。 从 10 岁开始，我就非常痴迷。 我曾经在我哥哥看...
#力扣 LeetCode1700. 无法吃午餐的学生数量 @FDDLC
LiuXingchang的博客
05-25 272
题目描述： 1700. 无法吃午餐的学生数量 - 力扣（LeetCode） (leetcode-cn.com) 自测用例： [1,1,0,0] [0,1,0,1] [1,1,1,0,0,1] [1,0,0,0,1,1] [1] [0] [1] [1] [1,1] [0,0] [1,1,1] [1,1,1] [1,1,1,1,1,1,1] [1,0,1,0,1,0,1] Java代码： class Solution { public int countStudents(int..
Leetcode刷题笔记--Hot01-10
牵一只蜗牛去散步
05-31 389
基于滑动窗口和哈希表，用一个滑动窗口遍历字符串的字符，确保滑动窗口内的所有字符都是不重复的，当滑动字符不断扩大遇到重复字符时，将左指针右移，直到没有重复字符，这时比较滑动窗口的长度和最大长度的值，更新最大长度；使用双指针法，左指针指向左边的容器，右指针指向右边的容器，左容器容量低则左指针自增，右容器容量低则右指针自减，直到两个指针相遇，记录并更新最大容量值，具体原理证明见上面的讲解视频；遍历字符串的每个字符，用两个指针 l 和 r 分别指向其左字符和右字符，判断左字符和右字符是否相等，不断贪心向外扩展；
【LeetCode 刷题笔记 2022-10-23】
David的博客
10-23 116
LeetCode 刷题笔记 2022-10-23
【LeetCode 刷题笔记 2022-10-20】
David的博客
10-20 173
Leetcode 刷题笔记 2022-10-20
LeetCode刷题指南 - 算法必读篇
weixin_622464的博客
04-24 1337
LeetCode刷题指南 - 算法必读篇
Leetcode刷题笔记--Hot61-70
牵一只蜗牛去散步
10-14 264
状态转移方程: dp[i][j] = std::min(dp[i-1][j-1], std::min(dp[i-1][j], dp[i][j-1])) + 1;不断将剩余先修课程数为0的课程加入到队列q中，当队列为空时，若修的课程数等于总课程数，则返回true，否则返回false；遍历两遍，第一遍求解L[i]，L[i]表示第i位左边所有数的乘积；基于动态规划，dp[i][j]表示以(i, j)为右下角，所构成正方形的最大边长。每修队列q中的课程，以该课程作为先修课程的所有课程，其剩余先修课程个数减1；
LeetCode刷题笔记-数据结构-day19
小皮皮LL的博客
02-03 567
文章目录LeetCode刷题笔记-数据结构-day19997. 找到小镇的法官1.题目描述2.解题思路3.代码1557. 可以到达所有点的最少点数目1.题目描述2.解题思路3.代码841. 钥匙和房间1.题目描述2.解题思路3.代码 LeetCode刷题笔记-数据结构-day19 997. 找到小镇的法官 1.题目描述 原题链接：997. 找到小镇的法官 2.解题思路 我们可以把每个人当做一个点，如果 a 信任 b，则 a 的出度加 1，b 的入度加 1。 我们可以直接用两个数组dout[]，din
Leetcode每日刷题笔记--JAVA版（边做边更新）
weixin_51766963的博客
09-06 511
按照题目选择1. Two Sum 1. Two Sum 202121/9/6 技巧：使用HashMap将集合的数保存 public int[] twoSum(int[] nums, int target) { HashMap<Integer, Integer> Sites = new HashMap<Integer, Integer>(); for (int i = 0; i < nums.length; i++) { int
谷歌师兄的leetcode刷题笔记-Simple-IT-English:来自社区的社区智能词汇书
06-30
谷歌师兄的leetcode刷题笔记网站：简单的 IT 英语 英语是 IT 社区的唯一语言。 我知道作为非母语人士学习英语和记住英语单词是多么痛苦。 由于缺乏英语技能，许多人才工程师被排除在社区之外。 大多数公共 IT 英文...
谷歌师兄的leetcode刷题笔记-Computer-Science-Internships:德克萨斯A&M大学-圣安东尼奥的学生策划的计算机
06-30
谷歌师兄的leetcode刷题笔记计算机科学实习 这是 2021 年夏季计算机科学实习机会的非包容性清单 该列表按一般业务类别以及德克萨斯州圣安东尼奥市的本地公司细分。 您还可以查看其他本地职位。 所有链接至少将您带到...
LeetCode 刷题笔记 with Java 1-50（暗黑版）
05-17
《LeetCode 刷题笔记 with Java 1-50（暗黑版）》是一份针对Java程序员准备的LeetCode题目解析合集，旨在帮助开发者提升算法能力，掌握数据结构和编程技巧。这份文档包含了LeetCode在线平台上的前50道Java编程题目，...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
力扣224.基本计算器
Pisasama的博客
07-14 230
【代码】力扣224.基本计算器。
力扣-bfs
weixin_63551790的博客
07-12 528
何为广度优先搜索？广度优先搜索，即bfs。不同于dfs（走到底然后再换另外一条路），bfs更像是一层一层的走。常常用来处理最短路径问题。
leetcode_88. 合并两个有序数组
最新发布
qq_42742845的博客
07-14 889
给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。
力扣1111.有效括号的嵌套深度
Pisasama的博客
07-14 345
对于。
Java版LeetCode刷题笔记：51-100题解析
“LeetCode 刷题笔记 with Java 51-100（暗黑版）.pdf 是一本关于使用Java解决LeetCode算法题目的详细笔记，由沉默王二创作。该笔记涵盖51至100号题目，包含题解预览链接、LeetCode官方题目链接以及GitHub项目地址。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值