1197. 进击的骑士

1197. 进击的骑士

一个坐标可以从 -infinity 延伸到 +infinity 的 无限大的 棋盘上，你的 骑士 驻扎在坐标为 [0, 0] 的方格里。

骑士的走法和中国象棋中的马相似，走 “日” 字：即先向左（或右）走 1 格，再向上（或下）走 2 格；或先向左（或右）走 2 格，再向上（或下）走 1 格。

每次移动，他都可以按图示八个方向之一前进。

返回 骑士前去征服坐标为 [x, y] 的部落所需的最小移动次数 。本题确保答案是一定存在的。

 

示例 1：

输入：x = 2, y = 1
输出：1
解释：[0, 0] → [2, 1]

示例 2：

输入：x = 5, y = 5
输出：4
解释：[0, 0] → [2, 1] → [4, 2] → [3, 4] → [5, 5]

 

提示：

• -300 <= x, y <= 300
• 0 <= |x| + |y| <= 300

#include <iostream>
#include <unordered_map>
#include <vector>
#include <queue>
using namespace std;

// 骑士走的8个方向
constexpr int g_direction[8][2] = {{1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}};
// 棋盘最大边界值
class Solution {
public:
    bool isInvalidPosition(int x, int y, int edgeX, int edgeY) {
        if ((x >= 0 && x < edgeX) &&(y >= 0 && y < edgeY)) {
            return true;
        }
        return false;
    }
    int minKnightMoves(int x, int y) {
        // 考虑到四个象限内位置对称,都映射到第一象限正数处理
        x = abs(x);
        y = abs(y);
        // 标记位置是否走过,这里数组定义大点
        int m = x + 20;
        int n = y + 20;
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        // 考虑到边界处理,目的坐标位置向外偏移10
        x += 10;
        y += 10;

        queue<std::pair<int, int>> q; // pair对为(x, y)
        // 起始位置入队列
        q.push(make_pair(10, 10));
        visited[10][10] = true;
        int step = 0;
        while (!q.empty()) {
            int size = q.size();
            while (size--) {
                int nowX = q.front().first;
                int nowY = q.front().second;
                q.pop();
                if (nowX == x && nowY == y) {
                    return step;
                }
                // 向8个方向移动
                for (int i = 0; i < 8; i++) {
                    int nextX = nowX + g_direction[i][0];
                    int nextY = nowY + g_direction[i][1];
                    if (isInvalidPosition(nextX, nextY, m, n) && (!visited[nextX][nextY])) {
                        q.push(make_pair(nextX, nextY));
                        visited[nextX][nextY] = true;
                    }
                }
            }
            step++;
        }
        return -1;
    }
};

int main()
{
    Solution *test = new Solution();
    int x = 2;
    int y = 112;
    cout << test->minKnightMoves(x, y) << endl;
    system("pause");
    return 0;
}

 采用结构体保存骑士走的位置和步骤：

// 保存骑士走的位置和步数
struct Position {
    int x;
    int y;
    int step;
};
// 骑士走的8个方向
constexpr int g_direction[8][2] = {{1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}};
class Solution {
public:
    bool isInvalidPosition(int x, int y, int edgeX, int edgeY) {
        if ((x >= 0 && x < edgeX) &&(y >= 0 && y < edgeY)) {
            return true;
        }
        return false;
    }
    int minKnightMoves(int x, int y) {
        // 考虑到四个象限内位置对称,都映射到第一象限正数处理
        x = abs(x);
        y = abs(y);
        // 标记位置是否走过,这里数组定义大点
        int m = x + 20;
        int n = y + 20;
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        // 考虑到边界处理,目的坐标位置向外偏移10
        x += 10;
        y += 10;

        queue<Position> q;
        Position start;
        start.x = 10;
        start.y = 10;
        start.step = 0;
        // 起始位置入队列
        q.push(start);
        visited[start.x][start.y] = true;
        while (!q.empty()) {
            Position now = q.front();
            q.pop();
            // 如果到达终点,则返回走的步数
            if (now.x == x && now.y == y)
            {
                return now.step;
            }
            // 如果尚未到终点,则将8个方向移动一步后加入待处理队列
            for (int i = 0; i < 8; i++) {
                Position next;
                next.x = now.x + g_direction[i][0];
                next.y = now.y + g_direction[i][1];
                if (!isInvalidPosition(next.x, next.y, m, n)) {
                    continue;
                }
                if (visited[next.x][next.y]) {
                    continue;
                }
                next.step = now.step + 1;
                q.push(next);
                visited[next.x][next.y] = true;
            }
        }
        return -1;
    }
};