LeetCode部分题解（三）

LeetCode部分题解3

1、1662. 检查两个字符串数组是否相等

给你两个字符串数组 word1 和 word2 。如果两个数组表示的字符串相同，返回 true ；否则，返回 false 。

数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。

示例 1：

输入：word1 = [“ab”, “c”], word2 = [“a”, “bc”]
输出：true
解释：
word1 表示的字符串为 “ab” + “c” -> “abc”
word2 表示的字符串为 “a” + “bc” -> “abc”
两个字符串相同，返回 true
示例 2：

输入：word1 = [“a”, “cb”], word2 = [“ab”, “c”]
输出：false
示例 3：

输入：word1 = [“abc”, “d”, “defg”], word2 = [“abcddefg”]
输出：true

这道题我们把字符数组不断加到一个字符串上，然后比较两个长字符串即可，用python内置的join函数可以直接一行秒

class Solution:
    def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:
        return "".join(word1) == "".join(word2)

2、1365. 有多少小于当前数字的数字

给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。

换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。

以数组形式返回答案。

示例 1：

输入：nums = [8,1,2,2,3]
输出：[4,0,1,1,3]
解释：
对于 nums[0]=8 存在四个比它小的数字：（1，2，2 和 3）。
对于 nums[1]=1 不存在比它小的数字。
对于 nums[2]=2 存在一个比它小的数字：（1）。
对于 nums[3]=2 存在一个比它小的数字：（1）。
对于 nums[4]=3 存在三个比它小的数字：（1，2 和 2）。
示例 2：

输入：nums = [6,5,4,8]
输出：[2,1,0,3]
示例 3：

输入：nums = [7,7,7,7]
输出：[0,0,0,0]

提示：

2 <= nums.length <= 500
0 <= nums[i] <= 100

这里我们将数组排序，然后输入每个数字最早出现的下标即可。注意要复制一套数组在最后按顺序输出，而python的万物皆对象让我们不能直接用等于，需要借助切片来复制

class Solution:
    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
        temp = nums[:]
        nums.sort()
        ans = [0 for i in range(len(nums))]
        for i in range(len(nums)):
            ans[i] = nums.index(temp[i])
        return ans            

3、1614. 括号的最大嵌套深度

如果字符串满足以下条件之一，则可以称之为 有效括号字符串（valid parentheses string，可以简写为 VPS）：

字符串是一个空字符串 “”，或者是一个不为 “(” 或 “)” 的单字符。
字符串可以写为 AB（A 与 B 字符串连接），其中 A 和 B 都是 有效括号字符串 。
字符串可以写为 (A)，其中 A 是一个 有效括号字符串 。
类似地，可以定义任何有效括号字符串 S 的 嵌套深度 depth(S)：

depth("") = 0
depth© = 0，其中 C 是单个字符的字符串，且该字符不是 “(” 或者 “)”
depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是 有效括号字符串
depth("(" + A + “)”) = 1 + depth(A)，其中 A 是一个 有效括号字符串
例如：""、"()()"、"()(()())" 都是 有效括号字符串（嵌套深度分别为 0、1、2），而 “)(” 、"(()" 都不是 有效括号字符串 。

给你一个 有效括号字符串 s，返回该字符串的 s 嵌套深度 。

示例 1：

输入：s = “(1+(2*3)+((8)/4))+1”
输出：3
解释：数字 8 在嵌套的 3 层括号中。
示例 2：

输入：s = “(1)+((2))+(((3)))”
输出：3
示例 3：

输入：s = “1+(2*3)/(2-1)”
输出：1
示例 4：

输入：s = “1”
输出：0

提示：

1 <= s.length <= 100
s 由数字 0-9 和字符 ‘+’、’-’、’*’、’/’、’(’、’)’ 组成
题目数据保证括号表达式 s 是 有效的括号表达式

因为题目保证是有效括号表达式，所以只要有一个前括号，深度就加一，有一个后括号，深度就减一，所以我们遍历一遍，找到峰值即可

class Solution:
    def maxDepth(self, s: str) -> int:
        dep = 0
        res = 0
        for c in s:
            if c == '(':
                dep += 1
            if c == ')':
                res = max(res,dep)
                dep -= 1
        return res

4、1266. 访问所有点的最小时间

平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi] 。请你计算访问所有这些点需要的 最小时间（以秒为单位）。

你需要按照下面的规则在平面上移动：

每一秒内，你可以：
沿水平方向移动一个单位长度，或者
沿竖直方向移动一个单位长度，或者
跨过对角线移动 sqrt(2) 个单位长度（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
必须按照数组中出现的顺序来访问这些点。
在访问某个点时，可以经过该点后面出现的点，但经过的那些点不算作有效访问。

示例 1：

输入：points = [[1,1],[3,4],[-1,0]]
输出：7
解释：一条最佳的访问路径是： [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]
从 [1,1] 到 [3,4] 需要 3 秒
从 [3,4] 到 [-1,0] 需要 4 秒
一共需要 7 秒
示例 2：

输入：points = [[3,2],[-2,2]]
输出：5

提示：

points.length == n
1 <= n <= 100
points[i].length == 2
-1000 <= points[i][0], points[i][1] <= 1000

这道题是简单的贪心算法，只要需要斜着走我们就斜着，所以只要在答案里加上两点之间长宽绝对值中大的那个即可

class Solution:
    def minTimeToVisitAllPoints(self, points: List[List[int]]) -> int:
        res = 0
        for i in range(len(points)):
            if i == 0:
                continue
            res += max(abs(points[i][1] - points[i-1][1]),abs(points[i][0] - points[i-1][0]))
        return res

4、52. N皇后 II

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。

示例 1：

输入：n = 4
输出：2
解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：

输入：n = 1
输出：1

提示：

1 <= n <= 9
皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。

经典深搜，也是老套路了，判断可以放就放入，放够8个就输出

class Solution:
    def totalNQueens(self, n: int) -> int:
        self.ans = 0
        li = [0 for i in range(n+1)]
        def dfs(k):
            if k == n + 1:
                self.ans += 1
                return
            for i in range(1, n + 1):
                for j in range(1, k):
                    if li[j] == i:
                        break;
                    if abs(i - li[j]) == abs(k - j):
                        break
                else:
                    li[k] = i
                    dfs(k+1)
        dfs(1)
        return self.ans

5、1732. 找到最高海拔

有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。

给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差（0 <= i < n）。请你返回 最高点的海拔 。

示例 1：

输入：gain = [-5,1,5,0,-7]
输出：1
解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
示例 2：

输入：gain = [-4,-3,-2,-1,4,3,2]
输出：0
解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。

提示：

n == gain.length
1 <= n <= 100
-100 <= gain[i] <= 100

模拟，和前缀和有点像，遍历一遍，找出最高点即可

class Solution:
    def largestAltitude(self, gain: List[int]) -> int:
        res = 0
        ma = 0
        for dif in gain:
            res += dif
            ma = max(ma,res)
        return ma

6、面试题 08.04. 幂集

幂集。编写一种方法，返回某集合的所有子集。集合中不包含重复的元素。

说明：解集不能包含重复的子集。

示例:

输入： nums = [1,2,3]
输出：
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

这个题我们可以找到他的递推公式，f(n) = [i for i in f(n-1) + [num[n]]] + [f(n - 1)]

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        self.ans = [[],]
        if len(nums) == 0:
            return self.ans
        for num in nums:
            self.ans += [arr+[num] for arr in self.ans]
        return self.ans

7、1342. 将数字变成 0 的操作次数

给你一个非负整数 num ，请你返回将它变成 0 所需要的步数。 如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。

示例 1：

输入：num = 14
输出：6
解释：
步骤 1) 14 是偶数，除以 2 得到 7 。
步骤 2） 7 是奇数，减 1 得到 6 。
步骤 3） 6 是偶数，除以 2 得到 3 。
步骤 4） 3 是奇数，减 1 得到 2 。
步骤 5） 2 是偶数，除以 2 得到 1 。
步骤 6） 1 是奇数，减 1 得到 0 。
示例 2：

输入：num = 8
输出：4
解释：
步骤 1） 8 是偶数，除以 2 得到 4 。
步骤 2） 4 是偶数，除以 2 得到 2 。
步骤 3） 2 是偶数，除以 2 得到 1 。
步骤 4） 1 是奇数，减 1 得到 0 。
示例 3：

输入：num = 123
输出：12

提示：

0 <= num <= 10^6

这道题数据量也是很小，也只访问一次，所以直接模拟就好了

class Solution:
    def numberOfSteps (self, num: int) -> int:
        cnt = 0
        while(num != 0):
            cnt += 1
            if num % 2 == 0:
                num /= 2
            else :
                num -= 1
        return cnt

8、1551. 使数组中所有元素相等的最小操作数

存在一个长度为 n 的数组 arr ，其中 arr[i] = (2 * i) + 1 （ 0 <= i < n ）。

一次操作中，你可以选出两个下标，记作 x 和 y （ 0 <= x, y < n ）并使 arr[x] 减去 1 、arr[y] 加上 1 （即 arr[x] -=1 且 arr[y] += 1 ）。最终的目标是使数组中的所有元素都 相等 。题目测试用例将会 保证 ：在执行若干步操作后，数组中的所有元素最终可以全部相等。

给你一个整数 n，即数组的长度。请你返回使数组 arr 中所有元素相等所需的 最小操作数 。

示例 1：

输入：n = 3
输出：2
解释：arr = [1, 3, 5]
第一次操作选出 x = 2 和 y = 0，使数组变为 [2, 3, 4]
第二次操作继续选出 x = 2 和 y = 0，数组将会变成 [3, 3, 3]
示例 2：

输入：n = 6
输出：9

提示：

1 <= n <= 10^4

因为他说一定等于，所以我们直接让小于平均数的所有数字变成平均数即可，当然如果我们判断一下奇数偶数也可以总结出公式来得到更好的复杂度

class Solution:
    def minOperations(self, n: int) -> int:
        res = 0
        for i in range(1,n+1,2):
            res += n - i
        return res

9、654. 最大二叉树

给定一个不含重复元素的整数数组 nums 。一个以此数组直接递归构建的 最大二叉树 定义如下：

二叉树的根是数组 nums 中的最大元素。
左子树是通过数组中 最大值左边部分 递归构造出的最大二叉树。
右子树是通过数组中 最大值右边部分 递归构造出的最大二叉树。
返回有给定数组 nums 构建的 最大二叉树 。

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：

• [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
  • [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
    • 空数组，无子节点。
    • [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
      • 空数组，无子节点。
      • 只有一个元素，所以子节点是一个值为 1 的节点。
  • [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
    • 只有一个元素，所以子节点是一个值为 0 的节点。
    • 空数组，无子节点。
      示例 2：

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同

二叉树的问题在之前有写过专题，这道题和其中的一些题非常像，就是对区间进行求最大值，其实可以用RMQ来优化一下，因为数据量不大，直接写也能过

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        def create(start,end):
            if start == end:
                return None
            if start == end - 1:
                return TreeNode(nums[start])
            ide = start
            for i in range(start,end):
                if nums[i] > nums[ide]:
                    ide = i
            root = TreeNode(nums[ide])
            root.left = create(start,ide)
            root.right = create(ide+1,end)
            return root
        return create(0,len(nums))

10、1637. 两点之间不包含任何点的最宽垂直面积

给你 n 个二维平面上的点 points ，其中 points[i] = [xi, yi] ，请你返回两点之间内部不包含任何点的 最宽垂直面积 的宽度。

垂直面积 的定义是固定宽度，而 y 轴上无限延伸的一块区域（也就是高度为无穷大）。 最宽垂直面积 为宽度最大的一个垂直面积。

请注意，垂直区域 边上 的点 不在 区域内。

示例 1：

输入：points = [[8,7],[9,9],[7,4],[9,7]]
输出：1
解释：红色区域和蓝色区域都是最优区域。
示例 2：

输入：points = [[3,1],[9,0],[1,0],[1,4],[5,3],[8,8]]
输出：3

提示：

n == points.length
2 <= n <= 105
points[i].length == 2
0 <= xi, yi <= 109

将坐标按照横坐标大小排序，然后输出最大的差值即可

class Solution:
    def maxWidthOfVerticalArea(self, points: List[List[int]]) -> int:
        def sor(ele):
            return ele[0]
        points.sort(key = sor)
        res = 0
        for i in range(len(points)):
            if i >=  1:
                res = max(res,points[i][0] - points[i-1][0])
        return res