aaaluofan 2026-8-5 16:00:22
YIZHIYANG初来乍到 2026-5-24 13:10:59
| 序号 | 题号 | 题目名称 | 标签 | 难度 |
|---|---|---|---|---|
| 1 | B3941 | [GESP样题 五级] 小杨的锻炼 | 数论 最大公约数 gcd |
普及− |
| 2 | B3951 | [GESP样题 五级] 小杨的队列 | 排序 | |
| 3 | B3871 | [GESP202309 五级] 因数分解 | 数论 | |
| 4 | B3968 | [GESP202403 五级] 成绩排序 | 模拟 排序 结构体 |
|
| 5 | B3969 | [GESP202403 五级] B-smooth 数 | 素数判断 质数 筛法 |
|
| 6 | P10720 | [GESP202406 五级] 小杨的幸运数字 | 数论 | |
| 7 | B4051 | [GESP202409 五级] 小杨的武器 | 贪心 | |
| 8 | P13014 | [GESP202506 五级] 最大公因数 | 数学 | |
| 9 | P14073 | [GESP202509 五级] 数字选取 | 数学 贪心 数论 枚举 素数判断 质数 筛法 |
|
| 10 | P15798 | [GESP202603 五级] 有限不循环小数 | 数论 | |
| 11 | P15799 | [GESP202603 五级] 找数 | 二分 离散化 队列 双指针 two-pointer bitset 哈希表 STL |
|
| 12 | B3872 | [GESP202309 五级] 巧夺大奖 | 贪心 | 普及/提高− |
| 13 | B3929 | [GESP202312 五级] 小杨的幸运数 | 二分 筛法 |
|
| 14 | B3930 | [GESP202312 五级] 烹饪问题 | 贪心 位运算 |
|
| 15 | P10719 | [GESP202406 五级] 黑白格 | 数学 二分 前缀和 |
|
| 16 | B4050 | [GESP202409 五级] 挑战怪物 | 贪心 数论 枚举 |
|
| 17 | B4070 | [GESP202412 五级] 奇妙数字 | 数学 数论 |
|
| 18 | B4071 | [GESP202412 五级] 武器强化 | 贪心 线性数据结构 枚举 排序 数组 |
|
| 19 | P11960 | [GESP202503 五级] 平均分配 | 贪心 排序 |
|
| 20 | P13013 | [GESP202506 五级] 奖品兑换 | 二分 整数规划 |
|
| 21 | P14074 | [GESP202509 五级] 有趣的数字和 | 数学 分治 记忆化搜索 数位 DP 进制 组合数学 前缀和 位运算 |
|
| 22 | P14917 | [GESP202512 五级] 数字移动 | 二分 | |
| 23 | P14918 | [GESP202512 五级] 相等序列 | 贪心 数论 素数判断 质数 筛法 |
|
| 24 | P11961 | [GESP202503 五级] 原根判断 | 原根 数论 |
提高+/省选− |
给定长度为 的序列 ，有 次询问，每次给出 ，要求统计 在区间 中出现了多少次。
对每个数值 ，记录它在序列中出现的所有下标，并保持升序。
对于询问 ，只需要在 的下标数组中二分：
也就是：
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, q;
inline void solve() {
cin >> n;
map<int, vector<int> > mp;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
mp[x].push_back(i);
}
cin >> q;
while (q--) {
int l, r, x;
cin >> l >> r >> x;
if (!mp.count(x)) {
printf("0\n");
continue;
}
vector<int> &v = mp[x];
int Ans = upper_bound(v.begin(), v.end(), r) - lower_bound(v.begin(), v.end(), l);
printf("%d\n", Ans);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _ = 1; cin >> _;
while (_--) solve();
return 0;
}
给定一棵 个点的树，部分城市有传送门。任意两个传送门城市之间可以花费 时间互相传送。每次询问从 到 的最短时间。
从 到 有两种方案：
其中 表示点 到最近传送门的树上距离。
所以答案为：
树上距离用 求，最近传送门距离用多源 求。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 2e5 + 10, inf = 1e9 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, k, q;
vector<int> G[N];
int dep[N], fa[20][N];
int dis[N];
void bfs_dep() {
queue<int> que;
que.push(1);
dep[1] = 1;
fa[0][1] = 1;
while (!que.empty()) {
int u = que.front();
que.pop();
for (int v : G[u]) {
if (v == fa[0][u]) continue;
fa[0][v] = u;
dep[v] = dep[u] + 1;
que.push(v);
}
}
for (int j = 1; j < 20; j++) {
for (int i = 1; i <= n; i++) {
fa[j][i] = fa[j - 1][fa[j - 1][i]];
}
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int d = dep[x] - dep[y];
for (int j = 19; j >= 0; j--) {
if ((d >> j) & 1) x = fa[j][x];
}
if (x == y) return x;
for (int j = 19; j >= 0; j--) {
if (fa[j][x] != fa[j][y]) {
x = fa[j][x];
y = fa[j][y];
}
}
return fa[0][x];
}
int dist(int x, int y) {
int z = lca(x, y);
return dep[x] + dep[y] - 2 * dep[z];
}
inline void solve() {
cin >> n >> k >> q;
for (int i = 1, x, y; i < n; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
bfs_dep();
queue<int> que;
for (int i = 1; i <= n; i++) dis[i] = inf;
for (int i = 1, x; i <= k; i++) {
cin >> x;
dis[x] = 0;
que.push(x);
}
while (!que.empty()) {
int u = que.front();
que.pop();
for (int v : G[u]) {
if (dis[v] > dis[u] + 1) {
dis[v] = dis[u] + 1;
que.push(v);
}
}
}
while (q--) {
int u, v;
cin >> u >> v;
int Ans = dist(u
给定一个 的邻接矩阵，表示 个迷宫之间是否可以直接到达。对于指定迷宫 ，要求输出：
注意每个迷宫都可以直接到达自己。
邻接矩阵中：
所以直接统计第 行和第 列中 的个数即可。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e3 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, m;
int a[N][N];
inline void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
int out = 0, in = 0;
for (int j = 1; j <= n; j++) if (a[m][j]) out++;
for (int i = 1; i <= n; i++) if (a[i][m]) in++;
printf("%d %d %d\n", out, in, out + in);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _ = 1;
while (_--) solve();
return 0;
}
给定一个有向无环图，每个点有一个点权 。对于图中的任意一条路径，可以得到路径上的点权序列。要求在所有路径中，求最长不下降子序列的最大长度。点权满足 。
因为图是 ，可以拓扑排序。
由于点权只有 ，可以对每个点维护一个数组：
表示走到点 时，已经得到的最长不下降子序列中，最后一个被选中的值为 的最大长度。
处理点 时，可以选择把 加入子序列。若 ，则可以从所有 的状态转移过来：
然后把 的状态沿有向边传播给后继点。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, m;
int a[N], deg[N];
int dp[N][11];
vector<int> g[N];
inline void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
deg[v]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (!deg[i]) q.push(i);
}
int Ans = 0;
while (!q.empty()) {
int u = q.front(); q.pop();
int w = a[u], best = 0;
for (int v = 1; v <= w; v++) best = max(best, dp[u][v]);
dp[u][w] = max(dp[u][w], best + 1);
for (int v = 1; v <= 10; v++) Ans = max(Ans, dp[u][v]);
for (int to : g[u]) {
for (int v = 1; v <= 10; v++) {
dp[to][v] = max(dp[to][v], dp[u][v]);
}
deg[to]--;
if (!deg[to]) q.push(to);
}
}
printf("%d\n", Ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _ = 1;
while (_--) solve();
return 0;
}
有 种商品，每种商品有价值 。若某个商人支持用商品 换商品 ，则你可以从 变成 。交换时还要支付：
其中 是手续费。现在你初始拥有商品 ，希望得到商品 ，求最少花费；若无法得到，输出 。
一条路径：
总费用为：
$$(v_{p_1}-v_a+1)+(v_{p_2}-v_{p_1}+1)+\cdots+(v_b-v_{last}+1) $$中间价值会全部抵消，得到：
因此只需要求从 到 的最少边数。
用 求最短路边数即可。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, m, a, b;
一共有 个台阶，每一步可以走 个、 个或 个台阶。求走完 个台阶共有多少种不同方案。
设 表示走到第 个台阶的方案数。
最后一步可能来自：
因此：
初始化：
表示一个台阶都不走有 种方案。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
LL f[N];
int n;
inline void solve() {
cin >> n;
f[0] = 1;
for (int i = 1; i <= n; i++) {
if (i - 1 >= 0) f[i] += f[i - 1];
if (i - 2 >= 0) f[i] += f[i - 2];
if (i - 3 >= 0) f[i] += f[i - 3];
}
printf("%lld\n", f[n]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _ = 1;
while (_--) solve();
return 0;
}
给定一个数字串 和正整数 ，统计 的所有连续子串中，有多少个子串对应的整数是 的倍数。子串允许有前导零，相同内容但位置不同的子串算不同子串。
设 表示当前处理到某个位置之前，所有 以当前位置前一位结尾 的子串中，模 余数为 的个数。
读入新数字 后：
每处理一位，就把当前余数为 的子串数量加入答案。
因为 ，所以每个字符枚举所有余数即可。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int p;
string s;
LL cnt[N], tmp[N];
inline void solve() {
cin >> p >> s;
LL Ans = 0;
for (char ch : s) {
int d = ch - '0';
for (int i = 0; i < p; i++) tmp[i] = 0;
tmp[d % p]++;
for (int r = 0; r < p; r++) {
int nr = (r * 10 + d) % p;
tmp[nr] += cnt[r];
}
Ans += tmp[0];
for (int i = 0; i < p; i++) cnt[i] = tmp[i];
}
printf("%lld\n", Ans);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _ = 1;
while (_--) solve();
return 0;
}
有 种饮料，每种饮料最多买一瓶。第 种饮料价格为 ，容量为 。小杨希望购买的总容量不低于 ，并且花费最少。如果无法满足要求，输出 。
这是一个 背包问题。
设 表示买到总容量为 时的最小花费。因为只关心是否达到 ，所以容量超过 的都压缩成 。
对于每瓶饮料，倒序更新：
$$dp_{\min(L,j+l_i)}=\min(dp_{\min(L,j+l_i)},dp_j+c_i) $$最后如果 仍然是无穷大，说明无解。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
const LL inf = 4e18;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, L;
LL dp[N];
inline void solve() {
cin >> n >> L;
for (int i = 0; i <= L; i++) dp[i] = inf;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
LL c, l; cin >> c >> l;
for (int j = L; j >= 0; j--) {
if (dp[j] == inf) continue;
int nj = min((LL)L, j + l);
dp[nj] = min(dp[nj], dp[j] + c);
}
}
if (dp[L] == inf) printf("no solution\n");
else printf("%lld\n", dp[L]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int _ = 1;
while (_--) solve();
return 0;
}
有 名同学，学号为 到 。他们按给定顺序进入教室。每位同学进入时，会和已经在教室内且学号小于自己的同学握手。求总握手次数。
班级里有 名同学，第 名同学每隔 天锻炼一次。某一天所有同学都一起锻炼了，求下一次所有同学再次一起锻炼至少要过多少天。
所有同学再次同时锻炼的时间，必须同时是所有 的倍数。
所以答案就是：
由于 ，但多个数的最小公倍数可能比较大，记得使用 防止溢出。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
LL gcd(LL a, LL b) {
while (b) {
LL t = a % b;
a = b;
b = t;
}
return a;
}
int n;
inline void solve() {
cin >> n;
LL Ans = 1;
for (int i = 1; i <= n; i++) {
LL x; cin >> x;
LL g = gcd((LL)(Ans % x), x);
Ans = Ans / g * x;
}
printf("%lld\n", Ans);
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
有 名同学，每名同学有一个身高。老师依次点名若干名同学入队。每次新同学先站到队尾，然后队伍要按身高从低到高重新排序。问每次新同学加入后，最少需要交换几次位置。
每次加入新同学前，队伍已经是有序的。
新同学站到队尾后，要移动到合适位置。需要越过所有比他高的同学。
由于允许交换任意两名同学，最少交换次数等于当前队伍中身高大于新同学的人数。
所以每次统计已经入队的同学中，有多少人的身高大于当前同学即可。
不过数据存在相同元素，所以还需要进行标记， 所以使用 进行标记。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, m;
LL h[N];
vector<int> q;
map<LL, int> mp;
inline void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> h[i];
cin >> m;
for (int i = 1, x; i <= m; i++) {
cin >> x;
int Ans = 0;
for (int id : q) {
if (mp[h[id]] == 0 && h[id] > h[x]) Ans++;
mp[h[id]] = 1;
}
printf("%d\n", Ans);
q.push_back(x);
mp.clear();
}
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
给定一个正整数 ，输出它的质因数分解式。
例如：
输出格式中乘号用 表示，指数用 \texttt{^} 表示。
从 开始枚举可能的质因数 。
如果 能整除当前的 ，就不断除以 ，统计 出现了多少次。
最后如果剩下的 ，说明它本身是一个质因数。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
LL n;
vector<pair<LL, int> > v;
inline void solve() {
cin >> n;
for (LL i = 2; i * i <= n; i++) {
if (n % i == 0) {
int cnt = 0;
while (n % i == 0) {
n /= i;
cnt++;
}
v.push_back({i, cnt});
}
}
if (n > 1) v.push_back({n, 1});
for (int i = 0; i < (int)v.size(); i++) {
if (i) printf(" * ");
printf("%lld", v[i].first);
if (v[i].second > 1) {
printf("^%d", v[i].second);
}
}
printf("\n");
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
有 个小游戏和 个时间段。每个小游戏需要 个时间段完成，第 个小游戏必须在第 个时间段结束前完成，完成后获得奖励 。求最多能获得多少奖励。
这是经典的 带截止时间的单位任务调度 。
贪心策略：
优先考虑奖励高的游戏。
对于每个游戏，尽量安排在不超过截止时间的最晚空闲时间段。
这样可以给后面的游戏留下更靠前的时间段。
如果一个两位数本身是素数，并且交换十位和个位后仍然是素数，则称为 绝对素数。给定 ，输出区间 中所有绝对素数。
枚举 到 中的每个数 。
判断两个条件：
交换数字可以这样做：
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
bool pri(int x) {
if (x < 2) return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
int a, b;
inline void solve() {
cin >> a >> b;
for (int x = a; x <= b; x++) {
int y = x % 10 * 10 + x / 10;
if (pri(x) && pri(y)) {
printf("%d\n", x);
}
}
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
给定一个奇数 ，按照题目给出的规则构造一个 的幻方。规则是先把 填在第一行正中央，然后不断尝试向右上方移动，如果右上方已经有数，则改为向下移动。
使用二维数组模拟。
当前位置为 。
每次填完当前数字后，尝试移动到：
如果这个位置没有填过，就移动过去；否则移动到当前格子的下一行：
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e2 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, a[N][N];
inline void solve() {
cin >> n;
int r = 0;
int c = n / 2;
for (int x = 1; x <= n * n; x++) {
a[r][c] = x;
int nr = (r - 1 + n) % n;
int nc = (c + 1) % n;
if (a[nr][nc] == 0) {
r = nr;
c = nc;
} else {
r = (r + 1) % n;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j) printf(" ");
printf("%d", a[i][j]);
}
printf("\n");
}
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
一个正整数从个位开始编号，个位是第 位。偶数位不变，奇数位要乘以 ，如果结果大于 ，就不断求数位和直到变成一位数。最后把所有变换后的数字求和，如果和是 的倍数，则这个数是幸运数。
因为数字小于 ，可以直接用字符串处理。
从右往左枚举每一位：
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int digsum(int x) {
int s = 0;
while (x > 0) {
s += x % 10;
x /= 10;
}
return s;
}
int trans(int d) {
int x = d * 7;
while (x > 9) {
x = digsum(x);
}
return x;
}
string s;
inline void solve() {
cin >> s;
int sum = 0;
int pos = 1;
for (int i = (int)s.size() - 1; i >= 0; i--) {
int d = s[i] - '0';
if (pos % 2 == 1) sum += trans(d);
else sum += d;
pos++;
}
if (sum % 8 == 0) printf("T\n");
else printf("F\n");
}
int main() {
int _ = 1; cin >> _;
while (_--) solve();
return 0;
}
给定一幅 级灰阶图像，每个像素由两位十六进制表示。现在要压缩成 级灰阶：先选出出现次数最多的 种灰阶，次数相同则灰阶值小的优先。其他灰阶转换到这 种灰阶中灰度值最接近的一种；若距离相同，则选编号较小的。
步骤如下：
小明有 元钱，依次遇到 件想买的物品。
如果当前钱够买某件物品，就买下来，并扣掉对应价格；否则跳过。
求最后一共买了多少件物品。
按顺序模拟即可。
对于每个价格 ：
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, a[N], x;
inline void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> x;
int Ans = 0;
for (int i = 1; i <= n; i++) {
if (x >= a[i]) {
x -= a[i];
Ans++;
}
}
printf("%d\n", Ans);
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
给定十进制正整数 和进制 ，其中 ，输出 的 进制表示。
超过 的数字用大写字母表示：
不断对 取余。
例如：
就是当前最低位。
然后令：
继续处理。
由于先得到的是低位，所以最后要反转字符串。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
char gc(int x) {
if (x <= 9) return char('0' + x);
return char('A' + x - 10);
}
int n, r;
inline void solve() {
cin >> n >> r;
string Ans;
while (n > 0) {
Ans += gc(n % r);
n /= r;
}
reverse(Ans.begin(), Ans.end());
cout << Ans << '\n';
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
班上有 位同学，编号为 到 。 集合时，同学们一共报出了 次编号，已经到达的同学可能会重复报编号。 要求输出没有到达的同学编号。
如果所有同学都到了，输出 。
用数组 记录某个编号是否出现过。
读入每个编号 后，令：
vis[x] = true;
最后从 到 检查哪些编号没有出现。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n, m, vis[N];
inline void solve() {
cin >> n >> m;
for (int i = 1, x; i <= m; i++) {
cin >> x;
vis[x] = 1;
}
bool all = true;
bool first = true;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
all = false;
if (!first) printf(" ");
printf("%d", i);
first = false;
}
}
if (all) printf("%d\n", n);
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
输入一个用英文逗号分隔的字符串，每一段都是一个待检测密码。 合规密码需要满足：
输出所有合规密码。
先按照逗号 把字符串切分成多个密码。
对每个密码检查：
如果满足条件，就输出。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x 
输入 ，输出一个 的大写字母正方形。第 行第 列从 开始，每往右一个位置字母后移一位；下一行开头也比上一行开头后移一位； 后面回到 。
第 行第 列的字母偏移量是：
所以字符为：
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n;
inline void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
char ch = 'A' + (i + j - 2) % 26;
printf("%c", ch);
}
printf("\n");
}
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
给定 ，统计有多少组三元组 满足：
并且：
这样的三元组叫做勾股数。
枚举 和 ，计算：
如果 是完全平方数，并且 ，则找到一组答案。
注意要求 ，所以枚举时令 从 开始。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n;
inline void solve() {
cin >> n;
int Ans = 0;
for (int a = 1; a <= n; a++) {
for (int b = a; b <= n; b++) {
int c2 = a * a + b * b;
int c = sqrt(c2);
if (c * c == c2 && c <= n) Ans++;
}
}
printf("%d\n", Ans);
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
每只公鸡 元，每只母鸡 元，每 只小鸡 元。现在有 元，要买 只鸡，问共有多少种购买方案。
设公鸡数量为 ，母鸡数量为 ，小鸡数量为 。
需要满足：
并且：
由于每 只小鸡 元，所以 必须是 的倍数。
直接枚举公鸡和母鸡数量，小鸡数量由 得出。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int x, y, z, n, m;
inline void solve() {
cin >> x >> y >> z >> n >> m;
int Ans = 0;
for (int a = 0; a <= m; a++) {
for (int b = 0; b <= m - a; b++) {
int c = m - a - b;
if (c % z == 0) {
int cost = a * x + b * y + c / z;
if (cost == n) Ans++;
}
}
}
printf("%d\n", Ans);
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
输入 ，输出一个由大写字母组成的三角形。第 行 个字母，第 行 个字母，依此类推。字母从 到 循环使用。
用一个变量记录当前应该输出的字母编号。
每输出一个字符，编号加 。
编号对 取模即可实现 到 的循环。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int n;
inline void solve() {
cin >> n;
int Now = 0;
for
给定起始年份和终止年份，求它们之间 不包含起始年份和终止年份 的所有闰年年份之和。
闰年判断规则：
如果年份能被 整除，或者能被 整除但不能被 整除，则是闰年。
从 枚举到 ，判断是否为闰年，是就累加。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int a, b;
bool ok(int y) {
return y % 400 == 0 || (y % 4 == 0 && y % 100 != 0);
}
inline void solve() {
cin >> a >> b;
int Ans = 0;
for (int y = a + 1; y <= b - 1; y++) {
if (ok(y)) Ans += y;
}
printf("%d\n", Ans);
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
输入一个时刻的时、分、秒，以及字符 或 。 表示上午， 表示下午。求这个时刻是当天的第几秒。
把时、分、秒统一转成秒。
如果是下午 ，小时数要加 。
答案为：
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int h, m, s;
char c;
inline void solve() {
cin >> h >> m >> s >> c;
if (c == 'P') h += 12;
printf("%d\n", (h * 3600 + m * 60 + s));
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
给定长方形面积 ，求有多少种长和宽都是整数的长方形。要求长大于等于宽。
如果 是面积 的因数，那么可以令宽为 ，长为 。
由于要求长大于等于宽，只需要枚举 从 到 。
如果 ，就找到一种。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int A;
inline void solve() {
cin >> A;
int Ans = 0;
for (int i = 1; i * i <= A; i++) {
if (A % i == 0) Ans++;
}
printf("%d\n", Ans);
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
输入年份和月份，输出这个月有多少天。
普通月份天数固定。
二月需要判断闰年：
闰年二月 天，平年二月 天。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();
while (ch < '0' || ch > '9') {if (ch == '-') f = -1; ch = getchar();}
while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
return x * f;
}
int y, m;
bool ok(int y) {
return y % 400 == 0 || (y % 4 == 0 && y % 100 != 0);
}
inline void solve() {
cin >> y >> m;
if (m == 2) {
if (ok(y)) printf("29\n");
else printf("28\n");
} else if (m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10 || m == 12) {
printf("31\n");
} else {
printf("30\n");
}
}
int main() {
int _ = 1;
while (_--) solve();
return 0;
}
输入开始时刻和结束时刻，求中间相差多少分钟。
把两个时刻都转成 从当天 点开始经过的分钟数 。
然后用结束分钟数减去开始分钟数。
#include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long LL;
const int N = 1e6 + 10;
int read(){
int x = 0,f = 1; char ch = getchar();