CSP-homework Week2 Problem A 签到BFS--找妹子

原题叙述

题目叙述

东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线。

INPUT

输入是一个5 × 5的二维数组，仅由0、1两数字组成，表示法阵地图。

OUTPUT

输出若干行，表示从左上角到右下角的最短路径依次经过的坐标，格式如样例所示。数据保证有唯一解。

输入样例

0 1 0 0 0
0 1 0 1 0
0 1 0 1 0
0 0 0 1 0
0 1 0 1 0

输出样例

(0, 0)
(1, 0)
(2, 0)
(3, 0)
(3, 1)
(3, 2)
(2, 2)
(1, 2)
(0, 2)
(0, 3)
(0, 4)
(1, 4)
(2, 4)
(3, 4)
(4, 4)

问题重述

就是个简单的迷宫问题，找一条最短路，记录下走的路径，因为是要求最短路径，那最省事就是BFS。

解题思路

思路概述

BFS部分就是赤裸裸的BFS板子，处理都不大用处理的，用个二维数组vis[][]存下来,不能访问的地方标-2，能够访问的地方标-1，访问之后正数代表距离出发点的距离就可以了。
需要注意的是输出方案部分的选择，解题的时候我是比较倾向于写递归来输出的，但可能当时脑子昏昏的，输出总是乱掉，干脆开了个vector<struct point>
，用二维数组 struct dis[][]来存放某个点的来路，然后在print()函数里倒序处理下就好了，虽然空间费得多，但是解题的时候不用思考递归边界也还算可行。
递推版print()函数见下

point dis[maxn][maxn];
vector<point> v;
void print(point &p)
{
	point target=p;
	v.push_back(p);
	while(target.x!=0 | target.y!=0)
	{
		target=dis[target.x][target.y];
		v.push_back(target);
	}
	for(int i=v.size()-1;i>=0;i--)
	{
		printf("(%d, %d)\n",v[i].x,v[i].y);
	}
}

后来发现自己的递归数组写错了(蠢哭.jpg）,递归的写法更具有编程之美，脑子清醒的话还是更可行的写法
递归版的print()如下

point dis[maxn][maxn];
vector<point> v;
void print(point &p)
{
    point target=p;
    if(target.x==0 && target.y==0)
    {
        printf("(%d, %d)\n",target.x,target.y);
        return;
    }
    print(dis[target.x][target.y]);
    printf("(%d, %d)\n",target.x,target.y);
}

数据存储

本题中用到的数据和存储方式

类型名和变量名	实际意义
int dx[],dy[]	偏移量数组
int vis[][]	某点距离原点的距离
struct point dis[][]	某点在BFS过程中的来路

总结

比较水的一道签到题，注意好格式不出现PE，基本上就不会出错。

改进点

针对这道题暂无。

题目源码

#include<iostream>
#include<queue>
#include<stdio.h>
#include<string.h>
#include<map>
#include<vector>
using namespace std;
struct point
{
    /* data */
    int x;
    int y; 
};
const int maxn=10;
int dx[]={+1,-1,0,0};
int dy[]={0,0,+1,-1};
int vis[maxn][maxn];
point dis[maxn][maxn];
vector<point> v;
void print(point &p)
{
	point target=p;
	v.push_back(p);
	while(target.x!=0 | target.y!=0)
	{
		target=dis[target.x][target.y];
		v.push_back(target);
	}
	for(int i=v.size()-1;i>=0;i--)
	{
		printf("(%d, %d)\n",v[i].x,v[i].y);
	}
}
void bfs(int sx,int sy,int tx,int ty)
{
	point target={tx,ty};
    point the_begin={sx,sy};
    queue<point> Q;
    Q.push(the_begin);
    vis[sx][sy]=0;
    while(!Q.empty()){
        point now=Q.front(); Q.pop();
        if(now.x==tx &&now.y==ty)
        print(target);
        for(int i=0;i<4;i++){
            int newx=now.x+dx[i],
                newy=now.y+dy[i];
                point start={now.x,now.y};
                point finish={newx,newy};
                if(newx>=0 && newx<=4 && newy>=0 && newy<=4 && vis[newx][newy]==-1){
                	vis[newx][newy]=vis[now.x][now.y]+1;
                    Q.push(finish);
                    dis[newx][newy]=start;
            }
        }
    }
}
int main()
{
    memset(vis,-1,sizeof(vis));
    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            int number=0;
            cin>>number;
            if(number==1)
            {
                vis[i][j]=-2;
            }
        }
    }
	bfs(0,0,4,4);
    return 0;
}