FLGB-CSDN博客

原创【多维动态规划】Leetcode 64. 最小路径和【中等】

时间复杂度：遍历了一次二维数组dp，时间复杂度为O(m*n)，其中m为网格的行数，n为网格的列数。空间复杂度：使用了一个二维数组dp，空间复杂度为O(m*n)。：因为路径 1→3→1→1→1 的总和最小。说明：每次只能向下或者向右移动一步。

2024-04-28 11:40:52 20

原创【多维动态规划】Leetcode 62. 不同路径【中等】

时间复杂度：遍历了一次二维数组dp，时间复杂度为O(m*n)，其中m为网格的行数，n为网格的列数。空间复杂度：使用了一个二维数组dp，空间复杂度为O(m*n)。问总共有多少条不同的路径？

2024-04-28 11:17:38 51

原创【动态规划】Leetcode 32. 最长有效括号【困难】

时间复杂度：遍历了一次字符串s，时间复杂度为O(n)，其中n为字符串s的长度。空间复杂度：使用了一个一维数组dp，空间复杂度为O(n)。：最长有效括号子串是 “()()”

2024-04-26 14:11:29 123 1

原创【动态规划】Leetcode 416. 分割等和子集【中等】

时间复杂度：遍历了一次数组nums，并使用了一个二维数组dp，时间复杂度为O(n * sum)，其中n为数组nums的长度，sum为数组nums的总和。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。空间复杂度：使用了一个二维数组dp，空间复杂度为O(n * sum)。：数组可以分割成 [1, 5, 5] 和 [11]。这是一个典型的动态规划问题，可以使用动态规划来解决。

2024-04-26 11:47:24 486

原创【动态规划】Leetcode 152. 乘积最大子数组【中等】

我们定义两个数组 maxDp 和 minDp，其中 maxDp[i] 表示以 nums[i] 结尾的乘积最大的连续子数组的乘积，而 minDp[i] 表示以 nums[i] 结尾的乘积最小的连续子数组的乘积。这里为什么是**nums[i], maxDp[i-1] nums[i]**两个比较?时间复杂度：遍历了一次数组nums，时间复杂度为O(n)，其中n为数组nums的长度。当前的 nums[i] 自身就构成一个连续子数组，此时乘积最大；当前的 nums[i] 与之前的连续子数组相乘后得到的乘积更大。

2024-04-26 11:04:56 341

原创【动态规划】Leetcode 300. 最长递增子序列【中等】

是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的。时间复杂度：外层循环遍历了数组nums，内层循环遍历了0到i - 1，时间复杂度为O(n^2)，其中n为数组nums的长度。这个问题可以使用动态规划来解决。我们定义一个长度为 nums.length 的整型数组 dp，**解释：**最长递增子序列是 [2,3,7,101]，因此长度为 4。空间复杂度：使用了长度为n的数组dp，空间复杂度为O(n)。

2024-04-25 15:10:46 276

原创【动态规划】Leetcode 139. 单词拆分【中等】

4、使用两层循环遍历字符串s的每个字符，外层循环遍历从1到s.length()，内层循环遍历从0到i，判断从0到j的子串是否可以被拆分，并且判断从j到i的子串是否在wordDict中，如果满足条件，则将dp[i]设置为true。这个方程的意思是，如果存在一个 j，使得 dp[j] 为 true并且字典中包含 s.substring(j, i)，那么 dp[i] 就可以被设置为 true，表示字符串 s 的前 i 个字符可以被拼接而成。：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

2024-04-25 11:29:43 311

原创【动态规划】Leetcode 322. 零钱兑换【中等】

这个方程的意思是，如果当前的金额 i 可以由硬币的面额 coin 和金额 i - coin 组成，那么 dp[i] 就可以通过 dp[i - coin] + 1 来更新，即将 coin 加入到凑成金额 i 的硬币组合中。4、使用循环遍历从1到amount的每个金额i，内层循环遍历硬币数组coins，更新dp[i]为dp[i - coin] + 1和dp[i]中的较小值，其中coin为硬币的面额。1、我们定义一个长度为 amount+1 的数组 dp，其中 dp[i] 表示凑成金额 i 所需的最少硬币数量。

2024-04-25 10:35:22 611

原创【动态规划】Leetcode 279. 完全平方数【中等】

完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。时间复杂度：外层循环遍历了n次，内层循环遍历了sqrt(n)次，时间复杂度为O(n * sqrt(n))。空间复杂度：使用了长度为n + 1的数组dp，空间复杂度为O(n)。给你一个整数 n ，返回和为 n 的完全平方数的最少数量。

2024-04-24 11:37:01 257

原创【动态规划】Leetcode 198. 打家劫舍【中等】

定义一个数组 dp，其中 dp[i] 表示偷窃前 i 个房屋能够获得的最高金额。你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。时间复杂度：遍历一次数组，时间复杂度为O(n)，其中n为房屋的数量。空间复杂度：使用了长度为n的数组dp，空间复杂度为O(n)。偷窃到的最高金额 = 1 + 3 = 4。，一夜之内能够偷窃到的最高金额。

2024-04-24 11:09:24 480

原创【动态规划】Leetcode 118. 杨辉三角【简单】

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。

2024-04-23 15:19:38 181

原创【动态规划】Leetcode 70. 爬楼梯【简单】

8 空间复杂度：使用了长度为n + 1的数组dp，空间复杂度为O(n)。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？需要 n 阶你才能到达楼顶。：有两种方法可以爬到楼顶。

2024-04-23 14:43:12 311

原创【贪心算法】Leetcode 763. 划分字母区间【中等】

像 “ababcbacadefegde”, “hijhklij” 这样的划分是错误的，因为划分的片段数较少。划分结果为 “ababcbaca”、“defegde”、“hijhklij”。注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s。空间复杂度：使用了长度为26的数组lastIndex，空间复杂度为O(1)。时间复杂度：遍历字符串s，时间复杂度为O(n)，其中n为字符串s的长度。返回一个表示每个字符串片段的长度的列表。每个字母最多出现在一个片段中。

2024-04-23 14:10:52 738

原创【贪心算法】Leetcode 45. 跳跃游戏 II【中等】

从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。时间复杂度：遍历一次数组，时间复杂度为O(n)，其中n为数组nums的长度。空间复杂度：仅使用了常数级的额外空间，空间复杂度为O(1)。表示从索引 i 向前跳转的最大长度。] 的最小跳跃次数。生成的测试用例可以到达。跳到最后一个位置的最小跳跃数是 2。处，你可以跳转到任意。

2024-04-23 13:35:41 195

原创【贪心算法】Leetcode 55. 跳跃游戏【中等】

给你一个非负整数数组 nums ，你最初位于数组的第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。判断你是否能够到达最后一个下标，如果可以，返回 true；否则，返回 false。时间复杂度：遍历一次数组，时间复杂度为O(n)，其中n为数组nums的长度。空间复杂度：仅使用了常数级的额外空间，空间复杂度为O(1)。

2024-04-23 11:31:12 408

原创【贪心算法】Leetcode 121. 买卖股票的最佳时机【简单】

你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。时间复杂度：遍历一次数组，时间复杂度为O(n)，其中n为数组prices的长度。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0。空间复杂度：仅使用了常数级的额外空间，空间复杂度为O(1)。

2024-04-23 10:55:55 169

原创【堆】Leetcode 295. 数据流的中位数【困难】

double findMedian() 返回到目前为止所有元素的中位数。addNum方法的时间复杂度为O(log n)，其中n为数据流中元素的个数，因为在插入元素时需要维护堆的平衡。// 返回 1.5 ((1 + 2) / 2)如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。void addNum(int num) 将数据流中的整数 num 添加到数据结构中。findMedian方法的时间复杂度为O(1)，因为只需要获取堆顶元素即可。由于使用了两个优先队列，所以空间复杂度为O(n)。

2024-04-22 13:12:59 469

原创【堆】Leetcode 347. 前 K 个高频元素【中等】

时间复杂度：统计频率的时间复杂度为O(n)，构建最小堆的时间复杂度为O(k log k)，总时间复杂度为O(n + k log k)。（k->n时，时间复杂度O(nlogn）)给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。空间复杂度：哈希表和最小堆各需要O(n)的额外空间。

2024-04-22 11:15:19 521

原创【堆】Leetcode 215. 数组中的第K个最大元素【中等】

时间复杂度：插入一个元素到堆中的时间复杂度为O(log k)，总共有n个元素，因此总时间复杂度为O(n log k)。（如果不算使用的数据结构内部，插入复杂度就是O(n)）请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。空间复杂度：O(k)，堆的大小最多为k。

2024-04-22 10:47:11 363 1

原创【栈】Leetcode 84. 柱状图中最大的矩形【困难】

时间复杂度：O(n)，其中n为柱状图的高度数组heights的长度。因为需要遍历柱状图的高度数组一次。给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1。空间复杂度：O(n)，使用了一个额外的栈来存储柱子的索引。求在该柱状图中，能够勾勒出来的矩形的最大面积。：最大的矩形为图中红色区域，面积为 10。

2024-04-19 17:38:58 571 1

原创【栈】Leetcode 739. 每日温度【中等】

时间复杂度：O(n)，其中n为温度数组temperatures的长度。因为需要遍历温度数组一次，并且每个元素最多入栈一次。是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。空间复杂度：O(n)，使用了一个额外的栈来存储温度数组的索引。，表示每天的温度，返回一个数组。

2024-04-19 14:16:30 367

原创【栈】Leetcode 394. 字符串解码【中等】

表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像。空间复杂度：O(n)，最坏情况下，需要额外的栈空间来存储重复次数和临时结果。时间复杂度：O(n)，其中n为字符串s的长度。因为需要遍历字符串s一次。给定一个经过编码的字符串，返回它解码后的字符串。

2024-04-19 11:43:21 217

原创【栈】Leetcode 155. 最小栈【中等】

空间复杂度：push、pop、top、getMin操作的空间复杂度均为O(n)，其中n为栈中元素的个数，因为需要额外的栈来存储最小元素。时间复杂度：push、pop、top、getMin操作的时间复杂度均为O(1)，因为栈的操作时间复杂度为O(1)。设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。--> 返回 -3.minStack.getMin();--> 返回 -2.minStack.top();

2024-04-18 17:49:42 433

原创【栈】Leetcode 20. 有效的括号【简单】

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。空间复杂度：O(n)，最坏情况下，需要将所有左括号压入栈中，占用额外的空间。时间复杂度：O(n)，其中n为字符串s的长度。因为需要遍历一次字符串。

2024-04-18 16:38:11 227

原创【二分查找】Leetcode 4. 寻找两个正序数组的中位数【困难】

时间复杂度：O(log(min(m, n)))，其中m和n分别为nums1和nums2的长度。因为每次查找时，都将问题的规模缩小一半。空间复杂度：O(log(min(m, n)))，因为使用了递归算法，需要递归调用log(min(m, n))次。：合并数组 = [1,2,3] ，中位数 2。算法的时间复杂度应该为。

2024-04-18 15:04:31 202

原创【二分查找】Leetcode 153. 寻找旋转排序数组中的最小值【中等】

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。时间复杂度：O(log n)，其中n为数组nums的长度。因为使用了二分查找算法。：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。，它原来是一个升序排列的数组，并按上述情形进行了多次。你必须设计一个时间复杂度为。请你找出并返回数组中的。空间复杂度：O(1)。

2024-04-18 13:30:59 227

原创【二分查找】Leetcode 33. 搜索旋转排序数组【中等】

和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1。时间复杂度：O(log n)，其中n为数组nums的长度。因为使用了二分查找算法。你必须设计一个时间复杂度为。按升序排列，数组中的值。给你旋转后的数组。空间复杂度：O(1)。

2024-04-18 11:42:07 341

原创【技巧】Leetcode 31. 下一个排列【中等】

整数数组的下一个排列是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的下一个排列就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。时间复杂度：O(n)，其中n为数组nums的长度。整数数组的一个排列就是将其所有成员以序列或线性顺序排列。给你一个整数数组 nums ，找出 nums 的下一个排列。修改，只允许使用额外常数空间。空间复杂度：O(1)。

2024-04-18 10:52:32 274

原创【技巧】Leetcode 75. 颜色分类【中等】

给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。时间复杂度：O(n)，其中n为数组nums的长度。因为只需遍历一次数组。我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。必须在不使用库内置的 sort 函数的情况下解决这个问题。：通过交换使得红、蓝颜色排序好，中间剩下的全是白色。这个问题可以使用荷兰国旗问题的思想来解决，空间复杂度：O(1)。

2024-04-16 16:52:10 246

原创【技巧】Leetcode 169. 多数元素【简单】

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。时间复杂度：O(n)，其中n为数组nums的长度。因为只需遍历一次数组。你可以假设数组是非空的，并且给定的数组总是存在多数元素。：通过抵消不同的元素，最终剩下的就是多数元素。空间复杂度：O(1)。

2024-04-16 14:12:20 704

原创【二分查找】Leetcode 34. 在排序数组中查找元素的第一个和最后一个位置【中等】

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。示例 1：输入[3,4]

2024-04-16 13:53:59 234

原创【二分查找】Leetcode 74. 搜索二维矩阵【中等】

时间复杂度：O(m + n)，其中m为矩阵的行数，n为矩阵的列数。因为每次迭代都会将行索引或列索引移动一次，最多移动m + n次。给你一个整数 target ，如果 target 在矩阵中，返回 true；否则，返回 false。空间复杂度：O(1)。

2024-04-16 11:56:38 729

原创【二分查找】Leetcode 35. 搜索插入位置【简单】

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。时间复杂度：O(log n)，其中n为数组nums的长度。因为使用二分查找算法。请必须使用时间复杂度为 O(log n) 的算法。空间复杂度：O(1)。

2024-04-16 11:25:27 289

原创【回溯】Leetcode 131. 分割回文串【中等】

时间复杂度：O(N * 2^N)，其中N为字符串s的长度。因为对于每个位置，最坏情况下需要尝试2^N种分割方案，每种分割方案都需要判断每个子串是否是回文串。给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是。空间复杂度：O(N^2)，存储所有可能的分割方案。返回 s 所有可能的分割方案。

2024-04-15 14:31:02 317

原创【回溯】Leetcode 79. 单词搜索【中等】

时间复杂度：O(N * 4^L)，其中N为二维字符网格中的单元格数，L为单词的长度。因为对于每个单元格，最坏情况下需要尝试四个方向的递归搜索，单词的长度为L。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。二维字符网格 board 和一个字符串单词 word。如果 word 存在于网格中，返回 true；否则，返回 false。空间复杂度：O(L)，递归调用栈的深度为单词的长度。

2024-04-15 14:03:31 451

原创【回溯】Leetcode 22. 括号生成【中等】

时间复杂度：由于回溯算法的性质，最坏情况下时间复杂度为O(4^n / √n)，其中n是括号对数。数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。空间复杂度：O(n)，递归调用栈的深度为括号对数n。

2024-04-15 11:34:16 294

原创【回溯】Leetcode 39. 组合总和【中等】

时间复杂度：由于回溯算法的性质，最坏情况下时间复杂度为O(N^target)，其中N是candidates数组的长度，target是目标数。中可以使数字和为目标数 target 的所有不同组合，并以列表形式返回。如果至少一个数字的被选数量不同，则两种组合是不同的。2 和 3 可以形成一组候选，2 + 2 + 3 = 7。对于给定的输入，保证和为 target 的不同组合数少于 150 个。空间复杂度：O(target)，递归调用栈的深度为目标数target。7 也是一个候选， 7 = 7。

2024-04-12 17:27:28 312

原创【回溯】Leetcode 51. N 皇后【困难】

1、初始化棋盘：创建一个大小为 n×n 的棋盘，用二维数组表示，初始时所有位置都为空（用 ‘.’ 表示）。2、回溯搜索：从第一行开始逐行放置皇后，在放置每一行的皇后时，都需要检查当前位置是否合法。在递归的过程中，需要记录已经放置的皇后的位置，以便进行回溯。研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。6、回溯：在搜索过程中，如果发现当前位置无法放置皇后，或者已经找到了一个解，3、递归结束条件：当放置了所有的皇后时，即递归到达了棋盘的最后一行，

2024-04-12 17:02:43 402

原创【回溯】Leetcode 17. 电话号码的字母组合【中等】

时间复杂度：O(3^N * 4^M)，其中N是digits字符串中对应数字为3个字母的数量，M是digits字符串中对应数字为4个字母的数量。因为对于数字3和4，分别有3个和4个字母，所以时间复杂度是3^N * 4^M。给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。空间复杂度：O(3^N * 4^M)，存储所有可能的字母组合。**输入：**digits = “23”

2024-04-11 15:25:59 430

原创【回溯】Leetcode 78. 子集【中等】

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的。空间复杂度：O(2^N)，存储所有可能的子集。不能包含重复的子集。

2024-04-11 14:10:49 282

空空如也

空空如也