wikioi p1174 靶形数独

最新推荐文章于 2023-05-02 12:55:04 发布
最新推荐文章于 2023-05-02 12:55:04 发布
阅读量759 收藏
点赞数
分类专栏： wikioi天梯 noip普及组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011797284/article/details/10749179
版权

这题我原先是下标程的，先贴标程代码，待会我再贴我自己的代码。

pascal 不喜勿喷~

type ctype=array[1..9,1..9,1..9]of boolean;

     nctype=array[1..9,1..9]of longint;

const w:array[1..9,1..9]of integer=((6,6,6,6,6 ,6,6,6,6),

                                         (6,7,7,7,7 ,7,7,7,6),

                                         (6,7,8,8,8 ,8,8,7,6),

                                         (6,7,8,9,9 ,9,8,7,6),

                                         (6,7,8,9,10,9,8,7,6),

                                         (6,7,8,9,9 ,9,8,7,6),

                                         (6,7,8,8,8 ,8,8,7,6),

                                         (6,7,7,7,7 ,7,7,7,6),

                                         (6,6,6,6,6 ,6,6,6,6));

      vb:array[1..9,1..9]of integer=((1,1,1,2,2,2,3,3,3),

                                       (1,1,1,2,2,2,3,3,3),

                                       (1,1,1,2,2,2,3,3,3),

                                       (4,4,4,5,5,5,6,6,6),

                                       (4,4,4,5,5,5,6,6,6),

                                       (4,4,4,5,5,5,6,6,6),

                                       (7,7,7,8,8,8,9,9,9),

                                       (7,7,7,8,8,8,9,9,9),

                                       (7,7,7,8,8,8,9,9,9));

var v:array[1..82]of boolean;

    k:array[0..82,1..2]of longint;

    c:ctype;nc:nctype;

    depth,ans:longint;

    flag:boolean;

procedure init;

var i,j,x,m,n:longint;

begin

depth:=0;ans:=0;flag:=false;

for i:=1 to 9 do for j:=1 to 9 do nc[i,j]:=9;

fillchar(c,sizeof(c),true);fillchar(v,sizeof(v),false);

for i:=1 to 9 do

begin

   for j:=1 to 9 do

    begin

      read(x);

     if x>0 then begin

                    ans:=ans+x*w[i,j];

                    nc[i,j]:=0;

                    for m:=1 to 9 do

                     for n:=1 to 9 do

                      begin

                       if nc[m,n]=0 then continue;

                       if (c[m,n,x])and((m=i)or(n=j)or(vb[i,j]=vb[m,n]))

                        then begin c[m,n,x]:=false;dec(nc[m,n]);end;

                      end;

                   end

              else begin inc(depth);k[depth,1]:=i;k[depth,2]:=j;end;

    end;

   readln;

end;

end;


procedure outit;

begin

if flag then writeln(ans) else writeln('-1');

end;


procedure dfs(d,max:longint;c:ctype;nc:nctype);

var i,j,min,m,x,y:longint;c1:ctype;nc1:nctype;

begin

if d=depth+1 then begin if max>ans then ans:=max;flag:=true;exit; end;


min:=10;

for i:=1 to depth do if not (v[i])and(nc[k[i,1],k[i,2]]<min) then begin min:=nc[k[i,1],k[i,2]];m:=i;end;


x:=k[m,1];y:=k[m,2];v[m]:=true;

for i:=1 to 9 do if c[x,y,i] then

   begin

     c1:=c;nc1:=nc;

     for j:=1 to depth do

      begin

       if (not v[j])and c1[k[j,1],k[j,2],i]and((k[j,1]=x)or(k[j,2]=y)or(vb[k[j,1],k[j,2]]=vb[x,y]))

        then begin c1[k[j,1],k[j,2],i]:=false;dec(nc1[k[j,1],k[j,2]]);end;

       if nc1[k[j,1],k[j,2]]=0 then break;

      end;

     dfs(d+1,max+i*w[x,y],c1,nc1);

   end;

v[m]:=false;

end;


begin                                 {(input,'d:in.txt');(input);(,'d:out.txt');(output);}

init;
dfs(1,ans,c,nc);

outit;                                {close(input);close(output);}

end.


 然后我们就可以思考一个问题。数独的规则。

每行 每列 每个小数独都不能有相同的数字。

所以我们分别用Line list和sud记录重复。

这样搜索效率会增加。

但是bfs存在一个问题。就是只能得40分。

因为会超空间。

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<algorithm>
#include<queue>
#include<iostream>
#include<memory.h>
using namespace std;
const int MAX_N = 9;
const int MAX_M = 10;
int score[MAX_N][MAX_N]={
	          {6,6,6,6,6,6,6,6,6},
	          {6,7,7,7,7,7,7,7,6},
	          {6,7,8,8,8,8,8,7,6},
	          {6,7,8,9,9,9,8,7,6},
	          {6,7,8,9,10,9,8,7,6},
	          {6,7,8,9,9,9,8,7,6},
	          {6,7,8,8,8,8,8,7,6},
	          {6,7,7,7,7,7,7,7,6},
	          {6,6,6,6,6,6,6,6,6},
			  }; //靶型得分 
int ans = -1; //表示答案 
struct node
{
	int sudoku[MAX_M][MAX_N];
	bool line[MAX_M][MAX_M]; //行 
	bool list[MAX_M][MAX_M]; //列
	bool sud[MAX_M][MAX_M];  //数独 
	int x,y;
}head,next;  //靶型数独 
queue<struct node> Q;
int solve_score(struct node R) //计算总得分 
{
	int i,j;
	int tmp = 0;
	for (i=0;i<MAX_N;i++)
	for (j=0;j<MAX_N;j++)
	tmp+=score[i][j]*R.sudoku[i][j];
	return tmp ;
}
int which(int x,int y) //寻找该单元格在第几个小数独中 
{
	if (x>=0&&x<=2)
	{
		if (y>=0&&y<=2) return 1;
		if (y>=3&&y<=5) return 2;
		if (y>=6&&y<=8) return 3;
	}
	if (x>=3&&x<=5)
	{
		if (y>=0&&y<=2) return 4;
		if (y>=3&&y<=5) return 5;
		if (y>=6&&y<=8) return 6;
	}
	if (x>=6&&x<=8)
	{
		if (y>=0&&y<=2) return 7;
		if (y>=3&&y<=5) return 8;
		if (y>=6&&y<=8) return 9;
	}
}
int putG(struct node R)
{
	int i,j;
	for (i=0;i<MAX_N;i++)
	{
		for (j=0;j<MAX_N;j++)
		printf("%d ",R.sudoku[i][j]);
		printf("\n");
	}
	printf("\n");
}
int init() //初始化 
{
	memset(head.line,false,sizeof(head.line));
	memset(head.list,false,sizeof(head.list));
	memset(head.sud,false,sizeof(head.sud));
	int i ,j ;
	for (i=0;i<MAX_N;i++)
	for (j=0;j<MAX_N;j++)
	scanf("%d",&head.sudoku[i][j]);
	for (i=0;i<MAX_N;i++)
	for (j=0;j<MAX_N;j++)
	if (head.sudoku[i][j])
	{
		head.line[i][head.sudoku[i][j]]=true;
		head.list[j][head.sudoku[i][j]]=true;
		head.sud[which(i,j)][head.sudoku[i][j]]=true;
	}
	head.x = head.y=0;
	Q.push(head);
}
bool Cash(struct node R,int x,int y) //检查是否发生冲突 
{
	int i=R.sudoku[x][y];
	if (R.line[x][i]) return false;
	if (R.list[y][i]) return false;
	if (R.sud[which(x,y)][i])  return false;
	return true;
}
int work()
{
	int i;
	int x,y;
	int nx,ny;
	while(!Q.empty())
	{
		head=Q.front();
		Q.pop();
		x=head.x;
		y=head.y;
		//putG(head);
		//for (int v=1;v<=50000000;v++);
		if (x==MAX_N)
		{
			ans=max(solve_score(head),ans);
			continue;
		}
		if (y==MAX_N-1) nx=x+1,ny=0;
		else nx=x,ny=y+1;
		if (head.sudoku[x][y])
		{
			next=head;
			next.x=nx;
			next.y=ny;
			Q.push(next);
		}
		else
		for (i=1;i<=MAX_N;i++)
		{
			next=head;
			next.x=nx;
			next.y=ny;
			next.sudoku[x][y]=i;
			if (Cash(next,x,y))
			{
				next.line[x][i] = true;
				next.list[y][i] = true;
				next.sud[which(x,y)][i] =true;
				Q.push(next);
			}
		}
	}
}
int put()
{
	printf("%d",ans);
} 
int main()
{
	init();
	work();
	//putG(head);
	put();
	//while(1);
	return 0;
}


 

然后我们可以将他改成dfs

这样就不会超空间了。

不过任然存在一个问题，就是超时。

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<memory.h>
using namespace std;
const int MAX_N = 9;
const int MAX_M = 10;
int score[MAX_N][MAX_N]={
	          {6,6,6,6,6,6,6,6,6},
	          {6,7,7,7,7,7,7,7,6},
	          {6,7,8,8,8,8,8,7,6},
	          {6,7,8,9,9,9,8,7,6},
	          {6,7,8,9,10,9,8,7,6},
	          {6,7,8,9,9,9,8,7,6},
	          {6,7,8,8,8,8,8,7,6},
	          {6,7,7,7,7,7,7,7,6},
	          {6,6,6,6,6,6,6,6,6},
			  }; //靶型得分 
int ans = -1; //表示答案  
int sudoku[MAX_M][MAX_N];//靶型数独 
bool line[MAX_M][MAX_M]; //行 
bool list[MAX_M][MAX_M]; //列
bool sud[MAX_M][MAX_M];  //数独
int which(int x,int y) //寻找该单元格在第几个小数独中 
{
	if (x>=0&&x<=2)
	{
		if (y>=0&&y<=2) return 1;
		if (y>=3&&y<=5) return 2;
		if (y>=6&&y<=8) return 3;
	}
	if (x>=3&&x<=5)
	{
		if (y>=0&&y<=2) return 4;
		if (y>=3&&y<=5) return 5;
		if (y>=6&&y<=8) return 6;
	}
	if (x>=6&&x<=8)
	{
		if (y>=0&&y<=2) return 7;
		if (y>=3&&y<=5) return 8;
		if (y>=6&&y<=8) return 9;
	}
}
int init() //初始化 
{
	memset(line,false,sizeof(line));
	memset(list,false,sizeof(list));
	memset(sud,false,sizeof(sud));
	int i ,j ;
	for (i=0;i<MAX_N;i++)
	for (j=0;j<MAX_N;j++)
	scanf("%d",&sudoku[i][j]);
	for (i=0;i<MAX_N;i++)
	for (j=0;j<MAX_N;j++)
	if (sudoku[i][j])
	{
		line[i][sudoku[i][j]]=true;
		list[j][sudoku[i][j]]=true;
		sud[which(i,j)][sudoku[i][j]]=true;
	}
}
bool Cash(int x,int y,int i) //检查是否发生冲突 
{
	if (line[x][i]) return false;
	if (list[y][i]) return false;
	if (sud[which(x,y)][i])  return false;
	return true;
}
int dfs(int x,int y,int tmp)
{
	if (x==MAX_N)
	{
		ans=max(tmp,ans);
		return 0;
	}
	int i;
	int nx,ny;
	if (y==MAX_N-1) nx=x+1,ny=0;
	else nx=x,ny=y+1;
	if (sudoku[x][y])
	dfs(nx,ny,tmp+sudoku[x][y]*score[x][y]);
	else
	for (i=1;i<=MAX_N;i++)
	if (Cash(x,y,i))
	{
		sudoku[x][y]=i;
		line[x][i] = true;
		list[y][i] = true;
		sud[which(x,y)][i] = true;
		dfs(nx,ny,tmp+i*score[x][y]);
		line[x][i] = false;
		list[y][i] = false;
		sud[which(x,y)][i] = false;
        sudoku[x][y]=0;//这句话必不可少
	}
}
int put()
{
	printf("%d",ans);
} 
int main()
{
	init();
	dfs(0,0,0);
	put();
	return 0;
}


 

根据启发式搜索的思想，运用估价函数可以通过改变搜索的顺序增加速度。

但是这题数据比较奇葩，如果倒过来搜，也就是从最后一列最后一行开始搜索的话速度会快很多。

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<memory.h>
using namespace std;
const int MAX_N = 9;
const int MAX_M = 10;
int score[MAX_N][MAX_N]={
	          {6,6,6,6,6,6,6,6,6},
	          {6,7,7,7,7,7,7,7,6},
	          {6,7,8,8,8,8,8,7,6},
	          {6,7,8,9,9,9,8,7,6},
	          {6,7,8,9,10,9,8,7,6},
	          {6,7,8,9,9,9,8,7,6},
	          {6,7,8,8,8,8,8,7,6},
	          {6,7,7,7,7,7,7,7,6},
	          {6,6,6,6,6,6,6,6,6},
			  }; //靶型得分 
int ans = -1; //表示答案  
int sudoku[MAX_M][MAX_N];//靶型数独 
bool line[MAX_M][MAX_M]; //行 
bool list[MAX_M][MAX_M]; //列
bool sud[MAX_M][MAX_M];  //数独
int which(int x,int y) //寻找该单元格在第几个小数独中 
{
	if (x>=0&&x<=2)
	{
		if (y>=0&&y<=2) return 1;
		if (y>=3&&y<=5) return 2;
		if (y>=6&&y<=8) return 3;
	}
	if (x>=3&&x<=5)
	{
		if (y>=0&&y<=2) return 4;
		if (y>=3&&y<=5) return 5;
		if (y>=6&&y<=8) return 6;
	}
	if (x>=6&&x<=8)
	{
		if (y>=0&&y<=2) return 7;
		if (y>=3&&y<=5) return 8;
		if (y>=6&&y<=8) return 9;
	}
}
int init() //初始化 
{
	memset(line,false,sizeof(line));
	memset(list,false,sizeof(list));
	memset(sud,false,sizeof(sud));
	int i ,j ;
	for (i=0;i<MAX_N;i++)
	for (j=0;j<MAX_N;j++)
	scanf("%d",&sudoku[i][j]);
	for (i=0;i<MAX_N;i++)
	for (j=0;j<MAX_N;j++)
	if (sudoku[i][j])
	{
		line[i][sudoku[i][j]]=true;
		list[j][sudoku[i][j]]=true;
		sud[which(i,j)][sudoku[i][j]]=true;
	}
}
bool Cash(int x,int y,int i) //检查是否发生冲突 
{
	if (line[x][i]) return false;
	if (list[y][i]) return false;
	if (sud[which(x,y)][i])  return false;
	return true;
}
int dfs(int x,int y,int tmp)
{
	if (x==MAX_N)
	{
		ans=max(tmp,ans);
		return 0;
	}
	int i;
	int nx,ny;
	if (y==MAX_N-1) nx=x+1,ny=0;
	else nx=x,ny=y+1;
	if (sudoku[x][y])
	dfs(nx,ny,tmp+sudoku[x][y]*score[x][y]);
	else
	for (i=1;i<=MAX_N;i++)
	if (Cash(x,y,i))
	{
		sudoku[x][y]=i;
		line[x][i] = true;
		list[y][i] = true;
		sud[which(x,y)][i] = true;
		dfs(nx,ny,tmp+i*score[x][y]);
		line[x][i] = false;
		list[y][i] = false;
		sud[which(x,y)][i] = false;
                sudoku[x][y]=0;//这句话必不可少
	}
}
int put()
{
	printf("%d",ans);
} 
int main()
{
	init();
	dfs(0,0,0);
	put();
	return 0;
}


 

另外，网上说dl的速度非常快。但是不会写啊。

启发式搜索其实还是不难的。

但是估价函数的设计还比较麻烦。

YeasonWu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数独代码 数独代码 数独代码
01-20
数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码数独代码...
靶形数独
热门推荐
水蛙菌
02-28 1万+
小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z博士请教，Z博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。 靶形数独的方格同普通数独一样，在9格宽×9格高的大九宫格中有9个3格宽×3格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利用逻辑推理，在其他的空格上填入1到9的数字。每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现。但靶形数
靶形数独（dfs）
joseph0530的博客
05-02 77
祝大家5.1玩的快乐！！！
洛谷 P1074 靶形数独 [搜索，水题]
ryougi_的博客
09-07 163
展开 题目描述 小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向 Z 博士请教，Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。 靶形数独的方格同普通数独一样，在 99 格宽×99 格高的大九宫格中有9 9 个 33 格宽×33 格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有...
winform数独C#的数独游戏
12-10
winform数独C#的数独游戏 本程序基于.netframework使用C#语言开发，实现功能： 1、各个难度随机出题(New)； 2、数独解题提示(Compute)； 3、输入的合法性校验； 思路分享 说一下开发步骤及思路： 1、验证合法性...
C++实现数独游戏的设计
最新发布
10-09
数独是一种基于逻辑推理的数字填充游戏，其目标是填充一个9×9的网格，使得每一行、每一列以及每个小的3×3宫格内的数字从1到9都出现且仅出现一次。在C++中实现数独游戏，我们可以利用二维数组来模拟数独盘面，并...
数独问题,数独问题的解题思路,matlab
09-10
数独是一种广受欢迎的逻辑推理游戏，它基于一个9×9的网格，被分为9个3×3的小九宫格。每个小九宫格、每一行、每一列都必须填入1到9的数字，且每个数字在每个区域内只能出现一次。在数独问题的解题过程中，MATLAB是...
基于Android实现数独游戏
08-28
基于Android实现数独游戏 Android平台上的数独游戏开发是一项非常有趣的项目，对于Android应用开发者来说是一个非常好的实践机会。下面我们将详细介绍基于Android实现数独游戏的相关知识点。 1. Android游戏开发...
靶形数独（dfs+剪枝）
Loi_feather的博客
10-13 860
题目描述 Description 小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他 们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z 博士请教， Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。 靶形数独的方格同普通数独一样，在 9 格宽×9 格高的大九宫格中有9 个3 格宽×3 格 高的小九宫格（用粗黑色线隔开的）。在这
noip2009第4题 靶形数独 自己的血汗 WA:90版
Free-Man
07-06 855
<br /> 还记得当年看到这题的时候就晕了，想起来可以说去年根本谈不上会算法。现在再做这题，写个暴力，80分......想在优化，琢磨了好几天，自己也就升到了90分。标准做法听说是DancingLinks题解：http://www.cppblog.com/zxytim/archive/2009/11/30/102302.aspx还没看呢，等下跑完步回来研究。先发我自己的研究成果吧。题目描述：<br />小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通
靶形数独（恶心啊）
qq_40716114的博客
05-14 443
这道题。。重点是数独的性质（原谅我第一次做没注意）数独：每个区间，每行，每列数字都不能重复然后。。为了方便计算，先打三个表：#include&lt;bits/stdc++.h&gt; using namespace std; struct node { int l,r; }b[20]={};//这个。。好像没什么用，最开始加的。。后来发现用不上 int a[20][20]={},d[20][20...
[WIKIOI 1174]靶形数独(深度优先搜索)
梦幻神隐的幻想乡
05-18 845
题目描述 Description 小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他 们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z 博士请教， Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。 靶形数独的方格同普通数独一样，在 9 格宽×9 格高的大九宫格中有9 个3 格宽×3 格 高的小九宫格（用粗黑色线隔开
NOIP 2009 靶形数独（DLX）
weixin_30532987的博客
09-18 184
小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z 博士请教，Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。靶形数独的方格同普通数独一样，在 9 格宽×9 格高的大九宫格中有9 个3 格宽×3 格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利...
洛谷P1074 靶形数独（跳舞链）
weixin_34179762的博客
09-18 103
传送门 坑着，等联赛之后再填（联赛挂了就不填了233） 1 //minamoto 2 #include<iostream> 3 #include<cstdio> 4 #include<cstring> 5 using namespace std; 6 #define getc() (p1==p2&&...
NOIP2009 靶形数独
布拉克王国
04-02 395
拿到这道题就直接想到了搜索，我们只需要在输入时保存每一行已经用了的数字和每一列已经用了的的数字，并且保存下每一个3×3的小格里已经用了的数字，然后搜索时避免这样的情况即可，下面是代码： #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #inc...
MATLAB实现数独求解算法
"这篇资源是关于使用MATLAB解决数独问题的代码实现。它包含两个主要函数：`sudoku` 和 `find_variable`。`sudoku` 函数用于求解数独，而`find_variable`函数则用于找到数独矩阵中可填入数字最少的位置及其可能的数字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值