2024牛客暑期多校训练营2
2024牛客暑期多校训练营2
E-GCD VS XOR_2024牛客暑期多校训练营2 (nowcoder.com)
题意
给定 x，构造 y < x 使得 gcd(x, y) = x ⊕ y
思路
取 x − lowbit(x) 即可，如果 x 是 2 的整数次幂则无解。
代码
#include<bits/stdc++.h>
using namespace std;
using i64 = long long;
void solve() {
i64 n;
cin >> n;
i64 ans = n - (n & -n);
cout << (ans ? ans : -1) << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--)
solve();
return 0;
}
C-Red Walking on Grid_2024牛客暑期多校训练营2 (nowcoder.com)
题意
给定一个 2 行 n 列的地图，有一些格子为障碍
任选起点，每个格子最多只能走一次（不能走到障碍），求最长路径
思路
考虑 dp，从左往右遍历，遇到上下都是 \(R\) 的时候说明上下可转移，在上面的由下和左转移，在下面的由上和左转移，然后更新答案。
代码
#include<bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
string s[2];
cin >> s[0] >> s[1];
array<int, 2> dp{0, 0};
int ans = 0;
for (int i = 0; i < n; i ++) {
if (s[0][i] == 'R')
dp[0] ++;
else
dp[0] = 0;
if (s[1][i] == 'R')
dp[1] ++;
else
dp[1] = 0;
if (s[0][i] == 'R' && s[1][i] == 'R') {
dp = {max(dp[0], dp[1] + 1), max({dp[1], dp[0] + 1})};
}
ans = max({ans, dp[0], dp[1]});
}
ans = max(ans - 1, 0);
cout << ans << '\n';
return 0;
}
H-Instructions Substring_2024牛客暑期多校训练营2 (nowcoder.com)
题意
平面直角坐标系中，小红初始站在原点
给定一个包含“上、下、左、右”的、长度为 n的指令序列，以及一个
特殊点 (x, y)
求选定一个子串，小红根据该子串序列移动，可以经过特殊点的方案数
思路
考虑前缀和记录每次到达的坐标，枚举左端点，对于从该左端点为起点第一次经过 （x,y) 的右端点，其右端点右边的点均为合法的点。
倒着枚举，找差分下标即可。
代码
#include<bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, x, y;
cin >> n >> x >> y;
string s;
cin >> s;
vector<array<int, 2>> a(n + 1);
a[0] = {0, 0};
for (int i = 0; i < n; i ++) {
a[i + 1] = a[i];
if (s[i] == 'W') {
a[i + 1][1] ++;
} else if (s[i] == 'S') {
a[i + 1][1] --;
} else if (s[i] == 'A') {
a[i + 1][0]--;
} else
a[i + 1][0]++;
}
int ans = 0;
map<array<int, 2>, int> idx;
for (int i = n; i >= 0; i --) {
idx[a[i]] = i;
if (idx.count({a[i][0] + x, a[i][1] + y})) {
int j = idx[ {a[i][0] + x, a[i][1] + y}];
j = max(j, i + 1);
ans += n - j + 1;
}
}
cout << ans << '\n';
return 0;
}
B-MST_2024牛客暑期多校训练营2 (nowcoder.com)
题意
给定一个 n 个点的简单带权无向图 G
每次询问一个点集 S，求 S 关于 G 导出子图的最小生成树
没有输出 −1
思路
考虑根号分治。
因为没有办法使用邻接矩阵，所有首先用 map，将整个图存下来
考虑两种可能的暴力
设以 \(\sqrt n\) 为界。
对于 \(k\le \sqrt n\)：对于给定点集 S，双重循环枚举 S 中的每个点，把其中需要的
边均取出来，并排序，使用 kruskal 算法，求出最小生成树。
对于 \(k>\sqrt n\) ：对于给定点集 S，循环枚举 S 中的每个点，在循环枚举该点的
所有边，将需要的边取出来，并排序，使用 kruskal 算法，求出最小生成树。
因为边是双向边，边数组的大小得开 2 倍。
代码
#include<bits/stdc++.h>
using namespace std;
using i64 = long long;
const int N = 1e5 + 10;
map<int, int> g[N];
vector<int> vis(N), node(N), fa(N);
vector<array<int, 3>> edge(N << 1);
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < m; i ++) {
int u, v, w;
cin >> u >> v >> w;
g[u][v] = g[v][u] = w;
}
const int base = sqrt(n);
auto find = [&](auto & self, int x)->int{
return fa[x] == x ? x : fa[x] = self(self, fa[x]);
};
while (q--) {
int k;
cin >> k;
for (int i = 0; i < k; i ++) {
cin >> node[i];
int u = node[i];
fa[u] = u;
vis[u] = 1;
}
int cnt = 0;
if (k <= base) {
for (int i = 0; i < k; i ++)
for (int j = i + 1; j < k; j ++)
if (g[node[i]].count(node[j]))
edge[cnt++] = { g[node[i]][node[j]], node[i], node[j]};
} else {
for (int i = 0; i < k; i ++) {
int u = node[i];
for (auto &[v, w] : g[u])
if (vis[v])
edge[cnt++] = {w, u, v};
}
}
sort(edge.begin(), edge.begin() + cnt);
i64 ans = 0, kuai = 0;
for (int i = 0; i < cnt; i ++) {
auto &[w, u, v] = edge[i];
u = find(find, u), v = find(find, v);
if (u != v) {
fa[u] = v;
ans += w;
kuai ++;
}
if (kuai == k - 1) break;
}
for (int i = 0; i < k; i ++) {
int u = node[i];
fa[u] = u;
vis[u] = 0;
}
if (kuai != k - 1) ans = -1;
cout << ans << '\n';
}
return 0;
}
I-Red Playing Cards_2024牛客暑期多校训练营2 (nowcoder.com)
题意
给定一个长度为 2 × n 的数组，1 到 n 每个元素恰好出现两次
每次操作可以删除一个长度不小于 2 的连续子数组，需要满足该子数组
首尾相同，获得该连续子数组“首尾元素值”乘以“元素数量”的分数
问最终可以得到的最大分数
思路
处理出 \(1\sim n\) 每个数包含的区间，考虑从大到小去枚举每个区间产生的贡献，因为大数产生的贡献一定比小数产生的更多。
设 \(f_x\) 表示 x 这个数所包含的区间所产生的贡献。
遍历 x 所包含的区间，设 \(dp_i\) 表示当前 \(l_x+1\sim i\) 所产生的贡献，如果对于 \(a_i\) 这个数，其 \([l_{a_i},r_{a_i}] \subset [l_x,r_x]\) ，那么有 \(dp_{r_{a_i}+1} = \max(dp_{r_{a_i}+1},dp_i+f_{a_i})\)，对于其他位置， x 产生的贡献就是 x，即 \(dp_{i+1}=\max(dp_i+x,dp_{i+1})\)，开始在两端补 0 的话，最后的答案即就是 \(f_0\)。
代码
#include<bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
n ++;
vector<int> a(2 * n);
for (int i = 1; i < 2 * n - 1; i ++)
cin >> a[i];
vector<int> l(n, -1), r(n);
for (int i = 0; i < 2 * n; i ++) {
cin >> a[i];
if (l[a[i]] == -1) {
l[a[i]] = i;
} else {
r[a[i]] = i;
}
}
vector<int> f(n);
for (int x = n - 1; x >= 0; x --) {
vector<int> dp(2 * n + 1);
for (int i = l[x] + 1; i < r[x]; i ++) {
if (dp[i + 1] < dp[i] + x)
dp[i + 1] = dp[i] + x;
if (i == l[a[i]] && r[a[i]] < r[x]) {
if (dp[r[a[i]] + 1] < dp[i] + f[a[i]])
dp[r[a[i]] + 1] = dp[i] + f[a[i]];
}
}
f[x] = 2 * x + dp[r[x]];
}
cout << f[0] << '\n';
return 0;
}
G-The Set of Squares_2024牛客暑期多校训练营2 (nowcoder.com)
题意
定义一个多重数集合是好的，但且仅当集合中元素乘积是一个正整数的
平方，集合的权值为这个正整数的值。
求大小为 N的多重数集的所有子集中所有好集的权值和
思路
注意到 \(\sqrt{1000}\) 以内的质数只有 {2, 3, 5, 7, 11, 13, 17, 19, 23, 27, 31} 一共 11 个
注意到对于 1000 以内的数，质因子中不可能出现两个大于 32 的质数
按照大质数分组，小质数状态压缩当成背包的体积，做分组背包
小质数作为第一组，其他大质数各自一组，转移时对于第 11 位上的 1 要记得清零
注意：数字 1 根据写法不同，可能要特殊处理，大质数配对、小质数配
对都需要计算贡献，分类讨论不要遗漏情况
代码
#include<bits/stdc++.h>
using namespace std;
using i64 = long long;
constexpr i64 mod = 1e9 + 7, N = 1000;
i64 prime[12] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
int m = 0;
vector vec(N + 1, vector<array<int, 2>>());
for (int i = 0; i < n; i ++) {
int x;
cin >> x;
m = max(x, m);
int mask = 0, val = 1;
for (int j = 0; j < 11; j ++) {
while (x % prime[j] == 0) {
x /= prime[j];
mask ^= 1 << j;
if (!(mask >> j & 1)) {
val = val * prime[j] % mod;
}
}
}
vec[x].push_back({mask, val});
}
vector<i64> dp(1 << 12);
dp[0] = 1;
for (int i = 1; i <= m; i ++) {
if (i * i <= 1000 && i != 1)
continue;
if (vec[i].empty())
continue;
prime[11] = i;
for (auto [st, val] : vec[i]) {
auto ndp = dp;
if (i != 1)
st |= 1 << 11;
for (int j = 0; j < (1 << 12); j ++) {
int both = j & st, nval = val;
for (int k = 0; k < 12; k ++) {
if (both >> k & 1) {
nval = nval * prime[k] % mod;
}
}
ndp[j ^ st] += dp[j] * nval % mod;
ndp[j ^ st] %= mod;
}
dp = move(ndp);
}
for (int j = 1 << 11; j < (1 << 12); j ++)
dp[j] = 0;
}
cout << dp[0] - 1 << '\n';
return 0;
}
