破解数独——回溯法

最新推荐文章于 2025-02-15 16:19:18 发布
原创 最新推荐文章于 2025-02-15 16:19:18 发布 · 1.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数独 #算法 #回溯法 #sudoku

博客围绕用回溯法破解数独展开，提及了数独样例，回溯法是解决数独问题的关键算法，在信息技术领域常用于解决此类逻辑推理问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

破解数独——回溯法

'''
1、确保不出现连续两次only=2的情况
2、只要做了only=2的试填，就压入Stack
   做only=1不压入栈！！
3、出现报错，立刻退栈，再错再退，直到退回第一次only=2的尝试

疑问：1、退档是否要退a b A B ans的所有档？
退档的具体操作：
先出栈，上一次only=2的尝试，将另外一个数字填入即可（即转化成only=1的情况），别的都不用管
'''
from copy import deepcopy
from time import clock
start = clock()
#f（x）函数的作用是，输入一组数据，返回1-9间的补集
def f(x):
    ans = []
    for i in range(1,10):
        if i not in x:
            ans.append(i)
    return ans

#用于检测是否出现数字重复，即报错
def check(x,b,C):
    flag = False
    for i in range(1,10):
        for j in x:
            if j.count(i)>1:
                flag = True
                break
    for i in range(1,10):
        for j in b:
            if j.count(i)>1:
                flag = True
                break
    for i in range(1,10):
        for m in C:
            for n in m:
                if n.count(i)>1:
                    flag = True
                    break
    if flag==True:
        return "Error"
    else:
        return "True"
        
stack_x = []
stack_a = []
stack_b = []
stack_A = []
stack_B = []
stack_ans = []
stack_M = [] #表示每次做only=2的尝试是，ans的行列
stack_N = []

#数独是9*9的二维数组a，输入空的用0表示
#先尝试获取输入,x表示最原始的数独
x = [[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],]

#输入数独
num = 0
while num!=9:
    line = raw_input()
    k=-1
    for i in line:
        k+=1
        x[num][k]=int(i)
    num += 1 
    
change = False #change指针用于指示是否将ans插入'x'

while True:
    #import copy模块的deepcopy复制数组
    #a数组共有9行，表示每行已经存在的数字0
    a = deepcopy(x)
    #去掉所有的0再次存入a
    for i in a:
        while True:
            if 0 in i:
                i.remove(0)
            else:
                break
            
    #b数组是输入的置换矩阵，即行列交换
    b = [[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],]
    for i in range(9):
        for j in range(9):
            b[i][j]=x[j][i]
    #去掉所有0再次存入b
    for i in b:
        while True:
            if 0 in i:
                i.remove(0)
            else:
                break
    
    #A、B两个数组表示a、b的补集，再同C三者求交集便表示可能填的数字
    A = [None,None,None,None,None,None,None,None,None]        
    for i in range(9):
        A[i]=f(a[i])
    
    B = [None,None,None,None,None,None,None,None,None]
    for i in range(9):
        B[i]=f(b[i])
        
    #尝试解决宫内重复的问题
    #c数组是3*3表示每个宫内的数字，去0再存入c
    c = [[[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None]],[[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None]],[[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None]]]
    temp = []
    for i in range(3):
        for j in range(3):
            temp.append(x[i][j])
    for i in range(9):
        c[0][0][i]=temp[i]
    
    temp = []
    for i in range(3):
        for j in range(3,6):
            temp.append(x[i][j])
    for i in range(9):
        c[0][1][i]=temp[i]
        
    temp = []
    for i in range(3):
        for j in range(6,9):
            temp.append(x[i][j])
    for i in range(9):
        c[0][2][i]=temp[i]
    
    temp = []
    for i in range(3,6):
        for j in range(3):
            temp.append(x[i][j])
    for i in range(9):
        c[1][0][i]=temp[i]
    
    temp = []
    for i in range(3,6):
        for j in range(3,6):
            temp.append(x[i][j])
    for i in range(9):
        c[1][1][i]=temp[i]
    
    temp = []
    for i in range(3,6):
        for j in range(6,9):
            temp.append(x[i][j])
    for i in range(9):
        c[1][2][i]=temp[i]
    
    temp = []
    for i in range(6,9):
        for j in range(3):
            temp.append(x[i][j])
    for i in range(9):
        c[2][0][i]=temp[i]
    
    temp = []
    for i in range(6,9):
        for j in range(3,6):
            temp.append(x[i][j])
    for i in range(9):
        c[2][1][i]=temp[i]
    
    temp = []
    for i in range(6,9):
        for j in range(6,9):
            temp.append(x[i][j])
    for i in range(9):
        c[2][2][i]=temp[i]
    
    #去掉所有的0重新存入数组c
    for i in c:
        for j in i:
            while True:
                if 0 in j:
                    j.remove(0)
                else:
                    break
    C = deepcopy(c)
    m=-1            
    for i in c:
        m+=1
        n=-1
        for j in i:
            n+=1
            c[m][n]=f(j)
    
    #求交集方法，list( set(a) & set(b) & set(c) )
    #ans代表每个空可以输入的数字
    ans = [[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None],[None,None,None,None,None,None,None,None,None]]
    for i in range(9):
        for j in range(9):
            if x[i][j]==0:
                ans[i][j]=list( set(A[i]) & set(B[j]) & set(c[i/3][j/3]))
            else:
                ans[i][j]=[]
    '''change指针为True,说明此处ans会导致连续两次的only=2，所以加'x'
    '''
    if change==True:
        print 'm,n:',stack_M[-1],stack_N[-1]
        print 'x:',x[stack_M[-1]][stack_N[-1]]
        print 'sdsadasdasdasd:',ans[stack_M[-1]][stack_N[-1]]
        if len(ans[stack_M[-1]][stack_N[-1]])!=0:
            ans[stack_M[-1]][stack_N[-1]].append('x')
        change=False
    
                
    '''还要优先检测是否已经填了重复的数字，这是用ans无法检测出来的'''
    if check(x,b,C)=="Error":
        print "Error exists"
        #退到上一个二选一的Stack档，并且换数字，交换位置即可
        a = stack_a.pop();b = stack_b.pop();
        A = stack_A.pop();B = stack_B.pop();
        M = stack_M.pop();N = stack_N.pop();
        ans = stack_ans.pop();x = stack_x.pop();
        ans[M][N].pop()
        print "after [Error] back stack x:"
        for i in x:
            print i
            
    '''一定要优先检测ans是否报错，一旦报错立刻退档'''
    #如果ans中该填空为位置有空集，说明暴力填词出错，退档即可
    m = -1
    for i in ans:
        flag1 = False #flag1检测是否出现error，一旦出现立刻退档并且跳出for循环
        m += 1
        n = -1
        for j in i:
            n += 1
            if x[m][n]==0 and ans[m][n]==[]:#在应该填空的位置ans为空，就报错
                flag1 = True
                print "line "+str(m),"row "+str(n)+"   Error exists!"
                #报错后立刻退档，退回上一个二选一
                a = stack_a.pop();b = stack_b.pop();
                A = stack_A.pop();B = stack_B.pop();
                M = stack_M.pop();N = stack_N.pop();
                ans = stack_ans.pop();x = stack_x.pop();
                #退回上一个only=2的情形，就将其自动变成only=1的ans空
                ans[M][N].pop()#因为试填默认试第二个，所以直接pop即可
                break
        if flag1==True:
            break

    #only表示只能填唯一数的空数
    #若only=0,则找到only=2的进行试填，直至再次出现only=1的情况
    only = False
    for i in range(9):
        for j in range(9):
            if len(ans[i][j])==1:
                print "There exists only one condition!"
                print "only a["+str(i)+"]["+str(j)+"]="+str(ans[i][j][0])
                only = True
                print ans[i][j],"!!!!!!!!!"
                print x[i][j]
                x[i][j]= ans[i][j][0]
                
    '''
    重点，做暴力试填的点，要做全局变量标记，因为可能会退档
    !!优化：优先选择填完Only=2后能产生Only=1的来优先Try,这就需要逐一去试，若不能产生Only=1就退档，再进入for寻找下一个Only=2的
    '''
    only2 = False
    if only == False:
        print "No only=1 exists@@@"
        flag2 = False
        m = -1
        for i in ans:
            m += 1
            n = -1
            for j in i:
                n += 1
                if len(j)==2:
                    only2=True
                    stack_a.append(deepcopy(a));stack_b.append(deepcopy(b));stack_A.append(deepcopy(A));stack_B.append(deepcopy(B));stack_M.append(deepcopy(m));stack_N.append(deepcopy(n));stack_ans.append(deepcopy(ans));stack_x.append(deepcopy(x))
                    
                    x[m][n]=ans[m][n][1] 
                    if check(x,b,C)=="Error":
                        x[m][n]=0
                        
                    #默认试填第二个数字（反正蒙中概率是50%）
                    flag2 = True #flag2表示是否有only=2的空，有的话立刻试填，并且所有数据入栈以作备份
                    break
            if flag2==True:
                break
    
    
    
    
    #Check检测是否还有0未填 
    Check = []
    for i in x:
        for j in i:
            Check.append(j)
    if 0 not in Check:#所有空已经填完，则跳出程序
        break
  
#如果能跳出while，那么一定产生了答案（但未必是正确的答案）  
if check(x,b,C)=="True":
    print "answer:" 
    for i in x:
        print i
else:
    print "Sorry I cannot @-@"
    
end = clock()
print int(start)
print int(end)
print end-start


数独样例

简单测试
600090020
972500803
035407001
000300059
050000010
320008400
500704190
701002584
040010007


大师级别
302700009
008000045
004001300
000059000
090030060
000260000
001400200
260000100
400002503

专家级
000000020
081006000
000000430
006001098
000000000
007000063
003569207
579200000
000007000


世界最难数独题 by芬兰数学家
800000000
003600000
070090200
050007000
000045700
000100030
001000068
008500010
090000400
C语言学习日记（16）——回溯法解数独（1）
u010340279的博客
06-12 1243
数独是一种很流行的填数游戏，不少人都喜欢玩。用计算机来解数独也算是一个比较好的练习。恰好多年前看到过一则新闻，说是有个老人花了三天解了一个“世界最难数独”，我们就用计算机来求解一下。先看看这个号称世界最难的数独： ...
C语言学习日记（17）——回溯法解数独（2）
u010340279的博客
06-12 684
通过前面的分析，就可以写出解数独的代码了。 #include <stdio.h> void fill(int sd[][9]); //使用回溯法求解数独 int main() { int sd[9][9] = { // “世界最难数独”信息 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,
数独破解（软件）
06-25
数独是一种源自18世纪末的瑞士，后在美国发展、并在日本得以发扬光大的数学智力拼图游戏。拼图是九宫格（即3格宽×3格高）的正方形状，每一格又细分为一个九宫格。在每一个小九宫格中，分别填上1至9的数字，让整个大九宫格每一列、每一行的数字都不重复。<br><br>本软件的功能就是在你玩数独游戏的时候，帮助你迅速求解。若数独游戏本身非唯一解，则本软件只能帮你找出其中一个解。
Django之破解数独
山阴少年
01-10 1056
数独是一项快乐的益智游戏，起源于18世纪瑞士的一种数学游戏。解答者需要运用纸、笔进行演算，需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。   本次分享讲展示如何利用Django来直观方便地破解数独。   首先新建两个模板来展示页面，一个是index.html，方便用户输入数独，此数独可以来自其他网站；一个是an
利用python 完成 leetcode 37 解数独
找到工作之前一天十篇的博客
03-31 529
编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。 一个数独。 答案被标成红色。 Note: 给定的数独序列只包含数字 1-9 和字符 ‘.’ 。 你可以假设给定的数独只有唯一解。 给定数独永远是 9...
解数独
蜗牛的博客
11-02 1445
编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。 一个数独。 答案被标成红色。 Note: 给定的数独序列只包含数字 1-9 和字符 ‘.’ 。 你可以假设给定的数独只有唯一解。 给定数独永远是 9x9...
第五章——回溯法
weixin_55835175的博客
06-05 1601
对于回溯法的概念，我们需要先从回溯法在实际解决问题中的表现来理解。书上称：回溯法实际上是一个类似穷举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现不满足求解条件时，就“回溯”（即回退），然后尝试别的可能。就我个人的角度而言，我不认为回溯法是一个类似于穷举的方法，而是针对于一些通过穷举法求解的问题：问题求解过程中的各个可能出现的状态作为结点，通过决策将两两结点连边构成一棵有向树，存在一个或多个我们想要求解的目标状态。为了得到我们的目标状态(或者是初始状态到目标状态的路径)，我们采取深度优先遍历的策
算法分析论文——回溯算法的应用.zip
10-19
- **逻辑推理**：如谜题求解，如数独、逻辑谜题等。 - **组合优化**：如背包问题、车辆路径规划等，寻找最佳组合。 - **计算机编程竞赛**：在编程竞赛中，回溯算法常用于解决一些复杂的搜索问题。 在实际应用中，...
算法——结合经典示例了解回溯法
最新发布
oopxiajun博客专栏
02-15 525
需要穷举所有可能性问题有明确的约束条件解空间呈现树状结构组合、排列、选择类问题回溯法作为一种强大而灵活的算法策略，在解决复杂问题时展现出独特的优势。通过不断尝试和回溯，它能够在庞大的解空间中找到满足特定条件的解。从理论层面看，回溯法基于深度优先搜索的思想，巧妙地利用递归实现对各种可能性的探索。在实际应用中，无论是路径搜索、游戏 AI，还是资源分配等领域，都能看到回溯法的身影，它为解决现实世界中的诸多难题提供了有效的途径。
数独破解工具
03-31
本程序可以破解9*9的数独，是DOS程序，因此，还需要你们先熟悉以下简单的输入命令和格式。 （1）输入0或1,0代表程序自动产生可解的数独，这是面向报纸和杂志中出数独的人员，1代表自己手工输入一个数独。 （2）输入数独的大小，这里先限定9*9，因为本程序对于n*n的数独还不能全部兼容，所以在第二步中输入9，回车就行。 （3）如果输入没有问题，这时程序会自动产生一个数独示例，来指导你如何输入数独，最好现在记事本中先输入好，再粘贴到程序中，要不然会因为输入错误，重复输入的。 本程序是DOS界面，以后有需要会加上GUI（可视化界面）。 本程序解一般的数独不到1秒，但是对于较难的数独会1min左右，请耐心等待！
破解九宫格（数独）
07-05
数独是一种比较费时费脑的游戏，一般难度的数独玩下来也得1个小时左右，本人是伪数独爱好者，碰到难点的数独需要花上若干个小时，于是偷懒写了一套破解程序，特拿出来分享，希望有人喜欢。
5*5数独破解器，可以用来平时练习解数独。
02-22
该文件是数独软件，可以用于解决4*4及5*5数独问题，方便快捷！
计算机解数独
12-15
通过算法解数组，并输出多组答案通过算法解数组，技术涉及数独、搜索、剪枝,、递归、回溯
高级数独破解器
11-14
录入数独题库，迅速获得求解！ 跨操作系统软件，运行环境为python3
数独游戏破解
小强快跑~~
10-19 1445
游戏规则： 1、每行都是 1~9 2、没列都是 1~9 3、每块都是 1~9   解答思路： 从坐标 [0][0] 开始，算出其允许填入的数字集合（每行允许数字集合、每列允许数字集合 和 每块允许数字集合 的交集）。 从左到右，从上到下依次尝试（即，递归），当无法向 [下一步] 进行时候，则回溯（恢复状态，再尝试另一个值）。 这样直到最后解答完成。   源代码： packag
leetcode 37.解数独(python)
pureszgd的博客
08-19 522
leetcode 37.解数独(python) #leetcode 编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 '.' 表示。 一个数独。 答案被标成红色。 Note: 给定的数独序列只包含数字 1-9 和字符 '.' 。 你可以假设给定的数独只有唯一解。 给定数独永远是 9x9 形式的。 class Solu
回溯法解数独
Rocketng的博客
11-29 369
编写一个程序，通过已填充的空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 ‘.’ 表示。 一个数独。 c++回溯法 class Solution { public: void solveSudoku(vector<vecto...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值