hlc@-CSDN博客

原创【动态规划-最长公共子序列（LCS）】力扣712. 两个字符串的最小ASCII删除和

最后我们计算出字符串s1和s2的ascII码之和，然后减去保留下来的相同子序列的ascII码值（需要乘以2），剩下的就是两个字符串的最小ASCII删除和。如果改为将两个字符串转换为 “lee” 或 “eet”，我们会得到 433 或 417 的结果，比答案更大。结束时，两个字符串都等于 “let”，结果即为 100+101+101+101 = 403。解释: 在 “sea” 中删除 “s” 并将 “s” 的值(115)加入总和。解释: 在 “delete” 中删除 “dee” 字符串变成 “let”，

2024-09-30 19:04:47 291

原创【动态规划-最长公共子序列（LCS）】力扣583. 两个字符串的删除操作

所以可以参考力扣1143题（主页有）来求出最长公共子序列，然后最后两个字符串的长度相加，减去两倍的最长公共子序列，就是使得 word1 和 word2 相同所需的最少的删除次数。给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。解释: 第一步将 “sea” 变为 “ea” ，第二步将 "eat "变为 “ea”输入：word1 = “leetcode”, word2 = “etco”输入: word1 = “sea”, word2 = “eat”

2024-09-30 16:19:22 288

原创【线性dp-最长公共子序列（LCS）】力扣1143. 最长公共子序列

我们定义一个二维数组 dp，其中 dp[i][j] 表示 text1 的前 i 个字符与 text2 的前 j 个字符的最长公共子序列的长度。dp[i][j] 的具体含义是：text1 的前 i 个字符和 text2 的前 j 个字符的最长公共子序列的长度。一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。

2024-09-29 22:47:31 217

原创【动态规划-分组背包】【hard】力扣2218. 从栈中取出 K 个硬币的最大面值和

然后j就从num_n开始向下循环到j>0，然后第三重循环w的含义是目前遍历的栈选取w+1个硬币，然后这时候更新f[j]，他会比较如果选取了这个栈的前w+1个硬币，那么有没有可能会出现比之前更大的情况。输入：piles = [[100],[100],[100],[100],[100],[100],[1,1,1,1,1,1,700]], k = 7。然后定义一个整型num_n，他是用来判断j要从哪里开始向下循环，每当遍历一个栈的时候，num_n就会加上这个栈的硬币数n，然后保证不会超过k。

2024-09-29 21:48:48 386

原创【动态规划-分组背包】力扣1981. 最小化目标值与所选元素的差

g[j] 表示是否可以通过选择这一行中的某些元素，使得和等于 j，也就是说g的作用是在计算完当前行的时候，赋给f，供下一行的循环使用，而f代表的是当前循环的上一行的组合可能性。实际上没错，large+x不可能比j+x小，但是有一种情况，就是当遍历的某一个元素较小的时候，而且没有j+x大于target的情况，并且同一行其他元素的x较大的时候，这时候这个较小的x的large+x就可能是最接近target的值。输入：mat = [[1,2,3],[4,5,6],[7,8,9]], target = 13。

2024-09-29 00:29:46 349

原创【动态规划-分组背包】力扣1155. 掷骰子等于目标和的方法数

当我们已经确定了某个骰子i的时候，在他之前的前i-1个骰子，已经记录到了可能产生的目标和中，所以我们在计算第i个骰子可能产生的目标和的时候，是依赖于之前骰子产生的目标和。首先我们先遍历每个骰子，也就是遍历i，然后接着倒序循环从target到0的目标和，并且在每次第二层循环的时候，令dp[j] = 0，最后循环骰子可能的点数x。中，dp[j]代表的是可能产生的目标和，这取决于这次骰子的点数x，dp[j-x]取决于之前骰子产生的目标和。首先我们先定义一个向量dp[j]，含义是目标和为j的时候的方案数。

2024-09-26 17:10:41 466

原创【动态规划-多重背包】【hard】力扣2585. 获得分数的方法数

当我们确定某一类题目总得分t的时候，这时候方法数就是dp[j-t]，我们就将之前计算的方法数dp[j]加上dp[j-t]来确定一个新的dp[j]，这新的dp[j]会覆盖旧的dp[j]。输入：target = 5, types = [[50,1],[50,2],[50,5]]输入：target = 18, types = [[6,1],[3,2],[2,3]]输入：target = 6, types = [[6,1],[3,2],[2,3]]首先定义一个dp[j]向量，含义是得分为j的时候的方法数。

2024-09-25 19:46:55 1499

原创【数据结构-栈】力扣71. 简化路径

的话，就将stack的栈顶元素弹出，如果是”."的话，就不进行操作，如果都不是，就推入stack中。给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格绝对路径（以 ‘/’ 开头），请你将其转化为更加简洁的规范路径。所以我们就可以通过i来索引path中的元素，当path[i]为’/‘的时候，就跳过，让i指向’/‘后的第一个字母。任意多个连续的斜杠（即，‘//’ 或 ‘///’）都被视为单个斜杠 ‘/’。path 由英文字母，数字，‘.’，‘/’ 或 ‘_’ 组成。

2024-09-25 18:05:47 476

原创【数据结构-栈】力扣946. 验证栈序列

给定 pushed 和 popped 两个序列，每个序列中的值都不重复，只有当它们可能是在最初空栈上进行的推入 push 和弹出 pop 操作序列的结果时，返回 true；这道题的意思是，我们依次将pushed数组的元素push到栈中，如果栈顶元素刚好等于popped中的第j个元素，那么就会执行pop的操作，然后j++。输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]

2024-09-24 19:29:27 163

原创【数据结构-栈】2390. 从字符串中移除星号

使用栈的方法来模拟这个过程，当s中的字符不是* 的时候，就推入res末尾，如果是*的话，并且如果res不是空的，那么就弹出res的末尾字符。移除星号左侧最近的那个非星号字符，并移除该星号自身。解释：整个字符串都会被移除，所以返回空字符串。生成的输入保证总是可以执行题面中描述的操作。给你一个包含若干星号 * 的字符串 s。输入：s = “leet**cod*e”e" 中的 ‘t’ ，s 变为 "lee。输入：s = “erase*****”返回移除所有星号之后的字符串。选中 s 中的一个星号。

2024-09-24 14:46:41 137

原创【数据结构-栈】力扣682. 棒球比赛

比赛开始时，记录是空白的。“+” - 记录加 9 + 5 = 14 ，记录现在是 [5, -2, -4, 9, 5, 14]“+” - 记录加 -4 + 9 = 5 ，记录现在是 [5, -2, -4, 9, 5]输入：ops = [“5”,“-2”,“4”,“C”,“D”,“9”,“+”,“+”]“D” - 记录加 2 * -2 = -4 ，记录现在是 [5, -2, -4]“9” - 记录加 9 ，记录现在是 [5, -2, -4, 9]输入：ops = [“5”,“2”,“C”,“D”,“+”]

2024-09-23 19:15:21 531

原创【数据结构-栈】力扣844. 比较含退格的字符串

使用了栈的方法，我们定义了两个新字符串res1和res2来记录s和t进行计算后的最终结果，最后看res1和res2是否相等。当s或t字符串中的字符不为#的时候，就将他推入到我们构造的新字符串中，如果字符为#，我们还要判断他是否为空，如果不为空的话，那么就将重构字符串的最后一个字符弹出。输入：s = “ab#c”, t = “ad#c”输入：s = “ab##”, t = “c#d#”解释：s 会变成 “c”，但 t 仍然是 “b”。输入：s = “a#c”, t = “b”

2024-09-23 17:01:11 458

原创【数据结构-栈】力扣1441. 用栈操作构建数组

采用模拟的方法，使用prev来记录target中上一个元素的值，然后就进行k-prev-1次循环来对数组res传入"Push"和"Pop"，然后最后再传入"Push"。“Push”：从 list 中读取一个新元素，并将其推入数组中。输出：[“Push”,“Push”,“Pop”,“Push”]输入：target = [1,2,3], n = 3。输出：[“Push”,“Push”,“Push”]输入：target = [1,3], n = 3。输出：[“Push”,“Push”]

2024-09-22 18:22:06 381

原创【数据结构-二维差分】力扣2536. 子矩阵元素加 1

找出左上角为 (row1i, col1i) 且右下角为 (row2i, col2i) 的子矩阵，将子矩阵中的每个元素加 1。，实际上是因为，我们在后面需要运用到前缀和来累加差分矩阵，而前缀和需要我们第0行和第0列都为0，用来辅助计算，而差分又使最后一行和最后一列多出来用来辅助差分计算，所以最后就需要多出两行和两列的空间。输入：n = 3, queries = [[1,1,2,2],[0,0,1,1]]输出：[[1,1,0],[1,2,1],[0,1,1]]输出：[[1,1],[1,1]]

2024-09-21 22:45:18 586

原创【数据结构-差分】【贪心】力扣1526. 形成目标数组的子数组最少增加次数

我们要找的实际上有两个递增区间，一个是[3]（第一个区间的最小值默认为0），他最大值3减去最小值0的差为3，第二个递增区间是[1,2]，2-1=1，所以差为1。解释：(initial)[0,0,0,0] -> [1,1,1,1] -> [1,1,1,2] -> [2,1,1,2] -> [3,1,1,2] (target)。解释：(initial)[0,0,0,0,0] -> [1,1,1,1,1] -> [2,1,1,1,1] -> [3,1,1,1,1]输入：target = [1,2,3,2,1]

2024-09-21 17:13:24 547

原创【数据结构-差分】力扣1589. 所有排列中的最大和

输入：nums = [1,2,3,4,5,10], requests = [[0,2],[1,3],[1,1]]解释：一个和最大的排列为 [4,10,5,3,2,1] ，查询结果分别为 [19,18,10]。输入：nums = [1,2,3,4,5], requests = [[1,3],[0,1]]输入：nums = [1,2,3,4,5,6], requests = [[0,1]]解释：一个总和最大的排列为 [6,5,4,3,2,1] ，查询和为 [11]。总和为：8 + 3 = 11。

2024-09-20 19:00:00 687

原创【数据结构-差分】【hard】力扣995. K 连续位的最小翻转次数

k位翻转就是从 nums 中选择一个长度为 k 的子数组，同时把子数组中的每一个 0 都改成 1 ，把子数组中的每一个 1 都改成 0。翻转 A[0],A[1],A[2]: A变成 [1,1,1,1,0,1,1,0]翻转 A[4],A[5],A[6]: A变成 [1,1,1,1,1,0,0,0]翻转 A[5],A[6],A[7]: A变成 [1,1,1,1,1,1,1,1]输入：nums = [0,0,0,1,0,1,1,0], K = 3。输入：nums = [0,1,0], K = 1。

2024-09-19 18:02:57 1255

原创【数据结构-差分】力扣2381. 字母移位 II

对于每个 i ，将 s 中从下标 starti 到下标 endi （两者都包含）所有字符都进行移位运算，如果 directioni = 1 将字符向后移位，如果 directioni = 0 将字符向前移位。我们规定了向右移动时候为正，向左移动为负。输入：s = “abc”, shifts = [[0,1,0],[1,2,1],[0,2,1]]输入：s = “dztz”, shifts = [[0,0,0],[1,1,1]]最后，将下标从 1 到 1 的字符向后移位，得到 s = “catz”。

2024-09-19 00:57:51 323

原创【数据结构-线段树】【差分】力扣732. 我的日程安排表 III

/ 返回 2 ，第三个日程安排 [10, 40) 与第一个日程安排相交，所以最大 k 次预订是 2 次预订。给你一些日程安排 [startTime, endTime) ，请你在每个日程安排添加后，返回一个整数 k ，表示所有先前日程安排会产生的最大 k 次预订。// 返回 1 ，第一个日程安排可以预订并且不存在相交，所以最大 k 次预订是 1 次预订。// 返回 1 ，第二个日程安排可以预订并且不存在相交，所以最大 k 次预订是 1 次预订。需要空间存储所有的日程安排计数，需要的空间为 O(n)。

2024-09-18 19:29:27 681

原创【贪心】【数据结构-小根堆，差分】力扣2406. 将区间分为最少组数

当新区间的左端点要比堆顶元素(最小右端点)大的时候，那么就将这个区间分到堆顶元素所在的组中，由于我们只需要记录每个组的最大右端点，那么就将堆顶元素替换成新区间的右端点，然后priority_queue将会保证堆顶元素是最小的（所有组的最大右端点比较后的最小的最大右端点）。比方说区间 [1, 5] 和 [5, 8] 相交。输入：intervals = [[5,10],[6,8],[1,5],[2,3],[1,10]]输入：intervals = [[1,3],[5,6],[8,10],[11,13]]

2024-09-18 02:02:22 436

原创【数据结构-扫描线】力扣57. 插入区间

给你一个无重叠的，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。输出：[[1,2],[3,10],[12,16]]

2024-09-17 00:51:24 408

原创【贪心】【合并】力扣56. 合并区间

如果不是的话，说明会重叠，这时候就要更新merged最后一个区间的第二个元素，如果interval[1]较大，就将merged最后一个区间的第二个元素更改为interval[1]来表示一个最大的完整的范围。如上图，我们的代码会判断第二个interval的第一个元素比第一个interval的第二个元素小，这时候就会进行合并的逻辑，返回[1,4]这个错误答案。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]输出：[[1,6],[8,10],[15,18]]

2024-09-14 15:47:17 411

原创【数据结构-一维差分】力扣1109. 航班预订统计

这题运用了差分的解法，首先有几个要注意的点就是diff的容量要设定为多少，首先由于航班号是从1开始到n，并且可能出现booking[1]+1(当booking[1]为n时)的情况，所以diff的容量为n+2。输入：bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5。输入：bookings = [[1,2,10],[2,2,15]], n = 2。因此，answer = [10,55,45,25,25]输出：[10,55,45,25,25]

2024-09-13 16:01:28 213

原创【数据结构-一维差分】力扣1094. 拼车

给定整数 capacity 和一个数组 trips , trip[i] = [numPassengersi, fromi, toi] 表示第 i 次旅行有 numPassengersi 乘客，接他们和放他们的位置分别是 fromi 和 toi。然后我们定义一个s来记录，假设车容量没有限制的话，车上同时会有多少人，当发现车上同时拥有的人数大于capacity容量的时候，就说明无法在所有给定的行程中接送所有乘客，如果车上人数始终在capacity内，那么说明可以按需求接送所有乘客。

2024-09-13 15:16:15 279

原创 Unity 第一人称游戏的武器被其他物体覆盖解决方案

Clear Flags 是相机（Camera）组件的一个属性，它决定了在渲染每一帧时，背景部分如何被清空或填充。（不清除）：这个选项不会清除深度缓冲区或颜色缓冲区，意味着新帧将直接叠加在旧帧上。Main Camera的参数：我们这个摄像机不渲染equipable层（自定义武器为equipable的layer）（天空盒）：这是默认选项，表示使用当前场景的天空盒来填充背景。如果你的场景有天空盒材质，它会被渲染在背景中。在第一人称游戏的时候，会出现渲染过程中，主角的手持武器可能会被其他物体挡住。

2024-09-12 23:12:05 567

原创【贪心】力扣2960. 统计已测试设备

在设备 0 上，batteryPercentages[0] > 0 ，现在有 1 个已测试设备，batteryPercentages 变为 [1,0,1,0,2]。在设备 2 上，batteryPercentages[2] > 0 ，现在有 2 个已测试设备，batteryPercentages 变为 [1,0,1,0,1]。在设备 1 上，batteryPercentages[1] > 0 ，现在有 1 个已测试设备，batteryPercentages 变为 [0,1,1]。

2024-09-12 18:34:31 268

原创【数据结构-一维差分】力扣1854. 人口最多的年份

在使用差分的时候要注意的是death的那一年，就不算入人口，这和覆盖类的差分不一样，覆盖类差分需要。然后我们定义一个res来记录最多人口的年份，maxNum来计入最大人口的数量，然后去遍历每一年的人口，最后返回res+offset就是人口最多的年份。给你一个二维整数数组 logs ，其中每个 logs[i] = [birthi, deathi] 表示第 i 个人的出生和死亡年份。输入：logs = [[1950,1961],[1960,1971],[1970,1981]]返回人口最多且最早的年份。

2024-09-12 18:07:04 379

原创【数据结构-一维差分】力扣1893. 检查是否区域内所有整数都被覆盖

首先因为是差分的办法，所以i开始必须在ranges中最小的range[0]及其左边开始，但是由于可能会出现left在最小range[0]的左边，从而在遍历left到最小range[0]的时候满足了i>left而且s这时候又为0，会返回false。输入：ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5。输入：ranges = [[1,10],[10,20]], left = 21, right = 21。解释：21 没有被任何一个区间覆盖。

2024-09-12 17:06:15 544

原创【数据结构-一维差分】力扣2848. 与车相交的点

给你一个下标从 0 开始的二维整数数组 nums 表示汽车停放在数轴上的坐标。对于任意下标 i，nums[i] = [starti, endi] ，其中 starti 是第 i 辆车的起点，endi 是第 i 辆车的终点。解释：1、2、3、5、6、7、8 共计 7 个点满足至少与一辆车相交，因此答案为 7。解释：从 1 到 7 的所有点都至少与一辆车相交，因此答案为 7。输入：nums = [[3,6],[1,5],[4,7]]输入：nums = [[1,3],[5,8]]

2024-09-11 19:30:52 528

原创【数据结构-二维前缀最小值】力扣3148. 矩阵中的最大得分

也就是说，当grid[i][j]为终点的时候，要在以(0,0)为左上角，(i,j)为右下角的矩阵中（不包括(i,j)）找到最小的那个元素值mn。如果用列来表示我们需要的信息，也就是从0到j-1列的最小值，然后第j列的从0到i-1行的最小值，这两个最小值我们进行比较，更小的那个就是我们需要的信息。所以说在遍历每一行的时候，我们都要重置pre_min为INT_MAX，pre_min的作用就是找到从0到j-1列的最小值，col_min的作用就是储存第j列的从0到i-1行的最小值。

2024-09-11 15:01:00 1107

原创【动态规划【hard】力扣1449. 数位成本和为目标值的最大数字

因为这样子，最后的字符串才会尽可能长，然后在保证了最长长度的情况下，优先使用较大的数。输入：cost = [6,10,15,40,40,40,40,40,40], target = 47。输入：cost = [7,6,5,5,5,6,8,7,8], target = 12。输入：cost = [4,3,2,5,6,7,2,5,5], target = 9。输入：cost = [2,4,6,2,4,6,4,4,4], target = 5。这个代码的目的就是记录目标值为i的时候，能用的最多数的数量。

2024-09-10 22:35:09 1380

原创【完全背包】【四平方和定理】力扣279. 完全平方数

这道题也是经典的完全背包问题，首先遍历n之前的每个数，接着计算当每个n时，遍历j，遍历 j 的目的是为了找到可以用来表示数字 i 的最少完全平方数的组合。完全平方数是一个整数，其值等于另一个整数的平方；若要判断是否可以用两个平方和表示，那么就减去范围内任意的平方数，剩下的差要是个平方数，就说明可以。当 n=4 ^ k×(8m+7) 时，n 只能被表示为四个正整数的平方和。给你一个整数 n ，返回和为 n 的完全平方数的最少数量。j的最少完全平方数组合，因为我们要构成的是i，所以要加上j。

2024-09-09 21:59:38 515

原创【完全背包】力扣518. 零钱兑换 II

这能保证在每次外层的coin循环中，组合方式的末尾都是coin，即使经过coins.size()次的循环，可以保证每个dp[j]中的组合方式都是不相同的。因为外层循环是遍历数组 coins 的值，内层循环是遍历不同的金额之和，在计算 dp[i] 的值时，可以确保金额之和等于 i 的硬币面额的顺序，由于顺序确定，因此不会重复计算不同的排列。很多人会把coin放到内层循环，这样导致的一个问题就是，会出现类似dp[3] = {1,2},{2,1}，但实际上两种情况相等。请你计算并返回可以凑成总金额的硬币组合数。

2024-09-09 20:49:58 403

原创【Unity Shader】反射

【代码】【Unity Shader】反射。

2024-09-08 12:34:04 427

原创【动态规划】【完全背包】力扣322. 零钱兑换

但是由于dp(coins,rem-coin)由许多种情况构成，coin可以是不同面额，那么为了凑成价值为rem金额的最小硬币数量，就要求coin要满足dp(coins,rem-coin)必须是所有coin情况的最小的硬币数量，这时候再拿一个价值为coin的硬币，才是dp(coins,rem)的最小硬币组合数。有人会好奇那么不断找到最后，会发生什么，当rem == 0的时候，也就是末节点，实际上的含义也就是凑成金额0需要0种组合，这时候他的父节点就会计算res为0，然后记录Min为res+1 = 1。

2024-09-06 16:30:04 471

原创【数据结构-二维前缀和】力扣1504. 统计全 1 子矩形

既然右下角顶点已经确定，假设当矩形的高也知道，那么顶边的长度就是符合右下角为顶点，高确定的矩形个数。所以我们要做的就是遍历矩阵每个元素为矩形右下角，然后在不断假设高，然后找到在不同高的情况下矩形的顶边最长是多少。我们将每个元素为右下角能构成的矩形数量都计入ans中，最后返回的ans就是所有符合要求全为1的子矩阵数量。输入：mat = [[0,1,1,0],[0,1,1,1],[1,1,1,0]]输入：mat = [[1,0,1],[1,1,0],[1,1,0]]有 2 个 1x3 的子矩形。

2024-09-06 13:52:51 672

原创【数据结构-二维前缀和】力扣1277. 统计全为 1 的正方形子矩阵

该题和力扣221.最大正方形类似，以某一格为右下角能形成最大正方形的边长，就是以该格为右下角的正方形数量。给你一个 m * n 的矩阵，矩阵中的元素不是 0 就是 1，请你统计并返回其中完全由 1 组成的正方形子矩阵的个数。正方形的总数 = 10 + 4 + 1 = 15.正方形的总数 = 6 + 1 = 7.边长为 1 的正方形有 10 个。边长为 2 的正方形有 4 个。边长为 3 的正方形有 1 个。边长为 1 的正方形有 6 个。边长为 2 的正方形有 1 个。输入：matrix =

2024-09-06 00:06:59 369

原创【阿里笔试题】【三维dp优化二维dp】【hard】力扣879. 盈利计划

如果选择这个工作，那么为了保证member数量的人来完成这个工作，然后剩下的j-member的人去做的工作在前i-1个项目中最少可以创造k-earn的利润，其中要注意的是dp中储存的不是恰好k利润，而是最少k利润，且题目利润没有负数，那么当k-earn小于负数的时候，为了防止数组索引出现负数越界，所以把他定义为0即可。而在三维dp中，dp[0][0][0] = 1：这意味着在没有选择任何工作的情况下，使用 0 个人，获得 0 的利润时，有一种合法的方案——即不做任何事情。总的来说，有两种计划。

2024-09-05 19:03:47 937

原创【数据结构-二维前缀和】力扣221. 最大正方形

实际上之所以取三者最小值+1，是因为计算dp的时候，左边的dp限制了目前i和j的最左边的大小，上方dp限制了上面的范围，左上方dp限制了左上方的范围。输入：matrix = [[“1”,“0”,“1”,“0”,“0”],[“1”,“0”,“1”,“1”,“1”],[“1”,“1”,“1”,“1”,“1”],[“1”,“0”,“0”,“1”,“0”]]列出动态转换方程后，初始化dp，当i和j为0时候，dp初始化为1，遍历矩阵所有元素即可。输入：matrix = [[“0”,“1”],[“1”,“0”]]

2024-09-04 20:21:03 339

原创【数据结构-二位前缀和】【二分查找】【枚举优化】力扣1292. 元素和小于等于阈值的正方形的最大边长

这道题的精髓在于二分查找的使用，由于我们要找到最大的边长，那么我们是不是通常来想，需要遍历从1到矩阵较短边长度的正方形边长，然后把边长一个个去矩阵中寻找是否有合适的正方形。输入：mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1。输入：mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4。

2024-09-04 17:06:22 998

空空如也

kali linux apache2服务浏览器中无法访问