使用python解數獨

偶然發現linux系統附帶的一個數獨遊戲，打開玩了幾把。無奈是個數獨菜鳥，之前沒玩過，根本就走不出幾步就一團漿糊了。

因而就打算藉助計算機的強大運算力來暴力解數獨，仍是頗有樂趣的。

下面就記錄一下我寫解數獨程序的一些思路和心得。

一.數獨遊戲的基本解決方法

編程籠統的來講,就是個方法論。不論什麼程序，都必須將問題的解決過程分解成計算機能夠實現的若干個簡單方法。俗話說，大道至簡。對於只能明白0和1的計算機來講，就更須要細分步驟，一步一步的解決問題了。

首先來思考一下解數獨的基本概念。

數獨橫九豎九共八十一個格子，同時又分爲9個九宮格。規則很簡單——須要每個格中的數字，都保證與其所在橫排和豎排以及九宮格內無相同數字。

因此咱們的大概思路就是，從第一個空格開始試着填數，從 1 開始填，若是 1 不知足橫排豎排九宮格無重複的話，就再填入 2 ，以此類推，直到填入一個暫時知足規則的數，中斷此格，移動到下一個空格重複這個過程。

若是到達某個空格發現已經無數可選了，說明前面某一格填錯了，那就返回上一格，從上一格的中斷處繼續往 9 嘗試，直到這樣回朔到填錯的那一格。

這樣的話，咱們就能夠整理出重要的步驟了：

• 尋找到下一個空格
• 輪流填入格中數字 1 到 9
• 遞歸判斷填入數是否符合規則

二.程序

首先測試數獨使用的是芬蘭數學家因卡拉花費3個月時間設計出的世界上迄今難度最大的數獨。以下

將空格用 0 表示，同時將數獨表示成嵌套的列表，這樣每格的行數和列數就正好是列表中每一個對應數的索引。

程序以下：

 1 #coding=utf-8
 2 import datetime
 3 class solution(object):
 4     def __init__(self,board):
 5         self.b = board
 6         self.t = 0
 7 
 8     def check(self,x,y,value):#檢查每行每列及每宮是否有相同項
 9         for row_item in self.b[x]:
10             if row_item == value:
11                 return False
12         for row_all in self.b:
13             if row_all[y] == value:
14                 return False
15         row,col=x/3*3,y/3*3
16         row3col3=self.b[row][col:col+3]+self.b[row+1][col:col+3]+self.b[row+2][col:col+3]
17         for row3col3_item in row3col3:
18             if row3col3_item == value:
19                 return False
20         return True
21 
22     def get_next(self,x,y):#獲得下一個未填項
23         for next_soulu in range(y+1,9):
24             if self.b[x][next_soulu] == 0:
25                 return x,next_soulu
26         for row_n in range(x+1,9):
27             for col_n in range(0,9):
28                 if self.b[row_n][col_n] == 0:
29                     return row_n,col_n
30         return -1,-1  #若無下一個未填項，返回-1
31 
32     def try_it(self,x,y):#主循環
33         if self.b[x][y] == 0:
34             for i in range(1,10):#從1到9嘗試
35                 self.t+=1
36                 if self.check(x,y,i):#符合 行列宮均無條件 的
37                     self.b[x][y]=i #將符合條件的填入0格
38                     next_x,next_y=self.get_next(x,y)#獲得下一個0格
39                     if next_x == -1: #若是無下一個0格
40                         return True  #返回True
41                     else:        #若是有下一個0格，遞歸判斷下一個0格直到填滿數獨
42                         end=self.try_it(next_x,next_y)
43                         if not end:   #在遞歸過程當中存在不符合條件的，即 使try_it函數返回None的項
44                             self.b[x][y] = 0    #回朔到上一層繼續
45                         else:
46                             return True
47 
48     def start(self):
49         begin = datetime.datetime.now()
50         if self.b[0][0] == 0:
51             self.try_it(0,0)
52         else:
53             x,y=self.get_next(0,0)
54             self.try_it(x,y)
55         for i in self.b:
56             print i
57         end = datetime.datetime.now()
58         print '\ncost time:', end - begin
59         print 'times:',self.t
60         return
61 
62 
63 s=solution([[8,0,0,0,0,0,0,0,0],
64         [0,0,3,6,0,0,0,0,0],
65         [0,7,0,0,9,0,2,0,0],
66         [0,5,0,0,0,7,0,0,0],
67         [0,0,0,8,4,5,7,0,0],
68         [0,0,0,1,0,0,0,3,0],
69         [0,0,1,0,0,0,0,6,8],
70         [0,0,8,5,0,0,0,1,0],
71         [0,9,0,0,0,0,4,0,0]])
72 73 s.start()

 

值得注意的是使用的遞歸判斷可以很巧妙的在走錯分支時回朔到上一層。具體實現是經過 for 循環來從 1 到 9 不斷填入數字同時達到記錄中斷點的做用。經過下一層的返回值來肯定是否回朔。

程序輸出以下：

[8, 1, 2, 7, 5, 3, 6, 4, 9]
[9, 4, 3, 6, 8, 2, 1, 7, 5]
[6, 7, 5, 4, 9, 1, 2, 8, 3]
[1, 5, 4, 2, 3, 7, 8, 9, 6]
[3, 6, 9, 8, 4, 5, 7, 2, 1]
[2, 8, 7, 1, 6, 9, 5, 3, 4]
[5, 2, 1, 9, 7, 4, 3, 6, 8]
[4, 3, 8, 5, 2, 6, 9, 1, 7]
[7, 9, 6, 3, 1, 8, 4, 5, 2]

cost time: 0:00:00.060687
times: 45360

 

能夠看到程序雖然運算次數比較多，可是速度仍是很快的。