LeetCode 第31场夜喵双周赛 题解
这次比赛我个人感觉最难居然是第二题 其他都是白给 不如不做 浪费了美好的夜晚
文章目录
- a.在区间范围内统计奇数数目
- a.题目
- a.分析
- a.参考代码
- b.和为奇数的子数组数目
- b.题目
- b.分析
- b.参考代码
- c.字符串的好分割数目
- c.题目
- c.分析
- c.参考代码
- d.形成目标数组的子数组最少增加次数
- d.题目
- d.分析
- d.参考代码
a.在区间范围内统计奇数数目
a.题目
给你两个非负整数 low 和 high 。请你返回 low 和 high 之间（包括二者）奇数的数目。
示例 1
输入：low = 3, high = 7
输出：3
解释：3 到 7 之间奇数数字为 [3,5,7] 。
示例 2
输入：low = 8, high = 10
输出：1
解释：8 到 10 之间奇数数字为 [9] 。
提示
- 0 <= low <= high <= 10^9
a.分析
比赛第一时间肯定先想能不能直接暴力做 但是很可惜 1e9的数据量不能直接统计
那么就得上公式了 奇偶是隔着的 所以大概是(high-low)/2
但是还需要处理些细节 为了避免处理这些细节 我们可以把两端改一下
- low==high时 直接返回答案1或0
- 当low为奇数时 答案+1 low++
- 当high为奇数时 答案+1 high- -
- 接着就是(high-low)/2 因为此时都是偶数 肯定符合公式
a.参考代码
class Solution {
public:
int countOdds(int low, int high) {
if(low==high)return low%2==1;
int ans=0;
if(low&1){
low++;
ans++;
}
if(high&1){
high--;
ans++;
}
return ans+(high-low)/2;
}
};
b.和为奇数的子数组数目
b.题目
给你一个整数数组 arr 。请你返回和为 奇数 的子数组数目。
由于答案可能会很大，请你将结果对 10^9 + 7 取余后返回。
示例 1
输入：arr = [1,3,5]
输出：4
解释：所有的子数组为 [[1],[1,3],[1,3,5],[3],[3,5],[5]] 。
所有子数组的和为 [1,4,9,3,8,5].
奇数和包括 [1,9,3,5] ，所以答案为 4 。
示例 2
输入：arr = [2,4,6]
输出：0
解释：所有子数组为 [[2],[2,4],[2,4,6],[4],[4,6],[6]] 。
所有子数组和为 [2,6,12,4,10,6] 。
所有子数组和都是偶数，所以答案为 0 。
示例 3
输入：arr = [1,2,3,4,5,6,7]
输出：16
示例 4
输入：arr = [100,100,99,99]
输出：4
示例 5
输入：arr = [7]
输出：1
提示：
- 1 <= arr.length <= 10^5
- 1 <= arr[i] <= 100
b.分析
这里先看数据范围 1e5 应该是要用O（n）或者O（nlogn）的算法
但是由于是子数组连续的 所以不会往排序去想
子数组是连续的 所以大概率能用上dp 所以往dp方向想
假设dp1[i]定义为 以第i个为结尾的和为奇数的子数组的个数
假设dp2[i]定义为 以第i个为结尾的和为偶数的子数组的个数
只要固定了结尾 那么子数组就是直接往前延伸
思考以下 对于该状态定义 显然有以下状态转移：
- 当arr[i]为奇数的时候
- dp1[i]=dp2[i-1]+1 以i这个奇数为结尾的加在前面和为偶数的连续子数组 和为奇数 且可以仅有i这个奇数构成长度为1的奇数和子数组 所以要+1
- dp2[i]=dp1[i-1] 以i这个奇数为结尾的加在前面和为奇数的连续子数组 和为偶数
- 同理当arr[i]为偶数的时候
- dp1[i]=dp1[i-1] 以i这个偶数为结尾的加在前面和为奇数的连续子数组 和为奇数
- dp2[i]=dp2[i-1]+1 以i这个偶数为结尾的加在前面和为偶数的连续子数组 和为偶数 且可以仅有i这个偶数构成长度为1的偶数和子数组 所以要+1
最终的答案就是dp1的全部答案相加 因为要枚举全部以不同位为结尾的答案
总的时间复杂度为O（n）
b.参考代码
class Solution {
public:
const int mod=1e9+7;
int numOfSubarrays(vector<int>& arr) {
int n=arr.size();
vector<int> dp1(n,0),dp2(n,0);
if(arr[0]&1)dp1[0]=1; //先处理第一个 方便
else dp2[0]=1;
for(int i=1;i<n;i++) //按上面说的转移
if(arr[i]&1){
dp1[i]=dp2[i-1]+1;
dp2[i]=dp1[i-1];
}
else{
dp1[i]=dp1[i-1];
dp2[i]=dp2[i-1]+1;
}
int ans=0;
for(int i=0;i<n;i++)ans=(dp1[i]+ans)%mod; //最后䣌答案是全部作为末尾的计数
return ans;
}
};
c.字符串的好分割数目
c.题目
给你一个字符串 s ，一个分割被称为 「好分割」 当它满足：将 s 分割成 2 个字符串 p 和 q ，它们连接起来等于 s 且 p 和 q 中不同字符的数目相同。
请你返回 s 中好分割的数目。
示例 1
输入：s = “aacaba”
输出：2
解释：总共有 5 种分割字符串 “aacaba” 的方法，其中 2 种是好分割。
(“a”, “acaba”) 左边字符串和右边字符串分别包含 1 个和 3 个不同的字符。
(“aa”, “caba”) 左边字符串和右边字符串分别包含 1 个和 3 个不同的字符。
(“aac”, “aba”) 左边字符串和右边字符串分别包含 2 个和 2 个不同的字符。这是一个好分割。
(“aaca”, “ba”) 左边字符串和右边字符串分别包含 2 个和 2 个不同的字符。这是一个好分割。
(“aacab”, “a”) 左边字符串和右边字符串分别包含 3 个和 1 个不同的字符。
示例 2
输入：s = “abcd”
输出：1
解释：好分割为将字符串分割成 (“ab”, “cd”) 。
示例 3
输入：s = “aaaaa”
输出：4
解释：所有分割都是好分割。
示例 4
输入：s = “acbadbaada”
输出：2
提示
- s 只包含小写英文字母。
- 1 <= s.length <= 10^5
c.分析
假设s的长度为n 那么显然只有n-1种分割方式
那么先从暴力思考：
对于每种分割 假设分割点为x
那么需要在0~x中统计字母个数 x~n中也统计一下
暴力的统计方法就是每次遍历左右区间统计出现过的 但是显然会超时
那么就需要预处理一下s：
最多有26个字母 把每个字母第一次出现的位置和最后一次出现的位置记录下来
那么统计字母就变成了 在26个字母的位置数组中看看区间是否存在该字母
左区间中只要第一次出现的位置小于分割点即可
右区间中只要最后一次出现的位置大于分割点即可
那么每次统计就会变成固定的时间频率26次
总的时间复杂度是遍历分割点的O（n）
c.参考代码
class Solution {
public:
int numSplits(string s) {
int n=s.size();
vector<vector<int>> cnt(26);
for(int i=0;i<s.size();i++) //预处理
cnt[s[i]-'a'].push_back(i);
int ans=0;
for(int i=0;i<n-1;i++) //枚举分割点
{
int L=0,R=0;
for(int j=0;j<26;j++)
{
if(!cnt[j].size())continue;
if(cnt[j][0]<=i)L++; //左区间存在
if(cnt[j][cnt[j].size()-1]>i)R++; //右区间存在
}
if(L==R)ans++;
}
return ans;
}
};
d.形成目标数组的子数组最少增加次数
d.题目
给你一个整数数组 target 和一个数组 initial ，initial 数组与 target 数组有同样的维度，且一开始全部为 0 。
请你返回从 initial 得到 target 的最少操作次数，每次操作需遵循以下规则：
- 在 initial 中选择 任意 子数组，并将子数组中每个元素增加 1 。
答案保证在 32 位有符号整数以内。
示例 1
输入：target = [1,2,3,2,1]
输出：3
解释：我们需要至少 3 次操作从 intial 数组得到 target 数组。
[0,0,0,0,0] 将下标为 0 到 4 的元素（包含二者）加 1 。
[1,1,1,1,1] 将下标为 1 到 3 的元素（包含二者）加 1 。
[1,2,2,2,1] 将下表为 2 的元素增加 1 。
[1,2,3,2,1] 得到了目标数组。
示例 2
输入：target = [3,1,1,2]
输出：4
解释：(initial)[0,0,0,0] -> [1,1,1,1] -> [1,1,1,2] -> [2,1,1,2] -> [3,1,1,2] (target) 。
示例 3
输入：target = [3,1,5,4,2]
输出：7
解释：(initial)[0,0,0,0,0] -> [1,1,1,1,1] -> [2,1,1,1,1] -> [3,1,1,1,1]
-> [3,1,2,2,2] -> [3,1,3,3,2] -> [3,1,4,4,2] -> [3,1,5,4,2] (target)。
示例 4
输入：target = [1,1,1,1]
输出：1
提示
- 1 <= target.length <= 10^5
- 1 <= target[i] <= 10^5
d.分析
这题看代码长度就很无语了
考察贪心的思想
观察题目样例 需要简单总结下 如何才是最少的增加次数
我大概看了下就能假设出：同一层连续的需要一次改变完
举例：
[1,2,3,2,1]
我把它换成这样的形式
- - + - -
- + + + -
+ + + + +
这样就能理解我说的同一层是什么意思了
每次都选取最长的连续区间（即不会被减号分割的区间）进行增加
反证： 假如不这样做 那么这个区间必定可以划分成两次增加的区间
存在性质：增加的区间不需要从低到高 也就是顺序无所谓 先增加哪一层其实都一样
所以我们可以看到 最少的增加次数其实就是层数
更具体讲应该说是每座山山顶的层数
考虑下面样例：
[3,1,5,4,2]
- - + - -
- - + + -
+ - + + -
+ - + + +
+ + + + +
这个可以看出有两个山峰 第一个高度为3 第二个相对第一个山高度为4 它们拥有同一层的连续地基高度1 所以总次数为3+4=7
那么就呼之欲出了 那么显然只需要在上升序列中计数 下降序列不处理
总的时间复杂度为O（n）
d.参考代码
class Solution {
public:
int minNumberOperations(vector<int>& target) {
int n=target.size();
int ans=target[0];
for(int i=1;i<target.size();i++)
{
if(target[i]<=target[i-1])continue;
else ans+=target[i]-target[i-1];
}
return ans;
}
};