牛客周赛 Round 28（A,B,C,D,E,F）

比赛链接
B站官方讲解

这场乍一看好像比较难，实际上还行。A送分的，BC思考一下可以直接出，D是双指针或者二分，E是数学，F是离散化+树状数组。BCD三十分钟出了。E看错题了，后来也写出来了。F比较麻烦，写了三十多分钟。

---

A 小红的新周赛

思路：

这题纯送分，读入六个数求和即可，看一眼直接过了，没写代码。

---

B 小红的字符串

思路：

因为只要长度为2的子字符串，所以可以直接 $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]$ 的和就是 $a[r]-a[l-1]$。区间和大于等于k，也就是 $a[r]-a[l-1]\ge k$。枚举 r，我们要找的其实就是有多少个 $a[l-1]$ 满足条件，换句话说，就是找 $l-1\in [0,r-1]$中 有多少个 $a[l-1]\le a[r]-k$。

因为 每个元素都>0 所以这个前缀和数组是单调递增的，所以可以二分去找这个第一个不满足条件的位置，它前面的左端点都是符合条件的。枚举r，然后加上符合条件的左端点个数，累加起来就是答案。时间复杂度$O(nlogn)$。

题解还给出了双指针的解法，用两个指针（模拟指针，其实就是下标）。用 $l$ 和 $r$ 分别代表左右端点，$r$ 向右移动区间和一定增大，$l$ 向右移动区间和一定减小。因此每次 $r$ 向右移动一位，然后尝试把 $l$ 向右移动，直到 $l$ 不能移动（就是移动后会破坏区间和大于等于k的条件），这时候 $l$ 前面的端点都可以是合法的左端点，直接累加起来就能得到最后答案了。由于两个指针都只向右移动，总的移动次数是 $2\ast 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,\dots ,3\times i+1$位置上的所有数奇偶性相同，同理下标为
$2,5,8,11,\dots ,3\times i+2$以及
$3,6,9,12,\dots ,3\times i+3$位置上的所有数奇偶性也是绑定的。

我们去暴力枚举前三个数的奇偶性，就可以确定所有数的奇偶性，前面三个数的奇偶性一共八种可能，即：

偶 偶 偶
偶 偶 奇
偶 奇 偶
奇 偶 偶
偶 奇 奇
奇 偶 奇
奇 奇 偶
奇 奇 奇

满足和为偶数的有四种，即：

偶 偶 偶
偶 奇 奇
奇 偶 奇
奇 奇 偶

一个位置要保证填入的数 $\le k$，填入偶数可以有 $\lfloor \frac{k}{2}\rfloor$ 种选择，填入奇数可以有 $\lceil \frac{k}{2}\rceil$种选择。所以找到偶数位置有多少个，奇数位置有多少，根据分步乘法计数原理 乘起来即可，可以用快速幂优化。

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$ 的前缀和的个数，需要动态的$O(logn)$的加入每个前缀和，并查询小于等于某个数的前缀和个数。这个前缀和可能很大，而且我们不需要关心前缀和具体是什么，而只需要知道相对于它小的前缀和个数，所以用离散化+树状数组，这种做法相当经典。

具体来说，先算出前缀和数组，并把前缀和离散化，这样每个左端点前缀和都有一个相对大小位置 $i$（相当于它是第 i 大），每次加入一个左端点前缀和，就在树状数组中给它的相对大小位置上加1（表示第 i 大位置上的数个数+1），查询所有小于等于k的前缀和个数时 相当于查询树状数组中1 ~ k中数的个数。

前缀和离散化之后枚举右端点r，查询小于等于 $a[r]-k$ 的左端点个数。查询结束后它就可以作为一个左端点了，加入到树状数组中。

$a[i]-k$ 可以不离散化，而是在查询的时候在排序离散化后的数组中找最后一个小于等于 $a[i]-k$ 的数据，改为查询这个数即可。时间复杂度排序离散化是$O(nlogn)$的，树状数组查询是$O(nlogn)$的，加上每次在排序离散化后的数组中二分找最后一个小于等于 $a[i]-k$ 的数据，最坏情况是$O(logn)$的（没有去重，cnt=n），查询的总时间复杂度是$O(nlo{g}^{2}n)$，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;
}