- 博客(295)
- 收藏
- 关注
RSS订阅原创 吃葡萄--用图形解决算法问题（java）
随着c的不断增大，就会出现情况二，此时c > 2*(a+b)，由于每个人口味的限制，X顶多吃完a和b，为了尽可能平分，c边需要被Y或Z平分，也就是说此时吃的最多的人最少可以吃到的葡萄颗数就是(c+1)/2，即平分c边向上取整。综上，「吃得最多的那个人吃得最少」就是让我们尽可能地平均分配，而吃的最多的那个人吃掉的葡萄颗数就是(a+b+c)/3向上取整的结果，也就是(a+b+c+2)/3。也就是说，这种情况下，三个人依然是可以平均分配所有葡萄的，吃的最多的人最少可以吃到的葡萄颗数依然是(a+b+c+2)/3。
2023-10-11 13:54:26
226
原创 leetcode797. 所有可能的路径(java)
另外，你应该注意到了，这个onPath数组的操作很像 回溯算法核心套路 中做「做选择」和「撤销选择」，区别在于位置：回溯算法的「做选择」和「撤销选择」在 for 循环里面，而对onPath数组的操作在 for 循环外面。输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]输入：graph = [[1,2],[3],[3],[]]输出：[[0,1,3],[0,2,3]]
2023-10-08 15:41:00
264
原创 leetcode1610. 可见点的最大数目(java)
给你一个点数组 points 和一个表示角度的整数 angle ，你的位置是 location ，其中 location = [posx, posy] 且 points[i] = [xi, yi] 都表示 X-Y 平面上的整数坐标。输入：points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1]输入：points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]
2023-09-28 14:32:30
331
原创 leetcode1036. 逃离大迷宫(java)
数组 blocked 是封锁的方格列表，其中每个 blocked[i] = [xi, yi] 表示坐标为 (xi, yi) 的方格是禁止通行的。一个很容易想到的思路是：从 s 跑一遍 BFS，然后从 t 跑一遍 BFS，同时设定一个最大访问点数量 MAX，若从两者出发能够访问的点数量都能超过 MAX，说明两点均没有被围住，最终必然会联通。同时，不允许走出网格。输入：blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]+n−1=n∗(n−1)/2。
2023-09-27 22:10:03
209
原创 LC1305. 两棵二叉搜索树中的所有元素(JAVA)
根据二叉树的性质，可以得出，中序遍历的顺序就是递增的顺序，因此，我们可以用中序遍历把两个树，先遍历出来，放进集合中，两个集合就可以用归并排序进行排序，输入：root1 = [1,null,8], root2 = [8,1]输入：root1 = [2,1,4], root2 = [1,0,3]若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。输出：[0,1,1,2,3,4]输出：[1,1,8,8]
2023-09-26 19:27:54
113
原创 leetcode334. 递增的三元子序列(java)
在 nums[i] 的左边存在一个元素小于 nums[i] 等价于在 nums[i] 的左边的最小元素小于 nums[i]，在 nums[i] 的右边存在一个元素大于 nums[i] 等价于在 nums[i] 的右边的最大元素大于 nums[i]，因此可以维护数组 nums 中的每个元素左边的最小值和右边的最大值。否则，返回 false。2. 从左到右遍历数组 nums\textit{nums}nums，对于1≤i
2023-09-25 19:59:23
213
原创 LC926. 将字符串翻转到单调递增(JAVA - 动态规划)
如果下标 i 处的字符是 1，则下标 i−1 处的字符是 0 或 1 都符合单调递增，此时为了将翻转次数最小化，应分别考虑下标 i−1 处的字符是 0 和 1 的情况下需要的翻转次数，取两者的最小值。如果一个二进制字符串，是以一些 0（可能没有 0）后面跟着一些 1（也可能没有 1）的形式组成的，那么该字符串是 单调递增 的。2.其余的每个字符，字符 0 前面的相邻字符一定是 0，字符 1 前面的相邻字符可以是 0 或 1。给你一个二进制字符串 s，你可以将任何 0 翻转为 1 或者将 1 翻转为 0。
2023-09-22 15:52:34
247
原创 LC1713. 得到子序列的最少操作次数（java - 动态规划）
比方说，[2,7,4] 是 [4,2,3,7,2,1,4] 的子序列（加粗元素），但 [2,4,2] 不是子序列。对于某个 f[i] 而言，我们需要往回检查 [0,i−1] 区间内，所有可以将 nums[i] 接到后面的位置 jjj，在所有的 f[j]+1中取最大值更新 f[i]。比方说，如果 arr = [1,4,1,2] ，那么你可以在中间添加 3 得到 [1,4,3,1,2]。输入：target = [6,4,8,1,3,2], arr = [4,7,6,2,3,8,6,1]
2023-09-21 19:47:49
96
原创 LC1035. 不相交的线（java - 动态规划）
注意 f[i−1][j]只是表示「必然不包含 s1[i]，但可能包含s2[j]」的情况，也就是说 f[i−1][j]其实是该情况与情况 1 的合集。f[i][j] 就是在上述所有情况中取 max 而来，由于情况 1 被 情况 3 和 情况 4 所包含，因此我们只需要考虑 f[i−1][j]、f[i][j−1] 和 f[i−1][j−1]+1三种状态即可，其中最后一种状态需要满足 s1[i]=s2[j]前提条件。输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
2023-09-20 11:46:42
120
原创 leetcode522. 最长特殊序列 II(java)
例如，“abc” 是 “aebdc” 的子序列，因为您可以删除"aebdc"中的下划线字符来得到 “abc”。给出一个字符串数组，在里面找出字符串满足当前字符串不是字符串数组中其他字符串的子序列，返回满足条件的字符串中 最长的字符串的长度。在所有满足要求的 str[i]中，我们选出最长的那个，返回其长度作为答案。看懂题目应该就不难了，其实就是比较一个字符串，是不是其他字符串的字串，找出所有满足条件的，然后取最长的做答案。特殊序列 定义如下：该序列为某字符串 独有的子序列（即不能是其他字符串的子序列）。
2023-09-19 18:04:52
429
原创 leetcode1092. 最短公共超序列(java-动态规划)
求解 LCS 部分我们定义 f[i][j]代表考虑s1 的前i 个字符、考虑s2 的前j 的字符，形成的最长公共子序列长度（为了方便，令下标从1开始）。str1 = “abac” 是 “cabac” 的一个子串，因为我们可以删去 “cabac” 的第一个 "c"得到 “abac”。str2 = “cab” 是 “cabac” 的一个子串，因为我们可以删去 “cabac” 末尾的 “ac” 得到 “cab”。输入：str1 = “aaaaaaaa”, str2 = “aaaaaaaa”输出：“cabac”
2023-09-19 15:49:59
205
原创 leetcode1537. 最大得分(动态规划-java)
2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],（从 nums1 开始遍历）[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10] （从 nums2 开始遍历）输入：nums1 = [1,4,5,8,9,11,19], nums2 = [2,3,4,11,12]输入：nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]最大得分为上图中的绿色路径 [2,4,6,8,10]。
2023-09-18 16:38:09
242
原创 leetcode229. 多数元素 II(java)
一个朴素的做法是使用「哈希表」进行计数，在计数完成后将所有出现次数超过 的元素加入答案。给定一个大小为 n 的整数数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。输入：nums = [3,2,3]输入：nums = [1,2]输入：nums = [1]
2023-09-16 15:42:43
387
原创 leetcode 950. 按递增顺序显示卡牌(java)
的顺序取牌，我们只需要把最小的牌放在下标为 0 的地方，第二小的牌放在下标为 1 的地方，第三小的牌放在下标为 4 的地方，依次类推即可。我们得到的牌组顺序为 [17,13,11,2,3,5,7]（这个顺序不重要），然后将其重新排序。重新排序后，牌组以 [2,13,3,11,5,17,7] 开始，其中 2 位于牌组的顶部。牌组现在是 [3,11,5,17,7,13]。牌组现在是 [5,17,7,13,11]。输入：[17,13,11,2,3,5,7]输出：[2,13,3,11,5,17,7]
2023-09-16 14:51:05
193
原创 leetcode725. 分隔链表(java)
得到链表的长度 n 之后，记 quotient=⌊n / k⌋，remainder=n % k，则在分隔成的 k 个部分中，前 remainder个部分的长度各为 quotient+1，其余每个部分的长度各为 quotient。由于分隔成的每个部分的长度和原始链表的长度有关，因此需要首先遍历链表，得到链表的长度 nnn。输入：head = [1,2,3,4,5,6,7,8,9,10], k = 3。输出：[[1,2,3,4],[5,6,7],[8,9,10]]输出：[[1],[2],[3],[],[]]
2023-09-15 16:54:08
179
原创 leetcode 817. 链表组件(java)
解释: 链表中,0 和 1 是相连接的，且 nums 中不包含 2，所以 [0, 1] 是 nums 的一个组件，同理 [3] 也是一个组件，故返回 2。同时给定列表 nums，该列表是上述链表中整型值的一个子集。解释: 链表中，0 和 1 是相连接的，3 和 4 是相连接的，所以 [0, 1] 和 [3, 4] 是两个组件，故返回 2。输入: head = [0,1,2,3,4], nums = [0,3,1,4]输入: head = [0,1,2,3], nums = [0,1,3]
2023-09-14 16:28:48
138
原创 leetcode1797. 设计一个验证系统(java)
/ tokenId 为 “bbb” 的验证码在时刻 15 过期，tokenId 为 “aaa” 的验证码在时刻 7 过期，所有验证码均已过期，所以返回 0。// tokenId 为 “aaa” 的验证码在时刻 7 过期，且 8 >= 7 ，所以时刻 8 的renew 操作被忽略，没有验证码被更新。// tokenId 为 “bbb” 的验证码在时刻 10 没有过期，所以 renew 操作会执行，该 token 将在时刻 15 过期。这道题，挺简单的，只是阅读麻烦，是个阅读题，
2023-09-14 15:35:29
212
原创 leetcode1669. 合并两个链表(java)
输入：list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]输入：list1 = [0,1,2,3,4,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]输出：[0,1,1000000,1000001,1000002,1000003,1000004,6]输出：[0,1,2,1000000,1000001,1000002,5]
2023-09-14 14:18:10
466
原创 LC1798. 你能构造出连续值的最大数目(JAVA)
如果你从这些硬币中选出一部分硬币，它们的和为 x ，那么称，你可以 构造 出 x。如果满足，我们就计算下去，求出最大的前缀和，比如最大的连续前缀和是7，那么从0开始，肯定就能有8个答案，这道题呢，我们可以理解为前缀和数组有多少是连续的，如果直接算前缀和，然后再排序，时间上肯定无法满足，然后在遍历时，求出前缀和，后面的数字如果大于前缀和 加一，那么肯无法构成连续的了，就可以中断遍历了。输入：nums = [1,4,10,3,1]输入：coins = [1,1,1,4]7：取 [4,1,1,1]
2023-09-13 14:28:07
91
原创 leetcode427. 建立四叉树(java)
输入：grid = [[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,1,0,0,0,0]]输出：[[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]解释：网格中的所有值都不相同。
2023-09-12 15:50:18
162
原创 leetcode606. 根据二叉树创建字符串(java)
或者反过来说，如果对于每个非空节点才添加 () 的话，那么当「有右子树」同时「没有左子树」时，左子树的 () 不能被忽略，需要额外添加，从而确保生成出来的字符串能够与「有左子树」同时「没有右子树」的情况区分开来，而不会产生二义性。解释：初步转化后得到 “1(2(4)())(3()())” ，但省略所有不必要的空括号对后，字符串应该是"1(2(4))(3)"。为根时，其只「有左子树」而「没有右子树」时，右子树的 () 可被忽略，或者「左右子树都没有」时，两者的 () 可被忽略。
2023-09-11 16:38:48
143
原创 leetcode 589. N 叉树的前序遍历(java)
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]递归思路比较简单，NNN 叉树的前序遍历与二叉树的前序遍历的思路和方法基本一致，每次递归时，先访问根节点，然后依次递归访问每个孩子节点即可。输出：[1,2,3,6,7,11,14,4,8,12,5,9,13,10]输入：root = [1,null,3,2,4,null,5,6]输出：[1,3,5,6,2,4]
2023-09-11 15:15:58
167
原创 leetcode386. 字典序排数(java)
共有 个数需要被处理，假设当前处理到的数为j ，根据字典序规则，在满足条件的前提下，我们优先在j 的后面添加 0（即j * 10 < n 满足），否则我们考虑将上一位回退并进行加一操作。将[1,n]的数按照字典序添加到答案，本质上是对一颗节点数量为 ，形态类似字典树的多阶树进行遍历，根节点为0，需要被跳过，因此我们可以从树的第二层开始搜索。树中每个节点的值为其搜索路径所代表的数字，且每个节点有[0,9]共10 个子节点。输出：[1,10,11,12,13,2,3,4,5,6,7,8,9]
2023-09-08 15:14:43
383
原创 leetcode 671. 二叉树中第二小的节点(java)
此外，如果当前节点的值大于等于 ans，那么根据「思路」部分，以当前节点为根的子树中所有节点的值都大于等于 ans，我们就直接回溯，无需对该子树进行遍历。设根节点的值为 rootvalue，我们只需要通过遍历，找出严格大于 rootvalue 的最小值，即为「所有节点中的第二小的值」。如果一个节点有两个子节点的话，那么该节点的值等于两个子节点中较小的一个。对于二叉树中的任意节点 xxx，xxx 的值不大于以 xxx 为根的子树中所有节点的值。给出这样的一个二叉树，你需要输出所有节点中的 第二小的值。
2023-09-08 09:29:38
453
原创 leetcode872. 叶子相似的树(java)
输入：root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]具体地，在深度优先搜索的过程中，我们总是先搜索当前节点的左子节点，再搜索当前节点的右子节点。举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。输入：root1 = [1,2,3], root2 = [1,3,2]如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。
2023-09-07 19:32:43
369
原创 leetcode897. 递增顺序搜索树(java)
给你一棵二叉搜索树的 root ，请你 按中序遍历 将其重新排列为一棵递增顺序搜索树，使树中最左边的节点成为树的根节点，并且每个节点没有左子节点，只有一个右子节点。输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]输入：root = [5,3,6,2,4,null,8,1,null,null,null,7,9]然后根据列表中的节点值，创建等价的只含有右节点的二叉搜索树，其过程等价于根据节点值创建一个链表。
2023-09-07 17:26:09
264
原创 leetcode 2. 两数相加(java)
给你两个 非空 的链表，表示两个非负的整数。输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]每一位计算的同时需要考虑上一位的进位问题，而当前位计算结束后同样需要更新进位值。，则保留个位数字，同时向前一位进 1 如果最高位有进位，则需在最前面补。如果两个链表全部遍历完毕后，进位值为 1，则在新链表最前方添加节点 1。输入：l1 = [2,4,3], l2 = [5,6,4]输入：l1 = [0], l2 = [0]输出：[8,9,9,9,0,0,0,1]输出：[7,0,8]
2023-09-07 11:26:07
323
原创 leetcode 655. 输出二叉树(java)
对于放置在矩阵中的每个节点，设对应位置为 res[r][c] ，将其左子节点放置在 res[r+1][c-2height-r-1] ，右子节点放置在 res[r+1][c+2height-r-1]。给你一棵二叉树的根节点 root ，请你构造一个下标从 0 开始、大小为 m x n 的字符串矩阵 res ，用以表示树的 格式化布局。根节点 需要放置在 顶行 的 正中间 ，对应位置为 res[0][(n-1)/2]。矩阵的列数 n 应该等于 2height+1 - 1。输入：root = [1,2]
2023-09-06 15:55:41
300
原创 leetcode687. 最长同值路径(java)
在递归函数内部，先通过递归 root 的左右子节点，拿到以 root.left 和 root.right 为起点的最大路径长度 l 和 r，然后根据当前节点值和左右子节点值的相等关系来更新 ans，同时用 cur 维护「以当前节点 root 为目标路径中深度最小（位置最高）节点时」所经过的最大路径长度。给定一个二叉树的 root ，返回 最长的路径的长度 ，这个路径中的 每个节点具有相同值。输入：root = [5,4,5,1,1,5]输入：root = [1,4,5,4,4,5]
2023-09-06 10:36:59
322
原创 leetcode669. 修剪二叉搜索树(java)
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。可以证明，存在 唯一的答案。所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。由于被修剪的是二叉搜索树，因此修剪过程必然能够顺利进行。题目数据保证输入是一棵有效的二叉搜索树。树中每个节点的值都是 唯一 的。
2023-09-05 19:28:38
508
原创 leetcode-779. 第K个语法符号(java)
接下来的每一行，将前一行中的0替换为01，1替换为10。整理一下条件：首行为 0，每次用当前行拓展出下一行时，字符数量翻倍（将 0 拓展为 01，将 1 拓展为 10），且字符种类仍为 01。行第 列的字符，我们可以通过「倒推验证」的方式来求解：假设第 行第 为 1，若能倒推出首行为 ，说明假设成立，返回 1，否则返回 0。例如，对于 n = 3 ，第 1 行是 0 ，第 2 行是 01 ，第3行是 0110。（ k 从索引 1 开始）输入: n = 1, k = 1。输入: n = 2, k = 1。
2023-09-05 18:53:34
236
原创 LC2335. 装满杯子需要的最短总时长(JAVA)
还是和上面一样，主旨思想就是凑2.那么先给他排个序，求出最大值max,然后再求出总数量sum，如果最大值大于总和的二分之一，那么凑出的2肯定少于max,直接返回max 就行了，如果小于二分之一sum，那么就能凑出的2，就是 总和的一半，然后向上取整。给你一个下标从 0 开始、长度为 3 的整数数组 amount ，其中 amount[0]、amount[1] 和 amount[2] 分别表示需要装满冷水、温水和热水的杯子数量。第 2 秒：装满一杯温水和一杯热水。第 2 秒：装满一杯冷水和一杯温水。
2023-09-05 16:23:52
96
原创 leetcode986. 区间列表的交集(java)
输入：firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]输出：[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]输入：firstList = [], secondList = [[4,8],[10,12]]输入：firstList = [[1,3],[5,9]], secondList = []返回这 两个区间列表的交集。输出：[[3,7]]
2023-09-04 23:14:27
289
原创 leetcode56. 合并区间(java)
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。输入：intervals = [[1,4],[4,5]]输出：[[1,6],[8,10],[15,18]]输出：[[1,5]]
2023-09-04 16:49:35
363
原创 leetcode1288. 删除被覆盖区间(java)
常见的排序方法就是按照区间起点排序，或者先按照起点升序排序，若起点相同，则按照终点降序排序。就是说不要偷懒，勤动手，两个区间的相对位置到底有几种可能，不同的相对位置我们的代码应该怎么去处理。只有当 c
2023-09-04 15:42:07
392
原创 leetcode645. 错误的集合(java)
不幸的是，因为数据错误，导致集合里面某一个数字复制了成了集合里面的另外一个数字的值，导致集合 丢失了一个数字 并且 有一个数字重复。如果用hashMap 去记录每个数字出现的频率，那就是简单的程度，但既然写出来这个题，就不会用hashMap,我们用原数组的基础上，实现这个功能。现在的问题是，有一个元素重复了，同时导致一个元素缺失了，这会产生什么现象呢？那么，如果我能够通过某些方法，找到这个重复对应的索引，不就是找到了那个重复元素么？找到那个没有元素对应的索引，不就是找到了那个缺失的元素了么？
2023-09-03 17:27:26
263
原创 leetcode793. 阶乘函数后 K 个零(java)
首先，数学上的正无穷肯定是无法编程表示出来的，我们一般的方法是用一个非常大的值，大到这个值一定不会被取到。比如说 int 类型的最大值INT_MAX（2^31 - 1，大约 31 亿），还不够的话就 long 类型的最大值LONG_MAX（2^63 - 1，这个值就大到离谱了）。搜索有多少个n满足trailingZeroes(n) == K，其实就是在问，满足条件的n最小是多少，最大是多少，最大值和最小值一减，就可以算出来有多少个n满足条件了。例如， f(3) = 0 ，因为 3!末尾是 0 的数量。
2023-09-03 14:40:25
345
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人