Everlasting的博客

2026_WUST选拔赛Round1_L题题解

Mon, 15 Jun 2026 00:00:00 GMT

2026 WUST选拔赛Round1 L题题解

原题链接：Nowcoder

题意：

在 $1$ 到 $n$ 上有 $n$ 个位置，每个位置放置了一个弹簧，弹簧能将弹球弹到固定的点 $a[i]$ $(1 \leq a[i] \leq n)$ 上。

接下来要进行 $m$ 个操作：在第 $i$ $(1 \leq i \leq m)$ 个操作中，你需要放置一个拥有无限动力的弹球在 $b[i] \oplus c[i - 1]$ 处，并回答在 $b[i] \oplus c[i - 1]$ 处的弹球个数 $c[i]$ 。

注意：操作的顺序为：先放入一个弹球，询问当前位置的弹球数量，再所有弹球沿边移动一步。

已知 $c[0] = 0$ 。给定位置个数 $n$ $(1 \leq n \leq 5e5)$ ，操作数 $m$ $(1 \leq m \leq 5e5)$ 和数组 $a$， $b$。保证所有弹球都会被放置在 $pos$ $(1 \leq pos \leq n)$ 中。

思路：

转化题意

由于每个位置的弹球都会在一次操作中从位置 $x$ 被移到 $a[x]$，因此可以将每一个位置看成一个点，并连接一条有向边，形成了由若干个基环树组成的函数图。因此，此题可以转化为：在由若干个基环树组成的函数图上，支持动态加入弹球，并在线查询某个时刻某个点上的弹球数量。
非环点

对于不在环上的点，弹球会不断沿边移动，直到第一次到达唯一的，且在其所在基环树的环上的点为止。对于任意一个基环树来说，每一个非环点都在以某个唯一的，且在其所在基环树的环上的点为根的树上。因此，我们可以建立反图，利用树的结构去维护位置。

接下来需要维护非环点上弹球的位置。设在第 $t$ 次操作中在非环点 $u$ 放入弹球，在第 $i$ $(t \leq i \leq m)$ 次操作中询问非环点 $v$ ，且这个弹球在点 $v$ 上。利用树的结构，我们可以知道弹球从 $u$ 移动到点 $v$ 所需要的时间为点 $u$ 在树上的深度减去 $v$ 的在树上的深度，设 $dep[x]$ 表示点 $x$ 的深度，即有：$i - t = dep[u] - dep[v]$，变形可以得到： $$i + dep[v] = t + dep[u]$$

另外，点 $u$ 一定位于以点 $v$ 为根的子树中。因此，不仅要满足 $i + dep[v] = t + dep[u]$ 的时间条件，也要满足路径条件。可以对每一个树都维护一个 $dfs$ 序，设点 $tin[x]$ 和 $tout[x]$ 分别为点 $x$ 的 $dfs$ 进入时间和点 $x$ 子树内最大的 $dfs$ 进入时间，则需满足：$$tin[v] \leq tin[u] \leq tout[v]$$

因此，查询非环点 $v$ 时，只需统计满足$i + dep[v] = t + dep[u]$且$tin[u]$ 在 $[tin[v], tout[v]]$ 之间的历史插入点 $u$ 。因此，可以按照 $key$ $(key = t + dep[u])$ 的值进行分类，对于每一个 $key$ 来说，使用对应的平衡树维护其插入点的$dfs$序，并统计 $[tin[v], tout[v]]$ 之间的数目即可。我们可以使用unordered_map<int, ordered_set<array <int, 2> >进行维护。其中 $key = t + dep[u]$ ，ordered_set中存储 {tin[u], t} ，防止同一个点多次插入后仍计算为同一个点。
环点

对于环上的点，弹球会不断沿环上的边移动。设在第 $t$ 次操作中在环点 $u$ 放入弹球，环点 $u$ 所在的环的长度为 $len$ ，环点编号为 $pos_i$ 。则在第 $T$ $(t \leq T \leq m)$ 次操作中，弹球会移动到编号为 $pos[v]$ $(pos[v] \equiv pos[u] + (T - t) \pmod {len})$ 上，变形有： $$pos[u] - t \equiv pos[v] - T \pmod {len}$$

因此，与非环点类似， $pos[u] - t$ 仍然是一个不变量 $c_id$ ，利用简单数组统计有相同 $c_id$ 的点的数量即可。

除此之外，环点还需要维护弹球从非环点走到环上的弹球数量。对于每一个在非环点的弹球，可以利用其树的深度来快速算出其进入环点的时间，可以在对应的时间把这些点当作环点加入环内即可。

代码：

#include <bits/stdc++.h>
#include <bits/extc++.h>
using namespace std;
using namespace __gnu_pbds;
#define int long long
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
using arr2 = array <int, 2>;

void solve ()
{
    int n;
    cin >> n;
    vector <int> a(n + 1), ind(n + 1);
    vector <vector <int> > rev(n + 1);

    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        ind[a[i]]++;
        rev[a[i]].push_back(i);
    }

    // 一.建基环树
    // 1.topo判环
    vector <int> removed(n + 1);
    queue <int> q;
    for (int i = 1; i <= n; i++) {
        if (ind[i] == 0) {
            q.push(i);
        }
    }

    while (!q.empty()) {
        auto u = q.front();
        q.pop();
        removed[u] = true;
        int v = a[u];
        if (--ind[v] == 0) q.push(v);
    }

    // 2.建环
    vector <vector <int> > cycle;
    vector <int> vis(n + 1, 0);
    int id = 0;
    for (int i = 1; i <= n; i++) {
        if (removed[i] || vis[i]) continue;
        vector <int> cyc;
        int u = i;
        while (!vis[u]) {
            vis[u] = 1;
            cyc.push_back(u);
            u = a[u];
        }
        cycle.push_back(cyc);
    }

    // 3.初始化树的信息
    vector <int> comp(n + 1), pos(n + 1), dep(n + 1), root(n + 1);
    int sum_cyc = cycle.size();

    for (int id = 0; id < sum_cyc; id++) {
        for (int i = 0; i < cycle[id].size(); i++) {
            int u = cycle[id][i];
            comp[u] = id;
            pos[u] = i;
            dep[u] = 0;
            root[u] = u;
        }
    }

    // 4.建反树
    vector <vector <int> > e(n + 1);
    for (int u = 1; u <= n; u++) {
        for (auto v : rev[u]) {
            if (removed[v]) {
                e[u].push_back(v);
            }
        }
    }

    // 5.求dfs序
    vector <int> tin(n + 1), tout(n + 1);
    int time = 0;

    auto dfs = [&] (auto self, int u) -> void {
        tin[u] = ++time;
        for (auto v : e[u]) {
            comp[v] = comp[u];
            root[v] = root[u];
            dep[v] = dep[u] + 1;
            self(self, v);
        }
        tout[u] = time;
    };

    for (auto &cyc : cycle) {
        for (auto r : cyc) {
            dfs(dfs, r);
        }
    }

    // 二.计算答案

    // 1.初始化
    int m;
    cin >> m;
    vector <int> len(sum_cyc);
    vector <vector <int> > cyc_info(sum_cyc);
    for (int id = 0; id < sum_cyc; id++) {
        len[id] = cycle[id].size();
        cyc_info[id].assign(len[id], 0);
    }

    vector <vector <arr2> > update(m + 1);
    unordered_map <int, ordered_set<arr2> > mp;
    mp.reserve(m * 2 + 10);

    int pre = 0;

    for (int i = 1; i <= m; i++) {
        for (auto [id, c_id] : update[i]) {
            cyc_info[id][c_id]++;
        }
        int x;
        cin >> x;
        x = (x ^ pre);

        // 2.插入
        if (!removed[x]) {
            int id = comp[x];
            int c_id = ((pos[x] - i) % len[id] + len[id]) % len[id];
            cyc_info[id][c_id]++;
        }else {
            int key = i + dep[x];
            mp[key].insert({tin[x], i});
            int T = i + dep[x];
            if (T <= m) {
                int id = comp[x];
                int c_id = ((pos[root[x]] - T) % len[id] + len[id]) % len[id];
                update[T].push_back({id, c_id});
            }
        }

        // 3.查询
        int res = 0;
        if (!removed[x]) {
            int id = comp[x];
            int c_id = ((pos[x] - i) % len[id] + len[id]) % len[id];
            res = cyc_info[id][c_id];
        }else {
            int key = i + dep[x];
            auto it = mp.find(key);
            if (it != mp.end()) {
                auto &st = it->second;
                res = st.order_of_key({tout[x] + 1, -1}) - st.order_of_key({tin[x], -1});
            }
        }

        cout << res << '\n';
        pre = res;
    }
}

int32_t main ()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

Atcoder Beginner Contest 459 F题题解

Sun, 24 May 2026 00:00:00 GMT

Atcoder Beginner Contest 459 F题题解

题意：

给你一个长度为 $N$ 的非负整数序列 $A = (A_1, A_2, \ldots, A_N)$ 。

你可以对 $A$ 执行下列操作零次或多次：

选择一个有 $1 \le i \le N - 1$ 的整数 $i$ ，将 $A_i$ 减少 $1$ ，并将 $A_{i+1}$ 增加 $1$ 。

求使 $A$ 严格递增所需的最小运算次数。

可以证明答案小于 $2^{63}$ 。

给你 $T$ 个测试用例，请逐个求解。

$1 \le T \le 3 \times 10^5$
$1 \le N \le 2 \times 10^5$
$0 \le A_i \le 10^9$
所有测试用例中 $N$ 的总和最多为 $6 \times 10^5$ 。
所有输入值均为整数。

思路：

将求严格递增的序列 $B$ 转换为求非递减的序列 $B$ 。

将原序列 $A$ 的每一项转换为 $a_i - i$ 即可。设序列 $B$ 为 $b_i = a_i - i$，则 $b_i - b_{i - 1} = a_i - a_{i - 1} - (i - (i - 1))$，即 $b_i - b_{i - 1} = a_i - a_{i - 1} - 1$，这天然满足严格递增的条件，因此求非递减的序列即可。

将每个数看成一个块，若左边的块的最右端的值大于右边的块的最左端的值，将两个块合并成一个块。在处理每一个块时，需要将块中的值尽可能平均放。

开始时每个块中非递减严格成立。在处理每一个块时，若遇到左边的值的最右端的值大于右边的块的最左端的值，需要合并两个块。此时的情况是需要将左边的值转移至右边，我们就可以尽可能贪心的让左边的值少减一点，即将左端的值最大化，右端的值最小化。在处理每一个块时，我们只需要维护其块内的值的总和和块的长度即可。从左到右遍历块，最后形成一个满足条件的连续的若干个块。

设原序列为 $A$，最终序列为 $B$，则答案 $ans$ 为： $ans = \sum_{i = 1}^{n} (prefixA_i - prefixB_i)$

设序列 $X$，令 $x_i$ 为从第 $i$ 个点到第 $i + 1$ 个点被操作了多少次$(1 \leq i \leq n - 1)$，则 $b_i = a_i + x_{i - 1} - x_i$。易得 $x_1 = a_1 - b_1$，则 $x_2 = a_2 - b_2 + x_1$，即 $x_2 - x_1 = a_2 - b_2$，即有：$x_2 = (a_2 - b_2) + (a_1 - b_1)$，所以有：$$x_i = prefixA_i - prefixB_i$$。答案便是 $\sum_{i = 1}^{n}x_i$

代码：

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

struct node {
    int len, sum;
    node operator + (const node &other) const {
        return node{other.len + len, other.sum + sum};
    }
};

int Floor (int a, int b) {
    if (a >= 0) return a / b;
    return -((-a + b - 1) / b);

}

int Ceil (int a, int b) {
    return -Floor(-a, b);
}

void solve ()
{
    int n;
    cin >> n;
    vector <int> v(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> v[i];
        v[i] -= i;
    }

    vector <node> st;
    for (int i = 1; i <= n; i++) {
        st.push_back({1, v[i]});
        while (st.size() >= 2) {
            node s = st.back();
            node t = st[st.size() - 2];
            int smn = Floor(s.sum, s.len);
            int tmx = Ceil(t.sum, t.len);
            if (smn < tmx) {
                st.pop_back();
                st.pop_back();
                st.push_back({s + t});
            }else {
                break;
            }
        }
    }

    vector <int> f(n + 1);
    int pos = 1;

    for (auto x : st) {
        int mn = Floor(x.sum, x.len);
        int cmx = x.sum - mn * x.len;
        int cmn = x.len - cmx;
        for (int i = 1; i <= cmn; i++) {
            f[pos++] = mn;
        }
        for (int i = 1; i <= cmx; i++) {
            f[pos++] = mn + 1;
        }
    }

    int ans = 0;
    int pv = 0, pf = 0;
    for (int i = 1; i <= n - 1; i++) {
        pv += v[i];
        pf += f[i];
        ans += pv - pf;
    }

    cout << ans << '\n';
}   
    
int32_t main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

CF1463B题解

Fri, 22 May 2026 00:00:00 GMT

CF1463B题解

题意：

题目链接

给你一个数组 $[a_1, a_2, \dots, a_n]$ ，其中有 $1 \le a_i \le 10^9$ 。设 $S$ 是数组 $a$ 中所有元素的和。

如果 $n$ 个整数组成的数组 $b$ 漂亮，那么我们就把这个数组称为 $b$ ：

从 $1$ 到 $n$ 的每个 $i$ 都是 $1 \le b_i \le 10^9$ ；
对于数组 $(b_i, b_{i + 1})$ 中的每一对相邻整数，要么是 $b_i$ 除以 $b_{i + 1}$ ，要么是 $b_{i + 1}$ 除以 $b_i$ （或者两者都是(或两者）；
$2 \sum \limits_{i = 1}^{n} |a_i - b_i| \le S$ .

思路：

对于构造合法解的题目，我们可以先想什么能够稳定的构造相邻整除的数组。再结合$2 \sum \limits_{i = 1}^{n} |a_i - b_i| \le S$，不难推得$$ \frac{1}{2}a_i \leq b_i \leq \frac{3}{2}a_i$$ 注意到存在$ \frac{1}{2}a_i$，可以想到把每一个$b_i$都设置成小于等于$b_i$的最大的$2$的幂。即有：$0 \leq a_i - b_i < \frac{1}{2}a_i$ 求和即有：$$\sum \limits_{i = 1}^{n} |a_i - b_i| \leq \frac{1}{2}S$$ 满足要求

代码：

void solve ()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int t;
        cin >> t;
        cout << (1LL << __lg(t)) << " \n"[i == n];
    }
}

关于在windows上编译失败的解决方案

Wed, 20 May 2026 00:00:00 GMT

Windows 下给 MinGW 手动补齐 `iconv.h` 环境教程

1. 问题背景

在 Windows 下使用 MinGW / WinLibs 编译 C++ 代码时，如果包含：

#include <bits/extc++.h>

可能会遇到类似错误：

fatal error: iconv.h: No such file or directory

错误链大概是：

<bits/extc++.h>
    ↓
<ext/codecvt_specializations.h>
    ↓
<iconv.h>
    ↓
找不到 iconv.h

这个问题的本质不是 C++ 代码写错了，而是当前 MinGW 环境里缺少 libiconv 相关的头文件和库文件。

2. 适用环境

本教程适用于 Windows 下手动配置 MinGW / WinLibs 环境，并且不想安装完整 MSYS2，只想补齐 iconv.h 相关文件的情况。

可以通过下面命令查看自己的编译器信息：

g++ -v

重点观察输出中的关键词，比如：

x86_64-w64-mingw32
ucrt
mingw64
clang64
i686

根据自己的环境选择对应的 libiconv 包：

你的环境	关键词	应下载的包
普通 64 位 MinGW / MSVCRT	`x86_64-w64-mingw32`、`mingw64`、没有 `ucrt`	`mingw-w64-x86_64-libiconv`
UCRT64	`ucrt`、`ucrt64`	`mingw-w64-ucrt-x86_64-libiconv`
CLANG64	`clang64`、`clang-x86_64`	`mingw-w64-clang-x86_64-libiconv`
32 位 MinGW	`i686`、`mingw32`	`mingw-w64-i686-libiconv`

例如，如果 g++ -v 输出中有类似：

MinGW-W64 x86_64-ucrt-posix-seh

说明你使用的是 UCRT64 版本，这种情况下应该下载：

mingw-w64-ucrt-x86_64-libiconv

如果输出中没有 ucrt，而是普通的 64 位 MinGW 环境，一般应该下载：

mingw-w64-x86_64-libiconv

3. 下载 libiconv 包

进入 MSYS2 Packages 页面，下载自己环境对应的 libiconv 包。

MSYS2 Packages 搜索页：

https://packages.msys2.org/search?t=binpkg&q=libiconv

也可以根据自己的环境直接进入对应页面：

你的环境	应下载的包	下载页面
普通 64 位 MinGW / MSVCRT	`mingw-w64-x86_64-libiconv`	https://packages.msys2.org/package/mingw-w64-x86_64-libiconv
UCRT64	`mingw-w64-ucrt-x86_64-libiconv`	https://packages.msys2.org/package/mingw-w64-ucrt-x86_64-libiconv
CLANG64	`mingw-w64-clang-x86_64-libiconv`	https://packages.msys2.org/package/mingw-w64-clang-x86_64-libiconv
32 位 MinGW	`mingw-w64-i686-libiconv`	https://packages.msys2.org/package/mingw-w64-i686-libiconv

进入对应页面后，找到页面中的 File 一栏，下载 .pkg.tar.zst 文件。

例如 UCRT64 环境的页面中，文件名通常类似:

mingw-w64-ucrt-x86_64-libiconv-1.19-1-any.pkg.tar.zst

普通 64 位 MinGW 环境的文件名通常类似：

mingw-w64-x86_64-libiconv-1.19-1-any.pkg.tar.zst

注意：版本号可能会随着 MSYS2 更新而变化，所以实际下载时以页面中的 File 一栏为准。

4. 解压 `.pkg.tar.zst` 文件

下载后你会得到一个类似这样的文件：

mingw-w64-ucrt-x86_64-libiconv-1.19-1-any.pkg.tar.zst

解压展开后一般会看到一个环境目录，例如：

ucrt64

或者：

mingw64

再展开后应该有：

环境目录\bin
环境目录\include
环境目录\lib

例如 UCRT64 包中通常是：

ucrt64\bin
ucrt64\include
ucrt64\lib

普通 MINGW64 包中通常是：

mingw64\bin
mingw64\include
mingw64\lib

5. 复制文件到你的 MinGW 目录

假设你的 MinGW / WinLibs GCC 安装目录是：

D:\gcc-14.2.0\mingw64

那么要把解压出来的环境目录中的文件复制到这个目录下。

例如你解压出来的是：

ucrt64

就把 ucrt64 里面的 include、lib、bin 中的相关文件复制到：

D:\gcc-14.2.0\mingw64\include
D:\gcc-14.2.0\mingw64\lib
D:\gcc-14.2.0\mingw64\bin

如果你解压出来的是：

mingw64

也是同理，把里面对应的文件复制到你自己的 MinGW 安装目录。

5.1 复制 include 文件

从解压目录：

环境目录\include

复制以下文件：

iconv.h
libcharset.h
localcharset.h

到你的 MinGW include 目录：

D:\gcc-14.2.0\mingw64\include

也就是最终应该存在：

D:\gcc-14.2.0\mingw64\include\iconv.h
D:\gcc-14.2.0\mingw64\include\libcharset.h
D:\gcc-14.2.0\mingw64\include\localcharset.h

5.2 复制 lib 文件

从解压目录：

环境目录\lib

复制以下文件：

libiconv.a
libiconv.dll.a
libcharset.a
libcharset.dll.a

到你的 MinGW lib 目录：

D:\gcc-14.2.0\mingw64\lib

最终应该存在：

D:\gcc-14.2.0\mingw64\lib\libiconv.a
D:\gcc-14.2.0\mingw64\lib\libiconv.dll.a
D:\gcc-14.2.0\mingw64\lib\libcharset.a
D:\gcc-14.2.0\mingw64\lib\libcharset.dll.a

5.3 复制 bin 文件

从解压目录：

环境目录\bin

复制以下文件：

libiconv-2.dll
libcharset-1.dll

到你的 MinGW bin 目录：

D:\gcc-14.2.0\mingw64\bin

最终应该存在：

D:\gcc-14.2.0\mingw64\bin\libiconv-2.dll
D:\gcc-14.2.0\mingw64\bin\libcharset-1.dll

复制完后即可正常编译运行了

华中农业大学第十五届程序设计竞赛游记及部分题解

Mon, 06 Apr 2026 00:00:00 GMT

华中农业大学第十五届程序设计竞赛游记及部分题解

游记

今年第二场线下比赛，赛前几天一直晕晕的，虽然但是，最后还是以六题拿了铜牌，但之后也要加强一些算法的训练了，有些算法的不熟悉导致了很多题目看着没思路，赛后发现实际上思路其实并不是特别困难。赛时快速切了I，D两道签到后，就被E题卡死，直到封榜后没招了，E题写了一位一位的向上模拟侥幸通过~~（实际上是因为模拟写假了且在第一步特判时实际上就把题目写完了所以侥幸过了）。在过E前，过了G，F两题，G因为自己迟迟没有过E心态爆炸而wa了6发，F看出二叉树遍历后写得还算顺利。过了E之后，就去写了L，感觉L还算简单，感觉题解写复杂了。剩下能写的B和J感觉是因为自己对状压dp和st倍增的不熟悉而没有能写的思路，C看没多少人过也没细看，实际上思路还算清晰吧，感觉这次比赛有些可惜。之后得加训了（上次就说要加训来着）~~。

题解

I

题意

要买$n$杯奶茶，买一杯需要$a$元，买两杯需要$b$元，问最少需要多少钱能恰好买到$n$杯奶茶？

代码

void solve ()
{
	i64 n, a, b;
	cin >> n >> a >> b;
	if (2 * a <= b) {
		i64 ans = n * a;
		cout << ans << '\n';
	}else {
		i64 t = n / 2 * b;
		if (n & 1) {
			t += a;
		}
		cout << t << '\n';
	}
}

D

题意

给定整数$c$ $(2 \leq c \leq 1e9)$，需要找到两个正整数$a$和$b$,满足$a + b == c$，且使$lcm(a, b)$最大。

思路

对于奇数，直接取$\lfloor n / 2 \rfloor$和$\lceil n / 2 \rceil$即可。对于偶数，在$n / 2$的基础上往下，往上找到$lcm(l, r) == l \times r$的数即可。

代码

void solve ()
{
	i64 n;
	cin >> n;
	if (n & 1) {
		i64 t1 = n / 2;
		i64 t2 = n - n / 2;
		i64 ans = t1 * t2;
		cout << ans << '\n';
	}else {
		i64 l = n / 2, r = n / 2;
		while (lcm(l, r) != l * r) {
			l--;
			r++;
		}
		i64 ans = lcm(l, r);
		cout << ans << '\n';
	}
}

G

题意

给定$n$个魔法飞弹，第$i$枚飞弹对应第$i$个哥布林，给定每个飞弹的穿透力$a_i$和伤害$c_i$，和每个哥布林的防御力$b_i$。当且仅当$a_i \geq b_i$时飞弹才会对哥布林造成伤害。现在有$q$次独立的询问，每一次你有一次可以将任意一枚飞弹的穿透力修改为$X$的机会，求每一次最多能对哥布林造成多少总伤害？

思路

我们可以预先处理出不修改穿透力的总伤害，再在剩余的未能造成伤害的飞弹里面先按需要的穿透力，即哥布林的防御力排序，再维护一个前缀数组，能够快速求出能把一个穿透力修改为$X$所能多造成的伤害。在处理询问时，仅需在前缀数组中二分查找即可。

时间复杂度：$O((n + q)\log n)$。

代码

void solve ()
{
	int n, q;
	cin >> n >> q;
	vector <array <i64, 3> > v(n + 1);
	for (int i = 1; i <= n; i++) {
		cin >> v[i][0];
	}
	for (int i = 1; i <= n; i++) {
		cin >> v[i][1];
	}
	for (int i = 1; i <= n; i++) {
		cin >> v[i][2];
	}
	
	i64 res = 0;
	vector <array <i64, 2> > a;
	a.reserve(n + 1);
	for (int i = 1; i <= n; i++) {
		if (v[i][0] >= v[i][1]) {
			res += v[i][2];
		}else {
			a.push_back({v[i][1], v[i][2]});
		}
	}
	
	sort(a.begin(), a.end(), [] (auto aa, auto bb) {
		if (aa[0] != bb[0]) {
			return aa[0] < bb[0];
		}else {
			return aa[1] > bb[1];
		}
	});
	
	i64 m = a.size();
	vector <i64> pre(m + 1);
	if (!a.empty()) pre[0] = a[0][1];
	for (int i = 1; i < m; i++) {
		pre[i] = max(pre[i - 1], a[i][1]);
	}
    
	while (q--) {
		i64 t;
		cin >> t;
		if (a.empty()) {
			cout << res << '\n';
			continue;
		}
		if (!a.empty() && t < a[0][0]) {
			cout << res << '\n';
			continue;
		}
		int l = 0, r = m - 1;
		while (l <= r) {
			int mid = (l + r) / 2;
			if (a[mid][0] <= t) {
				l = mid + 1;
			}else {
				r = mid - 1;
			}
		}
		cout << res + pre[r] << '\n';
	}
}

F

题意

给定一个合法的括号序列$s$，按照左括号的顺序对所有括号对进行从$1$到$n$的编号，对于编号为$p$的括号对，若其左括号后仍为左括号，将下一个左括号的编号$l$作为$p$的左孩子，若其右括号后为左括号，将下一个左括号的编号$r$作为$p$的右孩子。现给出二叉树结构，构造出原来的合法括号序列$s$。

思路

手玩样例后不难发现，对二叉树进行先序遍历即可。时间复杂度：$O(n)$。

代码

void solve ()
{
	int n;
	cin >> n;
	vector <array <int, 2> > v(n + 1);
	for (int i = 1; i <= n; i++) {
		cin >> v[i][0] >> v[i][1];
	}

	vector <int> ans;
	auto dfs = [&] (auto self, int fa, int u) -> void {
		ans.push_back(u);
		if (v[u][0] != 0) self(self, u, v[u][0]);
		ans.push_back(u);
		if (v[u][1] != 0) self(self, u, v[u][1]);
	};
	dfs(dfs, 0, 1);
	
	vector <int> cnt(n + 1);
	string s;
	for (auto x : ans) {
		if (cnt[x] == 0) {
			s.push_back('(');
			cnt[x]++;
		}else {
			s.push_back(')');
		}
	}
	
	cout << s << '\n';
}

E

题意

给定一个正整数$x$ $(1 \leq x \leq 1e12)$，询问是否能找到另一个正整数$k$，使得$x \times k$在十进制中每一个数位上都是$9$？

思路

~~(大胆猜测个位上不能是偶数或5)~~ 实际上仅需判断$gcd(10, x) = 1$是否成立即可。即$x$不能存在质因子$2$和$5$。时间复杂度：$O(1)$。

代码

void solve ()
{
	i64 n;
	cin >> n;
    i64 t = n % 10;
    if (t == 1 || t == 3 || t == 7 || t == 9) {
        cout << "YES\n";
    }else {
        cout << "NO\n";
    }
}

L

题意

给定一个大小为$n \times m$的矩阵停车场，每个车位要么是空地（用 . 表示），要么停着一辆固定方向行驶的汽车，方向为：U(上)，D(下)，L(左)，R(右)。若所有车都能够驶离停车场，按顺序输出离开车辆的坐标，否则输出-1。

思路

简单模拟即可。分别从上到下寻找可以离开停车场的'U'，从下到上寻找可以离开的'D'，从左到右寻找可以离开的'L' ,从右到左寻找可以离开的'R'，依次记录能够离开的车即可。将U, D, L, R记为一轮寻找。若在一轮寻找中没有车能从成功离开且还有车剩余，输出-1即可。时间复杂度：$O(4 \times n \times m)$。

代码

void solve ()
{
	int n, m;
	cin >> n >> m;
	vector <vector <char> > v(n + 1, vector <char> (m + 1));
	int cnt = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> v[i][j];
			if (v[i][j] != '.') cnt++;
		} 
	}
	
	vector <array <int, 2> > ans;
	ans.reserve(cnt + 1);

	vector <int> v1(m + 1, 1);//u
	vector <int> v2(m + 1, n);//d
	vector <int> v3(n + 1, 1);//l
	vector <int> v4(n + 1, m);//r	
	
	int pre = cnt;
	while (cnt > 0) {
		for (int j = 1; j <= m; j++) {
			int i = v1[j];
			while (i <= n && (v[i][j] == 'U' || v[i][j] == '.')) {
				if (v[i][j] == 'U') {
					ans.push_back({i, j});
					cnt--;
					v[i][j] = '.';
				}
				i++;
			}
			v1[j] = i;
		}
		
		for (int j = 1; j <= m; j++) {
			int i = v2[j];
			while (i >= 1 && (v[i][j] == 'D' || v[i][j] == '.')) {
				if (v[i][j] == 'D') {
					ans.push_back({i, j});
					cnt--;
					v[i][j] = '.';
				}
				i--;
			}
			v2[j] = i;
		}
		
		for (int i = 1; i <= n; i++) {
			int j = v3[i];
			while (j <= m && (v[i][j] == 'L' || v[i][j] == '.')) {
				if (v[i][j] == 'L') {
					ans.push_back({i, j});
					cnt--;
					v[i][j] = '.';
				}
				j++;
			}
			v3[i] = j;
		}
		
		for (int i = 1; i <= n; i++) {
			int j = v4[i];
			while (j >= 1 && (v[i][j] == 'R' || v[i][j] == '.')) {
				if (v[i][j] == 'R') {
					ans.push_back({i, j});
					cnt--;
					v[i][j] = '.';
				}
				j--;
			}
			v4[i] = j;
		}
		
		if (pre == cnt) {
			cout << -1 << '\n';
			return;
		}
		
		pre = cnt;
	}

	for (auto [x, y] : ans) {
		cout << x << ' ' << y << '\n';
	}
	
}

J

题意

给定一个以$1$为根，包含$n$ $(1 \leq n \leq 1e5)$个节点的树，每个节点$i$有一个初始权值$m_i$ $(1 \leq m_i \leq 1e9)$，且对于任意非根节点$x$，其权值不会超过其父节点的权值。现给出$q$ $(1 \leq q \leq 1e5)$次操作。第一种操作中给出节点$u$和权值$w$ $(1 \leq w \leq 1e9)$，需要找出第一个权值至少为$w$的节点编号，若找不到则输出-1. 第二种操作中给出节点$x$和权值$v$ $(-1e9 \leq w \leq 1e9)$，需要判断给节点$x$的权值加上$v$后其权值是否超过其父节点的权值或小于其叶节点的权值，若超过其父节点的权值或小于其子节点的权值则修改失败，反之修改成功，并修改权值。

思路

对于第一种操作，可以用st倍增快速查询，找到最后一个权值小于$w$的节点输出其父节点即可。对于第二种操作，可以使用multiset，对每个节点存下其子节点的权值，将修改后的权值与父节点的权值和最大的子节点的权值比较即可。时间复杂度：$O((n + q) \times \log n)$。

代码

const int m = 20;

void solve ()
{
    int n, q;
    cin >> n >> q;
    vector <i64> val(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> val[i];
    }
    vector <vector <int> > e(n + 1);
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        e[u].push_back(v);
        e[v].push_back(u);
    }

    vector <int> fa(n + 1);
    vector <int> order;
    order.reserve(n + 1);
    fa[1] = 0;
    
    auto dfs = [&] (auto self, int f, int u) -> void {
        order.push_back(u);
        fa[u] = f;
        for (auto v : e[u]) {
            if (v == f) continue;
            self(self, u, v);
        }
    };
    dfs(dfs, 0, 1);

    vector <array <int, m> > st(n + 1);
    for (auto u : order) {
        st[u].fill(0);
        st[u][0] = fa[u];
    }
    for (int k = 1; k < m; k++) {
        for (int i = 1; i <= n; i++) {
            st[i][k] = st[st[i][k - 1]][k - 1];
        }
    }

    vector <multiset <i64> > a(n + 1);
    for (int i = 2; i <= n; i++) {
        a[fa[i]].insert(val[i]);
    }

    while (q--) {
        int op;
        cin >> op;
        if (op == 1) {
            int u;
            i64 w;
            cin >> u >> w;
            if (val[u] >= w) {
                cout << u << '\n';
                continue;
            }
            int cur = u;
            for (int k = m - 1; k >= 0; k--) {
                int t = st[cur][k];
                if (t != 0 && val[t] < w) {
                    cur = t;
                }
            }
            if (fa[cur] == 0) {
                cout << -1 << '\n';
            }else {
                cout << fa[cur] << '\n';
            }
        }else {
            int x;
            i64 v;
            cin >> x >> v;
            bool ok = true;
            if (x != 1 && v + val[x] > val[fa[x]]) {
                ok = false;
            }
            if (ok && !a[x].empty()) {
                i64 mx = *a[x].rbegin();
                if (v + val[x] < mx) {
                    ok = false;
                }
            }
            if (!ok) {
                cout << "FAILED\n";
                continue;
            }
            if (x != 1) {
                a[fa[x]].erase(a[fa[x]].find(val[x]));
                a[fa[x]].insert(v + val[x]);
            }
            val[x] += v;
            cout << "SUCCESS\n";
        }
    }
}

B

题意

有$n$ $(1 \leq n \leq 20)$个连续的公交车座位，编号从$1$到$n$，其中有$m$ $(0 \leq m \leq n)$个座位是损坏的。Alice和Bob轮流安排乘客入座，Alice先手，并希望入座的乘客尽量多，Bob希望入座的乘客尽量少。给定距离$k$，要求任意两名乘客的间距至少大于$k$ $(1 \leq k \leq 20)$。以字符串的形式输出最终可能的座位状态。

思路

注意到$n \leq 20$，考虑状压dp。设$dp[mask]$表示座位占有情况为$mask$时，最优的总入座人数。提前用dfs处理好每一个状态的最优总入座人数：若轮到Alice，其目标为最大化最终人数，枚举每一个合法的$i$，即：$dp[mask] = max , dp[mask \mid (1 \ll i)]$，若轮到Bob，其目标为最小化最终人数，枚举每一个合法的$i$，即：$dp[mask] = min , dp[mask \mid (1 \ll i)]$。接下来需要还原最终方案：可以从$mask = 0$开始正向模拟，对于$mask$状态，枚举所有合法的$i$，寻找某个$dp[mask \mid (1 \ll i)] = dp[mask]$，并将$mask$更新为$mask \mid (1 \ll i)$后继续查找即可。时间复杂度：$O(n \times 2^n)$。

代码

void solve ()
{
    int n, k, m;
    cin >> n >> k >> m;
    string s = string(n, '.');
    for (int i = 0; i < m; i++) {
        int t;
        cin >> t;
        t--;
        s[t] = 'x';
    }

    vector <i64> a(n, 0);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) continue;
            if (abs(i - j) <= k) {
                a[i] |= (1LL << j);
            }
        }
    }

    vector <i64> dp(1LL << n, -1);
    auto dfs = [&] (auto self, i64 mask, int cnt) -> i64 {
        if (dp[mask] != -1) return dp[mask];
        if (cnt & 1) {
            dp[mask] = 1e11;
        }else {
            dp[mask] = -1e11;
        }

        bool ok = false;
        for (int i = 0; i < n; i++) {
            if (s[i] == 'x') continue;
            if ((mask >> i) & 1) continue;
            if ((mask & a[i]) != 0) continue;
            ok = true;
            i64 nxt = mask | (1LL << i);
            i64 val = self(self, nxt, cnt + 1);
            if (cnt & 1) {
                dp[mask] = min(dp[mask], val);
            }else {
                dp[mask] = max(dp[mask], val);
            }
        }

        if (!ok) {
            dp[mask] = cnt;
        }

        return dp[mask];
    };
    dfs(dfs, 0LL, 0LL);

    i64 mask = 0LL;
    int cnt = 0;
    
    while (1) {
        int t = -1;
        for (int i = 0; i < n; i++) {
            if (s[i] == 'x') continue;
            if ((mask >> i) & 1) continue;
            if ((mask & a[i]) != 0) continue;

            i64 nxt = mask | (1LL << i);
            if (dp[nxt] == dp[mask]) {
                t = i;
                break;
            }
        }
        if (t == -1) break;
        if (cnt & 1) {
            s[t] = 'b';
        }else {
            s[t] = 'a';
        }
        mask |= (1LL << t);
        cnt++;
    }

    cout << s << '\n';
}

C

题意

给定大小为$n \times m$（$1 \leq n, m \leq 1e5$ 且 $n \times m \leq 2e5$）的矩阵，每个格子上都有一个权值$a_{ij}$ $(a_{ij} < 2^{30})$。从左上角$(1, 1)$走到右下角$(n, m)$，设路径上的地点值以此为$a_1, a_2, ... , a_k$，定义消耗的体力为$OR = a_1 \mid a_2 \mid ... \mid a_k$, 定义剩下的物资为$AND = a_1 & a_2 & ... & a_k$。要求在消耗的体力最小的情况下，最大化剩下的物资。输出最小体力消耗和最大物资剩余。

思路

先满足体力最小的条件，可以从高到低按位枚举确定答案，处理第$i$位时，尝试要求第$i$位全部为$0$。对整张图进行bfs，找出一条路径，其所有的点满足高位贪心结果且第$i$位都为$0$的路径。若不存在，该位只能为$1$。再满足最大物资剩余的条件，同样从高到低按位枚举，处理第$i$位时，尝试要求第$i$位全部为$1$。在满足体力最小的基础上，找出一条路径，其所有的点满足高位贪心结果且第$i$位都为$1$的路径。若不存在，该位只能为$0$。时间复杂度：$O(58 \times n \times m)$。

代码

const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, -1, 0, 1};

void solve ()
{
    int n, m;
    cin >> n >> m;
    vector <vector <i64> > v(n + 1, vector <i64> (m + 1));
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> v[i][j];
        }
    }

    i64 ans1 = 0;
    int t = 0;
    for (int i = 29; i >= 0; i--) {
        if (((v[1][1] >> i) & 1) || ((v[1][1] & t) != 0)) {
            ans1 += (1LL << i);
            continue;
        }

        vector <vector <int> > vis(n + 1, vector <int> (m + 1, 0));
        queue <array <int, 2> > q;
        q.push({1, 1});
        vis[1][1] = true;
        bool ok = false;
        while (!q.empty()) {
            auto [x, y] = q.front();
            q.pop();
            if (x == n && y == m) {
                ok = true;
                break;
            }
            for (int j = 0; j < 4; j++) {
                int xx = x + dx[j];
                int yy = y + dy[j];
                if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
                if (vis[xx][yy]) continue;
                vis[xx][yy] = true;
                if (((v[xx][yy] >> i) & 1) || (v[xx][yy] & t) != 0) continue;
                q.push({xx, yy});
            }
        }
        if (!ok) {
            ans1 |= (1LL << i);
        }else {
            t |= (1LL << i);
        }
    }

    i64 ans2 = 0;
    i64 x = 0;

    for (int i = 29; i >= 0; i--) {
        if (((ans1 >> i) & 1) == 0) continue;
        i64 a = x | (1LL << i);
        if ((v[1][1] & t) != 0 || (v[1][1] & a) != a) continue;

        vector <vector <int> > vis(n + 1, vector <int> (m + 1, 0));
        queue <array <int, 2> > q;
        q.push({1, 1});
        vis[1][1] = true;
        bool ok = false;
        while (!q.empty()) {
            auto [x, y] = q.front();
            q.pop();
            if (x == n && y == m) {
                ok = true;
                break;
            }
            for (int j = 0; j < 4; j++) {
                int xx = x + dx[j];
                int yy = y + dy[j];
                if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
                if (vis[xx][yy]) continue;
                vis[xx][yy] = true;
                if ((v[xx][yy] & t) != 0 || (v[xx][yy] & a) != a) continue;
                q.push({xx, yy});
            }
        }

        if (ok) {
            ans2 |= (1LL << i);
            x |= (1LL << i);
        }
    }

    cout << ans1 << ' ' << ans2 << '\n';
}

华中师范大学2026菜鸟杯游记及部分题解

Mon, 23 Mar 2026 00:00:00 GMT

华中师范大学2026菜鸟杯游记及部分题解

游记

下半学期参加的第一场线下赛，打得有点不尽人意。开头被A卡死，一直没发现代码的bug，卡了半个小时，很难受。J题花的时间略有一些长，不过还好过得也算足够快。而后面的H题一直没注意到1e9可拆分的性质，一直不知道怎么写。幸好盯了一会后总算发现，打暴力就行了。而对于后面的偏难的题目有些手足无措的感觉，E题的思路很晚才出，导致F题出了部分思路但后面已经没有时间了。以后得加强难题的训练了。

午饭挺丰盛的，好评。华师不大，但是风景挺好，已经羡慕了TAT。

题解

D

代码

void solve ()
{
    cout << "CCNU,Ciallo~(<`w< )n*!";
}

A

题意

给定字符串A，B，S，将S中与A匹配的部分替换成B。

思路

简单模拟即可(B题真是。。)

代码

void solve ()
{
    int a, b, s;
    cin >> a >> b >> s;
    string aa, bb, ss;
    cin >> aa >> bb >> ss;
    for (int i = 0; i <= ss.size() - a; i++) { 
        string t = ss.substr(i, a);
        if (t == aa) {
            ss.replace(ss.begin() + i, ss.begin() + i + a, bb);
            i += b - 1;
        }
    } 
    cout << ss << '\n';
}

I

题意

给定$n$款游戏，要求在一定要送出特定一款游戏的情况下购买最多款游戏。

思路

简单模拟即可。~~（赛时以为能购买多个同款游戏而卡了半天）~~

代码

void solve ()
{
    double m, n;
    cin >> m >> n;
    vector <array <double, 2> > v(n + 1);
    string t = "FemboyLovestory";
    bool ok = false;
    double x = -1.0;
    for (int i = 1; i <= n; i++) {
        string s;
        cin >> s;
        if (s == t) {
            ok = true;
        }
        i64 a, c;
        cin >> a >> c;
        v[i][0] = 1.0 * a * c / 100;
        if (s == t) {
            v[i][1] = 1;
            x = v[i][0];
        }else {
            v[i][1] = 0;
        }
    }

    sort(v.begin() + 1, v.end());

    if (!ok) {
        cout << 0 << '\n';
        return;
    }

    m -= x;
    if (m < 0) {
        cout << 0 << '\n';
        return;
    }
    int ans = 1;
    for (int i = 1; i <= n; i++) {
        if (v[i][1] == 1) continue;
        m -= v[i][0];
        if (m >= 0) ans++;
        else break;
    }

    cout << ans << '\n';
}

J

题意

小A把$N$颗糖以最优策略摆成一长条后，与小B一起从左端开始吃糖。小B先吃。每次吃糖最多吃$3$颗，最少吃$1$颗。$N$颗糖中有一颗特殊的糖，两人都不希望吃到这一颗糖。小B可以随时将特殊的糖移动到右端末尾，但只能移动一次。若小A吃到特殊的糖，输出"Yes"，否则输出"No"。

思路

简单博弈题。首先因为小B不知道特殊糖的位置，因此无论如何都应该将特殊的糖转移到糖的末端。枚举出糖的数量为$1, 5$时为NO，$2, 3, 4$为YES后，考虑状态转移。在吃糖数量最多吃三颗，最少吃一颗的情况下，$6, 7, 8$颗糖时小B都能将糖的数量转移到$5$的先手必输态，$9$颗糖时无法转移到$5$颗糖的先手必输态。由此可观察出当 $n \bmod 4 == 1$ 时小B必输，其余情况小B必赢。

代码

void solve ()
{
    i64 n;
    cin >> n;
    if (n % 4 == 1) {
        cout << "No\n";
    }else {
        cout << "Yes\n";
    }
}

C

题意

构造一个含有$n$个$0$和$m$个$1$的字符串S，满足字符串中任意一个子段满足子段中$0$的个数和$1$的个数的绝对值差值小于等于$k$且至少存在一个子段差值等于$k$。保证存在一个合法的解。

思路

简单构造题。题目保证了存在合法的解，我们便可以先满足至少存在一个子段差值等于$k$的条件。先让个数多的输出$k$个后再01或10地交替，这样保证了最优的构造。最后若有剩下的，因为题目保证合法，直接输出即可。

代码

void solve ()
{
    int n, m, k;
    cin >> n >> m >> k;
    if (n > m) {
        for (int i = 0; i < k; i++) {
            cout << '0';
        }
        int t0 = n - k;
        for (int i = 0; i < t0; i++) {
            cout << "10";
        }
        int l = m - t0;
        for (int i = 0; i < l; i++) {
            cout << '1';
        }
    }else {
        for (int i = 0; i < k; i++) {
            cout << '1';
        }
        int t0 = m - k;
        for (int i = 0; i < t0; i++) {
            cout << "01";
        }
        int l = n - t0;
        for (int i = 0; i < l; i++) {
            cout << '0';
        }
    }
}

H

题意

给定$T$组两个整数$n$, $m$，满足$n < m$,计算$n \times (n + 1) \times (n + 2) \times ··· \times m$对$1e9$取模后的结果。 $(1 \leq n \leq m \leq 1e9)$ $(1 \leq T \leq 1e5)$

思路

$1e9$由$9$个$2$和$9$个$5$相乘组成，由于只有$1e5$组数据，直接暴力计算$1e3$个数绝对是够的（事实上只用$40$个数据就够了）。

代码

const i64 mod = 1e9;

void solve ()
{
    i64 n, m;
    cin >> n >> m;
    i64 res = m % mod;
    for (int i = m - 1; i >= max(m - 1000, n); i--) {
        res = (res * i) % mod;
    }
    cout << res << '\n';
}

E

题意

Windows和Soubai比赛谁能活到最后，其生命值分别为$x$，$y$，实力分别为$A$，$B$，Boss的实力为$C$。比赛每轮会恰好发生三种事件之一，直至有人生命值小于等于$0$：

Windows有$A / C$的概率命中Soubai，对Soubai造成等于其自身生命值的伤害。
Soubai有$B / C$的概率命中Windows，对Windows造成等于其自身生命值的伤害。
双方有$1 - A / C - B / C$的概率均未命中。求出Windows赢得比赛的概率。

思路

首先可以简化模型，因为平局对胜负无影响，所以我们可以忽略平局。设$p_0$,$p_1$分别为Windows打到Soubai的概率和Soubai打到Windows的概率。其中$p_0 = A / (A + B)$，$p_1 = B / (A + B)$。我们可以根据生命值的大小分成三种情况，分别为$x > y$, $x < y$和$x = y$。我们需要维护至当前状态所需要的概率$res$。

当$x > y$时，要想使回合进行下去，只能由Soubai攻击Windows，同时每次攻击之后，Windows都能够直接击杀Soubai。因此在当前状态下，设Soubai能够攻击Windows的次数为$cnt$，Windows能赢得的概率为：$P = res * (p_0 + p_0 * p_1 + ··· + p_0 * p_1^{cnt})$,即$P = \frac{res \cdot p_0 \cdot p_1 \left(p_1^{\mathrm{cnt}} - 1\right)}{p_1 - 1}$。

当$x < y$时，要想使回合进行下去，只能由Windows攻击Soubai。但是这个时候不会出现Windows赢得比赛的情况，因此在当前状态下，只需要简单维护$res$即可。

当$x = y$时，只能由Windows攻击Soubai后得到答案。

直到$x$或$y$小于等于$0$时，结束比赛，输出答案即可。

代码

const i64 mod = 998244353;

i64 qpow (i64 a, i64 b) {
    i64 res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

void solve ()
{
    i64 x, y, a, b, c;
    cin >> x >> y >> a >> b >> c;
    
    i64 ans = 0;
    i64 res = 1;
    i64 p0 = a * qpow(a + b, mod - 2) % mod;
    i64 p1 = b * qpow(a + b, mod - 2) % mod;

    auto cal1 = [&] (i64 &x, i64 &y) {
        i64 cnt = x / y - (x % y == 0 ? 1 : 0);
        i64 sum = res * (1 + (mod - qpow(p1, cnt)) % mod) % mod;
        sum = sum * qpow((1 + mod - p1) % mod, mod - 2) % mod;
        ans = (ans + (sum * p0) % mod) % mod;
        res = res * qpow(p1, cnt) % mod;
        x -= cnt * y;
    };

    auto cal2 = [&] (i64 &x, i64 &y) {
        i64 cnt = y / x - (y % x == 0 ? 1 : 0);
        res = res * qpow(p0, cnt) % mod;
        y -= cnt * x;
    };

    while (x > 0 && y >  0) {
        if (x > y) {
            cal1(x, y);
        }else if (x < y) {
            cal2(x, y);
        }else {
            ans = (ans + (res * p0 % mod)) % mod;
            break;
        }
    } 

    cout << ans << '\n';

}

F

题意

给定一个长度为$n$的数组$a$，要求支持一共$q$次的以下两种操作:

输入$1 x v$，将数组下标为$x$的元素改成$v$。
输入$2 p$，查询可重集合$ {a_1 \bmod p, a_2 \bmod p, ···, a_n \mod p}$的中位数。 $(1 \leq n \leq 1e5, 1 \leq q \leq 1e5)$ $(1 \leq a_i \leq 2e5)$ $(1 \leq x \leq n, 0 \leq v \leq 2e5, 1 \leq p \leq 2e5)$

思路

很容易想到使用树状数组维护每一个值出现的个数并进行修改和查询。对于查询中位数而言，则是经典的根号分治的思想。对于小于$\sqrt {2e5}$的数，只需维护每一个小于$\sqrt {2e5}$的余数出现的次数即可，而对于大于$\sqrt {2e5}$的数，只需在每一个区间进行二分即可。这样即可解决中位数的问题了。

代码

const int m = 450;
const int mx = 2e5 + 5;

class BIT {
    public:
        int n;
        vector <i64> bit;

        BIT (int n = 0) {init(n);}
    
        void init (int m) {
            n = m;
            bit.assign(n + 1, 0);
        }

        static i64 lowbit (i64 x) { return x & -x; }

        i64 sum (int idx) const {
            i64 res = 0;
            for (; idx > 0; idx -= lowbit(idx)) res += bit[idx];
            return res; 
        }

        void point_add (int idx, i64 diff) {
            for (; idx <= n; idx += lowbit(idx)) bit[idx] += diff;
        }

        i64 point_query (int idx) const {
            return sum(idx) - sum(idx - 1);
        }

};

void solve ()
{
    int n, q;
    cin >> n >> q;
    vector <int> v(n + 1);
    for (int i = 1; i <= n; i++) {
    	cin >> v[i];
    }

    BIT bit(mx + 2);
    for (int i = 1; i <= n; i++) {
    	bit.point_add(v[i] + 1, 1);
    }

    vector <vector <int> > a(m + 1);
    for (int i = 1; i <= m; i++) {
    	a[i].assign(i, 0);
    }
    for (int i = 1; i <= n; i++) {
    	for (int j = 1; j <= m; j++) {
    		a[j][v[i] % j]++;
    	}
    }

    while (q--) {
    	int op;
    	cin >> op;
    	if (op == 1) {
    		int x, b;
    		cin >> x >> b;
    		if (v[x] == b) continue;
    		bit.point_add(v[x] + 1, -1);
    		bit.point_add(b + 1, 1);
    		for (int i = 1; i <= m; i++) {
    			a[i][v[x] % i]--;
    			a[i][b % i]++;
    		}
    		v[x] = b;
    	}else {
    		int x;
    		cin >> x;
    		if (x <= m) {
    			int sum = 0;
    			int ans = 0;
    			for (int i = 0; i < x; i++) {
    				sum += a[x][i];
    				if (sum >= (n + 1) / 2) {
    					ans = i;
    					break;
    				}
    			}
    			cout << ans << '\n';
    		}else {
    			int l = 0, r = x - 1;
    			int ans = x - 1;

    			auto check = [&] (int md) -> bool {
    				int res = 0;
    				for (int i = 0; i <= mx; i += x) {
    					res += bit.sum(min(i + md, mx) + 1) - bit.sum(i);
    				}
    				return res >= (n + 1) / 2;
    			};

    			while (l <= r) {
    				int mid = l + (r - l) / 2;
    				if (check(mid)) {
    					r = mid - 1;
    				}else {
    					l = mid + 1;
    				}
    			}
    			cout << l << '\n';
    		}
    	}
    }
}

天梯赛普及赛编程题题解

Sat, 14 Mar 2026 00:00:00 GMT

天梯赛普及赛编程题题解

1

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

void solve ()
{
    cout << "If people never did silly things, nothing intelligent would ever get done.";
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

2

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

void solve ()
{
    int x, n, y;
    cin >> x >> n >> y;
    cout << x * n + y << '\n';
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

3

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

void solve ()
{
    int a, b, c;
    cin >> a >> b >> c;
    cout << a << '\n';
    if (a < b) {
        cout << "Bu Kan";
    }else if (a >= b && a < c) {
        cout << "Zhe Gua Bao Shu Ma";
    }else {
        cout << "Chi Gua";
    }
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

4

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

void solve ()
{
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        int t;
        cin >> t;
        if (!(i & 1)) {
            ans += t;
        }
    }
    cout << ans;
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

5

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

void solve ()
{
    int a, b;
    cin >> a >> b;
    int res = a + b;
    int t;
    int ans = 1;
    while (cin >> t) {
        if (t == res) {
            cout << res << ' ' << "Accepted ";
            int l = ans % 60;
            int minute = ((ans - l) / 60) % 60;
            int hour = (ans - l - minute * 60) / 3600;
            if (hour <= 9) cout << "0" << hour;
            else cout << hour;
            cout << ":";
            if (minute <= 9) cout << "0" << minute;
            else cout << minute;
            cout << ":";
            if (l <= 9) cout << "0" << l;
            else cout << l;
            return;
        }
        ans += 2;
        if (ans >= 10800) {
            ans = 10799;
            break;
        }
    }

    cout << t << ' ' << "Wrong Answer " << "02:59:59";
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

6

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

void solve ()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int t;
        int ans = 0;
        bool ok = false;
        map <int, int> mp;
        while (cin >> t) {
            if (t == -1) break;
            if (!ok && mp[t]) {
                ans = t;
                ok = true;
            }
            mp[t] = true;
        }
        if (ok) {
            cout << ans << '\n';
        }else {
            cout << "NONE\n";
        }
    }
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

7

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

void solve ()
{
    int n;
    cin >> n;

    auto cal1 = [&] (i64 x) -> bool {
        i64 res = 0;
        while (res * res * 2 <= x) {
            if (res * res * 2 == x) return true;
            res++;
        }
        if (res * res * 2 == x) return true;
        else return false;
    };

    auto cal2 = [&] (i64 x) -> bool {
        i64 res = 0;
        while (res * res * res * 3 <= x) {
            if (res * res * res * 3 == x) return true;
            res++;
        }
        if (res * res * res * 3 == x) return true;
        else return false;
    };
 
    for (int i = 1; i <= n; i++) {
        i64 t;
        cin >> t;
        bool ok1 = cal1(t);
        bool ok2 = cal2(t);
        if (ok1 && ok2) {
            cout << t << ' ' << "is a triple flower" << '\n';
        }else if (ok1 && !ok2) {
            cout << t << ' ' << "is a double flower" << '\n';
        }else {
            cout << t << ' ' << "is" << ' ' << t << '\n';
        }
    }
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

8

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

void solve ()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        vector <i64> v;
        v.reserve(10001);
        i64 t;
        while (cin >> t) {
            if (t == -1) break;
            v.push_back(t);
        } 
        int m = v.size();
        bool ok = false;
        i64 ans1, ans2, ans3;
        unordered_map <i64, vector <int> > mp;
        for (int i = 0; i < m; i++) {
            if (i == m - 1 || i == m - 2) continue;
            mp[v[i]].push_back(i);
        }

        vector <array <i64, 4> > ans;
        unordered_map <int, int> mpp;
        mpp[v[m - 1]] = true;
        mpp[v[m - 2]] = true;
        for (int i = 0; i < m - 2; i++) {
            if (mpp[v[i]]) continue;
            i64 a = v[i + 1], b = v[i + 2];
            bool found = true;
            int cnt = 0;
            int pos = 0;
            for (auto x : mp[v[i]]) {
                i64 c = v[x + 1], d = v[x + 2];
                if (c != a || d != b) {
                    found = false;
                    break;
                }
                cnt++;
                if (cnt == 2) {
                    pos = x;
                }
                // cout << v[i] << ' ' << pos << '\n';
            }
            if (found && cnt >= 2) {
                ok = true;
                ans.push_back({pos, v[i], a, b});
            }
            mpp[v[i]] = true;
        }

        if (ans.size()) sort(ans.begin(), ans.end());
        if (ans.size()) {
            cout << ans[0][1] << ' ' << ans[0][2] << ' ' << ans[0][3] << '\n';
        }else {
            cout << "NONE\n";
        }
    }
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

9

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

void solve ()
{
    int n, m;
    cin >> n >> m;
    vector <vector <int> > e(m + 5);
    vector <vector <int> > v(n + 5);
    v.reserve(201 * 1001);
    for (int i = 1; i <= n; i++) {
        int t;
        cin >> t;
        v[i].reserve(1001);
        for (int j = 1; j <= t; j++) {
            int b;
            cin >> b;
            v[i].push_back(b);
            e[b].push_back(i);
        }
        sort(v[i].begin(), v[i].end());
        v[i].erase(unique(v[i].begin(), v[i].end()), v[i].end());
    }

    vector <vector <int> > a(n + 5);
    int cnt = 1;
    vector <int> vis(m + 5);
    vector <int> viss(n + 5);

    auto dfs = [&] (auto self, int u) -> void {
        for (auto x : e[u]) {
            if (viss[x]) continue;
            viss[x] = true;
            for (auto y : v[x]) {
                if (vis[y]) continue;
                vis[y] = true;
                a[cnt].push_back(y);
                self(self, y);
            }
        }
    };

    for (int i = 1; i <= m; i++) {
        if (vis[i]) continue;
        vis[i] = true;
        a[cnt].push_back(i);
        dfs(dfs, i);
        cnt++;
    }

    for (int i = 1; i < cnt; i++) {
        sort(a[i].begin(), a[i].end());
        if (i == cnt - 1) cout << a[i][0];
        else cout << a[i][0] << ' ';
    }
}

int main ()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

Codeforces Round 1072 (Div.3) E题题解

Tue, 13 Jan 2026 00:00:00 GMT

Codeforces Round 1072 (Div.3) E题题解

题意：

定义精致数组-$k$为任意相邻两数之差至少为$k$的数组。

给定长度为$n$的排列$p$，对于每一个从$1$到$n - 1$的$k$，找出精致数组-$k$的数量。

思路：

题目要求: 寻找相邻差值至少为$k$的数组个数。

这可以转化为：寻找差分数组中某一子段的最小值至少为$k$的数组个数。

这仍然很麻烦。于是我们可以先统计出最小值为$k,k\in [1, n - 1]$的子段数，最后再做前缀和即可转换为最小值至少为$k$的数组个数。

关于统计最小值为$k$的子段数，我们可以对差分数组中的每一个数进行单独计算：

对于第$i$个差值，我们可以利用两次单调栈统计出第$i$个差值左侧最近的满足$d[l]<=d[i]$的$l$和右侧最近的满足$d[r]<d[i]$的$r$，这样即可以求出对于当前的$d[i]$，以$d[i]$为最小值的数组个数：$(i - l + 1 - 1) \times (r - i + 1 - 1)$，即：$(i - l) \times (r - i)$。

这样即可不重不漏地统计出所有最小值为$k$的子段数，最后再从$1$到$n$做前缀和即可求出最小值至少为$k$的数组个数。

代码：

#include <bits/stdc++.h>
using namespace std;
using ld = long double;
#define int long long
#define fi first
#define se second

void solve ()
{
    int n; cin >> n;
    vector <int> v(n + 1), d(n + 3);
    for (int i = 1; i <= n; i++) {
        cin >> v[i];
        d[i] = abs(v[i] - v[i - 1]);
    }

    vector <int> al(n + 3, 1), br(n + 3, n + 1);
    vector <int> stk;

    for (int i = 2; i <= n; i++) {
        while (stk.size() && d[stk.back()] > d[i]) {
            stk.pop_back();
        }
        if (stk.size()) al[i] = stk.back();
        stk.push_back(i);
    }

    stk.clear();
    for (int i = n; i >= 2; i--) {
        while (stk.size() && d[stk.back()] >= d[i]) {
            stk.pop_back();
        }
        if (stk.size()) br[i] = stk.back();
        stk.push_back(i);
    }

    vector <int> ans(n + 1, 0);
    for (int i = 2; i <= n; i++) {
        ans[d[i]] += (br[i] - i) * (i - al[i]);
    }

    for (int i = n - 2; i >= 1; i--) {
        ans[i] += ans[i + 1];
    }

    for (int i = 1; i < n; i++) {
        cout << ans[i] << " \n"[i == n - 1];
    }
}   
    
signed main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

C语言作业答案(上)

Wed, 07 Jan 2026 00:00:00 GMT

C语言作业答案(上)

临近期末，打开oj，一笔没动，怎么办！

不用担心。这里有人经历过。为了不让更多的人经历如此磨难，现有答案供君参考。

若答案顺序与作业顺序不同，可联系笔者！

下给出笔者邮箱：2279839810@qq.com

第一章

求圆的面积和周长


#include <stdio.h>

int main()
{
	double r;
	double s, c;
	const double K=3.140000;
	
	scanf("%lf", &r);
	
	s=K*r*r;
	c=2*K*r;
	
	printf("%lf\n%lf", s, c);
	
	return 0;
}

求2个整数的和


#include <stdio.h>

int main()
{
	int a, b;
	
	scanf("%d %d", &a, &b);
	
	int c=a+b;
	
	printf("%d",c);
	
	return 0;
}

输出2行信息


#include <stdio.h>

int main()
{
	printf("Programing is fun.\n");
	printf("Programing in language C is even more fun!");
}

Hello World!


#include <stdio.h>

int main()
{
	printf("Hello World!");
	
	return 0;
}

设计函数求2个整数的最大值


int max (int x, int y) {
    if (x >= y) {
        return x;
    } else {
        return y;
    }
}

求2个整数的最大值


#include <stdio.h>

int main()
{
	int a, b, max;
	
	scanf("%d %d", &a, &b);
	
	if (a>b) max=a;
	else max=b;
	
	printf("max=%d",max);
	
	return 0;
}

This is a C program


#include <stdio.h>

int main()
{
	printf("This is a C program");
	
	return 0;
}

第二章

猫是液体


#include <stdio.h>

int main ()
{
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	
	int v = a * b * c;
	
	printf("%d", v);
	
	return 0;
}

中英长度单位换算


#include <stdio.h>

int main()
{
	int cm, foot, inch;
	
	scanf("%d", &cm);
	
    int t=cm/30.48;
	
	double n=cm/30.48;
	
	foot=t;
	
	inch=(n-t)*12;
	
	printf("%d %d", foot, inch)	;
	
	return 0;
}

打妖怪


#include <stdio.h>

int main()
{
	int a, b, c;
	
	scanf("%d %d", &a, &b);
	
	int rem=a%b;
	int t=a/b;
	
	if (rem==0)
	   printf("%d", t);
	   
	else 
	   printf("%d", t+1);
	
	return 0;
	
}

求整数均值


#include <stdio.h>

int main()
{
	int a, b, c, d;
	
	scanf("%d %d %d %d", &a, &b, &c, &d);
	
	int sum=a+b+c+d;
	double aver=(a+b+c+d)/4.00;
	
	printf("Sum = %d\nAverage = %.2f", sum, aver);
	
	return 0;
}

整数四则运算


#include <stdio.h>

int main()
{
	int a, b;
	
	scanf("%d %d", &a, &b);
	
	printf("%d + %d = %d\n", a, b, a+b); 
	printf("%d - %d = %d\n", a, b, a-b);
	printf("%d * %d = %d\n", a, b, a*b);
	printf("%d / %d = %d", a, b, a/b);
		   
	return 0;	   
}

分糖果


#include <stdio.h>

int main ()
{
	int x, y, z;
	scanf("%d %d %d", &x, &y, &z);
	
	int a = x / 3;
	x = a;
	y += a;
	z += a;
	
	int b = y / 3;
	x += b;
	y = b;
	z += b;
	
	int c = z / 3;
	x += c;
	y += c;
	z = c;
	
	printf("%d %d %d", x, y, z);
	
	return 0;
}

自由落体


#include <stdio.h>

int main ()
{
	int t;
	scanf("%d", &t);
	
	int h = 10 * t * t / 2;
	
	if (h > 2000) {
		printf("2000");
	}else {
		printf("%d", h);
	}
	
	return 0;
}

计算终止时间


#include <stdio.h>
#include <stdlib.h>

int main () 
{
    char str[4];
    double num;
    int a;
    
    scanf("%s %d", &str, &a);
    
    num = atof(str);
    
    int NUM = num;
    
    int min = NUM % 100;
    int hour = NUM / 100;
    
    int res = a + min;
    
    if (res >= 60) {
    	int temp = res / 60;
    	hour += temp;
    	res -= temp * 60;
	}else if (res < 0) {
		res = -res;
		int temp = res / 60;
		hour -= temp + 1;
		res -= temp * 60;
		res = 60 - res;
	}
	
	if (res >= 60) {
    	int temp = res / 60;
    	hour += temp;
    	res -= temp * 60;
    }

	printf("%d%02d", hour, res);

    return 0;
}

输出四位整数的各位数字


#include <stdio.h>

int main()
{
	int num;
	
	scanf("%d", &num);
	
	int a=num/1000, 
	    b=num/100-a*10, 
	    c=num/10-a*100-b*10,
	    d=num-a*1000-b*100-c*10;
	
	printf("%d=%d+%d*10+%d*100+%d*1000", num, d, c, b, a);
	
	return 0;
}

两小时学完C语言


#include <stdio.h>

int main()
{
	int n, k ,m;
	
	scanf("%d %d %d", &n, &k, &m);
	
	int remain=n-k*m;
	
	printf("%d", remain);
	
	return 0;
}

计算图形面积


#include <stdio.h>

int main()
{
	int a, b;
	
	scanf("%d %d", &a, &b);
	
	int s=abs(50*a-50*b);
	
	printf("%d", s);
	
	return 0;
}

折扣


#include <stdio.h>

int main()
{
	int ori, dis;
	
	scanf("%d %d", &ori, &dis);
	
	double final=ori*dis/10.00;
	
	printf("%.2f", final);
	
	return 0;
}

标准体重和身高的对应关系


#include <stdio.h>

int main()
{
	int h=0;
	
	scanf("%d", &h);
	
	double m=(h-100)*0.9*2;
	
	printf("%.1f", m);
	
	return 0;
}

后天


#include <stdio.h>

int main()
{
	int D=0;
	
	scanf("%d", &D);
	
	D+=2;
	
	if(D>7) D-=7;
	
	printf("%d", D);
	
	return 0;
}

第三章

字母对应的ASCII 码


#include <stdio.h>

int main()
{
	char ch;
	
	scanf("%c", &ch);
	
	printf("%d", ch);
	
	return 0;
}

温度转换


#include <stdio.h>

int main()
{
	double f=0;
	
	scanf("%lf", &f);
	
	double c=5.0/9.0*(f-32);
	
	printf("%lf", c);
	
	return 0;
}

计算圆的周长


#include <stdio.h>

int main()
{
	double r;
	double K=3.14;
	
	scanf("%lf", &r);
	
    double c=2*K*r;
    
    printf("%lf", c);
    
    return 0;
}

求三位整数的逆序数


#include <stdio.h>

int main()
{
	int num = 0;
	int result = 0;
	int digital = 0;
	
	scanf("%d", &num);
	
	while (num > 0){
		digital = num % 10;
		result = result * 10 + digital; 
		num /= 10;
	}
	
	printf("%03d", result);
	
	return 0;
}

求三角形面积


#include <stdio.h>
#include <math.h>

int main()
{
    double a, b, c;
    
    scanf("%lf %lf %lf", &a, &b, &c);
    
    double p = (a + b + c) / 2;
    
    double s = sqrt(p * (p - a) * (p - b) * (p - c));
    
    printf("%.2f", s);
    
    return 0;
}

计算浮点数相除的余数


#include <stdio.h>

int main()
{
	double a, b;
	
	scanf("%lf %lf", &a, &b);
	
	int k=0;
    double tag=0.0;
    double n=0.0;
    
    do{
    	n=a-k*b;
    	k++;
	}while (n>=0);
	
	double r=n+b;
	
	printf("%g", r);
	
	return 0;
}

年增长率


#include <stdio.h>
#include <math.h>

int main()
{
	int n;
	
	scanf("%d", &n);
	
	double x=pow(2.0, 1.0/n);
	
	double res=(x-1.0)*100;
	
	printf("%.2f%%", res);
	
	return 0;
}

快速求和


#include <stdio.h>

int main()
{
	int n;
	
	scanf("%d", &n);
	
	int tag;
	double s=0.0;
	
	for (tag=1; tag<=n; tag++){
		s+=1.0/(tag*(tag+1.0));
	}
	
	printf("%.5f", s);
	
	return 0;
}

混合类型数据格式化输入


#include <stdio.h>

int main()
{
	double a, b;
	int c;
	char d;
	
	scanf("%lf %d %c %lf", &a, &c, &d, &b);
	
	printf("%c %d %.2f %.2f", d, c, a, b);
	
	return 0;
}

定期存款


#include <stdio.h>

int main()
{
	double a, b;
	
	scanf("%lf %lf", &a, &b);
	
	double res1=a*b/100.0;
	
	double res2=res1+a;
	
	printf("%11.2f\n%11.2f\n%11.2f", a, res1, res2);
	
	return 0;
}

日期格式变化


#include <stdio.h>

int main()
{
	int m, d, y;
	
	scanf("%d-%d-%d", &m, &d, &y);
	
	printf("%02d-%02d-%02d", y, m, d);
	
	return 0;
}

水果店收款


#include <stdio.h>

int main()
{
	double a, b, c, d;
	
	scanf("%lf %lf %lf %lf,", &a, &b, &c, &d);
	
	double p=2.5*a+1.7*b+2*c+1.2*d;
	
	printf("%.2f", p);
	
	return 0;
}

计算房间面积


#include <stdio.h>

int main()
{
	double a, b;
	
	scanf("%lf\n%lf", &a, &b);
	
	double c=a*b;
	
	printf("the area of the room:%lf", c);
	
	return 0;
}

第四章

三天打鱼两天晒网


#include <stdio.h>

int main()
{
	int n;
	scanf("%d", &n);
	
	int tag = n % 5;
	
	switch (tag) {
		case 1:
		case 2:
		case 3:
			printf("Fishing in day %d", n);
		    break;
		    
		default:
			printf("Drying in day %d", n);
	}
	
	return 0;
	
}

闰年


#include <stdio.h>

int main()
{
	int yr;
	scanf("%d", &yr);
	
	int mask1 = yr%400;
	int lpyr = 0;
	
	int mask2 = yr%4;
	int mask3 = yr%100;
	
	if (mask1 == 0) {
		lpyr = 1;
	}else {
		if (mask2 == 0) {
			if (mask3 != 0 ){
				lpyr = 1;
			}
		}
	}
	
	if (lpyr == 1) {
		printf("%d is a leap year!", yr);
	}else {
		printf("%d isn't a leap year!", yr);
	}
	
	return 0;
	
}

三个整数排序


#include <stdio.h>

int main()
{
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	
	int num1, num2, num3;
	
	if (a > b) {
		if (a > c){
			num1 = a;
			if (b > c){
			    num2 = b, num3 = c;
		    }else {
			    num2 = c, num3 = b;
		        }
	        }else {
	        num1 = c, num2 = a, num3 = b;
			} 
		
	}else{
		if (b > c){
			num1 = b;
			if (a > c){
				num2 = a, num3 = c;
			}else {
				num2 = c, num3 = a;
			}
		}else{
			num1 = c, num2 = b, num3 = a;
		}
	}
	
	printf("a=%d,b=%d,c=%d", num3, num2, num1);
	
	return 0;
}

判断水仙花数


#include <stdio.h>

int main()
{
	int num;
	scanf("%d", &num);
	
	int a, b, c;
	a = num / 100;
	b = num / 10 - a * 10;
	c = num - a * 100 - b * 10;
	
	int A = 1;
	int B = 1;
	int C = 1;
	
	int cnt = 0;
	
	
	do {
		A *= a;
		B *= b;
		C *= c;
		
		cnt++;
		
	}while (cnt != 3);
	
	int res;
	res = A + B + C;
	
	if (res == num) {
		printf("YES");
		
	}else {
		printf("NO");
	}
	
	return 0;
	
}

计算奖金


#include <stdio.h>

int main()
{
	double p;
	scanf("%lf", &p);
	
	double bonus;
	
	if (p <= 100000) {
		bonus = p * 0.10;

	}else if (p > 100000 && p <= 200000) {
		bonus = 10000 + (p - 100000) * 0.075;

	}else if (p > 200000 && p <= 400000) {
		bonus = 17500 + (p - 200000) * 0.05;

	}else if (p > 400000 && p <= 600000) {
		bonus = 27500 + (p - 400000) * 0.03;

	}else if (p > 600000 && p <= 1000000) {
		bonus = 33500 + (p - 600000) * 0.015; 

	}else if (p > 1000000) {
		bonus = 39500 + (p - 1000000) * 0.01; 
	
	}//恶心 
	
	printf("%.2f", bonus);
	
	return 0;
}

按公式计算y和z的值


#include <stdio.h>
#include <math.h>

int main()
{
	double x = 0.0;
	scanf ("%lf", &x);
	
	double y, z;
	
	if (x >= 1 && x < 2) {
		y = x * x + 1.0;
		z = 3.0 * x + 5.0;
	}else if (x >= 2 && x <= 2.5) {
		y = x * x + 1.0;
		z = 2.0 * sin(x) - 1.0;
	}else if (x > 2.5 && x < 3) {
		y = x * x - 1.0;
		z = 2.0 * sin (x) - 1.0;
	}else if (x >= 3 && x < 5) {
		y = x * x - 1.0;
		z = sqrt (1.0 + x * x);
	}else if (x >= 5 && x < 8) {
		y = x * x - 1.0;
		z = x * x - 2 * x + 5;
	}
	
	printf("%lf\n%lf", y, z);
	
	return 0;
}

24小时时间记法转12小时时间记法


#include <stdio.h>

int main()
{
	int hor, min, sec;
	scanf("%d %d %d", &hor, &min, &sec);
	
	if (hor >= 12) {
		printf("%d %d %d PM", hor-12, min, sec);
	}else {
		printf("%d %d %d AM", hor, min, sec);
	}
	
	return 0;
	
}

能否构成三角形


#include <stdio.h>

int main()
{
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	
	if (a+b > c && a+c > b && b+c > a) {
		printf("YES");
	}else {
		printf("NO");
	}
	
	return 0;
}

找出3个整数居中的整数


#include <stdio.h>

int main()
{
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	
	int res;
	
	if (a > b) {
		if (b > c) {
			res = b;
		}else if (a > c) {
			res = c;
		}else {
			res = a;
		}
	}else if (a > c) {
		res = a;
	}else if (b > c) {
		res = c;
	}else {
		res = b;
	}
	
	printf("%d", res);
	
	return 0;
}

学生成绩评定


#include <stdio.h>

int main()
{
	int scr;
	scanf("%d", &scr);
	
	if (scr > 85) {
		printf("very good");
	}else if (scr <= 85 && scr >= 60) {
		printf("good");
	}else {
		printf("no good");
	}
	
	return 0;
	
}

求月份对应的英文名称及天数


#include <stdio.h>

int main()
{
	int mth;
	scanf("%d", &mth);
	
	switch ( mth ) {
		case 1:
			printf("January,31");
			break;
		
		case 2:
			printf("February,28/29");
			break;
			
		case 3:
			printf("March,31");
			break;
	
		case 4:
            printf("April,30");
            break;

		case 5:
			printf("May,31");
			break;

		case 6:
			printf("June,30");
			break;

		case 7:
			printf("July,31");
			break;

		case 8:
			printf("August,31");
			break;

		case 9:
			printf("September,30");
			break;

		case 10:
			printf("October,31");
			break;

		case 11:
			printf("November,30");
			break;

		case 12:
			printf("December,31");
			break;	
			
	}
	
	return 0;
	
}

百分制分数转换为等级


#include <stdio.h>

int main()
{
	int scr;
	scanf("%d", &scr);
	
	int tag = scr;
	scr /= 10;
	
	switch ( scr ) {
		case 10:
		case 9:
			printf("score=%d,grade:A", tag);
			break;
			
		case 8:
			printf("score=%d,grade:B", tag);
			break;
			
		case 7:
			printf("score=%d,grade:C", tag);
			break;
			
		case 6:
			printf("score=%d,grade:D", tag);
			break;
			
	    default:
			printf("score=%d,grade:E", tag);
			break;
	}
	
	return 0;
}

第五章1

求若干整数的最大值


#include <stdio.h>

int main()
{
	int n;
	scanf("%d", &n);
	
	int max = 0;
	int cnt = 1;
	int num = 0;
	
	scanf("%d", &max);
	
	for (cnt = 1; cnt < n; cnt++) {
		scanf("%d", &num);
		if (num > max) {
			max = num;
		}
	}
	
    printf("%d", max);
	
	return 0;
}

n！


#include <stdio.h>

int main()
{
	int num = 0;
	int res = 1;
	int fac = 1;
	
	scanf("%d", &num);
	
	while (fac <= num){
		res *= fac;
		fac++;
	}
	
	printf ("%d!=%d", num, res);
	
	return 0;
}

最大公约数


#include <stdio.h>

int main()
{
	int num1, num2;
	scanf("%d %d", &num1, &num2);
	
	int mask = 0;
	
	while (num2 != 0) {
		mask = num1 % num2;
		num1 = num2;
		num2 = mask;
	}
	
	printf("%d", num1);
	
	return 0;
}//解决了1 2的公约数是1的问题

最小值和最大值


#include <stdio.h>

int main ()
{
	int n = 0;
	scanf("%d", &n);
	
	int first = 0;
	scanf("%d", &first);
	
	int max = first;
	int min = first;
	int num = 0;
	int cntmax = 1;
	int cntmin = 1;
	
	for (int cnt = 1; cnt < n; cnt++) {
		scanf("%d", &num);
		if (num > max) {
			max = num;
			cntmax = 1;
		}else if (num == max) {
			cntmax++;
		}
		if (num < min) {
			min = num;
			cntmin = 1;
		}else if (num == min) {
			cntmin++;
		}
	}
	
	printf("%d %d\n%d %d", min, cntmin, max, cntmax);
	
	return 0;
}

连续因子


#include <stdio.h>

int main() {
    long long n;
    scanf("%lld", &n);

    long long len = 0;
    long long ans = 0;

    for (long long i = 2; i * i <= n; i++) {
        long long temp = 1;
        long long k = i;
        while (temp * k <= n) {
            temp *= k;
            if (n % temp == 0 && k - i + 1 > len) {
                len = k - i + 1;
                ans = i;
            }
            k++;
        }
    }

    if (len == 0) {
        printf("1\n%lld\n", n);
    } else {
        printf("%lld\n", len);
        for (int i = 0; i < len; i++) {
            if (i > 0) printf("*");
            printf("%lld", ans + i);
        }
        printf("\n");
    }

    return 0;
}

打印沙漏


#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int sum = -1;
	int i = 2;
	
	while (n - sum - i >= 0) {
		sum += i;
		i += 4;
	}
	
	int k = i;
	int j = 1;
	int u = 1;
	
	while (k > 2) {
		
	int t = k / 2;
	int j = u;
	
		while (t > 2) {
			if (t == 3) {
				printf("*\n");
			}else {
				printf("*");
			}
			t--;
		}
		
		while (j > 0 && k > 6) {
			printf(" ");
			j--;
		}
		
	k -= 4;
	u += 1;

	}
	
	k = i;
	u -= 3;
	int p = 3;
	int m = 3;
	
	while (u >= 0) {
		
		j = u;
	 	p = m;
	 	
		while (j > 0) {
			printf(" ");
			j--;
		}
		
		while (p > 0) {
			if (p == 1) {
				printf("*\n");
			}else {
				printf("*");
			}
			p--;
		}
		
		m += 2;
		u -= 1;
	}

	int difference = n - sum;
	
	printf("%d", difference);
	
	return 0;
}

念数字

#include <stdio.h>

int main()
{
    int x;
    scanf("%d", &x);
    
    int mask = 1;
    int t = x;
    
    if (x < 0) {
    	printf("fu ");
    	x = - x;
    	t = - t;
	}
    
	while (t > 9) {
    	t /= 10;
    	mask *= 10;
	}
	
	do {
		int d = x / mask;
		
		switch (d) {
			case 0:
				printf("ling");
				break;
			case 1:
				printf("yi");
				break;
			case 2:
				printf("er");
				break;
			case 3:
				printf("san");
				break;
			case 4:
				printf("si");
				break;
			case 5:
				printf("wu");
				break;
			case 6:
				printf("liu");
				break;
			case 7:
				printf("qi");
				break;
			case 8:
				printf("ba");
				break;
			case 9:
				printf("jiu");
				break;								
		}
		
		x %= mask;
		mask /= 10;
		
		if (mask > 0) {
			printf(" ");
		}
		
	}while (mask > 0);

	return 0;	
}

N个有理数求和

#include <stdio.h>
#include <stdlib.h>

#define ll long long

ll abss(ll x) { return x < 0 ? -x : x; }

ll gcd(ll a, ll b) {
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    while (b != 0) {
        ll t = a % b;
        a = b;
        b = t;
    }
    return a;
}

int main() {
    int n;
    if (scanf("%d", &n) != 1) return 0;

    ll num = 0;
    ll den = 1;

    for (int i = 0; i < n; ++i) {
        ll a, b;
        scanf("%lld/%lld", &a, &b);

        ll g = gcd(den, b);
        ll den1 = den / g;
        ll b1 = b / g;

        ll new_num = num * b1 + a * den1;
        ll new_den = den * b1;

        ll g2 = gcd(abss(new_num), new_den);
        new_num /= g2;
        new_den /= g2;

        if (new_den < 0) { new_den = -new_den; new_num = -new_num; }

        num = new_num;
        den = new_den;
    }

    ll integer = num / den;
    ll remainder = num % den;

    if (remainder == 0) {
        printf("%lld", integer);
        putchar('\n');
    } else {
        if (integer != 0) {
            printf("%lld", integer);
            putchar(' ');
            printf("%lld", remainder);
            putchar('/');
            printf("%lld", den);
            putchar('\n');
        } else {
            printf("%lld", remainder);
            putchar('/');
            printf("%lld", den);
            putchar('\n');
        }
    }

    return 0;
}

画方块

#include <stdio.h>
#include <math.h>

int main()
{
	double n;
	char c;
	scanf("%lf %c", &n, &c);
	
	int cnt = 0;
	double mask = 0.0;
	int tag = round (n / 2);
	
	while (cnt <= n) {
		cnt++;
		printf("%c", c);
		if (cnt == n) {
			printf("\n");
			cnt = 0;
			mask ++;
			if (mask == tag) {
				break;
			}
		} 
	}
	
	return 0;
}

守形数

#include <stdio.h>

int main()
{
	int min, max;
	scanf("%d %d", &min, &max);
	
	int tag = min;
	int mask = 10;
	int test = 0;
	int isfirst = 1;
	
	for (tag = min; tag <= max; tag++) {
		int t = tag * tag;
		int p = tag;
	    mask = 1;
		while (p > 0) {
			p /= 10;
			mask *= 10;
		}
		int cur = t % mask;
		if (cur == tag) {
			if (isfirst == 1) {
				printf("%d", tag);
				test = 1;
				isfirst = 0;
			}else{
			printf(" %d", tag);
		}
	}
	}
	
	if (test == 0) {
		printf("No exist");
	}

	return 0;
}

含数字5且是3的倍数

#include <stdio.h>

int main ()
{
	int m, n;
	scanf("%d %d", &m, &n);
	
	int i = m;
	int tag = 1;
	
	while (i <= n) {
		
		int j = 1;
		int k = i;
		
		int mask = 0;
		
		while (k > 0) {
			int num = k % 10;
			if (num == 5) {
				mask = 1;
				break;
			}else {
				k /= 10;
			}
		}
		
		if (i % 3 == 0 && mask == 1) {
			if (tag == 1) {
				printf("%d", i);
				tag = 0;
			}else {
				printf(" %d", i);
			}
		}
		
		i++;
		
	}
	
	if (tag == 1) {
		printf("No exist");
	}
	
	return 0;
	
}

小球自由落体

#include <stdio.h>

int main()
{
	int n;
	scanf("%d", &n);
	
	int cnt = 0;
	double res = 0.0;
	double h = 100.0;
	int tag = 1;
	
	for (cnt = 0; cnt< n; cnt++) {
		if (tag == 1) {
			res += 100;
			tag = 0;
		}else {
			h /= 2;
		    res += h*2;
		    
		}
	}
		  
	printf("%lf %lf", res, h/2);

    return 0;

}

鸡兔同笼

#include <stdio.h>

int main()
{
	int h, f;
	scanf("%d %d", &h, &f);
	
	int c = 0;
	int r = 0;
	int res = 0;
	
    for (r = 0; r<= h; r++) {
    	c = h - r;
    	if (4*r + 2* c == f) {
    		res = 1;
    		break;
		}
	}
    
	if (res == 1) {
		printf ("%d %d", c, r);
	}else {
		printf("Error");
	}
	
	return 0;
	
}

计算π的近似值

#include <stdio.h>

int main()
{
	int n;
	scanf("%d", &n);
	
	int cnt = 0;
	double res = 0.0;
	int i = 1;
	int sign = 1;
	
	for (cnt = 0; cnt < 2*n; cnt++) {
		res += sign * 1.0 / i;
		i += 2;
		sign = -sign;
	}
	
	printf("%lf", res*4.0);
	
	return 0;
}

“韩信点兵”数

#include <stdio.h>

int main()
{
	int min, max;
	scanf("%d %d", &min, &max);
	
	int res = 0;
	int cnt = 0;
	int tag = 1;
	
	for (res = min; res <= max ; res++) {
		if (res % 3 == 2 && res % 5 == 3 && res % 7 == 4) {
                if ( tag == 1) {
                    printf("%d", res);
                    tag = 0;
                    cnt++;
                }else {
                cnt++;
                printf(" %d", res);
			}
		}
		
	}
	
	if (cnt == 0) {
		printf("total=0");
	}else {
		printf("\ntotal=%d", cnt);
    }
	
	return 0;
}

祖孙年龄

#include <stdio.h>

int main()
{
	int x, y1, y2, y3;
	scanf("%d %d %d %d", &x, &y1, &y2, &y3);
	
	int res = x - y1 - y2 - y3;
	
	if (res % 2 == 0) {
		printf("%d", res / 2 );
	}else {
		printf("%d", (res + 1) / 2 );
	}
	
	return 0;
}

输出Fibonacci数列的前n项

#include <stdio.h>

int main()
{
	int n;
	scanf("%d", &n);
	
	int i = 1;
	int j = 0;
	int k;
	int cnt;
	int p = 1;
	
	for (cnt = 0; cnt < n; cnt++) { 
		printf("%10d", i);
		if (p % 5 == 0 && p!= 0) {
			printf("\n");
		}
		k = i;
		i = j + i;
		j = k;
		p++;
	}
	
	return 0;
}

菱形图案

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	n += 1;
	
	int cnt = 1;
	int CNT = 1;
	
	for (int s = n - 1; s > 0; s--) {
		for (int cnt_s = s; cnt_s > 1; cnt_s--) {
			printf(" ");
		}
		
		int cnt_q = 1;
		
		for ( ; cnt_q <= cnt; cnt_q++) {
			if (cnt_q == cnt) {
				printf("*\n");
			}else {
				printf("*");
			}
		}
	
		cnt += 2;
	}
	
	int CNT_S = 1;
	int mask = 0;
	int tag = 1;
	
	for (int S = n - 2; S > 0; S--) {		
		int cnt_S = 1;
		for (int cnt_S = 1 ; cnt_S <= CNT_S; cnt_S++) {
			mask++;
			if (cnt_S == 1 && tag == 0) {
				printf("\n ");
			}else {
				printf(" ");
			}	
		}

		int cnt_Q = 2 * (n - 1) - 3;
		
		for ( ; cnt_Q > 0; cnt_Q--) {
			if (cnt_Q == 1) {
				printf("*");
			}else {
				printf("*");
			}
		} 
		
		CNT += 1;
		n--;
		CNT_S++;
		tag = 0;
	}
	
	return 0;
}

计算某分数序列的前n项之和

#include <stdio.h>

int main()
{
	int n;
	scanf("%d", &n);
	
	double sum = 0.0;
    int cnt = 0;
	double i = 2.0;
	double j = 1.0;
	double k = 2.0;
	
	for (cnt = 0; cnt < n; cnt++) {
		sum += i / j;
		k = i;
		i += j;
		j = k; 
	}
	
	printf("%lf", sum);
	
	return 0;
}

素数

#include <stdio.h>

int main()
{
	int num;
	int i;
	int isprime = 1;
	
	scanf("%d", &num);
	
	if (num == 1) {
		printf("NO");
		goto final;
	}else { 
	
	for (i = 2; i < num; i++){
		if (num % i == 0){
			isprime = 0;
			break;
		}
		
	}
	if (isprime == 1) {
		printf("YES");
	}else {
	    printf("NO"); 
	}
}
final:
	
	return 0;
}

第五章2

寻找250

#include <stdio.h>

int main ()
{	
    int result = 1;
    int cnt = 0;

	do {
		int num = 0;
		result = scanf("%d", &num);
		cnt++;
		if (num == 250) {
			break;
		}
	}while (result == 1);
	
	printf("%d", cnt);
	
	return 0;
	
}

计算阶乘和

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int cnt = 1;
	int s = 0;
	
	do {
		int count = 1;
		int cur = 1;
		while (count <= cnt) {
			cur = count * cur;
			count++; 
			} 
		s += cur;
		cnt++;
	} while (cnt <= n);
	
	printf("%d", s);
	
	return 0;
}

整除光棍

#include<stdio.h>

int main()
{	    
	int x;
	scanf("%d", &x);		
	int count = 1;   
	int a = 1;	    

	while (a < x) {			
		a = a * 10 + 1;		
		count++;
	}
	printf("%d", a / x);
		
	int t = a % x;  
	
	while (t != 0) {			//利用循环将商从高到低位依次输出，直到余数为0。
		t = t * 10 + 1;		
		printf("%d", t / x);
		count++;
		t %= x;
	}
	printf(" %d", count);

	return 0;
}

求幂级数展开的部分和

#include <stdio.h>

int main ()
{
	double x;
	scanf("%lf", &x);
	
	double res = 1;
	int t = x;
	double temp = 1;
	int cnt = 1;
	
	while (temp >= 0.000001) {
		temp = temp * x / cnt;
		res += temp;
		cnt++;
	}
	
	printf("%.5f", res);
	
	return 0;
}

求奇数和

#include <stdio.h>

int main ()
{
	int num = 1;
	int temp = 0;
	int res = 0;
	
	while (num > 0) {
		scanf("%d", &num);
		if (num > 0) {
			temp = num % 2;
			if (temp != 0) {
				res += num;
		    }	
		}
		
	}
	
	printf("%d", res);
	
	return 0;
}

猴子吃桃问题

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int res = 1;
	
	for (int cnt = 1; cnt < n; cnt++) {
		res = (res + 1) * 2;
	}
	
	printf("%d", res);
	
	return 0;
}

水仙花数

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int first = 1;
	int i = 1;
	
	while (i < n) {
		first *= 10;
		i++;
	}
	
    i = first;
    
    while (i < first * 10) {
    	int t = i;
    	int sum = 0;
    	
    	do {
    		int d = t % 10;
    		t /= 10;
    		int p = d;
    		int j = 1;
    		
    		while (j < n) {
    			p *= d;
    			j++;
			}
			sum += p;
			
		} while (t > 0);
		
		if (sum == i) {
			printf("%d\n", i);
		}
    	
    	i++;
	}
	
	return 0;
}

兔子繁衍问题

#include <stdio.h>

int main() {
    int N;
    scanf("%d", &N);

    if (N <= 1) {
        printf("1\n");
        return 0;
    }

    int a = 1;
    int b = 1;
    int month = 2;

    while (b < N) {
        int c = a + b;
        a = b;
        b = c;
        month++;
    }

    printf("%d\n", month);
    return 0;
}

黑洞数

#include <stdio.h>

int main ()
{
	int num = 0;
	scanf("%d", &num);
	
	int x = num;
	int temp = 0;
	int X = 0;
	int cnt = 1;
	
	do {
		int c = 0;
		int b = 0;
		int a = 0;
		
		c = x / 100;
		b = x / 10 - c * 10;
		a = x - c * 100 - b * 10;
		
		if (a > b) {
			if (b > c) {
				temp = a * 100 + b * 10 + c;
				x = c * 100 + b * 10 + a;
			}else if (a > c) { 
				temp = a * 100 + c * 10 + b;
				x = b * 100 + c * 10 + a;
			}else {
				temp = c * 100 + a * 10 + b;
				x = b * 100 + a * 10 + c;
			}
		}else if (a > c) {
			temp = b * 100 + a * 10 + c;
			x = c * 100 + a * 10 + b;
		}else if (b > c) {
			temp = b * 100 + c * 10 + a;
			x = a * 100 + c * 10 + b;
		}else {
			temp = c * 100 + b * 10 + a;
			x = a * 100 + b * 10 + c;
		}
	  
	    int mask = temp - x;
	    if (mask == 495) {
	    	printf("%d: %d - %d = %d", cnt, temp, x, mask);
		}else {
	        printf("%d: %d - %d = %d\n", cnt, temp, x, mask);
 		}
		X = x;
		x = mask;
		cnt++;
		
	}while (temp - X != 495);
	
	return 0;
}

输出三角形字符阵列

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	char chr = 'A';
	int cnt = 0;
	int N = n;
	int mask = 1;
	
	while (cnt <= n) {
		
		if (N == 1 && mask == 1) {
			printf("%c\n", chr);	
		}else if (N > 1 && mask == 1) {
			printf("%c ", chr);	
		}else if (N == 1 && mask == 0) {
			printf("%c", chr);
		}
		
		chr++;
		N--;
		
		if (N == 0) {
			n -= 1;
			N = n;
			cnt = 0;
		} 
		
		if (N == 1 && n == 1) {
			mask = 0;
		} 
		
		cnt++;
		
	}
	
	return 0;
	
}

求整数的位数及各位数字之和

#include <stdio.h>

int main() {
    long long N;
    scanf("%lld", &N);

    int digits = 0;
    int sum = 0; 
    long long temp = N;

    while (temp > 0) {
        sum += temp % 10; 
        temp /= 10; 
        digits++;
    }

    printf("%d %d\n", digits, sum);
    return 0;
}

特殊a串数列求和

#include <stdio.h>

int main ()
{
	int a, n;
	scanf("%d %d", &a, &n);
	
	int temp = a;
	int res = a;
	
	for (int cnt = 0; cnt < n - 1; cnt++) {
		temp = temp * 10 + a;
		res += temp;
		
	}
	
	printf("%d", res);
	
	return 0;
}

验证“哥德巴赫猜想”

#include <stdio.h>

int main ()
{
	long int n;
	scanf("%ld", &n);
	
	long int b = 0;
	long int num1 = 0;
	long int num2 = 0;
	
	for (long int t = 2; t <= n; t++) {
		int isPrime = 1;
		
		for (long int i = 2; i * i < t; i++) {
			if (t % i == 0 && t != 2) {
				isPrime = 0;
				break;
			}
		}
		
		if (isPrime == 1) {
			num1 = t;
			b = n - t;
		}
		
		int isprime = 1;
		
		for (long int j = 2; j * j < b; j++) {
			if (b % j == 0 && b != 2) {
				isprime = 0;
				break;
			}
		}
		
		if (isprime == 1) {
			num2 = b;
			break;
		}
	}
	
	printf("%ld = %ld + %ld", n, num1, num2);
	
	return 0;
	
}

换硬币

#include <stdio.h>

int main ()
{
	int x;
	scanf("%d", &x);
	
	int one;
	int two;
	int five;
	int mask = 0;
	
	for (five = x / 5; five != 0; five--) {
		for (two = x / 2; two != 0; two--) {
			for (one = x - 1; one != 0; one--) {
				if (one + two * 2 + five * 5 == x) {
					int cnt = one + two + five;
					printf("fen5:%d, fen2:%d, fen1:%d, total:%d\n", five, two, one, cnt);
					mask++;
				}
			}
		}
	}
	
	printf("count = %d", mask);
	
	return 0;
}

统计素数并求和

#include <stdio.h>

int main () 
{
	int m, n;
	scanf("%d %d", &m, &n);
	
	int cnt = 0;
	int res = 0;
	
	if (m < 2) {
		m = 2;
	}
	
	for (int t = m; t <= n; t++) {
		int isPrime = 1;
		for (int x = 2; x < t; x++) {
			int rem = t % x;
			if (rem == 0) {
				isPrime = 0;
				break;
			}
		}
		if (isPrime == 1) {
			res += t;
			cnt++;
		}
	}
	
	printf("%d %d", cnt, res);
	
	return 0;
}

求e的近似值

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	double e = 1;
	double res = 1;
	
	for (int num = 1; num <= n; num++) {
		res = 1;
		for (int t = 1; t <= num; t++) {
			res *= t;
		}
		e += 1.0 / res;
	}
	
	printf("%.8f", e);
	
	return 0;
}

求平方与倒数序列的部分和

#include <stdio.h>

int main ()
{
	double m, n;
	scanf("%lf %lf", &m, &n);
	
	double s = 0;
	
	for ( ; m <= n; m++) {
		s += m * m + 1.0 / m;
	}
	
	printf("%.6f", s);
	
	return 0;
}

求组合数

#include <stdio.h>

int main()
{
	int n, m;
	scanf("%d %d", &n, &m);
	
	double N = 1;
	
	for (int numN = 1; numN <= n; numN++) {
		N *= numN;
	}
	
	double M = 1;
	
	for (int numM = 1; numM <= m; numM++) {
		M *= numM;
	}
	
	double C = 1;
	
	for (int numC = 1; numC <= m - n; numC++) {
		C *= numC;
	}
	
	double res = M / N / C;
	
	printf("%.0f", res);
	
	return 0;
}

求简单交错序列前N项和

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int den = 1;
	double s = 0;
	int sign = 1; 
	
	for (int cnt = 0; cnt < n; cnt++) {
		s += sign * 1.0 / den;
		den += 3;
		sign = -sign;
	}
	
	printf("%.4f", s);
	
	return 0;
}

最佳情侣身高差

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
    char x;
	double h;
	int cnt = 0;
	
	do {
	    scanf(" %c", &x);
		scanf("%lf", &h);
		if (x == 'M') {
			h /= 1.09;
		}else {
			h *= 1.09;
		}
		
		printf("%.2f\n", h);
		cnt++;
    } while (cnt < n);	
    
    return 0;
}

C语言作业答案(下)

Wed, 07 Jan 2026 00:00:00 GMT

C语言作业答案(下)

第六章1

逆序输出输入的整数

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int num [n];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &num [i]);
	}
	
	int mask = 1;
	
	for (int j = n - 1; j >= 0; j--) {
		if (mask == 1) {
			printf("%d", num [j]);
			mask = 0;
		}else {
			printf(" %d", num [j]);
		}
	}
	
	return 0;
	
}

统计各大写字母的个数

#include <stdio.h>

int main ()
{
	char s[10000];
	scanf("%[^\n]", s);
	
	int cnt[26] = {0};
	
	for (int i = 0; s[i] != '\0'; i++) {
		if (s[i] >= 'A' && s[i] <= 'Z') {
			cnt[s[i] - 'A']++;
		}
	}
	
	for (int i = 0; i < 26; i++) {
		printf("%c(%d)", 'A' + i, cnt[i]);
		if ((i + 1) % 5 == 0) {
			printf("\n");
		}
	}
	
	return 0;
	
}

输出斐波那契数列的前n项

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int num [n];

	for (int i = 0; i < n; i++) {
		if (i == 0 || i == 1) {
			num [i] = 1; 
		}else {
			num [i] = num [i - 1] + num [i - 2];
		}	
	}
	
	int mask = 1;
		
	for(int j = 0; j < n; j++) {
		if (mask % 5 == 0) {
			if (mask == n) {
				printf("%10d", num [j]);
			}else {
				printf("%10d\n", num [j]);
				mask++;
			}
		}else {
			printf("%10d", num [j]);
			mask++;
		}
	}
	
	return 0;
	
}

约瑟夫问题

#include <stdio.h>

int main()
{
	int n, m, s;
	scanf("%d %d %d", &n, &m, &s);
	
	int num[n + 1];
	num[0] = 0;
	
	for (int i = 1; i <= n; i++) {
		num[i] = i;
	}
	
	int i = s;
	int t = n;
	
	while (t > 0) {
		int cnt = 0;
		while (cnt < m) {
			if (num[i] != 0) {
				cnt++;
			}
			
			if (cnt < m) {
				i++;
				if (i > n) {
					i = 1;
				}
			}
		}
		printf("%3d", num[i]);
		num[i] = 0;
		t--;
		
		do {
			i++;
			if (i > n) {
				i = 1;
			}
		}while (num[i] == 0 && t > 0);
		
	}
	
	return 0;
	
}

奇数阶幻方问题

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int s[n][n];
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			s[i][j] = 0;
		}
	}
	
	int i = 0;
	int j = (n - 1) / 2;
	
	for (int k = 1; k <= n * n; k++) {
		s[i][j] = k;
		int I = i;
		int J = j;
		i -= 1;
		j += 1;

		if (i < 0) {
			i = n - 1;
		}
		if (j > n - 1) {
			j = 0;	
		}
		if (s[i][j] != 0) {
			i = I + 1;
			j = J;
		}
		
	}
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			printf("%4d", s[i][j]);
			if (j == n - 1) {
				printf("\n");
			}
		}
	}
	
	return 0;
}

统计学生的总分以及各课程的平均分

#include <stdio.h>

int main ()
{
	int n, m;
	scanf("%d %d", &n, &m);
	
	char name[n][100];
	int grade[n][m];
	
	int sum[n];
	
	for (int i = 0; i < n; i++) {
		sum[i] = 0;
	}
	
	for (int i = 0; i < n; i++) {
		scanf("%s", name[i]);
		for (int j = 0; j < m; j++) {
			scanf("%d", &grade[i][j]);
			sum[i] += grade[i][j];
		}
	}
	
	for (int i = 0; i < n; i++) {
		printf("%-8s", name[i]);
		printf("%6d", sum[i]);
		for (int j = 0; j < m; j++) {
			printf("%6d", grade[i][j]);
		}
		printf("\n");
	}
	
	double aver[m];
	
	for (int i = 0; i < m; i++) {
		aver[i] = 0;
	}
	
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			aver[i] += grade[j][i];
		}
		aver[i] /= n;
	}
	
	printf("average score:");
	
	for (int i = 0; i < m; i++) {
		printf("%6.1f", aver[i]);
 	}	
	
	return 0;
	
}

统计学生成绩的最高最低分以及超过平均分的人数

#include <stdio.h>

int main () 
{
	
	int n;
	scanf("%d", &n);
	
	int grade[n];
	double aver = 0;
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &grade[i]);
		aver += grade[i];
	}
	
	aver /= n;
	
	int cnt = 0;
	
	for (int i = 0; i < n; i++) {
		if (grade[i] > aver) {
			cnt++;
		}
	}
	
	int min = grade[0];
	
	for (int i = 1; i < n; i++) {
		if (grade[i] < min) {
			min = grade[i];
		}
	}
	
	int max = grade[0];
	
	for (int i = 1; i < n; i++) {
		if (grade[i] > max) {
			max = grade[i];
		}
	}
	
	printf("%d %d %d", max, min, cnt);
	
	return 0;
}

进制转换

#include <stdio.h>

int main ()
{
	char str[100];
	
	int num = 0;
	int i = 0;
	char c;
	
	while ((c = getchar()) != '#') {
		if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')) {
			str[i++] = c;
			num *= 16;
			if (c >= '0' && c <= '9') {
                num += c - '0';
            }else if (c >= 'A' && c <= 'F') {
                num += c - 'A' + 10;
            }else if (c >= 'a' && c <= 'f') {
            	num += c - 'a' + 10;
			}
		}
	}
	
	str[i] = '\0';
	
	printf("String:%s\n", str);	
	printf("number=%d", num);
	
	return 0;
	
}

求最大字符串

#include <stdio.h>
#include <string.h>

int main ()
{
	int n;
	scanf("%d", &n);
	getchar();
	
	char str[n][100];
	
	for (int i = 0; i < n; i++) {
		gets(str[i]);
	}
	
	int maxI = 0;
	
	for (int i = 1; i < n; i++) {
		if (strcmp(str[i], str[maxI]) > 0) {
			maxI = i;
		}
	}
	
	printf("%s", str[maxI]);
	
	return 0;
	
}

字符串首尾相连

#include <stdio.h>
int main() {
    char str1[101],str2[101];
    int i,j;

    gets(str1);
    gets(str2);
  // Here is your code
    i = 0;
    while (str1[i] != '\0' && str1[i] != '\n') {
        i++;
    }
    str1[i] = '\0'; 
    
    j = 0;
	while (str2[j] != '\0' && str2[j] != '\n') {
        j++;
    }
    str2[j] = '\0';
    
	for (int k = 0; k < j; k++) {
        str1[i] = str2[k];
        i++;
    }
    str1[i] = '\0';

  puts(str1);
  return 0;
}

统计各数字出现的次数

#include <stdio.h>

int main ()
{
	char c;
	int num[10] = {0};
	
	while (c != '!'){
		scanf("%c", &c);
		if (c >= '0' && c <= '9') {
			num[c - '0']++;
		}
	}
	
	for (int i = 0; i < 10; i++) {
		if (i == 9) {
			printf("The character %d appears %d times", i, num[i]);
		}else {
			printf("The character %d appears %d times\n", i, num[i]);
		}
	}
	
	return 0;
	
}

找出二维数组中的最小元素

#include <stdio.h>

int main ()
{
	int m, n;
	scanf("%d %d", &m, &n);
	
	int a[m][n];
	
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			scanf("%d", &a[i][j]);
		}
	}
	
	printf("before:\n");
	
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			printf("%4d", a[i][j]);
		}
		printf("\n");
	}
	
	printf("after:\n");
	
	int min =a[0][0];
	
	int I = 0;
	int J = 0;
	
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			if (a[i][j] < min) {
				min = a[i][j];
				I = i;
				J = j;
			}
		}
	}
	
	for (int j = 0; j < n; j++) {
		int t = a[m - 1][j];
		a[m - 1][j] = a[I][j];
		a[I][j] = t;
	}
	
	int mask = 0;
	
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			printf("%4d", a[i][j]);
		}
		if (i != m - 1) {
			printf("\n");
		}
	}
	
	return 0;
}

矩阵转置

#include <stdio.h>

int main ()
{
	int n, m;
	scanf("%d %d", &n, &m);
	
	int a[n][m];
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			scanf("%d", &a[i][j]);
		}
	}
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			if (j == m - 1) {
				printf("%d", a[i][j]);
			}else {
				printf("%d ", a[i][j]);
			} 
		}
		printf("\n");
	}
	
	int b[m][n];
	
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			b[i][j] = a[j][i];
			if (j == n - 1) {
				printf("%d", b[i][j]);
			}else {
				printf("%d ", b[i][j]);
			} 
		}
		printf("\n");
	}	
	
	return 0;
		
}

二分查找

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int num[n];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	
	int res;
	scanf("%d", &res);
	
	int a = 0;
	int b = n - 1;
	
	int mask = 0;
	
	while (a <= b) {
		
		int mid = a + (b - a) / 2;
		
		if (num[mid] == res) {
			printf("%d", mid);
			mask = 1;
			break;
		}else if (num[mid] < res) {
			a = mid + 1;
		}else {
			b = mid - 1;
		}
	}
	
	if (mask == 0) {
		printf("Not found");
	}
	
	return 0;
	
}

冒泡排序

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int num[100];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	
	for (int i = 0; i < n - 1; i++) {
		for (int j = 0; j < n - 1 - i; j++) {
			if (num[j] > num[j + 1]) {
				int t = num[j];
				num[j] = num[j + 1];
				num[j + 1] = t;
			}
		}
	}
	
	for (int i = 0; i < n; i++) {
		printf("%d", num[i]);
		if (i != n - 1) {
			printf(" ");
		} 
	}
	
	return 0;
	
}

第六章2

大写改小写

#include <stdio.h>

int main ()
{
	char ch;
	while (scanf("%c", &ch) != EOF && ch != '\n') {
		if (ch >= 'A' && ch <= 'Z') {
			ch += 32;
		}
		putchar(ch);
	}
	
	return 0;
	
}

串比较

#include <stdio.h>

int main ()
{
	char str1[101];
	gets(str1);
	
	char str2[101];
	gets(str2);
	
	int i = 0;
	
	while (str1[i] != '\0' && str2[i] != '\0' && str1[i] == str2[i]) {
		i++;
	}
	
	printf("%d", str1[i] - str2[i]);
	
	return 0;
}

串复制

#include <stdio.h>
int main() {
	char str1[101],str2[101];
	int i;
	gets(str1);
	// Please fill this blank
	for (i = 0; str1[i] != '\0'; i++) {
		str2[i] = str1[i]; 
	}
	str2[i] = '\0';
	
	puts(str2);
	return 0;
}

逆向输出字符串

#include <stdio.h>

int main () 
{
	char str1[101],str2[101];
	int i,j;
	gets(str1);
	// Please fill this blank
	int l = 0;
	while (str1[l] != '\0') {
		l++;
	}
	for (i = 0, j = l - 1; j >= 0; i++, j--) {
		str2[i] = str1[j];
	}
	
	str2[l] = '\0';
	
	puts(str2);
	return 0;
}

对方阵做统计处理

#include <stdio.h>

void Traverse(int n, int s[n][n])
{
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			scanf("%d", &s[i][j]);
		}
	}
}

int sumD(int n, int s[n][n])
{
	int sum = 0;
	
	for (int i = 0; i < n; i++) {
		sum += s[i][i];
	}
	
	for (int i = 0; i < n; i++) {
		sum += s[n - 1 - i][i];
	}
	
	if (n % 2 != 0) {
		sum -= s[(n - 1) / 2][(n - 1) / 2];
	}
	
	return sum;
	
}

int multiple(int n, int s[n][n])
{
	int m = 1;
	
	for (int i = 0; i < n; i += 2) {
		m *= s[i][i]; 
	}
	
	for (int j = 0; j < n; j += 2) {
		if ((n - 1 - j) % 2 == 0) {
			m *= s[n - 1 - j][j];
		} 
	}
	
	return m;
	
}

int main ()
{
	int n;
	scanf("%d", &n);
	
	int s[n][n];
	Traverse(n, s);
	
	printf("%d %d\n", sumD(n, s), multiple(n,s));
	
	int p[n][n];
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			p[j][n - 1 - i] = s[i][j];
		}
	}
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			printf("%d", p[i][j]);
			if (j < n - 1) {
				printf(" ");
			}
		}
		if (i < n - 1) {
			printf("\n");
		}
	}
	
	return 0;
	
}

兔子和狐狸

#include <stdio.h>

int main () 
{
	int n, m;
	scanf("%d %d", &n, &m);
	
	int h[n + 1];
	
	for (int i = 0; i <= n; i++) {
		h[i] = 1;
	}
	
	h[0] = 0;
	h[1] = 0;
	
	int i = 2;
	int j = 1;
	int s = 1;
	
	while (s <= m * n) {
		j += i;
		s += i;
		i++;
		if (s > m * n) {
			break;
		}
		if (j > n) {
			j %= n;
			if (j == 0) {
				j = n;
			}
		}
		h[j] = 0;
	}
	
	int mask = 1;
	
	for (int i = 0; i <= n; i++) {
		if (h[i] == 1) {
			if (mask == 1) {
				printf("%d", i);
				mask = 0;
			}else {
				printf(" %d", i);
			}
		}
	}
	
	if (mask == 1) {
		printf("No choice");
	}
	
	return 0;
	
}

删除字符串中指定字符

#include <stdio.h>

int main ()
{
	char str[101];
	gets(str);
	
	char ch;
	scanf("%c", &ch);
	
	int j = 0;
	
	for (int i = 0; str[i] != '\0'; i++) {
		if (str[i] != ch) {
			str[j++] = str[i];
		}
	}
	str[j] = '\0';
	
	printf("%s", str);
	
	return 0;
}

奇偶数分开排序

#include <stdio.h>

void sorting (int num[], int n) 
{
	for (int i = n - 1; i > 0; i--) {
		int tag = i;
		for (int j = i - 1; j >= 0; j--) {
			if (num[tag] < num[j]) {
				tag = j;
			}
		}
		int t = num[i];
		num[i] = num[tag];
		num[tag] = t;
	}
}

void print (int num[], int n) 
{
	int mask = 1;
	
	for (int i = 0; i < n; i++) {
		if (mask == 1) {
			printf("%d", num[i]);
			mask = 0;
		}else {
			printf(" %d", num[i]);
		}
	}
}

int main ()
{
	int n;
	scanf("%d", &n);
	
	int num[n];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	
	int odd[n];
	int even[n];
	
	int cnt1 = 0;
	int cnt2 = 0;
	
	for (int i = 0; i < n; i++) {
		if (num[i] % 2 == 1) {
			odd[cnt1] = num[i];
			cnt1++;
		}else {
			even[cnt2] = num[i];
			cnt2++;
		}
	}
	
	sorting(odd, cnt1);
	sorting(even, cnt2);
	
	print(odd, cnt1);
	printf(" ");
	print(even, cnt2);
	
	return 0;
	
}

选择排序

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int num[n];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	
	for (int i = n - 1; i > 0; i--) {
		int tag = i;
		for (int j = i - 1; j >= 0; j--) {
			if (num[tag] < num[j]) {
				tag = j;
			}
		}
		int t = num[i];
		num[i] = num[tag];
		num[tag] = t;
	}
	
	for (int i = 0; i < n; i++) {
		printf("%d ", num[i]);
	}
	
	return 0;
	
}

杨辉三角形

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    int a[31][31] = {0};
    
    // 构造杨辉三角
    for (int i = 0; i < n; i++) {
        a[i][0] = a[i][i] = 1;
        for (int j = 1; j < i; j++) {
            a[i][j] = a[i-1][j-1] + a[i-1][j];
        }
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= i; j++) {
            printf("%10d", a[i][j]);
        }
        printf("\n");
    }
    return 0;
}

在有序数组中插入一个数

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int num[n + 1];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	
	int m;
	scanf("%d", &m);
	
	num[n] = m;
	
	for (int i = n - 1; i >= 0; i--) {
		if (num[i] > num[i + 1]) {
			int t = num[i + 1];
			num[i + 1] = num [i];
			num[i] = t;
		}else {
			break;
		}
	}
	
	int mask = 1;
	
	for (int i = 0; i <= n; i++) {
		if (mask == 1) {
			printf("%d", num[i]);
			mask = 0;
		}else {
			printf(" %d", num[i]);
		}
	}
	
	return 0;
	
}

筛法求素数

#include <stdio.h>

int main () 
{
	int n;
	scanf("%d", &n);
	
	int Prime[n + 1];
	
	for (int i = 2; i <= n; i++) {
		Prime[i] = 1;
	}
	
	for (int i = 2; i <= n; i++) {
		if (Prime[i] == 1) {
			for (int k = i * i; k <= n; k += i) {
				Prime[k] = 0;
			}
		}
	}

	int mask = 1;
	
	for (int i = 2; i <= n; i++) {
		if (Prime[i] != 0) {
			if (mask == 1) {
				printf("%d", i);
				mask = 0;
			}else {
				printf(" %d", i);
			}
		}
	}
	
	return 0;
	
}

最长对称子串

#include <stdio.h>

int main ()
{
	char s[1001];
	gets(s);
	
	int length_I = 1;
	
	for (int i = 1; s[i] != '\0'; i++) {
		
		int length_i = 1;
		
		for (int j = 1; s[i + j] == s[i - j] && i - j >= 0; j++) {	
			length_i += 2;
		}
		
		if (length_i > length_I) {
			length_I = length_i;
		}
		
	}
	
	int length_J = 0; 
	
	for (int i = 0; s[i] != '\0'; i++) {
		
		int length_j = 0;
		
		for (int j = 1; s[i + 1 - j] == s[i + j] && i + 1 - j >= 0; j++) {
			length_j += 2;
		}
		
		if (length_j > length_J) {
			length_J = length_j;
		} 
	}
	
	if (length_J > length_I) {
		printf("%d", length_J);
	}else {
		printf("%d", length_I);
	}
	
	return 0;
	
}

装睡的人

#include <stdio.h>

int main() {
    int N;
    scanf("%d", &N);
    char name[4]; 
    int breath, pulse;
    
    for (int i = 0; i < N; i++) {
        scanf("%s %d %d", name, &breath, &pulse);
        if (breath < 15 || breath > 20 || pulse < 50 || pulse > 70) {
            printf("%s\n", name);
        }
    }
    return 0;
}

第六章3

个位数统计

#include <stdio.h>
#include <string.h>

int main() {
    char N[1005];
    int count[10] = {0};
    
    scanf("%s", N);
    
    for (int i = 0; i < strlen(N); i++) {
        int d = N[i] - '0';
        count[d]++;
    }

    for (int d = 0; d <= 9; d++) {
        if (count[d] > 0) {
            printf("%d:%d\n", d, count[d]);
        }
    }
    return 0;
}

找出不是两个数组共有的元素

#include <stdio.h>

void find(int m, int n, int a[m], int b[n], int s[42])
{
	int cnt = 0;
	
	for (int i = 0; i < m; i++) {
		
		int mask = 0;
		for (int j = 0; j < n; j++) {
			if (a[i] == b[j]) {
				mask = 1;
				break;
			}
		}
		if (mask == 0) {
			s[cnt++] = a[i];
		}
	}
	
	for (int i = 0; i < n; i++) {
		
		int mask = 0;
		for (int j = 0; j < m; j++) {
			if (b[i] == a[j]) {
				mask = 1;
				break;
			}
		}
		if (mask == 0) {
			s[cnt++] = b[i];
		}
	}
}

void printing (int a[42])
{
	int s[42];
	
	for (int i = 0; i < 42; i++) {
		s[i] = -1;
	}
	
	for (int i = 0; i < 42 && a[i] != -1; i++) {
		if (s[i] == -1) {
			printf("%d ", a[i]);
			for (int j = i; j < 42 && a[j] != -1; j++) {
				if (a[j] == a[i]) {
					s[j] = 0;
				}
			}
		}	
	}	
}

int main ()
{
	int n;
	scanf("%d", &n);
	
	int a[n];
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	
	int m;
	scanf("%d", &m);
	
	int b[m];
	
	for (int i = 0; i < m; i++) {
		scanf("%d", &b[i]);
	}
	
	int s[42];
	
	for (int i = 0; i < 42; i++) {
		s[i] = -1;
	}
	
	find(n, m, a, b, s);
	
	printing(s);
	
	return 0;
	
}

字符串逆序

#include <stdio.h>
#include <string.h>

int main ()
{
	char a[81];
	
	fgets(a, sizeof(a), stdin);
	
	int length = strlen(a);
	
	int j = length - 1;
	int i = 0;
	
	while (i < j) {
		char b = a[i];
		a[i] = a[j];
		a[j] = b;
		i++;
		j--;
	}
	
	printf("%s", a);
	
	return 0;
	
}

找鞍点

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    int a[6][6];
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &a[i][j]);
        }
    }
    
    for (int i = 0; i < n; i++) {
        int rowMax = a[i][0];
        for (int j = 1; j < n; j++) {
            if (a[i][j] > rowMax) {
                rowMax = a[i][j];
            }
        }
        
        for (int j = 0; j < n; j++) {
            if (a[i][j] == rowMax) {
                int colMin = a[0][j];
                for (int k = 1; k < n; k++) {
                    if (a[k][j] < colMin) {
                        colMin = a[k][j];
                    }
                }
                if (a[i][j] == colMin) {
                    printf("%d %d\n", i, j);
                    return 0;
                }
            }
        }
    }
    
    printf("NONE\n");
    return 0;
}

求n以内最大的k个素数以及它们的和

#include <stdio.h>

void findPrime (int n, int Prime[])
{	
	for (int i = 2; i <= n; i++) {
		Prime[i] = 1;
	}
	
	for (int i = 2; i * i <= n; i++) {
		if (Prime[i] == 1) {
			for (int k = i * i; k <= n; k += i) {
				Prime[k] = 0;
			}
		}
	}
	
	Prime[0] = 0;
	Prime[1] = 0;
}

int main ()
{
	int max, cnt;
	scanf("%d %d", &max, &cnt);
		
	int isPrime[10001];
	findPrime(max, isPrime);
	
	int sum = 0;
	int mask = 0;
	
	for (int i = max; i > 0 && mask < cnt; i--) {
		if (isPrime[i] == 1) {
			sum += i;
			if (mask == 0) {
				printf("%d", i);
			}else {
				printf("+%d", i);
			}
			mask++;
		}
	}
	
	printf("=%d", sum);
	
	return 0;
}

1234方阵

#include <stdio.h>

void printing (int n, int s[n][n])
{
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			printf("%d", s[i][j]);
			if (j < n - 1) {
				printf(" ");
			}
		}
		printf("\n");
	}
}

int main ()
{
	int n;
	scanf("%d", &n);
	
	int s[n][n];
	
	for (int i = 0; i < n; i++) {
		s[i][i] = 0;
	}
	
	for (int i = 0; i < n; i++) {
		s[n - 1 - i][i] = 0;
	}
	
	int cnt = n - 2;
	int k = cnt;
	int l = cnt;
	int J = 1;
	
	for (int i = 0; k > 0; i++) {
		l = k;
		int j = J;
		while (l > 0) {
			s[i][j] = 1;
			l--;
			j++;
		}
		k -= 2;
		J += 1;
	}
	
	cnt = n - 2;
	k = cnt;
	l = cnt;
	int I = 1;
	
	for (int j = 0; k > 0; j++) {
		l = k;
		int i = I;
		while (l > 0) {
			s[i][j] = 2;
			l--;
			i++;
		}
		k -= 2;
		I += 1;
	}
	
	cnt = n - 2;
	k = cnt;
	l = cnt;
	J = 1;
	
	for (int i = n - 1; k > 0; i--) {
		l = k;
		int j = J;
		while (l > 0) {
			s[i][j] = 3;
			l--;
			j++;
		}
		k -= 2;
		J += 1;
	}
	
	cnt = n - 2;
	k = cnt;
	l = cnt;
	I = 1;
	
	for (int j = n - 1; k > 0; j--) {
		l = k;
		int i = I;
		while (l > 0) {
			s[i][j] = 4;
			l--;
			i++;
		}
		k -= 2;
		I += 1;
	}
	
	printing(n, s);
	
	return 0;
	
}

心情查询

#include <stdio.h>

void Traverse1 (int n, int s[n])
{
	for (int i = 0; i < n; i++) {
		scanf("%d", &s[i]);
	}
}

void initialize_Traverse2 (int n, int s[n])
{
	for (int i = 0; i < n; i++) {
		s[i] = -1;
	}
	
	int i = 0;
	int j;
	
	while (i < n - 1 && scanf("%d", &j) == 1) {
		if (j < 0 || j > 23) {
			break;
		}else {
			s[i++] = j;
		}
	}
}

int main ()
{
	const int n = 24;
	
	int s[n];
	Traverse1(n, s);

	int hour[n + 1];
	initialize_Traverse2(n + 1, hour);

	int i = 0;
	
	while (i < n + 1 && hour[i] != -1) {
		
		if (s[hour[i]] > 50) {
			printf("%d Yes", s[hour[i]]);
		}else if (s[hour[i]] <= 50) {
			printf("%d No", s[hour[i]]);
		}
		
		if (s[hour[i + 1]] != -1) {
			printf("\n");
		}else {
			break;
		}
		i++;
	}
	
	return 0;
	
}

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int q[1001] = {0};
	
	for (int i = 0; i < n; i++) {
		int p;
		scanf("%d", &p);
		
		for (int j = 0; j < p; j++) {
			int k;
			scanf("%d", &k);
			q[k]++;
		}
		
	}
	
	int max = 1000;
	
	for (int i = 1000; i >= 0; i--) {
		if (q[i] > q[max]) {
			max = i;
		}
	}
	
	printf("%d %d", max, q[max]);
	
	return 0;
}

古风排版

#include <stdio.h>

int ceiling (double num)
{
	int i = (int)num;
	if (num > i) {
		return i + 1;
	}
	return i;
}


int main ()
{
	int n;
	scanf("%d", &n);
	getchar();
	
	char s[1001];
	gets(s);
	
	int len = 0;
	
	while (s[len] != '\0') {
		len++;
	}
	s[len] = '\0';
	
	int column = ceiling((double)len / n);
	
	char c[n][column];
	
	int k = 0;
	
	for (int j = column - 1; j >= 0; j--) {
		for (int i = 0; i < n; i++) {
			if (k < len) {
				c[i][j] = s[k++];
			} else {
				c[i][j] = ' ';
			}
		}
	}
	
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < column; j++) {
			printf("%c", c[i][j]);
		}
		printf("\n");
	}
	
	return 0;
	
}

字符串A-B

#include <stdio.h>

int main ()
{
	char a[10001];
	gets(a);
	char b[10001];
	gets(b);
	
	int c[10001] = {0};
	
	int k = 0;
	
	for (int i = 0; a[i] != '\0'; i++) {
		for (int j = 0; b[j] != '\0'; j++) {
			if (b[j] == a[i] ) {
				c[k++] = i;
				break;
			}
		}
	}
	
	for (int i = 0; a[i] != '\0'; i++) {
		int mask = 1;
		for (int j = 0; j < k; j++) {
			if (i == c[j]) {
				mask = 0;
				break;
			}
		}
		if (mask == 1) {
			printf("%c", a[i]);
		}
	}
	
	return 0;
}

n个数字都不相同的年份

#include <stdio.h>

void initialize_years(int year, int years[4]) 
{
	for (int i = 0; i < 4; i++) {
		years[i] = 0;
	}
	
	int i = 3;
	
	while (year > 0 && i >= 0) {
		years[i] = year % 10; 
		year /= 10;              
		i--;
	}
}

int main ()
{
	int y;
	scanf("%d", &y);

	int s[4];
	
	initialize_years(y, s);
	
	int n;
	scanf("%d", &n);
	
	int cnt = 0;
	
	while (1) {
		int mask = 1;
		int num[10] = {0};
		for (int i = 0; i < 4; i++) {
			int j = 0;
			for ( ; j < 10; ) {
				if (s[i] == j) {
					num[j]++;
					break;
				}else {
					j++;
				}
			}	
		}
		for (int k = 0; k < 10; k++) {
			if (n == 4) {
				if (num[k] != 0 && num[k] != 1) {
					mask = 0;
					break;
				}
			}else if (n == 3) {
				int cnt = 0;
				for (int l = 0; l < 10; l++) {
					if (num[l] == 2) {
						cnt++;
					}
				}
				if (cnt != 1) {
					mask = 0;
					break;
				}
			}else if (n == 2) {
				int tag = 0;
				for (int l = 0; l < 10; l++)
				if (num[l] == 0) {
					tag++;
				}
				if (tag != 8) {
					mask = 0;
					break;
				}
			}
		}
		if (mask == 0) {
			y += 1;
			cnt++;
			initialize_years(y, s);
		}else {
			break;
		}
	}
	
	printf("%d ", cnt);
	
	for (int i = 0; i < 4; i++) {
		printf("%d", s[i]);
	}
	
	return 0;
	
}

矩阵A乘以B

#include <stdio.h>

int main() {
    int Ra, Ca, Rb, Cb;
    int A[100][100], B[100][100], C[100][100];

    scanf("%d %d", &Ra, &Ca);
    for (int i = 0; i < Ra; i++) {
        for (int j = 0; j < Ca; j++) {
            scanf("%d", &A[i][j]);
        }
    }

    scanf("%d %d", &Rb, &Cb);
    for (int i = 0; i < Rb; i++) {
        for (int j = 0; j < Cb; j++) {
            scanf("%d", &B[i][j]);
        }
    }

    if (Ca != Rb) {
        printf("Error: %d != %d\n", Ca, Rb);
        return 0;
    }

    for (int i = 0; i < Ra; i++) {
        for (int j = 0; j < Cb; j++) {
            C[i][j] = 0;
            for (int k = 0; k < Ca; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }

    printf("%d %d\n", Ra, Cb);
    for (int i = 0; i < Ra; i++) {
        for (int j = 0; j < Cb; j++) {
            if (j > 0) printf(" ");
            printf("%d", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

查验身份证

#include <stdio.h>

int main ()
{
	int s[17];
	int a[17] = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
	
	int i = 0;
	int sum = 0;
	
	while (i < 17 && scanf("%1d", &s[i]) == 1) {
		sum += s[i] *a[i];
		i++;
	}
	
	char b;
	scanf("%c", &b);
	
	sum %= 11;
	
	int z[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	char m[11] = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'};
	
	char mask = '0';
	
	for (int i = 0; i < 11; i++) {
		if (sum == z[i]) {
			mask = m[i];
		}
	}
	
	if (mask == b) {
		printf("No problem");
	}else {
		printf("Incorrect");
	}
	
	return 0;		
}

判断题的评判

#include <stdio.h>

int main ()
{
	int n;
	scanf("%d", &n);
	
	int AC[n];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &AC[i]);
	}
	
	int WA[n];
	
	int cnt = 0;
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &WA[i]);
		if (WA[i] == AC[i]) {
			cnt++;
		}
	}
	
	double x;
	
	x = 1.0 * cnt / n;
	
	printf("%.2f%%", x * 100);
	
	return 0;
}

数组元素循环右移问题

#include <stdio.h>

void reverse(int a[], int l, int r) {
	while (l < r) {
		int t = a[l];
		a[l] = a[r];
		a[r] = t;
		l++;
		r--;
	}
}

int main () 
{
	int n, m;
	scanf("%d %d", &n, &m);
	m %= n;
	
	int s[n];
	for (int i = n - 1; i >= 0; i--) {
		scanf("%d", &s[i]);
	}
	
	reverse(s, 0, m - 1);
	reverse(s, m, n - 1);
	
	for (int i = 0; i < n; i++) {
		printf("%d ", s[i]);
	}
	
	return 0;
	
}

第七章

定义print函数，输出n个*

void print(int k)
{
	for (int i = 1; i <= k; i++)
		printf("*");
	printf("\n");
}

定义函数求π的近似值

double funpi(double e)
{
	double flag = 1, sum = 0;
	for (int i = 1;; i++)
	{
		double t = flag / (2 * i - 1);
		if (t < 0)
		{
			if (-t < e)
				break;
		}
		else
		{
			if (t < e)
				break;
		}
		sum += t;  //求和
		flag = -flag;  //正负反转
	}
	return sum;
}

设计函数计算并输出矩形的面积

void area(int a, int b)
{
    printf("%d", a * b);
}

定义函数prime，判定正整数n是否素数

#include <math.h>
int prime(int n)
{
	for (int i = 2; i <= sqrt(n); i++)
		if (n % i == 0)
			return 0;

	return 1;
}

设计函数实现冒泡排序

void sort(int a[], int n)
{
	for (int i = 0; i < n - 1; i++)  //一趟冒泡排序,把最小的数字放在最末尾
	{
		for (int j = 0; j < n - i - 1; j++)  //每经过一趟冒泡排序,需要检索的数字个数-1
		{
			if (a[j] < a[j + 1])  //如果左边的数字小于右边的数字,实现相邻两个数的交换
			{
				int t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
			}
		}
	}
}

void print(int a[], int n)
{
	for (int i = 0; i < n; i++)
	{
		if (i == 0)
			printf("%d", a[i]);
		else
			printf(" %d", a[i]);
	}
	printf("\n");
}

设计函数实现矩阵的转置

void convert(int arr1[][10], int arr2[][10], int x, int y)
{
	for (int i = 0; i < x; i++)
		for (int j = 0; j < y; j++)
			arr2[j][i] = arr1[i][j];  // 矩阵行列坐标互换
}

void print(int arr[][10], int x, int y)  //二维数组的行可以不初始化,列一定要初始化
{
	for (int i = 0; i < x; i++)  //控制行数
	{
		for (int j = 0; j < y; j++)  //控制列数
		{
			if (j == 0)
				printf("%d", arr[i][j]);
			else
				printf(" %d", arr[i][j]);
		}
		printf("\n");
	}
}

设计函数实现二分查找

int BinSearch(int a[], int n, int x)
{
	int left = 0;  //数组最左侧元素下标
	int right = n - 1;  //数组最右侧元素下标
	while (left <= right)
	{
		//int mid = (right + left) / 2;
		int mid = left + (right - left) / 2;  //防止数据过大，越界
		if (x < a[mid])
			left = mid + 1;
		else if (x > a[mid])
			right = mid - 1;
		else
			return mid;
	}
	return -1;
}

定义menu函数，输出菜单选项

void Menu()
{
	printf("       Menu\n");
	printf("  (1)--读取数据\n");
	printf("  (2)--数据计算\n");
	printf("  (3)--查找数据\n");
	printf("  (4)--输出数据\n");
	printf("  (0)--退出程序\n");
}

设计函数计算学生的平均成绩

double average(int a[], int n)
{
	double sum = 0;
	for (int i = 0; i < n; i++)
		sum = sum += a[i];
	return  sum / n;
}

设计递归函数模拟汉诺塔游戏

void move(int n, char a, char b, char c)
{
	if (n == 1)
		printf("%c-->%c\n", a, c);  //当只有一个盘子时,直接从起始柱移到目标柱
	else
	{
		move(n - 1, a, c, b);  //第一步:将n-1个盘子由a移动到b,注意此时起始柱是a,中转柱是c,目标柱是b; 
		printf("%c-->%c\n", a, c);  //第二步:将第n个盘子从起始柱移到目标柱
		move(n - 1, b, a, c);  //第三步:将n-1个盘子由b移动到c,注意此时起始柱是b,中转柱是a,目标柱是c; 
	}
}

设计递归函数计算Fibonacci数列的第n项

int fib(int n)
{
	if (n <= 1)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}

设计递归函数计算组合

int fun(int m, int n)
{
	if (n == 0 || n == m)  //c(0,m)和c(m,m)都为1(特判)
		return 1;
	else
		return fun(m - 1, n - 1) + fun(m - 1, n);  //组合数公式 c(n,m)=c(n-1,m-1)+c(n-1,m)  m>=n
}

设计递归函数计算两个整数的最大公约数

int gcd(int m, int n)  //辗转相除法
{
    if (n == 0)
        return m;
    else
        return gcd(n, m % n);
}

设计递归函数计算n！

int fac(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * fac(n - 1);
}

设计max函数，计算三个整数的最大值

int max(int a, int b, int c)
{
	if (a >= b && a >= c)
		return a;
	if (b >= a && b >= c)
		return b;
	if (c >= a && c >= b)
		return c;
}

2025武汉新生赛部分题解及游记

Mon, 22 Dec 2025 00:00:00 GMT

2025武汉新生赛部分题解及游记

游记

2025 年已经见底，今年最后一场参加的线下赛也告一段落。不知不觉已经过了快半年的时间，在这里先感谢这半年来帮助过我的学长，同学们，感谢他们作为我的领路人，帮助我应对大学里的事物，带我入门算法，学习计算机相关的知识。希望未来的自己能够争气点。

本次比赛仍需要反思的，首先是保持冷静。A 题样例都没看就开始搓，最后发现时几乎是全部重写，浪费了大量时间。另外对于一些细节方面仍需注意。例如算式中存在的计算符的优先性。最后对于拿不太准的代码，应当多造样例多测，这样能避免很多不应该出现的罚时。

这次是第二次去华农参加的比赛。相对于第一次，这次抽到了怎么按也按不动的键盘，刚交完 Wrong Answer 后就蓝屏的电脑，运气还是差了点 TAT。但这次发的面包好吃(~~虽然不咋饿~~)。这次仍然很幸运的拿到了签到题的一血，让我也不至于空手而归。另外，华农不愧是华“农”，比赛完在华农乱逛，田，一望无际的田~~

经历了这次比赛，意识到了自己与强者之间的差距真的很大。。。在算法这条路上仍是任重道远。希望自己以后加油吧！

部分题解

L - 那我问你

题意：

输入三个整数 a，b，c，输出“The paper you submitted have a Pros and b Cons, so I have c Questions for you.”。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 1e9 + 7;

void solve ()
{
    ll a, b, c; cin >> a >> b >> c;
    cout << "The paper you submitted have " << a << " Pros and " << b << " Cons, so I have " << c << " Questions for you.";
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

A - 昨日重现

题意：

给定一个长度不超过 100 的字符串，在五所大学(HUST, WHU, WHUT, HZAU, CCNU)的缩写中，找出在字符串中作为子序列出现次数最多且字典序最小的一个，输出大学的缩写及最大次数。

思路：

这里就不深究此题了，for 循环足以解决。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 1e9 + 7;

void solve ()
{
    string s; cin >> s;
    vector <ll> cnt(5, 0);
    ll n = s.size();

    for (ll i = 0; i < n; i++) {
        if (s[i] == 'C') {
            for (ll j = i + 1; j < n; j++) {
                if (s[j] == 'C') {
                    for (ll k = j + 1; k < n; k++) {
                        if (s[k] == 'N') {
                            for (ll l = k + 1; l < n; l++) {
                                if (s[l] == 'U') cnt[0]++;
                            }
                        }
                    }
                }
            }
        }
    }

    for (ll i = 0; i < n; i++) {
        if (s[i] == 'H') {
            for (ll j = i + 1; j < n; j++) {
                if (s[j] == 'U') {
                    for (ll k = j + 1; k < n; k++) {
                        if (s[k] == 'S') {
                            for (ll l = k + 1; l < n; l++) {
                                if (s[l] == 'T') cnt[1]++;
                            }
                        }
                    }
                }
            }
        }
    }

    for (ll i = 0; i < n; i++) {
        if (s[i] == 'H') {
            for (ll j = i + 1; j < n; j++) {
                if (s[j] == 'Z') {
                    for (ll k = j + 1; k < n; k++) {
                        if (s[k] == 'A') {
                            for (ll l = k + 1; l < n; l++) {
                                if (s[l] == 'U') cnt[2]++;
                            }
                        }
                    }
                }
            }
        }
    }

    for (ll i = 0; i < n; i++) {
        if (s[i] == 'W') {
            for (ll j = i + 1; j < n; j++) {
                if (s[j] == 'H') {
                    for (ll k = j + 1; k < n; k++) {
                        if (s[k] == 'U') {
                            for (ll l = k + 1; l < n; l++) {
                                if (s[l] == 'T') cnt[4]++;
                            }
                        }
                    }
                }
            }
        }
    }

    for (ll i = 0; i < n; i++) {
        if (s[i] == 'W') {
            for (ll j = i + 1; j < n; j++) {
                if (s[j] == 'H') {
                    for (ll k = j + 1; k < n; k++) {
                        if (s[k] == 'U') cnt[3]++;
                    }
                }
            }
        }
    }

    if (cnt[0] == max({cnt[0], cnt[1], cnt[2], cnt[3], cnt[4]})) {
        cout << "CCNU " << cnt[0] << '\n';
    }else if (cnt[1] == max({cnt[0], cnt[1], cnt[2], cnt[3], cnt[4]})) {
        if (cnt[0] == cnt[1]) {
            cout << "CCNU " << cnt[0] << '\n';
        }else {
            cout << "HUST " << cnt[1] << '\n';
        }
    }else if (cnt[2] == max({cnt[0], cnt[1], cnt[2], cnt[3], cnt[4]})) {
        if (cnt[0] == cnt[2]) {
            cout << "CCNU " << cnt[0] << '\n';
        }else if (cnt[1] == cnt[2]) {
            cout << "HUST " << cnt[1] << '\n';
        }else {
            cout << "HZAU " << cnt[2] << '\n';
        }
    }else if (cnt[3] == max({cnt[0], cnt[1], cnt[2], cnt[3], cnt[4]})) {
        if (cnt[0] == cnt[3]) {
            cout << "CCNU " << cnt[0] << '\n';
        }else if (cnt[1] == cnt[3]) {
            cout << "HUST " << cnt[1] << '\n';
        }else if (cnt[2] == cnt[3]) {
            cout << "HZAU " << cnt[2] << '\n';
        }else {
            cout << "WHU " << cnt[3] << '\n';
        }
    }else if (cnt[4] == max({cnt[0], cnt[1], cnt[2], cnt[3], cnt[4]})) {
        if (cnt[0] == cnt[4]) {
            cout << "CCNU " << cnt[0] << '\n';
        }else if (cnt[1] == cnt[4]) {
            cout << "HUST " << cnt[1] << '\n';
        }else if (cnt[2] == cnt[4]) {
            cout << "HZAU " << cnt[2] << '\n';
        }else if (cnt[3] == cnt[4]) {
            cout << "WHU " << cnt[3] << '\n';
        }else {
            cout << "WHUT " << cnt[4] << '\n';
        }
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

B - 易守难攻

题意：

给定一个空的 n 行 m 列的网格，需要往每一个格子填入一个$1$ ~ $n\times m$的高度值，满足有 k 个网格的高度值严格大于 8 个相邻格子的高度值，且这 k 个网格不位于边界上。输出满足条件的网格，或者报告不存在这样的分配方式。

思路：

首先明确：将大数一个隔一个的放是最大化能放置网格的放置方法。手模几个样例可以发现，若$(n - 1) / 2 \times (m - 1) / 2 < k$，则放不下满足条件的 k 个网格。我们可以从最大数开始放置。先将大数一个隔一个数地放，保证大数之间不会互相干扰。再依次放置其他数即可，可以保证大数总是可以满足条件的，且其他数不会形成新的满足条件的网格。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 1e9 + 7;

void solve ()
{
    ll n, m, k; cin >> n >> m >> k;
    if (((n - 1) / 2) * ((m - 1) / 2) < k) {
        cout << "No" << '\n';
        return;
    }

    vector <vector <ll> > v(n + 1, vector <ll> (m + 1));
    vector <vector <bool> > vis(n + 1, vector <bool> (m + 1, false));

    ll t = n * m;
    if (k != 0) {
        ll cnt = 0;
        bool found = true;
        for (int i = 2; i < n; i += 2) {
            for (int j = 2; j < m; j += 2) {
                cnt++;
                v[i][j] = t--;
                vis[i][j] = true;
                if (cnt == k) found = false;
                if (!found) break;
            }
            if (!found) break;
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (vis[i][j]) continue;
            v[i][j] = t--;
        }
    }

    cout << "Yes" << '\n';
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cout << v[i][j] << ' ';
        }
        cout << '\n';
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

F - Anon 的疑问

题意：

询问$q$次$(1 \leq q \leq 1e6)$，每次询问给定一个正整数$n(1 \leq n \leq 2e7)$，判断其能否被分解为两个正整数的平方和。

思路：

这里给出两种思路。

第一种思路：首先可以观察到这里的数据量并不是很大，我们完全可以直接预处理平方在$2e7$内的数，然后枚举得到所有满足条件的正整数。时间复杂度:$O(2e7)$。

第二种思路：可以利用两平方和定理：对于任意的正整数$n = a^2 + b^2(a, b \in Z)$，当且仅当在 n 的质因数分解中，所有形如$p \equiv 3 (mod 4)$的质数，其指数都是偶数。根据定理，我们可以先预处理出在$2e7$内所有数的最小质因数，然后再根据每个数判断其指数奇偶性。

但是这里由于询问次数可能很多，时间复杂度相对于暴力可能没有优势，且无法通过本题，仅供参考。

时间复杂度：$O(q\times nlogn)$。

代码：

思路一：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 1e9 + 7;

bool vis[20000005];//这里如果用vector记录可能会被卡常

void solve ()
{
    ll n; cin >> n;
    if (vis[n]) {
        cout << "Yes" << '\n';
    }else {
        cout << "No" << '\n';
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int _ = 1;
    cin >> _;

    for (int i = 1; i < 4473; i++) {
        if (i * i > 2e7 + 2) break;
        for (int j = i; j < 4473; j++) {
            if (i * i + j * j > 2e7 + 2) break;
            vis[i * i + j * j] = true;
        }
    }

    while (_--) {
        solve();
    }
    return 0;
}

思路二：（仅供参考）

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int N = 2e7 + 1;
const double eps = 1e-5;
const ll mod = 1e9 + 7;

bool isprime[N];
int prime[N], mnp[N];
ll cnt = 0;

void get_mn_prime_factor ()
{
    mnp[1] = 1;
    for (int i = 2; i < N; i++) {
        if (!isprime[i]) {
            prime[cnt++] = i;
            mnp[i] = i;
        }
        for (int j = 0; j < cnt && i * prime[j] < N; j++) {
            isprime[i * prime[j]] = true;
            mnp[i * prime[j]] = prime[j];
            if (i % prime[j] == 0) break;
        }
    }
}

void solve ()
{
    ll n; cin >> n;

    auto check = [&] (int x) -> bool {
        ll t = x;
        while (t != 1) {
            ll p = mnp[t];
            ll cnt = 0;
            while (t % p == 0) {
                t /= p;
                cnt++;
            }
            if (p % 4 == 3 && cnt & 1) {
                return false;
            }
        }
        if ((ll)sqrtl(x) * (ll)sqrtl(x) == x) return false;//特判
        else return true;
    };

    cout << (check(n) ? "Yes" : "No") << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    cin >> _;
    get_mn_prime_factor();
    while (_--) {
        solve();
    }
    return 0;
}

G - 你好，世界

题意：

有一个初始值为 0 的 N 位计数器，用来预测一条指令是否应当执行。

当扫描到一条指令时，若计数器的值小于$2^{N - 1}$，则预测该指令将不被执行，否则预测将被执行。
无论是否预测正确，如果当前指令的真实状况为需要执行，则计数器增加 1，否则计数器减少 1。
计数器的增加和减少不会超过$[0,2^N)$这一界限。

你需要构造一个长度为 len 的 01 字符串（指令），0 代表不执行，1 代表执行，使得预测错误的次数最大。

思路：

诈骗题。理解题意后，不难发现只需要使前$2^{N - 1}$个指令执行，后面的指令只需不执行，执行(01 循环)即可。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 1e9 + 7;

ll qpow (ll a, ll b)
{
    ll res = 1;
    while (b) {
        if (b & 1) res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}

void solve ()
{
    ll n, len; cin >> n >> len;
    ll tag = len;
    if (n <= 60) tag = min(qpow(2, n - 1), len);

    for (int i = 0; i < tag; i++) {
        cout << 1;
    }
    for (int i = 0; i < len - tag; i++) {
        cout << (i & 1);
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

H - 哆啦 A 梦的神奇铜锣烧储存系统

题意：

有$n$个宝箱，其中有$k$个宝箱里装有铜锣烧，哆啦 A 梦先从中选择$m$个他认为最有可能装有铜锣烧的宝箱，然后在剩下的$n - m$个宝箱中随机打开$n - (m + q)$个空箱子（若没有空箱子则不打开），最后剩下$q$个宝箱是关闭的。求出剩下的未打开$q$个宝箱中铜锣烧的期望数量（模 998244353）。

思路：

简洁的思路是：我们考虑任意一个真箱子，在每一次选完$m$个后，这个箱子仍然存在于$n - m$个箱子的期望为$E[X_i] = \frac{n - m}{n}$。一共有$k$个真箱子，只需要将$k$个期望累加就能得出答案：$\frac{n - m}{n} \times k$。

详细过程：（鸣谢笔者ichooooooo！）

首先，这是一道超几何分布题

经典场景：总共有$N$个商品，其中$M$个特殊品，选取$n$个出来

求$n$个商品中特殊商品期望设$X$是$n$个商品里的特殊品数量 $E = \sum_{X = 0}^{M}(X \times P(X))$

这里$P(X)$是从$n$个中抽取$X$个特殊品的概率， $X \times P(X)$ 是抽到$i$个特殊元素时，特殊品数量的期望贡献，$(n - X) \times P(X)$ 则是抽到$i$个特殊元素时，非特殊品数量的期望贡献
求$P(X)$ 超几何分布知识，我们用$\binom{k}{i}$表示$C(i, k)$，最终公式 $$\frac{\binom{M}{X}\binom{N - M}{n - X}}{\binom{N}{n}}$$ 其中$\binom{M}{X}$表示从$X$个总特殊品选取$M$个，那么剩下$n - X$个是非特殊，再从$N - M$个总非特殊选取$n - X$个，相乘是“有利情况”，除总情况就是概率
期望化简后求和结果 $$\frac{M}{N} \times n$$

回到题目，根据上面我们最终需要得到抽 n 个商品时，非特殊商品的期望，即 $${\sum_{i = 0}^{min(k, m)}(k - i)} \times P(i)$$ 展开得 $$\frac{\sum_{i = 0}^{min(k, m)}\binom{k}{i}\binom{n - k}{m - i}(k - i)}{\binom{n}{m}}$$ 化简得 $$\frac{n - m}{n} \times k$$

关于为什么 q 不会影响到最终结果

q 只抽取空箱子，不影响特殊品的数量，根据公式，P(i)不变，权值 k - i 也不变，所以结果不变

代码：

原始公式:

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 1e6 + 10;
const double eps = 1e-5;
const ll mod = 998244353;

vector <ll> f(MAXN), g(MAXN);

ll qpow (ll a, ll b)
{
    ll res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res % mod;
}

ll C (ll n, ll m)
{
    if (m < 0 || m > n) return 0;
    return f[n] * g[m] % mod * g[n - m] % mod;
}

void solve ()
{
    ll n, k, m, q; cin >> n >> k >> m >> q;
    ll a = 0, b = 0;
    for (int i = 0; i <= min(k, m); i++) {
        a = (a + C(k, i) * C(n - k, m - i) % mod * (k - i) % mod) % mod;
    }
    b = C(n, m);
    ll ans = a * qpow(b, mod - 2) % mod;
    cout << ans << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;

    f[0] = 1, g[0] = 1;
    for (int i = 1; i < MAXN; i++) {
        f[i] = f[i - 1] * i % mod;
        g[i] = qpow(f[i], mod - 2) % mod;
    }

    while (_--) {
        solve();
    }
    return 0;
}

化简：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 998244353;

ll qpow (ll a, ll b)
{
    ll res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res % mod;
}

void solve ()
{
    ll n, k, m, q; cin >> n >> k >> m >> q;
    cout << (n - m) * k % mod * qpow(n, mod - 2) % mod << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

2025菜鸟杯部分题解

Mon, 15 Dec 2025 00:00:00 GMT

2025菜鸟杯部分题解

A - hello

题意：

第一行输出“HELL0 WUSTACM!”，第二行输出“maintain integrity,think diligently, and challenge yourself”。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n;

void solve ()
{
    cout << "HELL0 WUSTACM!" << '\n';
    cout << "maintain integrity,think diligently, and challenge yourself" << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

C - 杨弟的电梯

题意：

输入一个整数 n 和 0 或 1，0 代表夏天，1 代表冬天。夏天时人数不少于 10 人输出 hot，不到 10 人输出 cool。冬天时人数不少于 10 人输出 warm，不到 10 人输出 cold。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n, a;

void solve ()
{
    cin >> n >> a;
    if (n > 15) {
        cout << "error" << '\n';
        return;
    }
    if (a == 0) {
        if (n < 10) {
            cout << "cool" << '\n';
        }else {
            cout << "hot" << '\n';
        }
    }else {
        if (n < 10) {
            cout << "cold" << '\n';
        }else {
            cout << "warm" << '\n';
        }
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

F - 猫猫

题意：

根据程序输出，程序如下：

miao_func(x):
    miaomiao (x < 1)
        miaomiaomiaowu 0
    miaomiaomiao (x & 1)
        miaomiaomiaowu x + miao_func(x - 2)
    miaomiaomioa
        miaomiaomiaowu miao_func(x - 2) - x

喵语： miaomiao : if miaomiaomiao : else if miaomiaomioa : else miaomiaomiaowu : return

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n;

void solve ()
{
    cin >> n;

    auto func = [&] (ll x, auto self) -> ll {
        if (x < 1) {
            return 0;
        }else if (x & 1) {
            return x + self(x - 2, self);
        }else {
            return self(x - 2, self) - x;
        }
    };

    ll ans = func(n, func);

    cout << ans << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

D - 装糖果

题意：

给定 n 种类型的糖果，k 和每种类型糖果的数量，求至少买多少个袋子能满足以下限制条件：

每个袋子最多能装下 k 个糖果
每个袋子中同一种类的糖果至多只能有一个

思路：

贪心。考虑最后的袋子有两种可能，一种是包含多种糖果，一种是只有一种糖果。对于第一种情况，至少的袋子数量即为 ceil(sum / k),对于第二种情况，至少的袋子数量即为最大的糖果数量。两种情况取最大值即可。时间复杂度：O(n)。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n, k;

void solve ()
{
    cin >> n >> k;
    vector <ll> v(n + 1);
    ll mx = 0;
    ll sum = 0;
    for (int i = 1; i <= n; i++) {
        cin >> v[i];
        sum += v[i];
        mx = max(mx, v[i]);
    }

    ll t;
    if (sum % k == 0) {
        t = sum / k;
    }else {
        t = sum / k + 1;
    }

    cout << max(t, mx);
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

G - 礼包和 scandi

题意：

给定碗的数量和每个碗中的米饭量。scandi 要吃完所有米饭且想要米饭量尽量少，礼包想要 scandi 吃的米饭量尽量多。在开始吃饭前，两人可以轮流对米饭量进行调整，礼包先手，过程如下：

任选一个满足 ai != ai+1的 i。
将 ai变为 func(ai，ai+1)。
当无法找到满足要求的 i 时，调整环节结束。注意：对于 scandi 而言，func() = min()，对于礼包而言，func() = max()。

求最终 scandi 需要吃掉的米饭总量

思路：

诈骗题。手模样例后发现，当所有数等于最后一个数时才不会满足题意。直接输出即可。时间复杂度：O(n)。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n;

void solve ()
{
    cin >> n;
    vector <ll> v(n + 1, 0);
    for (int i = 1; i <= n; i++) {
        cin >> v[i];
    }

    cout << v[n] * n << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

H - 凡安要当超级农民

题意：

给定矩阵的长和宽为 n 和 m，并给定次数 q。接下来的 q 行中，给定魔法生效点座标，延伸长度和魔法效果。魔法效果：在生效点上，上下左右依次延伸 k 个点，使得每个点的产量增加 s(初始产量为 0)。求最终矩阵中每个点的产量。

思路：

数据量不大，模拟即可。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n, m, q;

void solve ()
{
    cin >> n >> m >> q;
    vector <vector <ll> > v(n + 1, vector <ll> (m + 1, 0));

    while (q--) {
        ll x, y, k, s;
        cin >> x >> y >> k >> s;
        v[x][y] += s;
        for (int i = x - k; i <= x + k; i++) {
            if (i == x) continue;
            ll xx = (i + n - 1) % n + 1;
            v[xx][y] += s;
        }
        for (int i = y - k; i <= y + k; i++) {
            if (i == y) continue;
            ll yy = (i + m - 1) % m + 1;
            v[x][yy] += s;
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cout << v[i][j] << ' ';
        }
        cout << '\n';
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

L - 逃课计划

题意：

一周七天，每天有六节课，给定老师的具体查课时间，即第几天第几节。在两天不能逃同一节课的情况下，求出可能的逃课计划数量。

思路：

最大可能不超过 3e5 种情况，因此直接暴力 dfs 即可。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

vector <vector <ll> > e(8);
ll n;
ll ans = 0;

void solve ()
{
    cin >> n;
    map <pair<ll, ll>, bool> mp;
    for (int i = 0; i < n; i++) {
        int a, b;
        cin >> a >> b;
        mp[{a, b}] = true;
    }

    for (int i = 1; i <= 7; i++) {
        for (int j = 1; j <= 6; j++) {
            if (!mp[{i, j}]) {
                e[i].push_back(j);
            }
        }
    }

    auto dfs = [&] (ll day, ll course, auto self) -> void {
        if (day == 7) {
            ans++;
            return;
        }

        for (auto x : e[day + 1]) {
            if (x == course) continue;
            self(day + 1, x, self);
        }
    };

    for (auto x : e[1]) {
        dfs(1, x, dfs);
    }

    cout << ans << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

E - 比较 A 和 B 的大小

题意：

给定一种新的比较两数大小的方式：整数部分相同，但小数部分按整数来比较大小。例如：0.13 > 0.3, 0.50 > 0.5。给定两个数，若新的方式与数学方式的比大小结果相同，输出"ni shi dui de" 否则，输出"ni cuo le, ying gai shi ‘正确答案’"。 “正确答案”为：<, >, =。

思路：

首先注意到若存在一个数是整数，两种比大小的结果一定相同。接下来先判断整数部分，若整数部分不同，比大小结果一定也相同。若相同再来比较小数部分。小数部分中，分别将其根据数学方法和新的方式比较（注意前导 0 和后导 0 的讨论），查看两者结果是否不同即可。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 998244353;

string a1, a2;

void solve ()
{
    cin >> a1 >> a2;
    if (a1.find('.') == string::npos || a2.find('.') == string::npos) {
        cout << "ni shi dui de" << '\n';
        return;
    }
    string s1 = a1.substr(0, a1.find('.'));
    string s2 = a2.substr(0, a2.find('.'));

    if (s1 != s2) {
        cout << "ni shi dui de" << '\n';
        return;
    }

    string ss1 = a1.substr(a1.find('.') + 1);
    string ss2 = a2.substr(a2.find('.') + 1);

    int found2 = 0;//normal compare
    for (int i = 0; i < min(ss1.size(), ss2.size()); i++) {
        if (ss1[i] < ss2[i]) {
            found2 = 1;
            break;
        }else if (ss1[i] > ss2[i]) {
            found2 = 2;
            break;
        }
    }

    if (found2 == 0) {
        if (ss1.size() < ss2.size()) {
            bool foundd = false;
            for (int i = ss1.size(); i < ss2.size(); i++) {
                if (ss2[i] != '0') {
                    foundd = true;
                }
            }
            if (foundd) {
                found2 = 1;
            }
        }else if (ss1.size() > ss2.size()) {
            bool foundd = false;
            for (int i = ss2.size(); i < ss1.size(); i++) {
                if (ss1[i] != '0') {
                    foundd = true;
                }
            }
            if (foundd) {
                found2 = 2;
            }
        }
    }

    int found3 = 0;//require compare
    string t1; int index = 0;//remove 0 from front
    while (index < ss1.size()) {
        if (ss1[index] != '0') {
            break;
        }
        index++;
    }
    t1 = ss1.substr(index, ss1.size() - index);

    string t2; index = 0;
    while (index < ss2.size()) {
        if (ss2[index] != '0') {
            break;
        }
        index++;
    }
    t2 = ss2.substr(index, ss2.size() - index);

    if (t1.size() < t2.size()) {
        found3 = 1;
    }else if (t1.size() > t2.size()) {
        found3 = 2;
    }else {
        for (int i = 0; i < t1.size(); i++) {
            if (t1[i] < t2[i]) {
                found3 = 1;
                break;
            }else if (t1[i] > t2[i]) {
                found3 = 2;
                break;
            }
        }
    }

    if (found2 == found3) {
        cout << "ni shi dui de" << '\n';
    }else if (found2 == 0 && found3 == 1) {
        cout << "ni cuo le, ying gai shi <" << '\n';
    }else if (found2 == 0 && found3 == 2) {
        cout << "ni cuo le, ying gai shi >" << '\n';
    }else if (found2 == 1 && found3 == 0) {
        cout << "ni cuo le, ying gai shi =" << '\n';
    }else if (found2 == 1 && found3 == 2) {
        cout << "ni cuo le, ying gai shi >" << '\n';
    }else if (found2 == 2 && found3 == 0) {
        cout << "ni cuo le, ying gai shi =" << '\n';
    }else if (found2 == 2 && found3 == 1) {
        cout << "ni cuo le, ying gai shi <" << '\n';
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    //cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

K - 小白的好数组

题意：

给定一个长度为 n 的数组，求至少需要进行多少次对一个数加 p 的操作，可以使得数组至少有 k 个数字相同。

思路:

首先可以知道，若两个数%p 的结果相同，则两个数之间一定可以通过+p 的形式边成一个数。若不同，则一定不行。因此，可以根据此条件分成 p 个组，在每一组中排完序后，可能的最小的答案一定是连续的。因此，只需要以滑动窗口的形式来寻找答案即可。时间复杂度：O(n)。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const int MAXN = 6e7;
const double eps = 1e-5;
const ll mod = 998244353;

ll n, k, p;

void solve ()
{
    cin >> n >> k >> p;
    vector <vector <ll> > a(p);
    for (int i = 0; i < n; i++) {
        ll t;
        cin >> t;
        a[t % p].push_back(t);
    }

    bool found = false;
    ll ans = LLONG_MAX;
    for (int i = 0; i < p; i++) {
        if (a[i].size() < k) continue;
        else found = true;
        sort(a[i].begin(), a[i].end());

        ll mn = 0;
        for (int j = 0; j < k - 1; j++) {
            mn += (a[i][k - 1] - a[i][j]) / p;
        }

        ans = min(ans, mn);
        ll l = 1, r = k;
        while (r < a[i].size()) {
            mn -= (a[i][r - 1] - a[i][l - 1]) / p;
            mn += (a[i][r] - a[i][r - 1]) / p * (k - 1);
            ans = min(mn, ans);
            l++;
            r++;
        }
    }

    if (!found) {
        cout << "wuwuwu" << '\n';
    }else {
        cout << ans << '\n';
    }
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    //cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

B - 小李吃豆子

题意：

给定一个在 1e12 内的 n，求有多少个连续的数列相加后等于 n。

思路：

对于任意 n，假设其连续数列为 p，p + 1, p + 2,..., p + k - 1。对其求和后即可得到：(2p + k - 1) * k / 2 = n。化简后即为：p = (2n / k - k + 1) / 2。即一个符合要求的 p，一定会满足以下两个条件：

2n % k == 0
(2n / k - k + 1) % 2 == 0

因为范围为 1e12，考虑优化。2n / k - k + 1 >= 0 的条件为 p >= sqrt(2n)，即只需遍历 sqrt(2n)内的数即可。时间复杂度：O(sqrt(2n))。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n;

void solve ()
{
    cin >> n;
    ll m = sqrtl(2 * n);

    ll ans = 0;
    for (int i = 1; i <= m; i++) {
        if ((2 * n) % i == 0 && ((2 * n) / i - i + 1) % 2 == 0) {
            ans++;
        }
    }
    cout << ans << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

I - 攻守兼备

题意：

给定 n 张卡牌，每张卡牌有攻击力和防御值。想要从这 n 张卡牌中找到两张卡，使得这两张卡的总攻击力和总防御力的最小值达到最大，输出总攻击力和总防御力的最小值的最大值。

思路：

这里采用贪心做法。具体思路见wustacm

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;

#define fi first
#define se second

const ll MAXN = 1e7;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n;

void solve ()
{
    cin >> n;
    vector <pi> v(n);
    for (int i = 0; i < n; i++) {
        cin >> v[i].fi >> v[i].se;
    }
    sort(v.begin(), v.end(), [] (auto a1, auto b1) {
        return abs(a1.fi - a1.se) < abs(b1.fi - b1.se);
    });

    ll ans = 0, maxfi = 0, maxse = 0;
    for (int i = 0; i < n; i++) {
        if (v[i].fi > v[i].se) {
            ans = max(ans, maxse + v[i].se);
        }else {
            ans = max(ans, maxfi + v[i].fi);
        }
        maxfi = max(maxfi, v[i].fi);
        maxse = max(maxse, v[i].se);
    }

    cout << ans << '\n';
}

int main ()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}

华中农业大学第十五届程序设计竞赛（新生赛）游记及部分题解

Tue, 09 Dec 2025 00:00:00 GMT

华中农业大学第十五届程序设计竞赛（新生赛）游记及部分题解

仅以此记录我的第一次程序设计线下赛

游记

第一次线下赛，不出意料的感觉晚上没睡好，但到了比赛场地后就毫无疲惫感而言了。~~（瑞幸的新品是真难喝）~~

到场签到领了伴手礼，一个ACM的笔记本和一张明信片，虽然有点不及预期，但第一次拿到周边物件还是很兴奋的。在这里还是得感谢志愿者，赛前领的小纸条一下就弄丢了，上面的帐号密码志愿者们很热情地帮我解决了，非常感谢！另外赛前统一发的小熊猫dev还是很好用的，避免了用电脑自带的devc++，好评！

比赛开始后，很幸运地快速发现了签到题L，拿了一个一血！交完显示“correct”的时候发现自己是一血还是非常兴奋的！之后看了眼D题，发现跟热身赛的题差不多一样（~~其实并非~~），写完wa了之后，看到榜上有不少人也wa了D，就觉得有点不对劲了，仔细看题发现只能删除长度大于一的字串，找了下规律后又交了一发，wa了之后就没碰D题了(赛后题解显示是一道恐怖的分类讨论)。

接下来值得说的就是C题，赛时看出来是单调栈很兴奋，快速敲完交了一发wa后，由于没读清题意，自己一直在那乱改，交了无数发，最后十分钟实在没招了，而且此时也对题目思考地比较深入，再把第一发wa去掉特判后交了一发竟然A了~~(真的感受到了救赎感)~~，但是白白在这道题浪费了一个多小时，赛后看来很有可能可以再开一题，也是很可惜了。

另外，赛中发的午饭是一个“冷”热狗，鸡腿和两根香肠，难吃。

最后还是凭借7题获得了金牌，但以993的罚时在7题尾。就本次比赛来说，一定要想清楚题目再交，下次不能 “样例过了就AC” 了。

部分题解

L - 山海之约

题意：

给定两个非负整数 a 与 b，判断它们的和是否为神秘数字 350234。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

void solve ()
{
	ll a, b;
	cin >> a >> b;
	if (a + b == 350234) {
            cout << "YES" << '\n';
	}else {
		cout << "NO" << '\n';
	}
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

H - 对决

题意：

给定两个字符串 s 与 t，记字串“fire”出现次数是a，“water”出现次数是b， “wind”出现次数是c，定义字符串的权值为a + b * c，判断s的权值是否严格大于t的权值。

思路：

简单遍历即可。时间复杂度：O(n + m)。

代码：

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n, m;

void solve ()
{
	string a = "fire";
	string b = "water";
	string c = "wind";
	cin >> n >> m;
	string s, t;
	cin >> s >> t;
	
	ll cnta = 0;
	ll cntb = 0;
	ll cntc = 0;
	for (int i = 0; i <= n - 4; i++) {
		if (s[i] == 'f' && s[i + 1] == 'i' && s[i + 2] == 'r' && s[i + 3] == 'e') {
			cnta++;
		}
		if (s[i] == 'w' && s[i + 1] == 'i' && s[i + 2] == 'n' && s[i + 3] == 'd') {
			cntc++;
		}
	}
	for (int i = 0; i <= n - 5; i++) {
		if (s[i] == 'w' && s[i + 1] == 'a' && s[i + 2] == 't' && s[i + 3] == 'e' && s[i + 4] == 'r') {
			cntb++;
		}
	}
	
	ll cntaa = 0;
	ll cntbb = 0;
	ll cntcc = 0;
	
	for (int i = 0; i <= m - 4; i++) {
		if (t[i] == 'f' && t[i + 1] == 'i' && t[i + 2] == 'r' && t[i + 3] == 'e') {
			cntaa++;
		}
		if (t[i] == 'w' && t[i + 1] == 'i' && t[i + 2] == 'n' && t[i + 3] == 'd') {
			cntcc++;
		}
	}
	for (int i = 0; i <= m - 5; i++) {
		if (t[i] == 'w' && t[i + 1] == 'a' && t[i + 2] == 't' && t[i + 3] == 'e' && t[i + 4] == 'r') {
			cntbb++;
		}
	}
	
	if (cnta + cntb * cntc > cntaa + cntbb * cntcc) {
		cout << "YES" << '\n';
	}else {
		cout << "NO" << '\n';
	}
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

I - 学霸题

题意

给定三个点 A, B, C，找出一个点D使得这 4 个点可以连成一个平行四边形。

思路

确定两个点，求出两点间x和y座标的变化后根据第三个点推出第四个点的位置。时间复杂度：O(1)。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

void solve ()
{
	ll x1, y1, x2, y2, x3, y3;
	cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
	ll tx = x2 - x1;
	ll ty = y2 - y1;
	ll x4 = x3 + tx;
	ll y4 = y3 + ty;
	cout << x4 << ' ' << y4 << '\n';
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

B - 爱的魔法

题意

给定一个序列，对于序列中的每一个数，交换至多两个数位，最大化操作后的序列和。

思路

数据范围不是很大，直接对每一个数简单遍历，取每个数的最大值即可。时间复杂度：O(n)。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n;

void solve ()
{
	cin >> n;
	vector <ll> v(n);
	for (int i = 0; i < n; i++) {
		cin >> v[i];
	}
	
	for (int i = 0; i < n; i++) {
		string s = to_string(v[i]);
		for (int k = 0; k < (ll)s.size(); k++) {
			ll t = s[k] - '0';
			ll pos = k;
			for (ll j = k + 1; j < (ll)s.size(); j++) {
				ll a = s[j] - '0';
				if (a >= t) {
					t = a;
					pos = j;				
				}
			}
			if (pos != k && s[pos] > s[k]) {
				swap(s[pos], s[k]);
				break;
			}
		}
		v[i] = stoll(s);
	}
	
	ll ans = 0;
	for (int i = 0; i < n; i++) {
		ans += v[i];
	}
	
	cout << ans << '\n';
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

A - 矩形游戏

题意

给定一个单调不降的序列[b1, b2, ... bn]与一个k行n列的矩阵A。签到哥从矩阵的第一行第一列移动到第k行的任意一列。签到哥位于(i, j)时可以移动到(i + 1, j - 1)或(i + 1, j)或(i + 1, j + 1)。签到哥只能移动到大于等于自己的位置，且移动后签到哥的体力也会相应增加。

求签到哥到达第k行的体力最大值

思路

由于序列单调不降，只需尽量往右走就行。另外，由于k是1e9级别，而n是2e5级别，最后如果到最后一列可以直接退出单独计算。时间复杂度：O(n)。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll k, n;

void solve ()
{
	cin >> k >> n;
	vector <ll> v(n);
	for (int i = 0; i < n; i++) {
		cin >> v[i];
	}
	
	ll sum = 0;
	ll j = 0;
	ll t = 0;
	for (int i = 0; i < k; i++) {
		if (sum >= v[j + 1] && j < n - 1) {
			j++;
		}
		sum += v[j];
		if (j == n - 1) {
			t = k - i - 1;
			break;
		}
	}
	
	sum += max(0LL, t) * v[n - 1];
	cout << sum << '\n';
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

M - 终极考验

题意

给定n个石柱高度，耗费一点能量可以使任意一个i至min(i + x - 1, n)区间内的所有石柱升高1米。

求使得石柱的高度单调不降所要耗费能量的最小值。

思路

这里给出一个另类的思路。对于任意一个vi，在（i - x + 1， i）这个区间内若存在vy需要增加，则vi一定会与vy增加相同次数。因此，在维护好一个差分数组后，我们可以考虑对于任意一个di，加上需要做区间加且区间加触及不到di的合法的di - x，最后加上所有小于0的d[i]的绝对值即可时间复杂度：O(n);

代码


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

void solve ()
{
	ll n, x;
	cin >> n >> x;
	vector <ll> v(n + 1, 0);
	vector <ll> d(n + 1, 0);
	for (int i = 1; i <= n; i++) {
		cin >> v[i];
		d[i] = v[i] - v[i - 1];
	}
	
	for (int i = x + 1; i <= n; i++) {
		if (d[i - x] < 0) {
			d[i] += d[i - x];
		}
	}
	
	ll ans = 0;
	for (int i = 2; i <= n; i++) {
		if (d[i] < 0) {
			ans += abs(d[i]);
		}
	}
	
	cout << ans << '\n';
	
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

C - 小W的计数题

题意

对于给出的每一个ai，找到元素数量最多的集合Sx, 其中对于任意的y∈S，使得[amin{x,y}, ..., amax{x,y}]的最大值为ay。

思路

题意很复杂，简要地说，这一题实际上是想要找到对于每一个ai向左的单调递增区间和向右的单调递增区间的长度之和。由此，不难想到可以利用单调栈来解决问题。可以维护从前往后的一个单调递减栈和从后往前的维护一个单调递减栈，在每一位加上栈的大小，重复两遍即是最终结果。时间复杂度：O(n)。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n;

void solve ()
{
	cin >> n;
	vector <ll> v(n + 1);
	for (int i = 1; i <= n; i++) {
		cin >> v[i];
	}
	
	vector <ll> ans(n + 1, 0);
	stack <ll> stk;
	
	for (int i = 1; i <= n; i++) {
		while (!stk.empty() && v[i] > stk.top()) {
			stk.pop();
		}
		stk.push(v[i]);
		ans[i] += stk.size();
	}
	
	stack <ll> stk1;
	
	for (int i = n; i >= 1; i--) {
		while (!stk1.empty() && v[i] > stk1.top()) {
			stk1.pop();
		}
		stk1.push(v[i]);
		ans[i] += stk1.size();
	}
	
	for (int i = 1; i <= n; i++) {
        cout << ans[i] - 1 << ' ';
	}
	cout << '\n';
	
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

G - 二分图判定

题意

给定一个序列[a1, a2, ... an]和一个正整数k, 在一张包含n个点的图上，第i个点的权值为i，对于合法的任意两点i，j，若 |ai - aj| > k，就在i与j两点之间连接一条无向边。

求出最小的非负整数k，使得按照上述方法生成的图是二分图。

思路

读完题后不难发现，该题的目的是在给定的an序列中，将其分为两个集合，并最小化两个集合的极差的最大值。

不难想到可以利用二分答案的方法来解决这道题, 可以先对an序列进行排序，再以答案进行从前到后和从后到前的check，最后若r <= l + 1则说明check成功。时间复杂度：O(nlogn)。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 998244353;

ll n;

void solve ()
{
    cin >> n;
    vector <ll> v(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> v[i];
    }
    sort(v.begin() + 1, v.end());

    auto check = [&] (ll md) -> bool {
        ll l = 1;
        for (int i = 1; i <= n; i++) {
            if (v[i] - v[1] <= md) {
                l = i;
            }else {
                break;
            } 
        }
        ll r = n;
        for (int i = n - 1; i >= 1; i--) {
            if (v[n] - v[i] <= md) {
                r = i;
            }else {
                break;
            }
        }
        return r <= l + 1;
    };

    ll l = 0, r = v[n]; 
    while (l <= r) {
        ll mid = l + ((r - l) >> 1);
        if (check(mid)) {
            r = mid - 1;
        }else {
            l = mid + 1;
        }
    }
    cout << l << '\n';
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

J - 鱼骨挖矿法

题意

给定一个n行m列的二位网格，每个格子的数字代表当前格的矿物价值。首先钒钒会选择第i行作为主矿道，并将主矿道上方和下方的矿道的所有矿物全部采集。再以主矿道为中心，在每个满足j === 2 (mod 3)的j列（分矿道）分别向上向下挖，在挖到第一个矿物时停止挖掘。

挖掘规则：

如果在一次挖掘操作中发现多个矿物，钒钒会将这些矿物同时挖掘。
如果在当前分矿道上挖掘到矿物，钒钒会立即停止挖掘
上下分矿道的挖掘情况相互独立，即：上分矿道的挖掘情况不会影响到下分矿道的挖掘情况。

求在以第i行为主矿道时(1 <= i <= n)，所能挖到的矿物的总价值。

思路

首先，对于每一个主矿道来说，我们可以预处理每一个主矿道的结果。而对于每一个分矿道来说，对于向上的分矿道，我们可以预处理出到每一格时所能挖到的矿物价值，即sup[i][j] = v[i][j] + v[i - 1][j] + v[i][j - 1] + v[i][j + 1]。若sup[i][j] != 0，则up[i][j] = sup[i][j]，否则up[i][j] = up[i - 1][j]。向下的分矿道也是类似的。在每个i行，只需要加上所有合法的up[i - 2][j]和dw[i + 2][j]即可。时间复杂度：O(n * m)。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 1e9 + 7;

ll n, m;

void solve ()
{
	cin >> n >> m;
    vector <vector <ll> > v(n + 3, vector <ll> (m + 3));
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> v[i][j];
        }
    }

    vector <ll> ss(n + 2, 0);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            ss[i] += v[i][j];
        }
    }

    vector <ll> s(n + 2, 0);//主矿道
    for (int i = 1; i <= n; i++) {
        s[i] = ss[i - 1] + ss[i] + ss[i + 1];
    }

    vector <vector <ll> > sa(n + 2, vector <ll> (m + 2));//上部分矿道
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            sa[i][j] = v[i][j] + v[i - 1][j] + v[i][j - 1] + v[i][j + 1];
        }
    }
    vector <vector <ll> > up(n + 2, vector <ll> (m + 2)); 
    for (int j = 1; j <= m; j++) {
        for (int i = 1; i <= n; i++) {
            if (sa[i][j] != 0) {
                up[i][j] = sa[i][j];
            }else {
                up[i][j] = up[i - 1][j];
            }
        }
    }

    vector <vector <ll> > sb(n + 2, vector <ll> (m + 2));//下部分矿道
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            sb[i][j] = v[i][j] + v[i + 1][j] + v[i][j - 1] + v[i][j + 1];
        }
    }
    vector <vector <ll> > dw(n + 2, vector <ll> (m + 2)); 
    for (int j = 1; j <= m; j++) {
        for (int i = n; i >= 1; i--) {
            if (sb[i][j] != 0) {
                dw[i][j] = sb[i][j];
            }else {
                dw[i][j] = dw[i + 1][j];
            }
        }
    }

    vector <ll> ans(n + 1, 0);
    for (int i = 1; i <= n; i++) {
        if (i == 1) {
            ans[i] += s[i];
            if (n <= 2) continue;
            for (int j = 2; j <= m; j += 3) {
                ans[i] += dw[i + 2][j];
            }
        }else if (i == n) {
            ans[i] += s[n];
            if (n <= 2) continue;
            for (int j = 2; j <= m; j += 3) {
                ans[i] += up[i - 2][j];
            }
        }else {
            ans[i] += s[i];
            if (n <= 2) continue;
            for (int j = 2; j <= m; j += 3) {
                ans[i] += up[i - 2][j] + dw[i + 2][j];
            }
        }
    }

    for (int i = 1; i <= n; i++) {
        cout << ans[i] << ' ';
    }
    cout << '\n';
}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

K - 大师和他的领域

题意

给定一个数组a和值k，求有多少个区间满足以下要求：

区间中必须包含值k
区间中大于k值的数量必须等于小于k值的数量

思路

我们可以令大于k的值为1，小于k的值为-1，等于k的值为0。维护一个前缀和数组。对于每一个的下标，都往前二分查找相同值且包含值k的最大左边界即可。时间复杂度：O(nlogn)。

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

#define fi first
#define se second

const ll MAXN = 1e8;
const ld eps = 1e-12;
const ll mod = 998244353;

ll n, k;
string s;

void solve ()
{
	cin >> n >> k;
    vector <ll> v(n + 1);   
    
    for (int i = 1; i <= n; i++) {
        cin >> v[i];
    }

    vector <ll> s(n + 1, 0);
    for (int i = 1; i <= n; i++) {
        s[i] = s[i - 1];
        if (v[i] > k) {
            s[i]++;
        }else if (v[i] < k) {
            s[i]--;
        }
    }

    vector <vector<ll> > pos(2 * n + 2);
    pos[n].push_back(0);
    ll ans = 0; 
    ll exist = -1;

    for (int i = 1; i <= n; i++) {
        pos[s[i] + n].push_back(i);
        if (v[i] == k) {
            exist = i;
        }
        if (exist != -1) {
            ans += lower_bound(pos[s[i] + n].begin(), pos[s[i] + n].end(), exist) - pos[s[i] + n].begin();
        }
    }
    cout << ans << '\n';

}

int main ()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int _ = 1;
	cin >> _;
	while (_--) {
		solve();
	}
	return 0;
}

CS50入门教程

Fri, 10 Oct 2025 00:00:00 GMT

CS50入门教程

预先准备

首先，在开始之前，面对全英文的cs50网站，准备一个浏览器的翻译插件是必要的。这里推荐根据AI翻译插件配置教程 | scandi-blog来设置。若不想太麻烦，可以先选择有道灵动翻译插件先体验，在之后如果感觉翻译的晦涩难懂，跟原文有偏差，可以再使用AI翻译插件。

其次，由于众所周知的原因，梯子的准备会让学习的过程更加顺畅。

另外，也需要注册一个github账号，并提前在电脑上安装VSCode。

关于CS50的环境配置

CS50的学习主要分为看课程和提交作业两大项。关于课程的观看，可以直接在B站搜索CS50的相关课程资源来学习。观看一节课程，提交一节作业。

提交作业即需要配置相关的环境了。再点击进入csdiy中的2025年课程后，下滑左侧栏，找到Week 1 C，点击进入。

点开后，下滑右侧栏至底部，找到Problem Set 1（作业集1）。

点击进入后，便可看到配置环境的一些步骤。

首先进行步骤一，点开链接后，点击Authorize cs50（授权cs50）后，可退回进行步骤2。

进入CS50.dev 后，使用github账号log in后，便可看到网页版的VSCode。

但是在这个网页上做CS50的作业是非常卡顿的。若将其连接到本地VSCode，卡顿的情况将会大大改善。

将 CS50 网页端的 VSCode 环境连接到本地 VSCode

打开电脑中下载的VSCode软件，安装GitHub Codespaces扩展，成功后会发现左侧栏出现新标识（远程资源管理器），点击进入，并登录github账号，便可将网页端的VSCode连接到本地，此后可以愉快的在本地写CS50的作业啦！前提是每次连接前需要进入CS50.dev 打开网页端。

祝大家学习愉快！

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Spoiler

You can add spoilers to your text. The text also supports Markdown syntax.

The content :spoiler[is hidden ayyy]!

The content :spoiler[is hidden **ayyy**]!

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili

Everlasting的博客

2026_WUST选拔赛Round1_L题题解

2026 WUST选拔赛Round1 L题题解

题意：

思路：

代码：

Atcoder Beginner Contest 459 F题题解

Atcoder Beginner Contest 459 F题题解

题意：

思路：

代码：

CF1463B题解

CF1463B题解

题意：

思路：

代码：

关于在windows上编译失败的解决方案

Windows 下给 MinGW 手动补齐 iconv.h 环境教程

1. 问题背景

2. 适用环境

3. 下载 libiconv 包

4. 解压 .pkg.tar.zst 文件

5. 复制文件到你的 MinGW 目录

5.1 复制 include 文件

5.2 复制 lib 文件

5.3 复制 bin 文件

华中农业大学第十五届程序设计竞赛游记及部分题解

华中农业大学第十五届程序设计竞赛游记及部分题解

游记

题解

I

题意

代码

D

题意

思路

代码

G

题意

思路

代码

F

题意

思路

代码

E

题意

思路

代码

L

题意

思路

代码

J

题意

思路

代码

B

题意

思路

代码

C

题意

思路

代码

华中师范大学2026菜鸟杯游记及部分题解

华中师范大学2026菜鸟杯游记及部分题解

游记

题解

D

代码

A

题意

思路

代码

I

题意

思路

代码

J

Windows 下给 MinGW 手动补齐 `iconv.h` 环境教程

4. 解压 `.pkg.tar.zst` 文件