wellwang1993-CSDN博客

原创 leetcode139-Word Break

这道题目用贪心肯定不行，因为字符串有多种拆分的方式，所以肯定是需要用动态规划解的，题目说如果在字典中都能找到的返回true，那么我们就用dp[i]数组来表示从0到i的字符串是否可拆分，最终返回dp的最后一个元素即是最终的答案，而0～i可以分为0。i，如果dp[j]是可以拆分的同时S[i,j]子串也在字典中存在那么dp[i]肯定可以拆分，注意只要能找到一个字串能满足拆分需求的那就说明位置i处是可以拆分的。解释: 返回 true 因为 “leetcode” 可以由 “leet” 和 “code” 拼接成。

2024-06-18 23:45:13 488

原创 leetcode122-Best Time to Buy and Sell Stock II

由于可以反复购买，那么遍历数组只要下一个元素比当前元素大的利润累加起来就是最大利润(比如第一天3元，第二天4元，第三天7元，总利润肯定是第一天买第三天卖最大，但是由于交易可以重复进行，所以第一天买第二天卖，第二天买第三天卖的利润是一样的)随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。在每一天，你可以决定是否购买和/或出售股票。输入：prices = [7,1,5,3,6,4]总利润为 4 + 3 = 7。

2024-06-16 20:21:50 274

原创 leetcode120-Triangle

我们自上而下处理的时候，很明显每一行的第一个元素的dp公式可以写成dp[i][j] = dp[i-1][j] + triangle[i][j]，而最后一行可以写成dp[i][j] = dp[i-1][j-1] + triangle[i][j]。相邻的结点在这里指的是下标与上一层结点下标相同或者等于上一层结点下标 + 1 的两个结点。输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）

2024-06-12 23:50:55 292

原创 leetcode64-Minimum Path Sum

我们定义dp[i][j]为到当前位置最短路径和，由题目可知他一定等于grid[i][j]+min(dp[i-1][j]+dp[i][j-1])，所以递推公式有了。接下来需要处理好边界情况，即dp[0][i]和dp[i][0]的情况，注意这种情况每个位置的最短距离一定是前面的路径累加和。输入：grid = [[1,3,1],[1,5,1],[4,2,1]]解释：因为路径 1→3→1→1→1 的总和最小。说明：每次只能向下或者向右移动一步。

2024-06-04 23:33:59 347

原创 leetcode63-Unique Paths II

i]不再都是1了，因为当obstacleGrid[i][0]或者obstacleGrid[0][i]是1的时候，对应的dp也是0，而且往后都是0，因为有了路障也没法到达了。再需要注意的是dp公式也有前提条件了，即obstacleGrid[i][j]是0的时候才能求dp[i][j]，否则dp[i][j]根本到达不了。输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]这道题目新增了路障，要注意横坐标和纵坐标分别为0的情况，dp[i][0]和dp[0]

2024-06-04 00:20:47 219

原创 leetcode62-Unique Paths

每次只能向下或者向右，我们可以用dp[i][j]表示走到当前的路径，那么dp公式就可以为dp[i][j]=dp[i-1][j]+dp[i][j-1] ，最后注意起始条件，即第一行和第一列的路径数只能是1。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。输入：m = 3, n = 7。问总共有多少条不同的路径？

2024-06-03 23:52:00 275

原创 leetcode486-Predict the Winner

每一回合，玩家从数组的任意一端取一个数字（即，nums[0] 或 nums[nums.length - 1]），取到的数字将会从数组中移除（数组长度减 1 ）。这道题目很自然用递归的方式解，由于每次从头或者尾任取一个数字，所以递归的过程中需要同时考虑这俩种情况，只要上一轮的玩家输了那么本轮该玩家一定赢。如果玩家1能赢或者玩家1 和玩家2能打平都返回true，所以我们很自然的想到玩家1的分数>=玩家2的分数的情况下肯定是true。所以，玩家 1 的最终分数为 1 + 2 = 3，而玩家 2 为 5。

2024-06-01 20:38:33 297

原创 leetcode390-Elimination Game

这道题目就想试试递归的思路，很明显数组的长度为1的时候是递归终止的条件，然后他的逻辑是一轮按左往右一轮按右往左，所以可以用一个遍历标示它的遍历方向。从左往右的时候就是不断用i+2的值来填充，但是从右往左的时候切忌要处理好数组元素奇偶的情况，如果是奇数则还删除的是第一个元素，如果是偶数删除的是第2个元素。列表 arr 由在范围 [1, n] 中的所有整数组成，并按严格递增排序。也就是，删除最右侧的数字，然后剩下的数字每隔一个删除一个。从左到右，删除第一个数字，然后每隔一个数字删除一个，直到到达列表末尾。

2024-05-29 23:50:21 219

原创 leetcode231-Power of Two

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true；否则，返回 false。如果求余2不为0的能说明一定不是2的幂次方，处理好边界条件，通过递归不断缩小范围。如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。

2024-05-28 23:04:40 325

原创 leetcode1137-N-th Tribonacci Number

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2。这都题目很容易得到dp公式dp[i] = dp[i-1]+dp[i-2]+dp[i-3]，注意处理边界条件。给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

2024-05-27 23:30:12 179

原创 leetcode1025-Divisor Game

这道题目如果用递归解会有很多重复计算，比如计算n=6的时候肯定会计算到x=3的情况，计算n=12的时候也肯定会计算到x=3的情况，所以考虑采用递归。用dp[i]标示n=i爱丽丝的输赢情况，爱丽丝赢的条件是n % x==0同时鲍勃输，所以我们可以遍历n，同时取x（从1到n之间的整数），对于n % x == 0的情况爱丽丝可能会赢，同时还需要dp[n-x]=false（代表鲍勃输的情况下）选出任一 x，满足 0 < x < n 且 n % x == 0。用 n - x 替换黑板上的数字 n。

2024-05-27 23:21:05 142

原创 leetcode392-Is Subsequence

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。这道题目可以遍历s也可以遍历t，遍历s时间复杂度可能更低一点，遍历期间就是要判断s的顺序是否和t保持一致即可。给定字符串 s 和 t ，判断 s 是否为 t 的子序列。输入：s = “abc”, t = “ahbgdc”

2024-05-26 16:34:49 133

原创 leetcode338-Counting Bits

给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，计算其二进制表示中 1 的个数，返回一个长度为 n + 1 的数组 ans 作为答案。可以一个一个去计算每个数字的位数，也可以通过观察数字的规律找到更简单的办法，每个数字的位数和前一个数字的位数有很大的关系。输出：[0,1,1]

2024-05-26 16:08:21 173

原创 leetcode237-Best Time to Buy and Sell Stock

解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；每次遍历记录一个最小值，同时记录当前值和最小值的差值，找一个最大的差值即是最大利润。输入：[7,1,5,3,6,4]

2024-05-25 16:32:16 148

原创 leetcode119-Pascal‘s Triangle II

杨辉三角每位数字就是上一行同一列＋上一行前一列的和，这道题目要求我们在一个一维数组里不停的更新每一位数字。由于要求第rowIndex行，结合题目肯定是要遍历rowIndex遍，而内循环则是从最右边开始遍历按照dp[j] = dp[j] + dp[j-1]的规律计算，注意不能从最左边开始遍历因为实际上在一纬数组中每个数字前面的部分相当于上一行的元素，在计算出当前元素的时候是不能先计算该元素前面的元素的。给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。输出: [1,3,3,1]

2024-05-25 16:17:00 194

原创 leetcode118-Pascal‘s Triangle

充分利用杨辉三角的特性，俩边都是1，中间元素等于上一行当前列元素＋上一行当前列元素的前一个元素和。输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。输入: numRows = 5。

2024-05-23 23:06:33 254

原创 leetcode70-Climbing Stairs

爬到顶层n有俩种方式，要么是从第n-1层直接爬1层上来，要么是从第n-2层爬2层上来，所以状态转移方程为dp[n] = dp[n-1]+dp[n-2]。由于dp数组是从0开始的，所以第n层为dp的n-1下标。所以爬1层方法为1即dp[0]=1,爬2层方法为2即dp[1] = 2。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？需要 n 阶你才能到达楼顶。解释：有两种方法可以爬到楼顶。

2024-05-22 23:44:28 332

原创 leetcode1669-mergeLink

输入：list1 = [10,1,13,6,9,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]这道题目思路比较直接，在list1中找到下标为a前面的结点，一直删除到下标为b的结点，list2中找到末尾结点，然后把list2插入进去。解释：我们删除 list1 中下标为 3 和 4 的两个节点，并将 list2 接在该位置。上图中蓝色的边和节点为答案链表。请你将 list1 中下标从 a 到 b 的全部节点都删除，并将list2 接在被删除节点的位置。

2024-05-22 23:22:38 380

原创 leetcode725-Split Linked List in Parts

既然要分成k组，那么确认好每组的元素个数就可以了(总元素／k即可)，因为不是均分，所以需要把余数(总元素％k)按照1分摊到每组里。第一个元素 output[0] 为 output[0].val = 1 ，output[0].next = null。给你一个头结点为 head 的单链表和一个整数 k ，请你设计一个算法将链表分隔为 k 个连续的部分。这 k 个部分应该按照在链表中出现的顺序排列，并且排在前面的部分的长度应该大于或等于排在后面的长度。输出：[[1],[2],[3],[],[]]

2024-05-21 23:23:46 279

原创 leetcode445-Add Two Numbers II

给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。可以先翻转链表，把最低位放到最前面然后开始进行相加，注意和超过10需要进位。输入：l1 = [7,2,4,3], l2 = [5,6,4]你可以假设除了数字 0 之外，这两个数字都不会以零开头。输出：[7,8,0,7]

2024-05-21 22:58:21 336

原创 leetcode328-Odd Even Linked List

给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。我们可以用俩个指针永远指向最新的奇数和偶数，不断把偶数后面的奇数插入到奇数后面，然后更新分别指向奇数和偶数的指针。你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。第一个节点的索引被认为是奇数，第二个节点的索引为偶数，以此类推。请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。输入: head = [1,2,3,4,5]输出: [1,3,5,2,4]

2024-05-21 00:10:56 364

原创 leetcode237-Delete Node in a Linked List

删除一个结点肯定要拿到当前结点的前序结点，所以我们可以把待删除结点的下一个结点的值赋值到当前结点，这样这道题目就转换成删除当前结点的下一个结点了。node 不应该是链表的最后一个节点，而应该是链表中的一个实际节点。解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9。链表的所有值都是唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。有一个单链表的 head，我们想删除它其中的一个节点 node。我们将构建链表，并将节点传递给你的函数。

2024-05-20 23:20:44 229

原创 leetcode148-Sort List

这道题目的思路也比较明确，我们可以用递归排序的思路，先不断拆分链表直到只剩下一个结点，然后再合并俩个有序列表。拆分链表可以用快慢指针的方法。给你链表的头结点 head ，请将其按升序排列并返回排序后的链表。输入：head = [4,2,1,3]输出：[1,2,3,4]

2024-05-19 16:25:45 274

原创 leetcode143-Reorder List

这道题目的思路其实很明确，先把链表一分为二，再求第二个链表的翻转链表，再把俩个链表相互插入式的连接到一起即可。特别要注意处理一些边界情况，否则很容易空指针。不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。输入：head = [1,2,3,4]输出：[1,4,2,3]

2024-05-19 16:01:32 282

原创 leetcode92-Reverse Linked List II

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。拿例子来说，我们可以找到left的前序结点pre，链表翻转可以等同于不断的把left后面的结点往pre结点后面进行插入。输入：head = [1,2,3,4,5], left = 2, right = 4。输出：[1,4,3,2,5]

2024-05-18 16:06:33 301

原创 leetcode86-Partition List

用一个指针pre始终记录最新的比x小的结点，然后用一个指针不停的往后遍历，如果发现比x大则遍历即可，如果比x小，则将该结点放到pre结点的后面即可。给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。输入：head = [1,4,3,2,5,2], x = 3。你应当保留两个分区中每个节点的初始相对位置。输出：[1,2,2,4,3,5]

2024-05-16 23:09:03 278

原创 leetcode82-Remove Duplicates from Sorted List II

用cur指针指向链表的头结点，然后不断比较cur和她的next结点的值是否一样，如果一样则不断后移cur，最终比较哨兵结点的next是否是cur，如果不是则说明中间的元素值都一样直接更新哨兵的 next指针为cur的next，如果是的话则说明相邻俩个元素值不一样，那么后移哨兵结点继续遍历即可。给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。输入：head = [1,2,3,3,4,4,5]输出：[1,2,5]

2024-05-15 23:21:40 149

原创 leetcode61-Rotate List

这道题目用快慢指针即可解，先快指针往前走k个位置，然后和慢指针同时开始遍历，直到快指针的next为空。这个时候慢指针的next就是最新的头结点。这里要注意k比链表总长度大的情况，可以通过求余解决。给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。输入：head = [1,2,3,4,5], k = 2。输出：[4,5,1,2,3]

2024-05-15 22:45:44 231

原创 leetcode21-Swap Nodes in Pairs

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。要交换俩个结点，那肯定要拿到结点的前序结点，所以思路就是拿到俩个结点的前序结点进行交换。输入：head = [1,2,3,4]输出：[2,1,4,3]

2024-05-14 23:43:29 215

原创 leetcode19-Remove Nth Node From End of List

这道题目要求只遍历一次。删除倒数第n个结点，如果这个结点刚好是头结点那么应该返回头结点的 next结点，如果不是则可以通过pre和cur指针来实现，让cur指针往前走n步，然后和pre指针同时往前走，当cur走到最后一个结点的时候pre指针刚好是待删除结点的前序结点。给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。输入：head = [1,2,3,4,5], n = 2。输出：[1,2,3,5]

2024-05-13 23:55:39 170

原创 leetcode02-Add Two Numbers

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。输入：l1 = [2,4,3], l2 = [5,6,4]请你将两个数相加，并以相同形式返回一个表示和的链表。正常遍历俩个链表即可，需要处理俩位相加超过10的进位。解释：342 + 465 = 807.输出：[7,0,8]

2024-05-12 16:23:09 213

原创 leetcode876-Middle of the Linked List

给你单链表的头结点 head ，请你找出并返回链表的中间结点。用快慢指针即可，在快指针遍历完以后慢指针指向的就是目标结点。如果有两个中间结点，则返回第二个中间结点。输入：head = [1,2,3,4,5]解释：链表只有一个中间结点，值为 3。输出：[3,4,5]

2024-05-12 15:56:14 291

原创 leetcode234-Palindrome Linked List

可以用快慢指针的方式找到链表的中间结点，然后再将前半部分链表进行翻转，然后开始比较前半段链表和后半段链表是否严格一致即可。给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true；否则，返回 false。输入：head = [1,2,2,1]

2024-05-11 17:03:14 222

原创 leetcode206-Reverse Linked List

用一个指针记录当前位置，另外一个指针记录当前位置的前一个位置，以及另外一个指针记录下一个位置，然后遍历的过程中不停的改变当前位置的指针的next值。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。输入：head = [1,2,3,4,5]输出：[5,4,3,2,1]

2024-05-11 15:38:10 326

原创 leetcode203-Remove Linked List Elements

可以先处理掉头结点＝val的情况，然后因为要删除一个结点，删除一个结点的时候肯定需要知道被删除结点的上一个结点，所以用一个哨兵记录当前结点，一个记录上一个结点，如果当前结点和val相等那么更新上一个结点的next指针，如果不相等那就更新上一个结点。输入：head = [1,2,6,3,4,5,6], val = 6。输入：head = [], val = 1。输出：[1,2,3,4,5]

2024-05-09 23:02:03 381

原创 leetcode1290-Convert Binary Number in a Linked List to Integer

给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。这道题目就遍历链表就可以实现，先确定每一位的位数，然后分别计算每一位二进制对应的十进制数累加即可。解释：二进制数 (101) 转化为十进制数 (5)请你返回该链表所表示数字的十进制值。输入：head = [1,0,1]

2024-05-08 22:40:21 457

原创 leetcode83-Remove Duplicates from Sorted List

用一个指针从头结点开始遍历，如果当前元素和下个元素一致则更新当前指针的next结点为下个结点的下个结点，反之指针后移。给定一个已排序的链表的头 head ，删除所有重复的元素，使每个元素只出现一次。返回已排序的链表。输入：head = [1,1,2,3,3]输入：head = [1,1,2]输出：[1,2,3]

2024-05-07 23:53:17 431

原创 leetcode21-Merge Two Sorted Lists

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。输入：l1 = [1,2,4], l2 = [1,3,4]用一个指针去串联俩个链表，用一个指针记录新链表的头结点。输入：l1 = [], l2 = [0]输入：l1 = [], l2 = []输出：[1,1,2,3,4,4]

2024-05-07 23:40:32 449

原创 leetcode55-Jump Game

数组中的每个元素表示在该位置上可以跳跃的最大长度，比如第1个元素是3，它的下标是1，那就说明这个元素最远可以跳到1+3也就是下标为4的位置。我们可以用一个变量记录所有元素中能到达的最大位置，注意当元素的下标比这个变量大的时候说明前面的元素没办法跳跃到当前位置就可以返回false了，一直到最终这个变量的值达到数组的最后一个位置的时候说明可以跳跃到。解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。输入：nums = [2,3,1,1,4]

2024-05-07 00:00:06 291

原创 leetcode53-Maximum Subarray

求连续子数组的和，我们可以用一个变量cur记录连续子数组的最大和，当cur加上当前元素比当前元素还要小的时候说明不能再继续累加了，往后遍历的时候就应该用当前元素的值作为cur的初始值。同时遍历的过程中不停的取cur的最大值。给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。输入：nums = [-2,1,-3,4,-1,2,1,-5,4]解释：连续子数组 [4,-1,2,1] 的和最大，为 6。是数组中的一个连续部分。

2024-05-06 23:09:19 309

空空如也

空空如也