当前位置：首页 > article >正文

蓝桥杯十四届C++B组真题题解

article 2025/3/27 19:10:36

试题A：日期统计

【问题描述】
小蓝现在有一个长度为100的数组，数组中的每个元素的值都在0到9的范围之内。数组中的元素从左至右如下所示：

5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2 7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3 3 8 5 1 6 3 4 6 7 0 7 8 2 7 6 8 9 5 6 5 6 1 4 0 1 0 0 9 4 8 0 9 1 2 8 5 0 2 5 3 3

现在他想要从这个数组中寻找一些满足以下条件的子序列:
1.子序列的长度为 8:
2.这个子序列可以按照下标顺序组成一个 yyy,ymmdd 格式的日期，并且要求这个日期是 2023 年中的某一天的日期，例如 20230902，20231223。yyyy 表示年份，mm 表示月份，dd 表示天数，当月份或者天数的长度只有一位时需要一个前导零补充。
请你帮小蓝计算下按上述条件一共能找到多少个不同的 2023 年的日期。对于相同的日期你只需要统计一次即可。

【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

#include <iostream>
#include<vector>

using namespace std;

typedef long long ll;
int main()
{
    vector<int> v({ 5, 6, 8, 6, 9, 1, 6, 1, 2, 4, 9, 1, 9, 8, 2, 3, 6, 4, 7, 7, 5, 9, 5, 0, 3, 8, 7, 5, 8, 1, 5, 8, 6, 1, 8, 3, 0, 3, 7, 9, 2, 7, 0, 5, 8, 8, 5, 7, 0, 9, 9, 1, 9, 4, 4, 6, 8, 6, 3, 3, 8, 5, 1, 6, 3, 4, 6, 7, 0, 7, 8, 2, 7, 6, 8, 9, 5, 6, 5, 6, 1, 4, 0, 1, 0, 0, 9, 4, 8, 0, 9, 1, 2, 8, 5, 0, 2, 5, 3, 3 });
    int monthday[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    int count = 0;
    for (int month = 1; month <= 12; month++)
    {
        for (int day = 1; day <= monthday[month]; day++)
        {
            int k = 0;
            int a[] = { 2,0,2,3,month / 10,month % 10,day / 10,day % 10 };
            for (int i = 0; i < v.size(); i++)
            {
                if (v[i] == a[k])
                {
                    k++;
                    if (k == 8)
                    {
                        count++;
                        break;
                    }
                }
            }
        }
    }
    cout << count;
    return 0;
}

试题B：001的串的熵

#include <iostream>
using namespace std;

int main() {
    double n = 23333333.0;
    for (long long i = 0; i <= n / 2; i++)
    {
        double sum = 0.0;
        sum -= (i * i / n * log2(i / n)) + ((n - i) * ((n - i) / n) * log2((n - i) / n));
        if (sum > 11625907.5 && sum < 11625907.6) {
            cout << i << endl;
            break;
        }
    }
    
    return 0;
}

试题C：冶炼金属

题目描述

小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金

属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。

现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。

根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。

输入格式

第一行一个整数 N，表示冶炼记录的数目。

接下来输入 N 行，每行两个整数 A、B，含义如题目所述。

输出格式

输出两个整数，分别表示 V 可能的最小值和最大值，中间用空格分开。

样例输入

样例输出

20 25

提示

当 V = 20 时，有：⌊75/20⌋ = 3，⌊ 53/20 ⌋ = 2，⌊ 59/20 ⌋ = 2，可以看到符合所有冶炼记录。

当 V = 25 时，有：⌊75/25⌋ = 3，⌊ 53/25 ⌋ = 2，⌊ 59/25 ⌋ = 2，可以看到符合所有冶炼记录。

且再也找不到比 20 更小或者比 25 更大的符合条件的 V 值了。

#include <iostream>
#include<vector>

using namespace std;

typedef long long ll;
int main()
{
    int n;
    cin >> n;
    vector<pair<int, int>> v;
    int max_sum = 9999999999;
    for (int i = 0; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        v.push_back({ x,y });
        max_sum = min(x / y, max_sum);
    }
    int min_sum = 0;
    for (int i = max_sum - 1; i > 0; i--)
    {
        int flag = 1;
        for (int j = 0; j < n; j++)
        {
            if (v[j].first / i != v[j].second)
            {
                flag = 0;
                break;
            }
        }
        if (flag == 0)
        {
            min_sum = i + 1;
            break;
        }
    }
    cout << min_sum <<' '<< max_sum << endl;
    return 0;
}

试题D：飞机降落

N 架飞机准备降落到某个只有一条跑道的机场。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早

可以于 Ti 时刻开始降落，最晚可以于 Ti + Di 时刻开始降落。降落过程需要 Li个单位时间。

一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。

请你判断 N 架飞机是否可以全部安全降落。

输入格式

输入包含多组数据。

第一行包含一个整数 T，代表测试数据的组数。

对于每组数据，第一行包含一个整数 N。

以下 N 行，每行包含三个整数：Ti，Di 和 Li。

输出格式

对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。

样例输入

样例输出

YES
NO

#include <iostream>
#include<vector>

using namespace std;


struct node
{
    int t, d, l;
};

bool dfs(int u, int last,vector<node>& v, vector<bool>& hash)
{
    if (u == v.size()) return true;

    for (int i = 0; i < v.size(); i++)
    {
        if (v[i].t + v[i].d >= last && !hash[i])
        {
            hash[i] = true;
            if (dfs(u + 1, max(last, v[i].t) + v[i].l, v, hash)) return true;
            hash[i] = false;
        }
    }
    return false;
}

int main()
{
    int T;
    cin >> T;
    while (T--)
    {
        int n;
        cin >> n;
        vector<node> v(n);
        vector<bool> hash(n);
        for (int i = 0; i < n; i++)
        {
            cin >> v[i].t >> v[i].d >> v[i].l;
        }

        if (dfs(0, 0, v, hash)) cout << "YES" << endl;
        else cout << "NO" << endl;
    }

    return 0;
}

在DFS函数中，last参数表示上一架飞机完成降落的时间。当递归调用dfs(u + 1, max(last, t) + l)时，这里的关键是确定当前飞机的最早可开始降落时间，并计算其结束时间以约束后续飞机的降落时间。具体逻辑如下：

时间窗口约束
当前飞机的开始时间必须同时满足两个条件：
- 不能早于其到达时间 t（即必须满足 t ≤ 开始时间）。
- 不能早于上一架飞机的结束时间 last（即必须满足 last ≤ 开始时间）。
  因此，实际开始时间为 max(t, last)。
结束时间计算
当前飞机降落需要 l 个单位时间，因此其结束时间为 max(t, last) + l。
这个结束时间将作为下一层递归的 last 参数，确保后续飞机的开始时间不会与此冲突。

示例说明
假设上一架飞机在 last=20 完成降落，当前飞机的 t=15（到达时间）且 d=5（允许最晚在 t+d=20 开始降落）。此时：

开始时间必须取 max(20, 15) = 20（受限于前一架飞机的结束时间）。
结束时间为 20 + l，该值成为后续飞机的 last 参数。

若当前飞机的 t=25，而 last=20：

开始时间取 max(20, 25) = 25（受限于自身到达时间）。
结束时间为 25 + l，作为后续约束。

试题E：接龙数列

题目描述

对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。

例如 12, 23, 35, 56, 61, 11 是接龙数列；12, 23, 34, 56 不是接龙数列，因为 56的首位数字不等于 34 的末位数字。所有长度为 1 的整数数列都是接龙数列。

现在给定一个长度为 N 的数列 A1, A2, . . . , AN，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？

输入格式

第一行包含一个整数 N。

第二行包含 N 个整数 A1, A2, . . . , AN。

输出格式

一个整数代表答案。

样例输入

5
11 121 22 12 2023

样例输出

#include <iostream>
#include<vector>

using namespace std;

int aaa(int x)
{
    while (x / 10)
    {
        x /= 10;
    }
    return x;
}
int main()
{
    int n;
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; i++) cin >> v[i];
    vector<vector<int>> dp(n,vector<int>(10));
    dp[0][v[0] % 10] = 1;
    for (int i = 1; i < n; i++)
    {
        int tail = v[i] % 10;
        for (int j = 0; j < 10; j++)
        {
            dp[i][j] = dp[i - 1][j];
        }

        dp[i][tail] = max(dp[i - 1][aaa(v[i])] + 1, dp[i - 1][tail]);
    }
    int count = 0;
    for (int i = 0; i < 10; i++)
    {
        count = max(count, dp[n - 1][i]);
    }
    cout << n - count;
    return 0;
}

通过计算最小删除数可能会比较麻烦，所以我们可以求出接龙数列的最大长度，反其道而行

这里的dp[i][j]表示的含义：在前i个数据中以j位置为结尾的最大长度

dp[i][tail]=max(dp[i-1][head]+1,dp[i-1][tail])：第一种就是选i位置的元素，第二种就是删除i位置的元素

试题F：岛屿个数

题目描述

小蓝得到了一副大小为 M × N 的格子地图，可以将其视作一个只包含字符‘0’（代表海水）和 ‘1’（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的 ‘1’ 相连接而形成。

在岛屿 A 所占据的格子中，如果可以从中选出 k 个不同的格子，使得他们的坐标能够组成一个这样的排列：(x0, y0),(x1, y1), . . . ,(xk−1, yk−1)，其中(x(i+1)%k , y(i+1)%k) 是由 (xi , yi) 通过上/下/左/右移动一次得来的 (0 ≤ i ≤ k − 1)，

此时这 k 个格子就构成了一个 “环”。如果另一个岛屿 B 所占据的格子全部位于这个 “环” 内部，此时我们将岛屿 B 视作是岛屿 A 的子岛屿。若 B 是 A 的子岛屿，C 又是 B 的子岛屿，那 C 也是 A 的子岛屿。

请问这个地图上共有多少个岛屿？在进行统计时不需要统计子岛屿的数目。

输入格式

第一行一个整数 T，表示有 T 组测试数据。

接下来输入 T 组数据。对于每组数据，第一行包含两个用空格分隔的整数M、N 表示地图大小；接下来输入 M 行，每行包含 N 个字符，字符只可能是‘0’ 或 ‘1’。

输出格式

对于每组数据，输出一行，包含一个整数表示答案。

样例输入

样例输出

1
3

#include <iostream>
#include<vector>
#include <cmath>
#include <queue>
#include<algorithm>
#include <set>

using namespace std;

int dirss[8][2] = { {-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1} };
int dirs[4][2] = { {-1,0},{0,1},{1,0},{0,-1} };

void dfs1(int x, int y, vector<vector<bool>>& hash, vector<vector<int>>& v)
{
    for (auto dir : dirss)
    {
        int nx = x + dir[0], ny = y + dir[1];
        if (nx >= 0 && nx < v.size() && ny >= 0 && ny < v[0].size() && !hash[nx][ny] && v[nx][ny] == 0)
        {
            v[nx][ny] = 2;
            hash[nx][ny] = true;
            dfs1(nx, ny, hash, v);
        }
    }
}

bool dfs(int x, int y, vector<vector<bool>>& hash, vector<vector<int>>& v)
{
    for (auto dir : dirs)
    {
        int nx = x + dir[0], ny = y + dir[1];
        if (nx >= 0 && nx < v.size() && ny >= 0 && ny < v[0].size() && !hash[nx][ny] && v[nx][ny] == 1)
        {
            hash[nx][ny] = true;
            dfs(nx, ny, hash, v);
        }
    }

    for (auto dir : dirss)
    {
        int nx = x + dir[0], ny = y + dir[1];
        if (nx >= 0 && nx < v.size() && ny >= 0 && ny < v[0].size())
        {
            if (v[nx][ny] == 2) return true;
        }
    }
    return false;
}
int main()
{
    int T;
    cin >> T;
    while (T--)
    {
        int m, n;
        cin >> m >> n;
        vector<vector<int>> v(m+2, vector<int>(n+2, 0));
        for (int i = 1; i <= m; i++)
        {
            string s1;
            cin >> s1;
            for (int j = 1; j <= n; j++)
            {
                v[i][j] = s1[j - 1] - '0';
            }
        }
        int count = 0;
        vector<vector<bool>> hash(m + 2, vector<bool>(n + 2, false));
        hash[0][0] = true;
        v[0][0] = 2;
        dfs1(0, 0, hash, v);
        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (!hash[i][j] && v[i][j] == 1)
                {
                    if (dfs(i, j, hash, v)) count++;
                }
            }
        }
        cout << count << endl;
    }
    return 0;
}

这道题的难点在于如何排除子岛屿，我们可以加一圈外海（1），并且将所有与外海相连的海域统计为（2），之后在计算岛屿个数的时候只需要统计岛屿周围是否存在外海即可

试题G：子串简写

题目描述

程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如 internation-alization 简写成 i18n，Kubernetes （注意连字符不是字符串的一部分）简写成 K8s, Lanqiao 简写成 L5o 等。

在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法（长度小于 K 的字符串不配使用这种简写）。

给定一个字符串 S 和两个字符 c1 和 c2，请你计算 S 有多少个以 c1 开头c2 结尾的子串可以采用这种简写？

输入格式

第一行包含一个整数 K。

第二行包含一个字符串 S 和两个字符 c1 和 c2。

输出格式

一个整数代表答案。

样例输入

4
abababdb a b

样例输出

#include <iostream>
#include<vector>
#include <cmath>
#include <queue>
#include<algorithm>
#include <set>
#include<string>

using namespace std;


int main()
{
    int k;
    string s;
    cin >> k >> s;
    char a, b;
    cin >> a >> b;
    vector<int> v1;
    vector<int> v2;
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] == a) v1.push_back(i);
        if (s[i] == b) v2.push_back(i);
    }
    long long count = 0;
    for (int i = 0; i < v1.size(); i++)
    {
        auto it=lower_bound(v2.begin(), v2.end(), v1[i] + k-1);
        count += v2.end() - it;
    }
    cout << count << endl;
    return 0;
}

这道题用二分查找算法即可解决，count+=v2.end()-it是为了满足条件的元素数量累加到 count

试题H：整数删除

题目描述

给定一个长度为 N 的整数数列：A1, A2, . . . , AN。你要重复以下操作 K 次：

每次选择数列中最小的整数（如果最小值不止一个，选择最靠前的），将其删除。并把与它相邻的整数加上被删除的数值。输出 K 次操作后的序列。

输入格式

第一行包含两个整数 N 和 K。

第二行包含 N 个整数，A1, A2, A3, . . . , AN。

输出格式

输出 N − K 个整数，中间用一个空格隔开，代表 K 次操作后的序列。

样例输入

5 3
1 4 2 8 7

样例输出

17 7

#include <iostream>
#include<vector>
#include <cmath>
#include <queue>
#include<algorithm>
#include <set>
#include<string>

using namespace std;

struct cmp {
    bool operator()(pair<long long, long long> a, pair<long long, long long> b) {
        if (a.first == b.first) return a.second > b.second; // 数值相同则索引小的优先
        return a.first > b.first; // 数值小的优先（构建小根堆）
    }
};
int main()
{
    int n, k;
    cin >> n >> k;
    vector<long long> v(n);
    priority_queue<pair<long long, long long>,vector<pair<long long, long long>>,cmp> q;
    for (int i = 0; i < n; i++)
    {
        cin >> v[i];
        q.push({v[i],i});
    }
    while (k)
    {
        long long a = q.top().first, b = q.top().second;
        q.pop();
        if (v[b] == a)
        {
            v[b] = -1;

            int x = b - 1;
            while (x >= 0)
            {
                if (v[x] == -1)
                {
                    x--;
                    continue;
                }
                v[x] += a;
                q.push({ v[x],x});
                break;
            }

            int y = b + 1;
            while (y < n)
            {
                if (v[y] == -1)
                {
                    y++;
                    continue;
                }
                v[y] += a;
                q.push({ v[y],y });
                break;
            }
            k--;
        }
        else
        {
            continue;
        }
    }
    for (int i = 0; i < n; i++)
    {
        if (v[i] != -1) cout << v[i] << ' ';
    }
    return 0;
}

这题主要考察如何创建小根堆，只要将被删除数改为-1，并将被删除数加到左右两边非负数的数据即可

试题I：景区导游

题目描述

某景区一共有 N 个景点，编号 1 到 N。景点之间共有 N − 1 条双向的摆渡车线路相连，形成一棵树状结构。在景点之间往返只能通过这些摆渡车进行，需要花费一定的时间。

小明是这个景区的资深导游，他每天都要按固定顺序带客人游览其中 K 个景点：A1, A2, . . . , AK。今天由于时间原因，小明决定跳过其中一个景点，只带游客按顺序游览其中 K − 1 个景点。具体来说，如果小明选择跳过 Ai，那么他会按顺序带游客游览 A1, A2, . . . , Ai−1, Ai+1, . . . , AK, (1 ≤ i ≤ K)。

请你对任意一个 Ai，计算如果跳过这个景点，小明需要花费多少时间在景点之间的摆渡车上？

输入格式

第一行包含 2 个整数 N 和 K。

以下 N − 1 行，每行包含 3 个整数 u, v 和 t，代表景点 u 和 v 之间有摆渡车线路，花费 t 个单位时间。

最后一行包含 K 个整数 A1, A2, . . . , AK 代表原定游览线路。

输出格式

输出 K 个整数，其中第 i 个代表跳过 Ai 之后，花费在摆渡车上的时间。

样例输入

样例输出

10 7 13 14

#include <iostream>
#include <vector>
#include <cstring>
using namespace std;

const long long MAXN = 1e5 + 5;
const long long LOG = 20;

vector<pair<long long, long long>> tree[MAXN];//存储树的邻接表。每个节点u对应一个向量，其中每个元素是一个pair，包含子节点v和边权w。表示节点u与节点v之间有一条边，权值为w。
long long depth[MAXN];//存储每个节点的深度。深度表示从根节点到该节点的路径长度。根节点的深度通常初始化为0或1。
long long fa[MAXN][LOG];//存储每个节点的2^i级祖先。fa[u][i]表示节点u的第2^i级祖先。通过预处理，可以在O(logN)时间内找到任意两个节点的最近公共祖先（LCA）。
long long dis[MAXN][LOG]; 存储每个节点到其2^ i级祖先的距离。dis[u][i]表示节点u到其第2^ i级祖先的路径总权值。用于快速计算两个节点之间的路径距离。

void dfs(long long u, long long pre) {
    depth[u] = depth[pre] + 1;
    fa[u][0] = pre;
    for (long long i = 1; i < LOG; ++i) {
        fa[u][i] = fa[fa[u][i - 1]][i - 1];
        dis[u][i] = dis[u][i - 1] + dis[fa[u][i - 1]][i - 1];
    }

    for (auto& v : tree[u]) {
        long long a = v.first, b = v.second;
        if (a != pre) {
            dis[a][0] = b;
            dfs(a, u);
        }
    }
}

long long lca(long long u, long long v, long long& dist) {
    dist = 0;
    if (depth[u] < depth[v]) swap(u, v);
    // 上提u到v的深度
    for (long long i = LOG - 1; i >= 0; --i) {
        if (depth[fa[u][i]] >= depth[v]) {
            dist += dis[u][i];
            u = fa[u][i];
        }
    }
    if (u == v) return u;
    // 同时上提找LCA
    for (long long i = LOG - 1; i >= 0; --i) {
        if (fa[u][i] != fa[v][i]) {
            dist += dis[u][i] + dis[v][i];
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    dist += dis[u][0] + dis[v][0];
    return fa[u][0];
}

long long getDistance(long long u, long long v) {
    long long d;
    lca(u, v, d);
    return d;
}

int main() {
    long long N, K;
    cin >> N >> K;
    for (long long i = 0; i < N - 1; ++i) {
        long long u, v, t;
        cin >> u >> v >> t;
        tree[u].emplace_back(v, t);
        tree[v].emplace_back(u, t);
    }
    // 初始化根节点为1
    memset(depth, 0, sizeof(depth));
    dfs(1, 0); // 1的父节点设为0

    vector<long long> A(K);
    for (long long i = 0; i < K; ++i) {
        cin >> A[i];
    }

    // 计算原始总时间
    long long original_total = 0;
    if (K > 1) {
        for (long long i = 0; i < K - 1; ++i) {
            original_total += getDistance(A[i], A[i + 1]);
        }
    }

    vector<long long> ans(K);
    for (long long i = 0; i < K; ++i) {
        if (K == 1) { // 特殊情况处理
            ans[i] = 0;
        }
        else if (i == 0) {
            ans[i] = original_total - getDistance(A[0], A[1]);
        }
        else if (i == K - 1) {
            ans[i] = original_total - getDistance(A[K - 2], A[K - 1]);
        }
        else {
            long long d1 = getDistance(A[i - 1], A[i]);
            long long d2 = getDistance(A[i], A[i + 1]);
            long long d3 = getDistance(A[i - 1], A[i + 1]);
            ans[i] = original_total - d1 - d2 + d3;
        }
    }

    for (long long i = 0; i < K; ++i) {
        cout << ans[i] << (i == K - 1 ? "\n" : " ");
    }

    return 0;
}

这道题就是一道lca的模板题，直接套模板即可

试题J：砍树（不会，别看）

题目描述

给定一棵由 n 个结点组成的树以及 m 个不重复的无序数对 (a1, b1), (a2, b2),

. . . , (am, bm)，其中 ai 互不相同，bi 互不相同，ai ≠ bj(1 ≤ i, j ≤ m)。

小明想知道是否能够选择一条树上的边砍断，使得对于每个 (ai , bi) 满足 ai和 bi 不连通，如果可以则输出应该断掉的边的编号（编号按输入顺序从 1 开始），否则输出 -1.

输入格式

输入共 n + m 行，第一行为两个正整数 n，m。

后面 n − 1 行，每行两个正整数 xi，yi 表示第 i 条边的两个端点。

后面 m 行，每行两个正整数 ai，bi。

输出格式

一行一个整数，表示答案，如有多个答案，输出编号最大的一个。

样例输入

样例输出

查看全文

http://www.kler.cn/a/593879.html

计算机网络基础：网络配置与管理

springboot实现文件上传到服务器上，并通过url访问

批量将 PPT 转换为PDF/XPS/JPG图片等其它格式

谈谈 CSS 中z - index属性的作用及在什么情况下会失效。

LVGL和其他图形库区别于联系

1.环境搭建VUE+Spring boot

「清华大学、北京大学」DeepSeek 课件PPT专栏

小型状态机实现

Kubeasz工具快速部署K8Sv1.27版本集群(二进制方式)

Promethues 添加访问密码

数据结构与算法的学习路线

Redis设置开机自启报错start-limit-hit

MySQL配置主从复制教程(MySQL8)

【C++语言】继承和多态常见的面试问题

深入理解DFS：从迷宫探险到动态剪枝的征服之路（C++实现）

@maptalks/gl-layers中的VectorTileLayer的setStyle属性的全部line配置

Linux应用：进程间通信

集成学习（Ensemble Learning）基础知识2

sqli-labs学习记录5

游戏引擎学习第166天

试题A：日期统计

试题B：001的串的熵

试题C：冶炼金属

题目描述

输入格式

输出格式

样例输入

样例输出

提示

试题D：飞机降落

输入格式

输出格式

样例输入

样例输出

试题E：接龙数列

题目描述

输入格式

输出格式

样例输入

样例输出

试题F：岛屿个数

题目描述

输入格式

输出格式

样例输入

样例输出

试题G：子串简写

题目描述

输入格式

输出格式

样例输入

样例输出

试题H：整数删除

题目描述

输入格式

输出格式

样例输入

样例输出

试题I：景区导游

题目描述

输入格式

输出格式

样例输入

样例输出

试题J：砍树（不会，别看）

题目描述

输入格式

输出格式

样例输入

样例输出

相关文章：