克孜勒苏柯尔克孜铝皮保温施工队 2026-08-07: 移除子数组元素后 K 小偶数。用go话语, 给定个严
2026-08-09 00:53:20
2026-08-07：移除子数组元素后 K 小偶数。用go话语，给定个严格递加的整数数组 nums，以及组查询克孜勒苏柯尔克孜铝皮保温施工队，每个查询包含三个整数 l、r 和 k。
关于每个查询，咱们只看 nums 中下标从 l 到 r 的这段邻接子数组。
接着，探讨通盘正偶数组成的限序列：2, 4, 6, 8, 10, …
从这个序列中，剔除去那些恰巧等于上述子数组里出现的数值的元素。
剔除之后，序列仍然保合手从小到大罗列，咱们需要找出这个新序列中的 k 个小的整数。
后，将每个查询对应的 k 个小整数按礼貌放入后果数组中复返。
厚爱：nums 本人是严格递加的，是以落拓子数组中的元素亦然严格递加且互不相通的。
1
1
nums 是严格递加的。
1
queries[i] = [li, ri, ki]。
0
1
输入： nums = [1,4,7], queries = [[0,2,1],[1,1,2],[0,0,3]]。
输出： [2,6,6]。
解释：
i
queries[i]
nums[li..ri]
移除的偶数
剩余的偶数
ki
ans[i]
0
[0, 2, 1]
[1, 4, 7]
[4]
2, 6, 8, ...
1
2
1
[1, 1, 2]
[4]
[4]
2, 6, 8, ...
2
6
2
[0, 0, 3]
[1]
[]
2, 4, 6, ...
3
6
因此，ans = [2, 6, 6]。
题目来独力扣3911。
算法总体想路
本题要求对每个查询，在全局正偶数序列（2, 4, 6, …）中删除指定子数组里出现的偶数后，找出 k 个剩下的偶数。
由于 nums 本人严格递加，子数组中的偶数亦然严格递加且互不重叠，因此咱们不错欺诈“删除偶数在原偶数序列中的序号”来快速定位。
中枢想想：
将每个偶数 v 映射为其在偶数序列中的序号 v / 2（从 1 运行）。
关于某个查询，子数组中通盘偶数对应的序号组成个严格递加的连结 S（记为被删除的序号）。
咱们要求在删除 S 后，剩下的序号中 k 个小的序号 t，然后谜底即是 2 * t。
预管制
1. 遍历通盘 nums，找出通盘值为偶数的元素，并记载它们的原始下标，存入数组 evenPos。
• 因为 nums 严格递加克孜勒苏柯尔克孜铝皮保温施工队，是以 evenPos 中的下标亦然严格递加的。
• 这步耗时 O(n)，n 为 nums 长度。
每个查询的管制按序
关于每个查询 [l, r, k]，咱们按如下经过设想谜底：
1. 定位子数组内通盘偶数下标
• 在 evenPos 中，使用二分查找找到个 ≥ l 的位置 left。
• 再找到个 ≥ r+1 的位置 right（由于 r 是闭区间，r+1 当作开区间右畛域）。
• 则 evenPos[left : right] 即是通盘落在 [l, r] 区间内的偶数下标，记为数组 pos，其长度为 m。
• 若 m = 0，阐发子数组中莫得偶数，删除连结为空，那么 k 个剩余偶数即是通盘偶数序列的 k 个，即 2 * k。
2. 将子数组偶数映射为序号并相识删除影响
• 关于 pos 中的 j 个元素（0 ≤ j
• 在探讨这个偶数之前，全局序号小于它的偶数共有 nums[pos[j]] / 2 - 1 个。
• 由于 pos[0..j-1] 皆是比它小的被删除偶数（共 j 个），是以在通盘小于该偶数的偶数中，被删除的个数恰巧是 j。
• 因此，在该偶数之前（不包括它本人）剩余的偶数个数为：
剩余个数 = (nums[pos[j]] / 2 - 1) - j。
3. 二分查找 k个剩余偶质问在哪个区间
• 咱们需要在通盘被删除偶数（共 m 个）中找到“分界点”。
• 界说函数 f(j)（其中 0 ≤ j ≤ m）：
• 当 j = m 时，默示通盘被删除偶数皆已探讨已毕，此时不错以为 f(m) = true（即 k 个剩余偶数定在通盘被删除偶数之后）。
• 由于 nums 严格递加且偶数至少增多 2，可阐发 f(j) 的值跟着 j 增大从 false 单调变为 true。因此不错在 [0, m] 上进行二分查找，找到小的 j 使得 f(j) 建树。
4. 左证分界点设想谜底
• 找到的 j 默示：在前 j 个被删除偶数之前，依然有至少 k 个剩余偶数；但在前 j-1 个之前不够。
• 因此， k 个剩余偶数定位于 j-1 个被删除偶数之后、 j 个被删除偶数之前（若 j=0，则在个被删除偶数之前；若 j=m，则在通盘被删除偶数之后）。
• 此时，在通盘小于该谜底的偶数中，恰好有 j 个被删除（即 pos[0..j-1]），铁皮保温是以该谜底在原始偶数序列中的序号为 j + k。
• 终谜底为 (j + k) * 2。
为什么二分条目正确
• 如若 f(j) 为真，阐发在 j 个被删除偶数之前，剩余的偶数个数依然不少于 k，那么 k 个剩余偶数不成能在 j 个被删除偶数之后，谜底的序号小于等于 nums[pos[j]] / 2（但不会等于它，因为该值已被删除），因此咱们不错把搜索领域向左邋遢。
• 如若 f(j) 为假，则阐发前边剩余个数不及 k，谜底势必在 j 个被删除偶数之后，搜索领域向右迁徙。
• 二分查找终笃定分界点，使设想准确。
本领复杂度
• 预管制：遍历次 nums，O(n)，n 为 nums 长度。
• 每个查询需要三次二分查找：
1. 在 evenPos 中找 left，O(log n)；
2. 找 right，O(log n)；
3. 在 pos 上二分，O(log m) ≤ O(log n)。
• 总查询数为 q，是以总本领复杂度为 O(n + q log n)。
罕见空间复杂度
• 存储 evenPos 数组，多 O(n)。
• 存储谜底数组，O(q)。
• 其他临时变量 O(1)。
• 因此总和外空间复杂度为 O(n + q)。
终回话示例
关于题中示例 nums = [1,4,7]，queries = [[0,2,1],[1,1,2],[0,0,3]]，经过可归纳为：
• 预管制的 evenPos = [1]（只消下标 1 的 4 是偶数）。
• 查询 0：子数组 [1,4,7]，pos = [1]，m=1，二分得到 j=0（因为 4/2-1-0 = 1 ≥ 1），谜底 (0+1)*2=2。
• 查询 1：子数组 [4]，雷同 pos=[1]，k=2，f(0)=1-0=1
• 查询 2：子数组 [1]，偶数，pos=[]，m=0，二分复返 j=0，谜底 (0+3)*2=6。
后果 [2,6,6]，与预期致。
Go竣工代码如下：
.
package main
import (
"fmt"
"sort"
)
func kthRemainingInteger(nums []int, queries [][]int) []int {
// 记载通盘偶数的下标
evenPos := []int{}克孜勒苏柯尔克孜铝皮保温施工队
for i, x := range nums {
if x2 == 0 {
evenPos = append(evenPos, i)
}
}
ans := make([]int, len(queries))
for i, q := range queries {
// 找到商讨对应的 evenPos 的子数组
l := sort.SearchInts(evenPos, q[0])
r := sort.SearchInts(evenPos, q[1]+1)
pos := evenPos[l:r]
k := q[2]
// 经过见 1539 题解
j := sort.Search(len(pos), func(j int) bool {
return nums[pos[j]]/2-1-j >= k
})
ans[i] = (j + k) * 2
}
return ans
}
func main {
nums := []int{1, 4, 7}
queries := [][]int{{0, 2, 1}, {1, 1, 2}, {0, 0, 3}}
result := kthRemainingInteger(nums, queries)
fmt.Println(result)
}
Python竣工代码如下：
.
# -*-coding:utf-8-*-
import bisect
def kthRemainingInteger(nums, queries):
# 相聚 nums 中通盘偶数元素的下标（因为 nums 严格递加，下标亦然递加的）
even_pos = [i for i, x in enumerate(nums) if x 2 == 0]
ans = []
for l, r, k in queries:
# 在 even_pos 中定位落在 [l, r] 区间内的下标领域
left = bisect.bisect_left(even_pos, l)
right = bisect.bisect_right(even_pos, r)
pos = even_pos[left:right] # 这些下标对应的 nums 值皆是偶数，且在子数组内
# 二分查找小的 j，使得 nums[pos[j]]//2 - 1 - j >= k
lo, hi = 0, len(pos)
while lo
mid = (lo + hi) // 2
# 刻下偶数在原始偶数序列中的序号（从0运行）减去前边已移除的偶数个数
if nums[pos[mid]] // 2 - 1 - mid >= k:
hi = mid
else:
lo = mid + 1
j = lo
ans.append((j + k) * 2)
return ans
def main:
nums = [1, 4, 7]
queries = [[0, 2, 1], [1, 1, 2], [0, 0, 3]]
result = kthRemainingInteger(nums, queries)
print(result)
if __name__ == "__main__":
main
C++竣工代码如下：
.
#include
#include
#include
using namespace std;
vector kthRemainingInteger(vector& nums, vector>& queries) {
vector evenPos;
// 相聚 nums 中通盘偶数元素的下标
for (int i = 0; i
if (nums[i] 2 == 0) {
evenPos.push_back(i);
}
}
vector ans;
ans.reserve(queries.size);
for (auto& q : queries) {
int l = q[0], r = q[1], k = q[2];
// 在 evenPos 中定位属于 [l, r] 的下标领域
int leftIdx = lower_bound(evenPos.begin, evenPos.end, l) - evenPos.begin;
int rightIdx = lower_bound(evenPos.begin, evenPos.end, r + 1) - evenPos.begin;
int m = rightIdx - leftIdx; // 该区间内偶数的个数
// 二分查找小的 j，使得 nums[evenPos[leftIdx + j]] / 2 - 1 - j >= k
int lo = 0, hi = m;
while (lo
int mid = (lo + hi) / 2;
int idx = evenPos[leftIdx + mid];
if (nums[idx] / 2 - 1 - mid >= k) {
hi = mid;
} else {
lo = mid + 1;
}
}
int j = lo;
ans.push_back((j + k) * 2);
}
return ans;
}
int main {
vector nums = {1, 4, 7};
vector> queries = {{0, 2, 1}, {1, 1, 2}, {0, 0, 3}};
vector result = kthRemainingInteger(nums, queries);
for (int x : result) {
cout
}
cout
return 0;
}
·
咱们敬佩东谈主工智能为宽泛东谈主提供了种“增强器具”，并骁敢于共享全位的AI常识。在这里，您不错找到新的AI科普著作、器具评测、进步率的秘密以及行业细察。
宽待诊疗“福大大架构师逐日题”，发音问可赢得口试尊府，让AI助力您的异日发展。手机：18632699551（微信同号）相关词条:罐体保温施工 异型材设备 锚索 玻璃棉 保温护角专用胶
1.本网站以及本平台支持关于《新广告法》实施的“极限词“用语属“违词”的规定，并在网站的各个栏目、产品主图、详情页等描述中规避“违禁词”。
2.本店欢迎所有用户指出有“违禁词”“广告法”出现的地方，并积极配合修改。
3.凡用户访问本网页，均表示默认详情页的描述，不支持任何以极限化“违禁词”“广告法”为借口理由投诉违反《新广告法》克孜勒苏柯尔克孜铝皮保温施工队，以此来变相勒索商家索要赔偿的违法恶意行为。