力扣第470场周赛

原创 2025-10-07 19:16:10 1.7k 阅读 AI写同款

收录于

力扣

一只鱼^_

码龄3年墨衍会员 · AI 创作全网分发

1073粉丝92篇原创

关注

告别有线：用PVE直通无线网卡，打造一台真正的‘无线’Win10软路由/测试机本文详细介绍了如何通过PVE直通无线网卡技术，构建全无线Win10软路由或测试机。从硬件选型、PVE环境配置到PCIe和USB双模直通技术，逐步指导实现Wi-Fi AP和蓝牙连接功能，为家庭实验室和小型办公环境提供灵活高效的网络解决方案。阅读详情

AI摘要

本文详细分析LeetCode第470场周赛四道题目，涵盖交替和计算、异或非零最长子序列、移除k-平衡子串及无零数对统计。重点涉及模拟、位运算、栈应用与数位DP等核心算法思想，适合提升编程竞赛解题能力。

题目链接如下：

https://leetcode.cn/contest/weekly-contest-470/

Q1. 计算交替和

给你一个整数数组 nums。

交替和定义为：将 nums 中偶数下标位置的元素相加，减去奇数下标位置的元素。即：nums[0] - nums[1] + nums[2] - nums[3]...

返回表示 nums 的交替和的整数。

示例 1：

输入： nums = [1,3,5,7]

输出： -4

解释：

偶数下标位置的元素是 nums[0] = 1 和 nums[2] = 5，因为 0 和 2 是偶数。
奇数下标位置的元素是 nums[1] = 3 和 nums[3] = 7，因为 1 和 3 是奇数。
交替和为 nums[0] - nums[1] + nums[2] - nums[3] = 1 - 3 + 5 - 7 = -4。
示例 2：

输入： nums = [100]

输出： 100

解释：

唯一的偶数下标位置的元素是 nums[0] = 100，因为 0 是偶数。
没有奇数下标位置的元素。
交替和为 nums[0] = 100。

提示：

1 <= nums.length <= 100
1 <= nums[i] <= 100

解题思路：按题意进行模拟

class Solution {
public:
    int alternatingSum(vector<int>& nums) {
        int tot=0;
        for(int i=0;i<nums.size();i++){
            if(i&1) tot-=nums[i];
            else tot+=nums[i];
        }
        return tot;
    }
};

Q2. 按位异或非零的最长子序列

给你一个整数数组 nums。
返回 nums 中按位异或（XOR）计算结果非零的最长子序列的长度。如果不存在这样的子序列，返回 0 。

子序列是一个非空数组，可以通过从原数组中删除一些或不删除任何元素（不改变剩余元素的顺序）派生而来。

示例 1：

输入： nums = [1,2,3]

输出： 2

解释：

最长子序列之一是 [2, 3]。按位异或计算为 2 XOR 3 = 1，它是非零的。

示例 2：

输入： nums = [2,3,4]

输出： 3

解释：

最长子序列是 [2, 3, 4]。按位异或计算为 2 XOR 3 XOR 4 = 5，它是非零的。

提示：

1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9

解题思路：

如果所有元素异或起来为 0，那么任何去掉一个元素的子序列，异或就变成非 0，答案为n-1

如果所有元素异或起来非0，那答案就为n

class Solution {
public:
    int longestSubsequence(vector<int>& nums) {
        int res=0,max_len=0,n=nums.size(); long long tot=0;
        for(int x: nums){
            res^=x;
            tot+=x;
        }
        if(res!=0) return n;
        if(n==1||tot==0) return 0;
        return n-1;
    }
};
// dp[i][j]; 以nums[i]结尾的异或值为j的非零子序列的长度

Q3. 移除K-平衡子字符串

给你一个只包含 '(' 和 ')' 的字符串 s，以及一个整数 k。
如果一个字符串恰好是 k 个连续的 '(' 后面跟着 k 个连续的 ')'，即 '(' * k + ')' * k ，那么称它是 k-平衡的。

例如，如果 k = 3，k-平衡字符串是 "((()))"。

你必须重复地从 s 中移除所有不重叠的 k-平衡子串，然后将剩余部分连接起来。持续这个过程直到不存在 k-平衡子串为止。

返回所有可能的移除操作后的最终字符串。

子串是字符串中连续的非空字符序列。

解题思路：这种括号很容易想到用栈解决, 当k=1时, 遍历到右括号，如果栈顶元素是左括号匹配成功就弹出栈顶元素，否则就入栈, 当k>1 时, 可以用pair来捆绑相同的字符，来统计相同字符的出现次数

class Solution {
public:
    string removeSubstring(string s, int k) {
        vector<pair<char,int>> st;
        for(auto& x: s){
            if(!st.empty() && st.back().first==x) st.back().second+=1;
            else st.emplace_back(x,1);

            if(x==')' && st.size()>1 && st.back().second==k && st[st.size()-2].second>=k){
                st.pop_back();
                st.back().second-=k;
                if(st.back().second==0) st.pop_back();
            }
        }
        string res;
        for(auto& x: st){
            res+=string(x.second,x.first);
        }
        return res;
    }
};

Q4. 统计和为 N 的无零数对

一个无零整数是一个十进制表示中不包含数字 0 的正整数。
给定一个整数 n，计算满足以下条件的数对 (a, b) 的数量：

a 和 b 都是无零整数。
a + b = n
返回一个整数，表示此类数对的数量。

示例 1:

输入: n = 2

输出: 1

解释:

唯一的数对是 (1, 1)。

示例 2:

输入: n = 3

输出: 2

解释:

数对有 (1, 2) 和 (2, 1)。

示例 3:

输入: n = 11

输出: 8

解释:

数对有 (2, 9)、(3, 8)、(4, 7)、(5, 6)、(6, 5)、(7, 4)、(8, 3) 和 (9, 2)。请注意，(1, 10) 和 (10, 1) 不满足条件，因为 10 在其十进制表示中包含 0。

提示:

2 <= n <= 10^15

解题思路：

设n的十进制字符串为s, 设当前数位 d=s[i], 我们需要将d拆分成两个[1,9]的数字,

例如n=234,

对于最低位4, 不借位拆, {1,3} {2,2}, {3,1} , 一共3种

借位拆：原数变成220 + 14, 14可以拆分成 5 种

一般地，借位会影响当前数位的值，从而影响拆分方案数

1. 设当前数位d=s[i]

2. 如果低位(i+1) 发生了借位, 那么把d减少 1，表示借给低位一个 1

3. d 也可以向高位（i−1）借 1，把 d 增加 10

4. 特别地，如果 d=0，那么把 d 减少 1 后 d=−1，此时必须向高位借 1

情况1：无前导0

设 d=a+b, 其中a,b都是[1,9]中的正整数

分类讨论:

1. d 不向高位借 1，我们计算的是 [1,9] 中的两数之和等于 d 的方案数，即 (a,b)=(1,d−1),(2,d−2),…,(d−1,1)，一共有 d−1 个。特别地，如果 d<2，那么无解。
2. d 向高位借 1，我们计算的是 [1,9] 中的两数之和等于 d+10 的方案数，即 (a,b)=(d+1,9),(d+2,8),…,(9,d+1)，一共有 9−d 个，或者说 19−(d+10) 个。

情况2：有前导0

如果当前拆分出来一个0, 那么这个数当前位之前的其他位就只能为0了，例如: d=a+b, a=0, b=d;

分类讨论:

1. 如果d!=0, b=d，只有一种填法。如果 d<0 则必须向高位借 1

特别地，如果我们刚开始填前导零，那么 (a,b)=(0,d) 或者 (a,b)=(d,0) 是对称的。我们无需分别计算 a=0 和 b=0 的情况，只需计算其中一种情况，然后把方案数乘以 2

2. 如果 d=0，那么 b=d=0

如果 i>0，由于我们没有向高位借 1，那么 b 的高位至少有一个非零数字，b 前面不能都是 0。此时无解。

否则 i=0，两个数的最高位都是 0，这是合法的。例如 100=49+51，49 和 51 的百位都是前导零

根据上面的讨论，定义 dfs(i,borrowed,isNum) 表示在 [0,i] 中填数字，且满足如下约束时的方案数：

1. borrowed=true 表示被低位（i+1）借 1。
2. isNum=true 表示右边所填数位没有 0（无前导零）。

递归边界：如果 i<0，那么 borrowed 必须是 false。是 false 则返回 1，不是则返回 0。

递归入口：为了获知低位的行为（是否借 1），要从最低位开始递归，即 dfs(∣s∣−1,false,true)。

class Solution {
    int fun(int b) {
        return max(min(b - 1, 19 - b), 0);
    }
public:
    long long countNoZeroPairs(long long n) {
        string d = to_string(n);
        int e = d.size();
        vector f(e, array<array<long long, 2>, 2>({{-1, -1}, {-1, -1}}));
        auto g = [&](this auto&& g, int h, bool i, bool j) -> long long {
            if (h < 0) return !i;
            long long& k = f[h][i][j];
            if (k != -1) return k;

            int l = d[h] - '0' - i;
            k = 0;

            if (j) {
                k = g(h - 1, false, true) * fun(l);
                k += g(h - 1, true, true) * fun(l + 10);
            }

            if (h < e - 1) {
                if (l) {
                    k += g(h - 1, l < 0, false) * (j + 1);
                } else if (h == 0) {
                    k++;
                }
            }

            return k;
        };
        return g(e - 1, false, true);
    }
};