【发布时间】：2012-04-12 17:05:33
【问题描述】：
我有一个包含 81 个顶点的漂亮图（一个列表）（每个顶点都是 Vertex 类的一个实例）。每个顶点有 20 个邻居。每个顶点都有许多可能的值（范围从 1 到 9），给定问题的一些初始约束，平均为 4 或 5。我在此图上实现了一个简单的 DFS，它采用可能值较少的节点， foreach 值构建另一个只有一个可能值的“深度复制”图，最后递归地将“深度复制”图再次传递到 DFS。问题在于速度； cProfiling 我的代码我发现我的 Mac 用来解决这个问题的 641 秒中有 635 秒被 copy.deepcopy 使用。有没有解决这个问题的方法？这是我的 DFS：
def dfs(graph):
global initial_time_counter
if all(len(i.possible_values)==1 for i in graph):
sys.exit("Done in: %s" % (time.time()-initial_time_counter))
#find out the non-solved vertex with minimum possible values
min_vertex=sorted(filter(lambda x: len(x.possible_values)>1,graph),
key=lambda x: len(x.possible_values))[0]
for value in min_vertex.possible_values:
sorted_graph_copy=sorted(copy.deepcopy(graph), key=lambda x: len(x.possible_values))
min_vertex_copy=filter(lambda x: len(x.possible_values)>1,sorted_graph_copy)[0]
sorted_graph_copy.remove(min_vertex_copy)
if min_vertex_copy.try_value(value): #Can this vertex accept value -> value?
min_vertex_copy.set_value(value) #Yes, set it.
sorted_graph_copy.append(min_vertex_copy) #Append it to the graph.
dfs(sorted_graph_copy) #Run the DFS again.
return False
附：你们中最聪明的人可能已经理解这个问题通常被称为数独。请注意，我不是在寻找特定于数独的答案，请以抽象的方式分析问题。
[编辑]
同样的问题，用顶点的纯字符串表示来解决，需要
import sys,time
def srange():
return [[x,y] for x in range(9) for y in range(9)]
def represent_sudoku(sudoku):
print "\n".join(["|".join([str(elem) for elem in line]) for line in sudoku])
#Hard sudoku
sudoku=[[4, 0, 0, 0, 0, 0, 8, 0, 5], [0, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 7, 0, 0, 0, 0, 0], [0, 2, 0, 0, 0, 0, 0, 6, 0], [0, 0, 0, 0, 8, 0, 4, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 6, 0, 3, 0, 7, 0], [5, 0, 0, 2, 0, 0, 0, 0, 0], [1, 0, 4, 0, 0, 0, 0, 0, 0]]
represent_sudoku(sudoku)
def get_nbs(x,y,sudoku,also_incomplete=False):
line_nbs=sum([elem for elem in sudoku[y] if ((elem!=[0] and len(elem)==1) or also_incomplete)],[])
column_nbs=sum([sudoku[xline][x] for xline in range(9) if ((sudoku[xline][x]!=[0] and len(sudoku[xline][x])==1) or also_incomplete)],[])
area_nbs=[[j for j in i[(x/3)*3:(x/3)*3+3] if ((j!=[0] and len(j)==1) or also_incomplete)] for i in sudoku[(y/3)*3:(y/3)*3+3]]
area_nbs=sum(sum(area_nbs,[]),[])
if not also_incomplete:
return list(set(line_nbs+column_nbs+area_nbs))
return line_nbs+column_nbs+area_nbs
for x,y in srange():
sudoku[y][x]=[sudoku[y][x]]
def base_cleanup(sudoku):
while 1:
something_changed=False
for x,y in srange():
if sudoku[y][x]==[0] or len(sudoku[y][x])>1:
possible_values=range(1,10) if sudoku[y][x]==[0] else sudoku[y][x]
sudoku[y][x]=list(set(possible_values)-set(get_nbs(x,y,sudoku)))
if sudoku[y][x]==[]:
return False
something_changed=True if possible_values!=sudoku[y][x] else False
else:
sudoku[y][x]=sudoku[y][x]
if not something_changed:
break
return sudoku
def dfs(graph):
global s
if graph==False:
return False
if all(sum([[len(elem)==1 for elem in line] for line in graph],[])):
represent_sudoku(graph)
sys.exit("Done in: %s" % (time.time()-s))
enumerated_filtered_sudoku=filter(lambda x: len(x[1])>1, enumerate(sum(graph,[])))
sorted_enumerated_sudoku=sorted(enumerated_filtered_sudoku,key=lambda x: len(x[1]))
min_vertex=sorted_enumerated_sudoku[0]
possible_values=[value for value in min_vertex[1]]
for value in possible_values:
graph_copy=[[elem for elem in line] for line in graph]
y,x=elements_position[min_vertex[0]]
if not any(value==i for i in get_nbs(x,y,graph_copy)):
graph_copy[y][x]=[value]
if base_cleanup(graph_copy)!=False:
graph_copy=base_cleanup(graph_copy)
if graph_copy:
dfs(graph_copy)
return False
sudoku = base_cleanup(sudoku)
elements_position = {i:srange()[i] for i in range(81)}
s = time.time()
dfs(sudoku)
【问题讨论】：
-
使用在 C 中实现了 .copy 方法的 python 图类？可能是（networkx.lanl.gov）
-
假设我想留在 cPython 边界内。
-
您可以在 C 中创建自己的图形结构并使用 python 包装器在 python 中使用它并创建一个复制方法来复制连续的内存块......我可能会看看那个 networkX 包复制速度更快，但我不能保证，但我认为它提供了 graph.copy() 方法（iirc ...）
-
@luke14free - FWIW 几年前我用 Ruby 写了一个蛮力数独求解器，它从来没有超过一秒钟。我希望 Python 具有可比性或更快。 IIRC 每当它想要建立一个分支以回溯到时，它都会复制整个“板”的状态。我使用了一个相对简单的结构来表示“板”，单元格以及每个单元格共享的行、列和子块。所以复制很简单，而且是“手工”完成的。所以我确实认为还有很大的改进空间。
-
@gbulmer 我同意，我正在重写算法，以避免使用任何比列表/字典更复杂的数据结构，因为我希望有类似的性能。
标签： python algorithm deep-copy depth-first-search