1608. 特殊数组的特征值【排序】
思路
将数组升序排序，遍历数组，如果nums[n - i] >= i and nums[n - i -1] < i则i满足条件。注意边界情况。
AC代码
class Solution:
def specialArray(self, nums: List[int]) -> int:
nums = sorted(nums)
n = len(nums)
ans = -1
for i in range(1, 1001):
if n - i < 0:
break
if nums[n - i] >= i and (n - i == 0 or nums[n - i - 1] < i):
ans = i
break
return ans
这里如果数据量大，也可用二分来找i。但是话说回来，sorted的复杂度已经nlogn了，二分优化不了最大的复杂度，即原来的复杂度是O(nlogn + n)，而优化过的复杂度是O(nlogn + logn)。
670. 最大交换【贪心】
思路
先将数的每位分离出来，之后可用交换排序的思想，找数组里面的最大元素，与当前元素做交换。
AC代码
class Solution:
def maximumSwap(self, num: int) -> int:
arr = []
while num > 0:
arr.append(num % 10)
num //= 10
arr = list(reversed(arr))
n = len(arr)
# 交换排序
for i in range(n):
tmp = arr[i]
pos = i
flag = False
for j in range(n - 1, i, -1):
if arr[j] > tmp:
tmp = arr[j]
pos = j
flag = True
arr[i], arr[pos] = arr[pos], arr[i]
if flag:
break
ans = 0
for val in arr:
ans = ans * 10 + val
return ans
1619. 删除某些元素后的数组均值【排序】
思路
最小5%和最大5%就是数组排序后前n/20， 和后n/20的数，将其过滤，算中间数的平均值即可。
AC代码
class Solution:
def trimMean(self, arr: List[int]) -> float:
arr = sorted(arr)
ans, n = 0, len(arr)
k = n // 20
for i in range(k, n - k):
ans += arr[i]
return ans / (n - k * 2)
672. 灯泡开关 Ⅱ【规律题】
思路
枚举n=1-5的情况，p枚举1-4的情况，会发现答案只有1， 2， 3， 4， 7， 8，这六种答案。
AC代码
class Solution:
def flipLights(self, n: int, p: int) -> int:
if p == 0:
return 1
if n == 1:
return 2
if n == 2:
return 3 if p == 1 else 4
if n > 2:
if p == 1:
return 4
return 7 if p == 2 else 8
850. 矩形面积 II
不会，这题用了好几种算法
换个题吧
1856.子数组最小乘积的最大值【前缀和+单调栈】
思路
- 找右边第一个比当前值小的下标r， 再找左边第一个比当前值小的下标l，求这段区间的和
- 这段区间的和可以用前缀和预处理
- 找l 和 r用单调栈
AC代码
class Solution:
def maxSumMinProduct(self, nums: List[int]) -> int:
nums = [0] + nums + [0] # 添加两个哨兵作为单调栈的两个边界
pre_sum = [0]
for num in nums:
pre_sum.append(pre_sum[-1] + num)
n = len(nums)
rfs = [None] * n # right_first_smaller 找右边第一个比i小的
stack = []
for i in range(n):
while stack and nums[i] < nums[stack[-1]]:
rfs[stack.pop()] = i
stack.append(i)
lfs = [None] * n # left_first_smaller 找左边第一个比i小的
stack = []
for i in range(n - 1, -1, -1):
while stack and nums[i] < nums[stack[-1]]:
lfs[stack.pop()] = i
stack.append(i)
mx = 0
for i in range(1, n - 1):
r = rfs[i]
l = lfs[i]
mx = max(mx, nums[i] * (pre_sum[r] - pre_sum[l + 1]))
return mx % (10**9 + 7)
1624. 两个相同字符之间的最长子字符串
思路
用字符映射，只存不同字符出现的第一个字符，然后判断后面字符串有相同字符，将其下标作差-1即可。
AC代码
class Solution:
def maxLengthBetweenEqualCharacters(self, s: str) -> int:
tmp = [None] * 26
ans = -1
for i, ch in enumerate(s):
if tmp[ord(ch) - 97] != None:
ans = max(ans, i - tmp[ord(ch) - 97] - 1)
else:
tmp[ord(ch) - 97] = i
return ans
827. 最大人工岛【并查集】
思路
第一遍并查集：将所有连通的1合并的一个集合
第二遍并查集：判断当前值为0的周边值，如果为1，则可将0变成1再来看连通分量的大小是多少。
AC代码
class Solution:
# 方法1并查集
def largestIsland(self, grid: List[List[int]]) -> int:
def find(a):
if f[a] != a:
f[a] = find(f[a])
return f[a]
def union(a, b):
fa, fb = find(a), find(b)
if fa != fb:
f[fa] = fb # fb为父亲
size[fb] += size[fa]
n = len(grid)
f = list(range(n * n))
size = [1] * (n * n)
for i, row in enumerate(grid):
for j, v in enumerate(row):
if v == 1: # 将连通的1合并为一个集合
for a, b in [[0, -1], [-1, 0]]: # python强大之处，不用遍历四个方向，因为左边界走完就到了右边界，上边界走完到了下边界。
x, y = i + a, j + b
if 0 <= x < n and 0 <= y < n and grid[x][y] == 1:
union(x * n + y, i * n + j) # 将其转化为1维进行合并
ans = max(size)
for i, row in enumerate(grid):
for j, v in enumerate(row):
vis = set()
t = 1
if v == 0:
for a, b in [[0, -1], [-1, 0], [0, 1], [1, 0]]:
x, y = i + a, j + b
if 0 <= x < n and 0 <= y < n and grid[x][y] == 1:
root = find(x * n + y)
if root not in vis:
vis.add(root)
t += size[root] # 累加周围连通块为1的集合大小
ans = max(ans, t)
return ans