0.目录
1.介绍
2.一些通用函数
3.全局变量（宏变量）
4.数独预处理（约束传播）
5.解数独（深度优先搜索+最小代价优先）
6.主函数
7.总代码
1.介绍
数独是一个非常有趣味性的智力游戏，数独起源于18世纪初瑞士数学家欧拉等人研究的拉丁方阵（Latin Square）。
参与者需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个宫内的数字均含1-9，不重复。
一个数独谜题是由81个方块组成的网格。大部分爱好者把列标为1-9，把行标为A-I，把9个方块的一组（列，行，或者方框）称为一个单元，把处于同一单元的方块称为对等方块。谜题中有些方块是空白的，其他的填入了数字。
每个方块都属于3个单元，有20个对等方块。
当每个单元的方块填入了1到9的一个排列时，谜题就解决了。
本文采用解空间搜索的深度优先搜索（最小代价优先）加约束传播算法来解数独。
代码总体分为五个部分：
1.通用函数
2.全局变量（宏变量）
3.数独预处理（约束传播）
4.解数独（深度优先搜索+最小代价优先）
5.主函数
2.一些通用函数
import time
def cross(A, B):
# 例如：A = ‘ABC‘, B = ‘123‘
# 则返回[‘A1‘, ‘A2‘, ‘A3‘, ‘B1‘, ‘B2‘, ‘B3‘, ‘C1‘, ‘C2‘, ‘C3‘]
return [a+b for a in A for b in B]
def arr_to_dict(A, B):
# 例如：A = [‘A‘, ‘B‘, ‘C‘], B = [‘1‘, ‘2‘, ‘3‘]
# 则返回{‘A‘: ‘1‘, ‘B‘: ‘2‘, ‘C‘: ‘3‘}
return dict(zip(A, B))
def str_to_arr(str_sudoku):
# 传入：str_sudoku = ‘4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......‘
# 返回[‘4‘, ‘.‘, ‘.‘, ‘.‘, ‘.‘, ‘.‘, ‘8‘, ... , ‘.‘, ‘.‘]
return [c for c in str_sudoku if c in cols or c in ‘0.‘]
def show_str_sudoku(str_sudoku):
# 解析字符串形式的数独并展示
for i, value in enumerate(str_sudoku):
if i%3 == 0 and i%9 != 0:
print(‘|‘, end=‘ ‘)
print(value, end=‘ ‘)
if (i+1)%9 == 0:
print()
if i == 26 or i == 53:
print(‘------+-------+------‘)
def show_dict_sudoku(dict_sudoku):
# 解析字典形式的数独并展示
width = 1 + max(len(dict_sudoku[s]) for s in squares)
line = ‘+‘.join([‘-‘ * (width * 3)] * 3)
for r in rows:
print(‘‘.join(dict_sudoku[r + c].center(width) + (‘|‘ if c in ‘36‘ else ‘‘) for c in cols))
if r in ‘CF‘: print(line)
print()cross函数：输出A、B交叉组合而成的字符串
arr_to_dict函数：将数组形式的数独转化为字典形式的数独
str_to_arr函数：将字符串形式的数独转化为数组形式的数独
show_str_sudoku函数：解析字符串形式的数独并显示
show_dict_sudoku函数：解析字典形式的数独并显示
3.全局变量（宏变量）
用Python按如下方式来实现单元、对等方块、方块的概念：
cols = ‘123456789‘
rows = ‘ABCDEFGHI‘
# squares表示 9*9个元素编号:[‘A1‘, ‘A2‘, ‘A3‘, ... , ‘I8‘, ‘I9‘]
squares = cross(rows, cols)
# unitlist表示 3*9个单元列表:
unitlist = ([cross(rows, c) for c in cols] + [cross(r, cols) for r in rows] + [cross(rs, cs) for rs in (‘ABC‘,‘DEF‘,‘GHI‘) for cs in (‘123‘,‘456‘,‘789‘)])
# units表示 某个元素编号:与之相关的3个单元列表
units = dict((s, [u for u in unitlist if s in u]) for s in squares)
# peers表示 某个元素编号:与之相关的20个元素编号
peers = dict((s, set(sum(units[s], []))-set([s])) for s in squares)squares代表81个元素编号
unitlist代表27个不能出现重复数字的单元
units表示某个元素编号以及与之对应的3个单元列表
peers表示某个元素编号以及与之相关的20个元素编号
4.数独预处理（约束传播）
初始数独的样子：
以下是简单的预处理函数：
# 一.数独预处理
def parse_sudoku(str_sudoku):
# values代表各位置上可能的取值:{‘A1‘: ‘123456789‘, ‘A2‘: ‘123456789‘, ... , ‘I8‘: ‘123456789‘, ‘I9‘: ‘123456789‘}
values = dict((s, cols) for s in squares)
# arr_sudoku为数组形式, dict_sudoku为字典形式, 均为81位
arr_sudoku = str_to_arr(str_sudoku)
dict_sudoku = arr_to_dict(squares, arr_sudoku)# {‘A1‘: ‘4‘, ‘A2‘: ‘.‘, ... , ‘I8‘: ‘.‘, ‘I9‘: ‘.‘}
for key,value in dict_sudoku.items():
if value in cols and not assign(values, key, value):
return False
return values
def assign(values, key, value):
# 从values[key]中删除除了value以外的所有值，因为value是唯一的值
# 如果在过程中发现矛盾，则返回False
other_values = values[key].replace(value, ‘‘)
if all(eliminate(values, key, num) for num in other_values):
return values
else:
return False
def eliminate(values, key, num):
# 从values[key]中删除值num，因为num是不可能的
if num not in values[key]:
return values
values[key] = values[key].replace(num, ‘‘)
return values共三个函数。values[key]代表在key这个位置上的可能取值。
parse_sudoku函数：预处理的入口函数
assign函数：从values[key]中删除除了value以外的所有值
eliminate函数：从values[key]中删除值num
处理完后的数独为：
以上只是简单的进行的数独的预处理。
但是其实根据数独的规则，我们可以得到以下两条原则：
(1).如果一个方块只有一个可能值，把这个值从方块的对等方块（的可能值）中排除;
(2).如果一个单元只有一个可能位置来放某个值，就把值放那。
于是我们根据这个策略可以改写eliminate函数：
def eliminate(values, key, num):
# 从values[key]中删除值num，因为num是不可能的
if num not in values[key]:
return values
values[key] = values[key].replace(num, ‘‘)
# 这里采用了约束传播
# 1.如果一个方块只有一个可能值，把这个值从方块的对等方块（的可能值）中排除。
if len(values[key]) == 0:
return False
elif len(values[key]) == 1:
only_value = values[key]
# 从与之相关的20个元素中删除only_value
if not all(eliminate(values, peer, only_value) for peer in peers[key]):
return False
# 2.如果一个单元只有一个可能位置来放某个值，就把值放那。
for unit in units[key]:
dplaces = [s for s in unit if num in values[s]]
if len(dplaces) == 0:
return False
elif len(dplaces) == 1:
only_key = dplaces[0]
if not assign(values, only_key, num):
return False
return values于是数独的预处理结果变为了：
这样是不是就把问题规模一下子简化了很多。
5.解数独（深度优先搜索+最小代价优先）
因为没有规定数独只有唯一解，所以以下程序实际上求解了数独的所有解。
# 二.解数独
def solve_sudoku(str_sudoku):
return search_sudoku(parse_sudoku(str_sudoku))
def search_sudoku(values):
if values is False:
return False
if all(len(values[s]) == 1 for s in squares):
return values
# 选择可能值数目最少的方块, 进行深度优先搜索
n, key = min((len(values[key]), key) for key in squares if len(values[key]) > 1)
return some_result(search_sudoku(assign(values.copy(), key, num)) for num in values[key])
def some_result(values):
for result in values:
if result:
return result
return Falsesolve_sudoku函数：是真正的解数独的入口，将数独预处理完毕的结果抛给search_sudoku函数求解
search_sudoku函数：是一个递归函数，采用的代价函数是选择可能值数目最少的方块，然后进行深度优先搜索遍历。
some_result函数：是在深度优先搜索的结果中找出满足条件的数独返回。如果想要所有解，那么可以改成返回一个解的列表。
如果想要程序更快，那么就可以只找一个解。可以在深度优先搜索的循环代码中，返回找到的满足条件的解即可。
6.主函数
if __name__ == ‘__main__‘:
# str_sudoku为字符串形式, 为81位
str_sudoku = [‘4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......‘]
# str_sudoku = [‘4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......‘,
# ‘003020600900305001001806400008102900700000008006708200002609500800203009005010300‘,
# ‘.....6....59.....82....8....45........3........6..3.54...325..6..................‘]
for sudoku in str_sudoku:
start = time.clock()
solve_result = solve_sudoku_1(sudoku)
end = time.clock()
print(‘初始数独为：‘)
show_str_sudoku(sudoku)
print(‘解为：‘)
show_dict_sudoku(solve_result)
print("求解数独运行时间为: %f s" % (end - start))解出来数独的结果为：
7.总代码
‘‘‘
数独是一个非常有趣味性的智力游戏
参与者需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，
并满足每一行、每一列、每一个宫内的数字均含1-9，不重复。
‘‘‘
__author__ = ‘PyLearn‘
import time
def cross(A, B):
# 例如：A = ‘ABC‘, B = ‘123‘
# 则返回[‘A1‘, ‘A2‘, ‘A3‘, ‘B1‘, ‘B2‘, ‘B3‘, ‘C1‘, ‘C2‘, ‘C3‘]
return [a+b for a in A for b in B]
def arr_to_dict(A, B):
# 例如：A = [‘A‘, ‘B‘, ‘C‘], B = [‘1‘, ‘2‘, ‘3‘]
# 则返回{‘A‘: ‘1‘, ‘B‘: ‘2‘, ‘C‘: ‘3‘}
return dict(zip(A, B))
def str_to_arr(str_sudoku):
# 传入：str_sudoku = ‘4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......‘
# 返回[‘4‘, ‘.‘, ‘.‘, ‘.‘, ‘.‘, ‘.‘, ‘8‘, ... , ‘.‘, ‘.‘]
return [c for c in str_sudoku if c in cols or c in ‘0.‘]
def show_str_sudoku(str_sudoku):
# 解析字符串形式的数独并展示
for i, value in enumerate(str_sudoku):
if i%3 == 0 and i%9 != 0:
print(‘|‘, end=‘ ‘)
print(value, end=‘ ‘)
if (i+1)%9 == 0:
print()
if i == 26 or i == 53:
print(‘------+-------+------‘)
def show_dict_sudoku(dict_sudoku):
# 解析字典形式的数独并展示
width = 1 + max(len(dict_sudoku[s]) for s in squares)
line = ‘+‘.join([‘-‘ * (width * 3)] * 3)
for r in rows:
print(‘‘.join(dict_sudoku[r + c].center(width) + (‘|‘ if c in ‘36‘ else ‘‘) for c in cols))
if r in ‘CF‘: print(line)
print()
cols = ‘123456789‘
rows = ‘ABCDEFGHI‘
# squares表示 9*9个元素编号:[‘A1‘, ‘A2‘, ‘A3‘, ... , ‘I8‘, ‘I9‘]
squares = cross(rows, cols)
# unitlist表示 3*9个单元列表:
unitlist = ([cross(rows, c) for c in cols] + [cross(r, cols) for r in rows] + [cross(rs, cs) for rs in (‘ABC‘,‘DEF‘,‘GHI‘) for cs in (‘123‘,‘456‘,‘789‘)])
# units表示 某个元素编号:与之相关的3个单元列表
units = dict((s, [u for u in unitlist if s in u]) for s in squares)
# peers表示 某个元素编号:与之相关的20个元素编号
peers = dict((s, set(sum(units[s], []))-set([s])) for s in squares)
# 一.数独预处理
def parse_sudoku(str_sudoku):
# values代表各位置上可能的取值:{‘A1‘: ‘123456789‘, ‘A2‘: ‘123456789‘, ... , ‘I8‘: ‘123456789‘, ‘I9‘: ‘123456789‘}
values = dict((s, cols) for s in squares)
# arr_sudoku为数组形式, dict_sudoku为字典形式, 均为81位
arr_sudoku = str_to_arr(str_sudoku)
dict_sudoku = arr_to_dict(squares, arr_sudoku)# {‘A1‘: ‘4‘, ‘A2‘: ‘.‘, ... , ‘I8‘: ‘.‘, ‘I9‘: ‘.‘}
for key,value in dict_sudoku.items():
if value in cols and not assign(values, key, value):
return False
return values
def assign(values, key, value):
# 从values[key]中删除除了value以外的所有值，因为value是唯一的值
# 如果在过程中发现矛盾，则返回False
other_values = values[key].replace(value, ‘‘)
if all(eliminate(values, key, num) for num in other_values):
return values
else:
return False
def eliminate(values, key, num):
# 从values[key]中删除值num，因为num是不可能的
if num not in values[key]:
return values
values[key] = values[key].replace(num, ‘‘)
# 这里采用了约束传播
# 1.如果一个方块只有一个可能值，把这个值从方块的对等方块（的可能值）中排除。
if len(values[key]) == 0:
return False
elif len(values[key]) == 1:
only_value = values[key]
# 从与之相关的20个元素中删除only_value
if not all(eliminate(values, peer, only_value) for peer in peers[key]):
return False
# 2.如果一个单元只有一个可能位置来放某个值，就把值放那。
for unit in units[key]:
dplaces = [s for s in unit if num in values[s]]
if len(dplaces) == 0:
return False
elif len(dplaces) == 1:
only_key = dplaces[0]
if not assign(values, only_key, num):
return False
return values
# 二.解数独
def solve_sudoku(str_sudoku):
return search_sudoku(parse_sudoku(str_sudoku))
def search_sudoku(values):
if values is False:
return False
if all(len(values[s]) == 1 for s in squares):
return values
# 选择可能值数目最少的方块, 进行深度优先搜索
n, key = min((len(values[key]), key) for key in squares if len(values[key]) > 1)
return some_result(search_sudoku(assign(values.copy(), key, num)) for num in values[key])
def some_result(values):
for result in values:
if result:
return result
return False
if __name__ == ‘__main__‘:
# str_sudoku为字符串形式, 为81位
str_sudoku = [‘4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......‘]
# str_sudoku = [‘4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......‘,
# ‘003020600900305001001806400008102900700000008006708200002609500800203009005010300‘,
# ‘.....6....59.....82....8....45........3........6..3.54...325..6..................‘]
for sudoku in str_sudoku:
start = time.clock()
solve_result = solve_sudoku_1(sudoku)
end = time.clock()
print(‘初始数独为：‘)
show_str_sudoku(sudoku)
print(‘解为：‘)
show_dict_sudoku(solve_result)
print("求解数独运行时间为: %f s" % (end - start))