蓝桥2023省赛B 题解

快雪_时晴

已于 2024-03-22 15:25:35 修改

阅读量1.2k

点赞数 43

文章标签：算法图论数据结构

于 2024-03-22 13:27:29 首次发布

本文链接：https://blog.csdn.net/2301_81633148/article/details/136938268

版权

蓝桥2023省赛B 题解

T1 冶炼金属

题目描述

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

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

现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立

的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。

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

输入格式

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

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

输出格式

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

数据范围

对于 30% 的评测用例，1 ≤ N ≤ 10^2。

对于 60% 的评测用例，1 ≤ N ≤ 10^3。

对于 100% 的评测用例，1 ≤ N ≤ 10^4，1 ≤ B ≤ A ≤ 10^9。

思路

数学思路题，对于一组给定的整数A,B可以知道
$V_{实} = a/b \newline V_{min} = \lceil V_{实} \rceil \newline V_{max} = \lfloor V_{实} \rfloor$
其中涉及到结果的取整运算

Vmax(数字最大，转换率最低）：可以直接由a/b取得（c++整数运算结果自动向下取整）

Vmin(转换率越高，数字v越小)：考虑到如果转换率最高的应该接近能得到b+1个，

用a/(b + 1) + 1表示a/(b + 1) 向上取整

注意比较时的下标别混

贴ACcode

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
    int n;
    int a,b,ansl = 0,ansr = 1000001;
    cin >> n;
    for(int i = 1;i <= n;i ++){
        cin >> a >> b;
        int resl = a / (b + 1) + 1,resr = a / b;
        ansl = max(ansl,resl);
        ansr = min(ansr,resr);
    }
    cout << ansl << " " << ansr;
}

T2 飞机降落

题目描述

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

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

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

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

输入格式

输入包含多组数据。

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

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

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

输出格式

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

数据范围

对于 30% 的数据，N ≤ 2。

对于 100% 的数据，1 ≤ T ≤ 10，1 ≤ N ≤ 10，0 ≤ Ti , Di , Li ≤ 10^5。

思路

考虑n<=10，是可以接受(n!) 约等于340w的复杂度的

理论上可以枚举n然后纯枚举排序暴力？（笑

dfs直接爆搜

贴AC code

#include <cstdio>
#include <iostream>
#include <algorithm>
#define Maxn 11
using namespace std;
int n,flag;
int t[Maxn],d[Maxn],l[Maxn];
int vis[Maxn];
int cnt[Maxn];
void Dfs(int step,int fa){
    if(flag) return;
    if(step == n){
        flag = 1;
        return;
        
    }
    for(int i = 1;i <= n;i ++){
        if(vis[i]) continue;
        vis[i] = 1;
        if(fa <= t[i]) Dfs(step + 1,t[i] + l[i]);
        else if(fa <= t[i] + d[i]) Dfs(step + 1,fa + l[i]);
        vis[i] = 0;
    }
}
int main(){
    int T;
    cin >> T;
    while(T --){
        cin >> n;
        for(int i = 1;i <= n;i ++)
            cin >> t[i] >> d[i] >> l[i],vis[i] = 0;
        flag = 0;
        Dfs(0,0);
        if(flag) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    return 0;
}

确实是个朴素爆搜，看到n范围就别犹豫了直接战斗爽

T3 接龙数列

题目描述

对于一个长度为 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。

数据范围

对于 20% 的数据，1 ≤ N ≤ 20。

对于 50% 的数据，1 ≤ N ≤ 10000。

对于 100% 的数据，1 ≤ N ≤ 105，1 ≤ Ai ≤ 109。所有 Ai 保证不包含前导 0。

思路

线性dp。先设计状态

维度有两个，当前下标i,末位数字j

则有：
$f [i] [j] ：前 i 个数字希望得到尾数为 j 的合法方案最少删除 f [i] [j] 个数$
这样就寄了。

卡了10min发现状态转移方程不好写代码也是依托

重新看看问题，事实上是在问，最长的接龙序列的长度，最后用n减去即为答案。

则有：
$f [i] [j] ：前 i 个数字希望得到尾数为 j 的最长接龙数列长度$
这个好写很多，状态转移方程：

a[i]的头a[i - 1]尾j:
$f [i] [t] = ma x (f [i] [t], f [i - 1] [j] + 1)$
其中t 是a[i]尾
a[i]的头!=a[i - 1]尾：
$f [i] [t] = ma x (f [i] [t], f [i - 1] [t])$

可以发现，这个i没什么用处，可以压掉，只用尾数这个维度就可以做了

AC code：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define MAXN 100001
using namespace std;
int f[11];
int u[MAXN],v[MAXN];
int n;
int main(){
    cin >> n;
    for(int i = 1;i <= n;i ++){
        string s;cin >> s;
        u[i] = s[0] - '0',v[i] = s.back() - '0';
    }//这个参考了一个题解写法，感觉比直接数字运算处理优美很多
    for(int i = 1;i <= n;i ++)
        f[v[i]] = max(f[v[i]],f[u[i]] + 1);
    int ans = 0;
    for(int i = 0;i <= 9;i ++)
        ans = max(ans,f[i]);
    cout << n - ans;
}

T4 岛屿个数

题目描述

小蓝得到了一副大小为 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’。

输出格式

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

思路

两次DFS+染色

同样思路写过了，哪天想写再贴code

T5 子串简写

题目描述

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

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

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

输入格式

第一行包含一个整数 K。

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

输出格式

一个整数代表答案。

数据范围

对于 20% 的数据，2 ≤ K ≤ |S | ≤ 10000。

对于 100% 的数据，2 ≤ K ≤ |S | ≤ 5 × 105。S 只包含小写字母。c1 和 c2 都是小写字母。

|S | 代表字符串 S 的长度。

思路

感觉最没思考量的题，甚至不如T1，前缀和秒了

AC code

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define MAXN 500001
using namespace std;
int sum[MAXN];
char s[MAXN],c1,c2;
long long ans = 0;
int main(){
    int k,n;
    cin >> k >> s;
    cin >> c1 >> c2;
    n = strlen(s);
    for(int i = 0;i < n;i ++)
        sum[i + 1] = sum[i] + (s[i] == c2);
    for(int i = 1;i <= n - k + 1;i ++)
        if(s[i - 1] == c1) ans += (sum[n] - sum[i + k - 2]);
    cout << ans;
}

T6 整数删除：

题目描述

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

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

输入格式

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

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

输出格式

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

数据范围

对于 20% 的数据，1 ≤ K < N ≤ 10000。

对于 100% 的数据，1 ≤ K < N ≤ 5 × 10^5，0 ≤ Ai ≤ 10^8。

思路

STL大法好！

看起来简单但是抠细节的题目，10min写完调了快30min。。。。。

每次操作需要在一个比较短的时间里找到最小值，而且因为每次操作有影响到前后导致大小关系的变化，不能直接sort。考虑用优先队列维护单调性。

先贴AC code：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>
#define MAXN 11
using namespace std;
struct Node{
    int index,left_index,right_index;
    long long num;
    bool operator < (const Node &x) const{
        if(num == x.num) return index > x.index;
        return num > x.num;
    }
};
Node a[MAXN];
priority_queue <Node> q;
int n,k;
void add(Node t){
    int x = t.index;
    if(t.num != a[x].num)
        return;
    int l = a[x].left_index,r = a[x].right_index;
    a[l].right_index = r,a[r].left_index = l;
    a[l].num += a[x].num;
    a[r].num += a[x].num;
    a[x].num = 0;
    if(l != 0) q.push(a[l]);
    if(r != n + 1) q.push(a[r]);
    k --;
    return;
}
int main(){
    cin >> n >> k;
    for(int i = 1;i <= n;i ++){
        cin >> a[i].num;
        a[i].index = i;
        a[i].left_index = i - 1;
        a[i].right_index = i + 1;
        q.push(a[i]);
    }
    while(k){
        Node x = q.top();
        q.pop();
        add(x);
    }
    for(int i = 1;i <= n;i ++)
        if(a[i].num) cout << a[i].num << " ";
}

一些细节：

题面有提到：每次选择数列中最小的整数（如果最小值不止一个，选择最靠前的）

因此在重载运算符时注意细节：
```
bool operator < (const Node &x) const{
        if(num == x.num) return index > x.index;
        return num > x.num;
    }
```
先判断是否数值相等，如果是直接比较序号，再比较数字大小

2.用index,leftindex,rightindex维护原序列的左右关系

3.每次从队头取出新数字操作时要先判断是否是修改过的，如果这个队头的数值(num)和下标对应原数组的数值(a[x].num)不同直接return；相应的，每次操作完要直接把修改过的数（Node a[l] a[r])加入队列，这样实际的操作次数应该是在确认完成一整次操作再计算（入队出队的实际次数应该是远大于k的）

4.扣了很久的细节，注意边界0和n+1，他们只是边界，不能加入运算

T7 景区导游

题目描述

某景区一共有 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 之后，花费在摆渡车上的时间。

思路

LCA板子题

贴ACcode：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#define MAXN 8
using namespace std;
struct Edge{
    int to,val;
}edge;
int n,m;
int lg[MAXN];
int fa[MAXN][20],dep[MAXN];
int a[MAXN];
long long sum[MAXN];
long long V_1[MAXN],V_2[MAXN];
long long ans = 0;
vector <Edge> son[MAXN];
void Dfs(int now,int fath,int w){
    fa[now][0] = fath;
    dep[now] = dep[fath] + 1;
    sum[now] = sum[fath] + w;
    for(int i = 1;i <= lg[dep[now]];i ++)
        fa[now][i] = fa[fa[now][i - 1]][i - 1];
    for(auto &i : son[now])
        if(i.to != fath) Dfs(i.to,now,i.val);
}
int LCA(int x,int y){ // x > y
    if(dep[x] < dep[y]) swap(x,y);
    while(dep[x] > dep[y])
        x = fa[x][lg[dep[x] - dep[y]] - 1];
    if(x == y) return x;
    for(int i = lg[dep[x]];i >= 0;i --)
        if(fa[x][i] != fa[y][i])
            x = fa[x][i],y = fa[y][i];
    return fa[x][0];
}
long long V(int x,int y){
    return sum[x] + sum[y] - (sum[LCA(x,y)] << 1);
}
int main(){
    for(int i = 1;i <= MAXN;i ++)
        lg[i] = lg[i - 1] + (1 << lg[i-1] == i);
    int n,k;
    cin >> n >> k;
    for(int i = 1;i < n;i ++){
        int u,v;
        scanf("%d %d %d",&u,&v,&edge.val);
        edge.to = v;
        son[u].push_back(edge);
        edge.to = u;
        son[v].push_back(edge);
    }
    Dfs(1,0,0);
    for(int i = 1;i <= k;i ++)
        scanf("%d",&a[i]);
    for(int i = 1;i < k - 1;i ++){
        V_1[i] = V(a[i],a[i + 1]);
        V_2[i] = V(a[i],a[i + 2]);
        ans += V_1[i];
    }
    V_1[k - 1] = V(a[k - 1],a[k]);
    ans += V_1[k - 1];
    for(int i = 1;i <= k;i ++)
        printf("%d\n",ans - V_1[i - 1] - V_1[i] + V_2[i - 1]);
}

本来写的cin cout 86分t了，这题常数确实比较大，还是老实一点好

T8 砍树

题目描述

给定一棵由 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。

输出格式

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

数据范围

对于 30% 的数据，保证 1 < n ≤ 1000。

对于 100% 的数据，保证 1 < n ≤ 10^5，1 ≤ m ≤ 2/n。

思路

T7T8都是LCA就挺难蚌，但是这题还是含金量高一点的（笑，我的倍增LCA熟练度甚至不如树剖

题目意思是需要找到给定所有简单路径的共同边，用一个类似染色的方法，每条简单路径都把所有边权+1，只要有边权为m即可，我在代码里写法类似点权，因为可以自定树根，方向是确定的，没什么影响，同时n<=10^5纯暴力应该是拿不到很满的分，树上差分优化一下即可。

贴AC code

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#define MAXN 100001
using namespace std;
struct Edge{
    int index,to;
};
vector <Edge> son[MAXN];
int fa[MAXN][21];
int w[MAXN],dep[MAXN];
int lg[MAXN];
int n,m,ans = 0;
void LCA_DFS(int now,int fath){
    fa[now][0] = fath,dep[now] = dep[fath] + 1;
    for(int i = 1;i <= lg[dep[now]];i ++)
        fa[now][i] = fa[fa[now][i - 1]][i - 1];
    for(auto &i : son[now])
        if(i.to != fath) LCA_DFS(i.to,now);
    return;
}
int LCA(int x,int y){
    if(dep[x] < dep[y]) swap(x,y);
    while(dep[x] > dep[y])
        x = fa[x][lg[dep[x] - dep[y]] - 1];
    if(x == y) return x;
    for(int i = lg[dep[x]];i > 0;i --)
        if(fa[x][i] != fa[y][i]) x = fa[x][i],y = fa[y][i];
    return fa[x][0];
}
void modify(int a,int b){
    w[a] ++;
    w[b] ++;
    w[LCA(a,b)] -= 2;
}
void Dfs(int now,int fath){
    for(auto &i : son[now])
        if(i.to != fath){
            Dfs(i.to,now);
            w[now] += w[i.to];
            if(w[i.to] == m && i.index > ans) ans = i.index;
    }
}
int main(){
    cin >> n >> m;
    for(int i = 1;i <= n;i ++)
        lg[i] = lg[i - 1] + (1 << lg[i-1] == i);
    for(int i = 1;i < n;i ++){
        Edge x;
        x.index = i;
        int u,v;
        scanf("%d %d",&u,&v);
        x.to = v,son[u].push_back(x);
        x.to = u,son[v].push_back(x);
    }
    LCA_DFS(1,0);
    for(int i = 1;i <= m;i ++){
        int a,b;
        scanf("%d %d",&a,&b);
        modify(a,b);
    }
    Dfs(1,0);
    cout << ans;
}

快雪_时晴

关注

43
点赞
踩
42

收藏

觉得还不错? 一键收藏
0
评论
蓝桥2023省赛B 题解

小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。
复制链接

扫一扫