走迷宫1

走迷宫1

Time Limit: 1000ms

Memory Limit: 65535KB

64-bit integer IO format:  %lld      Java class name:  Main

Prev  Submit  Status  Statistics  Discuss  Next

Font Size:  +   -

Type: 

  None

  Graph Theory

      2-SAT

      Articulation/Bridge/Biconnected Component

      Cycles/Topological Sorting/Strongly Connected Component

      Shortest Path

          Bellman Ford

          Dijkstra/Floyd Warshall

      Euler Trail/Circuit

      Heavy-Light Decomposition

      Minimum Spanning Tree

      Stable Marriage Problem

      Trees

      Directed Minimum Spanning Tree

      Flow/Matching

          Graph Matching

              Bipartite Matching

              Hopcroft–Karp Bipartite Matching

              Weighted Bipartite Matching/Hungarian Algorithm

          Flow

              Max Flow/Min Cut

              Min Cost Max Flow

  DFS-like

      Backtracking with Pruning/Branch and Bound

      Basic Recursion

      IDA* Search

      Parsing/Grammar

      Breadth First Search/Depth First Search

      Advanced Search Techniques

          Binary Search/Bisection

          Ternary Search

  Geometry

      Basic Geometry

      Computational Geometry

      Convex Hull

      Pick's Theorem

  Game Theory

      Green Hackenbush/Colon Principle/Fusion Principle

      Nim

      Sprague-Grundy Number

  Matrix

      Gaussian Elimination

      Matrix Exponentiation

  Data Structures

      Basic Data Structures

      Binary Indexed Tree

      Binary Search Tree

      Hashing

      Orthogonal Range Search

      Range Minimum Query/Lowest Common Ancestor

      Segment Tree/Interval Tree

      Trie Tree

      Sorting

      Disjoint Set

  String

      Aho Corasick

      Knuth-Morris-Pratt

      Suffix Array/Suffix Tree

  Math

      Basic Math

      Big Integer Arithmetic

      Number Theory

          Chinese Remainder Theorem

          Extended Euclid

          Inclusion/Exclusion

          Modular Arithmetic

      Combinatorics

          Group Theory/Burnside's lemma

          Counting

      Probability/Expected Value

  Others

      Tricky

      Hardest

      Unusual

      Brute Force

      Implementation

      Constructive Algorithms

      Two Pointer

      Bitmask

      Beginner

      Discrete Logarithm/Shank's Baby-step Giant-step Algorithm

      Greedy

      Divide and Conquer

  Dynamic Programming

                      Tag it!

走迷宫是很有趣的一种游戏,能够锻炼人的记忆力和思维.现在,HK被困在一个迷宫里面了,请你帮助他找到一条最短的路径,能够让他走出迷宫.

迷宫使用一个N*M的矩阵来描述,矩阵中用'.'代表空格可以通行,用'*'代表障碍物,用'S'代表出发点,用'T'代表出口.例如下面的一个矩阵就描述了一个8*8的迷宫

.....T..
..*****.
......*.
*.***.*.
......*.
.****.*.
S..*....
........

每个字符代表1个格子,HK只能在格子间按上下左右的方向移动

Input

每个输入文件只包含一组输入数据.
每组数据第一行是两个正整数N和M(N,M<=100).
接着是一个N*M的矩阵.

Output

如果HK能够走出迷宫,输出最少需要的步数;否则输出-1.

Sample Input

8 8
.....T..
..*****.
......*.
*.***.*.
......*.
.****.*.
S..*....
........

Sample Output

11

Source

第七届北京师范大学程序设计竞赛热身赛第五场

Author

HK@Sphinx

Tags ( Click to see )

Prev  Submit  Status  Statistics  Discuss  Next

裸BFS

#include"queue"
#include"cstdio"
#include"cstring"
#include"iostream"
#include"algorithm"

using namespace std;

char maze[105][105];

int N,M;
int move[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
bool vis[105][105];

bool is_block(int x,int y)
{
    if(x<0 || x>=N || y<0 || y>=M)
    {
        return true;
    }
    if(maze[x][y] == '*')
    {
        return true;
    }
    return false;
}

struct node
{
    int x,y,step;
};

queue <node> q;

int bfs(int x,int y)
{
    while(!q.empty())
    {
        q.pop();
    }
    node now;
    now.x = x;
    now.y = y;
    now.step = 0;
    vis[x][y] = true;
    q.push(now);
    while(!q.empty())
    {
        node nnew = q.front();
        q.pop();
        if(maze[nnew.x][nnew.y] == 'T')
        {
            return nnew.step;
        }
        for(int i = 0;i < 4;i++)
        {
            int xx = nnew.x + move[i][0];
            int yy = nnew.y + move[i][1];
            if(!is_block(xx,yy) && !vis[xx][yy])
            {
                node n;
                n.x = xx;
                n.y = yy;
                n.step = nnew.step + 1;
                vis[xx][yy] = true;
                q.push(n);
            }
        }
    }
    return -1;
}

int main()
{
    while(~scanf("%d%d",&N,&M))
    {
        for(int i = 0;i < N;i++)
        {
            scanf("%s",maze[i]);
        }
        memset(vis,false,sizeof(vis));
        for(int i = 0;i < N;i++)
        {
            for(int j = 0;j < M;j++)
            {
                if(maze[i][j] == 'S')
                {
                    printf("%d\n",bfs(i,j));
                    break;
                }
            }
        }
    }
    return 0;
}