十三届蓝桥杯算法知识（一）

已于 2022-04-09 01:18:27 修改
阅读量473 收藏 4
点赞数 1
分类专栏： 学习记录 文章标签： c++ 算法 c算法 蓝桥杯
于 2021-11-28 15:59:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwq1455688169/article/details/121548940
版权

完结撒花

文章目录

一.贪心

贪心是什么

有些题目只需要做出在当前看来最好的选择就可以获得最好的结果，而不需要考虑整体上的最优。贪心必须具备无后效性，既某个状态以前的过程不会影响以后的状态。

思路模板

1.看题意创建结构体(也可能不用结构体)
2.看题意用sort和cmp自定义排序(也可能不用排序)
3.开始计算得出结果（如何计算考验思维）

洛谷p2240 部分背包问题

知识点

1.此题判断单个价值比应该是 a.价值 / a.重量，但是按照a.价值 * b.重量和a.重量 * b.价值 可以规避使用浮点数和除法
2.如何判断背包有没有装满：即将装进去的东西>背包剩余容量
那背包还有容量怎么办？背包剩余容量 / 即将装进去的东西 * 价值就装完了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int n,mi,vi,t,i;
struct money{
	int mi,vi;
}a[1050];

int cmp(money a,money b){
	return a.vi*b.mi >b.vi*a.mi;
}

int main(){
	cin>>n>>t;
	for(int i=1;i<=n;i++){
		cin>>a[i].mi>>a[i].vi;
	}
	sort(a+1,a+1+n,cmp);
	double sum=0;
	for(i=1;i<=n;i++){
		if(a[i].mi>t)break;
		sum+=a[i].vi;
		t-=a[i].mi;
	}
	if(i<n){
		sum+=1.0* t/a[i].mi *a[i].vi;
	}
	printf("%.2lf",sum);
	return 0;
}

洛谷p1223 排队接水

知识点

1.排队取水，如何排序后如何确定每个人的等水时间：第一个人会被等n-1次，第二个人会被等n-2次…第i个人会被等n-i次

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int n;
struct water{
	int time,num;
}a[1050];
bool cmp(water a,water b){
	return a.time<b.time;
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i].time;
		a[i].num=i;
	}
	sort(a+1,a+1+n,cmp);
	double ans;
	for(int i=1;i<=n;i++){
		cout<<a[i].num<<" ";
	}
	cout<<endl;
	for(int i=1;i<=n;i++){
		ans+=i*a[n-i].time;
	}
	printf("%.2lf",1.0*ans/n);
	return 0;
}

洛谷p1803 线段覆盖

知识点

1.这题显然只需要排序结束时间就是最优解，判断答案++的时候需要创建变量记录更新上一次比赛结束时间

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int n,ans,l;
struct oi{
	int ai,bi;
}a[100005];
int cmp(oi a,oi b){
	return a.bi<b.bi;
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i].ai>>a[i].bi;
	}
	sort(a+1,a+1+n,cmp);
	
	for(int i=1;i<=n;i++){
		if(a[i].ai>=l){
			ans++;
			l=a[i].bi;
		}
	}
	cout<<ans;
	return 0;
}

洛谷p1090 合并果子

知识点

  1. priority_queue<int,vector,greater >q; 按升序排序的优先队列
  2. priority_queue<int,vector,less >q; 按降序排序的优先队列
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
int n,ai,ans;

int main(){
	priority_queue<int,vector<int>,greater<int> >q;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>ai;
		q.push(ai);
	}
	int a;
	for(int i=1;i<n;i++){
		a=q.top();
		q.pop();
		a+=q.top();
		q.pop();
		ans+=a;
		q.push(a);
	}
	cout<<ans;
	return 0;
}

洛谷p3817 小A的糖果

知识点

1.两个相邻的加起来不能大于某个数，肯定是减掉后面的比较赚，因为从第二个数开始都会影响相邻的两个数，第一个数只影响后面的一个数
2.三年竞赛一场空，不开long long见祖宗

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
long long n,ai,x,a[100005],ans;


int main(){
	cin>>n>>x;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<=n;i++){//i等于1就可以特判a【0】了 
		if(a[i]+a[i-1]>x){
			ans+=a[i]+a[i-1]-x;
			a[i]-=a[i]+a[i-1]-x;
		}
	}
	cout<<ans;
	return 0;
}

洛谷p1478 陶陶摘苹果（升级版）

知识点

1.毫无技巧全是感情

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
int n,s,ans,a,b;
struct apple{
	int xi,yi;
}aa[105000];
int cmp(apple a,apple b){
	return a.yi<b.yi;
}
int main(){
	cin>>n>>s>>a>>b;
	for(int i=1;i<=n;i++){
		cin>>aa[i].xi>>aa[i].yi;
	}
	sort(aa+1,aa+1+n,cmp);
	for(int i=1;i<=n;i++){
		if(b+a>=aa[i].xi && aa[i].yi<=s){
			ans++;
			s-=aa[i].yi;
		}
	}
	cout<<ans;
	return 0;
}

洛谷p5019 铺设道路

知识点

1.铺路，值大减去，值小白嫖 ，请仔细审题，注意题解已经是特判了a【1】的
因为
假设现在有一个坑，但旁边又有一个坑。

你肯定会选择把两个同时减1；

那么小的坑肯定会被大的坑“带着”填掉。

但是如果后面的数大于了前面的数，那么前面的数为0，根据题意区间每块填充不能为0，就只能要单独加上大于前面的数值

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
int n,a[1000005],ans;


int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<=n;i++){
		if(a[i]>a[i-1]){
			ans+=a[i]-a[i-1];
		}
	}
	cout<<ans;
	return 0;
}

洛谷p1208 混合牛奶

知识点

1.毫无技巧，全是模板

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
int n,m,ans;
struct milk{
	int pi,ai;
}a[50500];
int cmp(milk a,milk b){
	return a.pi<b.pi;
}
int main(){ 
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>a[i].pi>>a[i].ai;
	}
	sort(a+1,a+1+m,cmp);
	for(int i=1;i<=m;i++){
		if(a[i].ai<=n){
			n-=a[i].ai;
			ans+=a[i].pi*a[i].ai;
		}
		else{
			ans+=n * a[i].pi;
			break;
		}
	}
	cout<<ans;
	return 0;
}

洛谷p1094 纪念品分组

知识点

贪心算法并不难，难的是证明。 — 沃夏纪霸索德

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
int w,n,a[100005],ans;


int main(){ 
	cin>>w>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	sort(a+1,a+1+n);
	int l=1,r=n;
	while(l<=r){
		if(a[l]+a[r]<=w){
			ans++;
			l++;
			r--;
		}else{
			ans++;
			r--;
		}
	}
		
	cout<<ans;
	return 0;
}

二.二分

二分是什么

如果序列是有序的，就可以通过二分查找快速定位所需要的数据，除此之外，二分思想还可以求出可行解的最值问题，比如可行解的最大值或最小值

思路模板

1.查找一个值

int f(int b){
	int l=1,r=n;
	while(l<=r){
		int mid=l+(r-l)/2;
		if(a[mid]==b)return mid；
		if(a[mid]<b)l=mid+1;
		else r=mid-1;
	}
	return -1;
}

2.查找有序数组中第一次出现的位置

int f(int b){
	int l=1,r=n;
	while(l<r){
		int mid=l+(r-l)/2;
		if(a[mid]>=b){
			r=mid;
		}
		else l=mid+1;
	}
	if(a[l]==b)return l;
	else return -1;
}

3.查找有序数组中最后一次出现的位置 可以变换得到 最后一个小于等于 某个值 的数

int f(int b){
	int l=1,r=n;
	while(l<r){
		int mid=l+(r-l)/2;
		if(a[mid]<=b){
			l=mid+1;
		}
		else r=mid;
	}
	if(a[l-1]==b)return l-1;
	else return -1;
}

洛谷p1102 A-B数对

知识点

1.lower_bound(a,a+n,3)-a找a数组中3第一次出现的位置的下标 （已经排序）
upper_bound(a,a+n,3)-a找a数组中3最后一次出现的位置的后面一位的下标 （已经排序）
那么数出现的次数可以表示为 upper_bound(a,a+n,3)-lower_bound(a,a+n,3)

2.计算出数对A-B=C出现的个数，可以转化为B+C出现了多少次

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<queue>
using namespace std;
long long n,c,sum; 
long long a[1000500];
int main(){
	cin>>n>>c;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	sort(a+1,a+1+n);
	for(int i=1;i<=n;i++){
		sum+=upper_bound(a+1,a+1+n,a[i]+c) - lower_bound(a+1,a+1+n,a[i]+c); 
	}
	cout<<sum;
	return 0;
}

洛谷p1873 砍树

知识点

1.运用函数判断二分的数是否满足条件，满足条件后再判断能不能最小
2.运用变量记录更新答案能不能最小(此题需要数尽量大)

#include<bits/stdc++.h>
using namespace std;
long long n,m,tot;
long long a[1005000];
bool f(long long b){
	long long ans=0;
	for(int i=1;i<=n;i++){
		if(a[i]>b){
			ans+=a[i]-b;
		}
	}
	if(ans>=m)return true;
	else return false;
}

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	long long l=1,r=1000000000,tot=0;
	while(l<=r){
		long long mid=l+(r-l)/2;
		if(f(mid)){//满足条件了求能不能最小 
			tot=mid;
			l=mid+1; 
		}
		else r=mid-1;
	}
	cout<<tot;
	return 0;
}

洛谷p1678 烦恼的高考志愿

知识点

1.考点：最后一个小于等于 某个值 的数 套用二分模板可得到 a[l-1]是最后一个小于学生成绩的数
a[l]是第一个大于学生成绩的数 ，它们两个数中肯定有正确答案

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
int n,m,a[10000050],b[10000050],ans;


int main(){
	cin>>m>>n;
	for(int i=1;i<=m;i++){
		cin>>a[i];
	} 
	for(int i=1;i<=n;i++){
		cin>>b[i];
	}
	sort(a+1,a+1+m);
	for(int i=1;i<=n;i++){
		int l=1,r=m;
		while(l<r){//可得到 a[l-1]是最后一个小于学生成绩的数
		           //a[l]是第一个大于学生成绩的数 
			int mid=l+(r-l)/2;
			if(a[mid]<=b[i]){
				l=mid+1;
			}else{
				r=mid;
			}
		}
		if(b[i]<=a[1])ans+=a[1]-b[i];
		else{
			ans+=min(abs(b[i]-a[l-1]),abs(b[i]-a[l]));
		}
	} 
	cout<<ans;
	return 0;
}

洛谷p2440 木材加工

知识点

函数判断+求满足条件的最大值

#include<iostream>
#include<cmath>
#include<cstdio>
#include<algorithm>
#include<string>
#define shu 105000000
using namespace std;
long long n,k,a[shu];
bool f(int b)
{
	long long tot=0;
   	for(int i=1;i<=n;i++)
   	{
   	  tot+=a[i]/b;
   	}
   	return tot>=k;
}
int main()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
	}
	long long l=0,r=100000000,ans;
	while(l<=r)
	{
		long long mid=l+(r-l)/2;
		if(mid==0)
		{ 
		cout<<"0"<<endl;
		return 0;
		} 
			if(f(mid))
		{
			ans=mid,l=mid+1;
		}
		else r=mid-1;
	}
	cout<<ans;
	return 0;
}

洛谷p1824 进击的奶牛

知识点

1.函数判断的技巧，建立变量记录上一头牛的坐标，两坐标相减可以得到间距
2.二分答案，找符合条件中的最大值模板

#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
long long n,c,a[100050];
bool f(int b){
	long long last=-10000000,sum=0;
	for(int i=1;i<=n;i++){
		if(a[i]-last>=b){
			sum++;
			last=a[i];
		}
	}
	return sum>=c;
}

int main(){
	cin>>n>>c;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	sort(a+1,a+1+n);
	long long l=1,r=a[n];
	long long ans=0;
	while(l<=r){
		int mid=l+(r-l)/2;
		if(f(mid)){
			ans=mid;
			l=mid+1;
		}else{
			r=mid-1;
		}
	}
	cout<<ans;
	return 0;
}

三.搜索

搜索是什么

搜索算法也是一种暴力枚举策略。但是算法特性决定了效率比直接的枚举所以答案要高，使用搜索可以解决一些小规模的情况，分为dfs深搜(栈的思想)和bfs广搜（队列思想）

思路模板

dfs一般形式：

void dfs(int k){
	if(所以空填完了){
		记录答案
		return ; 
	} 
	for(枚举这个空能填的选项){
		if(条件都通过){
			记录下这个空(保存现场)
			dfs(k+1);
			取消这个空(回溯恢复现场) 
		} 
	}
}

dfs一般形势：

while(!q.enpty())
{
   int first=q.front();
   q.pop();
   for(枚举所有可扩展状态) //找到first所以可达状态v
   if(是合法的) //v需要满足条件，比如未访问过、未在队内
   q.push(v); //入队（同时可能需要维护某些必要信息）
}

dfs不能搜最短、最小
bfs搜最短、最小

关于要不要恢复现场：枚举所有可能的状态，如果不恢复现场会不会污染其他状态
个体：比如点、连通块可以标记，就没必要恢复现场
整体：比如全排列、地图，枚举的是路径，有必要恢复现场
如果出题人说了这么一句废话：“按字典序输出”就是要我们从小到大枚举.

洛谷p1706 全排列问题 dfs

知识点

搜索模板

#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n,a[50],vis[50]; 

void dfs(int b){
	if(b>n){//所以空填完了，然后输出
		for(int i=1;i<=n;i++){
			printf("%5d",a[i]);
		}
		cout<<endl;
		return ;
	}
	for(int i=1;i<=n;i++){
		if(vis[i]==0){
			vis[i]=1;//用了就不能再用，因为数字不能相同
		    a[b]=i;//记录答案
		    dfs(b+1);//这里会完成或失败
		    vis[i]=0;//完成或失败后回溯
		}
		
	}
}

int main(){
	cin>>n;
	dfs(1);
	return 0;
}

洛谷p1219 八皇后 dfs

知识点

八皇后，需要判断四个点：行，列，左斜，右斜
行的判断，dfs x往下走++就不可能在同一行，不用特判
列的判断，for循环列i++，我们可以建立数组记录，用了就变为1，没用就是0
左上斜边 可以发现行减列数字相同 zs[x-i+n] 加n防止越界
右上斜边 可以发现行和列加起来数字相同 ys[x+n]

#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n,ans;
int a[1050];//记录答案
int column[1050];//记录列的访问
int zs[1050];//记录左上到右下的那条 
int ys[1050];//记录右上到左下的那条 

void pr(){
	for(int i=1;i<=n;i++){
		cout<<a[i]<<" ";
	}
	cout<<endl;
}

void dfs(int x){
	if(x>n){
		if(ans<3){
			pr();
		}
		ans++;
		return ;
	}
	for(int i=1;i<=n;i++){
		if(!column[i] && !zs[x-i+n] && !ys[x+i]){
			column[i]=1;
			zs[x-i+n]=1;
			ys[x+i]=1;
			a[x]=i;
			dfs(x+1);
			column[i]=0;
			zs[x-i+n]=0;
			ys[x+i]=0;
		} 
	}
}

int main(){
	cin>>n;
	dfs(1);
	cout<<ans;
	return 0;
}

洛谷p1605 迷宫 dfs

知识点

1.起点需要记录用过
2.障碍物，路线都需要记录

#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n,m,t,diex,diey,ans,startx,starty,endx,endy;
int vis[20][20];//障碍 
int a[20][20];//路线，走过了要记录 
int aa[]={-1,1,0,0};
int bb[]={0,0,-1,1};
void dfs(int x,int y){
	if(x==endx && y==endy){
		ans++;
		return ;
	}
	for(int i=0;i<4;i++){
		int dx=aa[i]+x;
		int dy=bb[i]+y;
		if(dx>=1 && dx<=n && dy>=1 && dy<=m && !vis[dx][dy] && !a[dx][dy] ){
			a[dx][dy]=1;
			dfs(dx,dy);
			a[dx][dy]=0;
		}
	}
}


int main(){
	cin>>n>>m>>t;
	cin>>startx>>starty>>endx>>endy;
	for(int i=1;i<=t;i++){
		cin>>diex>>diey;
		vis[diex][diey]=1;
	}
	vis[startx][starty]=1;
	dfs(startx,starty);
	cout<<ans; 
	return 0;
}

洛谷p1101 单词方阵 dfs

知识点

此题先找到第一个字母，往它的八个方向判断，如果全部符合，vis记录输出本身，否则输出*

#include<bits/stdc++.h>
using namespace std;
int n,vis[105][105];
char a[105][105];
string s="yizhong";
int xx[]={1,1,1,0,0,-1,-1,-1};
int yy[]={1,0,-1,1,-1,1,0,-1};

void dfs(int x,int y){
	for(int i=0;i<8;i++){
		int flag=1;
		for(int j=0;j<7;j++){
			int dx=j*xx[i]+x;
			int dy=j*yy[i]+y;
			if(dx<1||dx>n||dy<1||dy>n||s[j]!=a[dx][dy]){
				flag=0;
				break;
			}
		}
		if(flag){
			for(int j=0;j<7;j++){
			int dx=j*xx[i]+x;
			int dy=j*yy[i]+y;
			vis[dx][dy]=1;
			}
		}
	}
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			cin>>a[i][j];
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(a[i][j]=='y'){
				dfs(i,j);
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(!vis[i][j]){
				cout<<"*";
			}
			else {
				cout<<a[i][j];
			}
		}
		cout<<endl;
	}
	return 0;
}

洛谷p1162 填图颜色 bfs

知识点

运用bfs，为了方便搜索，假设外面还有一圈0，从0,0开始遍历，遍历过的用vis数组记录，这样没有被记录过的0就是要改变的数

#include<bits/stdc++.h>
#include<queue>
using namespace std;
int n,a[50][50],vis[50][50];
int aa[]={1,0,0,-1};
int bb[]={0,-1,1,0};

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			cin>>a[i][j];
		}
	}
	queue<int>x;
	queue<int>y;
	x.push(0);
	y.push(0);
	while(!x.empty()){
		x.pop();
		y.pop();
		for(int i=0;i<4;i++){
			int dx=aa[i]+x.front();
			int dy=bb[i]+y.front();
			if(dx>=0&&dx<=n+1&&dy>=0&&dy<=n+1&&a[dx][dy]==0&&!vis[dx][dy]){//外面还有一圈0
				vis[dx][dy]=1;
				x.push(dx);
				y.push(dy);
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(vis[i][j]==0&&a[i][j]==0){
				cout<<"2 ";
			}
			else cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}

DFS代码

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int n;
int a[50][50];
int vis[50][50];
int aa[]={-1,1,0,0};
int bb[]={0,0,-1,1};
void dfs(int x,int y){
	for(int i=0;i<4;i++){
		int dx=aa[i]+x;
		int dy=bb[i]+y;
		if(dx>=0&&dx<=n+1&&dy>=0&&dy<=n+1&&!vis[dx][dy]&&a[dx][dy]==0){
			vis[dx][dy]=1;
			dfs(dx,dy);
		}
	}
}

int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			cin>>a[i][j];
		} 
	}
	dfs(0,0);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(!vis[i][j] && a[i][j]==0){
				cout<<"2"<<" ";
			}else{
				cout<<a[i][j]<<" ";
			}
		} 
		cout<<endl;
	}
	return 0;
}

洛谷p1443 马的遍历 bfs

知识点

队列与结构体的运用，广搜，初始化数组全部是-1

#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
#include<cstdio>
using namespace std;
int n,m,mx,my;
int a[400][400];
int aa[]={2,2,1,1,-1,-1,-2,-2};
int bb[]={1,-1,2,-2,2,-2,1,-1};
struct horse{
	int x,y,s;
};

void bfs(int x,int y){
	queue<horse>Q;
	Q.push((horse){x,y,0});
	while(!Q.empty()){
		for(int i=0;i<8;i++){
		int dx=aa[i]+Q.front().x;
		int dy=bb[i]+Q.front().y;
		if(dx>=1&&dx<=n&&dy>=1&&dy<=m&&a[dx][dy]==-1){
			a[dx][dy]=Q.front().s+1;
			Q.push((horse){dx,dy,Q.front().s+1});
		    }
	    }
	    Q.pop();
	}
}

int main()
{
	cin>>n>>m>>mx>>my;
	memset(a,-1,sizeof(a));
	a[mx][my]=0;
	bfs(mx,my);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			printf("%-5d",a[i][j]);
		}
		cout<<endl;
	}
	return 0;
}

洛谷p1135 奇怪的电梯 bfs

知识点

#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
#include<cstdio>
using namespace std;
int n,a,b;
int ans[500],vis[500];


int main()
{
	cin>>n>>a>>b;
	for(int i=1;i<=n;i++){
		cin>>ans[i];
	}
	queue<int>x;
	queue<int>s;
	x.push(a);
	s.push(0);
	while(!x.empty()){
		if(x.front()==b){
			cout<<s.front();
			return 0;
		}
		int dx=x.front()+ans[x.front()];
		int dy=x.front()-ans[x.front()];
		if(dx<=n&&!vis[dx]){
			vis[dx]=1;
			x.push(dx);
			s.push(s.front()+1);
		}
		if(dy>=1&&!vis[dy]){
			vis[dy]=1;
			x.push(dy);
			s.push(s.front()+1);
		}
		x.pop();
		s.pop();
	}
	cout<<"-1";
	return 0;
}
真的能留住晚霞
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【蓝桥杯 && LCA && 差分】 砍树
鹭天
11-28 479
这道题还是比较裸的一道书上差分的题目了对于每一对标记点(x,y)他们之间的路径就是x−LCAxy−y这条路径上的每一条边都要经过。那么对于一条边，什么时候砍掉这条边的时候，这几对点互相到达不了呢？那就是这条边是这m条路径（一共m对点，每一对点都有一条路径）的公共边也就是说这条边被经过了m次因此，对于每一条边，我们用一个数组记录这条边被经过了几次最后经过次数为m的边就是可以砍掉的边，最后取一个max即可那么我们如何累加边经过的次数呢。
十三届蓝桥杯基础知识大全
qwq1455688169的博客
11-16 2434
文章目录普通题型 普通题型 字符转换大小写 大转小+32 小转大-32（记得用char强转） 反转数字问题 如果直接用取个位十位百位的方法的题目，会输出0 方法1：固定了几位数，直接输入字符，反着输出字符 cin>>a>>b>>c>>d>>e; cout<<e<<d<<c<<b<<a; ...
蓝桥杯算法考前复习要点和归纳总结
星辰大数据的博客
07-09 1万+
一、重要知识要点 1、穷举法 2、枚举法 3、动态规划 4、回溯法 5、图论 6、深度优先搜索（DFS） 7、广度优先搜索（BFS ） 8、二叉树 9、递归 10、分治法、矩阵法 11、排列组合 12、素数、质数、水仙花数 13、欧几里得定理gcd 14、求最大公约数、最小公倍数 15、海伦公式（求三角形面积） 16、博弈论 17、贪心...
蓝桥杯一些常用的算法
qq_52897257的博客
04-05 5795
蓝桥杯倒计时（常用算法合集）
【蓝桥杯】第十三届蓝桥杯省赛 AK 攻略 —— C++ B组全真题超详细剖析
秋刀鱼与猫的博客
05-02 1万+
村口二大爷都能看懂的第十三届蓝桥杯AK攻略！C++ B组真题详细解读！
第十三届蓝桥杯省赛JavaB组题目
04-09
【压缩包子文件的文件名称列表】：《第十三届蓝桥杯软件赛省赛_JAVA_B组.pdf》是本次比赛的题目集，其中包含了一系列的编程题目，可能涵盖基础编程、数据结构（如数组、链表、树等）、排序算法（如冒泡排序、快速...
第十三届蓝桥杯嵌入式省一程序
05-05
【标题】"第十三届蓝桥杯嵌入式省一程序"揭示了这是一份与第13届蓝桥杯竞赛相关的嵌入式系统程序，它获得了省级一等奖的荣誉。蓝桥杯是一项全国性的信息技术竞赛，旨在提升学生的软件和硬件开发能力，特别是嵌入式...
第十三届蓝桥杯Java C组试题
04-09
【标题】"第十三届蓝桥杯Java C组试题"涵盖了两个主要编程语言——Java和C，在这个竞赛中，参赛者需要展示他们在编程、算法设计和问题解决上的技能。蓝桥杯是一项全国性的软件和信息技术专业人才大赛，旨在促进高校...
第十五届蓝桥杯大赛知识点大纲
01-17
以下是对第十五届蓝桥杯大赛知识点大纲的详细解析： 一、编程语言： 1. C/C++：这是基础语言，要求掌握基本语法、指针操作、内存管理以及STL（Standard Template Library）的使用。 2. Java：了解面向对象编程，...
第十三届蓝桥杯大赛省赛(第一场)个人赛获奖名单.rar
04-28
本压缩包文件包含了第十三届蓝桥杯大赛省赛（第一场）个人赛的两个获奖名单，分别针对"电子类"和"软件类"的参赛者。这表明竞赛涵盖了电子工程和软件开发两大领域，反映了当前信息技术行业对多元化技术人才的需求。 ...
蓝桥杯 常用（常考）算法 模板大全 富含比赛技巧 得分方法
qq_51797890的博客
04-07 9033
2022年4月9日又是新一届蓝桥杯大赛，再次，根据往年蓝桥杯考题我整理了算法模板，一来用于复习巩固，二来有需要的小伙伴们可自取，同时预知小伙伴们取得好成绩。 1：判断闰年 bool isLeaf(int x){ return (x % 400 == 0) || (x % 4 == 0 && x % 100 != 0) ; } 2:计算从xx年xx月xx日 ------ xx年xx月xx日 一共经历了多少天 int end_year , end_month , end_day ; i
蓝桥杯2022年第十三届省赛真题-统计子矩阵
qq_61623487的博客
02-22 294
蓝桥杯python，ICPC，前缀法应用
第十三届蓝桥杯嵌入式国赛真题(基于HAL库的巨简代码＋超级详解)
关于你的一切我都在意
06-21 1万+
开发板：CT117E-M4(STM32G431RBT6) 开发环境： CubeMX+Keil5 涉及题目：第十三届蓝桥杯嵌入式国赛真题 难点：双路AD测量电压、输入捕获测频率、LCD屏幕翻转、冒泡法、初始上电判断、按键长短按
第十三届蓝桥杯2022各组完整真题(可评测)
Dotcpp
04-18 2万+
2022年第十三届蓝桥杯大赛软件类省赛题集链接 1.2022年第十三届蓝桥杯大赛软件类省赛C/C++大学A组真题 https://www.dotcpp.com/oj/train/1025/ 2.2022年第十三届蓝桥杯大赛软件类省赛C/C++大学B组真题 https://www.dotcpp.com/oj/train/1026/ 3.2022年第十三届蓝桥杯大赛软件类省赛C/C++大学C组真题 https://www.dotcpp.com/oj/train/1027/ 4.2022年第十三届蓝桥杯大赛软件.
蓝桥杯---基础算法思想-贪心（算法笔记15）
Edwinwzy的博客
02-20 269
以前觉得贪心是个算法，就像DFS这种有固定套路的，后来才发现，其实贪心也是一种算法思想，没有固定的模板，它常常与动态规划思想结合在一起。 贪心算法的定义： 个人理解：对于当前问题，找到问题的局部问题，并获得局部最优解，其次向着全局最优解拓展。贪心，顾名思义就是能多拿就多拿这种思想，每次找到满足局部条件的最好解。但这样并不意味着全局最优，这个还需要后期的优化。贪心的例子通过下面的书上例题来展示。 用贪心有好处也有坏处，什么时候用贪心是需要牢记的，这个使用贪心满足的性质和动态规划差不多。 总结两个就
2022年十三届蓝桥杯国赛（C/C++大学B组）个人题解
热门推荐
polarday的博客
06-19 2万+
去年国赛基本都是暴力，最后国三都没拿到（我是废物 ），今年感觉比去年难了不少，而且时间没有安排好，第一题就被卡了好久，然后G题概率论也分析了好久，导致最后三题都没时间做了，总之就是一点暴力分都没骗到，希望做的题能多对几道吧，希望能拿个国三。10个循环暴力明显超时，有一点思路大概是最小数的范围在0-197之间，可能需要根据数的范围来做？然后就不会了。枚举时分秒，分别计算秒针、分针、时针与0时的夹角度数 秒针的夹角度数为：360 * m / 60；（一圈360度，秒针转了m / 60圈） 分针的夹角度数为：36
蓝桥杯总结-常用函数及算法
weixin_30511039的博客
06-20 1954
<memory.h>或<string.h> void *memset(void *s, int ch,size_tn); #include <algorithm> sort(a,a+n)排序函数，从小到大，a为数组名字，n为元素个数 sort(vector.begin(),vector.end())排序vector 只要数据类型定义了小于操作...
[蓝桥杯]常用算法-穷举法
luojin2003529的专栏
10-30 8808
穷举法又称为枚举法，它是在计算机算法设计中用得最多的一种编程思想。它的实现方式是：在已知答案范围的情况下，依次地枚举该范围内所有的取值，并对每个取值进行考查，确定是否满足条件。经过循环遍历之后，筛选出符合要求的结果来。这种方法充分利用了计算机运算速度快的特点，思路简单直接，能够解决大部分的问题。 什么样的问题适合使用穷举法来解决呢？归纳起来，遇到了如下的三种情况，将优先考虑使用穷举法： 1. 
【2022第十三届蓝桥杯】c/c++ 大学c组 解题报告
m0_66252872的博客
04-09 1万+
大家好，我是小单同学，欢迎交流指正~ 今天上午蓝桥杯圆满落幕，准备了几个月的比赛也终于打完了。今年填空题变成了两道，根据同学们反映今年难度上升很大，小单也感觉今年难度较大hh，空了两道题。现在给大家分享一下本菜鸡的解题报告，供大家交流。仅供参考哈。 目录 ​大家好，我是小单同学，欢迎交流指正~​ 🎁试题 A: 排列字母 【问题描述】 小蓝要把一个字符串中的字母按其在字母表中的顺序排列。 例如，LANQIAO 排列后为 AAILNOQ。 又如，GOODGOODSTUDYDAYDAY...
第十三届蓝桥杯python真题
最新发布
03-14
第十三届蓝桥杯中国最具影响力的计算机竞赛之一，旨在培养和选拔计算机人才。以下是该届比赛的一些真题题目： 1. 编写一个程序输入一个整数n，输出n的阶。 2. 编写一个程序，输入一个字符串，回文串。 3 编写一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值