围棋

过默

FishC 发表于 2026-7-10 20:26
以下是完整的人机对战围棋程序（19×19），AI 采用简单的评分策略（评估落子后提子数及棋子数）。代码 ...

1. ef get_neighbors(r, c):
   
2.     dirs =
   
3.     res =
   
4.     for dr, dc in dirs:
   
5.         nr, nc = r + dr, c + dc
   
6.         if 0 <= nr < SIZE and 0 <= nc < SIZE:
   
7.             res.append((nr, nc))
   
8.     return res
   
9. 
   
10. def get_group(board, r, c, color):
    
11.     stack =
    
12.     visited = {(r, c)}
    
13.     group =
    
14.     while stack:
    
15.         cr, cc = stack.pop()
    
16.         group.append((cr, cc))
    
17.         for nr, nc in get_neighbors(cr, cc):
    
18.             if board == color and (nr, nc) not in visited:
    
19.                 visited.add((nr, nc))
    
20.                 stack.append((nr, nc))
    
21.     return group

复制代码

=没赋值

FishC

过默 发表于 2026-07-10 20:27
FishC 发表于 2026-7-10 20:26
以下是完整的人机对战 ...

您提供的 `get_neighbors` 函数代码不完整，存在以下问题：  
- 缺少 `def` 关键字（开头是 `ef`）  
- `dirs` 和 `res` 赋值未完成  
- `for` 循环缩进错误  
- `if` 条件未闭合  
- 缺少 `return` 语句  

以下是修正后的正确函数（以 19 路棋盘为例），可直接使用：  

1.   
   
2. def get_neighbors(r, c):  
   
3.     dirs = [(-1,0), (1,0), (0,-1), (0,1)]  
   
4.     res = []  
   
5.     for dr, dc in dirs:  
   
6.         nr, nc = r + dr, c + dc  
   
7.         if 0 <= nr < SIZE and 0 <= nc < SIZE:  
   
8.             res.append((nr, nc))  
   
9.     return res  
   

复制代码

您需要确保在函数外定义了 `SIZE`（例如 `SIZE = 19`）。  

如果希望直接运行完整的人机对战程序，请参考之前提供的新代码（已修正所有语法错误）。请将以下完整代码复制到 Python 文件中运行（建议使用 9 路棋盘测试，速度更快）：  

1.   
   
2. import tkinter as tk  
   
3. import random  
   
4. 
   
5. SIZE = 9  # 可改为 19  
   
6. 
   
7. def init_board():  
   
8.     return [[0]*SIZE for _ in range(SIZE)]  
   
9. 
   
10. def get_neighbors(r, c):  
    
11.     dirs = [(-1,0),(1,0),(0,-1),(0,1)]  
    
12.     res = []  
    
13.     for dr, dc in dirs:  
    
14.         nr, nc = r+dr, c+dc  
    
15.         if 0 <= nr < SIZE and 0 <= nc < SIZE:  
    
16.             res.append((nr,nc))  
    
17.     return res  
    
18. 
    
19. def get_group(board, r, c, color):  
    
20.     stack = [(r,c)]  
    
21.     visited = {(r,c)}  
    
22.     group = []  
    
23.     while stack:  
    
24.         cr, cc = stack.pop()  
    
25.         group.append((cr,cc))  
    
26.         for nr, nc in get_neighbors(cr, cc):  
    
27.             if board[nr][nc] == color and (nr,nc) not in visited:  
    
28.                 visited.add((nr,nc))  
    
29.                 stack.append((nr,nc))  
    
30.     return group  
    
31. 
    
32. def get_liberties(board, group):  
    
33.     libs = set()  
    
34.     for r, c in group:  
    
35.         for nr, nc in get_neighbors(r, c):  
    
36.             if board[nr][nc] == 0:  
    
37.                 libs.add((nr,nc))  
    
38.     return libs  
    
39. 
    
40. def place_stone(board, r, c, color):  
    
41.     if board[r][c] != 0:  
    
42.         return False  
    
43.     board[r][c] = color  
    
44.     opponent = 3 - color  
    
45.     for nr, nc in get_neighbors(r, c):  
    
46.         if board[nr][nc] == opponent:  
    
47.             group = get_group(board, nr, nc, opponent)  
    
48.             if len(get_liberties(board, group)) == 0:  
    
49.                 for gr, gc in group:  
    
50.                     board[gr][gc] = 0  
    
51.     my_group = get_group(board, r, c, color)  
    
52.     if len(get_liberties(board, my_group)) == 0:  
    
53.         board[r][c] = 0  
    
54.         return False  
    
55.     return True  
    
56. 
    
57. def evaluate_move(board, r, c, color):  
    
58.     if board[r][c] != 0:  
    
59.         return -999  
    
60.     test_board = [row[:] for row in board]  
    
61.     if not place_stone(test_board, r, c, color):  
    
62.         return -999  
    
63.     count = 0  
    
64.     for rr in range(SIZE):  
    
65.         for cc in range(SIZE):  
    
66.             if test_board[rr][cc] == color:  
    
67.                 count += 1  
    
68.     return count  
    
69. 
    
70. def ai_play(board, color):  
    
71.     best_score = -1000  
    
72.     best_moves = []  
    
73.     for r in range(SIZE):  
    
74.         for c in range(SIZE):  
    
75.             score = evaluate_move(board, r, c, color)  
    
76.             if score > best_score:  
    
77.                 best_score = score  
    
78.                 best_moves = [(r,c)]  
    
79.             elif score == best_score:  
    
80.                 best_moves.append((r,c))  
    
81.     if best_moves:  
    
82.         return random.choice(best_moves)  
    
83.     else:  
    
84.         return (-1,-1)  
    
85. 
    
86. class GoGame:  
    
87.     def __init__(self):  
    
88.         self.board = init_board()  
    
89.         self.current = 1  
    
90.         self.root = tk.Tk()  
    
91.         self.root.title("围棋 人机对战")  
    
92.         self.info = tk.Label(self.root, text="当前：黑子（你） 按1黑，按2白", font=('Arial',12))  
    
93.         self.info.pack()  
    
94.         self.canvas = tk.Canvas(self.root, width=500, height=500, bg="#DEB887")  
    
95.         self.canvas.pack(padx=10, pady=10)  
    
96.         self.canvas.bind("<Button-1>", self.click)  
    
97.         self.root.bind('1', lambda e: self.set_color(1))  
    
98.         self.root.bind('2', lambda e: self.set_color(2))  
    
99.         self.draw()  
    
100. 
     
101.     def set_color(self, color):  
     
102.         self.current = color  
     
103.         name = "黑子" if color == 1 else "白子"  
     
104.         self.info.config(text="当前："+name+"（按1黑，按2白）")  
     
105.         if color == 2:  
     
106.             self.root.after(100, self.ai_move)  
     
107. 
     
108.     def draw(self):  
     
109.         self.canvas.delete("all")  
     
110.         cell = 500 // (SIZE + 2)  
     
111.         off = cell  
     
112.         for i in range(SIZE):  
     
113.             x = off + i * cell  
     
114.             self.canvas.create_line(off, x, off + (SIZE-1)*cell, x)  
     
115.             self.canvas.create_line(x, off, x, off + (SIZE-1)*cell)  
     
116.         star = [(3,3),(3,5),(5,3),(5,5),(4,4)] if SIZE==9 else [(3,3),(3,15),(15,3),(15,15),(9,9)]  
     
117.         for r, c in star:  
     
118.             x = off + c * cell  
     
119.             y = off + r * cell  
     
120.             self.canvas.create_oval(x-3, y-3, x+3, y+3, fill='black')  
     
121.         radius = cell//2 - 2  
     
122.         for r in range(SIZE):  
     
123.             for c in range(SIZE):  
     
124.                 if self.board[r][c] != 0:  
     
125.                     x = off + c * cell  
     
126.                     y = off + r * cell  
     
127.                     color = "black" if self.board[r][c] == 1 else "white"  
     
128.                     outline = "white" if self.board[r][c] == 1 else "black"  
     
129.                     self.canvas.create_oval(x-radius, y-radius, x+radius, y+radius, fill=color, outline=outline, width=1)  
     
130. 
     
131.     def click(self, event):  
     
132.         cell = 500 // (SIZE + 2)  
     
133.         off = cell  
     
134.         col = round((event.x - off) / cell)  
     
135.         row = round((event.y - off) / cell)  
     
136.         if 0 <= row < SIZE and 0 <= col < SIZE:  
     
137.             if place_stone(self.board, row, col, self.current):  
     
138.                 self.draw()  
     
139.                 opponent = 3 - self.current  
     
140.                 # AI 自动走一步  
     
141.                 self.root.after(100, self.ai_move)  
     
142. 
     
143.     def ai_move(self):  
     
144.         opponent = self.current  
     
145.         r, c = ai_play(self.board, opponent)  
     
146.         if r != -1:  
     
147.             if place_stone(self.board, r, c, opponent):  
     
148.                 self.draw()  
     
149. 
     
150. if __name__ == "__main__":  
     
151.     game = GoGame()  
     
152.     game.root.mainloop()  
     

复制代码

将以上代码另存为 `go_human_vs_ai.py` 运行即可。AI 会执与您当前颜色相反的颜色（即您执黑时 AI 执白，您按2切换白时 AI 执黑）。通过按键盘 1 或 2 可主动切换当前落子颜色。  
您还可以通过修改 `SIZE` 为 19 来使用标准棋盘（但 AI 运算会变慢）。提升 AI 强度可改进 `evaluate_move` 中的评分函数（例如加入围地面积、眼位等因素）。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

过默

FishC 发表于 2026-7-10 20:27
您提供的 `get_neighbors` 函数代码不完整，存在以下问题：  
- 缺少 `def` 关键字（开头是 `ef`）  
...

没重新开始,黑白下了多个子

FishC

过默 发表于 2026-07-10 20:31
FishC 发表于 2026-7-10 20:27
您提供的 `get_neighb ...

您的问题是说“黑白下了多个子”没有被交替规则限制，即同一方可以连续落子。这是因为在 `click` 函数中，落子成功后没有自动切换当前颜色。请按以下步骤修改：

### 修改方法
找到 `click` 方法，在 `place_stone` 成功之后添加一行，切换 `self.current` 颜色。

修改后的 `click` 方法（只显示关键部分）：

  
def click(self, event):  
    cell = 500 // (SIZE + 2)  
    off = cell  
    col = round((event.x - off) / cell)  
    row = round((event.y - off) / cell)  
    if 0

这样，每次点击成功落子后，`self.current` 会自动变为对方颜色，实现黑白交替。如果您不想自动交替（而是想完全通过键盘切换颜色），可以不添加该行，但那样就需要手动按 1 或 2 来改变颜色。

### 重新开始（重置棋盘）
添加一个“重新开始”按钮，绑定到 `reset` 函数。在 `__init__` 中添加：

  
self.reset_btn = tk.Button(self.root, text="重新开始", command=self.reset)  
self.reset_btn.pack()  

并定义 `reset` 方法：

  
def reset(self):  
    self.board = init_board()  
    self.current = 1  
    self.draw()  
    self.info.config(text="当前：黑子（按1黑，按2白）")  

这样就能随时清空棋盘重新开始对局。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。