2024 ICPC National Invitational Collegiate Programming Contest, Wuhan Site
2024 ICPC National Invitational Collegiate Programming Contest, Wuhan Site
I. Cyclic Apple Strings
题意：给定一个01字符串，每次操作可以将这个字符串向左循环移动任意次数，求让这个字符串变成有序的需要最少几次操作
思路：每次只能减少最右边的不和有边界相邻的一个1的长块，每次删去最右边的即可
void solve(){ string s; cin >> s; int ans = 0, idx = s.size() - 1; while(idx >= 0 && s[idx] == '1') idx --; for(idx; idx >= 0; idx --){ if(s[idx] == '1' && s[idx + 1] == '0') ans ++; } cout << ans << '\n'; }
K. Party Games
题意：给定 n 个整数从左到右排成一列，每次可以从两端拿走其中一个数字，如果数字被拿完了或者剩余的数字的异或和为0，则当前操作无法进行，就失败了
思路：打表发现 n % 4 == 0 || n % 4 == 1 的情况下 Fluttershy 必胜，否则必败
void solve(){ ll n; cin >> n; n %= 4; if(n == 1 || n == 0) cout << "Fluttershy\n"; else cout << "Pinkie Pie\n"; }
B. Countless Me
题意：给定一个数组，每个数组的值可以随便分配，求最后的最小或运算的和
思路：从高位往低位贪心即可，如果在当前位的后面放满而且不够，那么放在当前位是最好的选择，注意这里的位数不要太大
void solve(){ ll n, x, sum = 0; cin >> n; for(int i = 1; i <= n; i ++){ cin >> x; sum += x; } ll ans = 0; for(int i = 30; i >= 0; i --){ if(sum > ((1ll << i) - 1) * n){ ll num = min(n, sum / (1ll << i)); sum -= num * (1ll << i); ans += 1ll << i; } } cout << ans << '\n'; }
F. Custom-Made Clothes
题意：给定一个n * n 的矩阵，矩阵的每个点大于等于它左边的和上边的点（如果存在），每次可以查询一个点的数字是不是小于等于给定的询问值，在50000次查询中得出第k大的数字
思路：看50000次查询能猜到复杂度应该是2nlogn级别，二分答案，每次查询从左下角开始，如果小于等于mid，往上移动，否则把这一列上面的数字的个数全部加上，否则左移，每次查询的次数不超过2*n，总计2nlogn次查询得出答案
int n, k; int ask(int x, int y, int z){ cout << "? " << x << ' ' << y << ' ' << z << endl; int ans; cin >> ans; return ans; } bool check(int x){ int sum = 0; int a = n, b = 1; while(a >= 1 && b <= n){ int ans = ask(a, b, x); if(ans == 1){ sum += a; b ++; } else{ a --; } } if(sum >= k) return true; else return false; } void solve(){ cin >> n >> k; k = n * n - k + 1; int l = 1, r = n * n; while(l < r){ int mid = l + r >> 1; if(check(mid)) r = mid; else l = mid + 1; } cout << "! " << l << endl; }
D. ICPC
题意：有 n 个点，每个点的价值都是 ai 并且每个点被拿走之后价值变为0，求从每个点开始移动次数为 1~2 * n 能获得的最大价值
思路：很容易想到，从每个点出发之后最多折返一次，预处理出价值的前缀和，方便求前缀价值和，然后求出不折返的情况下能获得的最大价值，然后求出从每个点的左边折返过来的最大价值，同理求出右边，最后取max即可
ll n, a[N]; ll dp1[N][N * 2], dp2[N][N * 2]; void solve(){ cin >> n; for(int i = 1; i <= n; i ++) cin >> a[i]; for(int i = 1; i <= n; i ++) a[i] += a[i - 1]; for(int i = 1; i <= n; i ++){ for(int j = 1; j <= n * 2; j ++){ int l = max(1, i - j), r = min(n, 1ll * i + j); dp1[i][j] = max(a[i] - a[l - 1], a[r] - a[i - 1]); } }//不折返的情况 for(int i = 1; i <= n; i ++){ for(int j = 1; j <= 2 * n; j ++){ dp2[i][j] = max(dp2[i - 1][j - 1], dp1[i][j]); } } for(int i = n; i >= 1; i --){ for(int j = 1; j <= n * 2; j ++){ dp1[i][j] = max(dp1[i][j], dp1[i + 1][j - 1]); } } ll ans = 0; for(int i = 1; i <= n; i ++){ ll res = 0; for(int j = 1; j <= 2 * n; j ++){ res ^= j * max(dp1[i][j], dp2[i][j]); } ans ^= (i + res); } cout << ans << '\n'; }
E. Boomerang
题意：有一棵树，开始时假消息从r点开始传播，每次从已传播到的点开始传播到相邻的点，云宝从t0开始辟谣，辟谣从ro点开始，每次从已辟谣的点传播到相邻的k个所有节点，求k为1~n的情况下每次任选r0的情况最早什么时候完成辟谣
思路：可以很容易发现，从直径中间开始辟谣是最好的，动态维护一个树直径，LCA即可，每次把下一层的点加入，当加入一个新的点的时候，直径只有三种情况，假设新加入的点是 x，原直径两端是u, v，那么新的直径只会是（u, v), (u, x), (v. x), 不断扩大树的直径，然后记录每一秒的树的直径，然后开始枚举秒数，最大不会超过n + t0，因为时间是随着 k 的增大逐渐递减，所以枚举秒数，当就理论上扩散的深度比直径/2大，ans--，否则输出ans
struct LCA{ int n; vector<int> dep, vis; vector<vector<int>> fa; LCA(int _n) : n(_n), dep(_n + 10), vis(_n + 10), fa(n + 1, vector<int>(25, 0)) {} void init(auto edge[], int x){ auto dfs =[&](auto && dfs, int u, int fath){ if(vis[u]) return; vis[u] = 1; dep[u] = dep[fath] + 1; fa[u][0] = fath; for(int i = 1; i <= __lg(dep[u]); i ++){ fa[u][i] = fa[fa[u][i - 1]][i - 1]; } for(auto v : edge[u]){ dfs(dfs, v, u); } }; dfs(dfs, x, 0); } int query(int a, int b){ if(dep[a] > dep[b]) swap(a, b); while(dep[a] != dep[b]) b = fa[b][__lg(dep[b] - dep[a])]; if(a == b) return a; for(int k = __lg(dep[a]); k >= 0; k --){ if(fa[a][k] != fa[b][k]){ a = fa[a][k], b = fa[b][k]; } } return fa[a][0]; } int dist(int u, int v){ return dep[u] + dep[v] - 2 * dep[query(u, v)]; } }; void solve(){ int n; cin >> n; vector<int> edge[n + 1]; for(int i = 1; i < n; i ++){ int u, v; cin >> u >> v; edge[u].push_back(v); edge[v].push_back(u); } int r, t0; cin >> r >> t0; LCA lca(n); lca.init(edge, r); vector<array<int, 3>> dd(n + 1); dd[1] = {1, r, r};//d, u, v int d = 0, du = r, dv = r; queue<PII> q; q.push({1, r}); while(q.size()){ auto [deep, u] = q.front(); q.pop(); auto now = max(dd[deep], dd[deep - 1]); int ud = lca.dist(now[1], u) + 1, vd = lca.dist(now[2], u) + 1; if(ud > now[0]){ now = {ud, u, now[1]}; } if(vd > now[0]){ now = {vd, u, now[2]}; } dd[deep] = max(dd[deep], now); for(auto v : edge[u]){ if(v == lca.fa[u][0]) continue; q.push({deep + 1, v}); } } for(int i = 1; i <= n; i ++) dd[i][0] = max(dd[i][0], dd[i - 1][0]); int ans = n + t0; for(int i = 1; i <= n; i ++){ while(dd[min(n, ans)][0] / 2 <= (ans - 1 - t0) * i){ ans --; } cout << ans << ' '; } }
M. Merge
题意：给定n个数字，每次可以把绝对值差为1的两个数字合并，求最终数字任意排序后最大字典序情况
思路：由于是求字典序，肯定优先得到最大的数字，由于是绝对值差为1的两个数字的合并，所以一个为奇数，一个为偶数，每次取出最大的偶数合并，要不和x + 1合并，要不和x - 1合并，递归的取合并数字，如果需要的数字已经存在了，那就优先合成进去，然后再用小数字合成，可以发现， 奇数可以用一个奇数一个偶数合成，偶数除非本身就存在，否则无法合成，用map记录数字的数量来递归的合成即可
void solve(){ ll n; cin >> n; map<ll, ll> mp; multiset<ll> even; for(int i = 1; i <= n; i ++){ ll x; cin >> x; mp[x] ++; if(x % 2 == 0) even.insert(x); } auto check =[&](auto && check, ll x) -> bool{ if(mp[x]){ mp[x] --; return true; } ll x2 = x / 2, y2 = x2 + 1; if(y2 % 2 == 0) swap(x2, y2); if(!mp[x2]) return false; else{ mp[x2] --; if(check(check, y2)){ return true; } else{ mp[x2] ++; return false; } } }; vector<ll> ans; while(even.size()){ auto x = *even.rbegin(); even.erase(even.find(x)); if(!mp[x]) continue; mp[x] --; if(check(check, x + 1)){ mp[x * 2 + 1] ++; } else if(check(check, x - 1)){ mp[x * 2 - 1] ++; } else{ ans.push_back(x); } } for(auto &[x, y] : mp){ for(int i = 1; i <= y; i ++) ans.push_back(x); } cout << ans.size() << '\n'; sort(ans.begin(), ans.end(), greater<ll>()); for(auto x : ans) cout << x << ' '; }
