POJ 3009 Curling 2.0

题目链接：https://vjudge.net/problem/POJ-3009

题目大意：

　　冰壶比赛。

给定一个 n * m 的矩阵A，其中：

1. A[i][j] == 0，代表通路。
2. A[i][j] == 1，代表冰块。
3. A[i][j] == 2，代表冰壶起点。
4. A[i][j] == 3，代表冰壶所要到达的点。

冰壶只能往上下左右四个方向移动，且碰到冰块才会停下来，同时冰块也会碎掉，冰壶也随之停在原地，冰壶一旦打出界，比赛就结束了，冰壶只要在10步以内经过终点，就算成功。

求每场冰壶比赛的最小移动步数。

分析：

　　dfs基础题，读懂题目最重要。

代码如下：

//#include <bits/stdc++.h>

// POJ 用 start 
#include<cstdio>  
#include<cstring>  
#include<algorithm>  
#include<iostream>  
#include<string>  
#include<vector>  
#include<stack>  
#include<bitset>  
#include<cstdlib>  
#include<cmath>  
#include<set>  
#include<list>  
#include<deque>  
#include<map>  
#include<queue>  
// POJ 用 end 

using namespace std;

/*-------------------Define Start-------------------*/
typedef bool BL;                        // 布尔类型
typedef char SB;                        // 有符号1字节,8位
typedef unsigned char UB;                // 无符号1字节,8位
typedef short SW;                        // 有符号短整型,16位
typedef unsigned short UW;                // 无符号短整型,16位
typedef long SDW;                        // 有符号整型,32位
typedef unsigned long UDW;               // 无符号整型,32位
typedef long long SLL;                    // 有符号长整型,64位
typedef unsigned long long ULL;            // 无符号长整型,64位
typedef char CH;                        // 单个字符
typedef float R32;                        // 单精度浮点数
typedef double R64;                        // 双精度浮点数

#define Rep(i, n) for (register SDW i = 0; i < (n); ++i)
#define For(i, s, t) for (register SDW i = (s); i <= (t); ++i)
#define rFor(i, t, s) for (register SDW i = (t); i >= (s); --i)
#define foreach(i, c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
#define ms0(a) memset(a,0,sizeof(a))
#define msI(a) memset(a,0x7f,sizeof(a))
#define LOWBIT(x) ((x)&(-x))

#define MP make_pair
#define PB push_back
#define ft first
#define sd second

#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl

const ULL mod = 1e9 + 7;                //常用模数(可根据题目需要修改)
const ULL inf = 0x7fffffff;                //用来表示无限大
const ULL infLL = 0x7fffffffffffffffLL;    //用来表示无限大
/*-------------------Define End-------------------*/

struct Point{
    SDW X, Y;
    
    Point(SDW x = 0, SDW y = 0) : X(x), Y(y) {}
    
    void set(SDW x, SDW y) {
        X = x;
        Y = y;
    }
    
    Point operator+ (const Point& x) { return Point(X + x.X, Y + x.Y); }
    BL operator== (const Point& x) const { return X == x.X && Y == x.Y; }
    BL operator!= (const Point& x) const { return !(*this == x); }
}; 

const UDW maxN = 2e1 + 7;
SDW N, M;
SDW field[maxN][maxN];
Point S, G;
Point dir[] = {Point(0, -1), Point(-1, 0), Point(0, 1), Point(1, 0)};
SDW ans;

void input(){
    ans = inf;
    Rep(i, N) {
        Rep(j, M) {
            cin >> field[i][j];
            if(field[i][j] == 2) {
                S.set(i, j);
            }
            if(field[i][j] == 3) {
                G.set(i, j);
            }
        }
    }
}

BL isPass(Point x, Point y) {
    if(x.X == y.X) {
        return x.X == G.X && min(x.Y, y.Y) <= G.Y && G.Y <= max(x.Y, y.Y);
    }
    else {
        return x.Y == G.Y && min(x.X, y.X) <= G.X && G.X <= max(x.X, y.X);
    }
} 

// 查找冰壶所能移动到的最左位置 
Point leftMost(Point x) {
    while(x.Y > 0 && field[x.X][x.Y - 1] != 1) {
        --x.Y;
    }
    return x;
}

// 查找冰壶所能移动到的最上位置 
Point upMost(Point x) {
    while(x.X > 0 && field[x.X - 1][x.Y] != 1) {
        --x.X;
    }
    return x;
}

// 查找冰壶所能移动到的最右位置 
Point rightMost(Point x) {
    while(x.Y < M - 1 && field[x.X][x.Y + 1] != 1) {
        ++x.Y;
    }
    return x;
}

// 查找冰壶所能移动到的最下位置 
Point downMost(Point x) {
    while(x.X < N - 1 && field[x.X + 1][x.Y] != 1) {
        ++x.X;
    }
    return x;
}

Point (*func[4])(Point) = {leftMost, upMost, rightMost, downMost};

void dfs(Point p, SDW cnt) {
    if(cnt > 10) {
        return;
    }
    
    Rep(i, 4) {
        Point nextP = func[i](p);        // 冰壶的下一个出发点 
        Point blockP = nextP + dir[i];    // 冰壶撞到的冰块的位置或者边界位置 
        
        if(isPass(p, nextP)) {             // 经过了目标点 
            ans = min(ans, cnt + 1);
            return;
        }
        if(p != nextP && blockP.X >= 0 && blockP.X < N && blockP.Y >= 0 && blockP.Y < M) {
            field[blockP.X][blockP.Y] = 0;
            dfs(nextP, cnt + 1);
            field[blockP.X][blockP.Y] = 1;
        }
    }
}

void solve(){
    dfs(S, 0);
    if(ans > 10) {
        ans = -1;
    }
}

void output(){
    cout << ans << endl;
}

int main() {
    while((cin >> M >> N) && M) {
        input();
        solve();
        output();
    }
    return 0;
}