poj 3083

题目大意：给一个迷宫，要你分别求出按先考虑左边的方向，和先考虑右边方向走出迷宫所经过的格子，还有走出迷宫经过的最少格子

解题思路：题目不难，比较繁琐，就是深度优先左边遍历和深度优先右边遍历还有就是广度优先遍历迷宫

深度优先遍历和宽度优先遍历时，要区分从上一个格子过来的方向来判断下一个格子的左边右边是哪个格子

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;


#define left 0
#define up 1
#define right 2
#define down 3

const int maxn = 41;

struct Point
{
    int x, y;
};

struct node
{
	int x, y, layer, dir;
};

char maze[maxn][maxn];
int n, w, h, step;
bool graph[maxn][maxn];
Point s, e;
Point dir[4] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};

int dfs(int x, int y, bool flag, int d);
int bfs(int x, int y, int d);

int main()
{
    
    int d;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        memset(graph, 0, sizeof(graph));
        scanf("%d %d", &w, &h);
        for(int j = 0; j < h; j++)
        {
            char *p;
            scanf("%s", maze[j]);
            if((p = strchr(maze[j], 'S')) != NULL)
            {
                s.x = j;
                s.y = p - maze[j];
                if(s.x == 0)
                    d = down;
                else if(s.x == h - 1)
                    d = up;
                else if(s.y == 0)
                    d = right;
                else
                    d = left;
            }
            if((p = strchr(maze[j], 'E')) != NULL)
            {
                e.x = j;
                e.y = p - maze[j];
            }
        }
        
        int step_l = 0, step_r = 0, step = 0;
        
        step_l = dfs(s.x, s.y, true, d);
        step_r = dfs(s.x, s.y, false, d);
        
        step = bfs(s.x, s.y, d);
        printf("%d %d %d\n", step_l, step_r, step);
        
    }
    
    return 0;
}

int dfs(int x, int y, bool flag, int d)
{
    int index, start = 0;
    if(maze[x][y] == 'E')
        return 1;
        
    if(flag)
    {
        switch(d)
        {
            case left:
                d = down;
                start = 3;
                break;
            case up:
                d = left;
                start = 0;
                break;
            case right:
                d = up;
                start = 1;
                break;
            case down:
                d = right;
                start = 2;
                break;
            default:
                break;
        }
    }
    else
    {
        switch(d)
        {
            case left:
                d = up;
                start = 1;
                break;
            case up:
                d = right;
                start = 2;
                break;
            case right:
                d = down;
                start = 3;
                break;
            case down:
                d = left;
                start = 0;
                break;
            default:
                break;
        }
    }
    
    for(int i = 0; i < 4; i++)
    {
        if(flag)
            index = start++ % 4;
        else
        {
            index = start;
            start = (4 + start - 1) % 4;
        }
        
        int dx = x + dir[index].x;
        int dy = y + dir[index].y;
        
        if(dx >= 0 && dx < h && dy >= 0 && dy < w && maze[dx][dy] != '#')
            return 1 + dfs(dx, dy, flag, d);
            
        if(flag)
			d = (++d) % 4;
		else
			d = (4 + d - 1) % 4;
    }
    return 0;
}

int bfs(int x, int y, int d)
{
    queue<node> q;
    node s;
    s.x = x; s.y = y;
    s.layer = 1; s.dir = d;
    if(maze[x][y] == 'E')
        return 1;
    graph[x][y] = true;
    q.push(s);
    while(!q.empty())
    {
        node t = q.front();
        q.pop();
        if(maze[t.x][t.y] == 'E')
            return t.layer;
        int start = 0;
        switch(t.dir)
        {
            case left:
                d = down;
                start = 3;
                break;
            case up:
                d = left;
                start = 0;
                break;
            case right:
                start = 1;
                d = up;
                break;
            case down:
                start = 2;
                d = right;
                break;
            default:
                break;
        }
        for(int i = 0; i < 3; i++)
        {
            int index = start++ % 4;
            int dx = t.x + dir[index].x;
            int dy = t.y + dir[index].y;
            if(dx >= 0 && dx < h && dy >= 0 && dy < w && maze[dx][dy] != '#' && !graph[dx][dy])
            {
                node tmp;
                tmp.x = dx; tmp.y = dy;
                tmp.layer = t.layer + 1;
                tmp.dir = d;
                graph[dx][dy] = true;
                q.push(tmp);
            }
            d = ++d % 4;
        }
    }
    return 0;
}