数独问题

数独（shù dú）是源自18世纪瑞士的一种数学游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。

数独盘面是个九宫，每一宫又分为九个小格(cell)。在这八十一格中给出一定的已知数字和解题条件，利用逻辑和推理，在其他的空格上填入1-9的数字。使1-9每个数字在每一行、每一列和每一宫中都只出现一次，所以又称“九宫格”。
我采用的是枚举的方式去处理数独问题:
即每个格子用1-9这个数字进行测试，判断是否满足两个规则

数独文件存储在easy50.txt中
在代码中会对其进行读取

import copy
import time

t1=time.time()
import os
import os
def readfile():
    a=[]
    b=[[0]*9]*9
    with open('easy50.txt', 'r') as f:
        for line in f.readlines():
            line=line.strip()
            if '=' not in  line:
                a.append(line)
            if '=' in line:
                print(a)
                xx=input("是否继续:
")
                while xx is 'y':
                    a.clear()
                    print("清空",a)
                    break
                else:
                    return a

    f.close()
li=readfile()
arr=[]
for i in range(9):
    for j in range(9):
        arr.append(int(li[i][j]))
a1=[]
a2=[]
a3=[]
a4=[]
a5=[]
a6=[]
a7=[]
a8=[]
a9=[]


for i in range(9):
    a1.append(arr[i])
for i in range(9,18):
    a2.append(arr[i])
for i in range(18,27):
    a3.append(arr[i])
for i in range(27,36):
    a4.append(arr[i])
for i in range(36,45):
    a5.append(arr[i])
for i in range(45,54):
    a6.append(arr[i])
for i in range(54,63):
    a7.append(arr[i])
for i in range(63,72):
    a8.append(arr[i])
for i in range(72,81):
    a9.append(arr[i])
origin = [a1, a2,a3,a4,a5,a6,a7,a8,a9]

print("原始origin的值:
",a1,'
', a2,'
',a3,'
',a4,'
',a5,'
',a6,'
',a7,'
',a8,'
',a9)
print("--------------------------------------start---------------------------------------")

class sudoku:
    def debug(self):  # 调试
        for list in origin:
            print(list)
        print("
")

    def check_repetition(self,list):#判断表中是否有重复值，0除外
        flag=0
        for i in range(1,10):
            if list.count(i)>=2:
                return 1
            else:
                flag=flag+1
        if flag==9:
            return 0

    def check_row(self,row):#检测横向是否有重复值，无则为返回0，有则返回1
        list = origin[row]  # 横向
        r1 = self.check_repetition(list)
        if r1 == 0:
            return 0
        else :
            return 1


    def check_column(self,column):#检测纵向是否重复值，无则为返回0，有则返回1
        list = []  # 纵向
        for num in origin:
            list.append(num[column])
        r2 = self.check_repetition(list)
        if r2==0:
            return 0
        else:
            return 1

    def check_square(self,x,y):#检测九宫格是否有重复值，无则为返回0，有则返回1
        x,y=y,x
        if x>=9 or y>=9:
            return
        square = []#九宫格
        for i in range(0+y//3*3, 3+y//3*3):
            for j in range(0+x//3*3, 3+x//3*3):
                square.append(origin[i][j])
        r3 = self.check_repetition(square)
        if r3==0:
            return 0
        else:
            return 1

    def check(self,x,y):#检测是否有重复值，无则为0，有则不为0
        r1 = self.check_row(x)
        r2 = self.check_column(y)
        r3 = self.check_square(x, y)
        result=r1+r2+r3
        return result

    def get_next(self):  # 获得下一个空值，返回row,column值
        i = 0
        for list in origin:
            try:  # 当0不在列表中时，跳过
                column = list.index(0)
                row = origin.index(list)
                res = (row, column)
                return res
            except ValueError:
                i = i + 1
                if i == 9:
                    t2=time.time()
                    print("总用时={}".format(t2 - t1))
                    exit(0)

    def poi(self,row, column):  # 位置修正
        if row == 0 and column == -1:
            return
        if row == 8 and column == 9:
            return
        if column == -1:
            column = 8
            row = row - 1
        if column == 9:
            column = 0
            row = row - 1
        return (row, column)

    def get_last(self,row, column):
        origin[row].insert(column, 0)
        origin[row].pop(column + 1)
        column = column - 1  # 获得上一个已填值的行、列位置
        row, column = self.poi(row, column)#位置修正
        r = origin[row][column] * compare[row][column]
        while r != 0:
            column = column - 1
            row, column = self.poi(row, column)
            r = origin[row][column] * compare[row][column]
        return (row, column)

    def blank(self):
        try:
            row,column=self.get_next()
        except TypeError:#已填完
            exit(0)
        j=0
        flag=0
        for i in range(1,10):
            origin[row].insert(column,i)
            origin[row].pop(column+1)
            self.debug()
            r = self.check(row, column)
            if r==0:#无重复值
                return
            else:
                j = j + 1
                if j==9:
                    flag=1
                    break
        if flag==1:
            row, column = self.get_last(row, column)
            value=origin[row][column]
            self.debug()
            while value == 9:
                row, column = self.get_last(row, column)
                value = origin[row][column]
                self.debug()
            while value<9:
                for k in range(value+1,10):
                    origin[row].insert(column, k)
                    origin[row].pop(column + 1)
                    self.debug()
                    r=self.check(row,column)
                    if r!=0:#有重复
                        if k==9:
                            row, column = self.get_last(row, column)
                            value=origin[row][column]
                            self.debug()
                            while value==9:
                                row, column = self.get_last(row, column)
                                value = origin[row][column]
                                self.debug()
                            break
                    else:
                        return

if __name__=="__main__":
    compare = copy.deepcopy(origin)#深复制  被复制出来对象对复制出来的对象没有任何影响
    sudoku = sudoku()#对象的id值
    while 1:
        sudoku.blank()

读取的数独问题文件:

大家还可以尝试另外一种方式去解决问题:
1.将每个空格的可能放置一个集合中，利用规则一消去行重复的
2.规则二消除列重复，前面两个规则重复进行
3.进行枚举，一个一个的试

相关阅读:
剑指offer编程题Java实现——面试题14调整数组顺序使奇数位于偶数之前
 剑指offer编程题Java实现——面试题13在O(1)时间内删除链表节点
 剑指offer编程题Java实现——面试题12相关题大数的加法、减法、乘法问题的实现
 剑指offer编程题Java实现——面试题12打印1到最大的n位数
 《深入理解JAVA虚拟机》——学习笔记
 剑指offer编程题Java实现——面试题11数值的整数次方
 剑指offer编程题Java实现——面试题10二进制中1的个数
 剑指offer编程题Java实现——面试题9斐波那契数列
 剑指offer编程题Java实现——面试题8旋转数组的最小数字
 mysql高可用集群——MHA架构
原文地址：https://www.cnblogs.com/Xiong-Jun/p/13515051.html