1
// 依赖：g++ -std=c++17（无第三方库）
2
// 把「格子号 → 世界坐标」抽成唯一入口，棋盘旋转只影响 theta 与 center
3
#include <cmath>
4
#include <cstdio>
5

6
struct Vec2 { double x, y; };
7

8
// 棋盘几何：格子边长 s、中心 center、旋转角 theta（弧度）
10 collapsed lines
9
struct BoardFrame {
10
    Vec2   center{0.0, 0.0};
11
    double s     = 30.0;   // 题目给的格子边长量级
12
    double theta = 0.0;    // 棋盘绕中心旋转角，±45° 内的任意值
13
};
14

15
// 第 1 号与第 3 号方格中心的连线与水平轴夹角 → 棋盘旋转角
16
double solve_theta(Vec2 p1, Vec2 p3) {
17
    return std::atan2(p3.y - p1.y, p3.x - p1.x);
18
}
19

20
// 唯一的坐标入口：row/col 取 1..3
21
Vec2 grid_to_world(const BoardFrame& f, int row, int col) {
22
    const double lx = (col - 2) * f.s;   // 棋盘自身坐标系下的偏移
23
    const double ly = (row - 2) * f.s;
24
    const double c = std::cos(f.theta), sn = std::sin(f.theta);
25
    return Vec2{
26
        f.center.x + c * lx - sn * ly,
27
        f.center.y + sn * lx + c * ly,
28
    };
29
}
30

31
// ⚠️ 早期版本（已废弃）：把 9 个格子的世界坐标写死成一张表。
32
// 棋盘只要一转（theta ≠ 0），这张表整体失准，第 3 项直接零分。
33
// 保留在这里做对照——它就是下面正文里说的「1 号格被算到 (70, 50)」那个版本：
34
// const double GRID[9][2] = {
35
//     { 70,  50}, {100,  50}, {130,  50},
36
//     { 70,  80}, {100,  80}, {130,  80},
37
//     { 70, 110}, {100, 110}, {130, 110},
38
// };
39

40
int main() {
41
    BoardFrame f;
42
    f.center = {100.0, 80.0};
43

44
    // 不加旋转：5 号格应当正好落在棋盘中心
45
    Vec2 a = grid_to_world(f, 2, 2);
46
    std::printf("theta=0    5号格 -> (%.3f, %.3f)\n", a.x, a.y);
47

48
    // 棋盘转 30°：中心仍应在中心，但 1 号格的坐标必须跟着转
49
    f.theta = 30.0 * M_PI / 180.0;
50
    Vec2 b = grid_to_world(f, 2, 2);
51
    Vec2 c = grid_to_world(f, 1, 1);
52
    std::printf("theta=30°  5号格 -> (%.3f, %.3f)\n", b.x, b.y);
53
    std::printf("theta=30°  1号格 -> (%.3f, %.3f)\n", c.x, c.y);
54

55
    // 自检：中心格在任意 theta 下都必须等于棋盘中心（容差 1e-9）
56
    const bool center_ok =
57
        std::fabs(b.x - f.center.x) < 1e-9 && std::fabs(b.y - f.center.y) < 1e-9;
58
    std::printf("中心格不随 theta 漂移: %s\n", center_ok ? "PASS" : "FAIL");
59
    return center_ok ? 0 : 1;
60
}

1
// 依赖：g++ -std=c++17
2
// 极小极大 + Alpha-Beta：三子棋局面数极小，穷举即最优，不需要启发式
3
#include <algorithm>
4
#include <array>
5
#include <cstdio>
6
#include <limits>
7

8
constexpr char EMPTY = '.';
9

10
// 平局打破用：仅在「多个走法分数相同」时生效，不参与胜负判定。
11
// 三子棋的最优结果是平局，所以「好几步分数都一样」是常态，
12
// 需要一个固定偏好让行为可复现（否则会永远选第一个空格）。
13
constexpr int PREF[9] = {2,1,2, 1,3,1, 2,1,2};   // 中心 3 > 角 2 > 边 1
14

6 collapsed lines
15
// 8 条连线：3 行 + 3 列 + 2 斜
16
constexpr int LINES[8][3] = {
17
    {0,1,2},{3,4,5},{6,7,8},
18
    {0,3,6},{1,4,7},{2,5,8},
19
    {0,4,8},{2,4,6},
20
};
21

22
// 返回 +1 机器胜 / -1 人胜 / 0 未结束
23
int winner(const std::array<char,9>& b, char me, char human) {
24
    for (auto& L : LINES) {
25
        if (b[L[0]] != EMPTY && b[L[0]] == b[L[1]] && b[L[1]] == b[L[2]])
26
            return b[L[0]] == me ? +1 : -1;
27
    }
28
    return 0;
29
}
30

31
// 带 Alpha-Beta 的极小极大。depth 只用于在本层内打破平局（越快赢越好）
32
int minimax(std::array<char,9>& b, char cur, char me, char human,
33
            int depth, int alpha, int beta) {
34
    const int w = winner(b, me, human);
35
    if (w != 0) return w * (10 - depth);            // 赢在浅层 = 分数更高
36
    if (std::none_of(b.begin(), b.end(), [](char c){ return c == EMPTY; }))
37
        return 0;                                   // 平局
38

39
    const bool maximizing = (cur == me);
40
    int best = maximizing ? std::numeric_limits<int>::min()
41
                          : std::numeric_limits<int>::max();
42

43
    for (int i = 0; i < 9; ++i) {
44
        if (b[i] != EMPTY) continue;
45
        b[i] = cur;
46
        const int v = minimax(b, cur == me ? human : me, me, human,
47
                              depth + 1, alpha, beta);
48
        b[i] = EMPTY;
49

50
        if (maximizing) {
51
            best  = std::max(best, v);
52
            alpha = std::max(alpha, v);
53
        } else {
54
            best = std::min(best, v);
55
            beta = std::min(beta, v);
56
        }
57
        if (beta <= alpha) break;                   // 剪枝：这一支对手不会走进来
58
    }
59
    return best;
60
}
61

62
// 返回机器的最优落子格（0..8）；棋盘已满返回 -1
63
int best_move(std::array<char,9> b, char me, char human) {
64
    int best_score = std::numeric_limits<int>::min(), best_idx = -1;
65
    for (int i = 0; i < 9; ++i) {
66
        if (b[i] != EMPTY) continue;
67
        b[i] = me;
68
        const int v = minimax(b, human, me, human, 1,
69
                              std::numeric_limits<int>::min(),
70
                              std::numeric_limits<int>::max());
71
        b[i] = EMPTY;
72
        if (best_idx < 0 || v > best_score ||
73
            (v == best_score && PREF[i] > PREF[best_idx])) {
74
            best_score = v;
75
            best_idx   = i;
76
        }
77
    }
78
    return best_idx;
79
}
80

81
int main() {
82
    // 局面 1：机器(X)该走，威胁两条线 → 必须占中心
83
    std::array<char,9> b1 = {
84
        'X','.','.',
85
        '.','.','.',
86
        '.','.','X',
87
    };
88
    std::printf("局面1 机器最优落子: %d（应为中心 4）\n", best_move(b1, 'X', 'O'));
89

90
    // 局面 2：人(O) 已有两子连线威胁第 1 行，机器自己没有立即取胜的走法 → 必须堵
91
    std::array<char,9> b2 = {
92
        'O','O','.',
93
        '.','X','.',
94
        '.','.','X',
95
    };
96
    std::printf("局面2 机器最优落子: %d（应为 2，堵住第 1 行）\n", best_move(b2, 'X', 'O'));
97

98
    // 局面 3：空棋盘先手，所有走法都是平局 → 由 PREF 打破平局，落在中心
99
    std::array<char,9> b3 = {
100
        '.','.','.',
101
        '.','.','.',
102
        '.','.','.',
103
    };
104
    std::printf("局面3 空盘先手:     %d（应为 4，中心）\n", best_move(b3, 'X', 'O'));
105
    return 0;
106
}

1
# 依赖：Python 3.10+，无第三方库
2
# 棋盘状态差分：找出被人挪动过的棋子，并给出应有的位置
3
from dataclasses import dataclass, field
4

5

6
@dataclass
7
class Board:
5 collapsed lines
8
    """cells[i] 为该格的棋子，'.' 表示空，'B'/'W' 为黑/白。"""
9
    cells: list[str] = field(default_factory=lambda: ["."] * 9)
10

11
    def board_key(self) -> str:
12
        return "".join(self.cells)
13

14
    def place(self, idx: int, stone: str) -> None:
15
        if not 0 <= idx < 9:
16
            raise IndexError(f"格号越界: {idx}")
17
        self.cells[idx] = stone
18

19

20
def diff(prev: Board, now: Board) -> list[tuple[int, int, str]]:
21
    """对比两帧棋盘。
22

23
    返回 [(from_idx, to_idx, stone)]：
24
      from_idx 是上一帧它所在的位置，to_idx 是现在的位置。
25
      棋子被挪走（原地变空）且别处多出来 → 一对 from/to。
26
    """
27
    moved: list[tuple[int, int, str]] = []
28
    # ① 哪些格子"少了子"
29
    missing = [i for i in range(9)
30
               if prev.cells[i] != "." and now.cells[i] == "."]
31
    # ② 哪些格子"多了子"（原来空着，现在有子）
32
    appeared = [i for i in range(9)
33
                if prev.cells[i] == "." and now.cells[i] != "."]
34

35
    # ③ 按棋子颜色配对：人的小动作通常是"把某颗子换个格子"
36
    used: set[int] = set()
37
    for m in missing:
38
        for a in appeared:
39
            if a in used:
40
                continue
41
            if prev.cells[m] == now.cells[a]:
42
                moved.append((m, a, now.cells[a]))
43
                used.add(a)
44
                break
45
    return moved
46

47

48
if __name__ == "__main__":
49
    prev = Board()
50
    # 机器(B)之前下在 4 和 8，人(W)在 0
51
    prev.place(4, "B"); prev.place(8, "B"); prev.place(0, "W")
52

53
    now = Board()
54
    # 人把机器在 4 号格的棋子挪到了 6 号格（不落新子）
55
    now.place(6, "B"); now.place(8, "B"); now.place(0, "W")
56

57
    moved = diff(prev, now)
58
    print("检测到被挪动的棋子:", moved)
59
    for frm, to, stone in moved:
60
        print(f"  {stone} 从 {frm} 号格被挪到 {to} 号格 → 应复位到 {frm} 号格")
61

62
    assert moved == [(4, 6, "B")], "差分结果不符预期"
63
    print("自检通过 PASS")