FLGB

时间复杂度：O(m * n)，其中 m 是矩阵的行数，n 是矩阵的列数，需要遍历矩阵中的每一个元素。空间复杂度：O(m * n)，使用了一个大小为 m * n 的 dp 数组。

dp[i-1][j] 表示 s3 的前 i + j - 1 个字符可以通过 s1 的前 i-1 个字符和 s2 的前 j 个字符交错组成。同理，如果 dp[i][j-1] 为真且 s2[j-1] == s3[i + j - 1]，则 dp[i][j] = true。如果 dp[i-1][j] 为真且 s1[i-1] == s3[i + j - 1]，则 dp[i][j] = true。如果 s1 的第 i 个字符 s1[i-1] 等于 s3 的第 i + j 个字符 s3[i + j - 1]，

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？网格中的障碍物和空位置分别用 1 和 0 来表示。：3x3 网格的正中间有一个障碍物。

相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1。为了找到从顶部到底部的最小路径和，可以使用动态规划（Dynamic Programming, DP）方法。输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。输入：triangle = [[-10]]

在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。因此，在 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。就是把n的低位加入到result的低位，然后result不断左移把低位，n不断右移把高位变低位，逐位反转。可以从输入的最低位开始，将其移动到输出的最高位，然后依次处理每一位，直到所有位都被处理完。n >>= 1：将 n 右移一位，准备处理下一位。

快速幂算法的基本思想是利用幂的二分性质，将幂次分解成较小的幂次，减少乘法次数。实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。解释：2-2 = 1/22 = 1/4 = 0.25。输入：x = 2.00000, n = 10。输入：x = 2.00000, n = -2。输入：x = 2.10000, n = 3。输出：1024.00000。输出：9.26100。输出：0.25000。

不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。使用牛顿迭代法通过逐步逼近来找到平方根。

时间复杂度：O(log n)，因为我们每次将 powerOf5 乘以 5，直到它超过 n，循环的次数是log 5(n)。对于每一个数字i（从 1 到 n），统计它包含的因子 5 的数量。在阶乘中，因子 2 的数量总是多于因子 5 的数量，因此尾随零的数量由因子 5 的数量决定。= n * (n - 1) * (n - 2) * …n/5 的结果，然后计算n/5/5即n/25 的结果，依此类推，直到n/5的k次方为 0。1、100/5=20 表示从 1 到 100 之间有 20 个数是 5 的倍数。

给你两个整数 left 和 right ，表示区间 [left, right] ，返回此区间内所有数字 按位与 的结果（包含 left 、right 端点）。可以通过不断右移操作，找到左端点和右端点的共同前缀（非共同前缀&的结果一定是0），记录右移的次数，最后将共同前缀左移回原来的位置。在一个范围内进行按位与操作时，如果这个范围跨越了多个2的幂次方区间，那么最终的结果中，这些幂次方位上的所有位都将变为0。5 & 6 & 7 = 100 (即 只有相同前缀的数字保留了，其他位都是0)

对数组进行处理，将表示的整数加一。由于数组中每个元素都只存储一个数字，需要从数组的末尾开始逐位处理进位问题。如果所有位都处理完之后仍有进位（例如 999 + 1 变成 1000），需要在数组最前面插入一个 1。最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。输入：digits = [1,2,3]解释：输入数组表示数字 123。输出：[1,2,4]

解释：从左向右读, 为 -121。从右向左读, 为 121-。因此它不是一个回文数。是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。输入：x = -121。输入：x = 121。

要找到一个整数数组中唯一出现一次的元素，其余元素都出现三次，我们可以使用位操作的方法。这种方法利用了数字在计算机中是以二进制形式存储的特性，通过统计每一位上出现1的次数来解决这个问题。你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。输入：nums = [0,1,0,1,0,1,99]输入：nums = [2,2,3,2]

输入的二进制串 10000000 中，共有 1 个设置位。：输入的二进制串 1011 中，共有 3 个设置位。

【代码】【技巧】Leetcode 67. 二进制求和【简单】

给定两个以 非递减顺序排列 的整数数组 nums1 和 nums2 , 以及一个整数 k。请找到和最小的 k 个数对 (u1,v1), (u2,v2) …定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2。在最坏情况下，堆中最多包含 k 个元素，每次操作（插入和删除）需要。空间复杂度：最小堆最多包含 k 个元素，因此空间复杂度是 O(k)。时间复杂度：初始化堆的时间复杂度是。，因为将最多 k 个元素加入堆。因此，总体时间复杂度为。

nums[-1] = nums[n] = -∞，这就代表着 只要数组中存在一个元素比相邻元素大，那么沿着它一定可以找到一个峰值。你可以假设 nums[-1] = nums[n] = -∞。解释：3 是峰值元素，你的函数应该返回其索引 2。输入：nums = [1,2,1,3,5,6,4]解释：你的函数可以返回索引 1，其峰值元素为 2；输入：nums = [1,2,3,1]或者返回索引 5， 其峰值元素为 6。是指其值严格大于左右相邻值的元素。

形式上，对于子数组 nums[i], nums[i + 1], …, nums[j] ， 不存在 i <= k1, k2 <= j 其中 k1 % n == k2 % n。即数组中的最小子数组和，然后用总和减去最小子数组和得到最大子数组和。解释：从子数组 [3] 和 [3,-2,2] 都可以得到最大和 3。解释：从子数组 [5,5] 得到最大和 5 + 5 = 10。输入：nums = [1,-2,3,-2]输入：nums = [3,-2,2,-3]输入：nums = [5,-3,5]

你可以按 任何顺序 返回答案。

search：最坏情况下 O(N * 26^L)，其中 N 是节点数量，L 是单词的长度。// 返回 False。// 返回 True。// 返回 True。// 返回 True。空间复杂度：O(N * L)，其中 N 是单词数量，L 是平均单词长度。addWord：O(L)，其中 L 是单词的长度。

给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。**输入：**adjList = [[2,4],[1,3],[2,4],[1,3]]节点 1 的值是 1，它有两个邻居：节点 2 和 4。节点 2 的值是 2，它有两个邻居：节点 1 和 3。节点 3 的值是 3，它有两个邻居：节点 2 和 4。节点 4 的值是 4，它有两个邻居：节点 1 和 3。图中有 4 个节点。

被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

差值是一个正数，其数值等于两值之差的绝对值。

【代码】【二叉树】Leetcode 103. 二叉树的锯齿形层序遍历【中等】

第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11。因此返回 [3, 14.5, 11]。

的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。// 返回 True。// 返回 True。// 返回 True。

从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123。因此，数字总和 = 495 + 491 + 40 = 1026。从根到叶子节点路径 4->9->5 代表数字 495。从根到叶子节点路径 4->9->1 代表数字 491。计算从根节点到叶节点生成的 所有数字之和。从根到叶子节点路径 4->0 代表数字 40。是指没有子节点的节点。

等于目标和的根节点到叶节点路径如上图所示。是指没有子节点的节点。

给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），‘#’ 表示每层的末尾。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。

左子树 ->根节点-> 右子树 ，根节点的左边是左子树的节点，右边是右子树的节点。: 左子树 -> 右子树 -> 根节点，最后一个元素是树的根节点。

你应当 保留 两个分区中每个节点的初始相对位置。

【代码】【链表】Leetcode 61. 旋转链表【中等】

由于链表是已排序的，所以重复的节点会相邻出现。可以使用双指针法来解决这个问题，一个指针用于遍历链表，另一个指针用于跟踪上一个未重复的节点。

缺点是：如果 left 和 right 的区域很大，恰好是链表的头节点和尾节点时，找到 left 和 right 需要遍历一次，反转它们之间的链表还需要遍历一次，虽然总的时间复杂度为 O(N)，但遍历了链表 2 次。通过逐个移动 cur 和 next 节点的位置，在反转区间内执行交换操作，完成局部反转。时间复杂度：O(N)，其中 N 是链表总节点数。最多只遍历了链表一次，就完成了反转。时间复杂度：O(N)，其中 N是链表总节点数。next 指向当前节点的下一个节点，用于在反转过程中进行位置交换。

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

*注意:**不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval()。输入：s = “(1+(4+5+2)-3)+(6+8)”输入：s = " 2-1 + 2 "输入：s = “1 + 1”

输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”," *“,”/“,” *“,“17”,”+“,“5”,”+"]解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6。解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9。输入：tokens = [“4”,“13”,“5”,“/”,“+”]4、最后的结果:遍历结束后，栈中应只有一个元素，即表达式的计算结果。输入：tokens = [“2”,“1”,“+”,“3”,“*”]

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；任意多个连续的斜杠（即，‘//’）都被视为单个斜杠 ‘/’。对于此问题，任何其他格式的点（例如，‘…给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 ‘/’ 开头），请你将其转化为更加简洁的规范路径。构建简化后的路径: 使用栈中的部分重新构建简化后的路径，确保路径以 / 开头并且各部分之间只有一个 /。拆分路径: 使用斜杠 / 将路径字符串拆分为多个部分。：在规范路径中，多个连续斜杠需要用一个斜杠替换。

在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被 引爆。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。要解决这个问题，需要明白怎么能覆盖更多的气球，就是要尽可能多地让弓箭覆盖气球的直径区间，每次弓箭一定在某个气球的最右端。-在x = 6处射出箭，击破气球[2,8]和[1,6]。

给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。