数独解题器强化版

原创 已于 2024-02-07 21:40:56 修改 · 3.3k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c# #wpf

于 2019-10-14 15:22:40 首次发布

经过实际测试，在解决高难度数独时，解题器的效果仍旧不理想，所以添加了数字提示功能。

另外添加了自定义数独数据功能。

MainWindow.xaml

<Window x:Class="SudokuSolver.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:SudokuSolver"
        mc:Ignorable="d"
        Title="SudokuSolver" Height="450" Width="600">

    <Grid>
        <UniformGrid Name="InputGrid" Height="360" Rows="9" Columns="9" Margin="40,30,185,20"/>
        <UniformGrid Name="BorderPanel" Height="360" Rows="3" Columns="3" Margin="40,30,185,20"/>
        <Button Name="SolveBtn" Height="50" Width="100" Margin="430,70,40,290" Content="OneStep"/>
        <Button Name="RestartBtn" Height="50" Width="100" Margin="430,130,40,190" Content="Restart"/>
        <Button Name="CustomBtn" Height="50" Width="100" Margin="430,210,40,110" Content="Clear"/>
        <Button Name="SaveBtn" Height="50" Width="100" Margin="430,300,40,50" Content="Save"/>
        <Button Name="Tips" Height="50" Width ="50" Content="Tips" Margin="520,10,10,340"/>
    </Grid>

</Window>

MainWindow.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace SudokuSolver
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {

        private int[,] numArr = new int[9, 9];
        private List<TextBox> textBoxList = new List<TextBox>();

        private struct FillNum {
            public int row;
            public int col;
            public List<int> possibleNums;
        }

        private bool isCustom = false;
        private int[,] customNumArr = new int[9, 9];
        private List<FillNum> tipsList = new List<FillNum>();

        public MainWindow()
        {
            InitializeComponent();
            Create81Grids();
            DrawBorders();
            InitSudokuArr();
            SolveBtn.Click += SolveBtn_Click;
            RestartBtn.Click += RestartBtn_Click;
            CustomBtn.Click += CustomBtn_Click;
            SaveBtn.Click += SaveBtn_Click;
            Tips.Click += Tips_Click;
        }

        

        private void Create81Grids() {//创建格子
            for (int i = 0; i < 81; i++)
            {
                TextBox textBox = new TextBox();
                textBox.Height = 30;
                textBox.Width = 30;
                textBox.FontSize = 25;
                textBox.Foreground = Brushes.Black;
                textBox.TextAlignment = TextAlignment.Center;
                textBox.Name = "box_"+i.ToString();
                textBox.KeyUp += TextBox_KeyUp;
                textBoxList.Add(textBox);
                InputGrid.Children.Add(textBox);
            }
        }

        private void TextBox_KeyUp(object sender, KeyEventArgs e)
        {
            TextBox textBox = sender as TextBox;
            textBox.Foreground = Brushes.Blue;
            int index = int.Parse(textBox.Name.Split('_')[1]);
            if (string.IsNullOrEmpty(textBox.Text))
            {
                numArr[index / 9, index % 9] = 0;
                return;
            }
            numArr[index / 9, index % 9] = int.Parse(textBox.Text);
        }

        private void DrawBorders() {//绘制边框
            for (int i = 0; i < 9; i++)
            {
                Border border = new Border();
                border.Height = 120;
                border.Width = 120;
                border.BorderThickness = new Thickness(3, 3, 3, 3);
                border.BorderBrush = Brushes.Black;
                BorderPanel.Children.Add(border);
            }
        }

        private void InitSudokuArr() {//数独数据初始化
            numArr = new int[9,9] {
                { 7, 1, 3, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 5, 0, 3 },
                { 0, 0, 6, 0, 3, 8, 0, 7, 0 },
                { 9, 7, 0, 0, 0, 6, 0, 0, 8 },
                { 0, 0, 0, 9, 0, 2, 0, 0, 0 },
                { 2, 0, 0, 1, 0, 0, 0, 5, 6 },
                { 0, 5, 0, 4, 6, 0, 8, 0, 0 },
                { 8, 0, 2, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 6, 1, 7 },
            };
            for (int i = 0; i < textBoxList.Count; i++)
                if (numArr[i / 9, i % 9] != 0)
                    textBoxList[i].Text = numArr[i / 9, i % 9].ToString();
                else
                    textBoxList[i].Text = "";
        }

        private void CustomBtn_Click(object sender, RoutedEventArgs e)//清除初始数据
        {
            numArr = new int[9, 9] {
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 6 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
            };
            for (int i = 0; i < textBoxList.Count; i++)
                textBoxList[i].Text = "";
        }

        private void SaveBtn_Click(object sender, RoutedEventArgs e)//保存自定义初始数据
        {
            isCustom = true;
            for (int i = 0; i < textBoxList.Count; i++)
                if (textBoxList[i].Text != "")
                    numArr[i / 9, i % 9] = int.Parse(textBoxList[i].Text);
                else
                    numArr[i / 9, i % 9] = 0;
            customNumArr = numArr;
        }

        private void RestartBtn_Click(object sender, RoutedEventArgs e)//游戏还原
        {
            if (isCustom)
            {
                numArr = customNumArr;
                for (int i = 0; i < textBoxList.Count; i++)
                    if (numArr[i / 9, i % 9] != 0 && textBoxList[i].Foreground == Brushes.Black)
                        textBoxList[i].Text = numArr[i / 9, i % 9].ToString();
                    else
                        textBoxList[i].Text = "";
            }
            else {
                for (int i = 0; i < textBoxList.Count; i++)
                {
                    textBoxList[i].Foreground = Brushes.Black;
                }
                InitSudokuArr();
            }
                
        }
        
        bool isShowTips = false;
        private void Tips_Click(object sender, RoutedEventArgs e)
        {
            if (isShowTips)
            {
                for (int i = 0; i < textBoxList.Count; i++)
                {
                    if (textBoxList[i].Foreground == Brushes.Red)
                    {
                        textBoxList[i].Text = "";
                        textBoxList[i].FontSize = 25;
                        textBoxList[i].Foreground = Brushes.Black;
                    }
                }
                isShowTips = false;
            }
            else
            {
                for (int i = 0; i < tipsList.Count; i++)
                {
                    FillNum fillNum = tipsList[i];
                    if (fillNum.possibleNums.Count > 0)
                    {
                        int index = fillNum.row * 9 + fillNum.col;
                        if (textBoxList[index].Text == "")
                        {
                            textBoxList[index].FontSize = 10;
                            textBoxList[index].Foreground = Brushes.Red;
                            for (int j = 0; j < fillNum.possibleNums.Count; j++)
                            {
                                textBoxList[index].Text += fillNum.possibleNums[j];
                            }
                        }
                    }
                }
                isShowTips = true;
            }

        }

        private void SolveBtn_Click(object sender, RoutedEventArgs e)//点击解决按钮
        {
            CheckWrong();
            //找出可填数据
            List<FillNum> possibleNumsList = new List<FillNum>();
            for (int i = 0; i < 9; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    int num = numArr[i, j];
                    if (num == 0) {
                        FillNum fillNum = new FillNum();
                        fillNum.row = i;
                        fillNum.col = j;
                        fillNum.possibleNums = FindPossibleNums(i, j);
                        possibleNumsList.Add(fillNum);
                    }
                }
            }
            tipsList = possibleNumsList;
            List<List<FillNum>> Grid9List = Splict9GridList(possibleNumsList);
            List<List<FillNum>> Row9List = Splict9RowList(possibleNumsList);
            List<List<FillNum>> Col9List = Splict9ColList(possibleNumsList);

            for (int i = 0; i < Grid9List.Count; i++)
            {
                List<FillNum> gridList = Grid9List[i];//代表某个九宫格的可填数据
                List<FillNum> rowList = Row9List[i];
                List<FillNum> colList = Col9List[i];

                int guessNum = 1;
                while (guessNum < 10) {
                    int activeCountG = 0;
                    int activeCountR = 0;
                    int activeCountC = 0;   
                    FillNum fillFlag = new FillNum();

                    //判断九宫格
                    for (int j = 0; j < gridList.Count; j++)
                    {
                        List<int> possibleNums = gridList[j].possibleNums;
                        if (possibleNums.Contains(guessNum))
                        {
                            fillFlag = gridList[j];
                            activeCountG++;
                        }
                    }
                    if (activeCountG == 1)
                        FillNumber(fillFlag.row, fillFlag.col, guessNum);
                    //判断行
                    for (int k = 0; k < rowList.Count; k++)
                    {
                        List<int> possibleNums = rowList[k].possibleNums;
                        if (possibleNums.Contains(guessNum))
                        {
                            fillFlag = rowList[k];
                            activeCountR++;
                        }
                    }
                    if (activeCountR == 1)
                        FillNumber(fillFlag.row, fillFlag.col, guessNum);
                    //判断列
                    for (int l = 0; l < colList.Count; l++)
                    {
                        List<int> possibleNums = colList[l].possibleNums;
                        if (possibleNums.Contains(guessNum))
                        {
                            fillFlag = colList[l];
                            activeCountC++;
                        }
                    }
                    if (activeCountC == 1)
                        FillNumber(fillFlag.row, fillFlag.col, guessNum);

                    guessNum++;
                }
                
            }
        }

        private List<int> FindPossibleNums(int row, int col) {//找出格子可填数字
            List<int> optionNums = new List<int>{1,2,3,4,5,6,7,8,9};

            CheckOneRow(row, ref optionNums);
            CheckOneCol(col, ref optionNums);
            CheckOneGrid(row, col, ref optionNums);

            if (optionNums.Count == 1)
                FillNumber(row, col, optionNums[0]);

            return optionNums;
        }

        private void CheckOneRow(int row, ref List<int> nums) {//检查一行
            for (int i = 0; i < 9; i++)
            {
                int num = numArr[row, i];
                if (nums.Contains(num))
                    nums.Remove(num);
            }
        }

        private void CheckOneCol(int col, ref List<int> nums) {//检查一列
            for (int i = 0; i < 9; i++)
            {
                int num = numArr[i, col];
                if (nums.Contains(num))
                    nums.Remove(num);
            }
        }

        private void CheckOneGrid(int row, int col, ref List<int> nums) {//检查九宫格
            int startI = row / 3 * 3;
            int startJ = col / 3 * 3;

            for (int i = startI; i < startI+3; i++)
            {
                for (int j = startJ; j < startJ+3; j++)
                {
                    int num = numArr[i, j];
                    if (nums.Contains(num))
                        nums.Remove(num);
                }
            }
        }

        private void CheckWrong() {//检查异常
            //检查行列
            for (int i = 0; i < 9; i++)
            {
                List<int> allNumsRow = new List<int>();
                List<int> allNumsCol = new List<int>();
                bool isRowSame = false;
                bool isColSame = false;
                int sameRowIndex = -1;
                int sameColIndex = -1;
                for (int j = 0; j < 9; j++)
                {
                    int numR = numArr[i, j];
                    if (!allNumsRow.Contains(numR))
                        allNumsRow.Add(numR);
                    else if(numR != 0) {
                        isRowSame = true;
                        sameRowIndex = i+1;
                    }
                        
                    int numC = numArr[j, i];
                    if (!allNumsCol.Contains(numC))
                        allNumsCol.Add(numC);
                    else if (numC != 0)
                    {
                        isColSame = true;
                        sameColIndex = i+1;
                    }
                        
                }
                if (isRowSame)
                    MessageBox.Show("Wrong: Row" + sameRowIndex);
                if  (isColSame)
                    MessageBox.Show("Wrong: Col" + sameColIndex);
            }

            //检查九宫格
            for (int i = 0; i < 9; i+=3)
            {
                for (int j = 0; j < 9; j+=3)
                {
                    List<int> allNumsGrid = new List<int>();
                    bool isGridSame = false;

                    for (int x = i; x < i+3; x++)
                    {
                        for (int y = j; y < j+3; y++)
                        {
                            int num = numArr[x, y];
                            if (!allNumsGrid.Contains(num))
                                allNumsGrid.Add(num);
                            else if(num != 0)
                                isGridSame = true;
                        }
                    }
                    if (isGridSame)
                        MessageBox.Show("Wrong: Grid" + GetGridIndex(i,j));
                }
            }

        }

        private List<List<FillNum>> Splict9GridList(List<FillNum> orginalList) {//可能填的数字按九宫格划分
            List<List<FillNum>> resList = new List<List<FillNum>>();
            for (int i = 0; i < 9; i++)
            {
                resList.Add(new List<FillNum>());
            }

            for (int i = 0; i < orginalList.Count; i++)
            {
                FillNum fillNum = orginalList[i];
                int gridIndex = GetGridIndex(fillNum.row, fillNum.col);
                resList[gridIndex].Add(fillNum);
            }

            return resList;
        }

        private List<List<FillNum>> Splict9RowList(List<FillNum> orginalList)//可能填的数字按行划分
        {
            List<List<FillNum>> resList = new List<List<FillNum>>();
            for (int i = 0; i < 9; i++)
            {
                resList.Add(new List<FillNum>());
            }
            for (int i = 0; i < orginalList.Count; i++)
            {
                FillNum fillNum = orginalList[i];
                int rowIndex = fillNum.row;
                resList[rowIndex].Add(fillNum);
            }
            return resList;
        }

        private List<List<FillNum>> Splict9ColList(List<FillNum> orginalList)//可能填的数字按列划分
        {
            List<List<FillNum>> resList = new List<List<FillNum>>();
            for (int i = 0; i < 9; i++)
            {
                resList.Add(new List<FillNum>());
            }
            for (int i = 0; i < orginalList.Count; i++)
            {
                FillNum fillNum = orginalList[i];
                int colIndex = fillNum.col;
                resList[colIndex].Add(fillNum);
            }
            return resList;
        }

        private int GetGridIndex(int i, int j) {//获取所在九宫格索引
            if (i < 3 && j < 3) return 0;
            else if (i < 3 && j < 6) return 1;
            else if (i < 3) return 2;
            else if (i < 6 && j < 3) return 3;
            else if (i < 6 && j < 6) return 4;
            else if (i < 6) return 5;
            else if (j < 3) return 6;
            else if (j < 6) return 7;
            else return 8;
        }

        private void FillNumber(int i, int j, int num) {//填充数据
            numArr[i,j] = num;
            textBoxList[i * 9 + j].Foreground = Brushes.Green;
            textBoxList[i * 9 + j].Text = num.ToString();
            //MessageBox.Show((i + 1) + "行" + (j + 1) + "列解决：" + num);
        }
    }
}

以下是实际效果截图：

点击Clear按钮可以清除原始数据，然后用户输入数据，点击Save保存数据。

点击Tips按钮可以显示红色提示文本，点击第二次可以隐藏。

另外优化了求解算法，可以再更少的步骤得出结果。

sudoku_solver ：数独解题器
luoshuiqingfeng的博客
06-17 6094
在家陪上幼儿园的儿子做数学作业，其中有一个四阶数独的题目，如下。 第一次接触数独的我，被这个关于图形和数字的游戏吸引了，通过外在限制和内在逻辑推理得到结论的游戏，很适合对数字着迷的理工男。 但是毕竟四阶数独实在是太简单了。 于是我在晚上搜到了网站https://www.sudoku-cn.com/，它提供标准的九阶数独题目，如下： 解题还能防脑瘫，果然是一举两得。 既然无论哪个级别的数独样...
数独解答器
04-08
你曾经为了解开一个数独而花费整个下午吗? 你曾经因为一个无法完成的数独而痛苦不已吗? 你曾经在和朋友们一起比赛数独时落败吗? 使用数独解答器,帮您轻松解决一切数独难题。
数独求解器
05-28
使用c++语言，用QT编写的一个完善的数独求解软件
数独教学 一款数独解题软件 V4.2
06-07
是一款比较高端的数独教学解析应用，这款软件为用户提供大量的解题技巧，此软件能够根据自身情况进行一步步指导并解析，让每一位喜欢数独的爱好者都能够轻松快乐的学习，如果您是数独爱好者，或是个数独迷，那这个软件一定能让您满意，一步步指导，解析，学习起来更加容易，这可是个好老师，也是打法时间的好工具。
数独生成和解题工具
06-15
ss.exe是一个数独解题引擎 使用方法： ss.exe -v .9.5..8.7....2......3.49.2.1....67.......4..38..1526....5....7...8.9 .2..3.....96. ss.exe .9.5..8.7....2......3.49.2.1....67.......4..38..1526....5....7...8.9.2. .3.....96. ss.exe -v -v为详细输出，将打印解题步骤 最后一个参数为数独谜面，使用数字和点号逐行描述一个数独题目；为空则代表空数独，运行后将生成一个随机的数独
Sudoku-solver：数独解算器项目解析与实践
最新发布
weixin_29050829的博客
08-31 1851
本文还有配套的精品资源，点击获取 简介：数独是一种基于9x9格子逻辑推理游戏，每个3x3宫格内填入1到9数字，确保每行、每列和每个宫格内的数字唯一。"Sudoku-solver"是一个程序，旨在解决数独谜题。它使用多种算法，如回溯法、候选数法、唯一候选数法、隐性唯一候选数法、区块排除法和对角线数独解法，来自动找出数独的唯一解。项目的开发包括输入解析、初始化、解题算法、验证答...
HTML5实现的数独求解器：在线解决数独谜题
- 该数独求解器中可能使用了JavaScript来处理用户输入的数独谜题，计算解决方案，并在网页上动态显示结果。 - JavaScript中的函数和事件处理机制对于创建用户友好的交互式应用至关重要。 - 该应用可能还使用了DOM...
“Grupo ng mga Pogi”回购：回溯算法实现数独求解器
使用回溯的数独求解器 本文将详细探讨有关“cmsc142-sudoku”项目的回购过程，以及“Grupo ng mga Pogi”团队如何采用回溯算法构建数独求解器的实现细节。项目使用JavaScript作为编程语言，旨在解决经典的数独谜题...
Sudoku数独益智游戏（完美版1.1.1）
01-30
本游戏界面简洁，并有如下功能： 1. 按照5级难度自动布局或手工布局，并具有计时功能 2. 具有“下一步”提示，和步骤追踪“回退...注意：请下载我的空间中的最新“完美版”，该版本优化了自动布局算法，提高了布局速度
基于Python和OpenCV的实时数独解算器项目教程
数独求解算法是实现数独解算器的核心部分，它基于数独的规则，通过算法逻辑找出满足所有条件的数字填充方案。常见的求解算法有回溯法、约束传播算法、启发式搜索等。在本项目中，识别出的数字将被输入到这些算法中，...
数独解算器，计算数独题目
11-25
一个数独解算器，可以计算9*9大小的数独题目，输出所有的解。算法较快，可以作为数据结构的参考资料。
数独解析器
05-29
用java写的一个小程序，数独解析器，也就是一个用来解答数独的小程序，对于热爱数独的朋友有所帮助。一次做数独题居然做了一个小时，有一点郁闷，于是就写了这么一个小程序。
5*5数独破解器，可以用来平时练习解数独。
02-22
该文件是数独软件，可以用于解决4*4及5*5数独问题，方便快捷！
数独神器--用人工智能解数独题
02-03
解数独神器用于帮助你解决数独的难题，只要输入一个数独题，该工具就能自动给出解答，快速、高效，适合那些做数独题慢，又想提高速度的人。 使用C++开发，对于学习编程开发，算法，人工智能的人都有一定参考价值
数独教(学）案--完整版.doc
10-10
数独教学不仅是为了教授解题技巧，更在于锻炼学生的观察力、想象力和逻辑推理能力，符合新课改的精神，弥补传统教学中的不足。 **二、教学目标** 1. **尊重与引导**：尊重学生的个性，激发他们的学习兴趣，引导他们...
python数独解题器_Python编写的超帅数独可视化解题器
weixin_39978749的博客
12-09 293
数独相信大家都玩过，它被称为“聪明人的游戏”，在很多人眼里：会玩数独=高智商为什么？因为数独能够培养观察力，提高反应力：数独的练习能够锻炼手眼脑的协调性、提高手脑并用的能力，锻炼大脑的思维灵活度，全面提高反应力。非常适合孩子在成长过程中锻炼大脑，适合成年人在生活中激活思维。不过当我们遇到不会解的数独怎么办？对于我们这些学Python的人而言，答案当然是用Python算出来啦！基于 Pygame-S...
数独求解器——SudokuResolv完全指南
gitblog_00310的博客
08-22 1163
数独求解器——SudokuResolv完全指南 SudokuResolvSudoku solver with OCR capability on iOS (edit: developed for iOS 4 before ARC, some memory reference changes may be required to get the app to make a full run.)项目...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值