2026-08-15：删除元素后大固定点数目。用go语言日照橡塑胶，给定个整数数组 nums，你可以从中删除任意个元素（也可以不删）。删除后，剩下的元素会依次向左靠拢，下标从 0 开始重新编号。

如果某个位置上的元素值恰好等于它的新下标，这个位置就称为“固定点”。

请计：经过任意次删除操作后，多能得到多少个固定点。

1

0

输入： nums = [0,2,1]。

输出： 2。

解释：

删除 nums[1] = 2。数组变为 [0, 1]。

现在，nums[0] = 0 且 nums[1] = 1，因此两个下标都是固定点。

因此，答案为 2。

题目来自力扣3920。

大体步骤如下：

步：理解问题转化

题目要求我们删除任意个元素后，让剩下的元素在重新编号后，尽量多的位置满足“元素值 = 新下标”。

你的代码没有直接去模拟删除，而是做了个数学建模。

二步：构造候选点（固定点可能的位置）

代码中的 maxFixedPoints 函数先遍历原始数组 nums，对每个位置 i 和值 x：

• 如果 i >= x，说明如果保留这个元素，并且它终被移到了某个位置，有可能成为固定点。

• 它保存对值：[x, i - x]。

这里的含义是：

• 如果保留这个元素，并且它终成为固定点，那么它新下标须等于 x。

• 这个元素原本在位置 i，如果它被移动到了下标 x，那么它前面需要删除的元素个数为 i - x（因为向前移动）。

所以 [x, i - x] 就代表了“这个元素如果要成为固定点，需要的删除数量是 i - x，且它对应新下标 x”。

三步：排序（二维偏序处理）

将这些候选点存入二维数组 a，然后交给 maxEnvelopes 处理。

maxEnvelopes 使用了个经典技巧：

1. 按维 x 升序排列。

2. 如果维相同，按二维 i - x 降序排列（代码中用 b[1] - a[1]）。

这样排序的目的：

四步：长递增子序列（LIS）处理

排序后的数组，实际上我们关心二维 i - x 能否构成个严格递增的序列。

为什么？

• 如果两个固定点分别位于原下标 i1, i2，新下标 x1, x2，PVC管道管件粘结胶并且 x1

• 那么它们前面删除的元素个数分别是 i1 - x1 和 i2 - x2。

• 因为删除操作是全局的，若前个固定点保留，后面固定点要想同时保留，须保证后面的删除数大于前面的（因为越靠后的元素，要向前移动日照橡塑胶，需要的删除数也越多，并且这个删除数是递增的）。

所以我们需要找二维的长严格递增子序列（这里允许相邻相等，但排序时已经用降序避同 x 的冲突，所以实际上用 h+1 来允许相等）。

sort.SearchInts(g, h+1)：

• 用二分查找在 g 中找个 >= h+1 的位置。

• 相当于找个大于 h 的位置（允许相等情况下的处理）。

• 如果找到就替换，否则追加，这样 g 的长度就是长递增子序列的长度。

五步：得到答案

len(g) 就是多可以获得的固定点数量。

对于例子 nums = [0, 2, 1]：

• 原数组：

• i=0, x=0 => 0 >= 0 => [0, 0]

• i=1, x=2 => 1 >= 2? 否，跳过

• i=2, x=1 => 2 >= 1 => [1, 1]

• 候选：[[0,0], [1,1]]

• 排序后：[[0,0], [1,1]]

• LIS 长度 = 2，输出 2，正确。

时间复杂度

• 构造候选：O(n)

• 排序：O(n log n)

• LIS 二分：每个元素次二分查找，O(log n)，总共 O(n log n)

整体：O(n log n)

额外空间复杂度

• 候选数组 a 多 n 个元素：O(n)

• LIS 辅助数组 g：O(n)

整体：O(n)

Go完整代码如下：

.

package main

import (

"cmp"

"fmt"

"slices"

"sort"

)

func maxEnvelopes(envelopes [][2]int) int {

slices.SortFunc(envelopes, func(a日照橡塑胶, b [2]int) int {

return cmp.Or(a[0]-b[0], b[1]-a[1])

})

g := []int{}

for _, e := range envelopes {

h := e[1]

j := sort.SearchInts(g, h+1) // 允许 LIS 相邻元素相等

if j

g[j] = h

} else {

g = append(g, h)

}

}

return len(g)

}

func maxFixedPoints(nums []int) int {

a := [][2]int{}

for i, x := range nums {

if i >= x {

a = append(a, [2]int{x, i - x})

}

}

return maxEnvelopes(a)

}

func main {

nums := []int{0, 2, 1}

result := maxFixedPoints(nums)

fmt.Println(result)

}

Python完整代码如下：

.

# -*-coding:utf-8-*-

from typing import List

from bisect import bisect_left

def maxEnvelopes(envelopes: List[List[int]]) -> int:日照橡塑胶

# 按宽度升序，宽度相同时按度降序

envelopes.sort(key=lambda x: (x[0], -x[1]))

g = []

for _, h in envelopes:

# 允许 LIS 相邻元素相等（通过 h+1 来插入位置）

j = bisect_left(g, h + 1)

if j

g[j] = h

else:

g.append(h)

return len(g)

def maxFixedPoints(nums: List[int]) -> int:

a = []

for i, x in enumerate(nums):

if i >= x:

a.append([x, i - x])

return maxEnvelopes(a)

if __name__ == "__main__":

nums = [0, 2, 1]

result = maxFixedPoints(nums)

print(result)

C++完整代码如下：

.

#include

#include

#include

using namespace std;

int maxEnvelopes(vector>& envelopes) {

// 按宽度升序，宽度相同时按度降序

sort(envelopes.begin, envelopes.end,

[](const vector& a, const vector& b) {

if (a[0] != b[0]) return a[0]

return a[1] > b[1];

});

vector g;

for (const auto& e : envelopes) {

int h = e[1];

// 允许 LIS 相邻元素相等（通过 h+1 来插入位置）

auto it = lower_bound(g.begin, g.end, h + 1);

if (it != g.end) {

*it = h;

} else {

g.push_back(h);

}

}

return g.size;

}

int maxFixedPoints(vector& nums) {

vector> a;

for (int i = 0; i

if (i >= nums[i]) {

a.push_back({nums[i], i - nums[i]});

}

}

return maxEnvelopes(a);

}

int main {

vector nums = {0, 2, 1};

int result = maxFixedPoints(nums);

cout

return 0;

}

·

我们相信人工智能为普通人提供了种“增强工具”，并致力于分享全位的AI知识。在这里，您可以找到新的AI科普文章、工具评测、提升率的秘籍以及行业洞察。

欢迎关注“福大大架构师每日题”，发消息可获得面试资料，让AI助力您的未来发展。相关词条:铁皮保温施工     隔热条设备     锚索    离心玻璃棉    万能胶生产厂家

奥力斯    万能胶生产厂家    联系人：王经理    手机：13903175735（微信同号）    地址：河北省任丘市北辛庄乡南代河工业区

1.本网站以及本平台支持关于《新广告法》实施的“极限词“用语属“违词”的规定，并在网站的各个栏目、产品主图、详情页等描述中规避“违禁词”。
2.本店欢迎所有用户指出有“违禁词”“广告法”出现的地方，并积极配合修改。
3.凡用户访问本网页，均表示默认详情页的描述日照橡塑胶，不支持任何以极限化“违禁词”“广告法”为借口理由投诉违反《新广告法》，以此来变相勒索商家索要赔偿的违法恶意行为。