Codeforces Global Round 2 (A~E) 题解

FGH我太菜写不动——2019.4.7
A~E题好坑啊，重写的时候才发现昨晚自己不停地智障。

A. Ilya and a Colorful Walk
题目大意是给你一串数字，让你任两个不同数字间的最远距离。
一开始直接懵了，想暴力发现肯定超时，后来想二分距离，当时还过了，结果最后被Hack掉了。被人提醒后才知道大的距离满足时小的不一定满足。
其实这题·中的最大距离的一端一定在最左端或最右端，这里给出证明：
若存在1<i<j<n且最大距离在 i，j 取，那么要满足：

可知在1，2，3都成立的话4无法成立，所以不存在1<i<j<n的情况，那么，只要从左和右分别判断两次即可。

#include <iostream>
#include <algorithm>
using namespace std;
int n,infor[300010],ans;
int main(){
	cin>>n;
	int j;
	for(int i=0;i<n;i++){
		cin>>infor[i];
	}
	for(int i=n-1;i>=0;i--){
		if(infor[i]!=infor[0]){
			ans=i;
			break;
		}
	}
	for(int i=0;i<n;i++){
		if(infor[0]!=infor[i]){
			ans=max(ans,n-1-i);
			break; 
		}
	}
	cout<<ans<<endl;
	return 0;
}

B. Alyona and a Narrow Fridge
题目大意是让我们按顺序放瓶子，看最多能放多少个。
解法也很简单，暴力试值；放的方式是每次都放最高的那两个，然后减去高度即可。
一开始没看出来是按顺序放的我又懵了。

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int infor[1010],n,ans,k;
vector<int> pp;
bool check(int a){
	//cout<<a<<endl;
	int left=k;
	a--;
	while(a>=1){
		left-=pp[a];
		a-=2;
	//	cout<<left<<endl;
	}
	if(a==0) left-=pp[0];
	if(left<0) return false; 
//	cout<<left<<endl;
	return true;
}
int main(){
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>infor[i];
	}
	int i;
	for(i=1;i<=n;i++){
		pp.push_back(infor[i]);
		sort(pp.begin(),pp.end());
		if(!check(i)) break;
	} 
	cout<<i-1<<endl;
	return 0;
}

C. Ramesses and Corner Inversion
这题我想要骂人了，昨晚想了半天想用二维前缀和做一堆处理，然后放弃了去了E。今早一看直接暴力不就好了么，一个一个看，如果不同就把含他向右下所在的2×2的矩阵一起变了，最后比较一下两种有没有不同就好，没啥可证明的，想一下就行。

#include <iostream>
using namespace std;
bool mp1[510][510],mp2[510][510];
int m,n;
void func(int a,int b){
	mp1[a][b]=(!mp1[a][b]);
	mp1[a+1][b]=(!mp1[a+1][b]);
	mp1[a][b+1]=(!mp1[a][b+1]);
	mp1[a+1][b+1]=(!mp1[a+1][b+1]);
}
bool check(){
	for(int i=1;i<=m;i++){
		for(int j=1;j<=n;j++){
			if(mp1[i][j]!=mp2[i][j]){
				return false;
			}
		}
	}
	return true;
}
int main(){
	cin>>m>>n;
	for(int i=1;i<=m;i++){
		for(int j=1;j<=n;j++){
			cin>>mp1[i][j];
		}
	}
	for(int i=1;i<=m;i++){
		for(int j=1;j<=n;j++){
			cin>>mp2[i][j];
		}
	}
	for(int i=1;i<m;i++){
		for(int j=1;j<n;j++){
			if(mp1[i][j]!=mp2[i][j]){
				func(i,j);
			}
		}
	}
	if(check()) cout<<"Yes"<<endl;
	else cout<<"No"<<endl;
	return 0;
} 

官方给的解法是用奇偶性不变的原则来实现，由于每次操作的是4个角，所以他们所在的每行每列的和的奇偶性不变，如果两个数组每行每列的奇偶性都对应相同，那么就一定可以转化。
原文题解（数学证明好难）：

代码：

#include <iostream>
using namespace std;
bool mp1[510][510],mp2[510][510],h[2][510],l[2][510];
int m,n;
bool check(){
	for(int i=1;i<=m;i++){
		if(h[1][i]!=h[0][i]){
			return false;
		}
	}
	for(int i=1;i<=n;i++){
		if(l[1][i]!=l[0][i]){
			return false;
		}
	}
	return true;
}
int main(){
	cin>>m>>n;
	int sum=0;
	for(int i=1;i<=m;i++){
		for(int j=1;j<=n;j++){
			cin>>mp1[i][j];
			sum+=mp1[i][j];
		}
		if(sum&1){
			h[0][i]=true;
		}
		else{
			h[0][i]=false;
		}
		sum=0;
	}
	for(int i=1;i<=m;i++){
		for(int j=1;j<=n;j++){
			cin>>mp2[i][j];
			sum+=mp2[i][j];
		}
		if(sum&1){
			h[1][i]=true;
		}
		else{
			h[1][i]=false;
		}
		sum=0;
	}
	int sum2=0;
	for(int j=1;j<=n;j++){
		for(int i=1;i<=m;i++){
			sum+=mp1[i][j];
			sum2+=mp2[i][j];
		}
		if(sum&1){
			l[0][j]=true;
		}
		else{
			l[0][j]=false;
		}
		sum=0;
		if(sum2&1){
			l[1][j]=true;
		}
		else{
			l[1][j]=false;
		}
		sum2=0;
	}
	if(check()){
		cout<<"Yes"<<endl;
	}
	else{
		cout<<"No"<<endl;
	}
	return 0;
}

都是四百多ms过的，那么为什么不省点脑子暴力一把爽爽呢（雾）。

D. Frets On Fire
题目大意：给你一串数字，建立矩阵，每列的值是由前一列加一得到的。然后会有k次询问，问你在指定两列之间有多少个不同的数字。
我们稍作思考可知，问 i ~ j 和问 i+k ~ j+k 的答案应该是相同的，那么唯一的影响条件应该就是差值。
那么，现在对问题进行实际考虑，什么时候会出现重复情况？答：当 j-i 大于 某两个数插值时。于是，我们有知道了，此时应求插值，所以要排序，再做差值，每次询问时，相邻差值大于j-i的一定有 j-i 个不同的值出现，其余的每个则出现了差值次。详细实现方法如下：

#include <iostream>
#include <algorithm>
using namespace std;
typedef long long int ll;
ll a[100010];
ll pro[100010];
int main(){
	int n;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	sort(a,a+n);
	for(int i=0;i<n-1;i++){
		a[i]=a[i+1]-a[i];
	}
	sort(a,a+n-1);
	for(int i=0;i<n;i++){
		pro[i+1]=a[i]+pro[i]; 
	}
	int k;
	cin>>k;
	while(k--){
		ll l,r;
		cin>>l>>r;
		ll len = r-l+1;
		ll ind = lower_bound(a,a+n-1,len) - a;
		cout<<(n-ind)*len+pro[ind]<<" ";
	}
	return 0;
} 

E. Pavel and Triangles
题目大意：给你不同数量的二的次方长度的棍子，问你最多能组成多少个三角形。
题目看起来很简单，我又死在简单上了。
最优贪心法是：先组(i,j,j)型的三角形，若单个的边用完了，则组等边，余下的当作单个边使用。
至于证明，我就直接的翻译官方证明了：
为了证明正确性，我们取我们的方法和某一种最优解，然后找到两者间的第一个不同（在以同样顺序取的前提下）。这样只会有一种不同：我们取了某一种组合而那个最优解跳过了它。除此之外不可能有其他情况因为我们是能取则取，以下是各种情况：
……
（各种可能的跳过情况）
……
最后发现，所有可能的情况下我们的解法和最优解都会有相同的结果，因此我们可以将之后所有的不同都转化，且结果一定会是相同的，那么我们的解法得出的也是最优解。

#include <iostream>
#include <algorithm>
using namespace std;
typedef long long int ll;
ll n,infor[3000010];
ll ans;
int main(){
	cin>>n;
	ll d=0,s=0;
	for(int i=0;i<n;i++){
		cin>>infor[i];
		s+=infor[i]/2;
		d+=infor[i]%2;
		if(d>=s){
			ans+=s;
			d-=s;
			s=0;
		}
		else{
			ans+=d;
			s-=d;
			d=0;
			ans+=(s*2/3);
			s%=3;
			if(s==1) d+=2;
			else if(s==2){
				d++;
			}
			s=0;
		}
	}
	cout<<ans<<endl; 
	return 0;
}