NUIST第一届程序设计大赛团队赛题解

本次比赛，AK两题为签到题，

文章目录

A. 负鼠的追求者
- 解法1
- 解法2
B. Game
- 解法1
- 解法2
C. 犯困的负鼠
D. 天天爱跑步
E. 愉快的负鼠
F. Relative Molecular Mass
G. 后勤部长的晚会
H.摸鱼1
I. 摸鱼2
J. ytF's cupboard
K. 打牌

A. 负鼠的追求者

解法1

求[1,x]中与x互质的最大的数，由于x最大为5000，可以枚举[1,x]中的每个数来依次验证是否满足gcd(i,x)=1，时间复杂度为O(T∗nlog⁡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");elseputs("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");elseputs("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);  // 清空 cntint 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;}}// 清空 cntfor (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，而球的半径为r2\frac{r}{2}2r，所以可以先两个两个的放。

放到顶端时，我们的问题就在于能否在最顶上的弧下面再放一个。

记圆的半径为r2\frac{r}{2}2r，可得到GH=(1−32)∗rGH=(1-\frac{\sqrt{3}}{2})*rGH=(1−23)∗r，这三个圆堆起来需要的总高度为 2r−GH2r-GH2r−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 施博文