2022学年第一学期郑州大学ACM招新赛选拔赛

A SW的与众不同数组 — 签到

一共n个数，用set无重复值的性质统计一下有几个不同的数，记为 res
n - res 如果是偶数每次删除两个刚好可以，如果是奇数需要再删除一个不重复的数完成对应操作

#include <iostream>
#include <set>
using namespace std;
void solve()
{int n; cin >> n;set<int> mp;for(int i = 0, x; i < n; i ++) cin >> x, mp.insert(x);int res = mp.size();if((n - res) % 2 == 1) res --;cout << res << '\n';
}
signed main()
{int T; cin >> T;while(T --) solve();
}

B WASD机器人 — 暴力/ 数学推导

暴力写法：

直接暴力枚举最后成功到达终点的串中的 L/R 的数量，这样的话 L, R, U, D的数量全都可以确定下来了，然后每次更新答案，取最小值

#include <iostream>
#include <algorithm>
using namespace std;
signed main()
{string s; cin >> s; int n = s.size();int x, y; cin >> x >> y;if(abs(x) + abs(y) > s.size()) return puts("-1"), 0;// 现有的 l, r, u, d 的数量int nl = 0, nr = 0, nu = 0, nd = 0;for(auto c : s){nl += c == 'L';nr += c == 'R';nu += c == 'U';nd += c == 'D';}    int res = n;// 枚举最后结果中  l, r 数量 此时 u, d 数量也确定了int l, r, u, d;for(int i = 0; i <= n; i ++){if(x > 0) l = i, r = x + i;else l = -x + i, r = i;int dt = (n - l - r - y) / 2;if(y > 0) u = y + dt, d = dt;else u = dt, d = -y + dt;if(l < 0 || r < 0 || d < 0 || u < 0 ) break;int sum = abs(nl - l) + abs(nr - r) + abs(nu - u) + abs(nd - d);res = min(res, (sum + 1) / 2); } cout << res << '\n';
}

数学写法放上吕翊加大佬的推导过程

#include <iostream>
#include <algorithm>
using namespace std;
int sum[5];
int main()
{string s; cin >> s;for (int i = 0; i < (int)s.size(); ++ i){if (s[i] == 'R') ++ sum[1];if (s[i] == 'L') ++ sum[2];if (s[i] == 'U') ++ sum[3];if (s[i] == 'D') ++ sum[4];}int tx, ty; cin >> tx >> ty;if (abs(tx) + abs(ty) > sum[1] + sum[2] + sum[3] + sum[4]) return puts("-1"), 0;if (tx < 0){tx = -tx;swap(sum[1], sum[2]);}if (ty < 0){ty = -ty;swap(sum[3], sum[4]);}int ans = 0;if (sum[1] + sum[2] < tx) ans += tx - sum[1];else ans += (abs(sum[1] - sum[2] - tx) + 1) / 2;if (sum[3] + sum[4] < ty) ans += ty - sum[3];else ans += (abs(sum[3] - sum[4] - ty) + 1) / 2;if (abs(sum[1] - sum[2] - tx) % 2 && std::abs(sum[3] - sum[4] - ty) % 2) -- ans;cout << ans << '\n';
}

C SW的糖果树（困难版本）— 启发式合并优化

思路和简单暴力版一样只是多了启发式合并
这里大概说一下为什么可以用启发式合并，因为每个子节点遍历完后就不会再遍历了，如果不进行启发式合并就相当于把子节点对应的子树信息更新到父节点上，但是可能存在父节点存的信息更少，如果把子节点信息更新到父节点上就会变慢，所以可以进行启发式合并进行优化，复杂度O(nlogn)O(nlogn)O(nlogn)

#include <iostream>
#include <cstring>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
const int N = 100010;
int n, a[N], res = 0;
bool st[N];
vector<int> g[N];
map<int,int> mp[N];
int maxv[N], maxv_col[N], sum[N];void dfs(int u)
{st[u] = true;mp[u][a[u]] ++;maxv[u] = 1;maxv_col[u] = a[u];sum[u] = a[u];for(auto v : g[u]){if(st[v]) continue;dfs(v);// 启发式合并操作if(mp[u].size() < mp[v].size()) {swap(mp[u], mp[v]);swap(maxv[u], maxv[v]);swap(maxv_col[u], maxv_col[v]);swap(sum[u], sum[v]);}for(auto [x, c] : mp[v]){if(mp[u][x] == 0) sum[u] ^= x;mp[u][x] += c;if(mp[u][x] > maxv[u]){maxv[u] = mp[u][x];maxv_col[u] = x;}else if(mp[u][x] == maxv[u]) maxv_col[u] ^= x;}}res = max(sum[u] ^ maxv_col[u], res);
}signed main()
{cin >> n;for(int i = 1; i <= n; i ++) cin >> a[i];for(int i = 1, u, v; i < n; i ++){cin >> u >> v;g[u].push_back(v);g[v].push_back(u);}dfs(1);cout << res << '\n';
}

D SW的七星光芒剑 — 数学

找到6个点连接6条线
需要注意的是每行*之间有空格

#include <iostream>
#include <cstring>
using namespace std;
char g[1010][1010];
signed main()
{int n; cin >> n;memset(g, ' ', sizeof g);for(int i = 1; i <= 6 * n - 5; i ++) if(i & 1) g[n][i] = g[3 * n - 2][i] = '*';for(int i = 1, j = 3 * n - 2; i <= 3 * n - 2; i ++, j --) g[i][j] = '*';for(int i = 1, j = 3 * n - 2; i <= 3 * n - 2; i ++, j ++) g[i][j] = '*';for(int i = 4 * n - 3, j = 3 * n - 2; i >= n; i --, j --) g[i][j] = '*';for(int i = 4 * n - 3, j = 3 * n - 2; i >= n; i --, j ++) g[i][j] = '*';for(int i = 1; i <= 4 * n - 3; i ++){for(int j = 1; j <= 6 * n - 5; j ++)cout << g[i][j];cout << '\n';}
}

E 井字棋游戏 — 博弈论+ 暴搜

因为要判断a1是否必胜因此对于 a1 而言平局算输，而对于a2而言平局算赢
直接dfs出每种情况做一个判断，如果存在赢的情况就赢，如果一种情况都不赢就输
即有一种必胜就是必胜所有必败就是必败

#include <iostream>
using namespace std;
#define int long longint g[10];
// 判断是否获胜
bool win(int x)
{for(int i = 0; i < 7; i += 3)if(g[i] == x && g[i + 1] == x && g[i + 2] == x) return true;for(int i = 0; i < 3; i ++)if(g[i] == x && g[i + 3] == x && g[i + 6] == x) return true;if(g[0] == x && g[4] == x && g[8] == x) return true;if(g[2] == x && g[4] == x && g[6] == x) return true;return false;
}
// 1: 输/平局 0，赢1
// 2: 赢/平局 1, 输0
bool dfs()
{int a1 = 0, a2 = 0;for(int i = 0; i < 9; i ++){a1 += g[i] == 1;a2 += g[i] == 2;}// 最后一步是 p2走的，只要不是p1 赢 p1 就算输if(a1 + a2 == 9) return !win(1);// 轮到a1if(a1 == a2){if(win(1)) return true;if(win(2)) return false;bool f = 0;for(int i = 0; i < 9; i ++){if(g[i]) continue;g[i] = 1;// 如果存在a2 输了 ，则a1赢if(dfs() == false) f = 1;g[i] = 0;if(f) return true;}// 如果 a2一直赢 则 a1 必输return false;}// 先到轮到 a2  与 a1 同理else{if(win(2)) return true;if(win(1)) return false;bool f = 0;for(int i = 0; i < 9; i ++){if(g[i]) continue;g[i] = 2;if(dfs() == false) f = 1;g[i] = 0;if(f) return true;}return false;}
}
signed main()
{int a1 = 0, a2 = 0;for(int i = 0; i < 9; i ++){cin >> g[i];a1 += g[i] == 1;a2 += g[i] == 2;}int res = dfs();// 看残局先手是谁， 如果是p2 需要异或一下答案if(a1 != a2) res ^= 1;cout << (res ? "YES" : "NO") << '\n';
}

F SW的糖果树（简单版本）— 暴力

这个题意思容易理解错
意思是求把一个子树中最大数量的所有颜色去掉，求其它颜色的异或和的最大值
直接暴力每个子树顶点，然后统计这个子树中最大数量的颜色再异或去掉

#include <iostream>
#include <vector>
#include <map>
using namespace std;
#define int long long
const int N = 10010;
int a[N];
vector<int> g[N];
bool st[N];
map<int,int> mp[N];
int res = 0;
void dfs(int u, int fa)
{st[u] = true;for(auto v : g[u]){if(v == fa || st[v]) continue;dfs(v, u);// 把子树中颜色加到父亲节点颜色中for(auto [x, c] : mp[v])mp[u][x] += c;}mp[u][a[u]] ++;vector<int> vec;// 统计出现最多的颜色int maxv = 0, s = 0;for(auto [x, c] : mp[u]){if(maxv < c) vec.clear(), maxv = c;if(maxv == c) vec.push_back(x);s ^= x;}// 把出现最多的颜色去掉for(auto x : vec) s ^= x;res = max(res, s);
}
signed main()
{int n; cin >> n;for(int i = 1; i <= n; i ++) cin >> a[i];for(int i = 1, u, v; i < n; i ++){cin >> u >> v;g[u].push_back(v);g[v].push_back(u);}dfs(1, -1);cout << res << '\n';
}

G 凑数字 — 构造

n,n-1这两个数不变, 前面全部凑成1，相邻两个相减为1，然后1 * 1，最后(1 + n - 1) * n

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
signed main()
{int n; cin >> n;if(n == 2){cout << -1 << '\n';return 0;}int m = n - 2;vector<string> res;for(int i = m; i > 1; i -= 2){string s = to_string(i) + " - " + to_string(i - 1);res.push_back(s);}while(res.size() < n - 3) res.push_back("1 * 1");string s = "1 + " + to_string(n - 1); res.push_back(s);s = to_string(n) + " * " + to_string(n); res.push_back(s);for(auto x : res) cout << x << '\n';
}

H 旋转数组 — dp

这个一定要读清楚题连续上升子串是指数值连续 1，2，3，4…且位置连续
状态表示：
dp[i][j]dp[i][j]dp[i][j]表示以i列结尾，且数值为j的最长字串长度
状态转移：
dp[j+1][x]=max(dp[j+1][x],dp[j][x−1]+1)dp[j + 1][x] = max(dp[j + 1][x], dp[j][x - 1] + 1)dp[j+1][x]=max(dp[j+1][x],dp[j][x−1]+1)

#include <iostream>
#include <vector>
#include <map>
using namespace std;
const int N = 100010;
vector<vector<int>> a;
map<int,int> dp[N];
int n, m;
int res = 0;
signed main()
{cin >> n >> m;a = vector<vector<int>> (n, vector<int>(m));for(int i = 0; i < n; i ++)for(int j = 0; j < m; j ++)cin >> a[i][j];for(int j = 0; j < m; j ++)for(int i = 0; i < n; i ++){int x = a[i][j];dp[j + 1][x] = max(dp[j + 1][x], dp[j][x - 1] + 1);res = max(res, dp[j + 1][x]);}cout << res << '\n';
}

I 最小字典序序列 — 小项堆 + 栈模拟题

这就是个模拟题，开m个栈，记录每个栈栈顶数值对应的栈的编号pos
同时维护一个小项堆，每次从小项堆里拿出最小值放入结果中，同时根据pos找到最小值对应的栈的编号，将栈更新

#include <iostream>
#include <vector>
#include <stack>
#include <queue>
using namespace std;
const int N = 100010;
int pos[N];
stack<int> stk[N];
signed main()
{int n, m; cin >> n >> m;priority_queue<int, vector<int>, greater<int> > heap;for(int i = 1; i <= m; i ++){int t, x; cin >> t;while(t --) cin >> x, stk[i].push(x);pos[x] = i; heap.push(x);}string res = "";while(heap.size()){int t = heap.top(); heap.pop();res += " " + to_string(t);if(stk[pos[t]].size()) stk[pos[t]].pop();if(stk[pos[t]].size()){int top = stk[pos[t]].top();heap.push(top);pos[top] = pos[t];}}cout << res.substr(1) << '\n';
}

J SW玩扫雷 — 模拟签到

直接模拟，遍历到每个雷，把周围的数值都+1

#include <iostream>
#include <cstring>
using namespace std;
char g[110][110];
int res[110][110];
signed main()
{memset(res, 0, sizeof res);int n, m; cin >> n >> m;for(int i = 1; i <= n; i ++) cin >> (g[i] + 1);// 设置个负无穷 最后做判断for(int i = 1; i <= n; i ++)for(int j = 1; j <= m; j ++)if(g[i][j] == '*') res[i][j] = -1e9;for(int i = 1; i <= n; i ++)for(int j = 1; j <= m; j ++)if(g[i][j] == '*')// 相邻8个数for(int u = i - 1; u <= i + 1; u ++)for(int v = j - 1; v <= j + 1; v ++){if(u == i && j == v) continue;res[u][v] ++;}for(int i = 1; i <= n; i ++){for(int j = 1; j <= m; j ++)if(res[i][j] >= 0) cout << res[i][j];else cout << "*";cout << '\n';}
}

K 亮度 — 暴力

推个数学式子然后暴力，四维可优化到三维见代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
signed main()
{int a, b, c, d; cin >> a >> b >> c >> d;int res = 10000;for(int i = 0; i <= 500; i ++){if(i > res) break;for(int j = 0; j <= 500; j ++){if(i + j > res) break;for(int k = 0; k <= 500; k ++){if(i + j + k > res) break;int t1 = (a - (i + j / 2 + k / 2)) * 4;int t2 = (b - (i / 2 + j + k / 4)) * 2;int t3 = (c - (i / 2 + j / 4 + k)) * 2;int t4 = (d - (i / 4 + j / 2 + k / 2));int u = max({t1, t2, t3, t4});res = min(res, i + j + k + u);}}}cout << res << '\n';
}

L SW的妙妙区间 — 思维

这里放一道同类型力扣题，可以做一下传送门

正难则反的思路，我们可以先找不包含0的区间，再用总区间减去
不包含0的区间求解思路
先枚举右端点i，此时右端点固定找符合条件的左端点数量加到res中，离右端点最远的左端点就是到最近的一个包含0的区间，可以用map判断是否包含包含0， map储存前缀和，如果map出现两个相同的值就证明有0出现了，用pos记录最近的0的位置

#include <iostream>
#include <cstring>
#include <unordered_map>
using namespace std;
#define int long long
const int N = 1000010;
int a[N];
signed main()
{int n; cin >> n;for(int i = 1; i <= n; i ++) cin >> a[i];int res = 0;unordered_map<int,int> mp;for(int i = 0, pos = 0, sum = 0; i <= n; i ++){sum += a[i];if(mp.count(sum)) pos = max(pos, mp[sum] + 1);mp[sum] = i;res += i - pos;}cout << (n + 1) * n / 2 - res << '\n';
}