第十四届蓝桥杯省赛C++B组个人代码(未检验)

已于 2023-04-14 23:43:09 修改
阅读量687 收藏 9
点赞数 4
文章标签： 蓝桥杯 c++ 算法
于 2023-04-08 21:27:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62729874/article/details/130032777
版权

2023 年 4 月 8 日是蓝桥杯省赛，今年我参加的是 C++ 组 B 组，虽然说打得不是很理想，不过好在个人感觉省一问题不是很大，反正只要是省一对得多对得少都一样。

比赛中的代码是没法保存的，所以我借着新鲜的记忆，重新把我会写的题的代码都码了一遍，只是过了样例，不能保证是正确答案，不过思路大差不差，应该还是具有借鉴价值的吧。

A. 日期统计 (已通过民间数据)

235
#include <bits/stdc++.h>
const int n = 100;
bool check(std::string &s, std::string &t) {
    int j = 0;
    for (int i = 0; i < n; i++) {
        if (j < (int) t.size() && s[i] == t[j]) {
            j++;
        }
    }
    if (j == t.size())
        return true;
    return false;
};

int main() {
    std::string s = "5686916124919823647759503875815861830379270588570991944686338516346707827689565614010094809128502533";
    int ans = 0;
    std::string year = "2023";
    int d[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    for (int i = 1; i <= 12; i++) {
        std::string month = std::to_string(i);
        if (month.size() == 1) {
            month = "0" + month;
        }
        for (int j = 1; j <= d[i]; j++) {
            std::string day = std::to_string(j);
            if (day.size() == 1) {
                day = "0" + day;
            }
            std::string t = year + month + day;
            if (check(s, t)) {
                ans++;
            }
        }
    }
    std::cout << ans;
    
    return 0;
}

B. 01串的熵 (已通过民间数据)

11027421
#include "bits/stdc++.h"
double eps = 1E-4;
double get(int x, int y)
{
    double zero = 1.0 * x / (1.0 * (x + y));
    double one = 1.0 * y / (1.0 * (x + y));
    return -(x * zero * log2(zero) + y * one * log2(one));
}

int main() {
    int n = 23333333;
    for (int i = 0; i <= n; i++) {
        if (abs(get(i, n - i) - 11625907.5798) <= eps) {
            std::cout << i << '\n';
            return 0;
        }
    }
    return 0;
}

C. 冶炼金属 (已通过民间数据)

#include <iostream>
#include <cmath>
#define int long long
const int N = 1e4 + 1;
std::pair<int,int> a[N];
signed main()
{
    int n;
    std::cin >> n;
    int mx = INT_MAX;
    for (int i = 0; i < n; i ++) {
        std::cin >> a[i].first >> a[i].second;
        mx = std::min(mx, a[i].first / a[i].second);
    }
    int l = 1, r = 2e9, mn = r;
    while(l <= r) {
        int mid = (l + r) >> 1;
        bool ok = 1;
        for (int i = 0; i < n; i ++) {
            if(a[i].first / mid > a[i].second) {
                ok = 0;
                break;
            }
        }
        if(ok) {
            mn = mid;
            r = mid - 1;
        }
        else l = mid + 1;
    }
    std::cout << mn << ' ' << mx;
    
    return 0;
}

对于这种签到题，二分未免有点过于小题大做了，直接贪心即可

#include <iostream>
#include <cmath>
#define int long long
signed main()
{
    int n;
    std::cin >> n;
    int mx = INT_MAX, mn = 0;
    for (int i = 0; i < n; i ++) {
        int a, b;
        std::cin >> a >> b;
        mx = std::min(mx, a / b);
        mn = std::max(mn, a / (b + 1) + 1);
    }
    std::cout << mn << ' ' << mx;
    return 0;
}

D. 飞机降落 (已通过民间数据)

 

 听说这题可以用状压DP，不过我这种菜鸡显然只会全排列无脑暴力。毕竟复杂度也在允许范围内嘛~

复杂度 O(n\times n!) .

#include <iostream>
#include <algorithm>
struct node {
    int l, r, len;
};
node a[11];
int idx[11]; //存放下标的数组，便于全排列
void solve()
{
    int n;
    std::cin >> n;
    for (int i = 1; i <= n; i ++) {
        std::cin >> a[i].l >> a[i].r >> a[i].len;
        a[i].r += a[i].l;
    }
    for (int i = 1; i <= n; i ++)
        idx[i] = i;
    do {
        int rs = a[idx[1]].l + a[idx[1]].len;
        bool ok = 1;
        for (int k = 2; k <= n; k ++) {
            int i = idx[k];
            if(a[i].r < rs) {
                ok = 0;
                break;
            }
            rs = std::max(rs, a[i].l) + a[i].len;
        }
        if(ok) {
            std::cout << "YES\n";
            return;
        }
    }while(std::next_permutation(idx + 1, idx + n + 1));
    std::cout << "NO\n";
}

signed main()
{
    int t = 1;
    std::cin >> t;
    while(t --) {
        solve();
    }
    
    return 0;
}

E. 接龙数列 (已通过民间数据)

 

 这题很明显是需要DP的，正常的写法是复杂度 \small O(n^2) ，可以过前 50% 的数据点。

#include <iostream>
#include <vector>
#include <cstring>
const int N = 1e5 + 1;
int dp[N];

signed main()
{
    int n;
    std::cin >> n;
    std::vector<std::string> a(n + 1);
    for (int i = 1; i <= n; i ++) {
        std::cin >> a[i];
        dp[i] = 1;
        for (int j = 1; j < i; j ++) {
            if(a[i].front() == a[j].back()) {
                dp[i] = std::max(dp[i], dp[j] + 1);
            }
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; i ++) {
        ans = std::max(ans, dp[i]);
    }
    std::cout << n - ans;

    return 0;
}

我们可以将其优化至 O(n) 复杂度，就可以过 100% 的数据点了

#include <iostream>
#include <vector>
#include <cstring>
const int N = 1e5 + 1;
int dp[N];
int pre[11];
signed main()
{
    memset(pre, -1, sizeof(pre));
    int n;
    std::cin >> n;
    std::vector<std::string> a(n + 1);
    for (int i = 1; i <= n; i ++) {
        std::cin >> a[i];
    }
    int ans = 0;
    for (int i = 1; i <= n; i ++) {
        int x = a[i].front() - '0';
        int y = a[i].back() - '0';
        if (pre[x] != -1)
            dp[i] = dp[pre[x]] + 1;
        else
            dp[i] = 1;
        ans = std::max(ans, dp[i]);
        if (pre[y] == -1)
            pre[y] = i;
        else if(dp[i] > dp[pre[y]])
            pre[y] = i;
    }
    std::cout << n - ans;
 
    return 0;
}

F. 岛屿个数 (已通过民间数据)

 

 

 

在最外面加一圈 0 ，然后从左上角开始往 8 个方向搜索0，形成的空洞，搜索空洞数量即可。

复杂度 O(T\times n^2) .

#include <iostream>
#include <vector>
#include <string.h>
#include <queue>

const int N = 55, black = -1; //用-1代表染黑的地方
int g[N][N], g2[N][N], st[N][N];
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1}, dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
int n, m;
int cur; //记录某个岛屿的编号

void color(int I, int J)
{
    std::queue<std::pair<int,int> > q;
    q.push({I, J});
    st[I][J] = 1;
    g2[I][J] = black;
    while(q.size()) {
        int x = q.front().first, y = q.front().second;
        q.pop();
        for (int i = 0; i < 8; i ++) {
            int xx = x + dx[i], yy = y + dy[i];
            if(0 <= xx && xx <= n + 1 && 0 <= yy && yy <= m + 1 && 
                    g[xx][yy] == 0 && st[xx][yy] == 0) {
                st[xx][yy] = 1;
                g2[xx][yy] = black;
                q.push({xx, yy});
            }
        }
    }
}

void bfs(int I, int J)
{
    std::queue<std::pair<int,int> > q;
    q.push({I, J});
    st[I][J] = 1;
    g2[I][J] = cur;
    while(q.size()) {
        int x = q.front().first, y = q.front().second;
        q.pop();
        for (int i = 0; i < 4; i ++) {
            int xx = x + dx[i], yy = y + dy[i];
            if(0 <= xx && xx <= n + 1 && 0 <= yy && yy <= m + 1 && 
                    g2[xx][yy] == 0 && st[xx][yy] == 0) {
                st[xx][yy] = 1;
                g2[xx][yy] = cur;
                q.push({xx, yy});
            }
        }
    }
}

void solve()
{
    memset(g, 0, sizeof(g));
    memset(g2, 0, sizeof(g2));
    memset(st, 0, sizeof(st));
    std::cin >> n >> m;
    for (int i = 1; i <= n; i ++) {
        for (int j = 1; j <= m; j ++) {
            char x;
            std::cin >> x;
            g[i][j] = x - '0';
        }
    }
    color(0, 0);
    cur = 0;
    for (int i = 0; i <= n + 1; i ++) {
        for (int j = 0; j <= m + 1; j ++) {
            if(g2[i][j] == 0) {
                cur++;
                bfs(i, j);
            }
        }
    }
    std::cout << cur << '\n';
}

signed main()
{
    int t = 1;
    std::cin >> t;
    while(t --) {
        solve();
    }

    return 0;
}

G. 子串简写 (已通过民间数据)

 

算是一个简单的签到题，直接存储下标，然后二分就行了，复杂度 \small O(nlogn) 。

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#define int long long
 
signed main()
{
    int k;
    std::cin >> k;
    std::string s;
    std::cin >> s;
    char c1, c2;
    std::cin >> c1 >> c2;
    int n = s.size();
    std::vector<int> a1, a2;
    for (int i = 0; i < n; i ++) {
        if(s[i] == c1)
            a1.push_back(i + 1);
        if(s[i] == c2)
            a2.push_back(i + 1);
    }
    int ans = 0;
    for (size_t i = 0; i < a1.size(); i ++) {
        if(a2.size() == 0)
            continue;
        int loc = std::lower_bound(a2.begin(), a2.end(), a1[i] + k - 1) - a2.begin();
        ans += (int)a2.size() - loc;
    }
    std::cout << ans;
 
    return 0;
}

H. 整数删除 (已通过民间数据)

 

这题比赛中只写出个暴力，也就是说只能过掉前 20% 的数据。不过这题其实是会写的，只不过赛中时间不是很多，就先打了个暴力做后面的去了（

O(n^2) 解法：

#include <iostream>
#include <cstring>
#include <algorithm>
const int N = 5e5 + 1;
int a[N];

signed main()
{
    int n, k;
    std::cin >> n >> k;
    for (int i = 1; i <= n; i ++) {
        std::cin >> a[i];
    }
    for (int i = 1; i <= k; i ++) {
        int loc = std::min_element(a + 1, a + n + 1) - a;
        a[loc - 1] += a[loc];
        a[loc + 1] += a[loc];
        for (int j = loc; j < n; j ++) {
            a[j] = a[j + 1];
        }
        --n;
    }
    for (int i = 1; i <= n; i ++)
        std::cout << a[i] << ' ';

    return 0;
}

优先队列解法 O(nlogn) ：

#include "bits/stdc++.h"

using ll = long long;
std::priority_queue<std::pair<ll, int>, 
    std::vector<std::pair<ll, int>>, std::greater<std::pair<ll, int>>> q;

int main() {

    int n, k;
    std::cin >> n >> k;
    std::vector<ll> a(n);
    for (int i = 0; i < n; i++) {
        std::cin >> a[i];
    }

    for (int i = 0; i < n; i++) {
        q.push({a[i], i});
    }

    std::vector<int> pre(n), nex(n);
    std::iota(pre.begin(), pre.end(), -1);
    std::iota(nex.begin(), nex.end(), 1);

    while (q.size()) {
        auto Top = q.top();
        ll ai = Top.first;
        int i = Top.second;
        q.pop();
        if (ai != a[i]) {
            q.push({a[i], i});
            continue;
        }
        a[i] = -1;
        int Nex = nex[i];
        int Pre = pre[i];
        if (Nex < n) {
            a[Nex] += ai;
            pre[Nex] = Pre;
        }
        if (Pre >= 0) {
            a[Pre] += ai;
            nex[Pre] = Nex;
        }
        k--;
        if (k == 0) {
            break;
        }
    }

    for (int i = 0; i < n; i++) {
        if(a[i] != -1)
            std::cout << a[i] << ' ';
    }

    return 0;
}

I. 景区导游 (已通过民间数据)

 这题看似很难，其实是比较简单的算法题，需要用到 LCA 算法，比赛中我码了 40 多分钟，不过好在过了样例，没有出现 bug ，也是让我舒了一口气。

复杂度 O(n logn) .

#include <iostream>
#include <cstring>
#include <algorithm>
#define int long long
int n, k;
const int N = 1e5 + 5, M = 2e5 + 5;
int f[N][20], d[N][20];
int a[N], dep[N];
int d1[N], d2[N];
int h[N], ne[M], e[M], w[M], idx;
void add(int a, int b, int c)
{
    e[idx] = b; w[idx] = c; ne[idx] = h[a]; h[a] = idx++;
}

void dfs(int cur, int pre, int dis)
{
    dep[cur] = dep[pre] + 1;
    f[cur][0] = pre;
    d[cur][0] = dis;
    for (int i = 1; i <= std::__lg(dep[cur]); i++) {
        f[cur][i] = f[f[cur][i - 1]][i - 1];
        d[cur][i] = d[cur][i - 1] + d[f[cur][i - 1]][i - 1];
    }
    for (int i = h[cur]; i != -1; i = ne[i]) {
        int x = e[i];
        if (x == pre)
            continue;
        dfs(x, cur, w[i]);
    }
}

int lca(int u, int v)
{
    if (dep[u] < dep[v]) {
        std::swap(u, v);
    }
    int ans = 0;
    for (int i = (int) std::__lg(dep[u] - dep[v]); i >= 0; i--) {
        if (dep[f[u][i]] >= dep[v]) {
            ans += d[u][i];
            u = f[u][i];
        }
    }
    if (u == v)
        return ans;
    for (int i = (int) std::__lg(dep[u]); i >= 0; i--) {
        if (f[u][i] !=  f[v][i]) {
            ans += d[u][i];
            ans += d[v][i];
            u = f[u][i];
            v = f[v][i];
        }
    }
    return ans + d[u][0] + d[v][0];
}

signed main()
{
    memset(h, -1, sizeof(h));
    std::cin >> n >> k;
    for (int i = 1; i < n; i ++) {
        int u, v, w;
        std::cin >> u >> v >> w;
        add(u, v, w);
        add(v, u, w);
    }
    for (int i = 1; i <= k; i ++)
        std::cin >> a[i];
    dfs(1, 0, 0);
    int p1 = 0, p2 = 0;
    for (int i = 2; i <= k; i ++) {
        d1[p1++] = lca(a[i], a[i - 1]);
        if(i != 2)
            d2[p2++] = lca(a[i], a[i - 2]);
    }
    int sum = 0;
    for (int i = 0; i < p1; i++)
        sum += d1[i];
    for (int i = 1; i <= k; i ++) {
        int ans = 0;
        if(i == 1)
            ans = sum - d1[i - 1];
        else if(i == k)
            ans = sum - d1[i - 2];
        else ans = sum - d1[i - 1] - d1[i - 2];
        if(i != 1 && i != k) {
            ans += d2[i - 2];
        }
        std::cout << ans << ' ';
    }
    return 0;
}

J. 砍树 (已通过民间数据)

 

 这一题赛中已经没时间了（当时只剩20分钟了），所以就写了个 \small O(n^2) 的暴力（其实哪怕有时间也估计做不出来了）。

#include <iostream>
#include <algorithm>
const int N = 1e5 + 1;
int f[N];
std::pair<int,int> a[N], b[N];
int find(int x)
{
    if(x != f[x])
        f[x] = find(f[x]);
    return f[x];
}

signed main()
{
    int n, m;
    std::cin >> n >> m;
    
    for (int i = 1; i < n; i++) {
        int x, y;
        std::cin >> x >> y;
        a[i] = {x, y};
    }
    for (int i = 1; i <= m; i ++) {
        int x, y;
        std::cin >> x >> y;
        b[i] = {x, y};
    }

    for (int i = n - 1; i >= 1; i --) {
        for (int j = 1; j <= n; j ++)
            f[j] = j;
        for (int j = 1; j < n; j ++) {
            if(i == j)
                continue;
            int l = a[j].first, r = a[j].second;
            l = find(l), r = find(r);
            if(l != r)
                f[l] = r;
        }
        bool ok = 1;
        for (int j = 1; j <= m; j ++) {
            int l = b[j].first, r = b[j].second;
            l = find(l), r = find(r);
            if(l == r) {
                ok = 0;
                break;
            }
        }
        if(ok) {
            std::cout << i << '\n';
            return 0;
        }
    }
    std::cout << -1;

    return 0;
}

正解的话可以用 LCA + 树上差分，处理出每条树上边被 \small (a_i,b_i) 路径经过的次数，最大的被经过 m 次的边就是答案。

复杂度 O(nlogn) .

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
//#define int long long
int n, m;
const int N = 1e5 + 5, M = 2e5 + 5;
int f[N][20];
int dep[N], d[N];
int h[N], ne[M], e[M], idx;
void add(int a, int b)
{
    e[idx] = b; ne[idx] = h[a]; h[a] = idx++;
}
 
void dfs(int cur, int pre)
{
    dep[cur] = dep[pre] + 1;
    f[cur][0] = pre;
    for (int i = 1; i <= std::__lg(dep[cur]); i++) {
        f[cur][i] = f[f[cur][i - 1]][i - 1];
    }
    for (int i = h[cur]; i != -1; i = ne[i]) {
        int next = e[i];
        if (next == pre)
            continue;
        dfs(next, cur);
    }
}
 
int lca(int u, int v)
{
    if (dep[u] < dep[v])
        std::swap(u, v);
    for (int i = (int) std::__lg(dep[u] - dep[v]); i >= 0; i--) {
        if (dep[f[u][i]] >= dep[v]) {
            u = f[u][i];
        }
    }
    if (u == v)
        return u;
    for (int i = (int) std::__lg(dep[u]); i >= 0; i--) {
        if (f[u][i] !=  f[v][i]) {
            u = f[u][i];
            v = f[v][i];
        }
    }
    return f[u][0];
}

void dfs2(int cur, int pre) {
    for (int i = h[cur]; i != -1; i = ne[i]) {
        int next = e[i];
        if (next != pre) {
            dfs2(next, cur);
            d[cur] += d[next];
        }
    }
}
 
signed main()
{
    memset(h, -1, sizeof(h));
    std::cin >> n >> m;
    std::vector<std::pair<int,int> > edge(n);
    for (int i = 1; i < n; i ++) {
        std::cin >> edge[i].first >> edge[i].second;
        edge[i] = {edge[i].first, edge[i].second};
        add(edge[i].first, edge[i].second);
        add(edge[i].second, edge[i].first);
    }
    dfs(1, 0);
    for (int i = 1; i <= m; i ++) {
        int a, b;
        std::cin >> a >> b;
        int fa = lca(a, b);
        d[a]++, d[b]++;
        d[fa]--;
        d[f[fa][0]]--;
    }
    dfs2(1, 0);
    for (int i = n - 1; i >= 1; i --) {
        if(d[edge[i].first] == m && d[edge[i].second] == m) {
            std::cout << i;
            return 0;
        }
    }
    std::cout << -1;

    return 0;
}

日后有时间更新正解~

胡沛玮
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
第十一届蓝桥杯省赛第二场 I.子串分值和【简单dp】
while_you的博客
04-08 686
Link 分析 暴力的话是O(n2)O(n^2)O(n2)，考虑如何优化为O(n)O(n)O(n) 观察计算过程 发现有非常多的重复部分 令dp[i]为以第i号字符为结尾的所有值之和 则有dp[1]所对应子串有a dp[2]:b、ab dp[3]:a、ba、aba 即dp[i]对应子串为：dp[i-1]所对应所有的子串+a[i] 因计算的是不同字符数，故一字符出现后相同字符出现将不再对答案有贡献。所以对于字符a[i]，需知道其上一次出现的位置，即pre[a[i]]。那么由于a[i]的影响，本次贡献为 上
第九届蓝桥杯省赛C语言b组.zip
03-16
第九届蓝桥杯省赛C语言b组.zip
蓝桥杯每日一题：子串简写
Yonagi的博客
03-19 648
程序猿圈子里正流行一种很新的简写方法：对于一个字符串，只保留首位字符，将首位字符之间的所有字符用这部分的长度代替。例如internationalization简写成i18n，Kubernetes简写成K8s，Lanqiao简写成L5o等。下面给出题解代码, 共两个方案, 但核心思路都是一样的. 请注重思考, 不要无脑cv。先说这道题的解题方法: 二分法or双指针, 两种方案的题解我都会给出来。的下标单独用两个vector进行维护, 我们假设维护。的字符串都可以采用这种简写方法（长度小于。
子串简写(蓝桥杯）（双指针）
m0_74015873的博客
04-14 1517
程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。然后判断两者下标之间有无大于等于k，直接加上（b的个数-当前b下标（因为cnt2等于b的个数加1，所以直接减就好，不用在加1）给定一个字符串 S 和两个字符 c1 和 c2，请你计算 S 有多少个以 c1 开头c2 结尾的子串可以采用这种简写？在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法（长度小于 K 的字符串不配使用这种简写）。|S | 代表字符串 S 的长度。
子串简写(蓝桥杯2023)
weixin_73550568的博客
12-07 705
思路：使用s[i]表示前缀中给定首字母出现的次数（可以用t变量维护），遍历的同时当出现尾字母时，答案累加s[i - k + 1]。思路：把下标记录到两个数组中，如何固定其中一个数组，在另一个数组中找下标距离大于等于k的个数有多少个。
蓝桥杯2023年第十四届省赛真题-子串简写
m0_64427730的博客
05-28 147
朴素的做法解蓝桥杯2023年第十四届省赛真题-子串简写问题
第14届蓝桥杯省赛、国赛(B).pdf
06-07
第14届蓝桥杯省赛、国赛(B).pdf
2020年第十一届蓝桥杯省赛C++大学A组真题（第二场）
10-17
2020年第十一届蓝桥杯省赛 C++大学A组 试题（2020.10.17第二场） 比赛时间：2020.10.17
第十五届蓝桥杯大赛软件赛省赛C++B组题目
04-13
资源名称：第十五届蓝桥杯大赛软件赛省赛C++B组题目集 文件格式：PDF 内容概述： 本资源包含了第十五届蓝桥杯大赛软件赛省赛C++B组的全部题目。蓝桥杯大赛作为国内知名的软件编程竞赛，每年都会吸引大量的软件编程...
2021年第十二届蓝桥杯省赛大学A组题解C/C++代码
12-14
2021年第十二届蓝桥杯省赛大学A组题解C/C++代码
蓝桥杯真题 子串简写
在校大学生
01-07 730
解法：双指针或者二分，最主要的是能想到，先把出现c1字符和c2字符的下标先存起来，然后枚举c1出现的每个坐标，用双指针或者二分去找到c2中第一个符合条件的下标，因为下标存储是递增的，当前的下标符合了，后面的肯定也就符合了，就可以总数-第一个符合条件的下标。
【蓝桥杯C++】第十四届蓝桥杯大赛试题C冶炼金属、D子串简写（个人解题思路+代码）
qq_62775411的博客
04-11 779
【蓝桥杯C++】第十四届蓝桥杯大赛试题C冶炼金属、D子串简写（个人解题思路+代码）
第十四届蓝桥杯.子串简写（前缀和\后缀和）
陈进士学习的博客
05-01 1819
对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法。对于 100% 的数据，2 ≤ K ≤ |S| ≤ 5 × 105。对于 20% 的数据，2 ≤ K ≤ |S| ≤ 10000。第二行包含一个字符串 S 和两个字符c1 和c2。c1 和 c2 都是小写字母。给定一个字符串 S 和两个字符 c1 和 c2。长度小于 K 的字符串不允许使用这种简写。|S| 代表字符串S 的长度。第一行包含一个整数 K。
第十四届蓝桥杯大赛软件赛省赛C/C++ 大学 B 组
qq_52760486的博客
04-08 1525
第十四届蓝桥杯大赛软件赛省赛C/C++ 大学 B 组，试题 A: 日期统计 .本题总分：5 分 试题 B: 01 串的熵.本题总分：5 分 试题 C: 冶炼金属.本题总分：10分 试题 D: 飞机降落.本题总分：10分 试题 E: 接龙数列.本题总分：15分 试题 F: 岛屿个数.本题总分：15分 试题 G: 子串简写.本题总分：20分 试题 H: 整数删除.本题总分：20分 试题 I: 景区导游 .本题总分：25分 试题 J: 砍树 .本题总分：25分
（第十四届蓝桥真题）字串简写
AC__dream的博客
04-09 773
这个可以直接二分求解，也可以用前缀和进行优化，复杂度都是可以的。需要注意的一点是c1和c2有可能相同。，对于每一个c2出现的位置，我们都可以。这道题还是比较简单的，我们需要。
蓝桥杯参赛须知
热门推荐
风华绝代的博客
11-10 1万+
又到了一年一届的蓝桥杯比赛报名的时间，很荣幸受老师邀请于昨天早上通过腾讯会议线上给大数据专业的学弟学妹们分享蓝桥杯参赛心得，想必也会有更多初次参加蓝桥杯的同学们在寻找相关的信息。记录生活的同时我想把这份文章分享给大家，如果有这方面的疑问，欢迎评论留言。 内容主要涉及以下几个问题：比赛有哪些规则？（针对于第13界蓝桥杯，以后可能有变）需要做哪些准备？参加这个比赛有什么意义？ 比赛规则 来自于蓝桥杯官网：https://dasai.lanqiao.cn/，摘录了我认为比较重要的信息。 参赛组别 竞赛分为:C/C
第14届蓝桥杯C++B组省赛
killer的博客
04-08 2053
今年比去年难好多= =
[蓝桥杯 2020 省 A1] 超级胶水
最新发布
m0_53295313的博客
05-18 1314
小明有颗石子，按顺序摆成一排。他准备用胶水将这些石子粘在一起。每颗石子有自己的重量，如果将两颗石子粘在一起，将合并成一颗新的石子，重量是这两颗石子的重量之和。为了保证石子粘贴牢固，粘贴两颗石子所需要的胶水与两颗石子的重量乘积成正比，本题不考虑物理单位，认为所需要的胶水在数值上等于两颗石子重量的乘积。每次合并，小明只能合并位置相邻的两颗石子，并将合并出的新石子放在原来的位置。现在，小明想用最少的胶水将所有石子粘在一起，请帮助小明计算最少需要多少胶水。
第十四届蓝桥杯省赛c++
02-20
第十四届蓝桥杯省赛C++是中国著名的计算机竞赛之一，旨在选拔和培养优秀的计算机人才。比赛分为初赛和决赛两个阶段，初赛采用在线考试形式，决赛则是线下实操比赛。 在C++竞赛中，通常会涉及到以下几个方面的知识点： 1. 语法基础：包括C++的基本语法、数据类型、运算符、流控制语句等。 2. 数据结构与算法：常见的数据结构如数组、链表、栈、队列、树等，以及常见的算法如排序、查找、递归等。 3. 面向对象编程：包括类与对象、继承与多态、封装与抽象等。 4. 文件操作：涉及文件的读写操作，包括打开文件、读取文件内容、写入文件等。 5. 动态内存管理：包括new和delete操作符的使用，以及动态内存分配和释放。 6. 异常处理：了解异常的概念和处理方式，包括try-catch语句的使用。 7. STL库：熟悉STL库中常用的容器（如vector、list、map等）和算法（如排序、查找等）的使用。 参加蓝桥杯省赛C++竞赛需要对以上知识点有一定的掌握，并且需要进行大量的练习和实践，提高编程能力和解决问题的能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

胡沛玮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值