S_t_a_r_123-CSDN博客

原创跳跃游戏 III

若队不为空，则从队头取出一个下标index，先判断arr[index]是否为0，若为0则直接返回true，否则判断index+arr[index]是否在数组长度内，且没有被访问过，若满足以上两个条件就将index+arr[index]入队。下标 5 -> 下标 6 -> 下标 4 -> 下标 1 -> 下标 3。输入：arr = [4,2,3,0,3,1,2], start = 5。输入：arr = [4,2,3,0,3,1,2], start = 0。解释：无法到达值为 0 的下标 1 处。

2025-08-19 17:42:50 368

原创 LeetCode529：扫雷游戏

'M' 代表一个未挖出的地雷，'E' 代表一个未挖出的空方块，'B' 代表没有相邻（上，下，左，右，和所有4个对角线）地雷的已挖出的空白方块，数字（'1' 到 '8'）表示有多少地雷与这块已挖出的方块相邻，'X' 则表示一个已挖出的地雷。如果一个没有相邻地雷的空方块（'E'）被挖出，修改它为（'B'），并且所有和其相邻的未挖出方块都应该被递归地揭露。如果一个至少与一个地雷相邻的空方块（'E'）被挖出，修改它为数字（'1'到'8'），表示相邻地雷的数量。输入面板不会是游戏结束的状态（即有地雷已被挖出）。

2025-08-19 17:13:31 932

原创 LeetCode63：单词替换

例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。输入：dictionary = ["a", "aa", "aaa", "aaaa"], sentence = "a aa a aaaa aaa aaa aaa aaaaaa bbb baba ababa"输入：dictionary = ["catt","cat","bat","rat"], sentence = "the cattle was rattled by the battery"

2025-08-18 21:33:47 929

原创 LeetCode207：课程表

对输入的数组进行处理（构建一个邻接矩阵，同时记录节点的入度），处理完后，将入度为零的节点入队。若队不为空，则出队，将对应的visit数组下标设为true，表示已该节点访问，同时删除该节点的出边。最后遍历visit数组，若还有未访问的节点，则说明图有环即不能完成所有课程的学习，否则可以完成所有课程的学习。例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]输入的先决条件是由边组成，每条边包含两个元素，比如[1,0]，表示学习课程 1 之前，需要先完成课程 0。

2025-08-11 18:27:36 616

原创串联所有单词的子串

给定一个字符串 s 和一些长度相同的单词 words。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar"。输出时，按照索引由小到大顺序输出。注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。s中的子串无法由words串联得到，所以输出-1。最后输入n个字符串，表示words中的单词。然后输入words中单词的数目n，

2025-08-10 19:57:07 528

原创森林中的兔子

y/(x+1)是看有多少种颜色的兔子看到x只与自己颜色相同的兔子，且是能整除的，即有多少种有x+1只说话了的，再乘(x+1)表示一共多少只，若还有余数，说明还有一种颜色有x+1只，此时再加上x+1就好了。两只相同颜色的兔子看到的其他跟自己颜色相同的兔子数是一样的，所以若两只兔子看到的数量不同则说明这两只兔子是不同颜色的。如果x=0,则有看到0只跟自己颜色相同的兔子，那么0对应的值x就表示有x只不同颜色的兔子（此时res+=y）。因此森林中兔子的最少数量是 5: 3 只回答的和 2 只没有回答的。

2025-08-09 20:55:40 518

原创前K个高频单词

输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4。输入: ["i", "love", "leetcode", "i", "love", "coding"], k = 2。解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词，输出: ["the", "is", "sunny", "day"]注意，按字母顺序 "i" 在 "love" 之前。

2025-08-09 16:10:29 496

原创最长和谐子序列

用map来存数字及其频率，然后对map进行遍历，判断当前元素的键是否比前一个元素的键大1（因为map是升序排列），若大1，则记录两元素的值的和，并判断是否更新res。（以下代码多做了一步操作：将map里的数据存进vector，然后对vector里的数据进行判断）现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。和谐数组是指一个数组（长度>=2）里元素的最大值和最小值之间的差别正好是1。原因: 最长的和谐数组是：[3,2,2,2,3].输入: [1,3,2,2,5,2,3,7]

2025-08-08 17:19:43 312

原创找到字符串中所有字母异位词

先输入是字符串为 a，后输入的字符串为 b，若a的长度小于b的长度则直接返回空数组，否则遍历字符串，每一次都取出b的长度的字符串，将该字符串与b进行判断，若是字母异位词则记录结果，否则取下一个字符串进行比较。起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。

2025-08-08 16:52:39 310

原创根据字符出现频率排序

统计完后将unordered_map里的元素存入一个数组，对该数组进行排序，然后就可以用一个string来存最终结果并输出。给定一个字符串，请将字符串里的字符按照出现的频率降序排列，如果频率相同，则按照字符的ASCII码升序排列。因此'e'必须出现在'r'和't'之前，而且'r'比't'的ASCII码小。'A'和'a'被认为是两种不同的字符，并且'A'的ASCII码比'a'小。'c'和'a'都出现三次。因此按照字符升序排列，'a'在'c'前。'e'出现两次，'r'和't'都只出现一次。

2025-08-08 16:03:27 356

原创寻找右区间

对于任何区间，你需要存储的满足条件的区间 j 的最小索引，这意味着区间 j 有最小的起始点可以使其成为“右侧”区间。给定一组区间（包含起始点和终点），对于每一个区间 i，检查是否存在一个区间 j，它的起始点大于或等于区间 i 的终点，这可以称为 j 在 i 的“右侧”。解释:对于区间[1,4]和[3,4]，没有满足条件的“右侧”区间。输入: [ [3,4], [2,3], [1,2] ]输入: [ [1,4], [2,3], [3,4] ]对于[1,2]，区间[2,3]具有最小的“右”起点。

2025-08-07 20:03:42 404

原创二叉搜索子树的最大键值和

对树进行层次遍历，每次从队列弹出一个节点时，判断以该节点为根的子树是否为二叉搜索树，在判断的同时累加该树的节点和，若是二叉搜索树，则更新结果，若不是则不做处理，接着继续处理下一个节点。（若树过大，该算法会超时）输入：root = [1,4,3,2,4,2,5,null,null,null,null,null,null,4,6]解释：因为以3或4为根的二叉树不是二叉搜索树，所以键值为 2 的单节点子树是和最大的二叉搜索树。解释：因为以1为根的二叉树不是二叉搜索树，所以键值为 3 的子树是和最大的二叉搜索树。

2025-08-07 17:45:01 1006

原创从二叉搜索树到更大和树

给出二叉搜索树的根节点，该二叉树的节点值各不相同，修改二叉树，使每个节点 node 的新值等于原树中大于或等于 node.val 的所有节点的值之和。然后对该树进行一次中序遍历，每一次都用sum减去该结点的前驱结点的值（该前驱结点是中序遍历的前驱），同时更新sum值。输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]首先输入结点的数目n（注意，这里的结点包括题中的null空结点）输出：[30,36,21,36,35,26,15,33,8]

2025-08-07 16:52:20 892

原创搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。每行的第一个整数大于前一行的最后一个整数。首先输入matrix的行数m、列数n，每行中的整数从左到右按升序排列。最后输入一个整数target。然后输入m行，每行n个整数。输出true或false。

2025-08-05 16:41:36 545

原创找到小镇的法官

给定数组 trust，该数组由信任对 trust[i] = [a, b] 组成，表示标记为 a 的人信任标记为 b 的人。在循环完trust二维数组后，遍历这N个居民，若该居民被N-1个人信任且没有信任别人，则这个人就是法官。然后输入M行，每行两个整数a,、b，表示标记为 a 的人信任标记为 b 的人，a和b不相同。声明两个数组，一个用来存小镇居民 i 被信任的数量，另一个用来存小镇居民是否有信任其他人。如果小镇存在秘密法官并且可以确定他的身份，请返回该法官的标记。输出一个整数，为法官的标记。

2025-08-03 19:58:33 419

原创路径总和 III

使用两个递归函数，其中一个用来确定一个路径的起始节点a（因为本题路径不需要从根节点开始），另一个用来判断从起始节点a出发是否有路径为sum的路径，若有则res++。路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。首先输入结点的数目n（注意，这里的结点包括题中的null空结点）然后输入n个结点的数据，需要填充为空的结点，输入null。找出路径和等于给定数值的路径总数。

2025-08-03 17:57:48 713

原创二叉树的锯齿形层次遍历

对树进行层次遍历，只需要多一步操作：用一个变量记录遍历的是哪一层的数据，若为偶数则要将遍历该层得到的一维数组进行reverse。给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。首先输入结点的数目n（注意，这里的结点包括题中的null空结点）给定二叉树 [3,9,20,null,null,15,7],然后输入n个结点的数据，需要填充为空的结点，输入null。输出结果，每个数据的后面跟一个空格。

2025-08-03 16:50:30 988

原创求根到叶子节点数字之和

先序遍历树，用栈实现的非递归遍历，为记录路径，压入栈的元素是pair<TreeNode*,int>。给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。例如，从根到叶子节点路径 1->2->3 代表数字 123。从根到叶子节点路径 4->9->5 代表数字 495.从根到叶子节点路径 4->9->1 代表数字 491.从根到叶子节点路径 1->2 代表数字 12.从根到叶子节点路径 1->3 代表数字 13.从根到叶子节点路径 4->0 代表数字 40.

2025-08-03 16:31:03 762

原创二叉树的层次遍历 II

给定一个二叉树，返回其节点值自底向上的层次遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）首先输入结点的数目n（注意，这里的结点包括题中的null空结点）给定二叉树 [3,9,20,null,null,15,7],然后输入n个结点的数据，需要填充为空的结点，输入null。bilibili代码随想录：二叉树 5. 层序遍历。最后将得到的res数组进行一个reverse即可。输出结果，每个数据的后面跟一个空格。

2025-08-02 19:02:17 540

原创正方形数组的数目

返回 A 的正方形排列的数目。两个排列 A1 和 A2 不同的充要条件是存在某个索引 i，使得 A1[i]!给定一个非负整数数组 A，如果该数组每对相邻元素之和是一个完全平方数，则称这一数组为正方形数组。说明：若一个数能表示成某个整数的平方的形式，则称这个数为完全平方数。完全平方数是非负数。[1,8,17] 和 [17,8,1] 都是有效的排列。bilibili代码随想录：回溯算法：14全排列 II。然后输入n个整数，以空格分隔。首先输入A数组的长度n，输入：[1,17,8]输入：[2,2,2]

2025-08-01 20:37:31 542

原创有效的井字游戏

==”是比较运算符，返回的是布尔型数据，如果用a==b==c的话，会先比较a和b，返回true（1）或者false（0），再和c比较，即比较c是否等于1或0。该游戏板是一个 3 x 3 数组，由字符 " "，"X" 和 "O" 组成。board[i][j] 是集合 {" ", "X", "O"} 中的一个字符。输入三行，每行三个字符，每个字符都属于集合 {" ", "X", "O"}输入: board = ["XOX", "O O", "XOX"]玩家轮流将字符放入空位（" "）中。

2025-07-29 17:54:35 646

原创去除重复字母

如bcabc，遍历第一个b时，存如res，遍历到第一个c，若加入res，bc是最小字典序的，所以将c也存入res（此时res中为bc），遍历到a，若加入res，bca不是最小字典序，因为剩余的字符里有bc，所以可以从res中弹出c，此时res中为b，若现在加入a，ba也不是最小字典序，所以弹出b，此时res为空，把a加入res，后续的两个bc若加入res，是满足最小字典序的，所以加入。1、如果当前字符在整个字符串中只有一个，只能存进res（虽定义为string，但当栈用，且栈中存的数据是满足最小字典序的）

2025-07-23 21:53:11 446

原创分割数组为连续子序列

如果哈希表中存在以 x−1 结尾的子序列，则取出以 x−1 结尾的最小的子序列长度，将子序列长度加 1 之后作为以 x 结尾的子序列长度。遍历数组中的数据x，若存在一个以x-1为结尾的子序列，则将x插入以x-1为结尾的子序列，若存在多个以x-1为结尾的子序列，为了让最短的子序列尽可能的长，应该将x插入其中最短的子序列。哈希表的键为子序列的最后一个数字，值为最小堆，用于存储所有的子序列长度，最小堆满足堆顶的元素是最小的，因此堆顶的元素即为最小的子序列长度。输入: [1,2,3,3,4,4,5,5]

2025-07-23 17:25:54 159

原创翻转矩阵后的得分

翻转是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。2、行处理完之后，遍历除了第一列的所有列，判断此时每列1的个数，若1的个数小于0的个数则进行反转。在做出任意次数的翻转后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。为了使最终结果最大，则矩阵每一行的最左边都必须为1，然后让每列的1尽可能的多。转换为 [[1,1,1,1],[1,0,0,1],[1,1,1,1]]输入：[[0,0,1,1],[1,0,1,0],[1,1,0,0]]

2025-07-23 15:08:15 438

原创无重叠区间

首先输入区间集合的大小n(n<20000)，然后输入n行，每行2个整数，表示区间的起始和结束。区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。输入: [ [1,2], [2,3], [3,4], [1,3] ]解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。输入: [ [1,2], [1,2], [1,2] ]解释: 移除 [1,3] 后，剩下的区间没有重叠。输入: [ [1,2], [2,3] ]

2025-07-22 20:32:31 466

原创 LeetCode:881 救生艇

最主要的思想就是：体重轻的人应该尽量与体重重的人乘一艘船（因为如果不这样的话：比如两个最轻的人一艘船就可能导致其他的人不再有共用一条船的机会，就会导致船的数量变多）输入：people = [3,2,2,1], limit = 3。输入：people = [3,5,3,4], limit = 5。解释：4 艘船分别载 (3), (3), (4), (5)解释：3 艘船分别载 (1, 2), (2) 和 (3)首先输入人的数量n，然后输入n个整数，表示人的体重。想要最少的船，也就是让载两人的船尽可能的多。

2025-07-21 20:10:30 317

原创买卖股票的最佳时机

随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3。解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。输入: [7,1,5,3,6,4]输入: [1,2,3,4,5]

2025-07-21 18:08:38 429

原创有序矩阵中的第 k 个最小数组和

输入：mat = [[1,10,10],[1,4,5],[2,3,6]], k = 7。输入：mat = [[1,3,11],[2,4,6]], k = 5。输入：mat = [[1,3,11],[2,4,6]], k = 9。输入：mat = [[1,1,10],[2,2,9]], k = 7。

2025-07-21 16:57:37 706

原创 LeetCode 71：简化路径

遍历输入的字符串str，若字符不是 '/' 则将字符存进变量tem，否则对变量tem进行判断：若为空或者为 '.' 则将tem赋值为空字符串后遍历str的下一个字符；在处理栈里数据之前，需对tem中的字符串进行最后一次处理，因为输入的字符串结尾也许不是用 '/' 结尾，这时tem中的字符串在上述的循环中得不到处理。输入："/a//b////c/d//././/.."输入："/a/../../b/../c//.//"输入："/a/./b/../../c/"输入："/home//foo/"

2025-07-17 16:55:09 479

原创前 K 个高频元素

也可以将自己写的struct的对象放进去。map的特性是map中的元素会按照键的顺序自动排序，但我们用priority_queue的第三个参数实现排序，此时map中的排序不是我们所需的，当然也可以自定义比较函数，但C++提供了更方便的数据类型，所以不用map。若用int来存储数据的频率，最终也能实现存前k个频率最大的元素，但问题是如何实现最终输出的效果为：首先输出频率最高的元素，如果频率相同，则先输出元素值较大的元素？使用map存储键值对，就可以很方便的实现数字与频率的对应，map里的术语是键与值的对应。

2025-07-16 20:44:36 978

原创字符串解码

若为 ']' 则需要弹出数字栈的栈顶用于复制字符串（此时字符串栈s里存的是前面所有字符串处理后得到的结果，而字符串res则存的是这一次需要复制的字符串，所以只需要进行num.top()次s.top()+=res便完成了此次复制），并将结果复制给res，弹出栈顶。由例子3[a2[c]]可知需要一个存数字的栈和一个存字符串的栈（因为先出现的3后出现的2，先出现的a后出现的c，但结果确实先复制了两个c，得到cc，与acc组成一个字符串，然后复制三次得到了accaccacc）。输入：s = "3[a]2[bc]"

2025-07-15 21:14:15 561

原创反转每对括号间的子串

用string接收输入的数据，依次遍历该字符串，若不是 ')' 则将字符入栈，否则出栈，一直出到字符为 '(' ,并在出栈的时候将字符存入vector定义的结构里，由于栈的特性是后进先出，所以在出栈进vector的时候就已经完成了反转，然后将反转后的数据再次压入原来的栈里。请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。输入：s = "a(bcdefghijkl(mno)p)q"输入：s = "(ed(et(oc))el)"输入：s = "(u(love)i)"

2025-07-15 19:25:39 296

原创使括号有效的最少添加

若为 ')'，则判断栈此时是否为空，若不为空，则弹出栈顶元素，若为空则res++（res用来记录必须添加的最少括号数，并且这种情况下记录的是不合法的 ')'数目）。字符串处理完成后，若栈不为空，此时栈的长度表示不合法的 ')' 数目，res += 栈的长度便是最终所有不合法的括号数目，即为使结果字符串有效而必须添加的最少括号数。给定一个由 '(' 和 ')' 括号组成的字符串 S，我们需要添加最少的括号（ '(' 或是 ')'，可以在任何位置），以使得到的括号字符串有效。输入："()))(("

2025-07-15 16:21:01 331

原创链表中的下一个更大节点

每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，那么就有 j > i 且 node_j.val > node_i.val，而 j 是可能的选项中最小的那个。注意：在下面的示例中，诸如 [2,1,5] 这样的输入（不是输出）是链表的序列化表示，其第一个节点的值为 2，第二个节点值为 1，第三个节点值为 5。输入：[1,7,5,1,9,2,5,1]输出：[7,9,9,9,0,5,0,0]

2025-07-12 17:45:20 645

原创两两交换链表中的节点

本题可以理解为奇数和偶数的交换（此处的奇偶是结点所处位置，不是数值的奇偶），那么就可以将原链表拆成两个链表，即一个存处于奇数位置上的结点，一个存处于偶数位置的结点。然后依次遍历两链表，先插入偶数链表上的结点，再插奇数链表上的结点，然后让奇偶链表都向后移一个结点，直至两链表为空。可使用以下代码，完成其中的swapPairs函数，其中形参head指向无头结点单链表，返回结果链表的头指针。给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。首先输入链表长度len，然后输入len个整数，以空格分隔。

2025-07-12 16:35:18 302

原创 LeetCode 第61题：旋转链表

输入: 1->2->3->4->5->NULL, k = 2。向右旋转 1 步: 5->1->2->3->4->NULL。向右旋转 2 步: 4->5->1->2->3->NULL。输入: 0->1->2->NULL, k = 4。输出: 4->5->1->2->3->NULL。向右旋转 1 步: 2->0->1->NULL。向右旋转 2 步: 1->2->0->NULL。向右旋转 3 步: 0->1->2->NULL。向右旋转 4 步: 2->0->1->NULL。输出: 2->0->1->NULL。

2025-07-12 15:42:49 747

S_t_a_r_123的博客