2023第十四届蓝桥杯省赛

---

A.冶炼金属#

解题思路#

对于每组来说, 最大值肯定是用a/b得到, 而最小值则是用a/(b-1)+1来获取; 最终答案则是要最大值中的最小值和最小值中的最大值;

神秘代码#

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e4 + 10;
int n, m, k;
signed main() {
    cin >> n;
    int minn = 0;
    int maxn = 0x3f3f3f3f;
    for (int i = 1; i <= n; i++) {
        int a, b;
        cin >> a >> b;
        int x = a / b;
        int y = a / (b + 1) + 1;
        maxn = min(maxn, x);
        minn = max(minn, y);
    }
    cout << minn << ' ' << maxn;
    return 0;
}

---

B.飞机降落#

解题思路#

本题可以用状态压缩dp来求解, 这题我当时是直接暴力了, 状压dp还是太不熟练了; 本题主要是因为n<10; 所以可以想到用状压dp; f[i]则表示当降落情况为i时所需要的最短时间; 状态计算 f[i] = min(f[i], max(f[i-(1<<j)], t) + l); 注意如果状态计算时的max, 如果没到到达时间就得补上;

神秘代码#

#include<bits/stdc++.h>
//#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e4 + 10;
int n, m, t;
int f[N];
struct {
    int a, b, c;
}air [N];
signed main() {
    cin >> t;
    while (t--) {
        cin >> n;
        for (int i = 1; i <= n; i++) {
            int a, b, c;
            cin >> a >> b >> c;
            air[i] = { a,b,c };
        }
        memset(f, 0x3f, sizeof f);
        f[0] = 0;
        for (int i = 1; i < 1 << n; i++) {
            for (int j = 0; j < n; j++) {
                int a = air[j + 1].a, b = air[j + 1].b, c = air[j + 1].c;
                if (i >> j & 1) {
                    int x = f[i - (1 << j)];
                    if (x <= a + b) {
                        f[i] = min(f[i], max(x, a) + c);
                    }
                }
            }
        }
        if (f[(1 << n) - 1] < 0x3f3f3f3f) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    return 0;
}

---

C.接龙数列#

解题思路#

还是一个比较明显的dp问题; 状态表示 f(i,j) 表示前i个数中以j结尾的数列的最大长度; 状态计算分为选和不选两个状态; 对于当前这个数, 我们可以先把不选的最大长度算出来, 因为不选当前这个, 所以我们遍历0~9作为结尾: f[i][j] = f[i - 1][j]; 如果选择当前这个数, 那我们就得选择以这个数开头为结尾的状态, 设a为开头, b为结尾: f[i][b] = max(f[i][b], f[i - 1][a]+1)
对此我们还有一个空间优化版本, 对于上面状态计算中不选当前数的情况, 我们的操作实际上就是把前面以b结尾的状态延续到了第i个数; 比如数列中第2个数是以4结尾的, 从第3个数就断开了, 如果到了第5个数是以4开头的, 那么我们计算f[6][4]就需要用到f[5][4], 而其中f[5][4], f[4][4], f[3][4], 都需要从f[2][4]转移而来; 所以才需要做f[i][j] = f[i - 1][j]的计算; 而空间优化版我们可以把前面的i优化掉, 只保留f[j]; 这样我们的状态计算就变成了f[b] = max(f[b], f[a] + 1); 其中f[b]就是前面最后一个出现的以b结尾的数列的最大长度, 这样就省去了继承的过程

神秘代码#

//朴素版本;
#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e5 + 10;
int n, m, t;
int f[N][10];
signed main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        string s;
        cin>>s;
        int a = s.front() - '0';
        int b = s.back() - '0';
        for (int j = 0; j <= 9; j++) {
            f[i][j] = f[i - 1][j];
        }
        f[i][b] = max(f[i][b], f[i - 1][a] + 1);
    }
    int maxn = 0;
    for (int i = 0; i <= 9; i++)  maxn = max(maxn, f[n][i]);
    cout << n - maxn;
    return 0;
}

//空间优化版本
#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e5 + 10;
int n, m, t;
int f[10];
signed main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        string s;
        cin >> s;
        int a = s.front() - '0';
        int b = s.back() - '0';
        f[b] = max(f[b], f[a] + 1);
    }
    int maxn = 0;
    for (int i = 0; i <= 9; i++)  maxn = max(maxn, f[i]);
    cout << n - maxn;
    return 0;
}

---

D.岛屿个数#

解题思路#

本题的难点在于怎么判断外岛和子岛; 如果我们发现一个岛已经形成了环, 那我们就不用去看这个环内部的情况了; 对此我们需要从整个图的最外层入手, 为了防止有的岛就在边缘, 我们可以再给图增加一圈外海; 然后我们可以从外海开始进行bfs, 只要能连接到外海, 就一定不是子岛; 从第二个样例我们发现海水是8向流通, 而陆地是4向流通, 所以我们要用两个bfs来做; 如果外海在蔓延过程中遇到了岛屿, 那么就数量+1并对该岛屿进行bfs, 凡是蔓延过的岛屿或海水都要做个标记, 防止重复;

神秘代码#

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 60;
int n, m, t, idx;
int g[N][N];
bool st[N][N];
int dx[] = { 1,0,-1,0 ,1,1,-1,-1 }, dy[] = { 0,1,0,-1 ,1,-1,1,-1 };
void bfs2(int a,int b) {
    st[a][b] = true;
    for (int i = 0; i < 4; i++) {
        int x = a + dx[i], y = b + dy[i];
        if (x >= 1 && x <= n && y >= 1 && y <= m && !st[x][y] && g[x][y] == 1) {
            bfs2(x, y);
        }
    }
}
void bfs1(int a,int b) {
    st[a][b] = true;
    for (int i = 0; i < 8; i++) {
        int x = a + dx[i], y = b + dy[i];
        if (x >= 0 && x <= n + 1 && y >= 0 && y <= m + 1&&!st[x][y]) {
            if (g[x][y] == 1) {
                bfs2(x, y);
                idx++;
            }
            else bfs1(x, y);
        }
    }
}
signed main() {
    cin >> t;
    while (t--) {
        idx = 0;
        memset(st, false, sizeof st);
        memset(g,0,sizeof g);
        cin >> n >> m;
        for (int i = 1; i <= n; i++) {
            string s;
            cin >> s;
            for (int j = 0; j < s.size(); j++) {
                g[i][j + 1] = s[j] - '0';
            }
        }
        bfs1(0,0);
        cout << idx<<endl;
    }
    return 0;
}

---

E.子串简写#

解题思路#

因为字符串的长度是1e5级别, 所以我们只能线性的遍历字符串, 所以很容易想到利用双指针求解, 设子串以a开头, 以b结尾;
注意两点即可: 一是i和j之间距离要大于等于n; 二是假设i第一次到达b时, 这时发现有2个j满足要求, 此时结果为2, 当i到达第二个b时, 有1个j满足要求, 此时结果不仅要+1, 还要把之前的那2个也加上, 故结果是3; 所以我们可以开两个变量idx和res, idx表示当前一共有多少个j满足要求, 而res代表结果, 每次j走完后让res加上idx即可;

神秘代码#

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 10;
int n, m,idx,res;
int f[N];
signed main() {
    cin >> n;
    string s1, s = " ";
    cin >> s1;
    s += s1;
    char a, b;
    cin >> a >> b;
    for (int i = 1, j = 1; i < s.size(); i++) {
        if (s[i] == b) {
            while (j <= i - n + 1) {
                if (s[j] == a) idx++;
                j++;
            }
            res+=idx;
        }
    }
    cout << res;
    return 0;
}

---

F.整数删除#

解题思路#

因为要快速得到最小值, 所以可以想到用堆排序; 又因为要快速定位删除并更新其左右的值, 所以可以用双向链表进行维护; 优先队列的元素要用pair类型来储存值和位置; 当进行操作时, 难点在于怎么更新优先队列里的值; 我们发现每次操作都会让值增大, 所以当我们取堆顶的值时, 对照一下看看当前值和链表里面对应位置的值是否相同; 如果不同, 则把原值删除后把链表里的值和位置插入到优先队列里, 这样就实现了优先队列里值的更新;
注意别忘了初始化re[0]和le[n+1];

神秘代码#

#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 10;
int n, m,idx;
int le[N], re[N],e[N];
signed main() {
    priority_queue<PII, vector<PII>, greater<PII>> q;
    cin >> n >> m;
    re[0]=1,le[n+1]=n;
    for (int i = 1; i <= n; i++) {
        cin >> e[i];
        q.push({e[i],i});
        le[i] = i - 1;
        re[i] = i + 1;
    }
    while (m--) {
        auto t = q.top();
        q.pop();
        int x = t.first, y = t.second;
        if (x != e[y]) {
            m++;
            q.push({e[y],y});
            continue;
        }
        e[re[y]] += x;
        e[le[y]] += x;
        le[re[y]] = le[y];
        re[le[y]] = re[y];
        
    }
    int i = re[0];
    while (i < n + 1) {
        cout << e[i] << ' ';
        i = re[i];
    }
    return 0;
}