1464：數組中兩元素的最大乘積
給你一個整數數組 nums，請你選擇數組的兩個不同下標 i 和 j，使 (nums[i]-1)*(nums[j]-1) 取得最大值。
請你計算並返回該式的最大值。
提示：
2 <= nums.length <= 500
1 <= nums[i] <= 10^3
算法
class Solution:
def maxProduct(self, nums: List[int]) -> int:
nums.sort()
return (nums[-1]-1)*(nums[-2]-1)
執行用時 :36 ms, 在所有 Python3 提交中擊敗了100.00%的用戶
內存消耗 :13.8 MB, 在所有 Python3 提交中擊敗了100.00%的用戶
class Solution:
def maxProduct(self, nums: List[int]) -> int:
a,b=0,0
for i in nums:
if i>b:
b=i
if b>a:
a,b=b,a
return (a-1)*(b-1)
1465. 切割後面積最大的蛋糕
矩形蛋糕的高度爲 h 且寬度爲 w，給你兩個整數數組 horizontalCuts 和 verticalCuts，其中 horizontalCuts[i] 是從矩形蛋糕頂部到第 i 個水平切口的距離，類似地， verticalCuts[j] 是從矩形蛋糕的左側到第 j 個豎直切口的距離。
請你按數組 horizontalCuts 和 verticalCuts 中提供的水平和豎直位置切割後，請你找出 面積最大 的那份蛋糕，並返回其 面積 。由於答案可能是一個很大的數字，因此需要將結果對 10^9 + 7 取餘後返回。
算法
腦子瓦特了才用暴力……
class Solution:
def maxArea(self, h: int, w: int, horizontalCuts, verticalCuts) -> int:
horizontalCuts.sort()
verticalCuts.sort()
res=0
horizontalCuts=[0]+horizontalCuts+[h]
verticalCuts=[0]+verticalCuts+[w]
for i in range(1,len(verticalCuts)):
for j in range(1,len(horizontalCuts)):
res=max(res,(verticalCuts[i]-verticalCuts[i-1])*(horizontalCuts[j]-horizontalCuts[j-1]))%(10**9+7)
return res
超時後纔想起來……
class Solution:
def maxArea(self, h: int, w: int, horizontalCuts, verticalCuts) -> int:
horizontalCuts.sort()
verticalCuts.sort()
a,b=0,0
horizontalCuts=[0]+horizontalCuts+[h]
verticalCuts=[0]+verticalCuts+[w]
for i in range(1,len(verticalCuts)):
a=max(a,verticalCuts[i]-verticalCuts[i-1])
for j in range(1,len(horizontalCuts)):
b=max(b,horizontalCuts[j]-horizontalCuts[j-1])
return a*b%(10**9+7)
其實就是取橫着切最長的一塊，和縱着切最長的一塊，乘積。
1466. 重新規劃路線
n 座城市，從 0 到 n-1 編號，其間共有 n-1 條路線。因此，要想在兩座不同城市之間旅行只有唯一一條路線可供選擇（路線網形成一顆樹）。去年，交通運輸部決定重新規劃路線，以改變交通擁堵的狀況。
路線用 connections 表示，其中 connections[i] = [a, b] 表示從城市 a 到 b 的一條有向路線。
今年，城市 0 將會舉辦一場大型比賽，很多遊客都想前往城市 0 。
請你幫助重新規劃路線方向，使每個城市都可以訪問城市 0 。返回需要變更方向的最小路線數。
題目數據 保證 每個城市在重新規劃路線方向後都能到達城市 0 。
提示：
2 <= n <= 5 * 10^4
connections.length == n-1
connections[i].length == 2
0 <= connections[i][0], connections[i][1] <= n-1
connections[i][0] != connections[i][1]
算法
觀察實例，很輕易的想到了廣度優先搜索，
- 從0出發（把0放入集合），將所有與0相連的線路檢查一遍是否需要逆轉，然後把相鄰城市放入集合，把鏈接從
connections中剔除 - 更新集合，重複第一步，直到
connections爲空。
class Solution:
def minReorder(self, n: int, connections) -> int:
res=0
ls={0}
while connections:
i=0
tp=set()
while i<len(connections):
if connections[i][0] in ls:
res+=1
tp.add(connections[i][1])
connections.pop(i)
elif connections[i][1] in ls:
tp.add(connections[i][0])
connections.pop(i)
else:
i+=1
ls=tp.copy()
return res
執行用時 :704 ms, 在所有 Python3 提交中擊敗了100.00%的用戶
內存消耗 :22.3 MB, 在所有 Python3 提交中擊敗了100.00%的用戶
1467. 兩個盒子中球的顏色數相同的概率
桌面上有 2n 個顏色不完全相同的球，球上的顏色共有 k 種。給你一個大小爲 k 的整數數組 balls ，其中 balls[i] 是顏色爲 i 的球的數量。
所有的球都已經 隨機打亂順序 ，前 n 個球放入第一個盒子，後 n 個球放入另一個盒子（請認真閱讀示例 2 的解釋部分）。
注意：這兩個盒子是不同的。例如，兩個球顏色分別爲 a 和 b，盒子分別爲 [] 和 ()，那麼 [a] (b) 和 [b] (a) 這兩種分配方式是不同的（請認真閱讀示例 1 的解釋部分）。
請計算「兩個盒子中球的顏色數相同」的情況的概率。
示例 1：
輸入：balls = [1,1]
輸出：1.00000
解釋：球平均分配的方式只有兩種：
- 顏色爲 1 的球放入第一個盒子，顏色爲 2 的球放入第二個盒子
- 顏色爲 2 的球放入第一個盒子，顏色爲 1 的球放入第二個盒子
這兩種分配，兩個盒子中球的顏色數都相同。所以概率爲 2/2 = 1 。
示例 2：
輸入：balls = [2,1,1]
輸出：0.66667
解釋：球的列表爲 [1, 1, 2, 3]
隨機打亂，得到 12 種等概率的不同打亂方案，每種方案概率爲 1/12 ：
[1,1 / 2,3], [1,1 / 3,2], [1,2 / 1,3], [1,2 / 3,1], [1,3 / 1,2], [1,3 / 2,1], [2,1 / 1,3], [2,1 / 3,1], [2,3 / 1,1], [3,1 / 1,2], [3,1 / 2,1], [3,2 / 1,1]
然後，我們將前兩個球放入第一個盒子，後兩個球放入第二個盒子。
這 12 種可能的隨機打亂方式中的 8 種滿足「兩個盒子中球的顏色數相同」。
概率 = 8/12 = 0.66667
示例 3：
輸入：balls = [1,2,1,2]
輸出：0.60000
解釋：球的列表爲 [1, 2, 2, 3, 4, 4]。要想顯示所有 180 種隨機打亂方案是很難的，但只檢查「兩個盒子中球的顏色數相同」的 108 種情況是比較容易的。
概率 = 108 / 180 = 0.6 。
示例 4：
輸入：balls = [3,2,1]
輸出：0.30000
解釋：球的列表爲 [1, 1, 1, 2, 2, 3]。要想顯示所有 60 種隨機打亂方案是很難的，但只檢查「兩個盒子中球的顏色數相同」的 18 種情況是比較容易的。
概率 = 18 / 60 = 0.3 。
示例 5：
輸入：balls = [6,6,6,6,6,6]
輸出：0.90327
提示：
1 <= balls.length <= 8
1 <= balls[i] <= 6
sum(balls) 是偶數
答案與真實值誤差在 10^-5 以內，則被視爲正確答案
算法
class Solution:
def getProbability(self, balls: List[int]) -> float:
# 球數， 顏色數
n, nc = sum(balls), len(balls)
# 總方案數
self.k = 0
# 取到第i種球，1盒球數, 1盒顏色數, 2盒球數，2盒顏色數，方案數
def dfs(i, m1, mc1, m2, mc2, k):
# 剪枝
if m1 > n//2 or m2 > n//2:
return
if i == nc:
if m1 == m2 and mc1 == mc2 :
self.k += k
return
for dm in range(balls[i]+1):
dfs(i + 1, m1 + dm, mc1 + (dm != 0), m2 + balls[i] - dm, mc2 + (dm != balls[i]), k*comb(balls[i], dm))
dfs(0, 0, 0, 0, 0, 1)
return self.k/comb(n, n//2)
直接貼的大佬的算法，啊，實在不想去想了。
comb是math 下的函數，python3.8以後纔有。