C# 数独游戏 递归，回溯，验证是否满足数独

最新推荐文章于 2023-09-22 22:14:56 发布
最新推荐文章于 2023-09-22 22:14:56 发布
阅读量1k 收藏 2
点赞数
分类专栏： 项目开发功能实例 文章标签： .net 数独 c# 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuanger_/article/details/41414355
版权

你不去做，别人不知道你会做!送给我自己。

题设：在9*9的数独表格内输入几个数字，自动完成数独；

准备：在充分理解递归，回溯之后，完成这个题目就不难了。但是高性能完成就还是得研究。。。。

原理概要：采用栈的数据结构模型存入已经输入过得数独表格，此时应该只有几个表格有数字，我们采用一个标记数字记下这些数字位置，他们是不能进行压栈和出栈的。然后从第一个格子开始遍历。验证a[0] 是否为空，则插入1，进行验证。符合数独。继续a[1]插入1，不符合数独则插入2，符合。继续a[2]插入1,2,3，等等。直到某个数字插入9也不符合数独的规则的时候，回溯；

原理详解:

主函数：

using ch.shudu.musoft.com.cn.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Runtime.Serialization.Json;
using ch.shudu.musoft.com.cn.Utils;
using System.Text;

namespace ch.shudu.musoft.com.cn.Controllers
{
    public class MainController : Controller
    {
        //
        // GET: /Main/

        /// <summary>
        /// 主页面
        /// </summary>
        /// <returns></returns>
        public ActionResult Index()
        {
            return View();
        }
        /// <summary>
        /// 进入数独
        /// </summary>
        /// <param name="json">传入的Json串</param>
        /// <returns></returns>
        public string count(string json)
        {
            Num[] numStack = JsonHelper.DataContractJsonDeserialize<Num[]>(json);
            //一位数装入栈里面
            Map map = ShuDuUtil.toArray(numStack);
            //进入计算
            while (map.top < 80)
            {
                for (int i = 1; i < 10; i++)
                {
                    //如果当前栈顶是10，则压如数字 判断；否则直接判断
                    if (map.stack[map.top] == 10)
                    {
                        //输入第一个数为空则不用入栈直接开始
                        if (map.top == 0)
                        {
                            map.stack[map.top] = i;
                            break ;
                        }
                        else
                        {
                            map.pop();
                            //判断压入之后是否正确；正确就直接压一下个；不正确就清空
                            if (ShuDuUtil.IsRight(map.push(i)))
                            {
                                break;
                            }
                            else
                            {
                                map.pop();
                                map.push(10);
                                continue;
                            }
                        }
                    }
                    else
                    {
                        //判断当前栈是否正确；
                        if (ShuDuUtil.IsRight(map.stack))
                        {
                            //如果正确，在压入一个数。看看是否正确；正确就继续往后压；
                            if (ShuDuUtil.IsRight(map.push(i)))
                            {
                                break;
                            }
                            else
                            {
                                //如果不正确则+1继续压入；如果遍历到9还未成功，则回溯；
                                if (i == 9)
                                {
                                    map = ShuDuUtil.Back(out i, map);
                                }
                                else
                                {
                                    map.pop();
                                }
                                continue;
                            }
                        }
                            //当前栈如果不正确，回溯。
                        else
                        {
                            if (map.top == 0)
                            {
                                map.stack[map.top] = i;
                                continue;
                            }
                            map.pop();
                            i = map.stack[map.top];
                        }
                    }

                }
            }
            //将结果拼接成串  传回去
            StringBuilder resultStr = new StringBuilder();
            foreach (int temp in map.stack)
            {
                resultStr = resultStr.Append(temp + ",");
            }
            return resultStr.ToString();
        }


    }
}


栈类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
<pre name="code" class="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace ch.shudu.musoft.com.cn.Models
{
    public class Map
    {
        //存数据的栈
        public int[] stack{ get; set; }
        //存储标记该格子是否能被改变
        public int[] tag { get; set; }
        //栈指针
        public int top;
        //构造函数
        public Map()
        {
            top = 0;
            stack = new int[81];
            tag = new int[81];
        }
        /// <summary>
        /// 出栈
        /// </summary>
        public int[] pop() {
            if (top != 0) {
                if (tag[top] == 10)
                {
                    stack[top] = 10;
                    top--;
                }
                else
                {
                    top--;
                    pop();
                }
            }

            return stack;
        }
        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="i">存入的数</param>
        /// <returns></returns>
        public int[] push(int i)
        {
            //不能超过81
            if (top < 81)
            {
                if (tag[top + 1] == 10)
                {
                    top++;
                    stack[top] = i;
                }
                else
                {
                    top++;
                    push(i);

                }
            }
            
            return stack;
            
        }

    }
}

 工具类： 

 

 

using ch.shudu.musoft.com.cn.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace ch.shudu.musoft.com.cn.Utils
{
    public static class ShuDuUtil
    {
        /// <summary>
        /// 数组转为栈
        /// </summary>
        /// <param name="jsonArray"></param>
        /// <returns></returns>
        public static Map toArray(Num[] numStack)
        {
            Map map = new Map();
            for (int i = 0; i < numStack.Length; i++)
            {
                map.tag[i] = numStack[i].num;
                map.stack[i] = numStack[i].num;
            }
            return map;
        }
        /// <summary>
        /// 验证当前数独是否正确
        /// </summary>
        /// <param name="numStack"></param>
        /// <returns></returns>
        public static bool IsRight(int[] Stack)
        {
            //验证每行是否正确
            List<int> listInt = new List<int>();
            for(int j = 0;j<9;j++){
                for (int i = 0; i < 9; i++) {
                    if (Stack[i+j*9] != 10) {
                        listInt.Add(Stack[i + j* 9]);
                    }
                }
                if (!IsEquel(listInt))
                {
                    return false;
                }
                listInt.Clear();
            }
            //验证每列是否正确
            for (int j = 0; j < 9; j++)
            {
                for (int i = 0; i < 9;i++ )
                {
                    if (Stack[i * 9 + j] != 10)
                    {
                        listInt.Add(Stack[i*9+j]);
                    }
                }
                if (!IsEquel(listInt))
                {
                    return false;
                }
                listInt.Clear();
            }
            //验证每个框框内是否正确
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    for (int k = 0; k < 3; k++) {
                        if (Stack[i * 3 + j*9+k] != 10)
                        {
                            listInt.Add(Stack[i * 3 + j * 9 + k]);
                        }
                    }  
                }
                if (!IsEquel(listInt))
                {
                    return false;
                }
                listInt.Clear();
            }
            //验证第二排
            for (int i = 27; i < 34; i=i+3)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 3; k++)
                    {
                        if (Stack[i + j * 9 + k] != 10)
                        {
                            listInt.Add(Stack[i + j * 9 + k]);
                        }
                    }
                }
                if (!IsEquel(listInt))
                {
                    return false;
                }
                listInt.Clear();
            }
            //验证第三排
            for (int i = 54; i < 61; i = i + 3)
            {
                for (int j = 0; j < 3; j++)
                {
                    for (int k = 0; k < 3; k++)
                    {
                        if (Stack[i + j * 9 + k] != 10)
                        {
                            listInt.Add(Stack[i + j * 9 + k]);
                        }
                    }
                }
                if (!IsEquel(listInt))
                {
                    return false;
                }
                listInt.Clear();
            }
                return true;
        }
        /// <summary>
        /// 判断该数组集合类是否存在相同的数
        /// </summary>
        /// <param name="intArray"></param>
        /// <returns></returns>
        public static bool IsEquel(List<int> list) {
            for(int i=0;i<list.Count;i++){
              for(int j=0;j<list.Count;j++){
                  if(i != j && list[i]==list[j]){
                      return false;
                  }
              }
            }
            return true;
        }
        /// <summary>
        /// 回溯函数
        /// </summary>
        /// <param name="i"></param>
        /// <param name="map"></param>
        /// <returns></returns>
        public static Map Back(out int i, Map map) {
            if (map.tag[map.top] != 10)
            {
                map.top--;
                i = map.stack[map.top];
                map.pop();
            }
            else {
                if (map.stack[map.top] == 9)
                {
                    map.pop();
                    map = Back(out i, map);
                }
                else {
                    i = map.stack[map.top];
                    map.top--;
                }
                
            }
            return map;
            
        }

    }

}
 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  Cheng_Han
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
数独游戏(C#)

				
			

			

				

					08-19
				

			

		

		

			
				
这个是一个用C#写数独游戏，有兴趣的自己可以看一哈。

			
		

	



                

            
              



	

		

			

				
					
C#数独游戏

				
			

			

				

					02-27
				

			

		

		

			
				
数独游戏，可以自己编辑关卡，支持标准数独，对角线数独，锯齿数独，奇偶数独。配有机器求解算法，以及候选数表。可以在数独上做记号，可以撤销填数。花了我40多天精心打造而成。

			
		

	



              


  
              

                


	

		

			

				
					
一款基于C#的数独小游戏

				
			

			

				

					12-31
				

			

		

		

			
				
一款基于C#的数独小游戏，主要利用回溯算法来完成对数独的求解

			
		

	





	

		

			

				
					
C# PC版做的 数独游戏

				
			

			

				

					01-22
				

			

		

		

			
				
介绍：用C#开发的数独游戏
核心：核心代码是从网上借鉴来的，
价值：仅供娱乐和学习参考。
用途：大家开心就好

			
		

	



		

			
		



	

		

			

				
					
c#编写的数独游戏

				
			

			

				

					11-05
				

			

		

		

			
				
自己编写的c#数独小游戏，望大家下载提意见。

			
		

	





	

		

			

				
					
C#数独小游戏（winform)

				
			

			

				

					12-12
				

			

		

		

			
				
C#数独小游戏（winform)C#数独小游戏（winform)C#数独小游戏（winform)C#数独小游戏（winform)C#数独小游戏（winform)

			
		

	





	

		

			

				
					
【原创】数独游戏，C#源码，可随机出题，自动解题，代码简易

				
			

			

				

					10-11
				

			

		

		

			
				
数独游戏的实现通常涉及到回溯法或者递归。在这个项目中，随机出题可能采用了这样的方法：首先生成一个完整的数独解，然后通过随机消除一些已知数字，形成不完整的数独盘面。自动解题则可能采用深度优先搜索（DFS）...

			
		

	





	

		

			

				
					
C#数独程序

				
			

			

				

					05-09
				

			

		

		

			
				
通过阅读和分析代码，你可以学习到如何使用C#编写递归函数，如何构建高效的数据结构，以及如何运用回溯算法来解决约束满足问题。  总结而言，C#数独程序是学习C#编程和算法应用的绝佳案例。它涵盖了面向对象编程、...

			
		

	





	

		

			

				
					
数独游戏源代码C#写的

				
			

			

				

					04-15
				

			

		

		

			
				
用C#写了个数独游戏,大家看看吧.
先生成的正确的数独,后去掉部分数字显示.
填定完成后会有成功提示.

			
		

	





	

		

			

				
					
C# 数独游戏（二）——数独求解

				
			

			

				

					
				

				

					05-10
					
					455
					
				

			

		

		

			
				
　　上一篇讲了怎么构造数独，这一节讲怎么对一个被挖掉一些格子的数独矩阵（如以下矩阵）进行求解，用的是回溯法。
　　
　　（1）用程序求解：构造数独矩阵，随机挖掉一些空格的时候，要记录下这些空格的坐标，我们在Table类中用一个链表储存这些坐标。因为储存的这些坐标是随机产生的，所以求解之前最后排下序（排序时可以将Coord坐标类实现IComparable接口，将坐标按X,Y进行二级排序...

			
		

	





	

		

			

				
					
用c#实现的一个数独游戏

				
			

			

				

					05-10
				

			

		

		

			
				
纯c#做的一个数独游戏，反复测试成功，代码通俗易懂，很适合初学者的学习，知识点丰富

			
		

	





	

		

			

				
					
c#实现数独

				
			

			

				

					08-23
				

			

		

		

			
				
c#对数独的实现，方便实用，且具有计算功能，是组合数学的必备程序

			
		

	





	

		

			

				
					
c#开发的数独游戏源码(提供解题功能)

				
			

			

				

					04-20
				

			

		

		

			
				
用C#搭建的简单数独游戏。界面友好大方，已经打包。有兴趣的朋友可以看一下。其中的解题功能用了基本行、列、矩阵排除法和余数的排除法，并没有用到回溯法，所以并不是所有数独问题都能解决。

			
		

	





	

		

			

				
					
C# 实现数独解答C# 实现数独解答C# 实现数独解答

				
			

			

				

					05-21
				

			

		

		

			
				
vs2015开发，借鉴网上的知识和回溯算法，递归的运用实现解答数独的功能。有兴趣的可以下载研究一波

			
		

	





	

		

			

				
					
C# 数独游戏 九宫格游戏

				
			

			

				

					08-26
				

			

		

		

			
				
c#数独游戏，适合于初学者（自己写得觉得十分满意，所以标价10分）

			
		

	





	

		

			

				
					
C# 实现数独游戏

					
最新发布

				
			

			

				

					ftfmatlab的博客
				

				

					09-22
					
					1285
					
				

			

		

		

			
				
基于winform框架实现的数独游戏，难度分6种

			
		

	





	

		

			

				
					
数独解法 C#

				
			

			

				

					dragonOnSky555的博客
				

				

					02-06
					
					482
					
				

			

		

		

			
				
实在闲着无聊，把平时在公司闲着无聊刷的有意思一点的算法题发一下把。虽然平时喜欢写C++，不过上班用的C#嘛，就随手C#写了。有更好想法，或者想一起交流学习的就留言咯~尤其是有游戏客户端开发的大佬能一起学习就更好了（本人服务器开发，哈哈）不多说，上代码吧。



public class SudokuArea
{
    private class SudokuInputNode
    {
   ...

			
		

	





	

		

			

				
					
C# 自嗨：数独

				
			

			

				

					GuestingNew的博客
				

				

					04-29
					
					800
					
				

			

		

		

			
				
本来想自己写个创建+解题的数独流程，但是。。。写着写着发现创建和解题就是直接连贯的。。。所以干脆搞个81步创建数独的流程算了；
关键点主要在随机数以及排除3×3九宫格设计
			Dictionary<Point, int> pointsDic_0 = new Dictionary<Point, int>
            {
                // 解特...

			
		

	





	

		

			

				
					
C#  数独游戏（一）——构造数独矩阵

				
			

			

				

					
				

				

					05-08
					
					741
					
				

			

		

		

			
				
　　其实一直都很想写个数独的游戏，最近刚好看了《编程之美》，得到了一些启发。
　　好，这时第一节，构造数独矩阵。主要用到深度搜索算法，先往下一个格子填数字（依次填入1~9），在9*9表格的行中检验数字有没有出现过，在9*9表格的列中检验数字有没有出现过，最后在3*3的表格中检验数字是否出现过。如果最后1~9中所有的数字都不符合，则开始回溯。重复以上过程，最终我们可以得到一个数独矩阵。
...

			
		

	





	

		

			

				
					
C语言实现数独游戏算法：回溯与判断技巧

				
			

			

				

					
				

			

		

		

			
				
通过这个C语言实现的数独游戏算法，学习者不仅可以理解递归和回溯的思想，还能提高编程技巧，特别是数组和逻辑判断的运用。在实践中，这种算法还可以进一步优化，例如引入启发式搜索策略，以加快求解速度。这是一个...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值