This post is written in Chinese. Please consider using Google Translate

跳马问题的变化版，广度优先搜索。

从原点开始，每个点搜索8个方向的点，搜索到目标点时的步数最少。

#include <iostream>
#define MAX 31

using namespace std;

typedef struct
{
    int x,y;
}point;

class tQueue
{
public:
    class linklist
    {
    public:
        linklist* next;
        point value;
        linklist()
        {
            next=0;
        }
    };
    linklist *first,*last;
    int size;
    void add(point p)
    {
        if (size==0)
            first=last=new linklist;
        else
            last=last->next=new linklist;
        last->value=p;
        size++;
    }
    point del()
    {
        point rtn=first->value;
        linklist *tfirst=first;
        first=first->next;
        delete tfirst;
        size--;
        return rtn;
    }
    void reset()
    {
        size=0;
        first=last=0;
    }
    tQueue()
    {
        reset();
    }
};

int N,M,X,Y,Ans;
int dx[8],dy[8];
bool map[MAX][MAX];
int step[MAX][MAX];
point S,T;
tQueue Q;

void init()
{
    int i,j,c;
    freopen("bronlily.in","r",stdin);
    freopen("bronlily.out","w",stdout);
    cin >> N >> M >> X >> Y;
    for (i=1;i<=N;i++)
    {
        for (j=1;j<=M;j++)
        {
            cin >> c;
            if (c==1 || c==4)
                map[i][j]=true;
            if (c==3)
                S.x=i,S.y=j;
            if (c==4)
                T.x=i,T.y=j;
        }
    }
    dx[0]=-X; dy[0]=-Y;
    dx[1]=-X; dy[1]= Y;
    dx[2]= X; dy[2]=-Y;
    dx[3]= X; dy[3]= Y;
    dx[4]=-Y; dy[4]=-X;
    dx[5]=-Y; dy[5]= X;
    dx[6]= Y; dy[6]=-X;
    dx[7]= Y; dy[7]= X;
}

inline bool inrange(point p)
{
    return p.x>=1 && p.x <=N && p.y >=1 && p.y<=M;
}

int bfs()
{
    int k;
    point i,j;
    Q.add(S);
    while (Q.size)
    {
        i=Q.del();
        for (k=0;k<8;k++)
        {
            j.x=i.x+dx[k];
            j.y=i.y+dy[k];
            if (inrange(j) && map[j.x][j.y] && step[j.x][j.y]==0)
            {
                step[j.x][j.y]=step[i.x][i.y] + 1;
                if (j.x==T.x && j.y==T.y)
                    return step[j.x][j.y];
                Q.add(j);
            }
        }
    }
}

int main()
{
    init();
    Ans=bfs();
    cout << Ans << endl;
    return 0;
}

<a href="http://www.ruvtex.cn/wiki/USACOMonthly/2007_02_B/Bronze_Lilypad_Pond/Chinese">青铜莲花池</a>

译 By BYVoid

描述

Farmer John 建造了一个美丽的池塘，用于让他的牛们审美和锻炼。这个长方形的池子被分割成了 M 行和 N 列( 1 ≤ M ≤ 30 ; 1 ≤ N ≤ 30 ) 正方形格子的 。某些格子上有惊人的坚固的莲花，还有一些岩石，其余的只是美丽，纯净，湛蓝的水。

贝茜正在练习芭蕾舞，她从一个莲花跳跃到另一个莲花，当前位于一个莲花。她希望在莲花上一个一个的跳，目标是另一个给定莲花。她能跳既不入水，也不到一个岩石上。

令门外汉惊讶的是，贝茜的每次的跳跃像国际象棋中的骑士一样：横向移动M1(1 ≤M1 ≤ 30 )，纵向移动然后量M2 (1 ≤M2 ≤ 30 ;M1 ≠ M2 ) ，或纵向移动然后量M1，横向移动M2。贝茜有时可能会有多达8个选择的跳跃。

给定池塘的布局和贝茜的跳跃格式，请确定贝茜从从她的出发位置，到最终目的地，最小的跳跃次数，贝茜在给出测试数据一定可以跳到目的地。

输入

    * 第 1 行: 四个用空格隔开的整数: M, N, M1, M2
    * 第 2..M + 1 行: 第 i + 1 行 有 N 个整数，表示该位置的状态: 0 为水; 1 为莲花; 2 为岩石; 3 为贝茜开始的位置; 4 为贝茜要去的目标位置. 

输出

    * 第 1 行: 一个整数，从起始点到要去的位置，贝茜最小的跳跃次数。 

样例输入

4 5 1 2
1 0 1 0 1
3 0 2 0 4
0 1 2 0 0
0 0 0 1 0

样例输出

2

输入解释

贝茜从第2行第1个位置开始，她的目标在第2行最右边。几个

输出解释

贝茜聪明地跳跃到了第1行第3个位置，然后就到了目的地。