2. 程式人生 > 其它 >基於回溯法的數獨求解(Python)

基於回溯法的數獨求解(Python)

阿新 • • 發佈：2021-01-19

技術標籤：演算法遊戲python

目錄

相關介紹

什麼是數獨？

數獨是源自18世紀瑞士的一種數學遊戲。是一種運用紙、筆進行演算的邏輯遊戲。玩家需要根據9×9盤面上的已知數字，推理出所有剩餘空格的數字，並滿足每一行、每一列、每一個粗線宮（3*3）內的數字均含1-9，不重複 。
數獨盤面是個九宮，每一宮又分為九個小格。在這八十一格中給出一定的已知數字和解題條件，利用邏輯和推理，在其他的空格上填入1-9的數字。使1-9每個數字在每一行、每一列和每一宮中都只出現一次，所以又稱“九宮格”。

在這裡插入圖片描述

什麼是回溯法？

回溯法（探索與回溯法）是一種選優搜尋法，又稱為試探法，按選優條件向前搜尋，以達到目標。但當探索到某一步時，發現原先選擇並不優或達不到目標，就退回一步重新選擇，這種走不通就退回再走的技術為回溯法，而滿足回溯條件的某個狀態的點稱為“回溯點”。使用回溯法的核心是記錄每一步操作的位置，並在當前位置的數字均不符合條件時退回至上一位置。由此，可以使用棧來實現。

思路及實現

演算法思路

首先，從第一行開始尋找第一個待填寫的元素位置，並壓入用於記錄每次操作位置的棧中；然後，判斷此時該位置元素是否合法（合法：即該數字位於0-9之間，並且與該數字所在行、所在列、所在宮內的數字均不重複）。當該數字合法時，則繼續尋找下一個待填寫的位置，並壓入棧中；當該數字不合法時，若該數字還沒有大於9則自增，若該數字已大於9則退回至上一位置（當前位置歸零並彈出）；最後

，當最後一個待填寫的元素合法且不等於0之前，重複執行上述步驟。

Yes No Yes No Yes No 最後一個空位置不合法 當前位置合法 輸出數獨答案 尋找下一元素
當前位置>=9 退回至上一位置 當前位置自增 .

程式碼編寫

設定記錄空位置的棧

  • 首先，宣告列表。
#全域性變數記錄空位置（使用回溯法）
indexList = []
  • 然後，實現入棧和出棧的方法。
# --- 入棧 --- #
def myPush(coordinate):
	indexList.append(coordinate)

# --- 出棧 --- #
def myPop():
	indexList.pop()

尋找第一個空元素位置

# --- 尋找第一個空元素位置 --- #
def firstEmpty():
    for i in range(0,9):
        for j in range(0,9):
            if sudoku[i][j] == 0:
                myPush([i,j])
                return

尋找最後一個空元素位置

# --- 尋找最後一個空元素位置 --- #
def lastEmpty():
    for i in range(8,-1,-1):
        for j in range(8,-1,-1):
            if sudoku[i][j] == 0: #'0'
                return [i,j]

位置判空加入棧中

# --- 位置判空加入棧中 --- #
def isEmpty():
    #獲取棧頂元素
    a,b = indexList[-1]
    #從下一元素開始找起
    b += 1 
    for i in range(a,9):
        if i != a:
            b = 0
        for j in range(b,9):
            if sudoku[i][j] == 0:
                myPush([i,j])
                return

當前位置自增

# --- 當前位置自增 ---#
def myAdd():
    #獲取棧頂元素
    x,y = indexList[-1]
    sudoku[x][y] += 1

判斷當前位置是否合法

# --- 判斷當前位置是否合法 --- #
def isLegal():
    #獲取棧頂元素
    x,y = indexList[-1]
    temp = sudoku[x][y]

    #判斷該行是否重複
    for i in range(9):
        if sudoku[x][i] == temp and i != y:
            return False; #當前位置不合法

    #判斷該列是否重複
    for i in range(9): 
        if sudoku[i][y] == temp and i != x:
            return False; #當前位置不合法

    #判斷該宮是否重複
    xx = int(x / 3)
    yy = int(y / 3)
    for i in range(3):
        for j in range(3):
            if sudoku[xx * 3 + i][yy * 3 + j] == temp and (xx * 3 + i) != x and (yy * 3 + j) != y:
                return False; #當前位置不合法
    return True #當前位置合法

判斷某一位置是否合法 (用於判斷末尾元素)

# --- 判斷某一位置是否合法 --- #
def oneIsLegal(x,y):
    temp = sudoku[x][y]
    #判斷該行是否重複
    for i in range(9):
        if sudoku[x][i] == temp and i != y:
            return False; #當前位置不合法

    #判斷該列是否重複
    for i in range(9): 
        if sudoku[i][y] == temp and i != x:
            return False; #當前位置不合法

    #判斷該宮是否重複
    xx = int(x / 3)
    yy = int(y / 3)
    for i in range(3):
        for j in range(3):
            if sudoku[xx * 3 + i][yy * 3 + j] == temp and (xx * 3 + i) != x and (yy * 3 + j) != y:
                return False; #當前位置不合法
    return True #當前位置合法

回退函式

# --- 回退函式 --- #
def myReturn():
    #獲取棧頂元素
    x,y = indexList[-1]
    sudoku[x][y] = 0
    myPop()

輸出數獨

# --- 輸出數獨 --- #
def myOutput():
    print("答案為：")
    for i in range(9):
        print(sudoku[i])

主程式

# --- 程式入口 --- #
def main():
    #尋找首個空元素
    firstEmpty()

    #尋找末尾空元素
    last = lastEmpty()
    m,n = last

    #當末尾空元素合法且不等於0時停止迴圈
    while oneIsLegal(m,n) != True or sudoku[m][n] == 0:
        #獲取棧頂元素
        x,y = indexList[-1]

        #判斷當前位置是否合法
        if isLegal() == True and sudoku[x][y] <= 9 and 0 < sudoku[x][y]:
            #尋找下一個空元素
            isEmpty()
        else:
            #不合法 - 回退
            if sudoku[x][y] >= 9:
                myReturn()
                myAdd()
            else: #不合法 - 自增
                myAdd()
    myOutput()

if __name__ == "__main__":
    main()

測試數獨

#儲存數獨元素
sudoku = [[8,0,0,0,0,0,0,0,0],
          [0,0,3,6,0,0,0,0,0],
          [0,7,0,0,9,0,2,0,0],
          [0,5,0,0,0,7,0,0,0],
          [0,0,0,0,4,5,7,0,0],
          [0,0,0,1,0,0,0,3,0],
          [0,0,1,0,0,0,0,6,8],
          [0,0,8,5,0,0,0,1,0],
          [0,9,0,0,0,0,4,0,0],
]

執行結果

在這裡插入圖片描述

完整程式碼

#全域性變數記錄空位置（使用回溯法）
indexList = []

#儲存數獨元素
sudoku = [[8,0,0,0,0,0,0,0,0],
          [0,0,3,6,0,0,0,0,0],
          [0,7,0,0,9,0,2,0,0],
          [0,5,0,0,0,7,0,0,0],
          [0,0,0,0,4,5,7,0,0],
          [0,0,0,1,0,0,0,3,0],
          [0,0,1,0,0,0,0,6,8],
          [0,0,8,5,0,0,0,1,0],
          [0,9,0,0,0,0,4,0,0],
]

# --- 程式入口 --- #
def main():
    #尋找首個空元素
    firstEmpty()
    #尋找末尾空元素
    last = lastEmpty()
    m,n = last
    #當末尾空元素合法且不等於0時停止迴圈
    while oneIsLegal(m,n) != True or sudoku[m][n] == 0:
        #獲取棧頂元素
        x,y = indexList[-1]
        #判斷當前位置是否合法
        if isLegal() == True and sudoku[x][y] <= 9 and 0 < sudoku[x][y]:
            #尋找下一個空元素
            isEmpty()
        else:
            #不合法 - 回退
            if sudoku[x][y] >= 9:
                myReturn()
                myAdd()
            else: #不合法 - 自增
                myAdd()
    myOutput()

# --- 尋找第一個空元素位置 --- #
def firstEmpty():
    for i in range(0,9):
        for j in range(0,9):
            if sudoku[i][j] == 0: #'0'
                myPush([i,j])
                return

# --- 尋找最後一個空元素位置 --- #
def lastEmpty():
    for i in range(8,-1,-1):
        for j in range(8,-1,-1):
            if sudoku[i][j] == 0: #'0'
                return [i,j]

# --- 位置判空加入棧中 --- #
def isEmpty():
    #獲取棧頂元素
    a,b = indexList[-1]
    #從下一元素開始找起
    b += 1
    for i in range(a,9):
        if i != a:
            b = 0
        for j in range(b,9):
            if sudoku[i][j] == 0: #'0'
                myPush([i,j])
                return

# --- 入棧 --- #
def myPush(coordinate):
    indexList.append(coordinate)

# --- 出棧 --- #
def myPop():
    indexList.pop()

# --- 當前位置自增 ---#
def myAdd():
    #獲取棧頂元素
    x,y = indexList[-1]
    sudoku[x][y] += 1

# --- 判斷當前位置是否合法 --- #
def isLegal():
    #獲取棧頂元素
    x,y = indexList[-1]
    temp = sudoku[x][y]
    #判斷該行是否重複
    for i in range(9):
        if sudoku[x][i] == temp and i != y:
            return False; #當前位置不合法
    #判斷該列是否重複
    for i in range(9): 
        if sudoku[i][y] == temp and i != x:
            return False; #當前位置不合法
    #判斷該宮是否重複
    xx = int(x / 3)
    yy = int(y / 3)
    for i in range(3):
        for j in range(3):
            if sudoku[xx * 3 + i][yy * 3 + j] == temp and (xx * 3 + i) != x and (yy * 3 + j) != y:
                return False; #當前位置不合法
    return True #當前位置合法
    
# --- 判斷某一位置是否合法 --- #
def oneIsLegal(x,y):
    temp = sudoku[x][y]
    #判斷該行是否重複
    for i in range(9):
        if sudoku[x][i] == temp and i != y:
            return False; #當前位置不合法
    #判斷該列是否重複
    for i in range(9): 
        if sudoku[i][y] == temp and i != x:
            return False; #當前位置不合法
    #判斷該宮是否重複
    xx = int(x / 3)
    yy = int(y / 3)
    for i in range(3):
        for j in range(3):
            if sudoku[xx * 3 + i][yy * 3 + j] == temp and (xx * 3 + i) != x and (yy * 3 + j) != y:
                return False; #當前位置不合法
    return True #當前位置合法

# --- 回退函式 --- #
def myReturn():
    #獲取棧頂元素
    x,y = indexList[-1]
    sudoku[x][y] = 0
    myPop()

# --- 輸出數獨 --- #
def myOutput():
    print("答案為：")
    for i in range(9):
        print(sudoku[i])

if __name__ == "__main__":
    main()

相關推薦

基於回溯法的數獨求解(Python)

技術標籤：演算法遊戲python 目錄 相關介紹什麼是數獨？什麼是回溯法？ 思路及實現演算法思路程式碼編寫設定記錄空位置的棧尋找第一個空元素位置尋找最後一個空元素位置位置判空加入棧中當前位置自增判斷當前位

回溯法——數獨遊戲

一、問題描述 數獨（Sudoku）是一款大眾喜愛的數字邏輯遊戲。玩家需要根據9X9盤面上的已知數字，推算出所有剩餘空格的數字，並且滿足每一行、每一列、每一個粗線宮內的數字均含1-9，並且不重複。輸入：包含已知數字的

C# 數獨求解演算法的實現

前言 數獨是一種有趣的智力遊戲，但是部分高難度數獨在求解過程中經常出現大量單元格有多個候選數字可以填入，不得不嘗試填寫某個數字然後繼續推導的方法。不幸的是這種方法經常出現填到一半才發現有單元格無數可填，

python 回溯法模板詳解

什麼是回溯法 回溯法（探索與回溯法）是一種選優搜尋法，又稱為試探法，按選優條件向前搜尋，以達到目標。但當探索到某一步時，發現原先選擇並不優或達不到目標，就退回一步重新選擇，這種走不通就退回再走的技術為回

150行Python程式碼實現帶介面的數獨遊戲

今天閒著沒事幹，以前做過html+js版的數獨，這次做個python版本的，介面由pygame完成，數獨生成由遞迴演算法實現，由shuffle保證每次遊戲都是不一樣的情況，have fun；

LeetCode 36. 有效的數獨 | Python

36. 有效的數獨 題目來源：力扣（LeetCode）https://leetcode-cn.com/problems/valid-sudoku 題目

回溯搜尋（數獨）

這是我以前寫的，現在轉存在部落格上 玩家需要根據9×9盤面上的已知數字，推理出所有剩餘空格的數字，並滿足每一行、每一列、每一個粗線宮（3×3）內的數字均含1-9，不重複。

回溯法求解：最佳排程問題

技術標籤：# 演算法回溯法Java 一、問題描述： 假設有 n 個任務由 k 個可並行工作的機器來完成，完成任務 i 需要的時間為。試著設計一個演算法，找出完成這個 n 個任務的最佳排程，使得完成全部任務的時間最早。

回溯法求解n皇后問題(複習)

回溯法 回溯法是最常用的解題方法，有“通用的解題法”之稱。當要解決的問題有若干可行解時，則可以在包含問題所有解的空間樹中，按深度優先的策略，從根節點出發搜尋解空間樹。演算法搜尋至解空間樹的任一結點時，總

Java實現藍橋杯數獨遊戲的示例程式碼

你一定聽說過“數獨”遊戲。 如圖，玩家需要根據9×9盤面上的已知數字，推理出所有剩餘空格的數字，並滿足每一行、每一列、每一個同色九宮內的數字均含1-9，不重複。

LeetCode：有效的數獨

判斷一個9x9 的數獨是否有效。只需要根據以下規則，驗證已經填入的數字是否有效即可。

《演算法競賽進階指南》0x47離線分治演算法 基於值域的整體分治求解區間第K小

題目連結：https://www.acwing.com/problem/content/description/257/ 基於值域的整體分治策略是給定mid，將值小於mid的數的下標放入lq，另外的放入rq，將詢問也進行分割，變成兩個獨立的子問題，對子問題進行求解即

回溯法

使用剪枝函式的深度優先生產狀態空間樹中結點的求解方法稱為回溯法。 演算法搜尋至任一結點時，先判斷以該結點為根的子樹是否包含問題的解。如果肯定不包含，則跳過對該結點為根的子樹的搜尋，逐層向其父親結點回溯

Rust 有效的數獨

判斷一個9x9 的數獨是否有效。只需要根據以下規則，驗證已經填入的數字是否有效即可。

leetcode刷題-36有效的數獨

題目 判斷一個9x9 的數獨是否有效。只需要根據以下規則，驗證已經填入的數字是否有效即可。

POJ 2726、POJ3074 ：數獨（二進位制DFS）

題目連結：https://ac.nowcoder.com/acm/contest/1014/B 題目描述 In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3 × 3 subgrids. For example,

回溯法（一）——八皇后問題

  八皇后問題，陣列使用result[8]太妙了，切忌不要使用二維陣列result，這樣反而會增大難度，因為使用result[8]的話，每行路徑在找到正確位置都是更新的最新值；如果使用二維陣列的話，還要考慮當皇后回溯的時候，

回溯法（二）——0-1揹包問題

回溯法其實就是暴力，這個題目就是暴力的n層for（2次）迴圈。   給定揹包容量w，物品數量n，以及每個物品的重量wi，求揹包最多能裝多少多重的物品。

回溯法（三）——正則表示式匹配問題

遇到特殊字元的時候，我們就有多種處理方式了，也就是所謂的岔路口： “*”有多種匹配方案，可以匹配任意個文字串中的字元，我們就先隨意的選擇一種匹配方案，然後繼續考察剩下的字元。如果中途發現無法繼續匹配下

62有效的數獨（36）

作者: Turbo時間限制: 1S章節: 雜湊表 晚於: 2020-08-19 12:00:00後提交分數乘係數50% 截止日期: 2020-08-26 12:00:00