2026-10-19：偶数次骑士移动。用go语言，给定两个整数数组 start 和 target，分别表示 8×8 标准国际象棋棋盘上的起点格和终点格，坐标形|start|target|余数|国际象棋|整数|移动

2026-10-19：偶数次骑士移动。用go语言，给定两个整数数组 start 和 target，分别表示 8×8 标准国际象棋棋盘上的起点格和终点格，坐标形式都是 [x, y]。要求判断：骑士能否从 start 出发，经过偶数步合法移动后到达 target。若可以，返回 true；若不可以，返回 false。骑士的合法移动方式是：先沿一个方向走两格，再沿与刚才方向垂直的方向走一格。

start.length == target.length == 2。

0 <= start[i], target[i] <= 7。

输入： start = [1,1], target = [2,2]。

输出： true。

解释：

一种可行的移动序列为 (1, 1) -> (3, 2) -> (2, 4) -> (4, 3) -> (2, 2)。

骑士经过 4 次移动到达目标位置，4 是偶数。因此答案为 true。

题目来自力扣3996。

大体步骤如下：

1. 程序首先准备两个长度为 2 的整数数组，分别表示起点start和终点target，每个数组的两个元素就是棋盘上的横、纵坐标。
2. 进入判断函数后，先取起点的两个坐标相加，即计算start[0] + start[1]，再对 2 取余数。这个余数可以理解为起点格子的一种“颜色”或“奇偶属性”：余数为 0 表示坐标和是偶数，余数为 1 表示坐标和是奇数。
3. 然后对终点做同样的处理：计算target[0] + target[1]，再对 2 取余数，得到终点格子的“颜色”或“奇偶属性”。
4. 接着比较起点和终点得到的两个余数是否相等。如果相等，说明起点和终点位于同一种颜色的格子上；如果不相等，说明它们位于不同颜色的格子上。
5. 根据骑士移动规则，骑士每走一步，坐标和的变化量一定是奇数，因此每走一步都会让所在格子的颜色发生翻转。也就是说，走奇数步后颜色会改变，走偶数步后颜色保持不变。
6. 因此，如果起点和终点颜色相同，就可以通过偶数次骑士移动到达；如果颜色不同，就不可能通过偶数次移动到达。代码正是利用这个性质，直接比较起点和终点的坐标和奇偶性。
7. 在示例中，起点是[1, 1]，坐标和为1 + 1 = 2，对 2 取余得到 0；终点是[2, 2]，坐标和为2 + 2 = 4，对 2 取余也得到 0。两者余数相等，所以判断结果为真。
8. 主程序接收这个判断结果，并将其打印出来，因此示例最终输出true。

总的时间复杂度：O(1)。因为只进行了常数次数组访问、加法、取模和比较，没有循环或递归，输入规模固定为两个长度为 2 的数组。

总的额外空间复杂度：O(1)。除了保存起点、终点和结果等常数个变量外，没有使用额外的数据结构；输入数组本身通常不计入额外空间。

Go完整代码如下：

package main

 import (
    "fmt"
)

 func canReach(start, target []int)bool {
    return (start[0]+start[1])%2 == (target[0]+target[1])%2
}

 func main() {
    start := []int{1, 1}
    target := []int{2, 2}
    result := canReach(start, target)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 def can_reach(start, target):
    return (start[0] + start[1]) % 2 == (target[0] + target[1]) % 2

 def main():
    start = [1, 1]
    target = [2, 2]
    result = can_reach(start, target)
    print(result)

 if __name__ == "__main__":
    main()

C++完整代码如下：

  

  


 bool canReach(const std::vector& start, const std::vector& target) {
    return (start[0] + start[1]) % 2 == (target[0] + target[1]) % 2;
}

 int main() {
    std::vector start = {1, 1};
    std::vector target = {2, 2};
    bool result = canReach(start, target);
    std::cout << std::boolalpha << result << std::endl;
    return 0;
}