数独游戏（9*9）

最新推荐文章于 2021-09-17 11:38:07 发布
最新推荐文章于 2021-09-17 11:38:07 发布
阅读量680 收藏 3
点赞数 1
分类专栏： 题解 搜索 文章标签： dfs 剪枝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxmbbd/article/details/106105491
版权

题目

英文题目

在这里插入图片描述

中文题目

在这里插入图片描述

输入样例

.2738..1..1...6735.......293.5692.8...........6.1745.364.......9518...7..8..6534.
......52..8.4......3...9...5.1...6..2..7........3.....6...1..........7.4.......3.
end

输出样例

527389416819426735436751829375692184194538267268174593643217958951843672782965341
416837529982465371735129468571298643293746185864351297647913852359682714128574936

能过的是题解四，往下扒拉吧

题解一：DFS(1000ms会超时）

#include <bits/stdc++.h>
using namespace std;
int P[9][9];
bool flag = false;
char s[81];
// 判断即将放入的是否符合条件 
bool check(int n, int num)
{
	// 行 ,列
	for (int i = 0; i < 9; i++)
	{
		if (P[n / 9][i] == num || P[i][n % 9] == num)
		{
			return false;
		}
	}
	// 宫
	int x = n / 9 / 3 * 3;
	int y = n % 9 / 3 * 3;
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			if (P[x + i][y + j] == num)
			{
				return false;
			}
		}
	}
	return true;
}
void dfs(int n)
{
	// 成功 
	if (n == 81)
	{
		flag = true;
		return;
	}
	int x = n / 9, y = n % 9;
	// 有值 跳过 
	if (P[x][y])
	{
		dfs(n + 1);
		return;
	}
	// 遍历 
	for (int i = 1; i <= 9; i++)
	{
		// 判断成功 赋值  
		if (check(n, i))
		{
			P[x][y] = i;
			dfs(n + 1);
			// 退出时判断是否完成  完成时退出 
			if (flag)
			{
				return;
			}
			// 未完成 重置棋盘 
			P[x][y] = 0;
		}
	}
}
int main()
{
	ios::sync_with_stdio(false);
   
	while (scanf("%[^\n]", &s))
	{
		 getchar();
		flag = false;
		char t;
		int k = 0;
		for (int i = 0; i < 9; ++i)
			for (int j = 0; j < 9; ++j)
			{
				t = s[k]; //cout << " t1: " << t;
				if (t == '.') t = '0';
				P[i][j] = t - '0'; //cout << " t2: " << t<< " P[i][j]: " << P[i][j];
				++k;
			}
		dfs(0);
		for (int i = 0; i < 9; ++i)
			for (int j = 0; j < 9; ++j)
			{
				printf("%d",P[i][j]);
			}
		printf("\n");
	}
	return 0;
}

题解二：DFS(1000ms会超时）

#include<bits/stdc++.h>
#define scd(x) scanf("%d",&x)
#define scdd(x,y) scanf("%d %d",&x,&y)
#define sclld(x) scanf("%lld",&x)
#define sclldd(x,y) scanf("%lld %lld",&x,&y)
#define print(x) cout<<x<<endl
#define CLR(a) memset(a,0,sizeof(a))
using namespace std;
typedef long long  ll;
const int maxn=(int)4e5+500;
const double eps = 1e-7;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
const ll mod = 998244353;
template<typename tp>inline tp lowbit(tp x){return x&(-x);}
template<typename tp_>void debug(tp_ x) {cout<<"*********** "<<x<<" *************"<<endl;}
template<typename tp1_,typename tp2_>void debug(tp1_ x,tp2_ y){cout<<"*********** "<<x<<" "<<y<<" *************"<<endl;}
struct P{int x,y;};
char  s[100];
int a[15][15];
bool row[15][15],col[15][15],block[4][4][15];
bool judge(int x,int y,int num){
   if(!row[x][num]&&!col[y][num]&&!block[x/3][y/3][num])return true;
   else return false;
}
void dfs(int x,int y){
    int xx=x,yy=y;
    if(x>=9||y>=9){
         for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                printf("%d",a[i][j]);
            }
        }
        cout<<endl;
        return ;
    }
    if(a[x][y]){
        dfs(x+(y+1)/9,(y+1)%9);
        return ;
    }
    for(int i=1;i<=9;i++){
        if(judge(x,y,i)){
            a[xx][yy]=i;

            row[x][i]=1;
            col[y][i]=1;
            block[x/3][y/3][i]=1;
            dfs(x+(y+1)/9,(y+1)%9);
            a[xx][yy]=0;
            row[xx][i]=0;
            col[yy][i]=0;
            block[xx/3][yy/3][i]=0;
        }
    }
}
void init(){
    CLR(row);
    CLR(col);
    CLR(block);
}
void solve(){
    while(scanf("%s",s)){
        if(s[0]=='e')break;
        init();
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                int id = i*9+j;
                if(s[id]=='.'){
                    a[i][j] = 0;
                    continue;
                }
                int num=s[id]-'0';
                a[i][j] = num;
                row[i][num] = 1;
                col[j][num] = 1;
                block[i/3][j/3][num] = 1;
            }
        }
        dfs(0,0);
    }
}
int main(){
    solve();
    return 0;
}

题解三：dance link x(1000ms会超时）

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
const int N = 9;
const int maxn = N * N * N + 10;
const int maxnode = maxn * 4 + maxn + 10;
char g[maxn];
struct DLX
{
    int n,m,sz;
    int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];
    int H[maxn],S[maxn];
    int ansd,ans[maxn];
    void init(int _n,int _m)
    {
        n = _n;
        m = _m;
        for(int i = 0;i <= m;i ++)
        {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0;
        L[0] = m;
        sz = m;
        for(int i = 1;i <= n;i ++)
        {
            H[i] = -1;
        }
    }
    void Link(int r,int c)
    {
        ++ S[Col[++ sz] = c];
        Row[sz] = r;
        D[sz] = D[c];
        U[D[c]] = sz;
        U[sz] = c;
        D[c] = sz;
        if(H[r] < 0) H[r] = L[sz] = R[sz] = sz;
        else
        {
            R[sz] = R[H[r]];
            L[R[H[r]]] = sz;
            L[sz] = H[r];
            R[H[r]] = sz;
        }
    }
   void Remove(int c)
    {
        L[R[c]] = L[c];
        R[L[c]] = R[c];
        for(int i = D[c];i != c;i = D[i])
        {
            for(int j = R[i];j != i;j = R[j])
            {
                U[D[j]] = U[j];
                D[U[j]] = D[j];
                -- S[Col[j]];
            }
        }
    }
    void resume(int c)
    {
        for(int i = U[c];i != c;i = U[i])
        {
            for(int j = L[i];j != i;j = L[j])
            {
                ++ S[Col[U[D[j]] = D[U[j]] = j]];
            }
        }
        L[R[c]] = R[L[c]] = c;
    }
    bool Dance(int d)
    {
        if(R[0] == 0)
        {
            for(int i = 0;i < d;i ++)
            {
                g[(ans[i] - 1) / 9] = (ans[i] - 1) % 9 + '1';
            }
            for(int i = 0;i < N * N;i ++)
            {
                printf("%c",g[i]);
            }
            printf("\n");
            return true;
        }
        int c = R[0];
        for(int i = R[0];i != 0;i = R[i])
        {
            if(S[i] < S[c])
                c = i;
        }
        Remove(c);
        for(int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];
            for(int j = R[i]; j != i;j = R[j]) Remove(Col[j]);
            if(Dance(d + 1)) return true;
            for(int j = L[i];j != i;j = L[j]) resume(Col[j]);
        }
        resume(c);
        return false;
    }
};
void place(int &r,int &c1,int &c2,int &c3,int &c4,int i,int j,int k)
{
    r = (i * N + j) * N + k;
    c1 = i * N + j + 1;
    c2 = N * N + i * N + k;
    c3 = N * N * 2 + j * N + k;
    c4 = N * N * 3 + ((i / 3) * 3 + (j / 3)) * N + k;
}
DLX dlx;
int main()
{
  //  freopen("test1","r",stdin);
    while(scanf("%s",g))
    {
		if(g=="end")return 0;
		for(int i=0;i<81;++i)
		{
			if(g[i]=='.') g[i]='0';
		}
        dlx.init(N * N * N, N * N * 4);
        int r,c1,c2,c3,c4;
        for(int i = 0;i < N;i ++)
        {
            for(int j = 0;j < N;j ++)
            {
                for(int k = 1;k <= N;k ++)
                {
                    if(g[i * N + j] == '0' || g[i * N + j] == '0' + k)
                    {
                        place(r,c1,c2,c3,c4,i,j,k);
                        dlx.Link(r,c1);
                        dlx.Link(r,c2);
                        dlx.Link(r,c3);
                        dlx.Link(r,c4);
                    }
                }
            }
        }
        dlx.Dance(0);
    }
    return 0;
}

题解四：dance link x(35ms过）

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 9 * 9 * 9 * 9 * 9 * 4 + 5;//9 * 9 * 9行9 * 9 * 4列
int s[N],h[N],u[N],d[N],l[N],r[N],col[N],row[N],ans[N];
int head,num;
char str[200];
void init()
{
    memset(s,0,sizeof(s));//记得初始化，否则TLE！！
    head = 0;
    int i;
    int c = 9 * 9 * 4;
    for(i = 0;i <= c;i ++)
    {
        u[i] = d[i] = i;
        l[i] = (i - 1 + c + 1) % (c + 1);
        r[i] = (i + 1) % (c + 1);
    }
    num = c + 1;
    memset(h,0,sizeof(h));
 
}
void insert(int i,int j)
{
    if(h[i])
    {
        r[num] = h[i];
        l[num] = l[h[i]];
        l[r[num]] = num;
        r[l[num]] = num;
    }
    else
    {
        h[i] = num;
        l[num] = r[num] = num;
    }
    s[j] ++;
    u[num] = u[j];
    d[num] = j;
    d[u[j]] = num;
    u[j] = num;
    col[num] = j;
    row[num] = i;
    num ++;
}
void del(int c)
{
    l[r[c]] = l[c];
    r[l[c]] = r[c];
    int i,j;
    for(i = d[c];i != c;i = d[i])
    {
        for(j = r[i];j != i;j = r[j])
        {
            u[d[j]] = u[j];
            d[u[j]] = d[j];
            s[col[j]] --;
        }
    }
} 
void recover(int c)
{
    int i,j;
    for(i = u[c];i != c;i = u[i])
    {
        for(j = l[i];j != i;j = l[j])
        {
            s[col[j]] ++;
            u[d[j]] = d[u[j]] = j;
        }
    }
    r[l[c]] = l[r[c]] = c;
}
bool dfs(int k)
{
    int i,j;
    if(r[head] == head)
    {
        sort(ans,ans + 81);
        for(i = 0;i < 81;i ++)
        {
            printf("%d",ans[i] - i * 9);
        }
        printf("\n");
        return true;
    }
    int mn = N;
    int c;
    for(i = r[head];i != head;i = r[i])
    {
        if(s[i] < mn)
        {
            mn = s[i];
            c = i;
        }
    }
    del(c);
    for(i = d[c];i != c;i = d[i])
    {
        ans[k] = row[i];
        for(j = r[i];j != i;j = r[j])
            del(col[j]);
        if(dfs(k + 1))
            return true;
        for(j = l[i];j != i;j = l[j])
            recover(col[j]);
    }
    recover(c);
    return false;
}
int main()
{
    while(scanf("%s",str) != EOF)
    {
        if(str[0] == 'e')
            break;
        init();
        //system("pause");
        for(int i = 0;i < strlen(str);i ++)
        {
            int rr = i / 9;
            int cc = i - rr * 9;
            int base = (rr * 9 + cc) * 9;
            if(str[i] == '.')
            {
                for(int k = 1;k <= 9;k ++)//依次填充1-9
                {
                    insert(base + k,rr * 9 + k);//第rr行填k
                    insert(base + k,81 + 9 * cc + k);//第cc列填k
                    insert(base + k,81 + 81 + (3 * (rr / 3) + cc / 3) * 9 + k);
                    insert(base + k,81 + 81 + 81 + rr * 9 + cc + 1);
                }
            }
            else
            {
                insert(base + str[i] - '0',rr * 9 + str[i] - '0');
                insert(base + str[i] - '0',81 + 9 * cc + str[i] - '0');
                insert(base + str[i] - '0',81 + 81 + (3 * (rr / 3) + cc / 3) * 9 + str[i] - '0');
                insert(base + str[i] - '0',81 + 81 + 81 + rr * 9 + cc + 1);
            }
        }
        dfs(0);
    }
    return 0;
}
monster&&summit
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
回溯法
qq_43400374的博客
05-09 1072
7-1 青蛙过桥 (25 分) 一座长度为n的桥，起点的一端坐标为0，且在整数坐标i处有a[i]个石头【0<=a[i]<=4】， 一只青蛙从坐标0处开始起跳，一步可以跳的距离为1或2或3【即每一步都会落在整数点处】， 青蛙落在i处会踩着该点的所有石头，求青蛙跳出这座桥最少踩多少个石头？并且输出依次跳 过的坐标点路线，如果存在多种路线，输出字典序最小的那一条。 输入格式: 第一行整数n(<150000)，接着下一行会有n+1个由空格隔开的整数,即桥上各个坐标处石头数量。 输出格式: 第一行为
9*9数独游戏 C++&ncurses 开发
02-12
初级项目9*9数独游戏C++开发源码，界面采用Linux的ncurses文字界面。算法实现生成地图都有效，亲测可玩
1.数独游戏（生成题目解唯一）
热门推荐
一条咸鱼的博客
09-06 2万+
前几天在玩数独游戏的时候，产生了一个大胆的想法： 数独app上的题目都是现成的，干脆自己写一个可以随机生成数独的程序算了 一、需求提出： 1.随机生成数独题目，要求该题目有解（有一个解最好）； 2.当填数违反数独操作（填到题目原本的数字去了，填数违规等）时，禁止操作，弹出提示; 3.当81格都填满时，判断对错; 二、需求分析 总： 需求2,3相对简单，尤其是...
数独游戏（回溯算法）
李酒酒的博客
11-23 3838
蓝桥杯校内选择赛第6题，原题如下： 你一定听说过“数独”游戏。 如下图所示，玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个同色九宫内的数字均含1-9，不重复。 数独的答案都是唯一的，所以，多个解也称为无解。 本图的数字据说是芬兰数学家花了3个月的时间设计出来的较难的题目。但对会使用计算机编程的你来说，恐怕易如反掌了。 本题的要求就是输入数独
[LeetCode]36. Valid Sudoku
gqk289的专栏
12-29 208
https://leetcode.com/problems/valid-sudoku/ 判断是否为valid的数独问题 如何计算一个九宫格还是基本功啊！！！ 如何通过一个双层循环就判断row+col+matrix三个约束条件 public class Solution { public boolean isValidSudoku(char[][] board) {
2021 9.14 p.m.小结 以及 数独问题探索（T3）
Penguin_Wang的博客
09-17 467
T1:问题 A: 组合的输出 题目描述 排列与组合是常用的数学方法，其中组合就是从 n 个元素中抽出 r 个元素(不分顺序且 r<＝n)，我们可以简单地将 n 个元素理解为自然数 1，2，…，n，从中任取 r 个数。现要求你用递归的方法输出所有组合。例如 n＝5，r＝3，所有组合为：l 2 3 l 2 4 1 2 5 l 3 4 l 3 5 1 4 5 2 3 4 2 3 5 2 4 5 3 4 5 输入 一行两个自然数 n、r(1<n<21，1<＝r<＝n)。 输出
Python(+numpy)实现对9*9数独问题(单解或多解)的快速递归求解
01-20
Python(+numpy)实现对9*9数独问题的求解 利用Python(+numpy库)递归实现对9*9...无论是4*4还是9*9的数独游戏规则很简单很粗暴，拿9*9数独来说，规则可概括为 9组 1-9 共 81个数字（包含已给出的数字）填入 9*9 的方格
Android 数独游戏
08-11
数独是源自18世纪瑞士的一种数学游戏。是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。 ...
winform数独C#的数独游戏
12-10
winform数独C#的数独游戏 本程序基于.netframework使用C#语言开发，实现功能： 1、各个难度随机出题(New)； 2、数独解题提示(Compute)； 3、输入的合法性校验； 思路分享 说一下开发步骤及思路： 1、验证合法性...
生成数独游戏的python程序knapsackyolov9
最新发布
02-24
yolov9
安卓数独游戏
01-05
这是基于安卓的数独小游戏的代码，能够实现在9乘9的游戏界面中分为9个3乘3的方格，横向加竖向加斜向加的和均相等。
一个简单的数独游戏源码
03-15
一个简单的而数独游戏，可以自己生成数独题目，有GUI界面，炒鸡可爱，页面包含菜单，进度栏，可以实现一些简单的操作。
数独游戏（EXE文件）
07-04
数独游戏 选的题目都很简单 目前可以导入电子表格文件 把题目填在1-9列，2-10行就可以正常导入
数独小游戏《小程序游戏》
12-12
微信小程序游戏“数独”，亲测可以直接用web开发工具上传并通过验证发布的
9x9数独算法
04-13
NULL 博文链接：https://namas.iteye.com/blog/1733440
解9*9数独算法（C++）
qq_42731435的博客
11-08 5853
什么是数独 数独（shù dú）是源自18世纪瑞士的一种数学游戏。是一种运用纸、笔进行演算的逻辑游戏。已知有9行9列的格子，且被分成9个3*3的方块。其中一些格子内有数字，数值的范围为1-9 。玩家需要在其余的空白格子上填入数字，数字的范围也是1-9，要求所有空格都被填满而且满足以下条件： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 例如： 一个数独题目如下： 一种解法如下： 红色数字为玩家填入的答案，满
9*9数独游戏
weixin_44713389的博客
06-07 4084
分析： 深搜：很常规的从行开始遍历，遍历到底后，移到下一列再次遍历其行。如果遇到无法填入的情况则放回上一级尝试其他可选数字。 样例： 输入： 005300000 800000020 070010500 400005300 010070006 003200080 060500009 004000030 000009700 输出： 125346897 831467925 276918543 48962...
简易数独（9*9）
Crazy
04-25 4474
题目来源：http://acm.nyist.net/JudgeOnline/problem.php?pid=722 【题意】 数独游戏，含0的位置被填入1~9的数字之后，使得每一行每一列的数字都不一样。 【思路】 模板，不过在找到确定值之后，就要一直return，不然会超时。 【代码】#include<map> #include<stack> #include<queue> #includ
九宫格练习 9*9数独游戏
TIMELIMITE的专栏
05-19 4316
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include
c++ 数独游戏9*9
05-17
好的，以下是一个简单的 C++ 数独游戏实现，使用暴力回溯算法： ```c++ #include using namespace std; const int N = 9; int board[N][N]; bool isValid(int row, int col, int num) { // 检查行和列是否有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值