蓝桥补题 2024-4-9

已于 2024-04-10 21:00:06 修改
阅读量237 收藏 3
点赞数 5
文章标签： 算法
于 2024-04-09 23:11:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ychhaha/article/details/137571214
版权
本文讨论了几种编程代码中出现的错误，涉及字符串处理、数组操作、数据结构如优先队列的使用，以及动态规划在最短路径问题中的应用。作者分享了错误的原因，如理解偏差和优化方法选择不当，强调了学习和理解算法的重要性。
摘要由CSDN通过智能技术生成

子串分值
错误理由：哈哈哈，错得很尴尬。先用暴力写了一发，后来发现可以用字母的位置来写，复杂度会小一点，但是推导样例的时候没有想到乘法的情况。哈哈哈哈哈，***。

#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=1e3+100;
const int M=3000;
#define int long long
typedef long long ll;
typedef pair<ll,ll> PLL;

string str;
priority_queue<ll,vector<ll>,greater<ll>> q[30];
set<ll> save;

signed main (void)
{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
    cin>>str;
    ll len=str.size();
    str=" "+str;
    ll ans=0;
    for(int i=1;i<=len;i++)
    {
        save.insert(str[i]-'a');
        q[str[i]-'a'].push(i);
    }
    for(auto T_T:save)
    {
        ans+=q[T_T].size();
        ll first=q[T_T].top();
        q[T_T].pop();
        ans+=first-1;
        ll last_add=first-1;
        while(q[T_T].size())
        {
            ll next=q[T_T].top();
            q[T_T].pop();
            ans+=(next-first-1)*2;
            ans+=last_add*(next-first-1);
            last_add=next-first-1;
//            cout<<last_add<<" ha "<<endl;
            first=next;
        }
//        cout<<last_add<<" ha "<<endl;
        ans+=(len-first)*last_add;
        ans+=len-first;
//        cout<<ans<<endl;
    }
    cout<<ans<<endl;
    return 0;
}

整数拼接
错误理由：哈哈哈，错得更尴尬了。最开始直接把a[i]取模了，最后前面数字乘上十的倍数那里就算错了。***。

#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=1e5+100;
const int M=3000;
#define int long long
typedef long long ll;
typedef pair<ll,ll> PLL;

ll n,m;
ll a[N];
map<ll,map<ll,ll>> q;
// 将每一个数字作为右边瞧一瞧 看看有没有余数相同的
ll ans;
ll ten[15];

signed main (void)
{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
    cin>>n>>m;
    ten[0]=1;
    for(int i=1;i<=10;i++)
        ten[i]=(ten[i-1]*10)%m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        for(int j=1;j<=10;j++)
        {
            q[j][(a[i]*ten[j])%m]++;
        }
    }

    for(int i=1;i<=n;i++)
    {
        ll len= to_string(a[i]).size();
        ans+=q[len][(m-(a[i]%m))%m];
        if(((a[i]%m)*ten[len])%m==(m-(a[i])%m)%m)
            ans--;
    }
    cout<<ans<<endl;
    return 0;
}

画中漂流
错误理由：首先最开始题意理解没错，一秒钟就是可以消耗一点体力或者不消耗，那么要想最后体力不剩余，m<=t,但是题目并没有保证，我慌了。于是开始编造每一秒钟可以消耗不止一点体力。猜测是dp，但是没有想出来，就dfs写了一发… 哈哈哈，愚蠢的人类

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

typedef long long ll;
#define int long long
const int P=131;
const int N=3100;
const int MOD=1e9+7;

// 每秒只能够消耗一点体力 或者不消耗体力....
// 又读错题意了
// 当时是想不通 那么既然一秒只能够消耗一点体力 那么体力值m一定是小于等于t才是有解的咯

ll d,t,m;
ll f[N][N];
// 在第i秒使用j点体力的方案数是多少

signed main (void)
{
    cin>>d>>t>>m;
    f[0][0]=1;
    for(int i=1;i<=t;i++)
    {
        for(int j=min(i,m);j>=0;j--)
        {
            // i-j是不使用体力掉下去的情况
            // j是上升的情况
            // 如果掉下去的减去上升的大于等于的话 那么就是掉下悬崖了
            if((i-j)-j>=d)
                break;// 那么此时此刻的方案数就是为零的
            // 如果能使用体力的话
            if(j)
                f[i][j]+=f[i-1][j-1];
            // 如果能够往下掉的话
            if((i-1-j)-j<d-1)
                f[i][j]+=f[i-1][j];
            f[i][j]%=MOD;
        }
    }
    cout<<f[t][m]<<endl;
    return 0;
}

最优包含
错误理由：数组开打了，MLE… 耻辱。虽然初始化的时候也错了，只初始化了f[0][0]的情况… 哈哈哈

#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=1e3+100;
const int M=3000;
#define int long long
typedef long long ll;
typedef pair<ll,ll> PLL;
const int MOD=1000000007;

string str1,str2;
ll f[N][N];// 现在在第i个字符 已经有j个字符相等 需要的最小操作是多少




signed main (void)
{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
    memset(f,0x3f,sizeof f);
    cin>>str1>>str2;
    ll len1=str1.size();
    ll len2=str2.size();
    str1=" "+str1,str2=" "+str2;
    for(int i=0;i<=len1;i++)
        f[i][0]=0;
    for(int i=1;i<=len1;i++)
    {
        for(int j=i;j>=1;j--)
        {
            f[i][j]=f[i-1][j];
            if(str1[i]==str2[j])
                f[i][j]=min(f[i][j],f[i-1][j-1]);
            else
                f[i][j]=min(f[i][j],f[i-1][j-1]+1);
        }
    }
    cout<<f[len1][len2]<<endl;
    return 0;
}

网络分析
错误理由：不是很懂优化的方法，就纯暴力写了。赛后听说是启发式合并，"装模做样"地写了一发，竟然过了，哈哈哈哈，还是得多学点算法。

#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=1e4+100;
//#define int long long
typedef int ll;
typedef pair<ll,ll> PLL;
const int MOD=1000000007;

ll n,m;
vector<ll> save[N];
ll ans[N];
ll f[N];


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



signed main (void)
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        f[i]=i,save[i].push_back(i);
    for(int i=1;i<=m;i++)
    {
        ll x,y,z;   cin>>x>>y>>z;
        if(x==1) {
            if(find(y)== find(z))
                continue;
            if(save[find(y)].size()<save[find(z)].size())
            {
                for(auto T_T:save[find(z)])
                    save[find(y)].push_back(T_T);
                f[find(z)]= find(y);
            }
            else
            {
                for(auto T_T:save[find(y)])
                    save[find(z)].push_back(T_T);
                f[find(y)]= find(z);
            }
        }
        else {
            for(auto T_T:save[find(y)])
                ans[T_T]+=z;
//            cout<<endl;
        }
    }
    for(int i=1;i<=n;i++)
        cout<<ans[i]<<" ";
    return 0;
}

限高杆
错误的理由：题意理解错了，以为只是恢复一条边，结果“两段道路”，哈哈哈哈。暴力写了一发。正解是分层图最短路，去好好学一学。

#include <iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=1e5+100;
#define int long long
typedef long long ll;
typedef pair<ll,ll> PLL;

struct Point{
    ll x,y,z;
};

ll n,m;
vector<PLL> Edge[N];
vector<Point> q;
ll dist[N];
bool Vis[N];


void dijkstra(){
    memset(dist,0x3f,sizeof dist);
    memset(Vis, false,sizeof Vis);
    dist[0]=0;
    dist[0+n]=0;
    dist[0+2*n]=0;
    priority_queue<PLL,vector<PLL>,greater<PLL>> q;
    q.push({0,0});
    q.push({0,0+n});
    q.push({0,0+n*2});
    while(q.size())
    {
        PLL T_T=q.top();
        q.pop();
        if(Vis[T_T.second])
            continue;
        Vis[T_T.second]=true;
        for(PLL j:Edge[T_T.second])
        {
            if(Vis[j.first])
                continue;
            if(dist[j.first]>T_T.first+j.second)
                dist[j.first]=T_T.first+j.second,q.push({dist[j.first],j.first});
        }
    }
}


signed main (void)
{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        ll x,y,z;  cin>>x>>y>>z;
        x--,y--;
        ll k;  cin>>k;
        // 建一个两层的图
        if(k==1){
            Edge[y].push_back({x+n,z});
            Edge[y+n].push_back({x+n*2,z});
            Edge[x].push_back({y+n,z});
            Edge[x+n].push_back({y+n*2,z});
        }
        else{
            Edge[y].push_back({x,z}), Edge[x].push_back({y,z});
            Edge[y+n].push_back({x+n ,z}), Edge[x+n].push_back({y+n,z});
            Edge[y+2*n].push_back({x+n*2,z}), Edge[x+2*n].push_back({y+2*n,z});
        }
    }
    dijkstra();
    cout<<dist[n-1]-dist[n-1+2*n]<<endl;
    return 0;
}

分层图最短路例题二

#include <iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=5e5+100;
#define int long long
typedef long long ll;
typedef pair<ll,ll> PLL;



ll n,m,k;
ll st,ed;
vector<PLL> Edge[N];
ll dist[N];
bool Vis[N];
ll ans=1e18;

void dijkstra(){
    memset(dist,0x3f,sizeof dist);
    memset(Vis, false,sizeof Vis);
    priority_queue<PLL,vector<PLL>,greater<PLL>> q;
    for(int i=0;i<=k;i++)
    {
        dist[st+i*n]=0;
        q.push({0,st+i*n});
    }

    while(q.size())
    {
        PLL T_T=q.top();
        q.pop();
        if(Vis[T_T.second])
            continue;
        Vis[T_T.second]=true;
        for(PLL j:Edge[T_T.second])
        {
            if(Vis[j.first])
                continue;
            if(dist[j.first]>T_T.first+j.second)
                dist[j.first]=T_T.first+j.second,q.push({dist[j.first],j.first});
        }
    }
    for(int i=0;i<=k;i++)
        ans=min(ans,dist[ed+i*n]);
}


signed main (void)
{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
    cin>>n>>m>>k;
    cin>>st>>ed;
    for(int i=1;i<=m;i++)
    {
        ll x,y,z;  cin>>x>>y>>z;
        // 建一个k层的图
        for(int j=0;j<=k;j++)
        {
            // 同一层 还有向下传递的
            Edge[y+n*j].push_back({x+n*j,z});
            Edge[x+n*j].push_back({y+n*j,z});
            if(j){
//                cout<<"ahah\n";
                Edge[y+n*(j-1)].push_back({x+n*j,0});
                Edge[x+n*(j-1)].push_back({y+n*j,0});
            }

        }
    }
    dijkstra();
    cout<<ans<<endl;
    return 0;
}

分层图例题二

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N = 510000,INF = 0x3f3f3f3f;	
typedef pair<int,int> PII;

int e[N],ne[N],w[N],h[N],idx;
int n,m,s,t,dis[N];
bool vis[N];
priority_queue<PII,vector<PII>,greater<PII> > q;	

void add(int a,int b,int c)	
{
	e[idx] = b;
	ne[idx] = h[a];
	w[idx] = c;
	h[a] = idx++;
}

void dijkstra(int s)	
{
	memset(dis,INF,sizeof dis);
	dis[s] = 0;
	q.push({0,s});

	while(!q.empty())
	{
		int u = q.top().second;
		q.pop();
		if(vis[u])
			continue;
		vis[u] = 1;
		for(int i = h[u]; ~i;i = ne[i])
		{
			int v = e[i];
			if(dis[v] > dis[u]+w[i])
			{
				dis[v] = dis[u]+w[i];
				q.push({dis[v],v});
			}
		}
	}
}

int main()
{
	int price,ad,num,pre,cur;
	cin >> n >> m >> s >> t;
	memset(h,-1,sizeof h);
	for(int i = 1;i <= m;i++)
	{
		cin >> price >> ad >> num;
		for(int j = 0;j < num;j++)
		{
			cin >> cur;
			if(j)
			{
				add((i-1)*n+pre,(i-1)*n+cur,ad);	
				add((i-1)*n+cur,(i-1)*n+pre,ad);	
			}
			add((i-1)*n+cur,n*m+cur,0);	
			add(n*m+cur,(i-1)*n+cur,price);	
			pre = cur;
		}
	}

	dijkstra(n*m+s);	
	if(dis[n*m+t] == INF)	
		cout << -1 << endl;
	else
		cout << dis[n*m+t] << endl;

	return 0;
}

待补的题

皮亚诺曲线距离
没写的理由：这图也…太抽象了吧

hualallaa
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
scratch考级试题资料 1-4级 赠送蓝桥杯
10-13
scratch考级试题资料 1-4级 赠送蓝桥杯 儿童、家长指导 淘宝几十元购买的 分享给大家
蓝桥软件-财务基础操作.doc
12-02
蓝桥软件财务基础操作简介 蓝桥软件财务基础操作是企业财务管理的核心模块之一，旨在帮助企业高效地管理财务活动。下面将详细介绍蓝桥软件财务基础操作的主要功能和操作流程。 一、登陆财务中心 在蓝桥软件财务...
2024SMU蓝桥训练2补题
qq_42643660的博客
04-10 291
C-密文搜索 思路：不难。 void solve(){ //C--密文搜索 可以不是字符串哈希--因为只需要知道相同长度字符串对字母出现情况，可以对字符串进行！！！排序！！！ string str; cin>>str; int n,ans=0; cin>>n; unordered_map<string,int> m...
2024SMU蓝桥3训练补题
qq_42643660的博客
04-19 308
ps:这个时候蓝桥已经结束一个星期了。。我才把这个训练的题补完。 D-P8715 [蓝桥杯 2020 省 AB2] 子串分值 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn) 思路：对于每一个位置的字母，预处理出这个字母左边第一个出现的下标，和右边第一个出现的下标。 对应这个位置字母的贡献为，左边可选个数+右边可选个数+左边可选个数*右边可选个数。 左边可选和右边可选的个数都可以...
2024SMU蓝桥训练1补题
qq_42643660的博客
04-04 189
B-航班时间 思路：地理知识--时差计算-东加西减。此处去程和返程方向相反，时差相加必然抵消。那么就可以知道实际飞行时间 ps:这题有点奇怪，本地跑不过样例，交上去是AC。本地跑过样例，交上去RE，WA。RE好像是因为输入的格式不够严格.. D-飞机降落 思路：全排列枚举 or dfs--dfs类似之前电科校赛没做出来的电阻题，当时不是很懂，现在知道怎么写这种需要全排列的dfs了。细节见代码注释...
《蓝桥小记》 2018-04-01
科大云炬
10-29 163
蓝桥杯省赛从9:00-13:00历时4个小时，今年的题和去年的题差不多有易有难，整体来说今年出的题即使做不出来也会让你觉得比较生动有趣味性，可能是为了吸引更多的人参加吧。 第一题:求2000/5/4是一年的第几天，这道题用excel稍微计算一下就出来了。 第二题:求半径为1000的圆内包含多少完整的1 x1的方格，这个题分不高还是耗费比较多的时间的，一开始想通过几何的手段算出来没走通，后来才枚举1000X1000方格筛选出在圆内的方格并计数，最后乘以4得出结果 第三题求复数（2+3i）^123456的
蓝桥打卡-day9【未完成、待补】
weixin_61022759的博客
03-12 81
明天和意外谁先到，谁也不知道
7-4 航班时间-第九届蓝桥省赛-A组 (100 分)
qq_54374865的博客
01-24 109
先声明一个小小的问题，就是老师给的模板提交了之后输出往后错了一行，but竟然也AC了，我就很不理解，看别人写的有个cin.getline（）（处理）AC了，有没有大佬可以给我小萌新解释一下。 小 h 前往美国参加了蓝桥杯国际赛。 小 h 的女朋友发现小 h 上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。 小 h 对超音速飞行感到十分恐惧。 仔细观察后发现飞机的起降时间都是当地时间。 由于北京和美国东部有 12 小时时差，故飞机总共需要 14 小时的飞行时间。 不久后小
蓝桥-2019-完全二叉树的权值
qq_55269856的博客
01-22 378
给定一棵包含 N 个节点的完全二叉树，树上每个节点都有一个权值，按从 上到下、从左到右的顺序依次是 A1​,A2​,⋅⋅⋅AN​，如下图所示： 现在小明要把相同深度的节点的权值加在一起，他想知道哪个深度的节点 权值之和最大？如果有多个深度的权值和同为最大，请你输出其中最小的深度。 注：根的深度是 1。 输入描述 第一行包含一个整数 N（1≤N≤1e5）。 第二行包含 N 个整数 A1​,A2​,⋅⋅⋅AN​（−1e5≤Ai​≤1e5）。 输出描述 输出一个整数代表答案。 输入输出样例
蓝桥杯赛前冲刺-枚举暴力和排序专题2（包含历年蓝桥杯真题和AC代码）
m0_62609939的博客
04-01 339
蓝桥杯赛前冲刺-枚举暴力和排序专题1（包含历年蓝桥杯真题和AC代码）
2020-2021JMU蓝桥校选题解
solity-_-的博客
01-30 896
蓝桥校选题解7-1 邪恶学长的代码 (5分)7-2 真正的送分题 (10分)7-3 tly的摩天轮 (15分)7-4 谁是龙王2 (12分)7-5 爱瞎跑的学长 (20分)7-6 区间和 (25分) 一直忘了写，现在补一下 7-1 邪恶学长的代码 (5分) 第一题水题，直接输出样例就行，这里不写具体代码了 7-2 真正的送分题 (10分) 邪恶学长出的邪恶题目，坑点在数据范围0<=A<=2^64-1 ，0<=B<=2^64-1。即使用了longlong都会超范围，观察发现都是正数所以
十四届蓝桥选拔赛Scratch-20230212 试题素材
03-06
9. **解决问题的能力**：试题通常会设定特定的任务或挑战，参赛者需要运用编程知识来解决实际问题，锻炼他们的逻辑思维和分析能力。 10. **项目管理**：虽然在初级阶段，但良好的项目组织和时间管理也是成功的关键...
十四届蓝桥选拔赛Scratch-20230312 试题素材
03-14
4. 多媒体支持：可以集成图像、声音、动画等元素，增强项目的互动性和趣味性。 5. 社区分享：Scratch拥有庞大的用户社区，孩子们可以分享自己的作品，互相学习和激励。 【十四届】赛事内容 十四届蓝桥选拔赛...
十四届蓝桥选拔赛Scratch-20230115 试题素材
03-07
在准备蓝桥选拔赛的过程中，考生需要通过练习题、模拟比赛和实际项目来提升自己的编程技能。同时，理解并熟练应用上述知识点将有助于他们在比赛中取得好成绩。通过参加此类比赛，孩子们不仅能够掌握编程技术，还能...
函数模板与类模板
程序员_小兵
07-12 1563
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 387
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 379
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
最新发布
m0_74586426的博客
07-12 802
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
为蓝桥青少出一道压轴题
07-14
好的，这是一道压轴题目。题目如下： ...输入：[1, 2, 3, 4, 5], [4, 5, 6, 7, 8] 输出：[4, 5] 输入：[10, 20, 30, 40], [50, 60, 70, 80] 输出：[] 请编写代码实现上述功能，并提供测试样例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值