- 跳一跳
问题描述
近来，跳一跳这款小游戏风靡全国，受到不少玩家的喜爱。
简化后的跳一跳规则如下：玩家每次从当前方块跳到下一个方块，如果没有跳到下一个方块上则游戏结束。
如果跳到了方块上，但没有跳到方块的中心则获得1分；跳到方块中心时，若上一次的得分为1分或这是本局游戏的第一次跳跃则此次得分为2分，否则此次得分比上一次得分多两分（即连续跳到方块中心时，总得分将+2，+4，+6，+8…）。
现在给出一个人跳一跳的全过程，请你求出他本局游戏的得分（按照题目描述的规则）。
输入格式
输入包含多个数字，用空格分隔，每个数字都是1，2，0之一，1表示此次跳跃跳到了方块上但是没有跳到中心，2表示此次跳跃跳到了方块上并且跳到了方块中心，0表示此次跳跃没有跳到方块上（此时游戏结束）。
输出格式
输出一个整数，为本局游戏的得分（在本题的规则下）。
样例输入
1 1 2 2 2 1 1 2 2 0
样例输出
22
数据规模和约定
对于所有评测用例，输入的数字不超过30个，保证0正好出现一次且为最后一个数字。
代码：
#include <iostream>
using namespace std;
const int MAXN = 40;
int arr[40];
int main(){
int a, pre = 0, ans = 0;
while(cin >> a && a){
if(a == 1)
ans += 1, pre = 1;
else{
if(pre == 1 || pre == 0)
pre = 2;
else
pre += 2;
ans += pre;
}
}
cout << ans << endl;
return 0;
}
- 碰撞的小球
问题描述
数轴上有一条长度为L（L为偶数)的线段，左端点在原点，右端点在坐标L处。有n个不计体积的小球在线段上，开始时所有的小球都处在偶数坐标上，速度方向向右，速度大小为1单位长度每秒。
当小球到达线段的端点（左端点或右端点）的时候，会立即向相反的方向移动，速度大小仍然为原来大小。
当两个小球撞到一起的时候，两个小球会分别向与自己原来移动的方向相反的方向，以原来的速度大小继续移动。
现在，告诉你线段的长度L，小球数量n，以及n个小球的初始位置，请你计算t秒之后，各个小球的位置。
提示
因为所有小球的初始位置都为偶数，而且线段的长度为偶数，可以证明，不会有三个小球同时相撞，小球到达线段端点以及小球之间的碰撞时刻均为整数。
同时也可以证明两个小球发生碰撞的位置一定是整数（但不一定是偶数）。
输入格式
输入的第一行包含三个整数n, L, t，用空格分隔，分别表示小球的个数、线段长度和你需要计算t秒之后小球的位置。
第二行包含n个整数a1, a2, …, an，用空格分隔，表示初始时刻n个小球的位置。
输出格式
输出一行包含n个整数，用空格分隔，第i个整数代表初始时刻位于ai的小球，在t秒之后的位置。
样例输入
3 10 5
4 6 8
样例输出
7 9 9
样例说明
初始时，三个小球的位置分别为4, 6, 8。
一秒后，三个小球的位置分别为5, 7, 9。
两秒后，第三个小球碰到墙壁，速度反向，三个小球位置分别为6, 8, 10。
三秒后，第二个小球与第三个小球在位置9发生碰撞，速度反向（注意碰撞位置不一定为偶数），三个小球位置分别为7, 9, 9。
四秒后，第一个小球与第二个小球在位置8发生碰撞，速度反向，第三个小球碰到墙壁，速度反向，三个小球位置分别为8, 8, 10。
五秒后，三个小球的位置分别为7, 9, 9。
样例输入
10 22 30
14 12 16 6 10 2 8 20 18 4
样例输出
6 6 8 2 4 0 4 12 10 2
数据规模和约定
对于所有评测用例，1 ≤ n ≤ 100，1 ≤ t ≤ 100，2 ≤ L ≤ 1000，0 < ai < L。L为偶数。
保证所有小球的初始位置互不相同且均为偶数。
代码：
#include <iostream>
using namespace std;
const int N = 110, M = 1010;
struct node{
int x, fx;
node():x{-1}, fx{1} {};
};
node arr[N];
int seats[M];
int n, L, t;
int main(){
cin >> n >> L >> t;
for(int i = 1; i <= n; i ++){
cin >> arr[i].x;
seats[arr[i].x] = i;
}
while(t --){
for(int i = 1; i <= n; i ++){
int &x = arr[i].x;
seats[x] = 0;
x += arr[i].fx;
if(x == L || x == 0)
arr[i].fx = -arr[i].fx;
if(seats[x])
arr[i].fx = -arr[i].fx, arr[seats[x]].fx = -arr[seats[x]].fx;
seats[x] = i;
}
}
for(int i = 1; i <= n; i ++)
cout << arr[i].x << " ";
return 0;
}
- URL映射
问题描述
URL 映射是诸如 Django、Ruby on Rails 等网页框架 (web frameworks) 的一个重要组件。对于从浏览器发来的 HTTP 请求，URL 映射模块会解析请求中的 URL 地址，并将其分派给相应的处理代码。现在，请你来实现一个简单的 URL 映射功能。
本题中 URL 映射功能的配置由若干条 URL 映射规则组成。当一个请求到达时，URL 映射功能会将请求中的 URL 地址按照配置的先后顺序逐一与这些规则进行匹配。当遇到第一条完全匹配的规则时，匹配成功，得到匹配的规则以及匹配的参数。若不能匹配任何一条规则，则匹配失败。
本题输入的 URL 地址是以斜杠 / 作为分隔符的路径，保证以斜杠开头。其他合法字符还包括大小写英文字母、阿拉伯数字、减号 -、下划线 _ 和小数点 .。例如，/person/123/ 是一个合法的 URL 地址，而 /person/123? 则不合法（存在不合法的字符问号 ?）。另外，英文字母区分大小写，因此 /case/ 和 /CAse/ 是不同的 URL 地址。
对于 URL 映射规则，同样是以斜杠开始。除了可以是正常的 URL 地址外，还可以包含参数，有以下 3 种：
字符串 ：用于匹配一段字符串，注意字符串里不能包含斜杠。例如，abcde0123。
整数 ：用于匹配一个不带符号的整数，全部由阿拉伯数字组成。例如，01234。
路径：用于匹配一段字符串，字符串可以包含斜杠。例如，abcd/0123/。
以上 3 种参数都必须匹配非空的字符串。简便起见，题目规定规则中 和 前面一定是斜杠，后面要么是斜杠，要么是规则的结束（也就是该参数是规则的最后一部分）。而的前面一定是斜杠，后面一定是规则的结束。无论是 URL 地址还是规则，都不会出现连续的斜杠。
输入格式
输入第一行是两个正整数 n 和 m，分别表示 URL 映射的规则条数和待处理的 URL 地址个数，中间用一个空格字符分隔。
第 2 行至第 n+1 行按匹配的先后顺序描述 URL 映射规则的配置信息。第 i+1 行包含两个字符串 pi 和 ri，其中 pi 表示 URL 匹配的规则，ri 表示这条 URL 匹配的名字。两个字符串都非空，且不包含空格字符，两者中间用一个空格字符分隔。
第 n+2 行至第 n+m+1 行描述待处理的 URL 地址。第 n+1+i 行包含一个字符串 qi，表示待处理的 URL 地址，字符串中不包含空格字符。
输出格式
输入共 m 行，第 i 行表示 qi 的匹配结果。如果匹配成功，设匹配了规则 pj ，则输出对应的 rj。同时，如果规则中有参数，则在同一行内依次输出匹配后的参数。注意整数参数输出时要把前导零去掉。相邻两项之间用一个空格字符分隔。如果匹配失败，则输出 404。
样例输入
5 4
/articles/2003/ special_case_2003
/articles// year_archive
/articles/// month_archive
/articles article_detail
/static/static_serve
/articles/2004/
/articles/1985/09/aloha/
/articles/hello/
/static/js/jquery.js
样例输出
year_archive 2004
article_detail 1985 9 aloha
404
static_serve js/jquery.js
样例说明
对于第 1 个地址 /articles/2004/，无法匹配第 1 条规则，可以匹配第 2 条规则，参数为 2004。
对于第 2 个地址 /articles/1985/09/aloha/，只能匹配第 4 条规则，参数依次为 1985、9（已经去掉前导零）和 aloha。
对于第 3 个地址 /articles/hello/，无法匹配任何一条规则。
对于第 4 个地址 /static/js/jquery.js，可以匹配最后一条规则，参数为 js/jquery.js。
数据规模和约定
1 ≤ n ≤ 100，1 ≤ m ≤ 100。
所有输入行的长度不超过 100 个字符（不包含换行符）。
保证输入的规则都是合法的。
代码：
#include <iostream>
#include <string>
#include <vector>
using namespace std;
const int N = 110;
struct node {
string name;
vector<string> v;
bool op{}; //末尾是否有 /
node() {
op = false;
}
};
node arr[N];
int n, m;
void deal(node &a, const string &s) {
int pos = 1; //跳过第一个 /
int len;
a.op = s.back() == '/';
while (pos < s.length()) {
len = 0;
while (pos + len < s.length() && s[pos + len] != '/')
++len;
a.v.push_back(s.substr(pos, len));
pos += len + 1;
}
}
bool check(node &tmp, node &a, vector<string> &ans) {
//合法性检查
if (a.v.size() && a.v.back() != "<path>" && a.op != tmp.op)
return false;
int pos = 0, i = 0;
for (; i < tmp.v.size() && pos < a.v.size(); i++, pos++) {
string &s = tmp.v[i];
if (a.v[pos] == s) {
continue;
} else {
if (a.v[pos] == "<int>") {
for (char c : s)
if (!isdigit(c))
return false;
//去除前导 0
int k = 0;
//保留一位 考虑全部都是0的情况
while (k + 1 < s.length() && s[k] == '0')
++k;
ans.push_back(s.substr(k));
} else if (a.v[pos] == "<str>") {
ans.push_back(s);
} else if (a.v[pos] == "<path>") {
string t;
for (; i < tmp.v.size(); i++)
t += tmp.v[i] + '/';
if (!tmp.op)
t.pop_back();
ans.push_back(t);
return true;
} else {
return false;
}
}
}
return i == tmp.v.size() && pos == a.v.size();
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
arr[i].name = b;
deal(arr[i], a);
}
while (m--) {
node tmp;
string s;
bool op = false;
cin >> s;
deal(tmp, s);
for (int i = 0; i < n && !op; i++) {
node &a = arr[i];
vector<string> ans;
if (check(tmp, a, ans)) {
cout << a.name << " ";
for (const string &ss : ans)
cout << ss << " ";
cout << endl;
op = true;
}
}
if (!op)
cout << "404" << endl;
}
return 0;
}
- 棋局评估
问题描述
Alice和Bob正在玩井字棋游戏。
井字棋游戏的规则很简单：两人轮流往3*3的棋盘中放棋子，Alice放的是“X”，Bob放的是“O”，Alice执先。当同一种棋子占据一行、一列或一条对角线的三个格子时，游戏结束，该种棋子的持有者获胜。当棋盘被填满的时候，游戏结束，双方平手。
Alice设计了一种对棋局评分的方法：
- 对于Alice已经获胜的局面，评估得分为(棋盘上的空格子数+1)；
- 对于Bob已经获胜的局面，评估得分为 -(棋盘上的空格子数+1)；
- 对于平局的局面，评估得分为0；
例如上图中的局面，Alice已经获胜，同时棋盘上有2个空格，所以局面得分为2+1=3。
由于Alice并不喜欢计算，所以他请教擅长编程的你，如果两人都以最优策略行棋，那么当前局面的最终得分会是多少？
输入格式
输入的第一行包含一个正整数T，表示数据的组数。
每组数据输入有3行，每行有3个整数，用空格分隔，分别表示棋盘每个格子的状态。0表示格子为空，1表示格子中为“X”，2表示格子中为“O”。保证不会出现其他状态。
保证输入的局面合法。(即保证输入的局面可以通过行棋到达，且保证没有双方同时获胜的情况)
保证输入的局面轮到Alice行棋。
输出格式
对于每组数据，输出一行一个整数，表示当前局面的得分。
样例输入
3
1 2 1
2 1 2
0 0 0
2 1 1
0 2 1
0 0 2
0 0 0
0 0 0
0 0 0
样例输出
3
-4
0
样例说明
第一组数据：
Alice将棋子放在左下角(或右下角)后，可以到达问题描述中的局面，得分为3。
3为Alice行棋后能到达的局面中得分的最大值。
第二组数据：
Bob已经获胜(如图)，此局面得分为-(3+1)=-4。
第三组数据：
井字棋中若双方都采用最优策略，游戏平局，最终得分为0。
数据规模和约定
对于所有评测用例，1 ≤ T ≤ 5。
代码：
#include <iostream>
using namespace std;
int arr[3][3];
inline int cal() {
int cnt = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
if (arr[i][j] == 0)
++cnt;
return cnt;
}
//op为1代表先手
int dfs(int p) {
//判断是否获胜
int q = 3 - p;
bool op = false;
for (int i = 0; i < 3; i++) {
bool t = true;
for (int j = 0; j < 3; j++)
if (arr[i][j] != q)
t = false;
if (t)
op = true;
}
for (int i = 0; i < 3; i++) {
bool t = true;
for (int j = 0; j < 3; j++)
if (arr[j][i] != q)
t = false;
if (t)
op = true;
}
op |= (arr[0][0] == q && arr[1][1] == q && arr[2][2] == q) || (arr[2][0] == q && arr[1][1] == q && arr[0][2] == q);
if (op) {
int t = cal() + 1;
//考虑到上一个对手
return q == 1 ? t : -t;
}
//填满了
if (cal() == 0)
return 0;
int a = -10, b = 10;
//回溯dfs
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (arr[i][j])
continue;
arr[i][j] = p;
int t = dfs(3 - p);
a = max(a, t);
b = min(b, t);
arr[i][j] = 0;
}
}
if (p == 1)
return a;
else
return b;
}
int main() {
int T;
cin >> T;
while (T--) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
cin >> arr[i][j];
cout << dfs(1) << endl;
}
return 0;
}
- 二次求和
问题描述
给一棵 n 个节点的树，用 1 到 n 的整数表示。每个节点上有一个整数权值 ai。再给出两个整数 L,R。现在有 m 个操作，每个操作这样描述：
给定树上两个节点 u,v 和一个整数 d，表示将树上 u 到 v 唯一的简单路径上每个点的权值 ai 都加上 d。之后求树上所有节点个数大于等于 L 小于等于 R 的简单路径的节点权值和之和。注意这里有两次求和：对于一条节点个数大于等于 L 小于等于 R 的简单路径，求出它所有节点的权值之和；然后对所有这样的路径，对它们的权值和再进行求和。因为答案很大，只用输出对Q=1,000,000,007 取余的结果即可。
输入格式
从标准输入读入数据。
包含多组数据。数据的第一行包含一个正整数 T，表示数据组数。保证 T=10。
每组数据的第一行包含 4 个非负整数 n,m,L,R，分别表示节点个数、操作个数和询问相关的两个参数。保证 1≤L≤R≤n。
第二行包含 n 个整数，表示 ai。保证 0≤ai<Q。
第三行包含 n-1 个整数，描述树的形态，其中第 i 个数 fi 表示节点 i+1 与节点 fi 之间有一条边，保证 1≤fi≤i<n。能够证明，这样能够保证给出的是一棵树。
接下来 m 行，每行包含三个整数 u,v,d，描述一个操作即将树上 u 到 v 唯一的简单路径上每个点的权值 ai 都加上 d，之后询问满足条件的两次求和的结果。保证 1≤u,v≤n，0≤d<Q。
保证上述同一行所有的数之间，均用一个空格隔开。
输出格式
输出到标准输出。
输出 m 行每行一个整数，表示两次求和的结果对 Q=1000000007 求余的结果。
子任务
共有 10 个测试点，各测试点特点如下：
测试点1：n=10，m=10。
测试点2：n=50，m=50。
测试点3：n=300，m=300。
测试点4：n=2000，m=2000。
测试点5：n=2000，m=100000。
测试点6：n=100000，m=100000。保证 fi=i。
测试点7：n=100000，m=100000。保证 fi=⌊(i+1)/2⌋，其中 ⌊⋅⌋ 表示向下取整，即给定的树是完全二叉树。
测试点8：n=100000，m=100000。保证对于同一组数据，相同的 fi 至多出现 2 次，即给定的树是二叉树。
测试点9：n=100000，m=100000。
测试点10：n=100000，m=100000。
上述约束对同一测试点中的每组数据都有效。
代码：
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 100010, M = N * 2, MOD = 1e9 + 7;
int n, m, L, R;
int w[N];
int h[N], father[N], e[M], ne[M], idx;
int depth[N], fa[N][17];
int path[N], d[N], que[N];
int pos[N], root[N];
bool st[N];
int tr[N];
struct Node
{
int d, w, id;
bool operator< (const Node& t) const
{
return d < t.d;
}
}q[N], p[N];
inline void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
inline int lowbit(int x)
{
return x & -x;
}
inline void update(int x, int v, int k)
{
for (int i = x; i <= k; i += lowbit(i)) tr[i] = (tr[i] + v) % MOD;
}
inline int query(int x, int k)
{
x = min(x, k);
int res = 0;
for (int i = x; i > 0; i -= lowbit(i)) res = (res + tr[i]) % MOD;
return res;
}
void bfs()
{
memset(depth, 0x3f, sizeof depth);
depth[0] = 0, depth[1] = 1;
int hh = 0, tt = 0;
que[0] = 1;
while (hh <= tt)
{
int t = que[hh ++ ];
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (depth[j] > depth[t] + 1)
{
depth[j] = depth[t] + 1;
que[ ++ tt] = j;
fa[j][0] = t;
for (int k = 1; k <= 16; k ++ )
fa[j][k] = fa[fa[j][k - 1]][k - 1];
}
}
}
}
inline int lca(int a, int b)
{
if (depth[a] < depth[b]) swap(a, b);
for (int k = 16; k >= 0; k -- )
if (depth[fa[a][k]] >= depth[b])
a = fa[a][k];
if (a == b) return a;
for (int k = 16; k >= 0; k -- )
if (fa[a][k] != fa[b][k])
{
a = fa[a][k];
b = fa[b][k];
}
return fa[a][0];
}
void dfs(int u, int fa)
{
d[u] = (d[fa] + path[u]) % MOD;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
if (j == fa) continue;
dfs(j, u);
}
}
int get_size(int u, int fa)
{
if (st[u]) return 0;
int res = 1;
for (int i = h[u]; ~i; i = ne[i])
if (e[i] != fa)
res += get_size(e[i], u);
return res;
}
int get_wc(int u, int fa, int tot, int& wc)
{
if (st[u]) return 0;
int sum = 1, ms = 0;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
if (j == fa) continue;
int t = get_wc(j, u, tot, wc);
ms = max(ms, t);
sum += t;
}
ms = max(ms, tot - sum);
if (ms <= tot / 2) wc = u;
return sum;
}
void get_dist(int u, int fa, int dist, int sum, int& qt)
{
if (st[u]) return;
q[ ++ qt] = {dist, sum, u};
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
if (j != fa)
get_dist(j, u, dist + 1, (sum + w[j]) % MOD, qt);
}
}
inline int get(Node a[], int k, int limit, int wu, int& pu)
{
sort(a + 1, a + k + 1);
static int sum[N];
int res = 0;
for (int i = 1; i <= k; i ++ ) sum[i] = (sum[i - 1] + a[i].w) % MOD;
for (int i = 1, j = k; i < j; i ++ )
{
while (j > i && a[j].d + a[i].d - 1 > limit) j -- ;
if (j > i && a[j].d + a[i].d - 1 <= limit)
{
res = (res + (LL)sum[j] - sum[i] + (LL)(j - i) * a[i].w - (LL)wu * (j - i)) % MOD;
pu = (pu + j - i) % MOD;
}
}
return res;
}
int dfs_path(int u, int fa, int dist, int maxd)
{
if (st[u]) return 0;
int res = (query(R + 1 - dist, maxd) - query(L - dist, maxd)) % MOD;
if (dist >= L && dist <= R) res = (res + 1) % MOD;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
if (j != fa)
res = (res + dfs_path(j, u, dist + 1, maxd)) % MOD;
}
path[u] = (path[u] + res) % MOD;
return res;
}
int calc(int u)
{
if (st[u]) return 0;
get_wc(u, -1, get_size(u, -1), u);
st[u] = true;
int res = 0, pt = 0;
if (L <= 1 && R >= 1) res = w[u], path[u] = (path[u] + 1) % MOD;
int cnt = 0, maxd = 0;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i], qt = 0;
if (st[j]) continue;
get_dist(j, -1, 2, (w[u] + w[j]) % MOD, qt);
int pR = 0, pL = 0;
res = (res - (LL)(get(q, qt, R, w[u], pR) - get(q, qt, L - 1, w[u], pL))) % MOD;
path[u] = (path[u] - (LL)(pR - pL)) % MOD;
pos[ ++ cnt] = pt + 1; // 每一段开头
root[cnt] = j; // 每一段的根节点
for (int k = 1; k <= qt; k ++ )
{
if (q[k].d >= L && q[k].d <= R)
{
res = (res + q[k].w) % MOD;
path[u] = (path[u] + 1) % MOD; // 只计算从u到当前点的
}
p[ ++ pt] = q[k];
maxd = max(maxd, q[k].d);
}
}
pos[cnt + 1] = pt + 1; // 哨兵
for (int i = 1; i <= maxd; i ++ ) tr[i] = 0;
for (int i = 1; i <= pt; i ++ ) update(p[i].d, 1, maxd); // 插入树状数组中
for (int i = 1; i <= cnt; i ++ )
{
int l = pos[i], r = pos[i + 1] - 1;
for (int j = l; j <= r; j ++ ) update(p[j].d, -1, maxd); // 将当前子树中的节点删掉
dfs_path(root[i], u, 2, maxd);
for (int j = l; j <= r; j ++ ) update(p[j].d, 1, maxd); // 将当前子树中的节点添加回来
}
int pR = 0, pL = 0;
res = (res + (LL)get(p, pt, R, w[u], pR) - get(p, pt, L - 1, w[u], pL)) % MOD;
path[u] = (path[u] + (LL)pR - pL) % MOD;
for (int i = h[u]; ~i; i = ne[i]) res = (res + calc(e[i])) % MOD;
return res;
}
int main()
{
int T;
scanf("%d", &T);
while (T -- )
{
scanf("%d%d%d%d", &n, &m, &L, &R);
memset(h, -1, sizeof h), idx = 0;
memset(path, 0, sizeof path);
for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
for (int i = 2; i <= n; i ++ )
{
int p;
scanf("%d", &p);
add(i, p), add(p, i);
father[i] = p;
}
memset(st, 0, sizeof st);
int res = calc(1);
dfs(1, 0);
bfs();
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int p = lca(a, b);
int sum = (d[a] + (LL)d[b] - d[p] * 2 + path[p]) * c % MOD;
res = ((res + sum) % MOD + MOD) % MOD;
printf("%d\n", res);
}
}
return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/957323/
更多历年题解戳这里：ccf-csp 历年真题题解