力扣第113场双周赛
前言
这场双周赛是我打得最差的一回，只做出来一道题，呜呜呜，我是个fw，下次继续加油吧！
2855. 使数组成为递增数组的最少右移次数
思路分析：
明确右移操作该如何进行：nums[-1:] + nums[:-1] 即可！
首先，构造出一个排序好的数组，进行0~n - 1次右移操作，每次操作后与有序数组进行比较，若相同则返回次数，否则继续，若超过n - 1次，就返回 -1！
class Solution:
def minimumRightShifts(self, nums: List[int]) -> int:
lst = sorted(nums)
n = len(nums)
cnt = 0
if lst == nums:
return 0
while 1:
if cnt == n:
return -1
tmp = nums[-1:] + nums[:-1]
if tmp == lst:
return cnt + 1
nums = tmp
cnt += 1
作为，第一题比赛的时候这样做，是无可厚非的，但比完赛就要思考有没有是什么更好的方法呢？
首先，看一下更优雅但未改进的方法（灵神的！）
class Solution:
def minimumRightShifts(self, nums: List[int]) -> int:
for i in range(len(nums)):
if all(x < y for x, y in pairwise(nums)):
return i
nums = nums[-1:] + nums[:-1]
return -1
那么，该怎么改进呢？
思考：如果最后可以使数组成为递增数组，那么一开始必定是这样两种情况！
①一开始就是递增的；
②有且仅有有两段递增序列，且第二段递增序列的值是最大值小于第一段递增序列的最小值！【如下图：3 < 4】
如果，我们找到大于两段递增序列的话，那么一定是不合法的，返回-1即可！
class Solution:
def minimumRightShifts(self, nums: List[int]) -> int:
i,n = 1,len(nums)
while i < n and nums[i - 1] < nums[i]:
i += 1
# 说明一开始就是递增序列，返回0！
if i == n:
return 0
# 如果第二段递增序列的值是最大值大于第一段递增序列的最小值，不合法，返回-1。
if nums[0] < nums[-1]:
return -1
x = i
i += 1
while i < n and nums[i - 1] < nums[i]:
i += 1
# 如果多余两段递增序列，那么返回-1。
if i < n:
return -1
return n - x
类似于这样的题，还有搜索旋转排序数组。
有兴趣的，可以去做一下,我贴一下代码，用到了不寻常的二分！
class Solution:
def search(self, nums: List[int], target: int) -> int:
left,right = 0,len(nums) - 1
while left <= right:
mid = left + right >> 1
if nums[mid] == target:return mid
if nums[0] <= nums[mid]:
if nums[0] <= target < nums[mid]:
right = mid - 1
else:
left = mid + 1
else:
if nums[mid] < target <= nums[-1]:
left = mid + 1
else:
right = mid - 1
return -1
2856. 删除数对后的最小数组长度
思路分析：
这种题目需要找规律，首先从特例出发！设数组的长度为n
特例：设出现次数最多的那个数是x，且个数为cnt
①如果 cnt > n // 2，那剩下 n - cnt 个数肯定可以与x组合进行删除，最后剩下的数肯定只有x了，其个数为：cnt - (n - cnt) = 2cnt - n
②如果 cnt = n // 2，这里还要判断，n是否为奇数，如果是的话，最后一定会剩下1个数，如果是偶数的话，一定什么也不剩了，x可以与剩下的所有数组合，删除！
③如果 cnt < n // 2，这种情况就要考验数学思维了！我们来具体分析一波！
我们将除了x之外的其他数，分成两堆 y 与 z，只要这两堆中的数没有相同的就可以了！
一定可以分成两堆，如果只有一堆的话，则有x + y = n；x < n // 2;y < n // 2；这与题意不符！
如下图所示，我们设x出现了7次，y出现了6次，z出现了5次
我们可以让y,z进行组合，直到y和z的和加起来小于等于 x（此处由于n为偶数，所以可以全部消去），进行一个状态的转换，使得第三种情况，转换成前面两种情况！
如果，总个数n 为奇数，那么最后，肯定还会剩下一个！
那么，我们可以不可以得到这样一个结论，y与z这两堆中的数进行组合消去后，一定可以使得y1 + z1 <= x呢？
答案是肯定的，我们来证明一波！
现有三堆元素，每一堆的元素数量分别为x,y,z，总数量为n;
【数量最大的是x；且x < n // 2；y > z；不同堆中的元素可以相互消除!】
只要，我们证明 y - z <= x即可，因为y与z这两堆的元素相互抵消后，最终剩下的元素的最小值为y - z，也就是把z给抵没了，如果满足的话，那么一定可以使 y1 + z1 == x 或者 y1 + z1 == x -1 (y1,z1为抵消后的数量，一开始 y + z > x)，那样，就可以这道题了！
已知：x + y + z = n，x < n // 2,y + z > x，x > y > z;
求证：y - z <= x
证明如下：
假设，y - z > x；
则有，y > x + z
则有，y > n - y
则有，2y > n
则有，y > n // 2，则 y > x，这与题意矛盾，所以反证成功！
那么，这个题的代码就水到渠成了！
class Solution:
def minLengthAfterRemovals(self, nums: List[int]) -> int:
cnt,n = Counter(nums),len(nums)
# Python的collection.Counter的一个比较方便的操作！
x = cnt.most_common(1)[0][1]
if x > n // 2:
return 2 * x - n
else:
return n & 1
这里贴一个灵神大佬的神奇代码，巧妙利用二分，如果一个元素的数量大于等于 n // 2,这个数一定是最中间的那个数！
作者：灵茶山艾府 链接
class Solution:
def minLengthAfterRemovals(self, nums: List[int]) -> int:
n = len(nums)
x = nums[n // 2]
max_cnt = bisect_right(nums, x) - bisect_left(nums, x)
return max(max_cnt * 2 - n, n % 2)
还有另一种方法，就是贪心。
贪心，每次选择数量最多的两个元素消除，这样保证可以最大程度的利用数量较多的元素进行消除！使用堆就可以了，注意Python中的是小根堆，加个负号就可以了！
class Solution:
def minLengthAfterRemovals(self, nums: List[int]) -> int:
cnt = Counter(nums).values()
heap = []
for x in cnt:
heappush(heap,-x)
while len(heap) >= 2:
m,n = -heappop(heap),-heappop(heap)
m -= 1
n -= 1
if m: heappush(heap,-m)
if n: heappush(heap,-n)
if len(heap) == 0:
return 0
else:
return -heap[0]
2857. 统计距离为 k 的点对
思路讲解
此题的关键在于数据范围，还有就是异或的性质，注意k的范围只有[0,100]
x1 ^ x2 + y1 ^ y2 = k
我们可以枚举 0 到 k
使得统计每一次枚举时，如果【x1 ^ x2 = i 以及 y1 ^ y2 = k - i】，累加！
如果这样枚举的话，需要O(n^2 * k)的时间复杂度，肯定会超时的！
注意：
x1 ^ x2 = i 可以推出 x1 ^ i = x2
这样的话：x1 ^ i = x2 、y1 ^ (k - i) = y2
每次枚举存储【x1,y1】在哈希表中，
我们只需要判断 【x2 ^ i，y2 ^ (k - i)】是否在已经存储过的哈希表中就可以了，如果哈希表中有【x2 ^ i，y2 ^ (k - i)】，那就累加!
两数之和的思想还是十分重要的！
代码就比较简单了：
class Solution:
def countPairs(self, coordinates: List[List[int]], k: int) -> int:
cnt = Counter()
ans = 0
for x,y in coordinates:
for i in range(k + 1):
ans += cnt[x ^ i,y ^ (k - i)]
cnt[x,y] += 1
return ans
2858. 可以到达每一个节点的最少边反转次数
思路分析
我们首先思考，如果从节点0出发，到达所有节点的最少反转边次数该怎样做？
有两种思路：dfs、bfs
首先，我们建一个图
g = [set() for _ in range(n)]
for u,v in edges:
g[u].add(v)
# 如果，边相反的话就取相反数
g[v].add(-u)
我们先用dfs试一下
cnt = 0
vis = [0 for _ in range(n)]
def dfs(u):
global cnt
vis[u] = 1
for v in g[u]:
if vis[abs(v)]:continue
if v < 0:
cnt += 1
dfs(abs(v))
dfs(0)
print(cnt)
再用bfs试一波
cnt = 0
vis = [0 for _ in range(n)]
q = [0]
vis[0] = 1
while q:
q1 = []
for u in q:
for v in g[u]:
if vis[abs(v)]:continue
if v < 0:
cnt += 1
vis[abs(v)] = 1
q1.append(abs(v))
q = q1
print(cnt)
那么，如果我们对每个点都用一遍dfs或者bfs是否可以呢？
当然不可以，n最大为10**5，这样的时间复杂度是O（n ** 2）的，肯定不可以！
那我们看看，每个点之间有没有什么联系！
我们已经求得ans[0] = 1；
只需要反转0 - 2这条边，那么我们可以推出ans[2]吗？
实际上是可以的，我们只需要看2 到 0这条边是否需要反转就可以了，如果不需要反转的话，那么ans[2] = ans[0] - 1；如果需要反转的话，ans[2] = ans[0] + 1。
为什么，可以这样说呢？
因为，0到所有点与2到所有点不同的是只是在 2 - 0之间这一条路径上，其余的路径都是相同的！
所以，我们可以根据ans[0]把所有的ans[i]都给推出来，只需要看两个节点之间的边的方向就可以了！
class Solution:
def minEdgeReversals(self, n: int, edges: List[List[int]]) -> List[int]:
g = [set() for _ in range(n)]
for u,v in edges:
g[u].add(v)
# 如果，边相反的话就取相反数
g[v].add(-u)
ans = [0 for _ in range(n)]
vis = [0 for _ in range(n)]
def dfs(u):
vis[u] = 1
for v in g[u]:
if vis[abs(v)]:continue
if v < 0:
ans[0] += 1
dfs(abs(v))
dfs(0)
vis = [0 for _ in range(n)]
def dfs1(u):
nonlocal vis
vis[u] = 1
for v in g[u]:
if vis[abs(v)]:continue
# 说明 v -> u 是顺边
if v < 0:
ans[-v] = ans[u] - 1
# 说明 v -> u 是逆边，因为 u -> v 是顺边！
else:
ans[v] = ans[u] + 1
dfs1(abs(v))
dfs1(0)
return ans
同时，这个题我们还有一个思路，那就是通过一遍bfs，维护所有点到0之间的距离step，以及该点到0之间的路径需要反转的边数cnt!
那么，ans[i] = ans[0] - cnt + (step - cnt) = ans[0] + step - 2cnt
ans[0] - cnt 表示在 0 到 i 路径之外的需要翻转的数量！
step - cnt 表示在 0 到 i 路径之内的需要翻转的数量！
其代码如下所示：
class Solution:
def minEdgeReversals(self, n: int, edges: List[List[int]]) -> List[int]:
ans = [0 for _ in range(n)]
g = [set() for _ in range(n)]
for u,v in edges:
g[u].add(v)
g[v].add(-u)
# vis[i][0]表示0与i之间的距离step,vis[i][1]表示0与i之间的需要翻转的边的数量！
vis = {0:(0,0)}
# q里存的是，节点和需要翻转的边的数量；【距离可以通过step来维护，因为是bfs，每一层加1】
# 相当于一个层序遍历了！
q = [(0,0)]
step = 1
while q:
q1 = []
for u,cnt in q:
for v in g[u]:
if v > 0 and v not in vis:
q1.append((v,cnt))
vis[v] = (step,cnt)
if v < 0 and -v not in vis:
q1.append((-v,cnt + 1))
vis[-v] = (step,cnt + 1)
ans[0] += 1
q = q1
step += 1
for i in range(1,n):
ans[i] = ans[0] + vis[i][0] - 2 * vis[i][1]
return ans
总结
终于写完了，这篇博客花了我4个小时，好在每道题都弄懂了，也学到了新的东西，加油！