数独游戏求解：解法适用于任意阶数的数独

最新推荐文章于 2023-10-11 11:05:59 发布
最新推荐文章于 2023-10-11 11:05:59 发布
阅读量452 收藏
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/experdot/p/4839511.html
版权

第一节 数独简介

　　数独是一种运用纸、笔进行演算的逻辑游戏。

　　分类

　　4 阶：可填数字范围 1~4，宫格2阶

　　9 阶：可填数字范围 1~9，宫格3阶

　　16 阶：可填数字范围 1~16，宫格4阶 *图见附录　　

　　规则

　　以九阶数独为例，玩家需要根据 9×9 盘面上的已知数字，推理出所有剩余空格的数字

　　填入的数字需满足每一行、每一列、每一宫内的数字均含 1-9，且不重复

图1-1 四阶数独

图1-2 九阶数独

第二节 数独的表示

　　编程中，对于 N 阶数独可以用一个 N*N 的二维数组表示。

　　数独阶数

　　数独阶数 GridRank = N

　　宫格阶数 SubGridRank = Sqrt(N)

　　数独包含宫的阶数 SubGridIncludeRank = Sqrt(N)

　　数值范围

　　可填最大数字 MaxValue = N

　　可填最小数字 MinValue = 1 

　　任意阶数的数独

　　任意阶数独的表示（N≠K2,K>1,K∈Z）

　　任意阶数独仅有一个宫，所以数独阶数和宫阶数相等

　　以 7 阶为例，设置 GridRank = 7，SubGridRank = 7，SubGridIncludeRank = 1，即可

图2-1 数独结构解析

第三节 数独的求解

　　采用回溯法，直接寻找到一个空白格，尝试填入所有可能的数字，继续填下一个空白格，直至填满或者不能继续填入为止（不符合规则）。

　　寻找空白格

　　首先填入哪个空白格至关重要，不同的格子意味着不同的迭代和搜索次数

　　当一个格子的限制越多,也就是可填入数字越少时，优先选择该空白格，这样搜索次数最少

　　填充有效值

　　当确定空白格后就需要向其中填入数字了一一筛选出符合规则的数字

　　规则很简单，格子当前行，当前列，当前宫不能有相同数值出现

　　回溯法求解

　　递归寻找下一个空白格并填入有效值，直至中途不能再填值（不能解决的冲突）或者得出正确答案

　　出现不能解决的冲突时，回到上一个空白格，换一个有效值继续迭代搜索

附录

　　VB.NET 类 & C# 类，在线工具转换，仅供参考。

Public Class SudokuClass
    Public Property Rank As Integer '数独的阶数
        Get
            Return GridRank
        End Get
        Set(ByVal value As Integer)
            GridRank = value
            SubGridRank = CType(Math.Sqrt(value), Integer)
            SubGridIncludeRank = SubGridRank
            DataMaxValue = value
            DataMinValue = 1
        End Set
    End Property
    Public Property GridData As Integer?(,) '数独的数据
    Private GridRank As Integer '数独的阶数
    Private SubGridRank As Integer '子数独(宫)的阶数
    Private SubGridIncludeRank As Integer '数独包含子数独(宫)的阶数
    Private DataMaxValue As Integer '数独可填最大数值
    Private DataMinValue As Integer '数独可填最小数值
    ''' <summary>
    ''' 实例化一个指定阶数的数独类
    ''' </summary>
    ''' <param name="nRank">指定的阶数</param>
    Public Sub New(nRank As Integer)
        Me.Rank = nRank
    End Sub

    Public Function GenerateInitialNumbers() As Integer?(,)
        ReDim GridData(GridRank - 1, GridRank - 1)
        For i = 0 To GridRank - 1
            For j = 0 To GridRank - 1
                GridData(i, j) = 0 '暂无初始数字生成规则，请从数独文件导入
            Next
        Next
        Return GridData '返回一个空白数独
    End Function

    Public Function IsImpossible(ByVal Numbers As Integer?(,)) As Boolean
        Dim temp As Integer?
        For i = 0 To GridRank - 1
            For j = 0 To GridRank - 1
                If Not Numbers(i, j) = 0 Then
                    temp = Numbers(i, j)
                    Numbers(i, j) = 0
                    If GetExisting(Numbers, i, j, CInt(temp)) Then Numbers(i, j) = temp : Return True
                    Numbers(i, j) = temp
                End If
            Next
        Next
        Return False
    End Function
    Public Function IsWin(ByVal Numbers As Integer?(,)) As Boolean
        For i = 0 To GridRank - 1
            For j = 0 To GridRank - 1
                If Not Numbers(i, j).HasValue Then Return False '出现空格
            Next
        Next
        Dim TempInt As New List(Of Integer)
        '判断行重复
        For i = 0 To GridRank - 1
            TempInt.Clear()
            For j = 0 To GridRank - 1
                TempInt.Add(CInt(Numbers(i, j)))
            Next
            If IsDuplicate(TempInt.ToArray) Then Return False
        Next
        '判断列重复
        For j = 0 To GridRank - 1
            TempInt.Clear()
            For i = 0 To GridRank - 1
                TempInt.Add(CInt(Numbers(i, j)))
            Next
            If IsDuplicate(TempInt.ToArray) Then Return False
        Next
        '判断宫格重复
        For i = 0 To GridRank - 1 Step SubGridRank
            For j = 0 To GridRank - 1 Step SubGridRank
                TempInt.Clear()
                For i2 = 0 To SubGridRank - 1
                    For j2 = 0 To SubGridRank - 1
                        TempInt.Add(CInt(Numbers(i + i2, j + j2)))
                    Next
                Next
                If IsDuplicate(TempInt.ToArray) Then Return False
            Next
        Next
        Return True
    End Function
    ''' <summary>
    ''' 判断一个序列是否有重复数字
    ''' </summary>
    ''' <param name="Numbers"></param>
    ''' <returns></returns>
    Private Function IsDuplicate(ByVal Numbers() As Integer) As Boolean
        Array.Sort(Numbers)
        If Numbers.Length > 1 Then
            For i = 0 To Numbers.Length - 2
                If Numbers(i) = Numbers(i + 1) Then Return True
            Next
        End If
        Return False
    End Function
    ''' <summary>
    ''' 返回指定位置的所有可填数字的序列
    ''' </summary>
    ''' <param name="Numbers">原数组</param>
    ''' <param name="gX">指定的位置的X值，从0开始</param>
    ''' <param name="gY">指定的位置的Y值，从0开始</param>
    ''' <returns></returns>
    Public Function GetEnabledNum(ByVal Numbers As Integer?(,), gX As Integer, gY As Integer) As Integer()
        Dim NumList As New List(Of Integer)
        For i = DataMinValue To DataMaxValue
            If GetExisting(Numbers, gX, gY, i) = False Then NumList.Add(i)
        Next
        Return NumList.ToArray
    End Function
    '递归求解数独
    Private Function GetValue(ByVal gData As Integer?(,)) As List(Of Integer?(,))
        Dim ResultList As New List(Of Integer?(,))
        Dim i, j As Integer
        Dim tempPoint As Point = getStartPoint(gData)
        i = tempPoint.X : j = tempPoint.Y
        If i >= 0 AndAlso j >= 0 Then
            For value = DataMinValue To DataMaxValue
                If GetExisting(gData, i, j, value) = False Then
                    gData(i, j) = value
                    GetValue(gData)
                    gData(i, j) = 0
                End If
            Next
        Else
            '新增一个结果
            ResultList.Add(gData)
        End If
        Return ResultList
    End Function
    '查找当前空白格(最佳格)
    Private Function getStartPoint(ByRef data As Integer?(,)) As Point
        Dim gPoint As Point
        Dim tempValue As Integer
        Dim maxValue As Integer
        '查找限制最多的空白格
        For i = 0 To GridRank - 1
            For j = 0 To GridRank - 1
                If data(i, j) = 0 Then
                    tempValue = 0
                    For k = 0 To GridRank - 1
                        If data(i, k) > 0 Then tempValue += 1
                        If data(k, j) > 0 Then tempValue += 1
                        If data((i \ SubGridIncludeRank) * SubGridIncludeRank + k \ SubGridIncludeRank, (j \ SubGridIncludeRank) * SubGridIncludeRank + (k Mod SubGridIncludeRank)) > 0 Then tempValue += 1
                    Next
                    If tempValue > maxValue Then
                        maxValue = tempValue
                        gPoint.X = i
                        gPoint.Y = j
                    End If
                End If
            Next
        Next
        If maxValue > 0 Then
            Return gPoint
        Else
            gPoint.X = -1
            gPoint.Y = -1
            Return gPoint
        End If
    End Function
    '判断同行同列同宫是否已经存在
    Private Function GetExisting(ByRef data As Integer?(,), ByVal gX As Integer, ByVal gY As Integer, ByVal gValue As Integer) As Boolean
        For k = 0 To GridRank - 1
            If data(gX, k) = gValue OrElse data(k, gY) = gValue OrElse data((gX \ SubGridIncludeRank) * SubGridIncludeRank + k \ SubGridIncludeRank, (gY \ SubGridIncludeRank) * SubGridIncludeRank + (k Mod SubGridIncludeRank)) = gValue Then
                Return True
            End If
        Next
        Return False
    End Function
End Class
VB.NET 
using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
public class SudokuClass
{
    public int Rank {
        //数独的阶数
        get { return GridRank; }
        set {
            GridRank = value;
            SubGridRank = Convert.ToInt32(Math.Sqrt(value));
            SubGridIncludeRank = SubGridRank;
            DataMaxValue = value;
            DataMinValue = 1;
        }
    }
    public int?[,] GridData { get; set; }
    //数独的数据
        //数独的阶数
    private int GridRank;
        //子数独(宫)的阶数
    private int SubGridRank;
        //数独包含子数独(宫)的阶数
    private int SubGridIncludeRank;
        //数独可填最大数值
    private int DataMaxValue;
        //数独可填最小数值
    private int DataMinValue;
    /// <summary>
    /// 实例化一个指定阶数的数独类
    /// </summary>
    /// <param name="nRank">指定的阶数</param>
    public SudokuClass(int nRank)
    {
        this.Rank = nRank;
    }

    public int?[,] GenerateInitialNumbers()
    {
        GridData = new Nullable<int>[GridRank, GridRank];
        for (i = 0; i <= GridRank - 1; i++) {
            for (j = 0; j <= GridRank - 1; j++) {
                GridData[i, j] = 0;
                //暂无初始数字生成规则，请从数独文件导入
            }
        }
        return GridData;
        //返回一个空白数独
    }

    public bool IsImpossible(int?[,] Numbers)
    {
        int? temp = default(int?);
        for (i = 0; i <= GridRank - 1; i++) {
            for (j = 0; j <= GridRank - 1; j++) {
                if (!(Numbers[i, j] == 0)) {
                    temp = Numbers[i, j];
                    Numbers[i, j] = 0;
                    if (GetExisting(ref Numbers, i, j, Convert.ToInt32(temp))){Numbers[i, j] = temp;return true;}
                    Numbers[i, j] = temp;
                }
            }
        }
        return false;
    }
    public bool IsWin(int?[,] Numbers)
    {
        for (i = 0; i <= GridRank - 1; i++) {
            for (j = 0; j <= GridRank - 1; j++) {
                if (!Numbers[i, j].HasValue)
                    return false;
                //出现空格
            }
        }
        List<int> TempInt = new List<int>();
        //判断行重复
        for (i = 0; i <= GridRank - 1; i++) {
            TempInt.Clear();
            for (j = 0; j <= GridRank - 1; j++) {
                TempInt.Add(Convert.ToInt32(Numbers[i, j]));
            }
            if (IsDuplicate(TempInt.ToArray()))
                return false;
        }
        //判断列重复
        for (j = 0; j <= GridRank - 1; j++) {
            TempInt.Clear();
            for (i = 0; i <= GridRank - 1; i++) {
                TempInt.Add(Convert.ToInt32(Numbers[i, j]));
            }
            if (IsDuplicate(TempInt.ToArray()))
                return false;
        }
        //判断宫格重复
        for (i = 0; i <= GridRank - 1; i += SubGridRank) {
            for (j = 0; j <= GridRank - 1; j += SubGridRank) {
                TempInt.Clear();
                for (i2 = 0; i2 <= SubGridRank - 1; i2++) {
                    for (j2 = 0; j2 <= SubGridRank - 1; j2++) {
                        TempInt.Add(Convert.ToInt32(Numbers[i + i2, j + j2]));
                    }
                }
                if (IsDuplicate(TempInt.ToArray()))
                    return false;
            }
        }
        return true;
    }
    /// <summary>
    /// 判断一个序列是否有重复数字
    /// </summary>
    /// <param name="Numbers"></param>
    /// <returns></returns>
    private bool IsDuplicate(int[] Numbers)
    {
        Array.Sort(Numbers);
        if (Numbers.Length > 1) {
            for (i = 0; i <= Numbers.Length - 2; i++) {
                if (Numbers[i] == Numbers[i + 1])
                    return true;
            }
        }
        return false;
    }
    /// <summary>
    /// 返回指定位置的所有可填数字的序列
    /// </summary>
    /// <param name="Numbers">原数组</param>
    /// <param name="gX">指定的位置的X值，从0开始</param>
    /// <param name="gY">指定的位置的Y值，从0开始</param>
    /// <returns></returns>
    public int[] GetEnabledNum(int?[,] Numbers, int gX, int gY)
    {
        List<int> NumList = new List<int>();
        for (i = DataMinValue; i <= DataMaxValue; i++) {
            if (GetExisting(ref Numbers, gX, gY, i) == false)
                NumList.Add(i);
        }
        return NumList.ToArray();
    }
    //递归求解数独
    private List<int?[,]> GetValue(int?[,] gData)
    {
        List<int?[,]> ResultList = new List<int?[,]>();
        int i = 0;
        int j = 0;
        Point tempPoint = getStartPoint(ref gData);
        i = tempPoint.X;
        j = tempPoint.Y;
        if (i >= 0 && j >= 0) {
            for (value = DataMinValue; value <= DataMaxValue; value++) {
                if (GetExisting(ref gData, i, j, value) == false) {
                    gData[i, j] = value;
                    GetValue(gData);
                    gData[i, j] = 0;
                }
            }
        } else {
            //新增一个结果
            ResultList.Add(gData);
        }
        return ResultList;
    }
    //查找当前空白格(最佳格)
    private Point getStartPoint(ref int?[,] data)
    {
        Point gPoint = default(Point);
        int tempValue = 0;
        int maxValue = 0;
        //查找限制最多的空白格
        for (i = 0; i <= GridRank - 1; i++) {
            for (j = 0; j <= GridRank - 1; j++) {
                if (data[i, j] == 0) {
                    tempValue = 0;
                    for (k = 0; k <= GridRank - 1; k++) {
                        if (data[i, k] > 0)
                            tempValue += 1;
                        if (data[k, j] > 0)
                            tempValue += 1;
                        if (data[(i / SubGridIncludeRank) * SubGridIncludeRank + k / SubGridIncludeRank, (j / SubGridIncludeRank) * SubGridIncludeRank + (k % SubGridIncludeRank)] > 0)
                            tempValue += 1;
                    }
                    if (tempValue > maxValue) {
                        maxValue = tempValue;
                        gPoint.X = i;
                        gPoint.Y = j;
                    }
                }
            }
        }
        if (maxValue > 0) {
            return gPoint;
        } else {
            gPoint.X = -1;
            gPoint.Y = -1;
            return gPoint;
        }
    }
    //判断同行同列同宫是否已经存在
    private bool GetExisting(ref int?[,] data, int gX, int gY, int gValue)
    {
        for (k = 0; k <= GridRank - 1; k++) {
            if (data[gX, k] == gValue || data[k, gY] == gValue || data[(gX / SubGridIncludeRank) * SubGridIncludeRank + k / SubGridIncludeRank, (gY / SubGridIncludeRank) * SubGridIncludeRank + (k % SubGridIncludeRank)] == gValue) {
                return true;
            }
        }
        return false;
    }
}
C#

图4-1 十六阶数独

 

转载于:https://www.cnblogs.com/experdot/p/4839511.html

weixin_30483013
关注
DLX算法解数独游戏 Java版
魔神翼
07-11 2923
使用DLX算法解数独游戏。 初学Java，算法代码是由C代码转换的。 DLX.java是算法类，Sudoku.java是界面类。 解号称世界上最难的数独用时10ms以内。 算法详解 Sudoku 数独 Dancing Links模板 使用方法 int n = 9; DLX dlx = new DLX(n * n * n + 1, 4 * n * n);          
数独求解：用c++做一个数独求解的程序（附源代码和.exe文件）
absWC的博客
02-10 8748
数独这个游戏大家都知道吧：玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3×3）内的数字均含1-9，不重复。 为了更好的区分已填和未填的格子，未填的格子用0表示！！ 1.输入 int a[11][11]; int alltheanswer;//所有的解 int wanttheanswer;//期望得到的解数 int main() { printf("请输入9*9的数独:\n"); for(int i=1; ......
数独求解
Mic_H的博客
04-14 1171
题目链接 分析：数独的详细规则请参照--百度百科（这里就不设传送门啦，有兴趣的同学自行前往~）。 简单来说就是每一行、每一列都要有1~9的每个数字，既然是每个都要有，意味着不能重复。然而还有一个隐藏特征，就是九宫格（3*3）里面也得刚好是1~9. 用DFS试探和回溯就可以求出来，详细注解见代码。 #include <iostream> #include <cstdio&g...
LeetCode题解：数独游戏求解方法
qq_37172182的博客
10-19 416
在上一篇LeetCode题解：数独游戏有效性检测介绍了如何判断一个待填写的数独是否有效，本篇将进一步通过回溯法求解填充一个完整的数独。 图示： 求解结果： 解题思路： /* 回溯法： 1、遍历输入单元格，如果一个单元格为空，则填入该行为空的数字，更新对应的行、列、子单元； 2、判断填入数字是否满足数独有效性要求，如果不满足，填入该空格可填入的另一个有效数字； 3、重...
【C语言】求解数独 求数独的解的个数 多解数独算法
最新发布
GMfengyi的博客
10-11 1171
解决多解数独，搜索问题。
C语言数独游戏的求解方法
08-26
C语言数独游戏的求解方法是指使用C语言来解决数独游戏的解法。数独游戏是一种流行的逻辑游戏，玩家需要填充一个9x9的矩阵，使得每行、每列和每个3x3的小矩阵中都包含数字1-9，且每个数字只能出现一次。 该方法主要...
Python数独求解器：快速解析与解答数独游戏
4. 深度优先搜索（DFS）算法: 在数独求解中，深度优先搜索是一种常用的回溯算法，通过递归地尝试不同的数字填充，直到找到所有满足条件的解或者确定当前解法行不通为止。DFS是一种强大的搜索策略，用于解决各种组合...
数独求解器：如何快速解决数独问题
回溯算法适用于数独这类问题，因为它需要检查多个可能的解决方案，并且在发现当前解决方案不可行时撤销先前的步骤。 为了提高求解效率，求解器程序可能还应用了启发式搜索，比如按照一定规则排列数独棋盘上的数字，...
C++求解数独
weixin_41101375的博客
01-23 1047
本文利用回溯法求解数独，程序运行后输入9X9数独矩阵，数字0代表未填的数字，数字与数字之间以空格间隔 #include using namespace std; int A[9][9]={0}; int C=0; int s[81]={0};//标记未填写的空格 int row[9][10]={0};//行检测 int col[9][10]={0};//列检测 int p
使用VB.NET 2013的Windows完整数独游戏
04-01
本文是有关如何使用VB.NET编写自己的Sudoku游戏的教程。
（算法）数独问题
weixin_33958585的博客
11-22 321
题目： 数独问题：9*9的矩阵，要求每一行，每一列，每个九宫格都是1-9这九个数字且不能重复。 给定一9*9矩阵，里面有部分数空缺，要求找出满足上述要求的一个矩阵。 如： 思路： 代码：   #include&lt;iostream&gt; #include&lt;string.h&gt; using namespace std; class Sudoku{ ...
Gurobi求解标准数独问题
ilike_program的博客
12-29 2629
问题导入 数独问题就是将9×9的网格填充上1~9的整数值，同时保证每个整数在每一行、每一列和每个3×3方格只出现一次。网格中分布有一些线索，你的任务就是填充剩余的网格数字。对于此问题，可以使用0-1变量优化求解。 标准数独问题只要有解就行，无需设置目标函数，即：可行解就是数独问题的解。 决策变量 约束条件 1.对于给定的初始元素，都认为是等式约束： xijk=1∀k=cij∈C{{x}_{ij...
java实现数独的算法
weixin_30896825的博客
08-23 154
数独的历史： 　　数独前身为“九宫格”，最早起源于中国。数千年前，我们的祖先就发明了洛书，其特点较之现在的数独更为复杂，要求纵向、横向、斜向上的三个数字之和等于15，而非简单的九个数字不能重复。儒家典籍《易经》中的“九宫图”也源于此，故称“洛书九宫图”。而“九宫”之名也因《易经》在中华文化发展史上的重要地位而保存、沿用至今。 　　1783年，瑞士数学家莱昂哈德·欧拉发明了一种当时称作“拉...
每日随机一题 leetcode37. 解数独
加文斯利的博客
05-14 119
题： 思： 暴力解法，深搜+回溯 每次判断当前格子能不能从1到9里面选一个数，如果能就继续dfs 当dfs到最后一行结束的时候，整个递归结束，得到答案。 如果当前这个位置选了一个数，不能使得我们的递归运行到最后一行，说明当前位置不能选择这个数，因为当前位置可以考虑选择下一个数。如果当前位置不能选1-9任意的一个数，说明前面出问题了，回溯到前一步，改变前一步的数字。 码： public static void solveSudoku(char[][] board) { /*
回溯算法（解任意阶数独）
weixin_30300225的博客
01-11 157
<p>回溯算法的基本框架为</p><p> 函数名（int cnt）{ </p><p> for()</p><p> {</p><p> 赋值;</p><p> if（==）｛...
数独问题求解四：解数独
weixin_43464929的博客
01-18 512
数独问题求解四：解数独 1、心路历程 （写下这段话时我是崩溃的，写了一天的博客没保存，网页卡了一下全都不见了） 初见题目，我首先想到的算法是回溯DFS和暴力搜索，但是后者显然不太现实 抱着学习的心态我从网上找了许多大神对数独的求解，其中DFS和DLX两种算法的使用是最多的，由于时间关系，我对新算法DLX的掌握并不熟练，在此便使用了DFS解题 具体思路： DFS即深度优先搜索，我先对题中的0进行1到...
数独问题
蓝色的sky
12-27 566
设计算法求解数独 #include #define n 9 int a[n][n]={ 0, 0, 5, 3, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 2, 0, 0, 7, 0, 0, 1, 0, 5, 0, 0, 4, 0, 0, 0, 0, 5, 3, 0, 0, 0, 1, 0, 0, 7, 0, 0, 0, 6, 0, 0, 3, 2, 0, 0
用Java实现N*N的标准数独及对角线数独解题
常想一二
10-11 960
[size=x-large][b]1、引言[/b][/size] 前一段时间迷上了数独游戏（不知道数独的同学请自行百度，或[url=http://baike.baidu.com/link?url=AxWewvj278b3CQTybuJjuLJW3ehMNLbhGdZBs3qGCl9Ef6y7aRUYLtj_Oe20vAKv1Ghqfpxsyo4_qExCAgP8k6OG8FLL2Xgf09Sfl...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值