CodeForces 571B Minimization【dp】

最新推荐文章于 2025-12-13 19:26:52 发布
原创 最新推荐文章于 2025-12-13 19:26:52 发布 · 111 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构

文章描述了一种使用动态规划解决的问题，目标是找到在给定数组中，选择不同长度的子数组（长度为n/k和n/k+1），使得这些子数组元素之和的差值最小。通过状态转移方程f[i,j]=min(f[i-1,j]+a[cur]-a[cur-step],f[i,j-1]+a[cur]-a[cur+step])，计算出最小差值。时间复杂度为O(nk)。

发现  mod k\bmod kmodk 不同的两个下标之间互相独立。所以考虑 dp。

设 fi,jf_{i,j}fi,j​ 表示选择 iii 个长度为 ⌊nk⌋\lfloor\frac{n}{k}\rfloor⌊kn​⌋ 的组，jjj 个 ⌊nk⌋+1\lfloor \frac{n}{k}\rfloor +1⌊kn​⌋+1 的组，得到的最小值。

有 fi,j=min⁡(fi−1,j+a当前下标−a该组上一个下标,fi,j−1+a当前下标−a该组上一个下标)f_{i,j} = \min(f_{i-1,j}+a_{当前下标}-a_{该组上一个下标}, f_{i,j-1}+a_{当前下标}-a_{该组上一个下标})fi,j​=min(fi−1,j​+a当前下标​−a该组上一个下标​,fi,j−1​+a当前下标​−a该组上一个下标​)。

直接转移即可。时间复杂度为 O(nk)\mathcal O(nk)O(nk)。

#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int a[N];
int f[5010][5010];
signed main()
{
    memset(f, 0x3f, sizeof f);
    int n, k;
    cin >> n >> k;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    sort(a + 1, a + n + 1);
    f[0][0] = 0;
    int step = n / k;
    for (int i = 0; i <= n % k; i++)
        for (int j = 0; j <= (n - n % k) / step - n % k; j++)
        {
            int cur = i * (step + 1) + j * step;
            if (i)
                f[i][j] = min(f[i][j], f[i - 1][j] + a[cur] - a[cur - step]);
            if (j)
                f[i][j] = min(f[i][j], f[i][j - 1] + a[cur] - a[cur - step + 1]);
        }
    cout << f[n % k][(n - n % k) / step - n % k] << '\n';
    return 0;
}
codeforces 607B 区间dp
enamor_AC的博客
02-25 697
Zumatime limit per test2 seconds memory limit per test512 megabytes inputstandard input outputstandard output Genos recently installed the game Zuma on his phone. In Zuma there exists a line of n g
Codeforces Global Round 19 D题 Yet Another Minimization Problem（推式子，01背包变形）
weixin_74754298的博客
09-24 871
因此最后的结果为答案的一半）。是一个定值，我们只需要计算。
codeforces 571B Minimization(dp)
emmmmmm
09-02 2915
OBLEMS SUBMIT CODE MY SUBMISSIONS STATUS HACKS ROOM STANDINGS CUSTOM INVOCATION D. Minimization time limit per test 2 seconds memory limit per test 256 megabytes
Codeforces 571B Minimization (DP)
Winterfell30' Blog
06-17 527
题意有一个n个数的序列，给出一个k，可以通过对序列重排让∑n−ki=1|Ai−Ai+k|\sum_{i=1}^{n-k}|A_{i}-A_{i+k}|最小，求最小值。思路题目相当于分成k组，使得{0,k,2k…},{1,k+1,2k+1…}等这些序列分别的序列更小。 显然对于每一个链就是排序之后得到的绝对值的和最小，通过列项相消就能得到对于序列i他的结果就maxi−minimax_i-min_i
CodeForces 571B Minimization（dp）
阿狸的博客
12-02 256
题意：一个长度为n的序列和一个k，求一个排列使的最小。  显然我们需要对序列n从小到大排序，保证相邻两数差值最小，对于序列n我们可以分为长度为n/k和n/k+1的若干个序列且每个序列中每个数的位置相差k，对于每个序列我们的得到的|a[i]-a[i+k]|总和即为|a[n|-a[1]| 。那么我们要解决的便是这若干个序列的划分问题。 令dp[i][j]表示已经确定了i个系列，其中长度为n/k
CodeForces 571B Minimization
weixin_30528371的博客
02-25 129
题意：给你一串数，问你怎么构造，使得啊a[i]-a[i+k]的加和最大 思路：这个真的是数学太渣了，这个分块一直没想到，不过dp部分还是恨到理解的，当然后看的聚聚们的题解，构造的很巧%orz 代码： #include <bits/stdc++.h> using namespace std; typedef long long LL; LL a[300100],sum[3...
Codeforces 571B Minimization
szh_0808的博客
10-01 276
B. Minimization time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output You've got array A, consisting of n integer
Codeforces 571B Minimization：dp + 贪心【前后相消】
a1392136的博客
01-06 160
题目链接：http://codeforces.com/problemset/problem/571/B 题意： 　　给你一个长度为n的数列a[i]。 　　现在你可以随意改变数字的位置，问你 ∑| a[i] - a[i+k] | 的最小值(1 <= i <= n-k)。 题解： 　　将a[i]拆成若干个子序列s[j]，子序列中相邻两数在a[i]中的距离为k。 ...
codeforces 571B - Minimization (dp)
Glory 的 博客
10-11 519
题意很好理解 题解 ： 首先我们观察到几个事实就是说 ： 1. 这 n 个数可以分成 k 段 并且这 k 段互不影响 2. 每个段内的数都是连续的数，因为只有这样，才能保证这个问题的最小性 3. 如果这 n 个数排序后每连续的两个作差取绝对值再求和答案是固定的也就是 max (a[i]) - min (a[i]) 。 4. 如果第三个是确定的并且可以保证每个段内的数都是连续的数，那我们所关
【Codeforces 571B】Minimization | 思维dp
一只酷酷光儿的博客
06-28 565
题目链接：https://codeforces.ml/contest/571/problem/B 题目大意： 给一段序列a_i，你可以对其重排，要求重排之后的: 最大 题目思路： 首先裂项相消： a[i+k]-a[i] a[i+2*k] - a[i+k] sum = a[i+x*k]-a[i] 性质1:也就是这个每个数相距为k的子序列的权值实际即为a[i+x*k]-a[i] 性质2： 可以发现有长度为n%k个 n/k+1的子序列 有k-n%k个 n/k的子序列 因为要求重排，所以直
codeforces 571B B. Minimization
Rising_shit的博客
01-06 767
codeforces 571B B. Minimization
CodeForces – 1312E Array Shrinking(区间dp)
01-03
题目分析：最优性问题，且是对区间操作的，而且数据范围满足 n^3 的时间复杂度，综上可以考虑区间dp，因为题目已经明确了需要求什么，所以我们不妨设 dp[ i ][ j ] 为区间 [ i , j ] 合并后的最短数列的长度，因为...
CodeForces Number of Subsequences（计数DP）
不爱吃鱼的猫丶的博客
01-25 307
题意： 给出一段由 ‘a’,‘b’,‘c’,’?’ 组成的序列，每个’?‘都可以变成’a’,‘b’,'c’其中一个，假设有k个问号，那么最终可能序列就有3k3^k3k种，问所有可能的序列中，一共出现了多少次abc，结果对1e9+7取模。 思路： 状态表示： dp[i][0]：到i之前所有可能的序列种’a’一共出现的次数 dp[i][1]：到i之前所有可能的序列种’ab’一共出现的次数 dp[i][2]：到i之前所有可能的序列种’abc’一共出现的次数 如果不考虑问号，就是一个经典的计数dp。 考虑问号之后.
Louvain 算法
FionaDong的博客
12-12 118
Louvain 是一种经典的图社区发现算法（Community Detection），由 Blondel 等人在 2008 年提出。核心目标：通过最大化 Modularity（模块度）来自动划分图中的社区（cluster）。它最大的特点是：✔ 速度非常快✔ 能处理百万级节点的大图✔ 结果相对稳定。
shardingsphere-jdbc分表实现案例和算法比对
Sunchaser的博客
12-08 873
本文档基于shardingsphere-jdbc-core-spring-boot-starter 5.2.1版本验证分表能力，同时基于实际的业务场景对比几类分表策略和实现方案 分库和分表是两个截然不同的功能，分表只要我们在Springboot中引入shardingsphere-jdbc这个依赖库即可，但是分库就要单独部署一个服务shardingsphere-proxy，其他服务连接shardingsphere-proxy，从而实现分库的功能
从零开始写算法——链表篇：相交链表 + 反转链表
m0_59624833的博客
12-09 566
leetcode hot100中链表的两个题
从0开始学算法——第十五天（滑动窗口）
最新发布
2401_84407045的博客
12-13 998
本文旨在通过实践展示滑动窗口技术的应用，特别是在处理数组或字符串时的高效查找和统计操作。主要包括在给定的数组或字符串中找到满足特定条件的连续子数组或子字符串，旨在提高算法的时间效率和理解窗口滑动的原理与实现。
二次规划（QP）算法
weixin_43156294的博客
12-10 551
二次规划的本质，是在一组线性约束条件下，求解一个二次函数的极值问题。其核心特征在于目标函数的二次性与约束条件的线性性，这种结构既保留了线性规划的求解高效性，又能处理更复杂的优化场景——例如实际系统中普遍存在的“最小能量”“最小方差”等目标，这类目标往往天然呈现二次形式。1.标准数学模型QP问题的标准形式通常分为“凸二次规划”与“非凸二次规划”两类，其中凸QP因具有全局最优解且求解难度可控，应用最为广泛。
【每天学习一点算法 2025/12/10】反转链表
Colorful9的博客
12-10 864
本文介绍了反转链表的三种实现方法：1）使用栈结构存储节点后弹栈重建；2）迭代法通过遍历直接修改节点指向；3）递归法在回归过程中逐步反转节点。重点解析了递归实现的原理，通过递推找到尾节点后，在回归过程中逐个反转节点指向并断开原链接。三种方法各有特点，栈实现直观但需额外空间，迭代法高效，递归法则展示了递归的独特处理方式。
codeforces 519B
11-26
<think> 题目链接：https://codeforces.com/problemset/problem/519/B 题目大意：给出n个数字，然后给出n-1个数字（第一组），再给出n-2个数字（第二组）。第一组是原数组去掉一个元素，第二组是第一组再去掉一个元素。求被去掉的两个元素（按顺序，即第一个被去掉的是第一个答案，第二个被去掉的是第二个答案）。 方法1：使用求和法 原数组的和为s0，第一组数组的和为s1，则第一个被去掉的数为 s0 - s1。 第二组数组的和为s2，则第二个被去掉的数为 s1 - s2。 方法2：使用排序或哈希表（统计频率） 原数组为a，第一组数组为b，第二组数组为c。 第一个被去掉的元素：在a中出现但不在b中出现的元素，或者在a中比b中多出现一次的元素。 第二个被去掉的元素：在b中出现但不在c中出现的元素，或者在b中比c中多出现一次的元素。 考虑到可能有重复元素，所以使用统计频率的方法更可靠。 具体步骤： 1. 读入原数组a（长度为n），第一组数组b（长度为n-1），第二组数组c（长度为n-2）。 2. 分别统计a、b、c中每个元素的出现频率。 3. 第一个答案：遍历a的元素，找到在a中出现的次数比在b中多一次的元素（或者遍历b的元素，但注意a中可能有b没有的元素，所以遍历a更安全）。 具体：对于a中的每个元素x，如果a中x的频率比b中x的频率大1，则x就是第一个被去掉的。 但注意：因为b中可能没有x，所以当b中不存在x时，b中x的频率为0，此时a中x的频率应该是1（比0大1），所以成立。 4. 第二个答案：同理，遍历b的元素，找到在b中出现的次数比在c中多一次的元素。 但是需要注意：同一个元素可能在数组中出现多次，所以不能只用一个标记，必须统计频率。 另一种方法：由于题目保证答案唯一，我们可以用以下方法： 第一个答案 = 在数组a中出现但在数组b中少出现一次的元素（即a中比b中多一个的元素）。 第二个答案 = 在数组b中出现但在数组c中少出现一次的元素。 实现： 使用map来统计每个数组的元素频率。 但是注意：在统计第二个答案时，我们要在b中找比c中多一次的元素，而b中已经包含第一个答案，所以第一个答案在b中可能比a中少一次，但我们并不关心，因为第二个答案与第一个答案不同。 步骤： 1. 读入n，然后读入三个数组。 2. 分别用三个map统计a, b, c中每个元素的频率。 3. 遍历a中的每个元素，对于每个元素x，如果freq_a[x] != freq_b[x]（实际上应该大1），则第一个答案就是x，并跳出（但注意可能有多个？题目保证唯一，所以找到一个即可？但是因为同一个元素出现多次，我们只需找到一个元素在a中频率比b中多1即可，但这样的元素只有一个，因为只去掉一个元素，所以整个数组a中只有一个元素会多一次。但实际上，如果有重复元素，那么可能有多个元素在a中的频率比b中多1？但是仔细分析：只去掉一个元素，所以整个数组a和b之间，只有被去掉的那个元素在a中的频率比b中多1，其他元素都相同。所以我们可以遍历a，找到第一个满足freq_a[x] > freq_b[x]的元素，然后输出并跳出？但是有可能这个元素在b中不存在，所以用freq_b[x]可能为0。 具体：我们可以这样： for (auto x: a) { if (freq_a[x] - freq_b[x] == 1) { first = x; break; } } 但是注意：在遍历时，同一个x可能出现多次，所以不能一找到就break，因为可能后面还有？不对，因为同一个x，我们通过频率比较，如果这个x在a中出现了k次，那么在b中出现了k-1次，那么当我们遍历到x时，就会满足条件。但是这样会多次检测到同一个x，所以我们可以记录下这个x，然后跳出循环？但是这样会重复记录同一个x多次。因此，我们可以遍历map，而不是遍历数组a。 改进：遍历频率映射： for (auto it : freq_a) { int x = it.first; if (it.second - freq_b[x] == 1) { first = x; break; } } 但是这里要注意：freq_b中可能没有x，所以我们需要检查x是否在freq_b中？或者我们初始化freq_b时，对于a中所有元素都初始化了？没有。所以我们可以这样：使用map的find方法，或者直接访问freq_b[x]，如果x不在freq_b中，则返回0（因为我们使用map，默认值0）。 同样，第二个答案：遍历freq_b，找freq_b[x] - freq_c[x] == 1的元素。 但是注意：第一个答案也可能在b中出现（在c中不出现）吗？第二个答案只与b和c有关，所以这样找没有问题。 但是：第一个答案被去掉后，在b中就不存在了？不对，b是去掉第一个答案后的数组，所以第一个答案在b中出现的次数应该比a中少1（如果a中出现了多次，那么b中只少一次）。所以我们的方法正确。 但是：如果a中有重复元素，比如a=[2,2,3]，b=[2,3]，那么第一个被去掉的是2。那么freq_a[2]=2，freq_b[2]=1，所以2满足条件。而其他元素（3）在a和b中频率相等。 所以我们可以使用频率差的方法。 步骤： 1. 读入n，然后读入数组a（n个数），数组b（n-1个数），数组c（n-2个数）。 2. 定义三个map：freq_a, freq_b, freq_c。 3. 统计a中每个元素的频率，b中每个元素的频率，c中每个元素的频率。 4. 遍历freq_a，找到第一个满足 freq_a[x] - (freq_b.count(x)?freq_b[x]:0) == 1 的x，作为第一个答案。 5. 遍历freq_b，找到第一个满足 freq_b[x] - (freq_c.count(x)?freq_c[x]:0) == 1 的x，作为第二个答案。 但是注意：第一个答案可能有多个元素满足条件吗？题目保证唯一，所以只有一个元素会被去掉，所以只有一个元素满足这个条件。因此，我们找到第一个满足条件的x即可（但map遍历是随机的，所以最好直接遍历，然后输出找到的第一个，因为只有一个）。 但是，我们也可以不用map遍历，而是遍历数组a（但数组a有重复，所以可能重复找到同一个元素多次）。所以还是遍历map比较好。 但是注意：题目要求按顺序输出：先输出的第一个被去掉的，再输出第二个被去掉的。 所以，我们也可以这样： 第一个答案：遍历a，直到找到一个元素x，使得freq_a[x] > freq_b[x]（并且我们每找到一个，就在freq_b[x]上加1？这样不行）。所以还是用map统计后直接查找。 代码实现： 注意：由于n最大10^5，所以用map统计不会超时（O(n log n)）。 另外：也可以使用unordered_map（平均O(n)）。 代码： 方法1：使用map（或unordered_map）统计频率。 但是：题目要求按顺序输出两个答案，所以先输出第一个被去掉的，再输出第二个。 步骤： 1. 读入数组a，b，c。 2. 统计频率： map<int, int> fa, fb, fc; for (int i=0; i<n; i++) fa[a[i]]++; for (int i=0; i<n-1; i++) fb[b[i]]++; for (int i=0; i<n-2; i++) fc[c[i]]++; 3. 然后： int first = 0, second = 0; for (auto it : fa) { int num = it.first; if (it.second != fb[num]) { // 因为只少一个，所以一定是fa[num] == fb[num] + 1 first = num; break; // 因为只有一个，所以找到就可以退出 } } for (auto it : fb) { int num = it.first; if (it.second != fc[num]) { second = num; break; } } 4. 输出 first 和 second。 但是，注意：在第一个循环中，我们遍历fa，然后比较fa[num]和fb[num]（如果num不在fb中，fb[num]默认0）。但是当fa[num]不等于fb[num]时，我们直接取num作为第一个答案并跳出。因为只少一个元素，所以这样的元素只有一个。 但是：在第二个循环中，同样遍历fb，然后比较fb[num]和fc[num]（如果num不在fc中，则fc[num]为0）。 但是：有没有可能第一个循环中，有多个元素满足fa[num]!=fb[num]？题目保证答案唯一，所以只有一个元素被去掉，所以只有一个元素满足fa[num]!=fb[num]（即fa[num]比fb[num]大1，而其他都相等）。 但是，我们这样写可能会遇到问题：如果一个元素在a中不存在，但在fa中不会出现（因为我们遍历fa，所以不会出现这种情况）。所以正确。 但是：如果第一个答案在a中只出现一次，那么fb中这个元素就不存在（即fb[num]为0），此时fa[num]=1，fb[num]=0，满足不等。 所以，这个方法正确。 但是，有一个小问题：遍历map时，我们不知道顺序，但题目不要求顺序，只要输出那个被去掉的元素即可（因为答案唯一），所以任意顺序遍历map都可以。 但是，我们也可以不用map，而用数组求和法（更简单，且O(n)）： long long s1 = 0, s2 = 0, s3 = 0; for (int i=0; i<n; i++) s1 += a[i]; for (int i=0; i<n-1; i++) s2 += b[i]; for (int i=0; i<n-2; i++) s3 += c[i]; int first = s1 - s2; int second = s2 - s3; 求和法更简单，且效率高（O(n)），但要注意数据范围：n最大10^5，元素最大10^9，那么s1最大10^14，所以用long long不会溢出（long long最大9e18）。 所以，推荐使用求和法。 但是，求和法有一个问题：如果数组中有重复元素，并且被去掉的元素是重复的，会不会影响？不会，因为求和法就是计算总和，去掉一个元素，那么两个数组的差就是这个元素。 所以，求和法完全正确。 因此，我们可以写两种方法，但这里推荐求和法（更简单高效）。 代码（求和法）： #include <iostream> using namespace std; int main() { int n; cin >> n; long long a_sum = 0, b_sum = 0, c_sum = 0; int x; for (int i = 0; i < n; i++) { cin >> x; a_sum += x; } for (int i = 0; i < n-1; i++) { cin >> x; b_sum += x; } for (int i = 0; i < n-2; i++) { cin >> x; c_sum += x; } long long first = a_sum - b_sum; long long second = b_sum - c_sum; cout << first << endl; cout << second << endl; return 0; } 但是，题目要求输出两个答案，第一个答案和第二个答案。 但是，有没有可能多个不同的元素被去掉，但是和相同？题目没有说元素互不相同，所以有可能出现两个不同的元素和相同吗？题目要求去掉两个元素（但这两个元素可能相同），但是注意：在第一个数组中，去掉一个元素后得到第二个数组，再去掉一个元素得到第三个数组。所以两个被去掉的元素可能是相同的。 但是，用求和法：第一个答案 = a_sum - b_sum，第二个答案 = b_sum - c_sum。 如果两个被去掉的元素相同，比如a_sum - b_sum = X，b_sum - c_sum = X，那么输出两个X。 所以，求和法完全正确。 但是，题目中是否有说明元素互不相同？没有，所以可能重复。 因此，我们使用求和法。 但是，注意：题目要求输入输出格式，以及多个测试用例？看题目描述：输入第一行是n，然后第二行是n个整数（原数组），第三行是n-1个整数（第一组），第四行是n-2个整数（第二组）。 所以，我们只需要读入一次。 但是，题目中可能有多个测试用例？不，题目描述：The first line contains integer n (3≤n≤10^5) — the initial length of the array. 所以只有一个测试用例。 但是，我们再看题目：Input中第一行是n，所以代码按单组输入。 所以，最终代码： 注意：使用long long，因为元素最大10^9，n最大10^5，总和最大10^14。 代码： </think> 对于 Codeforces 519B 问题，我将提供两种优化解法：**求和法**（推荐）和**频率统计法**。原始问题需要找出两次删除操作中被移除的元素。 ### 解法一：求和法（O(n) 时间复杂度） 这是最优解法，利用数组和的差值直接计算被移除的元素： ```cpp #include <iostream> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; long long a_sum = 0, b_sum = 0, c_sum = 0; int x; // 读取原始数组并求和 for (int i = 0; i < n; i++) { cin >> x; a_sum += x; } // 读取第一次删除后的数组并求和 for (int i = 0; i < n - 1; i++) { cin >> x; b_sum += x; } // 读取第二次删除后的数组并求和 for (int i = 0; i < n - 2; i++) { cin >> x; c_sum += x; } // 计算被移除的元素 long long first_removed = a_sum - b_sum; long long second_removed = b_sum - c_sum; cout << first_removed << "\n"; cout << second_removed << "\n"; return 0; } ``` #### 代码解释： 1. **输入处理**： - 读取数组大小 `n` - 使用 `long long` 防止总和溢出（元素值 ≤10⁹，n≤10⁵，总和最大 10¹⁴） 2. **求和计算**： - `a_sum`：原始数组总和 - `b_sum`：第一次删除后数组（n-1 个元素）总和 - `c_sum`：第二次删除后数组（n-2 个元素）总和 3. **差值计算**： - `first_removed = a_sum - b_sum`：第一个被删除的元素 - `second_removed = b_sum - c_sum`：第二个被删除的元素 4. **时间复杂度**：O(n)，仅需三次线性遍历 ### 解法二：频率统计法（O(n log n) 时间复杂度） 使用哈希表统计元素频率，适合元素值范围大的情况： ```cpp #include <iostream> #include <vector> #include <unordered_map> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; vector<int> a(n), b(n-1), c(n-2); unordered_map<int, int> freq_a, freq_b, freq_c; // 读取并统计原始数组频率 for (int i = 0; i < n; i++) { cin >> a[i]; freq_a[a[i]]++; } // 读取并统计第一次删除后数组频率 for (int i = 0; i < n - 1; i++) { cin >> b[i]; freq_b[b[i]]++; } // 读取并统计第二次删除后数组频率 for (int i = 0; i < n - 2; i++) { cin >> c[i]; freq_c[c[i]]++; } // 查找第一个被删除的元素 int first_removed = 0; for (int num : a) { if (freq_a[num] != freq_b[num]) { first_removed = num; break; } } // 查找第二个被删除的元素 int second_removed = 0; for (int num : b) { if (freq_b[num] != freq_c[num]) { second_removed = num; break; } } cout << first_removed << "\n"; cout << second_removed << "\n"; return 0; } ``` #### 代码解释： 1. **数据结构**： - 使用 `unordered_map` 存储元素频率（平均 O(1) 操作） - `vector` 存储输入数组 2. **频率统计**： - `freq_a`：原始数组频率 - `freq_b`：第一次删除后频率 - `freq_c`：第二次删除后频率 3. **查找被删元素**： - 第一个元素：在 `a` 中频率比 `b` 大 1 的元素 - 第二个元素：在 `b` 中频率比 `c` 大 1 的元素 4. **时间复杂度**：O(n log n)（哈希表操作均摊 O(1)） ### 两种解法对比 | 特性 | 求和法 | 频率统计法 | |--------------|---------------------------|--------------------------| | 时间复杂度 | O(n) | O(n)（均摊） | | 空间复杂度 | O(1) | O(n) | | 适用场景 | 推荐通用解法 | 元素范围极大时更稳定 | | 优势 | 代码简洁，内存占用少 | 不依赖数值计算 | | 注意事项 | 总和可能溢出（用long long）| 哈希冲突可能影响性能 | ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值