⭐️ 本文已收錄到 AndroidFamily，技術和職場問題，請關注公眾號 [彭旭銳] 和 BaguTree Pro 知識星球提問。
學習資料結構與演算法的關鍵在於掌握問題背後的演算法思維框架，你的思考越抽象，它能覆蓋的問題域就越廣，理解難度也更復雜。在這個專欄裡，小彭與你分享每場 LeetCode 周賽的解題報告，一起體會上分之旅。
本文是 LeetCode 上分之旅系列的第 45 篇文章，往期回顧請移步到文章末尾\~
LeetCode 雙週賽 113 概覽
T1. 使陣列成為遞增陣列的最少右移次數（Easy）
- 標籤：模擬、暴力、線性遍歷
T2. 刪除數對後的最小陣列長度（Medium）
- 標籤：二分答案、雙指標、找眾數、
T3. 統計距離為 k 的點對（Medium）
- 標籤：列舉、雜湊表
T4. 可以到達每一個節點的最少邊反轉次數（Hard）
- 標籤：樹上 DP
T1. 使陣列成為遞增陣列的最少右移次數（Easy）
https://leetcode.cn/problems/minimum-right-shifts-to-sort-the-array/description/題解一（暴力列舉）
簡單模擬題。
由於題目資料量非常小，可以把陣列複製一份拼接在尾部，再列舉從位置 $i$ 開始長為 $n$ 的連續迴圈子陣列是否連續，是則返回 $(n - i)\%n$：
class Solution {
fun minimumRightShifts(nums: MutableList<Int>): Int {
val n = nums.size
nums.addAll(nums)
for (i in 0 until n) {
if ((i + 1 ..< i + n).all { nums[it] > nums[it - 1]}) return (n - i) % n
}
return -1
}
}class Solution:
def minimumRightShifts(self, nums: List[int]) -> int:
n = len(nums)
nums += nums
for i in range(0, n):
if all(nums[j] > nums[j - 1] for j in range(i + 1, i + n)):
return (n - i) % n
return -1複雜度分析：
- 時間複雜度：$O(n^2)$ 雙重迴圈；
- 空間複雜度：$O(n)$ 迴圈陣列空間。
題解二（線性遍歷）
更優的寫法，我們找到第一個逆序位置，再檢查該位置後續位置是否全部為升序，且滿足 $nums[n - 1] < nums[0]$：
class Solution {
fun minimumRightShifts(nums: List<Int>): Int {
val n = nums.size
for (i in 1 until n) {
// 第一段
if (nums[i] >= nums[i - 1]) continue
// 第二段
if (nums[n - 1] > nums[0]) return -1
for (j in i until n - 1) {
if (nums[j] > nums[j + 1]) return -1
}
return n - i
}
return 0
}
}複雜度分析：
- 時間複雜度：$O(n)$ $i$ 指標和 $j$ 指標總計最多移動 $n$ 次；
- 空間複雜度：$O(1)$ 僅使用常量級別空間。
T2. 刪除數對後的最小陣列長度（Medium）
https://leetcode.cn/problems/minimum-array-length-after-pair-removals/題解一（二分答案）
問題存在單調性：
- 當操作次數 $k$ 可以滿足時，操作次數 $k - 1$ 一定能滿足；
- 當操作次數 $k$ 不可滿足時，操作次數 $k + 1$ 一定不能滿足。
那麼，原問題相當於求解滿足目標的最大操作次數。
現在需要考慮的問題是：如何驗證操作次數 $k$ 是否可以完成？
一些錯誤的思路：
- 嘗試 1 - 貪心雙指標： $nums[i]$ 優先使用最小值，$nums[j]$ 優先使用最大值，錯誤用例：$[1 2 3 6]$；
- 嘗試 2 - 貪心： $nums[i]$ 優先使用最小值，$nums[j]$ 使用大於 $nums[i]$ 的最小值，錯誤用例：$[1 2 4 6]$；
- 嘗試 3 - 貪心： 從後往前遍歷，$nums[i]$ 優先使用較大值，$nums[j]$ 使用大於 $nums[i]$ 的最小值，錯誤用例：$[2 3 4 8]$。
開始轉換思路：
能否將陣列拆分為兩部分，作為 nums[i] 的分為一組，作為 $nums[j]$ 的分為一組。 例如，在用例 $[1 2 | 3 6]$ 和 $[1 2 | 4 6]$ 和 $[2 3 | 4 8]$ 中，將陣列的前部分作為 $nums[i]$ 而後半部分作為 $nums[j]$ 時，可以得到最優解，至此發現貪心規律。
設陣列的長度為 $n$，最大匹配對數為 $k$：
- 結論 1： 使用陣列的左半部分作為 $nums[i]$ 且使用陣列的右半部分作為 $nums[j]$ 總能取到最優解。反之，如果使用右半部分的某個數 $nums[t]$ 作為 $nums[i]$，相當於佔用了一個較大的數，不利於後續 $nums[i]$ 尋找配對；
- 結論 2： 當固定 $nums[i]$ 時，$nums[j]$ 越小越好，否則會佔用一個較大的位置，不利於後續 $nums[i]$ 尋找配對。因此最優解一定是使用左半部分的最小值與右半部分的最小值配對。
總結：如果存在 $k$ 對匹配，那麼一定可以讓最小的 $k$ 個數和最大的 $k$ 個數匹配。
基於以上分析，可以寫出二分答案：
class Solution {
fun minLengthAfterRemovals(nums: List<Int>): Int {
val n = nums.size
var left = 0
var right = n / 2
while (left < right) {
val k = (left + right + 1) ushr 1
if ((0 ..< k).all { nums[it] < nums[n - k + it] }) {
left = k
} else {
right = k - 1
}
}
return n - 2 * left
}
}複雜度分析：
- 時間複雜度：$O(nlgn)$ 二分答案次數最大為 $lgn$ 次，單次檢驗的時間複雜度是 $O(n)$；
- 空間複雜度：$O(1)$ 僅使用常量級別空間。
題解二（雙指標）
基於題解一的分析，以及刪除操作的上界 $n / 2$，我們可以僅使用陣列的後半部分與前半部分作比較，具體演算法：
- i 指標指向索引 $0$
- j 指標指向索引 $(n + 1) / 2$
- 向右列舉 $j$ 指標，如果 $i$、$j$ 指標指向的位置能夠匹配，則向右移動 $i$ 指標；
- 最後 $i$ 指標移動的次數就等於刪除操作次數。
class Solution {
fun minLengthAfterRemovals(nums: List<Int>): Int {
val n = nums.size
var i = 0
for (j in (n + 1) / 2 until n) {
if (nums[i] < nums[j]) i++
}
return n - 2 * i
}
}複雜度分析：
- 時間複雜度：$O(n)$ 線性遍歷；
- 空間複雜度：$O(1)$ 僅使用常量級別空間。
題解三（眾數）
由於題目的操作只要滿足 $nums[i] < nums[j]$，即兩個數不相等即可，那麼問題的解最終僅取決於陣列中的眾數的出現次數：
- 如果眾數的出現次數比其他元素少，那麼所有元素都能刪除，問題的結果就看陣列總長度是奇數還是偶數；
- 否則，剩下的元素就是眾數：$s - (n - s)$
最後，由於陣列是非遞減的，因此可以在 $O(1)$ 空間求出眾數的出現次數：
class Solution {
fun minLengthAfterRemovals(nums: List<Int>): Int {
val n = nums.size
var s = 1
var cur = 1
for (i in 1 until n) {
if (nums[i] == nums[i - 1]) {
s = max(s, ++ cur)
} else {
cur = 1
}
}
if (s <= n - s) {
return n % 2
} else {
return s - (n - s)
}
}
}複雜度分析：
- 時間複雜度：$O(n)$ 線性遍歷；
- 空間複雜度：$O(1)$ 僅使用常量級別空間。
題解四（找規律 + 二分查詢）
繼續挖掘資料規律：
$s <= n - s$ 等價於眾數的出現次數超過陣列長度的一半，由於陣列是有序的，那麼一定有陣列的中間位置就是眾數，我們可以用二分查詢找出眾數在陣列中出現位置的邊界，從而計算出眾數的出現次數。
由此，我們甚至不需要線性掃描都能計算出眾數以及眾數的出現次數，Nice！
當然，最後計算出來的出現次數有可能沒有超過陣列長度的一半。
class Solution {
fun minLengthAfterRemovals(nums: List<Int>): Int {
val n = nums.size
val x = nums[n / 2]
val s = lowerBound(nums, x + 1) - lowerBound(nums, x)
return max(2 * s - n, n % 2)
}
fun lowerBound(nums: List<Int>, target: Int): Int {
var left = 0
var right = nums.size - 1
while (left < right) {
val mid = (left + right + 1) ushr 1
if (nums[mid] >= target) {
right = mid - 1
} else {
left = mid
}
}
return if (nums[left] == target) left else left + 1
}
}複雜度分析：
- 時間複雜度：$O(lgn)$ 單次二分查詢的時間複雜度是 $O(lgn)$；
- 空間複雜度：$O(1)$ 僅使用常量級別空間。
相似題目：
T3. 統計距離為 k 的點對（Medium）
https://leetcode.cn/problems/count-pairs-of-points-with-distance-k/題解（雜湊表）
- 問題目標： 求 $(x1 xor x2) + (y1 xor y2) == k$ 的方案數；
- 技巧： 對於存在多個變數的問題，可以考慮先固定其中一個變數；
容易想到兩數之和的問題模板，唯一需要思考的問題是如何設計雜湊表的存取方式：
對於滿足 $(x1\ xor\ x2) + (y1\ xor\ y2) == k$ 的方案，我們抽象為兩部分 $i + j = k$，其中，$i = (x1\ xor\ x2)$ 的取值範圍為 $[0, k]$，而 $j = k - i$，即總共有 $k + 1$ 種方案。本題的 $k$ 資料範圍很小，所以我們可以寫出時間複雜度 $O(nk)$ 的演算法。
class Solution {
fun countPairs(coordinates: List<List<Int>>, k: Int): Int {
var ret = 0
// <x, <y, cnt>>
val map = HashMap<Int, HashMap<Int, Int>>()
for ((x2, y2) in coordinates) {
// 記錄方案
for (i in 0 .. k) {
if (!map.containsKey(i xor x2)) continue
ret += map[i xor x2]!!.getOrDefault((k - i) xor y2, 0)
}
// 累計次數
map.getOrPut(x2) { HashMap<Int, Int>() }[y2] = map[x2]!!.getOrDefault(y2, 0) + 1
}
return ret
}
}Python 計數器支援複合資料型別的建，可以寫出非常簡潔的程式碼：
class Solution:
def countPairs(self, coordinates: List[List[int]], k: int) -> int:
c = Counter()
ret = 0
for x2, y2 in coordinates:
# 記錄方案
for i in range(k + 1):
ret += c[(i ^ x2, (k - i) ^ y2)]
# 累計次數
c[(x2, y2)] += 1
return ret複雜度分析：
- 時間複雜度：$O(n·k)$ 線性列舉，每個元素列舉 $k$ 種方案；
- 空間複雜度：$O(n)$ 雜湊表空間。
T4. 可以到達每一個節點的最少邊反轉次數（Hard）
https://leetcode.cn/problems/minimum-edge-reversals-so-every-node-is-reachable/問題分析
初步分析：
- 問題目標： 求出以每個節點為根節點時，從根節點到其他節點的反轉操作次數，此題屬於換根 DP 問題
思考實現：
- 暴力： 以節點 $i$ 為根節點走一次 BFS/DFS，就可以在 $O(n)$ 時間內求出每個節點的解，整體的時間複雜度是 $O(n^2)$
思考最佳化：
- 重疊子問題： 相鄰邊連線的節點間存在重疊子問題，當我們從根節點 $u$ 移動到其子節點 $v$ 時，我們可以利用已有資訊在 $O(1)$ 時間算出 $v$ 為根節點時的解。
具體實現：
- 1、隨機選擇一個點為根節點 $u$，在一次 DFS 中根節點 $u$ 的反轉操作次數：
2、$u → v$ 的狀態轉移：
- 如果 $u → v$ 是正向邊，則反轉次數 $+ 1$；
- 如果 $u → v$ 是反向邊，則反轉次數 $- 1$（從 $v$ 到 $u$ 不用反轉）；
- 3、由於題目是有向圖，我們可以轉換為無向圖，再利用標記位 $1$ 和 $-1$ 表示邊的方向，$1$ 為正向邊，$-1$ 為反向邊。
題解（換根 DP）
class Solution {
fun minEdgeReversals(n: Int, edges: Array<IntArray>): IntArray {
val dp = IntArray(n)
val graph = Array(n) { LinkedList<IntArray>() }
// 建圖
for ((from, to) in edges) {
graph[from].add(intArrayOf(to, 1))
graph[to].add(intArrayOf(from, -1))
}
// 以 0 為根節點
fun dfs(i: Int, fa: Int) {
for ((to, gain) in graph[i]) {
if (to == fa) continue
if (gain == -1) dp[0] ++
dfs(to, i)
}
}
fun dp(i: Int, fa: Int) {
for ((to, gain) in graph[i]) {
if (to == fa) continue
// 狀態轉移
dp[to] = dp[i] + gain
dp(to, i)
}
}
dfs(0, -1)
dp(0, -1)
return dp
}
}複雜度分析：
- 時間複雜度：$O(n)$ DFS 和換根 DP 都是 $O(n)$；
- 空間複雜度：$O(n)$ 遞迴棧空間與 DP 陣列空間。
推薦閱讀
LeetCode 上分之旅系列往期回顧：
- LeetCode 單週賽第 361 場 · 同餘字首和問題與經典倍增 LCA 演算法
- LeetCode 單週賽第 360 場 · 當 LeetCode 考樹上倍增，出題的趨勢在變化嗎
- LeetCode 雙週賽第 112 場 · 電腦科學本質上是數學嗎？
- LeetCode 雙週賽第 111 場 · 按部就班地解決動態規劃問題
⭐️ 永遠相信美好的事情即將發生，歡迎加入小彭的 Android 交流社群\~
