本次比赛，AK两题为签到题，
文章目录
A. 负鼠的追求者
解法1
求[1,x]中与x互质的最大的数，由于x最大为5000，可以枚举[1,x]中的每个数来依次验证是否满足gcd(i,x)=1，时间复杂度为 O ( T ∗ n log n ) O(T*n \log n) O(T∗nlogn)。
#include <iostream>
using namespace std;
int gcd(int a,int b) {
if(!b) return a;
return gcd(b,a%b);
}
int T,x;
int main() {
cin >> T;
while (T--) {
cin >> x;
int f;
for(int i=1;i<=x;i++) {
if(gcd(i,x)==1) f = i;
}
cout << f << endl;
}
return 0;
}
解法2
观察可得，对于任意一个大于1的自然是x，x与x-1必然互质，直接输出x-1即可。注意：x=1时要特殊考虑。
#include <iostream>
using namespace std;
int T,x;
int main() {
cin >> T;
while(T--) {
cin >> x;
cout << (x==1?1:x-1) << endl;
}
return 0;
}
B. Game
把1-n每个数都看作一个节点，并且给相互连通的节点加边，记再次排列的得到的数组为p，如果i和p[i]不连通，那么输出NO。若所有的i都可以走到p[i]，那么输出YES。
解法1
用邻接矩阵表示i,j两点是否连通，再跑一遍Floyd求出结果。
#include <cstring>
#include <iostream>
using namespace std;
const int maxn = 105;
const int inf = 0x3f3f3f3f;
int n, p[maxn], a[maxn][maxn], d[maxn], T;
int main() {
scanf("%d", &T);
while (T--) {
memset(a, inf, sizeof(a));
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++) {
a[i][i] = 1;
for (int j = 1; j <= n; j++) {
if (abs(i - j) == d[i] || abs(i - j) == d[j])
a[i][j] = a[j][i] = 1;
}
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
}
}
bool flag = 1;
for (int i = 1; i <= n; i++) {
if (a[i][p[i]] == inf) flag = 0;
}
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
解法2
用邻接表建图，对1-n每个节点都跑一遍DFS/BFS即可。
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int maxn = 105;
int n, d[maxn], p[maxn], T;
vector<int> e[maxn];
bool flag, vis[maxn];
void dfs(int x, int pre, int dest) {
if (x == dest) {
flag = 1;
return;
}
vis[x] = 1;
for (int i = 0; i < e[x].size(); i++) {
int v = e[x][i];
if (!vis[v]) dfs(v, x, dest);
}
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++) {
e[i].clear();
e[i].push_back(i);
for (int j = 1; j <= n; j++) {
if (abs(i - j) == d[i] || abs(i - j) == d[j]) {
e[i].push_back(j);
e[j].push_back(i);
}
}
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
flag = 0;
dfs(i, -1, p[i]);
if (!flag) {
break;
}
}
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
C. 犯困的负鼠
暴力是肯定会TLE的，题解提供离散化+分块的做法。
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
const int maxn = 40000;
const int maxn_SQRT = 200;
// 离散化用到的 set（集合）和 tot（不重复的数字数量）
int n, a[maxn + 1], set[maxn + 1], tot;
// 块大小、块数量、cnt[x][i] 表示 x 这个数在前 i 个块中的出现次数，ans[l][r]
// 表示第 l 个块到第 r 个块的答案
int blockSize, blockCnt, cnt[maxn + 1][maxn_SQRT + 1],
ans[maxn_SQRT + 1][maxn_SQRT + 1];
// 离散化
inline void discrete() {
copy(a + 1, a + n + 1, set + 1);
sort(set + 1, set + n + 1);
int *end = unique(set + 1, set + n + 1);
for (int i = 1; i <= n; i++) a[i] = lower_bound(set + 1, end, a[i]) - set;
tot = end - (set + 1); // 区间 [set + 1, end) 的长度
}
// 给一个位置，求所在块编号
inline int blockID(int i) { return (i - 1) / blockSize + 1; }
// 给一个块编号，求其区间
inline void blockInterval(int i, int &l, int &r) {
l = (i - 1) * blockSize + 1;
r = i * blockSize;
// 防止越界
r = min(r, n);
}
// 预处理
inline void prepare() {
// 以根号 n 分块
blockSize = ceil(sqrt(n));
blockCnt = blockID(n);
// cnt[x][i] 表示 x 这个数在第 i 个块中的出现次数
for (int i = 1; i <= n; i++) {
int bi = blockID(i);
cnt[a[i]][bi]++;
}
// 做前缀和
for (int i = 1; i <= blockCnt; i++) {
for (int j = 1; j <= tot; j++) cnt[j][i] += cnt[j][i - 1];
}
// 求 ans[l][r]
for (int i = 1; i <= blockCnt; i++) {
// cnt[x] 表示 x 这个数在第 [i, j] 这个块区间内的出现次数
static int cnt[maxn + 1];
fill(cnt + 1, cnt + tot + 1, 0); // 清空 cnt
int tmp = 0; // 表示当前答案
for (int j = i; j <= blockCnt;
j++) // j 从 i 开始枚举，每次向后扩充一个块
{
// 将第 j 个块加入到答案中
int l, r;
blockInterval(j, l, r);
// 枚举第 j 个块的所有数
for (int k = l; k <= r; k++) {
cnt[a[k]]++;
// 更新答案
// 注意，根据题意，出现次数相同时取较小值
if (!tmp || cnt[a[k]] > cnt[tmp] ||
(cnt[a[k]] == cnt[tmp] && a[k] < tmp))
tmp = a[k];
}
// 记录答案
ans[i][j] = tmp;
}
}
}
// 暴力计算 [l, r] 的答案
inline int force(int l, int r) {
static int cnt[maxn + 1];
int ans = 0;
for (int i = l; i <= r; i++) {
cnt[a[i]]++;
// 更新答案
if (!ans || cnt[a[i]] > cnt[ans] ||
(cnt[a[i]] == cnt[ans] && a[i] < ans))
ans = a[i];
}
// 清空 cnt，注意不能 memset 或者 fill
// 因为我们需要 force() 的时间复杂度与 [l, r]
// 的区间长度有关，与序列中总数的数量无关
for (int i = l; i <= r; i++) cnt[a[i]]--;
return ans;
}
// 计算 a 中的 n 个数的答案（这些数是在查询时不在块内的数）
// 统计数的出现次数时，额外加入每个数在 [lb, rb] 这些（完整的）块内的出现次数
// 并将新答案与旧答案 oldAns 取较优
inline int calcPart(int lb, int rb, int *a, int n, int &oldAns,
int &oldAnsCnt) {
static int cnt[maxn + 1];
// 加入这些数在块内的出现次数
for (int i = 1; i <= n; i++) {
cnt[a[i]] =
::cnt[a[i]][rb] -
::cnt[a[i]][lb - 1]; // 注意不能是 +=，因为数可能重复，避免重复加入
}
for (int i = 1; i <= n; i++) {
cnt[a[i]]++; // 统计出现次数
}
int ans = oldAns, ansCnt = oldAnsCnt;
for (int i = 1; i <= n; i++) {
int newCnt = cnt[a[i]];
// 更新答案
if (!ans || newCnt > ansCnt || (newCnt == ansCnt && a[i] < ans)) {
ans = a[i];
ansCnt = newCnt;
}
}
// 清空 cnt
for (int i = 1; i <= n; i++) {
cnt[a[i]] = 0;
}
return ans;
}
// 求块 [lb, rb] 内的答案
inline void blockAns(int lb, int rb, int &ans, int &ansCnt) {
ans = ::ans[lb][rb];
ansCnt = cnt[ans][rb] - cnt[ans][lb - 1]; // 前缀和作差
}
// 查询 [l, r] 间的答案
inline int query(int l, int r) {
int lb = blockID(l), rb = blockID(r);
if (lb == rb || lb + 1 == rb) // 如果两端点在同一块或相邻块，则暴力计算
{
return force(l, r);
}
// 先计算块内的部分
int ans, ansCnt;
// [lb + 1, rb - 1] 是完整的块，lb 和 rb 不是完整的块
blockAns(lb + 1, rb - 1, ans, ansCnt);
// 取出块之外的数
int cnt = 0; // 块之外的数的数量
static int tmp[maxn + 1]; // 块之外的数
int ll, lr;
blockInterval(lb, ll, lr);
// 左半边块之外的
for (int i = l; i <= lr; i++) tmp[++cnt] = a[i];
int rl, rr;
blockInterval(rb, rl, rr);
// 右半边块之外的
for (int i = rl; i <= r; i++) tmp[++cnt] = a[i];
// 计算块外的部分，更新答案
// [lb + 1, rb - 1] 是完整的块
return calcPart(lb + 1, rb - 1, tmp, cnt, ans, ansCnt);
}
int main() {
int m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
discrete();
prepare();
int lastAns = 0; // 上一次的答案
while (m--) {
int l, r;
scanf("%d %d", &l, &r);
// 强制在线
l = (l + lastAns - 1) % n + 1;
r = (r + lastAns - 1) % n + 1;
if (l > r) swap(l, r);
// 将离散化后的值对应到原值
printf("%d\n", lastAns = set[query(l, r)]);
}
return 0;
}
D. 天天爱跑步
首先，对于lcm(w,b)和其倍数，在这些位置上syf和cjy一定是打平的。记这些位置为x。
对于任意x[i]+[0,min(w,b)-1] 的位置上，两人也一定是打平的。
于是我们就求合法范围内所有 x[i]+[0,min(w,b)-1] 的格点数即可。
注意：lcm可能求出会爆long long, 所以需要一些小优化。
#include <iostream>
using namespace std;
typedef long long ll;
ll t, w, b, ans;
ll gcd(ll a, ll b) {
if (!b) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll T;
int main() {;
cin >> T;
while (T--) {
ans = 0;
cin >> t >> w >> b;
ll g = lcm(w, b);
ll mini = min(min(w, b), t + 1);
ans += mini - 1;
ll k = t / w * gcd(w, b) / b;
ans += k * mini;
if (k) {
ll f = t % g;
if (f < mini) {
ans -= mini;
ans += f + 1;
}
}
ll d = gcd(ans, t);
ans /= d;
t /= d;
cout << ans << '/' << t << endl;
}
return 0;
}
E. 愉快的负鼠
如果一个数能被2-10中的所有数整除，那么它仅需满足能被2,3,5,7整除即可，因为其他数都是合数，而合数必然可以表示成若干个素数的乘积。例如如果能被10整除，那么必然能被2和5整除。
推出上述结论后，本题就变成了一个高中组合数学题，最终结果即为：
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
ll ans, n, T;
vector<int> a, f;
int main() {
cin >> T;
while (T--) {
cin >> n;
ans = n - n / 2 - n / 3 - n / 5 - n / 7 + n / (2 * 3) + n / (2 * 5) +
n / (2 * 7) + n / (3 * 5) + n / (3 * 7) + n / (5 * 7) -
n / (2 * 3 * 5) - n / (2 * 3 * 7) - n / (2 * 5 * 7) -
n / (3 * 5 * 7) + n / (2 * 3 * 5 * 7);
cout << ans << endl;
}
return 0;
}
F. Relative Molecular Mass
字符串处理题。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cctype>
using namespace std;
const int CM = 150;
struct Node {
double value;
Node* next[CM];
Node() { value = 0; memset(next, 0, sizeof(next));};
void construct(char* s, double value) {
if (!*s) { this->value = value; return; }
if (!next[*s]) { next[*s] = new Node();}
next[*s]->construct(s + 1, value);
}
} root, *cur;
char *x;
double solve() {
double ret = 0, val = 0;
for (; *x != 0 && *x != ')';) {
if (isalpha(*x)) {
if (cur->next[*x]) {
cur = cur->next[*x];
} else {
ret += val;
val = 0;
cur = root.next[*x];
}
if (cur->value) {
val = cur->value;
}
++x;
} else if (isdigit(*x)) {
int t = 0;
for (; isdigit(*x); ++x) {t *= 10; t += *x - '0';}
if (val) {
ret += val * t;
val = 0;
cur = &root;
} else {
ret += t * solve();
}
} else if (*x == '(') {
++x;
ret += val;
val = solve();
}
}
ret += val;
++x;
return ret;
}
int main() {
int n, k;
double v;
char s[300], t[200];
memset(root.next, 0, sizeof(root.next));
scanf("%d%d", &n, &k);
for (auto i = 0; i < n; i++) {
scanf("%s%lf", s, &v);
root.construct(s, v);
}
for (auto i = 0; i < k; i++) {
scanf("%s", t);
memset(s, 0, sizeof(s));
int j = 0, c = 0;
s[c++] = '(';
for (j = 0; t[j]; j++) {
if (t[j] == '.') {
s[c++] = ')';
s[c++] = '(';
} else {
s[c++] = t[j];
}
}
s[c] = ')';
cur = &root;
x = s;
auto ret = solve();
printf("%.lf\n", ret);
}
return 0;
}
G. 后勤部长的晚会
本题让我们求二分图的不可行边（可行边的补集）。不过，本题不保证二分图的最大匹配是一组完备匹配。
使用Dicnic算法求最大流，Tarjan算法求强连通分量，最后逐一对边进行判定，时间复杂度 O ( E ∗ N + M ) O(E*\sqrt{N+M}) O(E∗N+M)
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#define N 10005
#define M 100005
using namespace std;
int cnt = 1, n, m, t, head[2 * N], ans[M];
int d[2 * N];
int num, dfn[2 * N], low[2 * N], s[2 * N], c[2 * N];
bool vis[2 * N];
struct edge {
int from, to, nxt, size;
} w[3 * M];
void add(int x, int y) {
w[++cnt] = (edge){x, y, head[x], 1};
head[x] = cnt;
w[++cnt] = (edge){y, x, head[y], 0};
head[y] = cnt;
}
bool bfs() {
memset(d, 0, sizeof(d));
queue<int> q;
q.push(n + m + 1);
d[n + m + 1] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = w[i].nxt) {
int y = w[i].to;
if (d[y] || !w[i].size) continue;
d[y] = d[x] + 1;
if (y == n + m + 2) return 1;
q.push(y);
}
}
return 0;
}
int dinic(int x, int flow) {
if (x == n + m + 2) return flow;
int rest = flow;
for (int i = head[x]; i && rest; i = w[i].nxt) {
int y = w[i].to;
if (!w[i].size || d[y] != d[x] + 1) continue;
int k = dinic(y, min(rest, w[i].size));
if (!k) d[y] = 0;
w[i].size -= k;
w[i ^ 1].size += k;
rest -= k;
}
return flow - rest;
}
void tarjan(int x) {
dfn[x] = low[x] = ++num;
s[++s[0]] = x;
vis[x] = 1;
for (int i = head[x]; i; i = w[i].nxt) {
if (!w[i].size) continue;
int y = w[i].to;
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[y], low[x]);
} else if (vis[y])
low[x] = min(dfn[y], low[x]);
}
if (dfn[x] == low[x]) {
c[0]++;
while (1) {
int temp = s[s[0]];
vis[temp] = 0;
c[temp] = c[0];
s[s[0]--] = 0;
if (temp == x) break;
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &t);
for (int i = 1; i <= t; i++) {
int x, y;
scanf("%d %d", &x, &y);
add(x, n + y);
}
for (int i = 1; i <= n; i++) add(n + m + 1, i);
for (int i = 1; i <= m; i++) add(n + i, n + m + 2);
while (bfs()) int temp = dinic(n + m + 1, 0x3f3f3f3f);
for (int i = 1; i <= n + m + 2; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= t; i++) {
int x = w[i * 2].from, y = w[i * 2].to;
if (!w[i * 2].size || c[x] == c[y]) continue;
ans[++ans[0]] = i;
}
printf("%d\n", ans[0]);
for (int i = 1; i <= ans[0]; i++) printf("%d ", ans[i]);
return 0;
}
H.摸鱼1
比较裸的二分。
二分最少需要的天数，然后从1～n枚举每一个判断是否能成立即可。但需要注意左右边界的初始条件。
#include <iostream>
using namespace std;
typedef long long ll;
const int maxn = 100005;
ll T,n,S,W,w[maxn],a[maxn];
bool check(ll x) {
ll res = 0;
for(int i=0;i<n;i++) {
ll k = w[i] + a[i]*x;
if(k>=W) res += k;
if(res>=S) return 1;
}
return 0;
}
int main() {
scanf("%lld",&T);
while(T--) {
scanf("%lld%lld%lld",&n,&S,&W);
for(int i=0;i<n;i++) scanf("%lld",&w[i]);
for(int i=0;i<n;i++) scanf("%lld",&a[i]);
ll l = -1, r = 1e9;
while(l<r-1) {
ll mid = (l+r) / 2;
if(check(mid)) r = mid;
else l = mid;
}
printf("%lld\n",r);
}
return 0;
}
I. 摸鱼2
简单DP，公式见代码
#include <iostream>
#include <cstring>
using namespace std;
const int MOD = 10005;
int dp[3005];
int n, m, T, ans;
int main() {
cin >> T;
while (T--) {
ans = 0;
memset(dp, 0, sizeof(dp));
cin >> n >> m;
dp[0] = 1;
dp[1] = m;
for (int i = 2; i <= n; ++i) {
for (int j = m; j; --j) {
dp[j] = (dp[j] + dp[j - 1] * (m - j + 1)) % MOD;
}
}
for (int i = 0; i <= m; ++i)
ans = (ans + dp[i]) % MOD;
cout << ans << endl;
}
return 0;
}
J. ytF’s cupboard
计算几何。
由于底边长为r，而球的半径为
r
2
\frac{r}{2}
2r，所以可以先两个两个的放。
放到顶端时，我们的问题就在于能否在最顶上的弧下面再放一个。
记圆的半径为 r 2 \frac{r}{2} 2r，可得到 G H = ( 1 − 3 2 ) ∗ r GH=(1-\frac{\sqrt{3}}{2})*r GH=(1−23)∗r，这三个圆堆起来需要的总高度为 2 r − G H 2r-GH 2r−GH ，这样就可以求得最顶上是否还能放一个球。
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &r, &h);
int ans = h / r * 2;
h %= r;
if (h * 2 < r) {
++ans;
} else if (h * 2 >= sqrt(3) * r) {
ans += 3;
} else {
ans += 2;
}
printf("%d\n", ans);
}
return 0;
}
K. 打牌
如果满足条件，那么负鼠的牌数咕值和必然为总和的一半。写个三重for循环即可判断
#include <iostream>
#include <algorithm>
using namespace std;
int a[10];
int n = 6, sum, T;
int main() {
cin >> T;
while (T--) {
sum = 0;
for (int i = 0; i < n; i++) cin >> a[i], sum += a[i];
bool flag = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
if ((a[i] + a[j] + a[k]) * 2 == sum) {
flag = 1;
}
}
}
}
if(flag) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
}
written by 施博文
扫一扫
908
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
