LeetCode解法汇总2596. 检查骑士巡视方案

目录链接：

力扣编程题-解法汇总_分享+记录-CSDN博客

GitHub同步刷题项目：

https://github.com/September26/java-algorithms

原题链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

描述：

骑士在一张 n x n 的棋盘上巡视。在有效的巡视方案中，骑士会从棋盘的 左上角 出发，并且访问棋盘上的每个格子 恰好一次 。

给你一个 n x n 的整数矩阵 grid ，由范围 [0, n * n - 1] 内的不同整数组成，其中 grid[row][col] 表示单元格 (row, col) 是骑士访问的第 grid[row][col] 个单元格。骑士的行动是从下标 0 开始的。

如果 grid 表示了骑士的有效巡视方案，返回 true；否则返回 false。

注意，骑士行动时可以垂直移动两个格子且水平移动一个格子，或水平移动两个格子且垂直移动一个格子。下图展示了骑士从某个格子出发可能的八种行动路线。

示例 1：

输入：grid = [[0,11,16,5,20],[17,4,19,10,15],[12,1,8,21,6],[3,18,23,14,9],[24,13,2,7,22]]
输出：true
解释：grid 如上图所示，可以证明这是一个有效的巡视方案。

示例 2：

{
public:
    vector> forwards = {
        {2, 1},
        {2, -1},
        {1, 2},
        {1, -2},
        {-2, 1},
        {-2, -1},
        {-1, 2},
        {-1, -2}};
    pair jumpStep(vector> &grid, int current, int x, int y)
    {

        for (vector forward : forwards)
        {
            int newX = x + forward[0];
            int newY = y + forward[1];
            if (newX < 0 || newX >= grid.size() || newY < 0 || newY >= grid.size())
            {
                continue;
            }
            if (grid[newY][newX] != (current + 1))
            {
                continue;
            }
            return make_pair(newX, newY);
        }
        return make_pair(0, 0);
    }

    bool checkValidGrid(vector> &grid)
    {
        int i = 0;
        pair postion = {0, 0};
        while (i < grid.size() * grid.size() - 1)
        {
            postion = jumpStep(grid, i, postion.first, postion.second);
            if (postion.first == 2 && postion.second == 3)
            {
                cout << "x" << endl;
            }
            if (postion.first == 0 && postion.second == 0)
            {
                return false;
            }
            i++;
        }
        return true;
    }
};

输入：grid = [[0,3,6],[5,8,1],[2,7,4]]
输出：false
解释：grid 如上图所示，考虑到骑士第 7 次行动后的位置，第 8 次行动是无效的。

提示：

• n == grid.length == grid[i].length
• 3 <= n <= 7
• 0 <= grid[row][col] < n * n
• grid 中的所有整数 互不相同

解题思路：

* 解题思路：

* 定义jumpStep方法，这个方法输入x,y坐标，以及当前是第几步，然后以当前坐标搜索周边8个点，如果有满足的则返回搜索到的坐标。

* 然后使用新坐标进行下一轮搜索，这时候步数+1，

代码：

{
public:
    vector> forwards = {
        {2, 1},
        {2, -1},
        {1, 2},
        {1, -2},
        {-2, 1},
        {-2, -1},
        {-1, 2},
        {-1, -2}};
    pair jumpStep(vector> &grid, int current, int x, int y)
    {

        for (vector forward : forwards)
        {
            int newX = x + forward[0];
            int newY = y + forward[1];
            if (newX < 0 || newX >= grid.size() || newY < 0 || newY >= grid.size())
            {
                continue;
            }
            if (grid[newY][newX] != (current + 1))
            {
                continue;
            }
            return make_pair(newX, newY);
        }
        return make_pair(0, 0);
    }

    bool checkValidGrid(vector> &grid)
    {
        int i = 0;
        pair postion = {0, 0};
        while (i < grid.size() * grid.size() - 1)
        {
            postion = jumpStep(grid, i, postion.first, postion.second);
            if (postion.first == 2 && postion.second == 3)
            {
                cout << "x" << endl;
            }
            if (postion.first == 0 && postion.second == 0)
            {
                return false;
            }
            i++;
        }
        return true;
    }
};