Educational Codeforces Round 108 (Rated for Div. 2)题解

题目链接

A.Red and Blue Beans

题目描述
给定红色豆子 r 个，蓝色豆子 b 个，问是否存在一种分装方法，使得每个袋子里两种颜色的豆子至少都有一个，且两种豆子的数量差不超过 d 。
解题思路
关键点在于如何使差值尽可能小。贪心的减小一个袋子里，两种豆子的数目，那么设 r > b，就分为 b 份，再将 r 平均分到这些袋子里。比较差值与 d 的大小关系即可。

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<cmath>
#include<cstring>
#include<string>
#include<cstdio>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int mod = 1e9 + 7;
int main(){
    int t;
    cin>>t;
    while(t--){
        int r, b, d;
        cin >> r >> b >> d;
        int num = min(r, b);
        int num1 = max(r, b);
        int tag = num1 / num;
        int tag1 = num1 % num;
        if(tag1){
            tag++;
        }
        if(tag - 1 > d){
            cout << "NO" << endl;
        }
        else{
            cout << "YES" << endl;
        }
    }
        return 0;
}

B.The Cake Is a Lie

题目大意
给定一个 n*m 的矩阵，要求从（1，1）移动到（n，m），每走一步需要花费一定的值，若沿着 y 的正向走一步，花费 x，沿着 x 的正向走一步，花费 y (规定只能沿着x正向和y正向两个方向走)，问是否可以在花费恰好等于 k 的情况下走完全程？
解题思路
经过推导可发现无论怎么走，花费都是不变的，推导过程见下图：

所以仅需判断nm - 1 与 k 是否相等

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<cmath>
#include<cstring>
#include<string>
#include<cstdio>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int mod = 1e9 + 7;
int main(){
    int t;
    cin>>t;
    while(t--){
        int n, m, k;
        cin >> n >> m >> k;
        if(k == n * m - 1){
            cout << "YES" << endl;
        }
        else{
            cout << "NO" << endl;
        }
    }
        return 0;
}

C. Berland Regional

题目大意：
给定n个选手所处的学校与他们各自的能力值，指定每个学校派出的队伍规模，若人数小于要求数则该队不能组成，若可以组成的话，每个学校都会优先派出能力值高的队员，输出当队伍规模从 1 到 n 时，所有参加队员的能力值总和。
解题思路
比较明显的模拟题，用vector G[N]来存储每个学校的队员情况，注意在计算最后的总值时，要使用前缀和优化后的值来求取，不能遍历，否则会超时。

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<cmath>
#include<cstring>
#include<string>
#include<cstdio>
#include<set>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int mod = 1e9 + 7;
const int N = 2e5 + 100;
ll u[N];
ll s[N];
ll pre[N];
ll outp[N];
vector<ll> ans[N];
int main(){
    int t;
    cin>>t;
	while(t--){
		int n;
		cin >> n;
		set<ll> ss;//set不会存储重复值，用其来存储出现的学校有哪些
		for (int i = 1; i <= n;i++){
			ans[i].clear();
			cin >> u[i];
			ss.insert(u[i]);
		}
		for (int i = 1; i <= n;i++){
			cin >> s[i];
			ans[u[i]].push_back(s[i]);
		}
		for(int e : ss){
			sort(ans[e].begin(), ans[e].end(), greater<ll>());//按降序排
			int num = ans[e].size();
			for (int i = 1; i <= num;i++){
				pre[i] = pre[i - 1] + ans[e][i - 1];//存储每个学校的和
			}
			for (int i = 1; i <= num;i++){
				outp[i] += pre[num / i * i];//存储所有学校的和
			}
		}
		for (int i = 1; i <= n;i++){
			cout << outp[i] << ' ';
		}
		cout << endl;
		memset(outp, 0, sizeof outp);
 
	}
	return 0;
}

D. Maximum Sum of Products

题目大意
给定两个长度为 n 的数组 a, b 可以选定数组 a 的一个子序列进行反转。
$$求\sum _{i=1}^n{a}_i\times b_i的最大值$$
解题思路
假如暴力遍历所有区间计算的话 复杂度约为 n 的三次方级别，所以我们不妨考虑枚举区间中心所在的位置，在满足条件的情况下，每次对区间进行扩展后，该区间对应的值就相当于扩张前的值加上扩展后两个端点的值交叉相乘。
对于区间长度为奇数和偶数要分别进行讨论。
用前缀和来维护 O1 时间复杂度求值。

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<cmath>
#include<cstring>
#include<string>
#include<cstdio>
#include<set>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int mod = 1e9 + 7;
const int N = 2e5 + 100;
ll a[5010], b[5010];
ll pre[5010];
int main(){
	int n;
	cin >> n;
	ll ans = 0;
	for (int i = 1; i <= n;i++){
		cin >> a[i];
	}
	for (int i = 1; i <= n;i++){
		cin >> b[i];
	}
	for (int i = 1; i <= n;i++){
		pre[i] = pre[i - 1] + a[i] * b[i];
	}
	for (int cet = 1; cet <= n;cet++){
		ll cnt = a[cet] * b[cet];
		for (int l = cet - 1, r = cet + 1; l >= 1 && r <= n; l--,r++){
			cnt += a[l] * b[r];
			cnt += a[r] * b[l];
			ans = max(ans, pre[l - 1] + cnt + (pre[n] - pre[r]));
		}
	}//转化区间长度为奇数
	for (int cet = 1; cet <= n;cet++){
		ll cnt1 = 0;
		for (int l = cet, r = cet + 1; l >= 1 && r <= n; l--,r++){
			cnt1 += a[l] * b[r];
			cnt1 += a[r] * b[l];
			ans = max(ans, pre[l - 1] + cnt1 + (pre[n] - pre[r]));
		}
	}
	ans = max(ans, pre[n]);//以上情况是不考虑不做变化的情况的，最后特判一下
	cout << ans << endl;
	return 0;
}