蓝桥杯2023真题（4）

最新推荐文章于 2024-04-01 15:35:06 发布
最新推荐文章于 2024-04-01 15:35:06 发布
阅读量554 收藏 6
点赞数 13
分类专栏： 备战蓝桥杯 文章标签： 蓝桥杯 深度优先 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62734493/article/details/136617415
版权
文章讨论了如何通过优化dfs算法和数据结构来解决与景区导游路线、树上前缀和、差分以及贪心策略相关的问题，包括最近公共祖先的计算，以及如何将边权转化为点权以提高效率。
摘要由CSDN通过智能技术生成

1.景区导游（树上前缀和、最近公共祖先）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

思路

路线：2 -> 6 -> 5 -> 1
1.一个点都不去去掉的花费记作sum
2.去掉第一个点，sum - cost[2 -> 6]
3.去掉第二个点，sum - cost[2 -> 6] - cost[6 -> 5] + cost[2 -> 5]

dfs 中的参数不是一下就想到的，而是在写的过程中，你发现需要某个信息，而这个信息没有被提前记录，所以可以把这个信息当作参数记录下来

正解就是优化 cost 的求法

暴力 dfs（O(k * n)）

#include<iostream>
#include<vector>
#include<map>
using namespace std;
const int N = 2e5 + 10;
map<pair<int, int>, int> st; // 存储两个点之间的时间
vector<pair<int, int>> g[N]; // 存储图和时间
int n, k;
int a[N];

// 起点、终点、当前节点、父节点、时间总和
bool dfs(int u, int v, int s, int fa, int sum){
    if(s == v){
        st[make_pair(u, v)] = sum;
        st[make_pair(v, u)] = sum;
        return true;
    }
    for(int i = 0; i < g[s].size(); i++){
        // 子节点
        int son = g[s][i].first, w = g[s][i].second;
        // 如果子节点等于父节点，说明重复了跳过
        if(son == fa) continue;
        // 父节点为当前节点
        if(dfs(u, v, son, s, sum + w)) return true;
    }
    return false;
}

int main(){
    scanf("%d%d", &n, &k);
    int u, v, t;
    for(int i = 0; i < n - 1; i++){
        scanf("%d%d%d", &u, &v, &t);
        g[u].push_back(make_pair(v, t));
        g[v].push_back(make_pair(u, t));
    }
    for(int i = 0; i < k; i++) scanf("%d", &a[i]);
    int ans = 0;
    for(int i = 1; i < k; i++){
        dfs(a[i - 1], a[i], a[i - 1], -1, 0);
        ans += st[make_pair(a[i - 1], a[i])];
    }
    for(int i = 0; i < k; i++){
        int res = ans;
        if(!i) res -= st[make_pair(a[i], a[i + 1])];
        else if(i == k - 1) res -= st[make_pair(a[i - 1], a[i])];
        else{
            res -= st[make_pair(a[i - 1], a[i])];
            res -= st[make_pair(a[i], a[i + 1])];
            dfs(a[i - 1], a[i + 1], a[i - 1], -1, 0);
            res += st[make_pair(a[i - 1], a[i + 1])];
        }
        printf("%d ", res);
    }
    return 0;
}

正解（O(n)）

在这里插入图片描述

#include<iostream>
#include<vector>
using namespace std;
const int N = 2e5 + 10;
typedef long long qq;
vector<pair<int, int>> e[N];
// 存储父节点，存储深度，存储重儿子，存储以当前节点为根的子树节点数，存储当前节点的重链顶点
int fa[N], dep[N], son[N], sz[N], top[N]; 
qq sum[N]; // 存储树上前缀和
int a[N];
int n, k;

// 求出 fa, dep, son, sz
void dfs1(int u, int father){
    fa[u] = father, dep[u] = dep[father] + 1, sz[u] = 1;
    for(auto v : e[u]){
        int s = v.first;
        if(s == father) continue;
        dfs1(s, u);
        sz[u] += sz[s];
        if(sz[son[u]] < sz[s]) son[u] = s;
    }
}

// 求出 top
void dfs2(int u, int t){
    // 链头
    top[u] = t;
    // 没有重儿子
    if(!son[u]) return;
    // 搜重儿子
    dfs2(son[u], t);
    for(auto v : e[u]){
        int s = v.first;
        if(s == fa[u] || s == son[u]) continue;
        // 搜轻儿子
        dfs2(s, s);
    }
}

// 求公共祖先
int lca(int u, int v){
    while(top[u] != top[v]){
        if(dep[top[u]] < dep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    return dep[u] < dep[v] ? u : v;
}

// 求树上前缀和
void cal_sum(int u){
    for(auto v : e[u]){
        int s = v.first, w = v.second;
        if(s == fa[u]) continue;
        sum[s] = sum[u] + w;
        cal_sum(s);
    }
}

int main(){
    scanf("%d%d", &n, &k);
    int u, v, t;
    for(int i = 1; i < n; i++){
        scanf("%d%d%d", &u, &v, &t);
        e[u].push_back({v, t});
        e[v].push_back({u, t});
    }
    for(int i = 1; i <= k; i++) scanf("%d", &a[i]);
    
    dfs1(1, 0);
    dfs2(1, 1);
    
    cal_sum(1);
    
    qq ans = 0;
    for(int i = 2; i <= k; i++){
        int x = a[i - 1], y = a[i];
        qq cost = sum[x] + sum[y] - 2 * sum[lca(x, y)];
        ans += cost;
    }
    
    for(int i = 1; i <= k; i++){
        qq res = ans;
        int x = a[i - 1], y = a[i], z = a[i + 1];
        if(i == 1) res -= sum[y] + sum[z] - 2 * sum[lca(y, z)];
        else if(i == k) res -= sum[x] + sum[y] - 2 * sum[lca(x, y)];
        else{
            res -= sum[x] + sum[y] - 2 * sum[lca(x, y)];
            res -= sum[y] + sum[z] - 2 * sum[lca(y, z)];
            res += sum[x] + sum[z] - 2 * sum[lca(x, z)];
        }
        printf("%lld ", res);
    }
    return 0;
}

2.砍树（树上差分、最近公共祖先）

在这里插入图片描述
在这里插入图片描述

思路

dfs 找到两个点之间的路径，然后打上标记，如果打上 m 个标记，那么就可以作为答案

正解：优化打标记的过程，边权转换为点权，每个边权为子节点的点权
第一步：给路径的起点和终点都加 1
第二步：给两个点的最近公共祖先减 2
第三步：树上差分
第四步：让每个点都加上他的子树和
点权等于这个点和他父节点相连的边权

暴力 dfs（O(n * m)）

#include<iostream>
#include<vector>
#include<map>
using namespace std;
const int N = 2e5 + 10;
map<pair<int, int>, int> id; // 存储编号
vector<int> e[N];
int w[N]; // 存储边权
int n, m;

bool dfs(int a, int b, int u, int fa){
  if(u == b) return true;
  for(int v : e[u]){
    if(v == fa) continue;
    if(dfs(a, b, v, u)){
        int t = id[{u, v}];
        w[t]++;
        return true;
    }
  }
  return false;
}

int main()
{
  scanf("%d%d", &n, &m);
  int x, y;
  for(int i = 1; i < n; i++){
    scanf("%d%d", &x, &y);
    e[x].push_back(y);
    e[y].push_back(x);
    id[{x, y}] = i;
    id[{y, x}] = i;
  }
  int a, b;
  for(int i = 0; i < m; i++){
    scanf("%d%d", &a, &b);
    dfs(a, b, a, -1);
  }
  int ans = -1;
  for(int i = n - 1; i >= 1; i--){
      if(w[i] == m){
          ans = i;
          break;
      }
  }
  printf("%d", ans);
  return 0;
}

正解（O(n)）

#include<iostream>
#include<vector>
#include<map>
using namespace std;
const int N = 2e5 + 10;
int fa[N], dep[N], son[N], sz[N], top[N];
map<pair<int, int>, int> id; // 存储编号
vector<int> e[N];
int w[N]; // 存储点权
int n, m;

void dfs1(int u, int father){
    fa[u] = father, dep[u] = dep[father] + 1, sz[u] = 1;
    for(int v : e[u]){
        if(v == father) continue;
        dfs1(v, u);
        sz[u] += sz[v];
        if(sz[son[u]] < sz[v]) son[u] = v;
    }
}

void dfs2(int u, int t){
    top[u] = t;
    if(!son[u]) return;
    dfs2(son[u], t);
    for(int v : e[u]){
        if(v == fa[u] || v == son[u]) continue;
        dfs2(v, v);
    }
}

int lca(int u, int v){
    while(top[u] != top[v]){
        if(dep[top[u]] < dep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    return dep[u] < dep[v] ? u : v;
}

void lca_sum(int u, int father){
    for(int v : e[u]){
        if(v == father) continue;
        lca_sum(v, u);
        w[u] += w[v];
    }
}

int main()
{
  scanf("%d%d", &n, &m);
  int x, y;
  for(int i = 1; i < n; i++){
    scanf("%d%d", &x, &y);
    e[x].push_back(y);
    e[y].push_back(x);
    id[{x, y}] = i;
    id[{y, x}] = i;
  }
  
  dfs1(1, 0);
  dfs2(1, 1);
  
  int a, b;
  for(int i = 0; i < m; i++){
    scanf("%d%d", &a, &b);
    // 树上差分
    w[a]++, w[b]++;
    w[lca(a, b)] -= 2;
  }
  
  lca_sum(1, 0);
  
  int ans = -1;
  for(int i = 1; i <= n; i++){
      if(w[i] == m){
          int t = id[{i, fa[i]}];
          ans = max(ans, t);
      }
  }
  printf("%d", ans);
  return 0;
}

3.三国游戏（贪心）

在这里插入图片描述
在这里插入图片描述

思路

因为事件是独立的，所以可以从大到小排序，看 a - b - c 的和最多有多少个满足大于0

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N], c[N], d[N];
int n;

int f(int a[], int b[], int c[]){
  for(int i = 1; i <= n; i++) d[i] = a[i] - b[i] - c[i];
  sort(d + 1, d + n + 1, greater<int>());
  long long sum = 0;
  for(int i = 1; i <= n; i++){
    sum += d[i];
    if(sum <= 0){
      sum = i - 1;
      break;
    }
  }
  return sum > 0 ? sum : -1;
}

int main()
{
  scanf("%d", &n);
  for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
  for(int i = 1; i <= n; i++) scanf("%d", &b[i]);
  for(int i = 1; i <= n; i++) scanf("%d", &c[i]);
  int res = max(f(a, b, c), max(f(b, a, c), f(c, a, b)));
  printf("%d", res);
  return 0;
}

4.填充（贪心）

在这里插入图片描述

思路

在这里插入图片描述

#include <iostream>
using namespace std;
int main()
{
  string s;
  cin>>s;
  int res = 0;
  for(int i = 1; i < s.size(); i++){
    if(s[i - 1] == s[i] || s[i - 1] == '?' || s[i] == '?'){
      res++;
      // 成对匹配，如果匹配成功，就跳过后面那个，到后面的后面，再匹配
      i++;
    }
  }
  cout<<res;
  return 0;
}

5.翻转（模拟）

在这里插入图片描述
在这里插入图片描述

思路

如果两边和当前位置相反，且和 t 不同，那就翻转，最后再比较 s 和 t 是否相同

#include <iostream>
using namespace std;
int main()
{
  int d;
  cin>>d;
  string t, s;
  while(d--){
    cin>>t>>s;
    int res = 0;
    for(int i = 1; i < s.size() - 1; i++){
      if(s[i] != t[i] && s[i - 1] != s[i] && s[i] != s[i + 1]){
        s[i] ^= 1;
        res++;
      }
    }
    if(s == t) cout<<res<<endl;
    else cout<<-1<<endl;
  }
  return 0;
}
dy小坚果
关注
  • 13
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2023年蓝桥杯省赛Java语言大学A组真题.doc
10-27
2023年蓝桥杯省赛Java语言大学A组真题 题目1：结果填空，满分3分 熊怪吃核桃森林里有一只熊怪，很爱吃核桃。但是它有个习惯，每次都把找到的核桃提成相等的两份，吃掉一份，留一份。假如不能等分，熊怪就会扔掉一...
蓝桥杯历年真题视频解析
03-22
"蓝桥杯历年真题视频解析"是一系列针对本科B组参赛者的教学资源，主要涵盖了C/C++编程语言，旨在帮助学生准备蓝桥杯编程竞赛。蓝桥杯比赛是一项全国性的计算机程序设计竞赛，旨在提升大学生的算法设计与编程能力，...
2023蓝桥杯真题c++省A
qq_61786525的博客
05-11 5615
比赛的时候，脑袋要清晰一点，当时写幸运数这道题都感觉没在用脑子思考，花了特别多时间。
蓝桥杯2023年-景区导游（倍增法求LCA）
qq_63128300的博客
03-12 607
某景区一共有 N 个景点，编号 1 到 N。景点之间共有 N − 1 条双向的摆渡车线路相连，形成一棵树状结构。在景点之间往返只能通过这些摆渡车进行，需要花费一定的时间。小明是这个景区的资深导游，他每天都要按固定顺序带客人游览其中 K 个景点：A1, A2, . . . , AK。今天由于时间原因，小明决定跳过其中一个景点，只带游客按顺序游览其中 K − 1 个景点。
蓝桥杯2023年第十四届省赛真题-岛屿个数
无聊人的博客
03-11 244
在岛屿 A 所占据的格子中，如果可以从中选出 k 个不同的格子，使得他们的坐标能够组成一个这样的排列：(x0, y0),(x1, y1), . . . ,(xk−1, yk−1)，其中(x(i+1)%k , y(i+1)%k) 是由 (xi , yi) 通过上/下/左/右移动一次得来的 (0 ≤ i ≤ k − 1)，如果另一个岛屿 B 所占据的格子全部位于这个 “环” 内部，此时我们将岛屿 B 视作是岛屿 A 的子岛屿。若 B 是 A 的子岛屿，C 又是 B 的子岛屿，那 C 也是 A 的子岛屿。
蓝桥杯23年第十四届省赛真题-填充|DFS，贪心
qq_61814350的博客
03-28 981
1.填充 - 蓝桥云课 (lanqiao.cn)蓝桥杯2023年第十四届省赛真题-填充 - C语言网 (dotcpp.com)dfs就不再多说了，对于每个?都有0和1两个分支，数据范围是：那么有m个 ?，时间复杂度就是 O()，会超时。蓝桥杯官网可以过35%的数据，暴力先拿到一部分再说。这里需要注意的是：对于？的字符的每层，最后要把它复原，恢复为?。 贪心：当前能组成一个合法子串的时候我就组合起来，因为如果我放弃这个组合，我最多让后面一个字符和它后面的字符组成一个合法子串，而浪费了我当前这个字符，组合更
蓝桥杯2023年第十四届省赛真题
weixin_63544745的博客
02-16 539
十四届蓝桥杯省赛真题B组-子串简写
Scratch蓝桥杯国赛真题开启电脑 Scratch第十二届蓝桥杯国赛真题答案解析
01-20
Scratch蓝桥杯国赛真题开启电脑 Scratch第十二届蓝桥杯国赛真题答案解析 详细案例讲解可以查看对应博客：https://blog.csdn.net/frank2102/article/details/122577722
蓝桥杯历年真题（PDF）
12-03
4. "蓝桥杯单片机第五届省赛试题（第六届模拟题）-简易温度采集与控制装置.pdf"：这可能涉及到温度传感器的使用、数据处理和反馈控制，参赛者需设计一个可以实时监控并调整温度的系统。 5. "蓝桥杯单片机第九届初赛...
2024年蓝桥杯嵌入式真题
最新发布
04-13
2024年蓝桥杯嵌入式真题
蓝桥杯2023年第十四届省赛真题-接龙数列
m0_73754615的博客
07-20 1950
12, 23, 34, 56 不是接龙数列，因为 56的首位数字不等于 34 的末位数字。对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。现在给定一个长度为 N 的数列 A1, A2, . . . , AN，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？解题思路：逆向思维求删除最少的个数使其成为接龙序列，转换成序列的长度减去最长的接龙序列，这道题我用的是动态规划，
第十三届蓝桥杯JavaA组省赛真题 - 蜂巢
qq_61504864的博客
04-01 226
2.并且在Java中，static变量不能在方法内部声明，它们必须作为类的成员变量声明。1.静态方法只能访问静态变量。
2023年第十四届蓝桥杯省赛Java C组题解
qq_45910820的博客
04-12 5448
只做出来(ACDFGH)，挑几个出来，答案不一定正确，但自己测试通过了。
蓝桥杯2023年第十四届省赛真题-更小的数, 关于推荐题解的易错点
weixin_68629353的博客
02-18 424
我是看了题解自己再写的，但是由于自己的功力不深，还是出现了错误，例如。2.第二个循环，即右下标不要写r>1,要写>l,即大于左下标。1.判断函数最后要加上return 0;初入蓝桥杯，功力不够，还请大佬给些建议。这个网站的题解第一篇写的非常好。3.左下标是可以取到n-2的。
蓝桥杯2023年第十四届省赛真题-平方差|打表、数学
qq_61814350的博客
03-24 911
对于这道题，一个不错的题解，证明的很清楚：完整的请看该题解区的第二条。再加上的证明：用反证法：需要证明的就是x-y=m时，m为偶数的情况，上面的证明可以证明4的倍数是合法的，但不能证明2的倍数不合法。任意一个每个周期第二个数可以写成4n+2（n=0,1,2.....），假设它合法，（2*x-m）*m=4n+2，解得：n=((2*x-m)*m)/4-2/4，很明显((2*x-m)*m)/4是个整数，减去1/2，是一个分数，与n为整数的前提矛盾。证明完毕。
2023年第十四届蓝桥杯JavaB组省赛真题及解析
热门推荐
Narnat的博客
05-14 2万+
本次比赛我只能说真是技不如人，本以为精通暴力算法就能狠狠拿下蓝桥杯的我，真的是被狠狠军训了😭。虽然最后也是拿了二等安慰奖，但是内心根本没有多开心，因为自己这几个月学的算法，几乎没有在本次比赛发挥作用，而且一直处于被题目吊打的局面。但这不能说明刷题没用，只能说我的水平还有待提高。重心态，重思维。想想也是如果单纯以算法衡量能否在蓝桥杯取得好成绩是不妥当的。毕竟大一，大二乃至大三都可以参加，单纯以刷题就能取得好成绩的话，对大一刚接触编程的新生来说太不利了，所以侧重思维就相对来说更公平。
蓝桥杯真题之23.利息计算
2301_80300263的博客
02-19 223
【代码】蓝桥杯真题之23.利息计算。
蓝桥杯2023年真题（1）
qq_62734493的博客
02-11 1218
格式：⾃然数，值位数，值。
2023蓝桥杯c/c++省赛B组题目(最全版)：
m0_74542701的博客
04-08 2万+
蓝桥杯的c/c++省赛题目（全网最全）
蓝桥杯python真题2023
07-27
抱歉，我无法回答关于蓝桥杯python真题2023的问题。我只能根据提供的引用内容回答相关问题。如果您有其他问题，我会尽力帮助您解答。 #### 引用[.reference_title] - *1* [第十四届蓝桥杯青少组省赛Python真题（2023...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值