题目 on 云雾海的博客

数独

Sun, 02 Nov 2025 16:47:32 +0800

数独

问题

数独是在一个9*9宫格中，保证每行每列以及九个九宫格中填入的1-9的数字不出现重复。通过穷举法实现求解。

程序

import tkinter as tk
from tkinter import ttk, messagebox
import time
import threading

class SudokuSolver:
 def __init__(self, root):
 self.root = root
 self.root.title("数独求解器 - 穷举法")
 self.root.geometry("600x700")
 
 # 初始化数独网格
 self.board = [[0 for _ in range(9)] for _ in range(9)]
 self.initial_board = [[0 for _ in range(9)] for _ in range(9)] # 存储初始题目
 self.cells = [[None for _ in range(9)] for _ in range(9)]
 self.selected_cell = None
 self.solving = False
 self.speed = 100 # 默认速度（毫秒）
 self.algorithm_time = 0 # 纯算法时间
 self.step_count = 0 # 步骤计数器
 
 # 初始化组件变量
 self.speed_label = None
 self.speed_scale = None
 self.status_label = None
 self.stats_label = None
 
 self.create_widgets()
 
 def create_widgets(self):
 # 主框架
 main_frame = ttk.Frame(self.root, padding="10")
 main_frame.pack(fill=tk.BOTH, expand=True)
 
 # 标题
 title_label = ttk.Label(main_frame, text="数独求解器 - 穷举回溯法", 
 font=("Arial", 16, "bold"))
 title_label.pack(pady=10)
 
 # 数独网格框架
 grid_frame = ttk.Frame(main_frame)
 grid_frame.pack(pady=20)
 
 # 创建9x9网格
 self.create_grid(grid_frame)
 
 # 控制面板
 control_frame = ttk.Frame(main_frame)
 control_frame.pack(pady=20)
 
 # 速度控制
 speed_frame = ttk.Frame(control_frame)
 speed_frame.pack(pady=10)
 
 ttk.Label(speed_frame, text="演示速度:").pack(side=tk.LEFT)
 self.speed_scale = ttk.Scale(speed_frame, from_=10, to=1000, 
 orient=tk.HORIZONTAL, length=200,
 command=self.update_speed)
 self.speed_scale.set(100)
 self.speed_scale.pack(side=tk.LEFT, padx=10)
 
 self.speed_label = ttk.Label(speed_frame, text="100 ms")
 self.speed_label.pack(side=tk.LEFT)
 
 # 按钮
 button_frame = ttk.Frame(control_frame)
 button_frame.pack(pady=10)
 
 ttk.Button(button_frame, text="开始求解", 
 command=self.start_solving).pack(side=tk.LEFT, padx=5)
 ttk.Button(button_frame, text="直接作答", 
 command=self.direct_solve).pack(side=tk.LEFT, padx=5)
 ttk.Button(button_frame, text="重置", 
 command=self.reset_board).pack(side=tk.LEFT, padx=5)
 ttk.Button(button_frame, text="清空", 
 command=self.clear_board).pack(side=tk.LEFT, padx=5)
 ttk.Button(button_frame, text="示例", 
 command=self.load_example).pack(side=tk.LEFT, padx=5)
 
 # 状态显示
 self.status_label = ttk.Label(main_frame, text="请点击格子并输入数字1-9", 
 font=("Arial", 10))
 self.status_label.pack(pady=10)
 
 # 统计信息
 self.stats_label = ttk.Label(main_frame, text="步骤: 0 | 算法时间: 0.00s", 
 font=("Arial", 10))
 self.stats_label.pack(pady=5)
 
 # 操作说明
 instruction_text = """操作说明：
 1. 点击格子，然后按数字键1-9填入数字
 2. 按0或Delete键清空格子
 3. 调整速度滑块控制演示速度
 4. 点击"开始求解"观看穷举求解过程
 5. 点击"直接作答"直接获得答案
 6. 紫色格子表示初始题目，绿色表示尝试的数字，红色表示回溯"""
 
 instruction_label = ttk.Label(main_frame, text=instruction_text, 
 justify=tk.LEFT, font=("Arial", 9))
 instruction_label.pack(pady=10)
 
 def create_grid(self, parent):
 # 创建9x9网格，每个3x3区域有更粗的边框
 for i in range(9):
 for j in range(9):
 # 确定边框宽度 - 为3x3区域边界设置更粗的边框
 border_width = 1
 if i % 3 == 0 and i != 0:
 border_width = 3
 if j % 3 == 0 and j != 0:
 border_width = 3
 
 # 为外边框设置更粗的边框
 if i == 0 or i == 8:
 border_width = 3
 if j == 0 or j == 8:
 border_width = 3
 
 cell = tk.Entry(parent, width=3, font=("Arial", 16), 
 justify=tk.CENTER, relief="solid",
 borderwidth=border_width)
 cell.grid(row=i, column=j, padx=(1, 1), pady=(1, 1), ipady=5)
 
 # 绑定事件
 cell.bind("<Button-1>", lambda e, row=i, col=j: self.select_cell(row, col))
 cell.bind("<Key>", lambda e, row=i, col=j: self.on_key_press(e, row, col))
 cell.bind("<FocusIn>", lambda e, row=i, col=j: self.select_cell(row, col))
 
 self.cells[i][j] = cell
 
 def select_cell(self, row, col):
 # 取消之前选中格子的高亮
 if self.selected_cell:
 old_row, old_col = self.selected_cell
 self.cells[old_row][old_col].config(bg=self.get_cell_color(old_row, old_col))
 
 # 高亮当前选中的格子
 self.selected_cell = (row, col)
 self.cells[row][col].config(bg="#e0e0ff")
 self.cells[row][col].focus_set()
 
 self.status_label.config(text=f"选中格子: ({row+1}, {col+1})")
 
 def get_cell_color(self, row, col):
 """根据格子内容返回对应的背景颜色"""
 if self.initial_board[row][col] != 0:
 return "#e0c0ff" # 初始题目 - 紫色
 else:
 return "white" # 空白格子 - 白色
 
 def on_key_press(self, event, row, col):
 if event.char in '123456789':
 self.set_cell_value(row, col, int(event.char))
 elif event.keysym in ['Delete', 'BackSpace'] or event.char == '0':
 self.set_cell_value(row, col, 0)
 
 # 阻止默认行为
 return "break"
 
 def set_cell_value(self, row, col, value):
 self.board[row][col] = value
 if value == 0:
 self.cells[row][col].delete(0, tk.END)
 else:
 self.cells[row][col].delete(0, tk.END)
 self.cells[row][col].insert(0, str(value))
 
 # 更新格子颜色
 self.cells[row][col].config(bg=self.get_cell_color(row, col))
 
 def update_speed(self, value):
 self.speed = int(float(value))
 # 确保 speed_label 已创建
 if hasattr(self, 'speed_label') and self.speed_label is not None:
 self.speed_label.config(text=f"{self.speed} ms")
 
 def reset_board(self):
 for i in range(9):
 for j in range(9):
 self.set_cell_value(i, j, self.board[i][j])
 self.status_label.config(text="棋盘已重置")
 
 def clear_board(self):
 for i in range(9):
 for j in range(9):
 self.set_cell_value(i, j, 0)
 self.initial_board[i][j] = 0 # 同时清空初始题目
 self.status_label.config(text="棋盘已清空")
 self.step_count = 0
 self.algorithm_time = 0
 self.update_stats()
 
 def load_example(self):
 # 加载一个示例数独
 example = [
 [5, 3, 0, 0, 7, 0, 0, 0, 0],
 [6, 0, 0, 1, 9, 5, 0, 0, 0],
 [0, 9, 8, 0, 0, 0, 0, 6, 0],
 [8, 0, 0, 0, 6, 0, 0, 0, 3],
 [4, 0, 0, 8, 0, 3, 0, 0, 1],
 [7, 0, 0, 0, 2, 0, 0, 0, 6],
 [0, 6, 0, 0, 0, 0, 2, 8, 0],
 [0, 0, 0, 4, 1, 9, 0, 0, 5],
 [0, 0, 0, 0, 8, 0, 0, 7, 9]
 ]
 
 for i in range(9):
 for j in range(9):
 self.set_cell_value(i, j, example[i][j])
 self.initial_board[i][j] = example[i][j] # 保存初始题目
 
 self.status_label.config(text="已加载示例数独")
 
 def start_solving(self):
 if self.solving:
 return
 
 # 保存当前棋盘状态作为初始题目
 for i in range(9):
 for j in range(9):
 if self.board[i][j] != 0:
 self.initial_board[i][j] = self.board[i][j]
 # 更新格子颜色为初始题目颜色
 self.cells[i][j].config(bg=self.get_cell_color(i, j))
 
 # 在新线程中运行求解过程，避免阻塞UI
 thread = threading.Thread(target=self.solve_thread)
 thread.daemon = True
 thread.start()
 
 def direct_solve(self):
 """直接求解，不演示中间过程"""
 if self.solving:
 return
 
 # 保存当前棋盘状态作为初始题目
 for i in range(9):
 for j in range(9):
 if self.board[i][j] != 0:
 self.initial_board[i][j] = self.board[i][j]
 
 # 在新线程中运行直接求解过程
 thread = threading.Thread(target=self.direct_solve_thread)
 thread.daemon = True
 thread.start()
 
 def solve_thread(self):
 """演示求解线程"""
 self.solving = True
 self.status_label.config(text="开始求解...")
 self.step_count = 0
 self.algorithm_time = 0
 
 # 禁用控制按钮
 self.toggle_buttons(False)
 
 # 开始求解
 start_time = time.time()
 solved = self.solve_sudoku()
 end_time = time.time()
 
 self.solving = False
 
 # 启用控制按钮
 self.toggle_buttons(True)
 
 total_time = end_time - start_time
 if solved:
 self.status_label.config(text=f"求解完成! 总用时: {total_time:.2f}秒")
 else:
 self.status_label.config(text="无解!")
 
 def direct_solve_thread(self):
 """直接求解线程"""
 self.solving = True
 self.status_label.config(text="直接求解中...")
 
 # 禁用控制按钮
 self.toggle_buttons(False)
 
 # 开始直接求解
 start_time = time.time()
 solved = self.solve_sudoku_direct()
 end_time = time.time()
 
 self.solving = False
 
 # 启用控制按钮
 self.toggle_buttons(True)
 
 total_time = end_time - start_time
 if solved:
 # 更新UI显示最终结果
 self.update_final_board()
 self.status_label.config(text=f"直接求解完成! 用时: {total_time:.2f}秒")
 else:
 self.status_label.config(text="无解!")
 
 def solve_sudoku_direct(self):
 """直接求解数独，不更新UI，不延迟"""
 # 创建棋盘副本
 board_copy = [row[:] for row in self.board]
 
 # 直接求解
 solved = self.solve_direct(board_copy)
 
 # 如果求解成功，更新棋盘
 if solved:
 self.board = board_copy
 return solved
 
 def solve_direct(self, board):
 """直接求解数独的递归函数"""
 empty_cell = self.find_empty_cell_direct(board)
 if not empty_cell:
 return True # 没有空格子，求解完成
 
 row, col = empty_cell
 
 for num in range(1, 10):
 if self.is_valid_direct(board, row, col, num):
 # 尝试填入数字
 board[row][col] = num
 
 # 递归求解
 if self.solve_direct(board):
 return True
 
 # 回溯
 board[row][col] = 0
 
 return False
 
 def find_empty_cell_direct(self, board):
 """在直接求解模式下查找空格子"""
 for i in range(9):
 for j in range(9):
 if board[i][j] == 0:
 return (i, j)
 return None
 
 def is_valid_direct(self, board, row, col, num):
 """在直接求解模式下检查数字是否有效"""
 # 检查行
 for i in range(9):
 if board[row][i] == num:
 return False
 
 # 检查列
 for i in range(9):
 if board[i][col] == num:
 return False
 
 # 检查3x3宫格
 start_row, start_col = 3 * (row // 3), 3 * (col // 3)
 for i in range(3):
 for j in range(3):
 if board[start_row + i][start_col + j] == num:
 return False
 
 return True
 
 def update_final_board(self):
 """更新UI显示最终结果"""
 for i in range(9):
 for j in range(9):
 value = self.board[i][j]
 if value != 0:
 self.cells[i][j].delete(0, tk.END)
 self.cells[i][j].insert(0, str(value))
 # 如果是算法填入的数字，显示为浅蓝色
 if self.initial_board[i][j] == 0:
 self.cells[i][j].config(bg="#c0e0ff")
 
 def toggle_buttons(self, state):
 state_str = "normal" if state else "disabled"
 for widget in self.root.winfo_children():
 for child in widget.winfo_children():
 if isinstance(child, ttk.Frame):
 for button in child.winfo_children():
 if isinstance(button, ttk.Button):
 button.config(state=state_str)
 
 def is_valid(self, board, row, col, num):
 # 检查行
 for i in range(9):
 if board[row][i] == num:
 return False
 
 # 检查列
 for i in range(9):
 if board[i][col] == num:
 return False
 
 # 检查3x3宫格
 start_row, start_col = 3 * (row // 3), 3 * (col // 3)
 for i in range(3):
 for j in range(3):
 if board[start_row + i][start_col + j] == num:
 return False
 
 return True
 
 def solve_sudoku(self):
 # 使用回溯法求解数独
 empty_cell = self.find_empty_cell()
 if not empty_cell:
 return True # 没有空格子，求解完成
 
 row, col = empty_cell
 
 for num in range(1, 10):
 # 记录算法开始时间
 algo_start = time.time()
 
 if self.is_valid(self.board, row, col, num):
 # 尝试填入数字
 self.board[row][col] = num
 self.step_count += 1
 
 # 更新UI - 确保格子显示为绿色
 self.root.after(0, lambda r=row, c=col, v=num: self.update_cell_ui(r, c, v, "try"))
 
 # 记录算法结束时间
 algo_end = time.time()
 self.algorithm_time += (algo_end - algo_start)
 self.update_stats()
 
 # 延迟用于演示
 time.sleep(self.speed / 1000.0)
 
 # 递归求解
 if self.solve_sudoku():
 return True
 
 # 回溯
 algo_start = time.time()
 self.board[row][col] = 0
 self.step_count += 1
 
 # 更新UI
 self.root.after(0, lambda r=row, c=col, v=0: self.update_cell_ui(r, c, v, "backtrack"))
 
 # 记录算法结束时间
 algo_end = time.time()
 self.algorithm_time += (algo_end - algo_start)
 self.update_stats()
 
 # 延迟用于演示
 time.sleep(self.speed / 1000.0)
 else:
 # 即使数字无效，也记录算法时间
 algo_end = time.time()
 self.algorithm_time += (algo_end - algo_start)
 self.update_stats()
 
 return False
 
 def find_empty_cell(self):
 for i in range(9):
 for j in range(9):
 if self.board[i][j] == 0:
 return (i, j)
 return None
 
 def update_cell_ui(self, row, col, value, action_type):
 # 如果是初始题目格子，保持紫色，不改变
 if self.initial_board[row][col] != 0:
 return
 
 if value == 0:
 self.cells[row][col].delete(0, tk.END)
 if action_type == "backtrack":
 self.cells[row][col].config(bg="#ffcccc") # 回溯时显示红色
 # 立即更新UI
 self.root.update_idletasks()
 self.root.update()
 else:
 self.cells[row][col].delete(0, tk.END)
 self.cells[row][col].insert(0, str(value))
 if action_type == "try":
 self.cells[row][col].config(bg="#ccffcc") # 尝试时显示绿色
 # 立即更新UI
 self.root.update_idletasks()
 self.root.update()
 
 def update_stats(self):
 if hasattr(self, 'stats_label') and self.stats_label is not None:
 self.root.after(0, lambda: self.stats_label.config(
 text=f"步骤: {self.step_count} | 算法时间: {self.algorithm_time:.3f}s"))

def main():
 root = tk.Tk()
 app = SudokuSolver(root)
 root.mainloop()

if __name__ == "__main__":
 main()

执行结果

井字棋

Sun, 02 Nov 2025 16:47:09 +0800

井字棋

问题

井字棋是在一个九宫格中依次填入O或X，当横、竖、斜出现三个相同棋子时即获胜。以O先下为例，统计各自胜场和平局数。

完全穷举

讨论所有情况的胜率。

程序

class TicTacToeCompleteExhaustive:
 def __init__(self):
 self.total_states = 0
 self.o_wins = 0
 self.x_wins = 0
 self.draws = 0
 self.unfinished = 0
 self.total_moves = 0
 
 # 胜利条件
 self.win_conditions = [
 [0, 1, 2], [3, 4, 5], [6, 7, 8], # 横线
 [0, 3, 6], [1, 4, 7], [2, 5, 8], # 竖线
 [0, 4, 8], [2, 4, 6] # 对角线
 ]
 
 def is_win(self, state, player):
 """判断某玩家是否获胜"""
 for condition in self.win_conditions:
 if all(state[i] == player for i in condition):
 return True
 return False
 
 def is_draw(self, state):
 """判断是否平局"""
 return 0 not in state and not self.is_win(state, 1) and not self.is_win(state, 2)
 
 def is_unfinished(self, state):
 """判断是否未结束"""
 return 0 in state and not self.is_win(state, 1) and not self.is_win(state, 2)
 
 def analyze_state(self, state):
 """分析一个状态并更新统计"""
 self.total_states += 1
 
 # 计算当前状态的步数（已下的棋子数）
 moves_in_state = state.count(1) + state.count(2)
 self.total_moves += moves_in_state
 
 if self.is_win(state, 1): # O赢
 self.o_wins += 1
 elif self.is_win(state, 2): # X赢
 self.x_wins += 1
 elif self.is_draw(state): # 平局
 self.draws += 1
 elif self.is_unfinished(state): # 未结束
 self.unfinished += 1
 
 def dfs(self, state, is_o_turn):
 """深度优先搜索所有可能的局面（完全穷举）"""
 # 分析当前状态
 self.analyze_state(state)
 
 # 如果游戏结束，不再继续搜索
 if self.is_win(state, 1) or self.is_win(state, 2) or self.is_draw(state):
 return
 
 # 继续搜索下一步
 for i in range(9):
 if state[i] == 0:
 state[i] = 1 if is_o_turn else 2
 self.dfs(state, not is_o_turn)
 state[i] = 0
 
 def analyze_all_states(self):
 """分析所有可能的游戏局面（完全穷举）"""
 print("开始分析井字棋所有可能局面（完全穷举）...")
 
 initial_state = [0] * 9 # 0表示空，1表示O，2表示X
 self.dfs(initial_state, True) # O先手
 
 # 输出结果
 print("\n=== 井字棋穷举分析结果（完全穷举）===")
 print(f"总局面数: {self.total_states:,}")
 print(f"O 获胜局面数: {self.o_wins:,}")
 print(f"X 获胜局面数: {self.x_wins:,}")
 print(f"平局局面数: {self.draws:,}")
 print(f"未结束局面数: {self.unfinished:,}")
 
 # 验证总数
 total_calculated = self.o_wins + self.x_wins + self.draws + self.unfinished
 print(f"验证: {self.o_wins:,} + {self.x_wins:,} + {self.draws:,} + {self.unfinished:,} = {total_calculated:,}")
 print(f"与实际总数对比: {total_calculated} = {self.total_states}")
 
 print("\n=== 比例分析 ===")
 print(f"O 胜率: {self.o_wins/self.total_states*100:.4f}%")
 print(f"X 胜率: {self.x_wins/self.total_states*100:.4f}%")
 print(f"平局率: {self.draws/self.total_states*100:.4f}%")
 print(f"未结束率: {self.unfinished/self.total_states*100:.4f}%")
 
 # 计算平均深度
 if self.total_states > 0:
 avg_moves = self.total_moves / self.total_states
 print(f"\n平均步数: {avg_moves:.2f}")
 
 return self.total_states


# 运行分析
if __name__ == "__main__":
 analyzer = TicTacToeCompleteExhaustive()
 total = analyzer.analyze_all_states()

执行结果

完全去重

去除因为顺序和对称性导致的重复情况

程序

import tkinter as tk
from tkinter import messagebox, ttk
import itertools

class TicTacToeAnalyzer:
 def __init__(self):
 self.states = {} # 存储所有局面
 self.unique_states = set() # 去重后的局面
 self.state_list = [] # 状态列表，用于浏览
 self.current_state_index = 0 # 当前浏览的状态索引
 
 self.o_wins = 0
 self.x_wins = 0
 self.draws = 0
 
 # 对称变换策略
 self.symmetry_strategies = [
 [0, 1, 2, 3, 4, 5, 6, 7, 8], # 原始
 [2, 1, 0, 5, 4, 3, 8, 7, 6], # 垂直翻转
 [6, 7, 8, 3, 4, 5, 0, 1, 2], # 水平翻转
 [8, 5, 2, 7, 4, 1, 6, 3, 0], # 主对角线翻转
 [0, 3, 6, 1, 4, 7, 2, 5, 8], # 副对角线翻转
 [6, 3, 0, 7, 4, 1, 8, 5, 2], # 旋转90度
 [8, 7, 6, 5, 4, 3, 2, 1, 0], # 旋转180度
 [2, 5, 8, 1, 4, 7, 0, 3, 6], # 旋转270度
 ]
 
 # 胜利条件
 self.win_conditions = [
 [0, 1, 2], [3, 4, 5], [6, 7, 8], # 横线
 [0, 3, 6], [1, 4, 7], [2, 5, 8], # 竖线
 [0, 4, 8], [2, 4, 6] # 对角线
 ]
 
 self.setup_gui()
 
 def setup_gui(self):
 self.root = tk.Tk()
 self.root.title("井字棋穷举分析器")
 self.root.geometry("900x700")
 
 # 控制面板
 control_frame = tk.Frame(self.root)
 control_frame.pack(pady=10)
 
 tk.Button(control_frame, text="开始分析", command=self.start_analysis, 
 bg="lightblue", font=("Arial", 12)).pack(side=tk.LEFT, padx=5)
 
 tk.Button(control_frame, text="重置", command=self.reset, 
 bg="lightcoral", font=("Arial", 12)).pack(side=tk.LEFT, padx=5)
 
 # 统计信息
 stats_frame = tk.Frame(self.root)
 stats_frame.pack(pady=10)
 
 self.stats_text = tk.Text(stats_frame, height=6, width=80, font=("Courier", 10))
 self.stats_text.pack()
 
 # 进度条
 self.progress = ttk.Progressbar(self.root, orient=tk.HORIZONTAL, length=600, mode='determinate')
 self.progress.pack(pady=10)
 
 # 棋盘显示区域
 board_frame = tk.Frame(self.root)
 board_frame.pack(pady=10)
 
 # 创建棋盘
 self.canvas = tk.Canvas(board_frame, width=300, height=300, bg="white")
 self.canvas.pack()
 
 # 状态信息和导航
 nav_frame = tk.Frame(self.root)
 nav_frame.pack(pady=10)
 
 # 状态信息
 self.state_info = tk.Label(nav_frame, text="请点击'开始分析'进行穷举分析", 
 font=("Arial", 12), fg="blue")
 self.state_info.pack(pady=5)
 
 # 导航按钮
 nav_buttons = tk.Frame(nav_frame)
 nav_buttons.pack(pady=5)
 
 tk.Button(nav_buttons, text="第一个", command=self.first_state, 
 font=("Arial", 10)).pack(side=tk.LEFT, padx=5)
 
 tk.Button(nav_buttons, text="上一个", command=self.prev_state, 
 font=("Arial", 10)).pack(side=tk.LEFT, padx=5)
 
 tk.Button(nav_buttons, text="下一个", command=self.next_state, 
 font=("Arial", 10)).pack(side=tk.LEFT, padx=5)
 
 tk.Button(nav_buttons, text="最后一个", command=self.last_state, 
 font=("Arial", 10)).pack(side=tk.LEFT, padx=5)
 
 # 结果显示区域
 result_frame = tk.Frame(self.root)
 result_frame.pack(pady=10, fill=tk.BOTH, expand=True)
 
 # 创建滚动条
 scrollbar = tk.Scrollbar(result_frame)
 scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
 
 self.result_text = tk.Text(result_frame, height=10, width=80, font=("Courier", 9),
 yscrollcommand=scrollbar.set)
 self.result_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 scrollbar.config(command=self.result_text.yview)
 
 def draw_board(self, state):
 """绘制棋盘和棋子"""
 self.canvas.delete("all")
 
 # 绘制棋盘网格
 for i in range(1, 3):
 # 垂直线
 self.canvas.create_line(i * 100, 0, i * 100, 300, width=2)
 # 水平线
 self.canvas.create_line(0, i * 100, 300, i * 100, width=2)
 
 # 绘制棋子
 for i in range(9):
 row = i // 3
 col = i % 3
 x = col * 100 + 50
 y = row * 100 + 50
 
 if state[i] == 1: # O
 self.canvas.create_oval(x-30, y-30, x+30, y+30, width=3, outline="blue")
 elif state[i] == 2: # X
 self.canvas.create_line(x-30, y-30, x+30, y+30, width=3, fill="red")
 self.canvas.create_line(x-30, y+30, x+30, y-30, width=3, fill="red")
 
 def rearrange(self, state, strategy):
 """根据对称策略重新排列局面"""
 return [state[i] for i in strategy]
 
 def get_symmetric_states(self, state):
 """获取所有对称局面"""
 symmetric_states = []
 for strategy in self.symmetry_strategies:
 symmetric_states.append(self.rearrange(state, strategy))
 return symmetric_states
 
 def is_win(self, state, player):
 """判断某玩家是否获胜"""
 for condition in self.win_conditions:
 if all(state[i] == player for i in condition):
 return True
 return False
 
 def is_draw(self, state):
 """判断是否平局"""
 return 0 not in state and not self.is_win(state, 1) and not self.is_win(state, 2)
 
 def get_state_key(self, state):
 """获取状态的规范表示（用于去重）"""
 # 找到所有对称状态中最小的元组表示
 symmetric_states = self.get_symmetric_states(state)
 min_state = min(tuple(s) for s in symmetric_states)
 return min_state
 
 def dfs(self, state, is_o_turn):
 """深度优先搜索所有可能的局面"""
 state_key = self.get_state_key(state)
 
 # 如果已经访问过这个状态，直接返回
 if state_key in self.states:
 return
 
 # 记录这个状态
 self.states[state_key] = {
 'state': state.copy(),
 'o_win': self.is_win(state, 1),
 'x_win': self.is_win(state, 2),
 'draw': self.is_draw(state)
 }
 
 # 如果游戏结束，不再继续搜索
 if self.is_win(state, 1) or self.is_win(state, 2) or self.is_draw(state):
 return
 
 # 继续搜索下一步
 for i in range(9):
 if state[i] == 0:
 state[i] = 1 if is_o_turn else 2
 self.dfs(state, not is_o_turn)
 state[i] = 0
 
 def analyze_game(self):
 """分析所有可能的游戏局面"""
 self.states = {}
 initial_state = [0] * 9 # 0表示空，1表示O，2表示X
 self.dfs(initial_state, True) # O先手
 
 # 将状态转换为列表，用于浏览
 self.state_list = list(self.states.keys())
 
 # 统计结果
 self.o_wins = sum(1 for data in self.states.values() if data['o_win'])
 self.x_wins = sum(1 for data in self.states.values() if data['x_win'])
 self.draws = sum(1 for data in self.states.values() if data['draw'])
 
 return len(self.states)
 
 def format_state(self, state):
 """格式化显示局面"""
 symbols = {0: ' ', 1: 'O', 2: 'X'}
 lines = []
 for i in range(0, 9, 3):
 line = ' | '.join(symbols[state[i+j]] for j in range(3))
 lines.append(line)
 return '\n---------\n'.join(lines)
 
 def display_current_state(self):
 """显示当前状态"""
 if not self.state_list:
 return
 
 state_key = self.state_list[self.current_state_index]
 state_data = self.states[state_key]
 state = state_data['state']
 
 # 绘制棋盘
 self.draw_board(state)
 
 # 更新状态信息
 status = "O胜" if state_data['o_win'] else "X胜" if state_data['x_win'] else "平局" if state_data['draw'] else "未结束"
 self.state_info.config(text=f"状态 {self.current_state_index+1}/{len(self.state_list)} - {status}")
 
 # 在结果区域显示详细信息
 self.result_text.delete(1.0, tk.END)
 self.result_text.insert(tk.END, f"局面 #{self.current_state_index+1}:\n")
 self.result_text.insert(tk.END, self.format_state(state))
 self.result_text.insert(tk.END, f"\n\n状态: {status}")
 self.result_text.insert(tk.END, f"\n局面代码: {state}")
 
 def first_state(self):
 """跳转到第一个状态"""
 if self.state_list:
 self.current_state_index = 0
 self.display_current_state()
 
 def prev_state(self):
 """跳转到上一个状态"""
 if self.state_list and self.current_state_index > 0:
 self.current_state_index -= 1
 self.display_current_state()
 
 def next_state(self):
 """跳转到下一个状态"""
 if self.state_list and self.current_state_index < len(self.state_list) - 1:
 self.current_state_index += 1
 self.display_current_state()
 
 def last_state(self):
 """跳转到最后一个状态"""
 if self.state_list:
 self.current_state_index = len(self.state_list) - 1
 self.display_current_state()
 
 def display_results(self):
 """显示分析结果"""
 total_states = len(self.states)
 
 stats_info = f"""
=== 井字棋穷举分析结果 ===
总局面数（去重后）: {total_states}
O 获胜局面数: {self.o_wins}
X 获胜局面数: {self.x_wins}
平局局面数: {self.draws}
未结束局面数: {total_states - self.o_wins - self.x_wins - self.draws}

O 胜率: {self.o_wins/total_states*100:.2f}%
X 胜率: {self.x_wins/total_states*100:.2f}%
平局率: {self.draws/total_states*100:.2f}%
"""
 self.stats_text.delete(1.0, tk.END)
 self.stats_text.insert(1.0, stats_info)
 
 # 显示第一个状态
 if self.state_list:
 self.current_state_index = 0
 self.display_current_state()
 
 def update_progress(self, value):
 """更新进度条"""
 self.progress['value'] = value
 self.root.update_idletasks()
 
 def start_analysis(self):
 """开始分析"""
 self.stats_text.delete(1.0, tk.END)
 self.stats_text.insert(1.0, "正在分析井字棋所有可能局面...\n这可能需要几秒钟...")
 
 # 模拟进度更新
 for i in range(101):
 self.update_progress(i)
 self.root.after(10) # 小延迟让界面更新
 
 # 执行分析
 total_states = self.analyze_game()
 
 # 显示结果
 self.display_results()
 
 messagebox.showinfo("分析完成", f"分析完成！共找到 {total_states} 个不同的局面。")
 
 def reset(self):
 """重置分析"""
 self.states = {}
 self.state_list = []
 self.current_state_index = 0
 self.o_wins = 0
 self.x_wins = 0
 self.draws = 0
 self.progress['value'] = 0
 self.stats_text.delete(1.0, tk.END)
 self.result_text.delete(1.0, tk.END)
 self.state_info.config(text="请点击'开始分析'进行穷举分析")
 self.canvas.delete("all")
 
 def run(self):
 """运行应用程序"""
 self.root.mainloop()

# 创建并运行分析器
if __name__ == "__main__":
 analyzer = TicTacToeAnalyzer()
 analyzer.run()

执行结果

密码破解

Sun, 02 Nov 2025 16:41:22 +0800

密码破解

问题

使用暴力破解包含大小写字母和数字的四位密码。

程序

import itertools
import time
import hashlib

def generate_hashes(passwords):
 """生成密码的MD5哈希值"""
 hashes = {}
 for pwd in passwords:
 hashes[pwd] = hashlib.md5(pwd.encode()).hexdigest()
 return hashes

def crack_by_hash(target_hashes):
 """通过哈希值破解密码"""
 characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
 
 print("开始破解密码...")
 start_time = time.time()
 attempts = 0
 found_passwords = {}
 
 # 记录每个密码的破解信息
 crack_info = {}
 
 # 生成所有1-3位字符组合
 for length in range(1, 5):
 for candidate in itertools.product(characters, repeat=length):
 password_attempt = ''.join(candidate)
 attempts += 1
 
 # 计算当前尝试密码的MD5哈希值
 hash_attempt = hashlib.md5(password_attempt.encode()).hexdigest()
 
 # 检查哈希值是否匹配任何目标
 for original_pwd, target_hash in target_hashes.items():
 if hash_attempt == target_hash and original_pwd not in found_passwords:
 found_passwords[original_pwd] = password_attempt
 crack_time = time.time() - start_time
 crack_info[original_pwd] = {
 'attempts': attempts,
 'time': crack_time,
 'found_password': password_attempt
 }
 print(f"✅ 破解成功: '{original_pwd}' -> '{password_attempt}'")
 print(f" 尝试次数: {attempts}, 耗时: {crack_time:.4f}秒")
 
 # 如果所有密码都已找到，提前结束
 if len(found_passwords) == len(target_hashes):
 total_time = time.time() - start_time
 print(f"\n所有密码破解完成!")
 print(f"总尝试次数: {attempts}, 总耗时: {total_time:.4f}秒")
 return crack_info
 
 total_time = time.time() - start_time
 print(f"\n破解结束，找到 {len(found_passwords)}/{len(target_hashes)} 个密码")
 print(f"总尝试次数: {attempts}, 总耗时: {total_time:.4f}秒")
 return crack_info

def main():
 # 预存密码 - 代表最快和最后被遍历出来的密码
 passwords = ['a', '9', 'aa', '99', 'aaa', '999', 'aaaa', '9999']
 
 print("=" * 60)
 print(" 密码哈希破解演示 (使用MD5)")
 print("=" * 60)
 
 # 生成并显示预存密码的哈希值
 print("\n预存密码及其MD5哈希值:")
 print("-" * 80)
 hashes = generate_hashes(passwords)
 
 for pwd, h in hashes.items():
 print(f"密码: '{pwd}' -> 哈希: {h}")
 
 print("-" * 80)
 
 # 显示字符集信息
 characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
 print(f"\n字符集: {characters}")
 print(f"字符集大小: {len(characters)}")
 print(f"1位密码组合数: {len(characters)}")
 print(f"2位密码组合数: {len(characters)**2}")
 print(f"3位密码组合数: {len(characters)**3}")
 print(f"4位密码组合数: {len(characters)**4}")
 print(f"总组合数: {len(characters) + len(characters)**2 + len(characters)**3 + len(characters)**4}")
 
 # 开始破解
 input("\n按回车键开始破解...")
 
 # 破解密码（只通过哈希值比较）
 results = crack_by_hash(hashes)
 
 # 显示破解结果总结
 print("\n" + "=" * 60)
 print("破解结果总结:")
 print("-" * 60)
 
 # 按破解顺序显示
 for pwd in passwords:
 if pwd in results:
 info = results[pwd]
 print(f"密码 '{pwd}': {info['attempts']:6d} 次尝试, {info['time']:.4f} 秒")
 else:
 print(f"密码 '{pwd}': 未找到")
 
 print("=" * 60)

if __name__ == "__main__":
 main()

执行效果

============================================================
 密码哈希破解演示 (使用MD5)
============================================================

预存密码及其MD5哈希值:
--------------------------------------------------------------------------------
密码: 'a' -> 哈希: 0cc175b9c0f1b6a831c399e269772661
密码: '9' -> 哈希: 45c48cce2e2d7fbdea1afc51c7c6ad26
密码: 'aa' -> 哈希: 4124bc0a9335c27f086f24ba207a4912
密码: '99' -> 哈希: ac627ab1ccbdb62ec96e702f07f6425b
密码: 'aaa' -> 哈希: 47bce5c74f589f4867dbd57e9ca9f808
密码: '999' -> 哈希: b706835de79a2b4e80506f582af3676a
密码: 'aaaa' -> 哈希: 74b87337454200d4d33f80c4663dc5e5
密码: '9999' -> 哈希: fa246d0262c3925617b0c72bb20eeb1d
--------------------------------------------------------------------------------

字符集: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789
字符集大小: 62
1位密码组合数: 62
2位密码组合数: 3844
3位密码组合数: 238328
4位密码组合数: 14776336
总组合数: 15018570

按回车键开始破解...
开始破解密码...
✅ 破解成功: 'a' -> 'a'
 尝试次数: 1, 耗时: 0.0000秒
✅ 破解成功: '9' -> '9'
 尝试次数: 62, 耗时: 0.0006秒
✅ 破解成功: 'aa' -> 'aa'
 尝试次数: 63, 耗时: 0.0010秒
✅ 破解成功: '99' -> '99'
 尝试次数: 3906, 耗时: 0.0053秒
✅ 破解成功: 'aaa' -> 'aaa'
 尝试次数: 3907, 耗时: 0.0055秒
✅ 破解成功: '999' -> '999'
 尝试次数: 242234, 耗时: 0.2391秒
✅ 破解成功: 'aaaa' -> 'aaaa'
 尝试次数: 242235, 耗时: 0.2394秒
✅ 破解成功: '9999' -> '9999'
 尝试次数: 15018570, 耗时: 14.6867秒

所有密码破解完成!
总尝试次数: 15018570, 总耗时: 14.6869秒

============================================================
破解结果总结:
------------------------------------------------------------
密码 'a': 1 次尝试, 0.0000 秒
密码 '9': 62 次尝试, 0.0006 秒
密码 'aa': 63 次尝试, 0.0010 秒
密码 '99': 3906 次尝试, 0.0053 秒
密码 'aaa': 3907 次尝试, 0.0055 秒
密码 '999': 242234 次尝试, 0.2391 秒
密码 'aaaa': 242235 次尝试, 0.2394 秒
密码 '9999': 15018570 次尝试, 14.6867 秒
============================================================

水仙花数

Sun, 02 Nov 2025 16:37:50 +0800

水仙花数

问题

三位数的水仙花数是指一个三位数的每个数字的立方和等于该数本身。求所有三位水仙花数。

程序

for num in range(100, 1000):
 a = num // 100 # 百位
 b = (num // 10) % 10 # 十位
 c = num % 10 # 个位
 if a**3 + b**3 + c**3 == num:
 print(num)

思想

穷举所有可能并打印合适的数。

执行效果

百钱买百鸡

Sun, 02 Nov 2025 16:31:42 +0800

百钱买百鸡

问题

鸡翁一，值钱五；鸡母一，值钱三；鸡雏三，值钱一；百钱买百鸡，则翁、母、雏各几何？

程序

# 公鸡5文钱一只，母鸡3文钱一只，小鸡1文钱三只。用100文钱买100只鸡，问公鸡、母鸡、小鸡各多少只？

# 穷举法：遍历所有可能的公鸡、母鸡、小鸡数量，判断是否满足条件
for cock in range(0, 21): # 公鸡从0到20只
 for hen in range(0, 34): # 母鸡从0到33只
 chick = 100 - cock - hen # 小鸡数量
 if chick % 3 == 0 and cock * 5 + hen * 3 + chick // 3 == 100:
 print(f"公鸡：{cock}只，母鸡：{hen}只，小鸡：{chick}只")

思想

穷举所有可能，记录所有可能的情况。

执行效果

八皇后问题

Sun, 02 Nov 2025 16:02:36 +0800

八皇后问题

问题

八皇后问题是一个以国际象棋为背景的问题：如何能够在8×8的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵列、正斜线或反斜线。使用穷举法列举所有可能。

程序

import tkinter as tk
from tkinter import messagebox
import time
import threading

class EightQueensGUI:
 def __init__(self, root):
 self.root = root
 self.root.title("八皇后问题演示")
 self.root.geometry("650x750")
 
 self.board_size = 8
 self.cell_size = 50
 self.delay = 100
 
 self.setup_ui()
 self.solutions = []
 self.current_solution = 0
 self.solving = False
 self.solve_thread = None
 
 def setup_ui(self):
 # 创建主框架
 main_frame = tk.Frame(self.root)
 main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
 
 # 创建画布
 self.canvas = tk.Canvas(main_frame, width=500, height=500, bg='white')
 self.canvas.pack(pady=10)
 
 # 创建控制按钮框架
 control_frame = tk.Frame(main_frame)
 control_frame.pack(pady=10, fill=tk.X)
 
 # 第一行按钮
 btn_frame1 = tk.Frame(control_frame)
 btn_frame1.pack(pady=5)
 
 self.solve_btn = tk.Button(btn_frame1, text="开始求解", command=self.solve, width=10)
 self.solve_btn.pack(side=tk.LEFT, padx=5)
 
 self.next_btn = tk.Button(btn_frame1, text="下一个解", command=self.next_solution, width=10)
 self.next_btn.pack(side=tk.LEFT, padx=5)
 
 self.prev_btn = tk.Button(btn_frame1, text="上一个解", command=self.prev_solution, width=10)
 self.prev_btn.pack(side=tk.LEFT, padx=5)
 
 self.stop_btn = tk.Button(btn_frame1, text="停止求解", command=self.stop_solving, width=10)
 self.stop_btn.pack(side=tk.LEFT, padx=5)
 
 # 第二行控件
 btn_frame2 = tk.Frame(control_frame)
 btn_frame2.pack(pady=5, fill=tk.X)
 
 # 速度控制
 speed_frame = tk.Frame(btn_frame2)
 speed_frame.pack(side=tk.LEFT, padx=10)
 
 tk.Label(speed_frame, text="速度:").pack(side=tk.LEFT)
 self.speed_scale = tk.Scale(speed_frame, from_=10, to=500, orient=tk.HORIZONTAL,
 length=200, showvalue=True, command=self.update_delay)
 self.speed_scale.set(self.delay)
 self.speed_scale.pack(side=tk.LEFT, padx=5)
 
 # 解决方案选择
 sol_frame = tk.Frame(btn_frame2)
 sol_frame.pack(side=tk.RIGHT, padx=10)
 
 tk.Label(sol_frame, text="直接查看解:").pack(side=tk.LEFT)
 self.solution_var = tk.StringVar(value="1")
 self.solution_spinbox = tk.Spinbox(sol_frame, from_=1, to=92, width=5, textvariable=self.solution_var,
 command=self.jump_to_solution)
 self.solution_spinbox.pack(side=tk.LEFT, padx=5)
 
 # 信息标签
 self.info_label = tk.Label(main_frame, text="点击'开始求解'来演示八皇后问题的解法", 
 font=("Arial", 12), wraplength=600)
 self.info_label.pack(pady=5)
 
 # 状态标签
 self.status_label = tk.Label(main_frame, text="", font=("Arial", 10), fg="blue")
 self.status_label.pack(pady=5)
 
 # 绘制初始棋盘
 self.draw_board()
 
 def draw_board(self):
 self.canvas.delete("all")
 
 # 绘制棋盘
 for row in range(self.board_size):
 for col in range(self.board_size):
 x1 = col * self.cell_size + 50
 y1 = row * self.cell_size + 50
 x2 = x1 + self.cell_size
 y2 = y1 + self.cell_size
 
 color = "#DEB887" if (row + col) % 2 == 0 else "#8B4513"
 self.canvas.create_rectangle(x1, y1, x2, y2, fill=color, outline="black")
 
 # 绘制行列标记
 for i in range(self.board_size):
 # 行标记 (A-H)
 self.canvas.create_text(25, i * self.cell_size + 50 + self.cell_size // 2, 
 text=chr(65 + i), font=("Arial", 12, "bold"))
 # 列标记 (1-8)
 self.canvas.create_text(i * self.cell_size + 50 + self.cell_size // 2, 25, 
 text=str(i + 1), font=("Arial", 12, "bold"))
 
 def draw_queens(self, board):
 self.draw_board()
 
 for row in range(self.board_size):
 for col in range(self.board_size):
 if board[row][col] == 1:
 self.draw_queen(row, col)
 
 self.root.update()
 
 def draw_queen(self, row, col):
 x = col * self.cell_size + 50 + self.cell_size // 2
 y = row * self.cell_size + 50 + self.cell_size // 2
 radius = self.cell_size // 3
 
 # 绘制皇后
 self.canvas.create_oval(x - radius, y - radius, x + radius, y + radius, 
 fill="red", outline="darkred", width=2)
 
 # 绘制皇冠
 crown_points = [
 x - radius//2, y - radius,
 x - radius//3, y - radius//2,
 x, y - radius,
 x + radius//3, y - radius//2,
 x + radius//2, y - radius
 ]
 self.canvas.create_polygon(crown_points, fill="gold", outline="darkgoldenrod", width=2)
 
 def is_safe(self, board, row, col):
 # 检查同一列
 for i in range(row):
 if board[i][col] == 1:
 return False
 
 # 检查左上对角线
 for i, j in zip(range(row-1, -1, -1), range(col-1, -1, -1)):
 if board[i][j] == 1:
 return False
 
 # 检查右上对角线
 for i, j in zip(range(row-1, -1, -1), range(col+1, self.board_size)):
 if board[i][j] == 1:
 return False
 
 return True
 
 def solve_n_queens(self, board, row=0):
 if not self.solving:
 return False
 
 if row >= self.board_size:
 # 找到解，复制当前棋盘状态
 solution = [row[:] for row in board]
 self.solutions.append(solution)
 self.update_status(f"找到第 {len(self.solutions)} 个解")
 
 # 更新显示
 self.draw_queens(board)
 time.sleep(self.delay / 1000)
 
 # 继续寻找更多解
 return False
 
 for col in range(self.board_size):
 if not self.solving:
 return False
 
 if self.is_safe(board, row, col):
 board[row][col] = 1
 
 # 更新显示
 self.draw_queens(board)
 self.update_info(f"尝试在位置 ({chr(65+row)}{col+1}) 放置皇后")
 time.sleep(self.delay / 1000)
 
 # 递归调用
 self.solve_n_queens(board, row + 1)
 
 # 回溯
 board[row][col] = 0
 
 # 更新显示
 self.draw_queens(board)
 self.update_info(f"回溯: 移除位置 ({chr(65+row)}{col+1}) 的皇后")
 time.sleep(self.delay / 1000)
 
 return False
 
 def solve(self):
 self.solve_btn.config(state=tk.DISABLED)
 self.stop_btn.config(state=tk.NORMAL)
 self.solutions = []
 self.solving = True
 board = [[0 for _ in range(self.board_size)] for _ in range(self.board_size)]
 
 # 在新线程中运行求解过程
 self.solve_thread = threading.Thread(target=self.solve_thread_func, args=(board,))
 self.solve_thread.daemon = True
 self.solve_thread.start()
 
 def solve_thread_func(self, board):
 # 使用改进的算法找到所有解
 self.find_all_solutions(board)
 
 if self.solving:
 if self.solutions:
 self.current_solution = 0
 self.show_solution_info()
 self.update_status(f"求解完成! 共找到 {len(self.solutions)} 个解")
 self.solution_spinbox.config(to=len(self.solutions))
 self.solution_var.set("1")
 else:
 self.update_status("未找到解!")
 
 self.solve_btn.config(state=tk.NORMAL)
 self.stop_btn.config(state=tk.DISABLED)
 self.solving = False
 
 def find_all_solutions(self, board, row=0):
 """找到所有解的递归函数"""
 if not self.solving:
 return
 
 if row >= self.board_size:
 # 找到一个解
 solution = [row[:] for row in board]
 self.solutions.append(solution)
 self.update_status(f"找到第 {len(self.solutions)} 个解")
 
 # 显示当前解
 self.draw_queens(board)
 time.sleep(self.delay / 1000)
 return
 
 for col in range(self.board_size):
 if not self.solving:
 return
 
 if self.is_safe(board, row, col):
 board[row][col] = 1
 
 # 更新显示
 self.draw_queens(board)
 self.update_info(f"尝试在位置 ({chr(65+row)}{col+1}) 放置皇后")
 time.sleep(self.delay / 1000)
 
 # 递归调用
 self.find_all_solutions(board, row + 1)
 
 # 回溯
 board[row][col] = 0
 
 # 更新显示
 self.draw_queens(board)
 self.update_info(f"回溯: 移除位置 ({chr(65+row)}{col+1}) 的皇后")
 time.sleep(self.delay / 1000)
 
 def stop_solving(self):
 self.solving = False
 self.update_status("求解已停止")
 
 def show_solution_info(self):
 if self.solutions and 0 <= self.current_solution < len(self.solutions):
 solution = self.solutions[self.current_solution]
 self.draw_queens(solution)
 self.update_info(f"解 {self.current_solution + 1}/{len(self.solutions)}")
 
 def next_solution(self):
 if self.solutions:
 self.current_solution = (self.current_solution + 1) % len(self.solutions)
 self.solution_var.set(str(self.current_solution + 1))
 self.show_solution_info()
 
 def prev_solution(self):
 if self.solutions:
 self.current_solution = (self.current_solution - 1) % len(self.solutions)
 self.solution_var.set(str(self.current_solution + 1))
 self.show_solution_info()
 
 def jump_to_solution(self):
 if self.solutions:
 try:
 sol_num = int(self.solution_var.get()) - 1
 if 0 <= sol_num < len(self.solutions):
 self.current_solution = sol_num
 self.show_solution_info()
 except ValueError:
 pass
 
 def update_delay(self, value):
 self.delay = int(value)
 
 def update_info(self, text):
 self.info_label.config(text=text)
 self.root.update_idletasks()
 
 def update_status(self, text):
 self.status_label.config(text=text)
 self.root.update_idletasks()

def main():
 root = tk.Tk()
 app = EightQueensGUI(root)
 root.mainloop()

if __name__ == "__main__":
 main()

思想

该程序使用穷举法，并通过UI展示了完整的穷举过程，可以访问穷举结果。穷举中如果出现错误的情况就回溯。

执行效果

算法：两数之和（哈希算法）

Tue, 05 Apr 2022 20:16:44 +0800

题目来源
分析
我的程序
运行结果

题目来源

LeetCode：https://leetcode-cn.com/problems/two-sum

分析

具体思想可以参考这个题解的演示：https://leetcode-cn.com/problems/two-sum/solution/tu-jie-guan-fang-tui-jian-ti-jie-liang-s-02xs/，LeetCode中使用的哈希算法是通过uthash.h这个文件实现的，该文件本来是个开源项目，目前已整合到gcc中，关于其使用请参考uthash的文档：https://troydhanson.github.io/uthash/userguide.html。

我的程序

struct numsHash{
 int key;	// 键值
 int val;	// 数据
 UT_hash_handle hh;
};
struct numsHash* pNumsHashHead = NULL;

struct numsHash* Find_NumsHash(int targetKey)	// 定义查询函数
{
 struct numsHash *pReturn;
 HASH_FIND_INT(pNumsHashHead, &targetKey, pReturn);
 return pReturn;
}

void Add_NumsHash(int addKey, int addVal)
{
 struct numsHash* pTarget = Find_NumsHash(addKey);
 if(pTarget == NULL){
 struct numsHash* pTempHash = malloc(sizeof(struct numsHash));
 pTempHash->key = addKey;
 pTempHash->val = addVal;
 HASH_ADD_INT(pNumsHashHead, key, pTempHash);
 }
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
 pNumsHashHead = NULL;
 for(int i = 0; i < numsSize; i++){
 struct numsHash* pTempHash = Find_NumsHash(target - nums[i]);
 if(pTempHash != NULL){
 int* ret = malloc(sizeof(int) * 2);
 ret[0] = pTempHash->val;
 ret[1] = i;
 *returnSize = 2;
 return ret;
 }
 Add_NumsHash(nums[i], i);
 }
 *returnSize = 0;
 return NULL;
}

运行结果

执行用时	内存消耗
4ms	7.6MB

算法：两数之和（暴力枚举）

Tue, 05 Apr 2022 20:16:15 +0800

题目来源
我的程序
结果
官方答案
结果
分析

题目来源

LeetCode：https://leetcode-cn.com/problems/two-sum

我的程序

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
 int* ret = NULL;
 *returnSize = 0;
 int temp = 0;
 for(int i = 0; i < numsSize; ++i)
 {
 for(int j = i + 1; j < numsSize; ++j)
 {
 if(nums[i] + nums[j] == target)
 {
 *returnSize += 2;
 ret = realloc(ret, sizeof(int) * (*returnSize));
 ret[temp++] = i;
 ret[temp++] = j;
 }
 }
 }
 return ret;
}

结果

执行用时	内存消耗
152ms	6.1MB

官方答案

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
 for (int i = 0; i < numsSize; ++i) {
 for (int j = i + 1; j < numsSize; ++j) {
 if (nums[i] + nums[j] == target) {
 int* ret = malloc(sizeof(int) * 2);
 ret[0] = i, ret[1] = j;
 *returnSize = 2;
 return ret;
 }
 }
 }
 *returnSize = 0;
 return NULL;
}

结果

执行用时	内存消耗
92ms	6.3MB

分析

我的程序是整个完全遍历完了找出所有解，而官方是找到后直接跳出。相对于这道题来说官方的答案很显然更加贴近题意，但是我的程序更加具有普遍性（因为适合满足多组解的情况）。

二分查找

Sat, 02 Apr 2022 19:15:43 +0800

题目来源
题目内容
分析
我的程序
运行结果

题目来源

浙大数据结构MOOC-PTA的课后题

题目内容

分析

就是个普通的二分查找，没啥好分析的。

我的程序

Position BinarySearch( List L, ElementType X )
{
 Position left, right;
 left = 1;
 right = L->Last;
 while(left <= right)
 {
 Position middle = (left + right) / 2; // 记录中间位置
 if(L->Data[middle] == X)return middle;
 else if(L->Data[middle] < X)left = middle +1;
 else if(L->Data[middle] > X)right = middle - 1;
 }
 return NotFound;
}

运行结果

算法：Maximum Subsequence Sum

Sat, 02 Apr 2022 19:09:57 +0800

题目来源
题目内容
分析
我的程序
运行结果

题目来源

浙大数据结构MOOC-PTA的课后题

题目内容

分析

这一题时最大子列和问题的变形，需要输出最大子列和的子列首项与末项，且在数列全为负的情况下，最大子列和为0，且需要输出首尾。而且如果出现了前后有相同都是最大子列的情况，选择前面的那一个。

我继续沿用了最大子列和问题中的在线处理算法，但是加上了对子列首尾的处理。

说实话这题有点难，我的做法也稍微有点取巧，使用专门的标志来处理非正有0的情况，不过总体来说结果是过了。

我的程序

#include <stdio.h>

int main()
{
 // 获取数据
 int size;
 scanf("%d", &size);
 int num[size];
 int max = 0, this = 0;
 // 记录首尾位置
 int start = 0, end = 0, temp = 0;
 // 记录负数和正数的个数
 int negFlag = 0;
 int posFlag = 0;
 // 在线处理，寻找最大子列和同时记录该子列和首尾位置
 for(int i = 0; i < size; i++)
 {
 scanf("%d", num + i);
 // 记录正数和负数的个数，等会有用
 if(num[i] < 0)negFlag++;
 else if(num[i] > 0)posFlag++;
 // 计算子列和
 this += num[i];
 if(this > max)
 {
 max = this;
 // 当最大子列和发生了变化，记录其末尾，并将之前缓存的首部放入start
 end = i;
 start = temp;
 }
 else if(this < 0)
 {
 this = 0;
 // 当在线处理发现了子列和为负数的情况，需要丢弃前面的子列和，此时使用temp记录此次更新，因为它可能成为最大子列和的首项
 temp = i + 1;
 }
 }
 if(negFlag == size)printf("%d %d %d", 0, num[0], num[size - 1]);	// 全是负数，输出最大值0和首尾项
 else if(posFlag > 0)printf("%d %d %d", max, num[start], num[end]);	// 如果有正数，则必然存在非零最大子列
 else if(posFlag == 0)printf("0 0 0");	// 如果没有正数，又不全是负数，则最大子列和是0，且子列内容也全是0，直接输出0
 return 0;
}

运行结果

算法：最大子列和问题

Sat, 02 Apr 2022 18:45:44 +0800

题目来源
题目内容
分析
我的程序
运行结果

题目来源

浙大数据结构MOOC-PTA的课后题

题目内容

分析

这个程序在课程里讲过，一共有四种方法，其中两种是同一种方法，只是进行了优化，这道题没有什么好分析的，直接写就行了。

我的程序

暴力穷举：

#include <stdio.h>

int main()
{
 // 获取数据
 int size;
 scanf("%d", &size);
 int num[size];
 int max = 0, this = 0;
 for(int i = 0; i < size; i++)
 {
 scanf("%d", num + i);
 }
 // 穷举所有子列并找出最大和
 for(int i = 0; i < size; i++)	// 分别以每个项作为子列起点，然后计算这个起点所有子列和
 {
 this = 0;	// 每次计算完子列，都需要清空
 for(int j = i; j < size; j++)	// 计算当前所在起点的所有子列和
 {
 this += num[j];
 if(this > max)max = this;	// 当出现了更大的子列和时，将其存入max
 }
 }
 printf("%d", max);	// 打印出来
 return 0;
}

这种解法的时间复杂度为O(N^2^)，虽然能用但是还差点意思。

分而治之：

#include <stdio.h>

int getMaxSequenceSum(int* num, int size);

int main()
{
 int size;
 scanf("%d", &size);
 int num[size];
 int max = 0;
 for(int i = 0; i < size; i++)
 {
 scanf("%d", num + i);
 }
 max = getMaxSequenceSum(num, size);
 printf("%d", max);
 return 0;
}

int getMaxSequenceSum(int* num, int size) // 分而治之，左右分并分别计算最大子列和，然后从中间向两边延申计算最大子列和，比较三者，最终得到最大子列和
{
 if(size == 1)
 {
 return num[0]>0?num[0]:0; // 不可再分时，最大子列和就是本身或0（小于0的情况）
 }
 int left = getMaxSequenceSum(num, size / 2);
 int right = getMaxSequenceSum(num + size / 2, size - size / 2);
 int mid_l = 0, mid_r = 0;
 int max = 0, this = 0;
 for(int i = 1; i <= size / 2; i++)
 {
 this += num[size / 2 - i];
 if(mid_l < this)mid_l = this;
 }
 this = 0;
 for(int i = 0; i < size / 2; i++)
 {
 this += num[size / 2 + i];
 if(mid_r < this)mid_r = this;
 }
 max = mid_l + mid_r > left?mid_l + mid_r:left;
 return max > right?max:right;
}

这种解法的时间复杂度为O(NlogN)，已经是一种非常优秀的解法了。

在线处理：

#include <stdio.h>

int main()
{
 // 获取数据
 int size;
 scanf("%d", &size);
 int num[size];
 int max = 0, this = 0;
 for(int i = 0; i < size; i++)
 {
 scanf("%d", num + i);
 this += num[i];
 if(this > max)max = this;
 else if(this < 0)this = 0;
 }
 printf("%d", max);	// 打印出来
 return 0;
}

在线处理的时间复杂度是O(N)，时间复杂度是线性的算法，是该问题的最优解。

运行结果

下面的配图是我在MOOC中提交的图，里面代码没有优化，所以结果可能和预期有一点差别，不过整体大差没差。

1.暴力穷举

2.分而治之

3.在线处理