练习

最新推荐文章于 2021-08-21 11:25:26 发布

我要找对象

最新推荐文章于 2021-08-21 11:25:26 发布

阅读量199

点赞数

分类专栏：蓝桥杯文章标签：算法

本文链接：https://blog.csdn.net/lihao1875699404/article/details/107622197

版权

蓝桥杯专栏收录该内容

27 篇文章 0 订阅

订阅专栏

w# 练习
(dfs,bfs,dp)

在这里插入图片描述
题解

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
//typedef long long ll;
char keyword[] = "yizhong";
char a[101][101];
char book[101][101];
int d[8][2] = {{-1,0},{-1,-1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1}};
int n; 
struct node{
	int x;
	int y;

};
node way[7];
void dfs(int x,int y,int state,int dir){
	if(state > 6){
		for(int i = 0;i<7;i++){
			book[way[i].x][way[i].y] = 1;
		}
	}else if(state <= 6){
		int dx = x+d[dir][0];
		int dy = y+d[dir][1];
		if(state == 6 || a[dx][dy] == keyword[state+1]){
			way[state].x = x;
			way[state].y = y;
			dfs(dx,dy,state+1,dir);
		}
	}
}
int main(){
	cin >>n;
	for(int i = 0;i<n;i++){
		cin >>a[i];
	}
	for(int i = 0;i<n;i++){
		for(int j = 0;j<n;j++){
			if(a[i][j] == 'y'){
				for(int k = 0;k<8;k++){
					if(a[i+d[k][0]][j+d[k][1]] == 'i'){
						dfs(i,j,0,k);
					}
				}
			}
		}
	}
	for(int i = 0;i<n;i++){
		for(int j = 0;j<n;j++){
			if(book[i][j]){
				cout <<a[i][j];
			}else{
				cout <<'*';
			}
			cout <<endl;
		}
	}
	return 0;
}

2.w 在这里插入图片描述
题解

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
//typedef long long ll;
int n,sum;
bool flag;
int ans[20],b[20],vis[20];
int getC(){
	for(int i = 0;i<n;i++){
		b[i] = 1;
		for(int j = i/2;j>0;j--){
			b[j] = b[i-j] = b[j]+b[j-1];
		}
	}
}
void dfs(int d,int s){
	if(d == n && s == sum){
		for(int i = 0;i<n;i++){
			cout <<ans[i]<<" ";
		}
		exit(0);
	}
	if(s > sum){
		return;
	}
	for(int i = 1;i<=n;i++){
		if(!vis[i]){
		vis[i] = true;
		ans[d] = i;
		dfs(d+1,s+b[d]*i);
		vis[i] = false;
		}
	}
}
int main(){
	cin >>n>>sum;
	getC();
	dfs(0,0);
	return 0;	
}

答案 https://blog.csdn.net/weixin_45725925/article/details/104430634?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159585744619725247622509%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=159585744619725247622509&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allfirst_rank_ecpm_v3~pc_rank_v4-2-104430634.first_rank_ecpm_v3_pc_rank_v4&utm_term=dfs%E4%B9%A0%E9%A2%98&spm=1018.2118.3001.4187
3.
描述

定义一个二维数组：

INT迷宫[5] [5] = {

0，1，0，0，0，

0，1，0，1，0，

0，0，0，0，0，

0，1，1，1，0，

0，0，0，1，0，

};

它表示一个迷宫，其中的1表示直线，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序从左上角到右下角的最短路线。
输入项

一个5×5的二维矩阵，表示一个迷宫。数据保证有唯一解。
输出量

左上角到右下角的最短路径，格式如样例所示。
样本输入

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
样本输出

（0，0）
（1，0）
（2，0）
（2，1）
（2，2）
（2、3）
（2、4）
（3，4）
（4、4）

答案 https://blog.csdn.net/weixin_44668898/article/details/104163073?biz_id=102&utm_term=bfs%E4%B9%A0%E9%A2%98&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-0-104163073&spm=1018.2118.3001.4187
4.
农夫约翰已被告知一头逃犯的位置，并希望立即抓住她。他从数字线上的点N（0≤N≤100,000）开始，而母牛在同一数字线上的点K（0≤K≤100,000）。农夫约翰有两种运输方式：步行和传送。

*行走：FJ可以在一分钟内从任意点X移至点X-1或X + 1。
*传送：FJ可以在一分钟内从任意点X移至点2×X。

如果没有意识到它的追捕能力的母牛完全没有动弹，那么农夫约翰要花多长时间？

输入项
第1行：两个以空格分隔的整数：N和K

输出量
第1行：农夫约翰用最少的时间（以分钟为单位）捉住逃犯。

样本输入
5 17

样本输出
4

暗示
农夫约翰到达逃亡者牛的最快方法是沿着以下路径移动：5-10-9-18-17，这需要4分钟。

hdu2717

题解

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
struct node{
	int x,step;
};
int n,k;
int vis[101];
queue<node> q;
int bfs(){
	node now,next;
	now.step = 0;
	now.x = n;
	q.push(now);
	vis[n] = true;
	while(!q.empty()){
		now = q.front();
		q.pop();
		if(now.x == k){
			return now.step;
		}
		next.x = now.x * 2;
		if(next.x >= 0&&next.x <= k&&!vis[next.x]){
			next.step = now.step+1;
			q.push(next);
			vis[next.x] = true;
		}
		next.x = now.x+1;
		if(next.x >= 0&&next.x <= k&&!vis[next.x]){
			next.step = now.step+1;
			q.push(next);
			vis[next.x] = true;
		}
		next.x = now.x-1;
		if(next.x >= 0&&next.x <= k&&!vis[next.x]){
			next.step = now.step+1;
			q.push(next);
			vis[next.x] = true;
		}
	}
	return -1;
}
int main(){
	while(cin>>n>>k){
		while(!q.empty()){
			q.pop();
		}
		memset(vis,0,sizeof(vis));
		cout <<bfs()<<endl;
	}
}

5
鸣人的影分身
总时间限制: 1000ms 内存限制: 65536kB
描述
在火影忍者的世界里，令敌人捉摸不透是非常关键的。我们的主角漩涡鸣人所拥有的一个招数——多重影分身之术——就是一个很好的例子。

影分身是由鸣人身体的查克拉能量制造的，使用的查克拉越多，制造出的影分身越强。

针对不同的作战情况，鸣人可以选择制造出各种强度的影分身，有的用来佯攻，有的用来发起致命一击。

那么问题来了，假设鸣人的查克拉能量为M，他影分身的个数为N，那么制造影分身时有多少种（用K表示）不同的分配方法？（影分身可以被分配到0点查克拉能量）

输入
第一行是测试数据的数目t（0 <= t <= 20）。以下每行均包含二个整数M和N，以空格分开。1<=M，N<=10。
输出
对输入的每组数据M和N，用一行输出相应的K。
样例输入
1
7 3
样例输出
8
答案 https://blog.csdn.net/KersKver/article/details/53996267

题解

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int T,n,m;
int dp[21][21]; //把i能量放在j个分身里的放法 
int main(){
	cin >>T;
	while(T--){
		cin >>m>>n;
		memset(dp,0,sizeof(dp));
		for(int i = 1;i<=20;i++){
			dp[0][i] = dp[1][i] = dp[i][1] = 1;
		}
		for(int i = 1;i<=20;i++){
			for(int j = 1;j<=20;j++){
				if(dp[i][j] == 0){
					if(i<j){
						dp[i][j] = dp[i][j-1];
					}else{
						dp[i][j] = dp[i][j-1]+dp[i-j][j];
					}
				}
			}
		}
		cout <<dp[m][n]<<endl;
	}
	return 0;
}

6
奶牛的锻炼
(exer.c/.cpp/.pas)

Description:
奶牛Bessie有N分钟时间跑步，每分钟她可以跑步或者休息。若她在第i分钟跑步，可以跑出D_i米，同时疲倦程度增加1（初始为0）。若她在第i分钟休息，则疲倦程度减少1。无论何时，疲倦程度都不能超过M。另外，一旦她开始休息，只有当疲惫程度减为0时才能重新开始跑步。在第N分钟后，她的疲倦程度必须为0。

Input:
输入文件名为(exer.in)。
第一行，两个整数，代表N和M。接下来N行，每行一个整数，代表D_i。

Output
输出文件名为(exer.out)。
Bessie想知道，她最多能跑的距离。

exer.in
5 2
5 3 4 2 10

exer.out
9

答案 https://blog.csdn.net/Z_Mendez/article/details/47344307?biz_id=102&utm_term=dp%E5%9F%BA%E7%A1%80%E4%B9%A0%E9%A2%98&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-4-47344307&spm=1018.2118.3001.4187

题解

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int dp[101][101];
int a[101];
int n,m;
int main(){
	cin >>n>>m;
	for(int i = 1;i<=n;i++){
		cin >>a[i];
	}
	dp[0][0] = 0;
	for(int i = 1;i<=n;i++){
		dp[i][0] = dp[i-1][0];
		for(int j = 1;j<=m&&i-j>=0;j++){ // 休息 
			dp[i][0] = max(dp[i][0],max(dp[i-j][0],dp[i-j][j]));
		}
		for(int j = 1;j<=m;j++){
			dp[i][j] = dp[i-1][j-1]+a[i];
		} 
	}
	cout <<dp[n][0]<<endl;
	return 0;
}