5436. 一維數組的動態和
給你一個數組 nums 。數組「動態和」的計算公式爲：runningSum[i] = sum(nums[0]…nums[i]) 。
請返回 nums 的動態和。
示例 1：
輸入：nums = [1,2,3,4]
輸出：[1,3,6,10]
解釋：動態和計算過程爲 [1, 1+2, 1+2+3, 1+2+3+4] 。
示例 2：
輸入：nums = [1,1,1,1,1]
輸出：[1,2,3,4,5]
解釋：動態和計算過程爲 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
示例 3：
輸入：nums = [3,1,2,10,1]
輸出：[3,4,6,16,17]
提示：
1 <= nums.length <= 1000
-10^6 <= nums[i] <= 10^6
代碼
class Solution {
public int[] runningSum(int[] nums) {
int n = nums.length, i = 0;
int[] sums = new int[n];
sums[0] = nums[0];
for (i=1; i<n; ++i) {
sums[i] = sums[i-1] + nums[i];
}
return sums;
}
}
5437. 不同整數的最少數目
給你一個整數數組 arr 和一個整數 k 。現需要從數組中恰好移除 k 個元素，請找出移除後數組中不同整數的最少數目。
示例 1：
輸入：arr = [5,5,4], k = 1
輸出：1
解釋：移除 1 個 4 ，數組中只剩下 5 一種整數。
示例 2：
輸入：arr = [4,3,1,1,3,3,2], k = 3
輸出：2
解釋：先移除 4、2 ，然後再移除兩個 1 中的任意 1 個或者三個 3 中的任意 1 個，最後剩下 1 和 3 兩種整數。
提示：
1 <= arr.length <= 10^5
1 <= arr[i] <= 10^9
0 <= k <= arr.length
代碼
class Solution:
def findLeastNumOfUniqueInts(self, arr: List[int], k: int) -> int:
cnts = dict()
for num in arr:
cnts[num] = cnts.setdefault(num, 0) + 1
cnts = list(cnts.values())
cnts.sort()
ans = len(cnts)
for cnt in cnts:
if k >= cnt:
k -= cnt
ans -= 1
else:
break
return ans
5438. 製作 m 束花所需的最少天數
給你一個整數數組 bloomDay，以及兩個整數 m 和 k 。
現需要製作 m 束花。製作花束時，需要使用花園中 相鄰的 k 朵花 。
花園中有 n 朵花，第 i 朵花會在 bloomDay[i] 時盛開，恰好 可以用於 一束 花中。
請你返回從花園中摘 m 束花需要等待的最少的天數。如果不能摘到 m 束花則返回 -1 。
示例 1：
輸入：bloomDay = [1,10,3,10,2], m = 3, k = 1
輸出：3
解釋：讓我們一起觀察這三天的花開過程，x 表示花開，而 _ 表示花還未開。
現在需要製作 3 束花，每束只需要 1 朵。
1 天后：[x, _, _, _, _] // 只能製作 1 束花
2 天后：[x, _, _, _, x] // 只能製作 2 束花
3 天后：[x, _, x, _, x] // 可以製作 3 束花，答案爲 3
示例 2：
輸入：bloomDay = [1,10,3,10,2], m = 3, k = 2
輸出：-1
解釋：要製作 3 束花，每束需要 2 朵花，也就是一共需要 6 朵花。而花園中只有 5 朵花，無法滿足製作要求，返回 -1 。
示例 3：
輸入：bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
輸出：12
解釋：要製作 2 束花，每束需要 3 朵。
花園在 7 天后和 12 天后的情況如下：
7 天后：[x, x, x, x, _, x, x]
可以用前 3 朵盛開的花製作第一束花。但不能使用後 3 朵盛開的花，因爲它們不相鄰。
12 天后：[x, x, x, x, x, x, x]
顯然，我們可以用不同的方式製作兩束花。
示例 4：
輸入：bloomDay = [1000000000,1000000000], m = 1, k = 1
輸出：1000000000
解釋：需要等 1000000000 天才能採到花來製作花束
示例 5：
輸入：bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
輸出：9
提示：
bloomDay.length == n
1 <= n <= 10^5
1 <= bloomDay[i] <= 10^9
1 <= m <= 10^6
1 <= k <= n
思路
二分答案。判斷答案是否符合要求的方法check用到了貪心
代碼
class Solution:
def check(self, mid, bloomDay, m, k):
avail = 0
consq = 0
for bloom in bloomDay:
if bloom <= mid:
consq += 1
if consq >= k:
consq -= k
avail += 1
else:
consq = 0
return avail >= m
def minDays(self, bloomDay: List[int], m: int, k: int) -> int:
left = 1
right = max(bloomDay)
mid = 0
if len(bloomDay) < m * k:
return -1
while left <= right:
mid = left + (right - left) // 2
if self.check(mid, bloomDay, m, k):
right = mid - 1
else:
left = mid + 1
return left
5188. 樹節點的第 K 個祖先
題目難度Hard
給你一棵樹，樹上有 n 個節點，按從 0 到 n-1 編號。樹以父節點數組的形式給出，其中 parent[i] 是節點 i 的父節點。樹的根節點是編號爲 0 的節點。
請你設計並實現 getKthAncestor(int node, int k) 函數，函數返回節點 node 的第 k 個祖先節點。如果不存在這樣的祖先節點，返回 -1 。
樹節點的第 k 個祖先節點是從該節點到根節點路徑上的第 k 個節點。
示例：
輸入：
[“TreeAncestor”,“getKthAncestor”,“getKthAncestor”,“getKthAncestor”]
[[7,[-1,0,0,1,1,2,2]],[3,1],[5,2],[6,3]]
輸出：
[null,1,0,-1]
解釋：
TreeAncestor treeAncestor = new TreeAncestor(7, [-1, 0, 0, 1, 1, 2, 2]);
treeAncestor.getKthAncestor(3, 1); // 返回 1 ，它是 3 的父節點
treeAncestor.getKthAncestor(5, 2); // 返回 0 ，它是 5 的祖父節點
treeAncestor.getKthAncestor(6, 3); // 返回 -1 因爲不存在滿足要求的祖先節點
提示：
1 <= k <= n <= 510^4
parent[0] == -1 表示編號爲 0 的節點是根節點。
對於所有的 0 < i < n ，0 <= parent[i] < n 總成立
0 <= node < n
至多查詢 510^4 次
思路
樹上倍增。相當於對於所有(node, k)的結果的cache的一種二進制壓縮。
cache[node][k]表示node節點的第2^k個祖先。遞推公式：cache[node][k] = cache[cache[node][k-1]][k-1]. 查詢時按k的二進制位（(1<<i)&k判斷k的第i位是否是1）使用cache回溯
計算cache時間複雜度爲O(nlogn)，一次查詢時間複雜度爲O(logn)，空間複雜度爲O(nlogn).
代碼
class TreeAncestor {
private HashMap<Integer, ArrayList<Integer>> sons;
private int[][] cache;
private static final int MAX_LOG_DEPTH=20;
public TreeAncestor(int n, int[] parent) {
sons = new HashMap<>();
for (int i=0; i<n; ++i) {
if (parent[i] != -1) {
if (!sons.containsKey(parent[i])) {
sons.put(parent[i], new ArrayList<>());
}
sons.get(parent[i]).add(i);
}
}
cache = new int[n][MAX_LOG_DEPTH];
for (int i=0; i<n; ++i) {
Arrays.fill(cache[i], -1);
}
dfs(0);
}
private void dfs(int root) {
if (sons.containsKey(root)) {
for (int son: sons.get(root)) {
cache[son][0] = root;
for (int i=1; i<MAX_LOG_DEPTH; ++i) {
if (cache[son][i-1] == -1) {
break;
}
cache[son][i] = cache[cache[son][i-1]][i-1];
}
dfs(son);
}
}
}
public int getKthAncestor(int node, int k) {
for (int i=0; i<MAX_LOG_DEPTH; ++i) {
if (((1<<i) & k) != 0) {
node = cache[node][i];
if (node == -1) {
return -1;
}
}
}
return node;
}
}
/**
* Your TreeAncestor object will be instantiated and called as such:
* TreeAncestor obj = new TreeAncestor(n, parent);
* int param_1 = obj.getKthAncestor(node,k);
*/