第五届上海市青少年算法竞赛题解

关注

原创最新推荐文章于 2026-05-04 11:02:18 发布 1.9k 阅读 AI 写同款· GEO 优化 ›

上海市青少年算法月赛丙组—目录汇总 上海市青少年算法月赛—目录汇总阅读详情

第五届上海市青少年算法竞赛题解
本次比赛涉及算法：字符串、贪心、枚举模拟、 $ma p$ 、数学、思维、栈、折半查找、广度优先搜索
今年比赛整体的题目难度和思维难度还是偏大的，对小朋友们的逻辑思维、分析能力和运用能力有一定要求，特别是最后一题要拿满分，对于细节的处理要考虑周全， $2$ 小时的比赛时间确实有点太短了。

比赛时间：2024 年 4 月 6 日
比赛链接：https://iai.sh.cn/contest/63

第一题：T1符号译码

标签：字符串、枚举模拟、 $ma p$
题意：给定 $01$ 串和字符之间的编码规则，给出一个 $01$ 字符串，要求输出对应的符号序列。
（字符串长度为 $n$ ， $2 \leq n \leq 300000$ ）
题解：按照题意直接暴力模拟就好了，可以用 $ma p$ 优化下代码逻辑。下面给出两种的写法的代码。
代码：
普通暴力版：

#include <bits/stdc++.h>
using namespace std;

int main() {
    string s;
    cin >> s;
    int n = s.size();
    for (int i = 0; i < n; i++) {
        if (s[i] == '0' && s[i+1] == '1' && s[i+2] == '0') {
            cout << '[';
            i += 2;
        }
        else if (s[i] == '1' && s[i+1] == '0' && s[i+2] == '1') {
            cout << ']';
            i += 2;
        }
        else if (s[i] == '0' && s[i+1] == '0') {
            cout << '<';
            i += 1;
        }
        else if (s[i] == '1' && s[i+1] == '1') {
            cout << '>';
            i += 1;
        }
        else if (s[i] == '0' && s[i+1] == '1' && s[i+2] == '1') {
            cout << '+';
            i += 2;
        }
        else if (s[i] == '1' && s[i+1] == '0' && s[i+2] == '0') {
            cout << '-';
            i += 2;
        }
    }
    return 0;
}

简洁版、 $ma p$ 优化版：

#include <bits/stdc++.h>
using namespace std;

map<string, char> m;

int main() {
    // map预记录
    m["010"] = '['; m["101"] = ']';
    m["00"] = '<'; m["11"] = '>';
    m["011"] = '+'; m["100"] = '-';
    string s;
    cin >> s;
    int n = s.size();
    for (int i = 0; i < n; i++) {
        if (m[s.substr(i, 3)]) {
            cout << m[s.substr(i, 3)];
            i += 2;
        }
        else if (m[s.substr(i, 2)]) {
            cout << m[s.substr(i, 2)];
            i += 1;
        }
    }
    return 0;
}

标签：数学、思维
题意：由两个自然数组成的一对数称之为有序数对，有序是指数对的第一项与第二项是区别的，例如 $(0, 1)$ ， $(1, 0)$ 是不一样的数对。对所有有序数对进行排序，先按照每对中两数之和从小到大排序，两数之和相同，再按照每个数对中第一个数从小到大排序。
例如前 $6$ 个数对为 $(0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0)$
给定一个整数 $k$ ，求出第 $k$ 个数对。 $(1 \leq k \leq 1, 000, 000, 000)$
题解：我们列一下前几个，找下规律：
$(0, 0)$ 、 $(0, 1), (1, 0)$ 、 $(0, 2), (1, 1), (2, 0)$ 、 $(0, 3), (1, 2), (2, 1), (3, 0)$ 、 $(0, 4), (1, 3), (2, 2), (3, 1), (4, 0)$
能够发现数对之和为 $0$ 的有 $1$ 个；数对之和为 $1$ 的有 $2$ 个；数对之和为 $2$ 的有 $3$ 个；数对之和为 $3$ 的有 $4$ 个…
我们可以用 $\frac {(1+n)*n}{2}$ 公式，确定要找的第 $k$ 个数对两项之和为多少，因为第 $1$ 个数对是从 $(0, 0)$ 开始的，所以找到的时候要 $n - 1$ ，最后输出的时候，要注意对于每个之和为 $n$ 的第一项数也是从 $0$ 开始的，所以 $k$ 也需要减 $1$ 。
代码：

#include <bits/stdc++.h>
using namespace std;

int main() {
    int k, n = 0;
    cin >> k;
    while ((1 + n) * n / 2 < k) n++;
    n--;
    k -= (1 + n) * n / 2;
    k--;
    cout << k << " " << n - k << endl;
    return 0;
}

第三题：T3最大的数字

标签：字符串、栈、贪心
题意：给定一个十进制整数 $n$ ，保证 $n$ 的首位不为 $0$ ，你必须删除其中 $d$ 个数字，使得留下的数字最大。请输出留下的最大数。
( $1≤n<10^{300000}$ , 1≤ d <n)

题解：要使得最后留下的数最大，想着把前面稍微比较小的数删掉，后面大一点的数字顶上来。
比如 $417$ ，如果要删除一个数，我们会把 $1$ 删除，然后 $7$ 顶上来，形成 $47$ 。
如何实现这样的逻辑呢？我们考虑维护一个栈，由于栈后进先出的性质，我们遍历到每一位的时候可以去检测一下和栈顶元素的大小关系，如果目前还能删数，并且当前元素比栈顶元素（前面的数）大，那我们可以把栈顶元素弹掉，等价于删除栈顶元素。那么最后留下来的就能保证比较大。
可能整个过程中删除数不够，其实已经维护了一个递减序列（非严格），那我们把末尾的一些删掉即可。
比如原数为 $86421$ ， $d = 2$ ，那么遍历的过程中不会因为栈顶和当前数的关系删除的情况。
最终我们把最后两个元素删掉，形成 $864$ 就好了。
代码：

#include <bits/stdc++.h>
using namespace std;

int d;
string str, ans = "";
stack<char> s;

int main() {
    cin >> d >> str;
    int len = str.size();
    for (int i = 0; i < len; i++) {
        // 当d>0的时候，如果栈顶比当前字符小 弹出
        while (d > 0 && !s.empty() && s.top() < str[i]) {
            s.pop();
            d--;
        }
        s.push(str[i]);
    }
    while (!s.empty()) {
        if (d > 0) d--;
        else ans = s.top() + ans;
        s.pop();
    }
    cout << ans << endl;
    return 0;
}

第四题：T4夹心饼干

标签：思维、数学
题意：给定一个数列 $a_1,a_2,a_3...,a_n$ ，请求出在这个序列中，能挑出多少个三个数 $a_i,a_j,a_k$ ，满足 $i < j < k$ 且 $a_i=a_k$ 且 $a_i \neq a_j$ 。 $1≤n≤300,000,0≤a_i<n)$
题解：观察题目中给的样例： $1\ 2\ 1\ 2\ 1$ ，第 $1$ 个位置的 $1$ 和第 $3$ 个位置的 $1$ 中间夹了一个 $2$ ；
第 $1$ 个位置的 $1$ 和第 $5$ 个位置的 $1$ 之间夹了两个 $2$ ；第 $2$ 个位置的 $2$ 和第 $4$ 个位置的 $2$ 之间夹了 $1$ 个 $1$ ；第 $3$ 个位置的 $1$ 和第 $5$ 个位置的 $1$ 中间夹了一个 $2$ 。
可以把所有相同的数的下标按顺序放到对应的 $v ec t or$ 里面。
那么任意一对相同的数之间能够夹的数的个数就等于，两个数的下标之差 - 两个数中间包含的相同数个数。
比如 $1$ 维护的 $v ec t or$ ： $1\ 3 \ 5$ 。
原序列的下标 $1$ 和下标 $5$ 之间能夹的数的个数就等于 $5 - 1 - (3 - 1) = 2$ 。
注意题目中的细节， $a_i$ 可能等于 $0$ 。
代码：

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const ll N = 3e5 + 10;
ll n, x, mx = 0, ans = 0;
vector<ll> a[N];

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> x;
        mx = max(mx, x);
        a[x].push_back(i);
    }
    for (int k = 0; k <= mx; k++) {
        for (int i = 0; i < a[k].size(); i++) {
            for (int j = i + 1; j < a[k].size(); j++) {
                // 两个相同的数下标距离差-两个中间包含的相同数个数
                ans += (a[k][j] - a[k][i] - (j - i));
            }
        }
    }
    cout << ans << endl;
    return 0;
}

第五题：T5最大的余数

标签：折半查找
题意：给定 $n$ 个数字 $a_1,a_2,…,a_n$ ，在给定一个整数 $m$ ，请从给定的数字中挑选任意多个数字，使得它们的和模 $m$ 的余数尽量大，输出这个最大的余数。 $1≤n≤40，1≤a_i≤10^9，1≤m≤10^9)$
题解：一看到 $n \leq 40$ ，下意识就是折半查找，因为暴力搜索 $2^{40}≈10^{12}$ ，肯定会超时。把问题折半一下，分别预处理出各自一半的数的组成情况，时间复杂度是 $2*2^{20}≈2*10^6$ 。
比如样例： $\ \ 10 \ \ 100 \ \ 1000 \ \ 10000$
前两个的所有情况之和为 $\ \ 1 \ \ 10 \ \ 11$
后三个的所有情况之和为 $\ \ 100 \ \ 1000 \ \ 10000 \ \ 1100 \ \ 10100 \ \ 11000 \ \ 11100$
前半部分搜索出来的所有情况的值存到 $b$ 数组中，后半部分搜索出来的所以情况存到 $c$ 数组中。
要找出前半部分 $+$ 后半部分对 $m$ 进行取模余数尽可能大的。那我们可以枚举前半部分的所有情况，然后二分查找（ $lower\_bound$ ）一下后半部分中 $m - b [i]$ 的值，找到的是第一个大于等于 $m - b [i]$ 的，所以往前减一位即可。
代码：

#include <bits/stdc++.h>
using namespace std;

int n, m, a[50], ans = 0;
vector<int> b, c;
void dfs1(int p, int sum) {
    if (p == n / 2 + 1) {
        b.push_back(sum);
        return ;
    }
    dfs1(p + 1, (sum + a[p]) % m);
    dfs1(p + 1, sum % m);
}

void dfs2(int p, int sum) {
    if (p == n + 1) {
        c.push_back(sum);
        return ;
    }
    dfs2(p + 1, (sum + a[p]) % m);
    dfs2(p + 1, sum % m);
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        a[i] %= m;
    }
    dfs1(1, 0);
    dfs2(n / 2 + 1, 0);
    sort(c.begin(), c.end());
    for (int i = 0; i < b.size(); i++) {
        int p = lower_bound(c.begin(), c.end(), m - b[i]) - c.begin();
        p--;
        ans = max(ans, (b[i] + c[p]) % m);
    }
    cout << ans << endl;
    return 0;
}

第六题：T6位置互换

标签：广度优先搜索
题意：给定一个矩形地图，地图中 $.$ 代表可以走的空地； $\#$ 代表不可以走的墙壁； $1$ 表示小爱初始的位置； $2$ 表示小艾初始的位置。小爱和小艾可以上下左右走或原地不动，不可以移动到对方当前的位置，求经过多少轮之后，小爱和小艾可以实现互换位置。
题解：把小爱和小艾的整体移动跑 $b f s$ ，开个四维 $v i s$ 数组标记一下各自走同步的情况，进行位移的过程中需要把各自 $4$ 个方向，即 $4$ x $4$ 种情况都跑一下。跑 $b f s$ 的过程中需要注意几个细节：

如果小爱或者小艾某个人已经跑到对应互换的终点了，就原地保持不动。
如果发生了当前跑到的两个位置互换的情况，要跳过。比如小爱在 $(2, 2)$ 位置要往右走到 $(2, 3)$ ；小艾在 $(2, 3)$ 位置要往左走到 $(2, 3)$ 。
移动到同一个格子的时候，需要让其中一个人原地不动，另一个人走到这个各自上。

整道题细节比较多和需要考虑的点比较多，同学们在写的过程中要注意细节的处理。
代码：

#include <bits/stdc++.h>
using namespace std;

struct node {
	// 当前小爱坐标(x1,y1) 小艾坐标(x2,y2) 步数
	int x1, y1, x2, y2, step;
}st;
int n, m;
int dx[4] = {0, 0, -1, 1};
int dy[4] = {-1, 1, 0, 0};
char a[50][50];
bool vis[50][50][50][50];

bool check(int x, int y) {
    return x >= 1 && x <= n && y >= 1 && y <= m && a[x][y] != '#';
}

void bfs() {
    queue<node> q;
    q.push(st);
    vis[st.x1][st.y1][st.x2][st.y2] = 1;
    while (!q.empty()) {
        node p = q.front();
        q.pop();
        if (p.x1 == st.x2 && p.y1 == st.y2 && p.x2 == st.x1 && p.y2 == st.y1) {
            cout << p.step;
            return ;
        }
        // 枚举小爱和小艾的所有方向组合
        for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++) {
            int nx1 = p.x1 + dx[i], ny1 = p.y1 + dy[i];
            int nx2 = p.x2 + dx[j], ny2 = p.y2 + dy[j];

            if (nx1 == p.x2 && ny1 == p.y2 && nx2 == p.x1 && ny2 == p.y1) continue;

            // 如果已经到终点, 原地保持不动
            if (p.x1 == st.x2 && p.y1 == st.y2) nx1 = p.x1, ny1 = p.y1;
            if (p.x2 == st.x1 && p.y2 == st.y1) nx2 = p.x2, ny2 = p.y2;

            if (check(nx1, ny1) && check(nx2, ny2)) {
                if (nx1 == nx2 && ny1 == ny2) { // 移动到同一个格子的情况
                    if (!vis[nx1][ny1][p.x2][p.y2]) {
                        vis[nx1][ny1][p.x2][p.y2] = 1;
                        q.push({nx1, ny1, p.x2, p.y2, p.step + 1});
                    }
                    if (!vis[p.x1][p.y1][nx2][ny2]) {
                        vis[p.x1][p.y1][nx2][ny2] = 1;
                        q.push({p.x1, p.y1, nx2, ny2, p.step + 1});
                    }
                } else { // 不是移动到同一个格子的情况
                    if (!vis[nx1][ny1][nx2][ny2]) {
                        vis[nx1][ny1][nx2][ny2] = 1;
                        q.push({nx1, ny1, nx2, ny2, p.step + 1});
                    }
                }
            }
        }
    }
    cout << "No Solution";
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    for (int j = 1; j <= m; j++) {
        cin >> a[i][j];
        if (a[i][j] == '1') st.x1 = i, st.y1 = j;
        if (a[i][j] == '2') st.x2 = i, st.y2 = j;
    }
    bfs();
    return 0;
}