HDOJ1010 Tempter of the Bone[DFS+奇偶剪枝]

HDOJ1010

题目

思路
一般BFS用于求最短路，想求全部解可以用DFS。因此本题用DFS求解。我根据之前上课老师给的DFS模板直接修改的，改的地方不是很多。
1.DFS里return true的条件
原本是now等于终点就可以了。现在不仅要等于终点，还要时间上相等
2.迷宫表示问题
原来0代表可走，1代表不可走。现在.代表可走，X代表不可走

代码

#include <iostream>
#include <cstdlib>
using namespace std;

int T;
const int MAX_SIZE = 10;

struct Pos
{
    int x, y;
    int time;
    bool operator == (const Pos & rhs) const
    {
        return x == rhs.x && y == rhs.y;
    }
    bool operator != (const Pos & rhs) const
    {
        return !(*this == rhs);
    }
};

bool inside_judge(const Pos & pos, int n, int m)
{
    return 0 <= pos.x && pos.x < n && 0 <= pos.y && pos.y < m;
}

bool dfs(const Pos & now, const Pos & sink, int n, int m, char maze[][MAX_SIZE])
{
    if (now == sink&&now.time == T) 
    {
        return true;
    }
    const int dir[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
    for (int ind = 0; ind < 4; ++ind) 
    {
        Pos next = now;
        next.x += dir[ind][0];
        next.y += dir[ind][1];
        if (inside_judge(next, n, m) && '.' == maze[next.x][next.y]) 
        {
            maze[next.x][next.y] = 'X';
            next.time = now.time+1;
            if (dfs(next, sink, n, m, maze)) 
            {
                return true;
            }
            maze[next.x][next.y] = '.';
            }
    }
    return false;
}

void incubate(int n, int m, int T)
{
    char maze[MAX_SIZE][MAX_SIZE];
    Pos src, sink;
    bool ans;
    for (int i = 0; i < n; ++i) 
    {
        for (int j = 0; j < m; ++j) 
        {
            cin >> maze[i][j]; 
            if(maze[i][j]=='S')
            {
                   src.x = i;
                   src.y = j;
                   maze[i][j] = 'X';
            }
            if(maze[i][j]=='D')
            {
                   sink.x = i;
                   sink.y = j;
                   maze[i][j] = '.';
            }
       }   
    }
    if((abs(sink.x-src.x)+abs(sink.y-src.y))%2==T%2)        //奇偶剪枝
    {
        ans = dfs(src, sink, n, m, maze);
        if (ans) 
        {
            cout << "YES" << endl;
        }
        else
        {
            cout << "NO" << endl;
        }
    } 
    else
    {
        cout << "NO" << endl;
    } 
    return ;
}

int main()
{
    int n, m;
    while(cin>>n>>m&&!(n==0&&m==0))
    {
        cin>>T; 
        incubate(n, m, T);
    }
} 

Conclusion
学习了搜索中的小技巧——奇偶剪枝。
最短距离 = 起点终点横坐标差的绝对值+起点终点纵坐标差的绝对值
如果给定的步骤与最短距离奇偶性不一致，直接可以判定走不到。这样减少了调用dfs搜索的时间。