Educational Codeforces Round 115 (Rated for Div. 2) 题解
Educational Codeforces Round 115 (Rated for Div. 2)
好菜啊 什么老年人。
A. Computer Game
让我们判断是否能从左上角走到右下角，因为只有两行，直接判断每一列是不是全为1就行。
#include<bits/stdc++.h>
using namespace std;
const int N = 110;
int g[N][N];
int main() {
int _;
cin >> _;
while (_--) {
int n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
bool flag = true;
for (int i = 0; i < n; i++)
if (s1[i] == '1' && s2[i] == '1') flag = false;
if (!flag) puts("NO");
else puts("YES");
}
return 0;
}
B. Groups
问我们能否把学生分为两组，在一周里的两天给这些学生上课。暴力。
随便找两天day1，day2，然后遍历学生，计算这些学生在day1，day2有空的人数，以及两天都没空的情况，再稍加判断即可。
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int g[N][10];
int momolai[N];
int g1, g2;
bool st[N];
int main() {
int _;
cin >> _;
while (_--) {
memset(momolai, 0, sizeof(momolai));
g1 = g2 = 0;
int n;
cin >> n;
bool flag1 = false;
bool flag = false;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 5; j++) cin >> g[i][j];
for (int i = 1; i <= 5; i++)
for (int j = i + 1; j <= 5; j++) {
memset(st, false, sizeof(st));
int c1, c2;
c1 = c2 = 0;
flag = true;
for (int k = 1; k <= n; k++) {
if (g[k][i]) c1++, st[k] = true;
if (g[k][j]) c2++, st[k] = true;
}
for (int k = 1; k <= n; k++) {
if (!st[k]) flag = false;
}
if (c1 >= n / 2 && c2 >= n / 2 && flag) flag1 = true;
}
if (flag1) puts("YES");
else puts("NO");
}
return 0;
}
C. Delete Two Elements
给一个数组，数组元素的平均数为x，让我们删除其中两个数字，使得新数组的平均数也为x，求可行方案数。
设总和为\(sum\) 删除的两个元素为\(a_i\) ,\(a_j\) \((i<j)\) ,我们有：
\(\frac{sum}{n} = \frac{sum-a_i-a_j}{n-2}\) 即： \(\frac{sum}{n}*(n-2)=sum-a_i-a_j\) 即： \(\frac{sum}{n}*(n-2)+a_i=sum-a_j\)
这样我们只需要统计他们相等的对数就可以了。
#include<bits/stdc++.h>
using namespace std;
int main() {
int _;
cin >> _;
while (_--) {
int n;
cin >> n;
vector<int> a;
long long sum = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += x;
a.push_back(x);
}
map<double, int> mp;
long long ans = 0;
double base = 1.0 * sum / n * (n - 2);
for (auto i: a) {
if (mp.count(base + i)) ans += mp[base + i];
mp[sum - i]++;
}
cout << ans << endl;
}
return 0;
}
D. Training Session
给一堆数对\((a_i,b_i)\),让我们从里面挑三个，满足三个数对的\(a\)互不相同或者\(b\)互不相同
考虑用总的减去不合法的。
不合法如何计算：设当前数对\((a_i,b_i)\),从数对中a为\(a_i\)的里选择一个数对\((a_i,b_j)\)，再从数对中b为\(b_i\)的选择一个数对\((a_k,b_i)\)
这样就保证了计算出来的数对一定不合法，且没有缺漏。
#include<bits/stdc++.h>
using namespace std;
const int N = 200010;
vector<int> a;
vector<int> b;
map<int, int> cnta;
map<int, int> cntb;
int main() {
int _;
cin >> _;
while (_--) {
a.clear();
b.clear();
cnta.clear();
cntb.clear();
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back(x);
b.push_back(y);
cnta[x]++;
cntb[y]++;
}
long long ans = 1ll * n * (n - 1) * (n - 2) / 6;
for (int i = 0; i < n; i++) {
ans -= 1ll * (cnta[a[i]] - 1) * (cntb[b[i]] - 1);
}
cout << ans << endl;
}
return 0;
}
E. Staircases
给我们一个\(n*m\)的矩形，让我们求楼梯的数量。
即当前格子只能从上或者从左走来，且不能连续走。
每次操作改变目标格子属性，计算每次的楼梯总数。
对于每次操作 我们发现，我们在计算完到达\(g_{ij}\)的总数后，只需要遍历更新\(g_{{i+1},j}\),\(g_{i,{j+1}}\),\(g_{{i+1},{j+1}}\),就可以计算答案。
定义dp1为横着走到达的方案数，dp2为竖着走到达的方案数，对于初始状态则有：
\(dp1[i][j]=dp2[i-1][j]+1 \qquad dp2[i][j]=dp1[i][j-1]+1\)
//====================================================================================================
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<sstream>
#include<cmath>
#include <cctype>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<double, double> PUU;
#define RUSH cin.tie(),cout.tie(),ios::sync_with_stdio(false)
#define pb push_back
#define eb emplace_back
#define pai acos(-1.0)
inline ll qmi(ll a, ll b, ll mod) {
ll ans = 1 % mod;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans % mod;
}
inline ll inv(ll a, ll mod) {
return qmi(a, mod - 2, mod);
}
const int N = 1010;
int g[N][N];
int n, m, q;
ll ans = 0;
int dp1[N][N], dp2[N][N];
void change(int i, int j) {
while (i <= n && j <= m) {
if (i < n) {
ans -= dp1[i + 1][j];
dp1[i + 1][j] = g[i + 1][j] * (1 + dp2[i][j]);
ans += dp1[i + 1][j];
}
if (j < m) {
ans -= dp2[i][j + 1];
dp2[i][j + 1] = g[i][j + 1] * (1 + dp1[i][j]);
ans += dp2[i][j + 1];
}
if (i < n && j < m) {
ans -= dp1[i + 1][j + 1] + dp2[i + 1][j + 1];
dp1[i + 1][j + 1] = g[i + 1][j + 1] * (1 + dp2[i][j + 1]);
dp2[i + 1][j + 1] = g[i + 1][j + 1] * (1 + dp1[i + 1][j]);
ans += dp1[i + 1][j + 1] + dp2[i + 1][j + 1];
}
i++, j++;
}
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
dp1[i][j] = dp2[i][j] = 1;
g[i][j] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i > 1) dp1[i][j] = dp2[i - 1][j] + 1;
if (j > 1) dp2[i][j] = dp1[i][j - 1] + 1;
ans += dp1[i][j] + dp2[i][j];
}
int base = n * m;//多计算的个数
while (q--) {
int x, y;
cin >> x >> y;
g[x][y] ^= 1;
if (!g[x][y]) {
base--;
ans -= (dp1[x][y] + dp2[x][y]);
dp1[x][y] = dp2[x][y] = 0;
} else {
base++;
ans -= (dp1[x][y] + dp2[x][y]);
if (x > 1) dp1[x][y] = dp2[x - 1][y] + 1;
else dp1[x][y] = 1;
if (y > 1) dp2[x][y] = dp1[x][y - 1] + 1;
else dp2[x][y] = 1;
ans += dp1[x][y] + dp2[x][y];
}
change(x, y);
cout << ans - base << endl;
}
return 0;
}
F. RBS
给一堆括号字符串，我们可以改变字符串间的顺序，使得其合法前缀最大，求最大值。
由于n<=20,考虑状压dp。
设字符串s的长度为n，我们定义字符串自身总和：\(\begin{equation*} sum = \sum_{i=1}^n ((s[i]=='(')*2-1) \end{equation*}\)
对于每个字符串，计算其字符串自身括号匹配总和，当其总和小于零代表无法自身匹配，需要其他字符串加在前面。
我们记录每个字符串最小的值的数量以及字符串之和。(即不合法的右括号数量和不合法的左括号数量)
对于状态压缩：我们把我们所选的字符串总和加起来之后，去遍历没选的字符串j，计算选上未选字符串之后的状态：
\(new=las|(1<<j)\)
若字符串总和加上其最小值大于零：则\(dp[new]=max(dp[new],dp[las])\)
若字符串总和加上其最小值刚好等于零，说明可以完美拼接，有：\(dp[new]=max(dp[new],dp[las]+mp[j][minn[j]])\)
若字符串总和加上其最小值小于零，则：\(ans=max(ans,dp[las]+mp[j][-sum])\) 更新一下答案，加上能与其匹配的最大量以及以及合法匹配的前缀数量 （加在后面）
//====================================================================================================
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<sstream>
#include<cmath>
#include <cctype>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<double, double> PUU;
#define RUSH cin.tie(),cout.tie(),ios::sync_with_stdio(false)
#define pb push_back
#define eb emplace_back
#define pai acos(-1.0)
inline ll qmi(ll a, ll b, ll mod) {
ll ans = 1 % mod;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans % mod;
}
inline ll inv(ll a, ll mod) {
return qmi(a, mod - 2, mod);
}
const int N = 21;
int dp[1 << N];
int sum[N], minn[N];
map<int, int> mp[N];
int ans = 0;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
minn[i] = 0;
for (int j = 0; j < s.size(); j++) {
sum[i] += (s[j] == '(') * 2 - 1;
if (sum[i] < minn[i]) {
minn[i] = sum[i];
mp[i][minn[i]] = 1;
} else if (sum[i] == minn[i]) mp[i][sum[i]]++;
}
}
for (int i = 0; i < (1 << n); i++) dp[i] = -0x3f3f3f3f;
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
int now = 0;
for (int j = 0; j < n; j++) {
if (i >> j & 1) now += sum[j];
}
if (now < 0) continue;
for (int j = 0; j < n; j++) {
if (!(i >> j & 1)) {
int getj = i | (1 << j);
if (now + minn[j] > 0) dp[getj] = max(dp[getj], dp[i]);
else if (now + minn[j] == 0) {
dp[getj] = max(dp[getj], dp[i] + mp[j][minn[j]]);
ans = max(ans, dp[getj]);
} else ans = max(ans, dp[i] + mp[j][-now]);
}
}
}
cout << ans << endl;
return 0;
}
By 泽浩巨巨
浙公网安备 33010602011771号