POJ3074 Sudoku（数独（二））（位运算优化及DFS）

最新推荐文章于 2020-07-17 16:32:56 发布
最新推荐文章于 2020-07-17 16:32:56 发布
阅读量1k 收藏 8
点赞数 3
分类专栏： # >>>>深度优先搜索 ∨∨Acm 文章标签： dfs 数独 位运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40889820/article/details/86702558
版权

题目链接

（AC代码在最后面）

Description

In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3 × 3 subgrids. For example,

.2738..1.
.1...6735
.......29
3.5692.8.
.........
.6.1745.3
64.......
9518...7.
.8..6534.

Given some of the numbers in the grid, your goal is to determine the remaining numbers such that the numbers 1 through 9 appear exactly once in (1) each of nine 3 × 3 subgrids, (2) each of the nine rows, and (3) each of the nine columns.

Input

The input test file will contain multiple cases. Each test case consists of a single line containing 81 characters, which represent the 81 squares of the Sudoku grid, given one row at a time. Each character is either a digit (from 1 to 9) or a period (used to indicate an unfilled square). You may assume that each puzzle in the input will have exactly one solution. The end-of-file is denoted by a single line containing the word “end”.

Output

For each test case, print a line representing the completed Sudoku puzzle.

Sample Input

.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

Sample Output

527389416819426735436751829375692184194538267268174593643217958951843672782965341
416837529982465371735129468571298643293746185864351297647913852359682714128574936

如果按照POJ2676 Sudoku、POJ2918 Tudoku（数独（一））做是行不通的，需要进一步优化

超时代码：

//CSDN博客：https://blog.csdn.net/qq_40889820
#include<iostream>
#include<sstream>
#include<fstream>
#include<algorithm>
#include<string>
#include<cstring>
#include<iomanip>
#include<vector>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<map>
#define mem(a,b) memset(a,b,sizeof(a))
#define random(a,b) (rand()%(b-a+1)+a)
#define e 2.71828182
#define Pi 3.141592654
using namespace std;
char table[10][10];
int row[10][10],col[10][10],grid[10][10];
bool flag=false;
void dfs(int x,int y)//填第(x,y)格 
{
	if(flag) return;//已找到一种解法 
	if(y>9) y=1,x+=1;
	if(x>9)
	{
		for(int i=1;i<=9;i++)
		cout<<table[i]+1;
		flag=true;
		return;
	}
	if(table[x][y]!='0') dfs(x,y+1);
	else if(table[x][y]=='0') 
	{
		int ord=(x-1)/3*3+(y-1)/3+1;//第几个方块 
		for(int i=1;i<=9;i++)
		{
			if(!row[x][i]&&!col[y][i]&&!grid[ord][i])
			{
				table[x][y]=i+'0';
				row[x][i]=1;col[y][i]=1;grid[ord][i]=1;
				dfs(x,y+1);
				//回溯 
				table[x][y]='0';
				row[x][i]=0;col[y][i]=0;grid[ord][i]=0;
			}
		}
	}
}
int main()
{
	string str; 
	while(cin>>str)
	{
		if(str=="end") break;
		int count=0;
		mem(row,0);mem(col,0);mem(grid,0);
		for(int i=1;i<=9;i++)
			for(int j=1;j<=9;j++)
			{
				table[i][j]=str[count++];
				if(table[i][j]=='.') table[i][j]='0';
				row[i][table[i][j]-'0']=1;
				col[j][table[i][j]-'0']=1;
				int ord=(i-1)/3*3+(j-1)/3+1;
				grid[ord][table[i][j]-'0']=1;
			}
				
		dfs(1,1);
		cout<<endl;
		flag=false;
	}
}

样例用时：

位运算优化，利用三个一维数组row[10],col[10],grid[10]的二进制来记录数字的占用情况。
可填的数字为1~9，故令init=111111111(2)=511=(1<<9)-1，表示一开始1~9都可以填（都未被占用），row[i]表示第i行数字的占用情况，col数组和grid数组同理。当需要获取一个x行y列z方块的空白格子能填的数字只需要先将row[x]&col[y]&grid[z]（位与），再利用lowbit函数和预先处理好的figure数组依次取出能填的数字，如100100010即代表数字2、6、9可填。利用异或运算更新状态。

//CSDN博客：https://blog.csdn.net/qq_40889820
#include<iostream>
#include<sstream>
#include<fstream>
#include<algorithm>
#include<string>
#include<cstring>
#include<iomanip>
#include<vector>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<map>
#define mem(a,b) memset(a,b,sizeof(a))
#define random(a,b) (rand()%(b-a+1)+a)
#define e 2.71828182
#define Pi 3.141592654
using namespace std;
char table[10][10];
int row[10],col[10],grid[10];//二进制记录行、列、方块的数字占用情况 
int figure[(1<<8)+1];//
bool flag=false;
int lowbit(int x)
{
	return x&(-x);
}
void dfs(int x,int y)//填第(x,y)格 
{
	if(flag) return;//已找到一种解法 
	if(y>9) y=1,x+=1;
	if(x>9)
	{
		for(int i=1;i<=9;i++)
		cout<<table[i]+1;
		flag=true;
		return;
	}
	if(table[x][y]!='0') dfs(x,y+1);
	else if(table[x][y]=='0') 
	{
		int ord=(x-1)/3*3+(y-1)/3+1;//第几个方块 
		int status=row[x]&col[y]&grid[ord];//statue的二进制记录了行、列、方块数字的占用情况 
		
		for(int i=status;i>0;i-=lowbit(i))
		{
			int num=figure[lowbit(i)];//可填的数字 
			table[x][y]=num+'0';
			row[x] ^= lowbit(i);
			col[y] ^= lowbit(i);
			grid[ord] ^= lowbit(i);
			dfs(x,y+1);
			//回溯
			table[x][y]='0';
			row[x] ^= lowbit(i);
			col[y] ^= lowbit(i);
			grid[ord] ^= lowbit(i); 
		}
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	string str; 
	for(int i=0;i<9;i++) 
		figure[1<<i]=i+1;
	int init=(1<<9)-1;//二进制为111111111 
	while(cin>>str)
	{
		if(str=="end") break;
		int count=0;
		for(int i=1;i<=9;i++)
			row[i]=col[i]=grid[i]=init;	
		for(int i=1;i<=9;i++)
			for(int j=1;j<=9;j++)
			{
				table[i][j]=str[count++];
				if(table[i][j]=='.')
				{
					 table[i][j]='0';
					 continue;
				}
				row[i] ^= (1<<(table[i][j]-'0'-1));
				col[j] ^= (1<<(table[i][j]-'0'-1));
				int ord=(i-1)/3*3+(j-1)/3+1;
				grid[ord] ^= (1<<(table[i][j]-'0'-1));
			}
			/*clock_t t;
		t=clock();*/
		dfs(1,1);
		/*t=clock()-t;
		cout<<"时间为："<<(((float)t)/CLOCKS_PER_SEC*1000)<<"ms\n";*/
		cout<<endl;
		flag=false;
	}
}

样例用时：（由样例来看优化并不是特别明显？但是实际上位运算优化能提升较大的性能）

优化一下搜索顺序，优先处理可选数字较少的格子，一开始是静态的保存好，并未考虑到一个格子填好胡会对后续格子造成影响。

//CSDN博客：https://blog.csdn.net/qq_40889820
#include<iostream>
#include<sstream>
#include<fstream>
#include<algorithm>
#include<string>
#include<cstring>
#include<iomanip>
#include<vector>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<map>
#define mem(a,b) memset(a,b,sizeof(a))
#define random(a,b) (rand()%(b-a+1)+a)
#define e 2.71828182
#define Pi 3.141592654
using namespace std;
struct node
{
	int x,y,z;//第x行，第y列，第z个方块 
	vector<int> able;//可填数字 
	friend bool operator < (node a,node b)
	{
	    if(a.able.size()!=b.able.size())    return a.able.size()<b.able.size();
	    else if(a.x!=b.x) return a.x<b.x;
	    else return a.y<b.y;
	    /*if(a.x!=b.x) return a.x<b.x;
	    else return a.y<b.y;*/
	}
}p[82];
char table[10][10];
int row[10][10],col[10][10],grid[10][10];
bool flag=false;
void dfs(int step,int sum)//填排好序的第step个空格，共有sum个空格 
{
	if(flag) return;//已找到一种解法 
	if(step>sum)
	{
		for(int i=1;i<=9;i++)
		cout<<table[i]+1;
		flag=true;
		return;
	}
	for(int j=0;j<p[step].able.size()&&!flag;j++)
	{
		int i=p[step].able[j];
		if(!row[p[step].x][i]&&!col[p[step].y][i]&&!grid[p[step].z][i])
		{
			table[p[step].x][p[step].y]=i+'0';
			row[p[step].x][i]=1;col[p[step].y][i]=1;grid[p[step].z][i]=1;
			dfs(step+1,sum);
			//回溯 
			table[p[step].x][p[step].y]='0';
			row[p[step].x][i]=0;col[p[step].y][i]=0;grid[p[step].z][i]=0;
		}
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	string str; 
	while(cin>>str)
	{
		if(str=="end") break;
		int count=0;
		mem(row,0);mem(col,0);mem(grid,0);
		for(int i=1;i<=9;i++)
			for(int j=1;j<=9;j++)
			{
				table[i][j]=str[count++];
				if(table[i][j]=='.') table[i][j]='0';
				row[i][table[i][j]-'0']=1;
				col[j][table[i][j]-'0']=1;
				int ord=(i-1)/3*3+(j-1)/3+1;
				grid[ord][table[i][j]-'0']=1;
			}
		
		count=0; 
		for(int i=1;i<=9;i++)
			for(int j=1;j<=9;j++)
			{
				if(table[i][j]!='0') continue;
				count++;
				p[count].able.clear();//血与泪的教训！！这个坑太深了 
				p[count].x=i,p[count].y=j;
				int ord=(i-1)/3*3+(j-1)/3+1;
				p[count].z=ord;
				for(int k=1;k<=9;k++)
				if(!row[i][k]&&!col[j][k]&&!grid[ord][k])
				p[count].able.push_back(k);
			}	

		sort(p+1,p+count+1);
		/*clock_t t;
		t=clock();*/
		dfs(1,count);
		/*t=clock()-t;
		cout<<"时间为："<<(((float)t)/CLOCKS_PER_SEC*1000)<<"ms\n";*/
		cout<<endl;
		flag=false; 
	}
}

当对node里<号的重载为

if(a.able.size()!=b.able.size())    return a.able.size()<b.able.size();
else if(a.x!=b.x) return a.x<b.x;
else return a.y<b.y;

时，即按可选数字数递增，若相同则按原顺序进行搜索，所需时间为：

当对node里<号的重载为

if(a.x!=b.x) return a.x<b.x;
else return a.y<b.y;

时，即按原顺序（数独中从上到下，从左到右）进行搜索，所需时间为：

很显然，这样做并不能满足要求。

后来改为动态查询，每次都查找可选数字最少的格子。但还是不幸超时

//CSDN博客：https://blog.csdn.net/qq_40889820
#include<iostream>
#include<sstream>
#include<fstream>
#include<algorithm>
#include<string>
#include<cstring>
#include<iomanip>
#include<vector>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<map>
#define mem(a,b) memset(a,b,sizeof(a))
#define random(a,b) (rand()%(b-a+1)+a)
#define e 2.71828182
#define Pi 3.141592654
#define P pair<int,int>
using namespace std;
char table[10][10];
int row[10],col[10],grid[10];//二进制记录行、列、方块的数字占用情况 
int figure[(1<<8)+1];//
int lowbit(int x)
{
	return x&(-x);
}
int z[10][10]={{0,0,0,0,0,0,0,0,0,0},
			   {0,1,1,1,2,2,2,3,3,3},
			   {0,1,1,1,2,2,2,3,3,3},
			   {0,1,1,1,2,2,2,3,3,3},
			   {0,4,4,4,5,5,5,6,6,6},
			   {0,4,4,4,5,5,5,6,6,6},
			   {0,4,4,4,5,5,5,6,6,6},
			   {0,7,7,7,8,8,8,9,9,9},
			   {0,7,7,7,8,8,8,9,9,9},
			   {0,7,7,7,8,8,8,9,9,9}};
int num(int n)//返回可填数字个数 
{
	int ans=0;
	for(int i=n;i;i-=lowbit(i))
	ans++;
	return ans;
}
P Min()//获得可填数字数最少的格子 
{
	int x=0,y=0,Min=1<<30;
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			if(table[i][j]!='0') continue;
			int status=row[i]&col[j]&grid[z[i][j]];
			if(!status) return P(-1,-1);//该格子无可填的数字 
			if(num(status)<Min) Min=num(status),x=i,y=j;
		}	
	}
	return P(x,y); 
}
bool dfs(int x,int y)//填第(x,y)格 
{
	int status=row[x]&col[y]&grid[z[x][y]];//statues的二进制记录了行、列、方块数字的占用情况
	for(int i=status;i>0;i-=lowbit(i))
	{
		int num=figure[lowbit(i)];//可填的数字 
		table[x][y]=num+'0';
		row[x] ^= lowbit(i);
		col[y] ^= lowbit(i);
		grid[z[x][y]] ^= lowbit(i);
		P p=Min();
		if(p.first==-1)
		{
			table[x][y]='0';
			row[x] ^= lowbit(i);
			col[y] ^= lowbit(i);
			grid[z[x][y]] ^= lowbit(i); 
			continue;
		}
		if(p.first==0) return true;
		if(dfs(p.first,p.second)) return true;
		table[x][y]='0';
		row[x] ^= lowbit(i);
		col[y] ^= lowbit(i);
		grid[z[x][y]] ^= lowbit(i); 
	} 
	return false;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	string str; 
	for(int i=0;i<9;i++) 
		figure[1<<i]=i+1;
	int init=(1<<9)-1;//二进制为111111111 
	while(cin>>str)
	{
		if(str=="end") break;
		int count=0;
		for(int i=1;i<=9;i++)
			row[i]=col[i]=grid[i]=init;	
		for(int i=1;i<=9;i++)
			for(int j=1;j<=9;j++)
			{
				table[i][j]=str[count++];
				if(table[i][j]=='.')
				{
					 table[i][j]='0';
					 continue;
				}
				row[i] ^= (1<<(table[i][j]-'0'-1));
				col[j] ^= (1<<(table[i][j]-'0'-1));
				grid[z[i][j]] ^= (1<<(table[i][j]-'0'-1));
				
			}
		/*clock_t t;
		t=clock();*/
		P p=Min();
		dfs(p.first,p.second);
		//t=clock()-t;
		for(int i=1;i<=9;i++)
		cout<<table[i]+1;
		//cout<<"时间为："<<(((float)t)/CLOCKS_PER_SEC*1000)<<"ms\n";
		cout<<endl;		
	}
}

然后将各个10进制数字代表能填数字的个数保存在数组里，终于是过了

显然还有更进一步的优化，留在POJ3076去探索吧。

AC代码：

//CSDN博客：https://blog.csdn.net/qq_40889820
#include<iostream>
#include<sstream>
#include<fstream>
#include<algorithm>
#include<string>
#include<cstring>
#include<iomanip>
#include<vector>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<map>
#define mem(a,b) memset(a,b,sizeof(a))
#define random(a,b) (rand()%(b-a+1)+a)
#define e 2.71828182
#define Pi 3.141592654
#define P pair<int,int>
using namespace std;
char table[10][10];
int row[10],col[10],grid[10];//二进制记录行、列、方块的数字占用情况 
int num[(1<<9)];//
int lowbit(int x)
{
	return x&(-x);
}
int z[10][10]={{0,0,0,0,0,0,0,0,0,0},
			   {0,1,1,1,2,2,2,3,3,3},
			   {0,1,1,1,2,2,2,3,3,3},
			   {0,1,1,1,2,2,2,3,3,3},
			   {0,4,4,4,5,5,5,6,6,6},
			   {0,4,4,4,5,5,5,6,6,6},
			   {0,4,4,4,5,5,5,6,6,6},
			   {0,7,7,7,8,8,8,9,9,9},
			   {0,7,7,7,8,8,8,9,9,9},
			   {0,7,7,7,8,8,8,9,9,9}};
int fun(int n)//返回可填数字个数 
{
	int ans=0;
	for(int i=n;i;i-=lowbit(i))
	ans++;
	return ans;
}
P Min()//获得可填数字数最少的格子 
{
	int x=0,y=0,Min=1<<30;
	for(int i=1;i<=9;i++)
	{
		for(int j=1;j<=9;j++)
		{
			if(table[i][j]!='0') continue;
			int status=row[i]&col[j]&grid[z[i][j]];
			if(!status) return P(-1,-1);//该格子无可填的数字 
			if(num[status]<Min) Min=num[status],x=i,y=j;
		}	
	}
	return P(x,y); 
}
bool dfs(int x,int y)//填第(x,y)格 
{
	int status=row[x]&col[y]&grid[z[x][y]];//statues的二进制记录了行、列、方块数字的占用情况
	for(int i=1;i<=9;i++)
	{
		if(status>>(i-1) & 1)//数字i未被占用
		{
			table[x][y]=i+'0';
			row[x] ^= (1<< i-1);
			col[y] ^= (1<< i-1);
			grid[z[x][y]] ^= (1<< i-1);
			P p=Min();
			if(p.first==-1)
			{
				table[x][y]='0';
				row[x] ^= (1<< i-1);
				col[y] ^= (1<< i-1);
				grid[z[x][y]] ^= (1<< i-1); 
				continue;
			}
			if(p.first==0) return true;
			if(dfs(p.first,p.second)) return true;
			table[x][y]='0';
			row[x] ^= (1<< i-1);
			col[y] ^= (1<< i-1);
			grid[z[x][y]] ^= (1<< i-1); 	
		} 
	}
	return false;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	string str; 
	for(int i=0;i<(1<<9);i++) 
		num[i]=fun(i);
	int init=(1<<9)-1;//二进制为111111111 
	while(cin>>str)
	{
		if(str=="end") break;
		int count=0;
		for(int i=1;i<=9;i++)
			row[i]=col[i]=grid[i]=init;	
		for(int i=1;i<=9;i++)
			for(int j=1;j<=9;j++)
			{
				table[i][j]=str[count++];
				if(table[i][j]=='.')
				{
					 table[i][j]='0';
					 continue;
				}
				row[i] ^= (1<<(table[i][j]-'0'-1));
				col[j] ^= (1<<(table[i][j]-'0'-1));
				grid[z[i][j]] ^= (1<<(table[i][j]-'0'-1));
			}
		/*clock_t t;
		t=clock();*/
		P p=Min();
		dfs(p.first,p.second);
		//t=clock()-t;
		for(int i=1;i<=9;i++)
		cout<<table[i]+1;
		//cout<<"时间为："<<(((float)t)/CLOCKS_PER_SEC*1000)<<"ms\n";
		cout<<endl;
		
	}
}

样例用时：（显然样例只能当样例看）

参考资料：
搜索_常规DFS_POJ3074_Sudoku
Sicily1317-Sudoku-位运算暴搜
二进制-高效位运算

就算过了一载春秋
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C - Brackets（区间dp）
默的博客
08-03 636
Description Input The input test file will contain multiple test cases. Each input test case consists of a single line containing only the characters (, ), [, and ]; each input test will have length ...
“论解不了数独所以选择做个数独游戏这件事”
Foulove的博客
06-22 944
有一天，小明同学在津津有味的逛力扣网站的时候，惊喜的发现了一个看似非常好下手的题目（万恶之源 T T）。 于是小明同学又津津有味的写了解题思路。像往常一样打开了Unity准备开始做。。（画UI）。。（写脚本，使用不停产生1~9的随机数的办法，往一个一个空填，来达到解数独的目的）。。。（挂组件）好耶。测试环节：1个空测试（没问题）2个空填随机数（没问题）81个空（没反应）也许Untiy前端程序员最怕的不是满屏的报错，而是代码没问题，引擎设置也没问题，但是跑不起来。（核心算法逻辑出错 T T）于是乎，在某一次
week12-作业
qq_45757204的博客
05-28 330
文章目录空间bfs题意输入输出样例输入样例输出思路总结代码最长括号匹配题意输入输出样例输入样例输出思路总结反思代码东东扫楼题意输入输出样例输入样例输出思路总结反思代码状态压缩-分配作业时间题意输入输出样例输入样例输出思路总结反思代码 空间bfs 题意 zjm被困在一个三维的空间中,现在要寻找最短路径逃生！ 空间由立方体单位构成。 zjm每次向上下前后左右移动一个单位需要一分钟，且zjm不能对角线移动。 空间的四周封闭。zjm的目标是走到空间的出口。 是否存在逃出生天的可能性？如果存在，则需要多少时间？ 输入
week12作业
ych7777777的博客
05-18 194
C - 必做题 - 3 东东每个学期都会去寝室接受扫楼的任务，并清点每个寝室的人数。 每个寝室里面有ai个人(1<=i<=n)。从第i到第j个宿舍一共有sum(i,j)=a[i]+…+a[j]个人 这让宿管阿姨非常开心，并且让东东扫楼m次，每一次数第i到第j个宿舍sum(i,j) 问题是要找到sum(i1, j1) + … + sum(im,jm)的最大值。且ix <= iy <=jx和ix <= jy <=jx的情况是不被允许的。也就是说m段都不能相交。 注：1 ≤ i
poj 3074 Sudoku
u012647218的专栏
11-30 869
Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 7613   Accepted: 2696 Description In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3 × 3
POJ1014-Dividing【DFS】【多重背包+二进制优化】
08-04
在给出的文件列表中，“POJ1014-Dividing【多重背包+二进制优化】.cpp”和“POJ1014-Dividing【DFS】.cpp”很可能是两份不同的C++代码实现，分别展示了如何结合多重背包和二进制优化以及如何利用DFS来解决问题。...
POJ2676-Sudoku
07-31
标题“POJ2676-Sudoku”指向的是北京大学在线编程平台POJ上的一道题目，编号为2676，题目内容与经典的数独游戏有关。解题报告和AC（Accepted）代码是该问题解决方案的组成部分，通常包括对问题的理解、算法设计、...
poj 3435 Sudoku Checker.md
11-17
poj 3435 Sudoku Checker.md
POJ 2676 代码 搜索数独答案
09-15
简单搜索题 数独 答案 POJ 2676 也可以没事玩玩数独。
POJ中缀-后缀-四则运算
12-09
人们熟悉的四则运算表达式称为中缀表达式，例如(23+34*45/(5+6+7))。在程序设计语言中，可以利用堆栈的方法把中缀表达式转换成保值的后缀表达式（又称逆波兰表示法），并最终变为计算机可以直接执行的指令，得到...
数独的二进制解法
02-05
二进制的PYTHON 数独 算法
【POJ 3074】Sudoku【剪枝】
Gene_I must wait for the sunrise
08-14 340
题意： 一个数独问题，类似的还有POJ2676 = POJ 2918 < POJ3074 < POJ3076，按难度排序。 解法： 大部分的题解都是用舞蹈链写的，但是实在不想学这个不太常用的算法，就一直尝试剪枝。成功剪了n小时...... 两个剪枝操作： 1.每次寻找可以填的数字最少的那个格子 2.每次更新的时候，顺便寻找...
poj 3074
weixin_33976072的博客
08-30 92
题意：解数独 分析： 完整的数独有四个充要条件： 1.每个格子都有填数字 2.每列都有1~9中的每个数字 3.每行都有1~9中的每个数字 4.每个9宫格都有1~9中的每个数字 可以转化成精确覆盖问题。每行表示一个格子的一种填法，1~81列表示这个格子的位置，82~162列表示这是哪一行的什么数字，163~243列表示这是哪一列的什么数字，244~324列表示这是哪一个九宫格里的什么数...
Unity2*2数独游戏
qq_43459460的博客
07-17 1655
Unity2*2数独游戏 第一次写，希望大神们多多指点！ using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class SudokuItem : MonoBehaviour { public bool isNormal = false; //固定数字 不需要检测期望值 public int valu
poj 3074(数独 Dancing Link精确覆盖)
志当存高远
09-22 3020
Sudoku Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 5830   Accepted: 1839 Description In t
POJ 3074 Sudoku
忘梦心的博客
11-15 657
Sudoku Time Limit: 1000MS Memory Limit: 65536K Description In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3 × 3 subgrids. For example, . 2 7 3 8 . . 1 . . 1 . . . 6 7 3 ...
POJ - 3074（DancingLink）（数独）
偷吃了老鼠的土豆
03-30 523
题目：POJ - 3074 In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3 × 3 subgrids. For example, . 2 7 3 8 . . 1 . . 1 . . . 6 7 ...
【POJ 3074】 Sudoku
07-04 158
【题目链接】 http://poj.org/problem?id=3074 【算法】 将数独问题转化为精确覆盖问题，用Dancing Links求解 转化方法如下 ： 我们知道，在一个数独中 ： 1.每个格子填且只填一个数 2.每一行填1-9这...
【poj3074】【DLX】sudoku
anantheparty的博客
10-10 406
就是数独 Sudoku Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 9617 Accepted: 3473 Description In the game of Sudoku, you are given a large 9 × 9 grid divided into
poj 1256c语言dfs
最新发布
08-18
POJ 1256 是一个经典的搜索问题，可以使用深度优先搜索（DFS）来解决。这道题的要求是给定一个字符串，按照字典序输出这个字符串的所有排列。 下面是用C语言实现的DFS代码： ```c #include #include void swap...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值