这场乍一看好像比较难,实际上还行。A送分的,BC思考一下可以直接出,D是双指针或者二分,E是数学,F是离散化+树状数组。BCD三十分钟出了。E看错题了,后来也写出来了。F比较麻烦,写了三十多分钟。
A 小红的新周赛
思路:
这题纯送分,读入六个数求和即可,看一眼直接过了,没写代码。
B 小红的字符串
思路:
因为只要长度为2的子字符串,所以可以直接
O
(
n
)
O(n)
O(n) 暴力枚举所有的子字符串,把所有的子字符串放到multiset之后直接输出即可(multiset中元素可重复,元素有序)。
题解做法是开一个字符串数组,然后用sort直接排序,也差不多。
code:
#include <iostream>
#include <cstdio>
#include <set>
#include <cstring>
using namespace std;
multiset<string> s;
string str;
int main(){
cin>>str;
for(int i=0;i<=str.length()-2;i++)
s.insert(str.substr(i,2));
for(auto &x:s)
cout<<x<<endl;
return 0;
}
sort版:
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn=1e5+5;
string str,s[maxn];
int main(){
cin>>str;
for(int i=0;i<=str.length()-2;i++)
s[i]=str.substr(i,2);
sort(s,s+str.length()-2+1);
for(int i=0;i<=str.length()-2;i++)
cout<<s[i]<<endl;
return 0;
}
C 小红的炸砖块
思路:
有砖块的地方才能炸,炸完之后,最上面会留空。反过来说,给定坐标,相当于选定一列,尝试增加它的留空个数。给出x y,如果第y列留空的个数<x,那么x就在有砖块的位置,就可以给这一列留空数+1。输出的时候也是看留空数就行了。
code:
#include <iostream>
#include <cstdio>
using namespace std;
const int maxn=1005;
int n,m,k;
int a[maxn];
int main(){
cin>>n>>m>>k;
// for(int i=1;i<=m;i++)
// a[i]=n;
for(int i=1,x,y;i<=k;i++){
cin>>x>>y;
if(x>a[y])a[y]++;
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(i>a[j])printf("*");
else printf(".");
}
puts("");
}
return 0;
}
D 小红统计区间(easy)
思路:
这个只看区间之和,所以先算前缀和数组a,区间 [ l , r ] [l, r] [l,r] 的和就是 a [ r ] − a [ l − 1 ] a[r]-a[l-1] a[r]−a[l−1]。区间和大于等于k,也就是 a [ r ] − a [ l − 1 ] ≥ k a[r]-a[l-1] \ge k a[r]−a[l−1]≥k。枚举 r,我们要找的其实就是有多少个 a [ l − 1 ] a[l-1] a[l−1] 满足条件,换句话说,就是找 l − 1 ∈ [ 0 , r − 1 ] l-1 \in [0,r-1] l−1∈[0,r−1]中 有多少个 a [ l − 1 ] ≤ a [ r ] − k a[l-1] \le a[r]-k a[l−1]≤a[r]−k。
因为 每个元素都>0 所以这个前缀和数组是单调递增的,所以可以二分去找这个第一个不满足条件的位置,它前面的左端点都是符合条件的。枚举r,然后加上符合条件的左端点个数,累加起来就是答案。时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)。
题解还给出了双指针的解法,用两个指针(模拟指针,其实就是下标)。用 l l l 和 r r r 分别代表左右端点, r r r 向右移动区间和一定增大, l l l 向右移动区间和一定减小。因此每次 r r r 向右移动一位,然后尝试把 l l l 向右移动,直到 l l l 不能移动(就是移动后会破坏区间和大于等于k的条件),这时候 l l l 前面的端点都可以是合法的左端点,直接累加起来就能得到最后答案了。由于两个指针都只向右移动,总的移动次数是 2 ∗ n 2*n 2∗n,所以时间复杂度是 O ( n ) O(n) O(n)的。
前缀和和计数可以同时进行。
code:
二分:
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=1e5+5;
typedef long long ll;
int n;
ll a[maxn],k;
int main(){
cin>>n>>k;
ll ans=0;
for(int i=1;i<=n;i++){
cin>>a[i];
a[i]+=a[i-1];
ans+=upper_bound(a,a+i,a[i]-k)-a;//a[r]-k>=a[l-1]
}
cout<<ans<<endl;
return 0;
}
双指针:
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=1e5+5;
typedef long long ll;
int n;
ll a[maxn],k;
int main(){
cin>>n>>k;
ll ans=0;
for(int i=1,l=0,r=1;i<=n;i++,r++){
cin>>a[i];
a[i]+=a[i-1];
//如果区间[l+1,r]之和大于k,l++
while(a[r]-a[l]>=k)l++;
ans+=l;
}
cout<<ans<<endl;
return 0;
}
E 小红的好数组
思路:
一开始看假题了,以为子数组的长度不定(连续子数组长度固定为3),之后看了一眼题解会了。
长度为3的子数组可以通过用长为3的窗口从头移动到尾来全部枚举出来,这个长为3的窗口向右移动的时候会增加一个元素,同时减少一个元素,如果要保证奇偶性质不变,就必须保证增加一个奇数,就减少一个奇数,反之增加一个偶数,就减少一个偶数。那么下标为
1
,
4
,
7
,
10
,
…
,
3
×
i
+
1
1,4,7,10,\dots,3\times i+1
1,4,7,10,…,3×i+1位置上的所有数奇偶性相同,同理下标为
2
,
5
,
8
,
11
,
…
,
3
×
i
+
2
2,5,8,11,\dots,3\times i+2
2,5,8,11,…,3×i+2以及
3
,
6
,
9
,
12
,
…
,
3
×
i
+
3
3,6,9,12,\dots,3\times i+3
3,6,9,12,…,3×i+3位置上的所有数奇偶性也是绑定的。
我们去暴力枚举前三个数的奇偶性,就可以确定所有数的奇偶性,前面三个数的奇偶性一共八种可能,即:
偶 偶 偶
偶 偶 奇
偶 奇 偶
奇 偶 偶
偶 奇 奇
奇 偶 奇
奇 奇 偶
奇 奇 奇
满足和为偶数的有四种,即:
偶 偶 偶
偶 奇 奇
奇 偶 奇
奇 奇 偶
一个位置要保证填入的数 ≤ k \le k ≤k,填入偶数可以有 ⌊ k 2 ⌋ \left\lfloor \frac k 2 \right\rfloor ⌊2k⌋ 种选择,填入奇数可以有 ⌈ k 2 ⌉ \left\lceil \frac k 2 \right\rceil ⌈2k⌉种选择。所以找到偶数位置有多少个,奇数位置有多少,根据分步乘法计数原理 乘起来即可,可以用快速幂优化。
code:
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
ll n,k;
ll n1,n2,n3,a1,a2,a3,a4;
ll qpow(ll a,ll b){
ll ans=1,base=a;
while(b){
if(b&1){
ans=(ans*base)%mod;
}
base=(base*base)%mod;
b>>=1;
}
return ans;
}
int main(){
cin>>n>>k;
n1=(n+2)/3;
n2=(n+1)/3;
n3=n/3;
// printf("%lld %lld %lld\n",n1,n2,n3);
a1=qpow(k/2,n1)*qpow(k/2,n2)%mod*qpow(k/2,n3)%mod;//第一种情况的个数
a2=qpow(k/2,n1)*qpow((k+1)/2,n2)%mod*qpow((k+1)/2,n3)%mod;//第二种情况的个数
a3=qpow((k+1)/2,n1)*qpow(k/2,n2)%mod*qpow((k+1)/2,n3)%mod;//第三种情况的个数
a4=qpow((k+1)/2,n1)*qpow((k+1)/2,n2)%mod*qpow(k/2,n3)%mod;//第四种情况的个数
cout<<(a1+a2+a3+a4)%mod;
return 0;
}
F 小红统计区间(hard)
思路
和D题区别在于元素有可能<0,所以前缀和的单调性性质不存在了。依靠单调性的双指针和二分显然不能用了。仔细观察,如果a是前缀和数组,发现我们其实要找的是前r个左端点中所有小于等于 a r − k a_r-k ar−k 的前缀和的个数,需要动态的 O ( l o g n ) O(logn) O(logn)的加入每个前缀和,并查询小于等于某个数的前缀和个数。这个前缀和可能很大,而且我们不需要关心前缀和具体是什么,而只需要知道相对于它小的前缀和个数,所以用离散化+树状数组,这种做法相当经典。
具体来说,先算出前缀和数组,并把前缀和离散化,这样每个左端点前缀和都有一个相对大小位置 i i i(相当于它是第 i 大),每次加入一个左端点前缀和,就在树状数组中给它的相对大小位置上加1(表示第 i 大位置上的数个数+1),查询所有小于等于k的前缀和个数时 相当于查询树状数组中1 ~ k中数的个数。
前缀和离散化之后枚举右端点r,查询小于等于 a [ r ] − k a[r]-k a[r]−k 的左端点个数。查询结束后它就可以作为一个左端点了,加入到树状数组中。
a [ i ] − k a[i]-k a[i]−k 可以不离散化,而是在查询的时候在排序离散化后的数组中找最后一个小于等于 a [ i ] − k a[i]-k a[i]−k 的数据,改为查询这个数即可。时间复杂度排序离散化是 O ( n l o g n ) O(nlogn) O(nlogn)的,树状数组查询是 O ( n l o g n ) O(nlogn) O(nlogn)的,加上每次在排序离散化后的数组中二分找最后一个小于等于 a [ i ] − k a[i]-k a[i]−k 的数据,最坏情况是 O ( l o g n ) O(logn) O(logn)的(没有去重,cnt=n),查询的总时间复杂度是 O ( n l o g 2 n ) O(nlog^2n) O(nlog2n),1e5稳过。树状数组敲一遍下来还蛮快的,就几个小函数,树状数组love。
code:
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=1e5+5;
typedef long long ll;
int n;
ll a[maxn],k;
int cnt;
ll t[maxn];
inline int getidx(ll x){
return lower_bound(t+1,t+cnt+1,x)-t;
}
int tr[maxn];
int lowbit(int x){return x&-x;}
void pp(int x){
for(int i=x;i<=cnt;i+=lowbit(i))
tr[i]++;
}
int query(int x){
int ans=0;
for(int i=x;i;i-=lowbit(i))
ans+=tr[i];
return ans;
}
inline int query(int l,int r){
return query(r)-query(l-1);
}
inline int lowerbound(ll x){
// upper_bound()-t找到的是第一个大于x的数的位置,-1就退到了最后一个小于等于x的位置上
int idx=upper_bound(t+1,t+cnt+1,x)-t-1;
// printf("%lld %lld %lld\n",x,idx,query(idx));
return query(idx);
}
int main(){
cin>>n>>k;
ll ans=0;
for(int i=1;i<=n;i++){
cin>>a[i];
a[i]+=a[i-1];
t[++cnt]=a[i];
}
// for(int i=1;i<=n;i++)
// cout<<a[i]<<" ";
// puts("");
//因为左端点前缀和可以是a[0],即l-1=0,所以额外加上这个左端点
t[++cnt]=0;
sort(t+1,t+cnt+1);
cnt=unique(t+1,t+cnt+1)-t-1;
// for(int i=1;i<=cnt;i++)
// cout<<t[i]<<" ";
// puts("");
for(int i=1;i<=n;i++){
//把上一个循环中的右端点作为左端点加入树状数组
pp(getidx(a[i-1]));
//查询前i个左端点中小于等于a[i]-k的个数
ans+=lowerbound(a[i]-k);
}
cout<<ans<<endl;
return 0;
}