蓝桥杯提单day2【题解】

最新推荐文章于 2024-07-15 11:08:21 发布
最新推荐文章于 2024-07-15 11:08:21 发布
阅读量540 收藏
点赞数
分类专栏： ACM 文章标签： 蓝桥杯 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Galaxy_Su/article/details/130652029
版权

题单链接

蓝桥杯题单day2【题目】_奔跑的星黛露的博客-CSDN博客

题解

蓝肽子序列

链接

https://www.lanqiao.cn/problems/1030/learning/?page=1&first_category_id=1&sort=students_count&second_category_id=3&tags=%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92,%E5%9B%BD%E8%B5%9B

思路

先将字符串预处理分割为每个大写字母开头的“蓝肽” 在将其作为判断最长子序列 判断最长子序列 可以采用 动态规划(最简单高效) if S1[i] = S2[j] dp[i][j] = dp[i][j]+1; else dp[i][j] = max(dp[i-1][j] , dp[i][j-1]) 输出最大值即可。

代码

#include<bits/stdc++.h>
using namespace std;

const int N = 1000;
int dp[N][N];
string a,b;
vector<string>tmp;
vector<string>w;

int main(){
    cin >> a >> b;
    for(int i = 0, j = 0 ; i < a.size();){
        if(a[j] >= 'A' && a[j] <= 'Z'){
            j++;
            while(a[j] >= 'a' && a[j] <= 'z' && j < a.size())j++;
            tmp.push_back(a.substr(i,j - i));
            i = j;
        }
    }
    for(int i = 0, j = 0 ; i < b.size();){
        if(b[j] >= 'A' && b[j] <= 'Z'){
            j++;
            while(b[j] >= 'a' && b[j] <= 'z' && j < b.size())j++;
            w.push_back(b.substr(i,j - i));
            i = j;
        }
    }
  
    int ans = 0;
    int n = tmp.size(),m = w.size();
    for(int i = 1; i <= n ; i++){
        for(int j = 1 ; j <= m; j++){
            if(tmp[i - 1] == w[j - 1])dp[i][j] = dp[i - 1][j - 1] + 1;
            else dp[i][j] = max(dp[i - 1][j],dp[i][j - 1]);
        }
    }

    cout << dp[n][m] << endl;
    return 0;
}

能量项链

链接

https://www.luogu.com.cn/problem/P1063

思路

考虑区间DP。

定义 fij 表示将区间 [i, j] 合并的最大能量。那么我们可以有简单的转移方程：

f[i, j] = max_{i <= k <= j} {f[i, k] + f[k, j] + w[l] * w[k] * w[r]}

上述转移方程适用于一条链的转移，但是本题我们是一个环，因此我们可以使用一个常用的技巧将环拆解成两倍长度的链，所以 答案就是 max_{1 <= i  <= n} f[i, i + n - 1]

代码

#include "bits/stdc++.h"
using namespace std;
const int N=220;
int n,g[N],f[N][N];

int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>g[i];
        g[i+n]=g[i];
    }
    for(int len=3;len<=n+1;len++){
        for(int l=1;l+len-1<=2*n;l++){
            int r=l+len-1;
            for(int k=l+1;k<r;k++){
                f[l][r]=max(f[l][r],f[l][k]+f[k][r]+g[l]*g[k]*g[r]);
            }
        }
    }
    int res=0;
    for(int l=1;l<=n;l++) res=max(res,f[l][l+n]);
    cout<<res<<endl;
    return 0;
}

字串

链接

 https://www.luogu.com.cn/problem/P2679

思路

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define CaseT int CaseT; cin >> CaseT; while(CaseT--)
#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int INF = 0x3f3f3f3f;

const int MOD = 1e9 + 7;

void solve() {
    int n, m, K; string a, b; cin >> n >> m >> K >> a >> b;

    vector<vector<int>> dp(m + 1, vector<int>(K + 1));
    dp[0][0] = 1;
    vector<vector<int>> pre(m + 1, vector<int>(K + 1));
    for (int i = 1; i <= n; i++) {
        for (int j = m; j; j--) {  // 从后往前匹配a[1 ... i]和b[1 ... j]
            for (int k = K; k; k--) {
                if (a[i - 1] == b[j - 1]) 
                    pre[j][k] = (pre[j - 1][k] + dp[j - 1][k - 1]) % MOD;
                else pre[j][k] = 0;

                dp[j][k] = (dp[j][k] + pre[j][k]) % MOD;
            }
        }
    }
    cout << dp[m][K] << endl;
}

int main() {
    cin.tie(0)->sync_with_stdio(false);
    // init();
    // CaseT
    solve();
    return 0;
}

对局匹配

链接

https://www.lanqiao.cn/problems/107/learning/?page=1&first_category_id=1&sort=students_count&second_category_id=3&tags=%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92,%E5%9B%BD%E8%B5%9B

思路

进行分组dp，这里是差值只要是k就不能同时选，所以会将差值为k的划分为一组，然后每一组进行动态规划就可以了

dp[i]=max(dp[i−2]+arr[i], dp[i−1])

代码

#include<bits/stdc++.h>
using namespace std;
const int N = 100005;
int cnt[N], arr[N], dp[N];
int n, k;
 
int main() { 
    while (scanf("%d%d", &n, &k) == 2) {//输入个数n，差值k
        memset(cnt, 0, sizeof(cnt));//这里的cnt是记录每个值出现的次数
        int val, ans = 0;
        for (int i = 1; i <= n; i++) {
            scanf("%d", &val);
            cnt[val]++;
        }
        //特殊处理k=0的情况
        //处理思路是把所有的出现的元素都给ans加一
        if (k == 0) {
            for (int i = 0; i < N; i++) {
                if (cnt[i]) ans++;//计算有多少种数字
      
            }
        }
        else {
            for (int i = 0; i < k; i++) {//k个小组
                int len = 0;
                for (int j = i; j < N; j += k) {
                    arr[len++] = cnt[j];//遍历每个小组中的所有元素
                    //arr数组记录了每个元素的个数
                }
                //状态转移方程
                dp[0] = arr[0];
                for (int j = 1; j < len; j++) {
                    if (j == 1) 
                    {
                        dp[j] = max(dp[0], arr[j]);
                    }
                    else 
                    {
                        dp[j] = max(dp[j - 2] + arr[j], dp[j - 1]);
                    }
                }
                ans += dp[len - 1];//把k组的值都相加
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

货币系统

链接

https://www.luogu.com.cn/problem/P5020

思路

若两个货币系统等价，有如下性质

 1. a1,a2,...,an一定都可以被表示出来

 2. 在最优解中,b1,b2,...bm一定都是从a1,a2,...,an中选择的

 2. b1,b2,...,bm一定不能被其他bi表示出来

步骤
由于数据中不存在负数，将 a[] 数组从小到大排序

 1. 若ai能被a0~a(i-1)表示出来，则一定不选

 2. 若ai不能被能被a0~a(i-1)表示出来，则一定选

时间复杂度 O(nm)

代码

#include "bits/stdc++.h"
using namespace std;
const int maxn=25010;
typedef long long ll;
int t,n,f[maxn],a[110];

int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        memset(f,0,sizeof f);
        f[0]=1;
        for(int i=0;i<n;i++){
            scanf("%d",&a[i]);
        }
        sort(a,a+n);
        int v=a[n-1],ans=0;
        for(int i=0;i<n;i++){
            if(f[a[i]]==0)  ans++;
            for(int j=a[i];j<=v;j++){
                f[j]+=f[j-a[i]];
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

最优包含

链接

https://www.lanqiao.cn/problems/239/learning/?page=1&first_category_id=1&sort=students_count&second_category_id=3&tags=%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92,%E5%9B%BD%E8%B5%9B

思路

状态定义：f[i][j]表示第一个字符串前i个字符，第二个字符串前j个字符，第一个字符串前i个字符包含第二个字符串前j个字符的最少修改次数

初始状态：f[i][0] = 0 other f[i][j] = INF

状态转移：s1[i]==s2[j] f[i][j] = f[i - 1][j - 1]

                  s1[i] != s2[j] max(f[i - 1][j - 1] + 1, f[i - 1][j])

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1024, INF = 0x3f3f3f3f;
int f[N][N];
int main() 
{
  string s1, s2;
  cin >> s1 >> s2;
  int n = s1.size();
  int m = s2.size();
  memset(f, 0x3f, sizeof(f));
  for (int i = 0; i <= n; i++) f[i][0] = 0;
  for (int i = 1; i <= n; i++) 
  {
    for (int j = 1; j <= i && j <= m; j++) 
    {
      if (s1[i - 1] == s2[j - 1]) f[i][j] = f[i - 1][j - 1];
      else 
      {
        f[i][j] = f[i - 1][j - 1] + 1;
        if (i - 1 >= j) f[i][j] = min(f[i][j], f[i - 1][j]);
      }
    }
  }
  cout << f[n][m] << endl;
  return 0;
}

合根植物

链接https://www.lanqiao.cn/problems/110/learning/?page=1&first_category_id=1&sort=students_count&second_category_id=3&tags=%E5%B9%B6%E6%9F%A5%E9%9B%86

思路

编号为 a 的小格子和编号为 b 的小格子合根表示他们合并在了同一个集合里，把所有合并之后，若发现某一个格子的father等于格子编号，说明这是一个集合，统计一下就可以算出共有多少个合根植物。

代码

#include <bits/stdc++.h>
using namespace std;

const int N = 1e6 + 20;
int m, n, k, fa[N];

int find(int x){
  if(x == fa[x]) return x;
  return fa[x] = find(fa[x]);
}

void uni(int x, int y){
  int fx = find(x), fy = find(y);
  fa[fx] = fy;
}

int main()
{
  cin >> m >> n >> k;
  for(int i = 1; i <= m * n; i++) fa[i] = i;
  while(k--){
    int x, y;
    cin >> x >> y;
    uni(x, y);
  }
  int ans = 0;
  for(int i = 1; i <= m * n; i++){
    if(find(i) == i) ans++;
  }
  cout << ans;
  return 0;
}

Bitwise Exclusive-OR Sequence

链接

https://ac.nowcoder.com/acm/contest/24346/B?&headNav=acm

思路

种类并查集，首先可能是多个图， 对于每个图中的每一位， 取0 或者取1 都是可以确定图上的其他数字取0 或者取1 ，所以我们可以去枚举取0 或者取1 ，来取个min 得到结果。
所以这里我们用并查集， 最大数为 2的30次， 所以我们对于每一位都做一个并查集， 就是30个并查集。 f[a] 表示当前位置取1，f[a+n] 表示当前位取0，这样就可以枚举区间了。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int N = 2e5+10;
ll n, m, fa[N], sz[N];
ll a[N];

struct Node
{
	ll a, b;
	ll val;
}num[N];

ll find(ll x)
{
    if(x == fa[x]) return x;
    return fa[x] = find(fa[x]);
}

void init()
{
	for(ll i = 1; i <= n; i ++)
	{
		fa[i] = i, sz[i] = 1;
		fa[i+n] = i+n, sz[i+n] = 0;
	}
}

void uni(ll a, ll b)
{
	sz[a] += sz[b];
	fa[b] = a;
}

int main()
{
	cin >> n >> m;
	for(int i = 1; i <= m; i ++)
	{
		scanf("%lld%lld%lld", &num[i].a, &num[i].b, &num[i].val);
	}
	
	ll res = 0;
	for(int i = 0; i < 30; i ++)
	{
		init(); // 每一次做并查集都要初始化！
		for(int j = 1; j <= m; j ++)
		{
			int a1 = find(num[j].a);
			int b1 = find(num[j].b);
			
			int a2 = find(num[j].a + n);
			int b2 = find(num[j].b + n);
			
			if((num[j].val >> i) & 1 ) // 不同为1 ，一个取0一个取1
			{
				if(a1 == b1)
				{
					cout << -1 << endl;
					return 0;
				}
				if(a1 == b2) continue;
				
				uni(a1, b2);
				uni(b1, a2);
			}
			else // 相同为0， 都取1 或者都取0
			{
				if(a1 == b2)
				{
					cout << -1 << endl;
					return 0;
				}
				if(a1 == b1) continue;
				
				uni(b1, a1);
				uni(b2, a2);
			}
		}
		for(int j = 1; j <= n; j ++) // 对于每个数字计算结果
		{
			res += (ll)min(sz[find(j)], sz[find(j+n)]) * (1 << i);
			sz[find(j)] = 0;
			sz[find(j+n)] = 0;
		}
	}
	
	cout << res << endl;
	return 0;
}

奔跑的星黛露
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
蓝桥杯真题（Day2）
yingyuzhai的博客
03-19 1948
递增序列 题目描述 本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 对于一个字母矩阵，我们称矩阵中的一个递增序列是指在矩阵中找到两个字母，它们在同一行，同一列，或者在同一45度的斜线上，这两个字母从左向右看、或者从上向下看是递增的。 例如，如下矩阵中 LANN QIAO 有LN、LN、AN、AN、IO、AO、LQ、AI、NO、NO、AQ、IN、AN 等13个 递增序列。注意当两个字母是从左下到右上排列时，从左向右看和从上向下看 是不同的顺序。 对于下面...
【蓝桥杯day2】
gsggd的博客
02-27 475
题目1 题目描述 解题代码： import java.util.Scanner; import java.util.*; // 1:无需package // 2: 类名必须Main, 不可修改 public class Main { private static final Scanner in = new Scanner(System.in); // private static List<int[]> edges =new ArrayList<>.
6-4 字符串加密 (10 分)
okkkkO_O的博客
12-15 8484
本题要求实现一个函数，能对一行字符串(字符串的长度<80)加密。 加密函数采用的加密算法：如果不是英文字母，就不加密，原样显示；否则就将字母加上一个偏移值5实现加密。注意大小写英文字母分别构成一个封闭环，如字符‘w’，加密后为字符‘b’。 函数接口定义： void cryptograp(char ch[],int n); 其中给定一行英文字符串存放在数组ch[]中，n是这行字符串的实际长度。 裁判测试程序样例： #include<stdio.h> #include<st
2021蓝桥杯省赛b题解
JOKER_0_的博客
02-25 8455
无题目
第十五届蓝桥杯C++ B组题解
qq_73208522的博客
04-14 2841
A.握手问题 C.好数 D.R格式 E.宝石组合 F.数字接龙 G.爬山 H.拔河
蓝桥杯 C++ 历年真题题解
02-29
历届真题 contests 2013 年蓝桥杯 2017 年蓝桥杯 2018 年蓝桥杯 2019 年蓝桥杯 2020 年蓝桥杯 2021 年蓝桥杯 2022 年蓝桥杯 蓝桥杯 C++ 历年真题题解 历届真题 contests ...蓝桥杯 C++ 历年真题题解
蓝桥杯46道真题题解（Python实现）.zip
01-17
蓝桥杯46道真题题解（Python实现）.zip 蓝桥杯46道真题题解（Python实现）.zip 蓝桥杯46道真题题解（Python实现）.zip 蓝桥杯46道真题题解（Python实现）.zip 蓝桥杯46道真题题解（Python实现）.zip 蓝桥杯46道真题...
蓝桥杯个人整理学习题解
01-06
1. **编程语言基础**：蓝桥杯比赛通常涵盖C++、Java、Python等主流编程语言，因此题解中会涉及到这些语言的基本语法、数据类型、控制结构、函数、类与对象等内容。 2. **算法与数据结构**：这是编程竞赛的核心，...
蓝桥杯-蛇形矩阵题解.zip
01-06
蓝桥杯—蛇形矩阵题解.zip 是一个压缩文件，包含了关于蛇形矩阵问题的详细题解和代码实现。该资源旨在帮助参加蓝桥杯竞赛的选手更好地理解蛇形矩阵问题，并提供相应的解决方案和代码示例。 内容概要： 该压缩文件...
Xcode Playgrounds：探索Swift编程的交互式乐园
2401_85763803的博客
07-12 800
Playgrounds为开发者提供了一个轻量级、交互式的开发环境，你可以在这里快速尝试Swift语言的新特性，验证算法逻辑，或者仅仅是学习Swift编程。Xcode Playgrounds是一个功能丰富的交互式开发环境，它为Swift编程提供了即时反馈和无需编译的便利。无论是学习Swift语言、验证算法逻辑，还是进行快速原型开发，Playgrounds都是一个不可或缺的工具。通过本文的介绍和示例，你应该已经对Playgrounds有了深入的了解，现在就打开Xcode，开始你的Playgrounds之旅吧！
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 197
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 431
算法014：找到字符串中所有字母异位词
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 393
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 212
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 917
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 836
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
摩尔投票算法
qq_55846232的博客
07-14 459
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 305
手撕七大排序 （三）
【JavaScript 算法】哈希表：快速查找与存储
最新发布
Allen-
07-15 765
哈希表（Hash Table）是一种非常高效的数据结构，用于实现快速的查找和存储操作。通过使用哈希函数将数据映射到数组中的某个位置，哈希表能够在常数时间内完成插入、删除和查找操作。
蓝桥杯因数平方和题解
04-10
蓝桥杯因数平方和题是一道经典的数学题，要求计算一个给定正整数的所有因数的平方和。下面是一种解题思路： 1. 首先，我们可以遍历从1到给定正整数的所有数字，判断是否是该正整数的因数。 2. 如果某个数字是该正整数的因数，那么我们就将其平方加入到一个累加变量中。 3. 最后，累加变量的值就是所求的因数平方和。 下面是一个示例代码实现： ```python def factor_square_sum(n): sum = 0 for i in range(1, n+1): if n % i == 0: sum += i * i return sum # 示例调用 n = 12 result = factor_square_sum(n) print("因数平方和为:", result) ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值