POJ 1736 Robot BFS

Robot

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 7561		Accepted: 2444

Description

The Robot Moving Institute is using a robot in their local store to transport different items. Of course the robot should spend only the minimum time necessary when travelling from one place in the store to another. The robot can move only along a straight line (track). All tracks form a rectangular grid. Neighbouring tracks are one meter apart. The store is a rectangle N x M meters and it is entirely covered by this grid. The distance of the track closest to the side of the store is exactly one meter. The robot has a circular shape with diameter equal to 1.6 meter. The track goes through the center of the robot. The robot always faces north, south, west or east. The tracks are in the south-north and in the west-east directions. The robot can move only in the direction it faces. The direction in which it faces can be changed at each track crossing. Initially the robot stands at a track crossing. The obstacles in the store are formed from pieces occupying 1m x 1m on the ground. Each obstacle is within a 1 x 1 square formed by the tracks. The movement of the robot is controlled by two commands. These commands are GO and TURN. 
The GO command has one integer parameter n in {1,2,3}. After receiving this command the robot moves n meters in the direction it faces. 

The TURN command has one parameter which is either left or right. After receiving this command the robot changes its orientation by 90o in the direction indicated by the parameter. 

The execution of each command lasts one second. 

Help researchers of RMI to write a program which will determine the minimal time in which the robot can move from a given starting point to a given destination. 

Input

The input consists of blocks of lines. The first line of each block contains two integers M <= 50 and N <= 50 separated by one space. In each of the next M lines there are N numbers one or zero separated by one space. One represents obstacles and zero represents empty squares. (The tracks are between the squares.) The block is terminated by a line containing four positive integers B1 B2 E1 E2 each followed by one space and the word indicating the orientation of the robot at the starting point. B1, B2 are the coordinates of the square in the north-west corner of which the robot is placed (starting point). E1, E2 are the coordinates of square to the north-west corner of which the robot should move (destination point). The orientation of the robot when it has reached the destination point is not prescribed. We use (row, column)-type coordinates, i.e. the coordinates of the upper left (the most north-west) square in the store are 0,0 and the lower right (the most south-east) square are M - 1, N - 1. The orientation is given by the words north or west or south or east. The last block contains only one line with N = 0 and M = 0. 

Output

The output contains one line for each block except the last block in the input. The lines are in the order corresponding to the blocks in the input. The line contains minimal number of seconds in which the robot can reach the destination point from the starting point. If there does not exist any path from the starting point to the destination point the line will contain -1. 

Sample Input

9 10
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 1 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 1 0
7 2 2 7 south
0 0

Sample Output

12

　　题目大意：给一个图，然后给你起点和终点，以及开始所处的方向，要求你求出从起点到终点的最小步数，如果无法到达则输出-1。这个题注意有4点：

　　1、它一秒可以执行2种命令，一种是向现在所面向的方向走1-3步，另外一种是向左或向右90度转向（不能向后转）。

　　2、图中为1的是障碍物，是不允许通过的，包括边界也不能允许，这一点需要注意下。

　　题目分析：这道题就是简单BFS,  有五种转变方式， 走1步， 走2步， 走三步， 向左转， 向右转， 将这五种状态分别推入队列BFS,  记住当走一步都超出边界的时候， 再多走肯定超出边界，

　可以break掉。然后就是细节的问题了， 就是说做这种题如何快速简单的建模非常重要， 将题意转化成好的程序语言表达方式， 这点需要靠多多做题来巩固。

　　代码：

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <string>
#include <algorithm>
using namespace std;

struct Node {
    int x;
    int y;
    int time;
    int pos;
};
int m, n;
int map[100][100];
int vis[100][100][5];
int B1, B2, E1, E2;
int dx[4] = { -1, 0, 1, 0 };
int dy[4] = { 0, 1, 0, -1 };
string original_position;
queue<Node> Q;

int getPos( string str ) {
    if( str == "north" ) return 0;
    else if( str == "east" ) return 1;
    else if( str == "south" ) return 2;
    return 3;
}

bool canGo( int x, int y ) {
    if( x < 1 || x >= n || y < 1 || y >= m ) return false;
    if( map[x][y] || map[x+1][y] || map[x][y+1] || map[x+1][y+1] ) {
        return false;
    }
    return true;
}

int bfs() {
    Node start;
    start.x = B1;
    start.y = B2;
    start.time = 0;
    start.pos = getPos( original_position );
    Q.push( start );
    vis[start.x][start.y][start.pos] = 1;
    while( !Q.empty() ) {
        
        Node vn = Q.front();
        Q.pop();
        
        int x = vn.x;
        int y = vn.y;
        int time = vn.time;
        int pos = vn.pos;
        if( x == E1 && y == E2 ) return time;
        for( int i = 1; i <= 3; i++ ) {
            x += dx[vn.pos];
            y += dy[vn.pos];
            if( !canGo( x, y ) ) {
                break;
            }
            
            if( !vis[x][y][vn.pos] ) {
                Node next;
                next.x = x;
                next.y = y;
                next.pos = vn.pos;
                next.time = time + 1;
                vis[next.x][next.y][next.pos] = 1;
                Q.push( next );
            }
        }
        for( int i = 0; i < 4; i++ ) {
            if( max( pos, i ) - min( pos, i ) == 2 ) {
                continue;
            }
            if( vis[vn.x][vn.y][i] ) continue;
            Node next;
            next.x = vn.x;
            next.y = vn.y;
            next.pos = i;
            next.time = time + 1;
            vis[next.x][next.y][next.pos] = 1;
            Q.push( next );
        }
        
    }
    return -1;
}

int main() {
    while( cin >> n >> m && ( n || m ) ) {
        while( !Q.empty() ) Q.pop();
        memset( map, 0, sizeof( map ) );
        memset( vis, 0, sizeof( vis ) );
        for( int i = 1; i <= n; i++ ) {
            for( int j = 1; j <= m; j++ ) {
                cin >> map[i][j];
            }
        }
        cin >> B1 >> B2 >> E1 >> E2 >> original_position;
        cout << bfs() << endl;
    }
    return 0;
}

View Code

 

　　最近很少写博客了， 注重思维多刷题， 不要懈怠啊， 人一我十， 人十我万！

转载于:https://www.cnblogs.com/FriskyPuppy/p/6031842.html