备战蓝桥杯决赛----坚持第四天!!!

      又是一个深夜。。。昨天说今天要找一些关于BFS和DFS的练习题,今天当然是要怎么做。但是,我仅仅做了两道题,全来自于蓝桥杯练习题库。再看看所用时间,发现自己的效率是真的不高。。(一直以来的问题,还没有找到好的办法解决)

     那就说下这两道题目吧,说完还要洗洗睡觉。。。

     首先是一道关于BFS的练习题

问题描述
  学霸抢走了大家的作业,班长为了帮同学们找回作业,决定去找学霸决斗。但学霸为了不要别人打扰,住在一个城堡里,城堡外面是一个二维的格子迷宫,要进城堡必须得先通过迷宫。因为班长还有妹子要陪,磨刀不误砍柴功,他为了节约时间,从线人那里搞到了迷宫的地图,准备提前计算最短的路线。可是他现在正向妹子解释这件事情,于是就委托你帮他找一条最短的路线。
输入格式
  第一行两个整数n, m,为迷宫的长宽。
  接下来n行,每行m个数,数之间没有间隔,为0或1中的一个。0表示这个格子可以通过,1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方,即左上角,迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里,每次移动算一步。数据保证(1,1),(n,m)可以通过。
输出格式
  第一行一个数为需要的最少步数K。
  第二行K个字符,每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径,选择在此表示方法下字典序最小的一个。
样例输入
Input Sample 1:
3 3
001
100
110

Input Sample 2:
3 3
000
000
000
样例输出
Output Sample 1:
4
RDRD

Output Sample 2:
4
DDRR
数据规模和约定
  有20%的数据满足:1<=n,m<=10
  有50%的数据满足:1<=n,m<=50
  有100%的数据满足:1<=n,m<=500。

思路:通过bfs寻找一条可从起点到达终点的最短路径,但是这里附件了一个条件:如果有多条长度相同的最短路径,选择在此表示方法下字典序最小的一个。这才是值得思考的地方,既然需要字典序最小,那么我们首先对四个方向进行字典序排序,排序结果为:DLRU。那么我们在进行bfs搜索时,按照这个排序方向的先后顺序,进行搜索,这样最终确定的一定是一个字典序最小的路径。

附程序代码及重要注释:

#include <iostream>  
#include <cstdio>  
#include <cstring>  
#include <algorithm>  
#include <queue>  
using namespace std;
const int MAX=501;//有100%的数据满足:1<=n,m<=500。因为我们使用时从1,1开始,所以数组长度为501  
struct pos{
	int x;
	int y;
	int sum;
}; 
int dict[4][2]={{1,0},{0,-1},{0,1},{-1,0}};//这里数组表示的是与字典序对应操作DLRU所产生的结果,二维数组中两个元素分别代表行(1下移0不动-1上移)和列(1右移0不动-1左移)
                                          //的变化。其实很好理解,想两遍就通了
char str[5]="DLRU";//详细说明见下面常识一
int pre[MAX][MAX];
char temp[MAX][MAX];
int vis[MAX][MAX];
int n;
int m;
void bfs(){
	queue<pos> q;
	memset(vis,0,sizeof(vis));
	pos p;
	p.x=1;
	p.y=1;
	p.sum=0;
	q.push(p);
	vis[1][1]=1;
	pre[1][1]=-1;//设置其实点的pre为-1,不存在 
	while(!q.empty()){
		p=q.front();
		q.pop();
		if(p.x==n&&p.y==m){
			cout<<p.sum<<endl;
			return;//此时一定要return空结束循环 
		}
		pos pp;
		for(int i=0;i<4;i++){
			pp.x=p.x+dict[i][0];
			pp.y=p.y+dict[i][1];
			pp.sum = p.sum+1;
			if(pp.x>=1&&pp.x<=n&&pp.y>=1&&pp.y<=m&&temp[pp.x][pp.y]=='0'&&vis[pp.x][pp.y]==0){
				vis[pp.x][pp.y]=1;
				pre[pp.x][pp.y]=i;
				q.push(pp);
			}
		}
	}
}
void path(int x,int y){
	if(x==1&&y==1){
		return;
	}
	path(x-dict[pre[x][y]][0],y-dict[pre[x][y]][1]);//输出时,我们反向寻找,从终点寻找到起点
	cout<<str[pre[x][y]];//递归到起点位置,每次返回上一层时,打印对应操作字符,即又变成从起点到终点的动作
}
int main () {  
    cin>>n>>m;
    getchar();
    for(int i=1;i<=n;i++){
    	for(int j=1;j<=m;j++){
    		cin>>temp[i][j];
		}
		getchar();//详细说明见下面常识二
	}
	bfs();
	path(n,m);
    return 0;  
} 

另外,想在此题下面补充两个常识(其实就是之前忘记的知识点)

常识一:

char str[]="abcd"与char str[]={'a','b','c','d'}一样吗?char str[]="abcd" 等价于 char str[]={'a','b','c','d','\0'},实际上占用5bytes内存。

char str[]={'a','b','c','d'} 占用4bytes内存。

常识二:

getchar()是stdio.h中的库函数,它的作用是从stdin流中读入一个字符,1.从缓冲区读走一个字符,相当于清除缓冲区2.前面的scanf()在读取输入时会在缓冲区中留下一个字符'\n'(输入完s[i]的值后按回车键所致),所以如果不在此加一个getchar()把这个回车符取走的话,gets()就不会等待从键盘键入字符,而是会直接取走这个“无用的”回车符,从而导致读取有误3.getchar()是在输入缓冲区顺序读入一个字符(包括空格、回车和Tab)getchar()使用不方便,解决方法: (1)使用下面的语句清除回车: while(getchar()!='\n'); (2)用getche()或getch()代替getchar(),其作用是从键盘读入一个字符(不用按回车),注意要包含头文件<conio.h>    

然后是关于DFS的一道例题

问题描述

很久以前,T王国空前繁荣。为了更好地管理国家,王国修建了大量的快速路,用于连接首都和王国内的各大城市。

为节省经费,T国的大臣们经过思考,制定了一套优秀的修建方案,使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时,如果不重复经过大城市,从首都到达每个大城市的方案都是唯一的。

J是T国重要大臣,他巡查于各大城市之间,体察民情。所以,从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋,用于存放往来城市间的路费。

聪明的J发现,如果不在某个城市停下来修整,在连续行进过程中,他所花的路费与他已走过的距离有关,在走第x千米到第x+1千米这一千米中(x是整数),他花费的路费是x+10这么多。也就是说走1千米花费11,走2千米要花费23。

J大臣想知道:他从某一个城市出发,中间不休息,到达另一个城市,所有可能花费的路费中最多是多少呢?

输入格式

输入的第一行包含一个整数n,表示包括首都在内的T王国的城市数

城市从1开始依次编号,1号城市为首都。

接下来n-1行,描述T国的高速路(T国的高速路一定是n-1条)

每行三个整数Pi, Qi, Di,表示城市Pi和城市Qi之间有一条高速路,长度为Di千米。

输出格式

输出一个整数,表示大臣J最多花费的路费是多少。

样例输入1
5
1 2 2
1 3 1
2 4 5
2 5 4
样例输出1
135
输出格式

大臣J从城市4到城市5要花费135的路费。

解题思路:其实这是一道非常简单的搜索类型题目,关键点是如何判断出深搜时最长的一条路?其实,像这种题目,是存在一个知识点的,即这题就是让求:树的直径(树上最长的简单路径即为树的直径。求树的直径的方法就是在树上任选一点u,求距离点u最远的点y,再求距离点y最远的点s,点y到点s的距离即为树的直径。)这样,我们很明确得出:树的直径即为最长路径。

另外我们做题之前还要考虑一个经验性问题,就是这个题目,并没有个数据范围,比如:城市数目,即节点数目。所以我们构建图时,需要设定一个范围非常大的图,所以我们要使用邻接表表示图节点之间的联系

附程序代码及重要注释:

#include <iostream>    
#include <cstring>  
#include<vector>
using namespace std;
const int MAX=10005; 
int visit[MAX];
int len,n,st;
struct node{    //构建与某节点相连的节点及权值
	int v,w;
	node(int vv,int ww){
		v=vv;
		w=ww;
	}
};
vector<node> vt[10005];  //将数组定义为10005,基本就满足“很大”这个条件了
void getValue(int len){
	cout<<(10*len+(len*(1+len)/2));
} 
void dfs(int u,int cur){
	if(len<cur){
		len=cur;
		st=u;
	}
	int l=vt[u].size();
	for(int i=0;i<l;i++){
		int v=vt[u][i].v;
		int w=vt[u][i].w;
		if(!visit[v]){
			visit[v]=1;
			dfs(v,cur+w); 
		}
	}
}

int main () {  
    int x,y,z;
    memset(visit,0,sizeof(visit));
    cin>>n;
    for(int i=0;i<n-1;i++){
    	cin>>x>>y>>z;
    	vt[x].push_back(node(y,z)); //无向图,插入两边节点
    	vt[y].push_back(node(x,z));
	}
	len=0;
	visit[1]=1;
	dfs(1,0);
	len=0;
	memset(visit,0,sizeof(visit));//一定要记得清空节点访问记录
	visit[st]=1;
	dfs(st,0);
	getValue(len);
    return 0;  
}  

当然,对于这种初级的dfs,我们也可以改成栈优化的dfs,这里不做介绍,自己可以尝试



阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页