您的位置：360文档中心› C++源程序解 游戏数字九宫格

C++源程序解 游戏数字九宫格

合集下载

C++解决九宫算法

C++解决九宫算法
b[c[k-1]]=0;
print();
}
b[c[k]]=i; /*将中间的数字i移入正确的位置*/
b[4]=0; /*空出中间的空格*/
print();
break;
}
else if(b[c[j]]==i) break; /*数字i在正确的位置*/
system("pause");
return 0;
}
/*顺序输入矩阵外边的8个数字,矩阵元素的顺序由指针数组的元素a[i]控制*/
printf("The sorting process is as felow:\n");
print();
for(t=-1,j=0;j<8&&t==-1;j++) /*确定数字1所在的位置*/
if(b[a[j]]==1) t=j; /*t:记录数字1所在的位置*/
printf("Please input rank and column of matrix:");
scanf("%d%d",&m,&n);
printf("Please input %d elements of the matrix:\n",m*n);
for(i=0;i<m;i++)
for(j=0;j<n;j++)
if(b[c[j]]==i&&j!=i-1) /*若i不在正确的位置*/
{
b[4]=i; /*将i移到中心的空格中*/
b[c[j]]=0;print(); /*空出i原来所在的位置,输出*/
for(k=j;k!=i-1;k--) /*将空格以前到i的正确位置之间的数字依次向后移动一格*/

C#简单实现九宫数独算法

C#简单实现九宫数独算法

{
if ((t != i || u != j) && pu[t, u] == n)
return false;
}
}
for (int k = 0; k < 9; k++)
{
pu[i, j]++;//当前格子进行尝试所有解
if (IsValid(i, j))
GetAnswer(n + 1);//验证通过，就继续下一个
{0,0,0,0,6,0,0,8,2},
{3,0,0,8,0,2,7,0,4},
{1,7,4,0,3,0,0,2,0},
{2,8,0,5,0,0,0,3,0},
{0,1,0,3,0,0,2,0,0},
return true;
}
/// <summary>
/// 显示函数
/// </summary>
ቤተ መጻሕፍቲ ባይዱtatic void Show()
{
for (var i = 0; i < 9; i++)
}
pu[i, j] = 0; //如果上面的单元无解，还原，就回溯
return ;
}
}
}
本文来自CSDN博客，转载请标明出处：/canhui87/archive/2009/12/13/4997969.aspx
/// <summary>
/// 使用回溯算法求解
/// </summary>
/// <param name="n"></param>

C语言数独游戏的求解方法

C语言数独游戏的求解方法

C语⾔数独游戏的求解⽅法数独游戏的解法：先将数独分为九个格⼦，⽤⼀个数组将每个⼩九宫格的候选数存放下来，将候选数挨个放进数独⾥的空位，如果这⼀⾏和这⼀列都没有这个数字，继续放⼊下⼀个，如果不能放⼊的话就回到上⼀步继续尝试，直到成功求出数独的解为⽌；⽐如这个数独第⼀个九宫格的候选数就有1,2,7,8,9，我们需要从1开始放⼊第⼀个格⼦挨个尝试直到8的时候发现剩下的两个格⼦都不能放⼊这个时候我们就要撤回上⼀个插⼊的7，发现8仍然不能放⼊，就继续撤回2，发现8可以放⼊，就将8放⼊3号位置，然后将9插⼊这个时候我们发现2不能放⼊剩下的两格，我们就继续撤回到1插⼊的时候，将2放⼊1号位置，然后挨个放⼊剩下的数循环这⼀过程，直到数独求出解为⽌；这个⽅法⽐较容易想到，操作也⽐较容易实现下⾯是代码代码⼤多数都写了备注便于理解题⽬需要的1000道题放在下⾯了，将这1000个txt⽂件拷到EXE⽂件同⼀⽬录就可以了题⽬链接：#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAX 81typedef struct asd{int x;//待测试的值的x坐标int y;//待测试的值的y坐标int p;//待测试的值的位置（1道9代表在九宫格⾥的位置）int n;//待测试的值}A;A zhan[MAX];//存放每个放进题⽬数组测试的数据void kongque(int queshi[9][9],int aa[9][9]);//函数将候选数数组⾥去除题⽬中有的数字void shuchu(int aa[9][9],int q);//输出整个数组到⽂件中int end(int aa[9][9]); //判断是否结束int next(int queshi[9][9],int m,int n,int *x,int *y,int aa[9][9]);//查找下⼀个应该放进九宫格测试的数据int chazhao(int aa[9][9],int m,int n,int num);//查找同⼀⾏同⼀列是否有相同的值int nfrz(int queshi[9][9],int aa[9][9],int m,int n,int *p);//判断是否满⾜⼊栈条件（就是当前值是否可以插⼊九宫格）int rz(int *t,int x,int y,int p,int num);//⼊栈操作int cz(int *t,int *x,int *y,int *p,int *num);//出栈操作void aaaa(char aa[10],int a);//计算题⽬⽂件的⽂件名void bbbb(char aa[10],int a);//计算答案⽂件的⽂件名int main(){int i;//记录该调⽤哪道题for(i=0;i<1000;i++){int aa[9][9],j,k;//aa数组存放的是题⽬数独int queshi[9][9];//存放的是每个九宫格的待选数int end=0;//判断循环结束条件int h=0,l=0,p=1;//h是候选数的⾏坐标，l是候选数的列坐标，p代表当前测试数属于⼩九宫格的位置int t=-1;//栈的长度int s=0,num;FILE *u;char qwe[10];for(j=0;j<9;j++)//将数组置为每⾏都是（1到9）for(k=0;k<9;k++)queshi[j][k]=k+1;aaaa(qwe,i);u=fopen(qwe,"r");for(j=0;j<9;j++){//读⼊题⽬for(k=0;k<9;k++){fscanf(u,"%d",&aa[j][k]);}}fclose(u);memset(zhan,0,sizeof(zhan));//将栈的数据全部置为0kongque(queshi,aa);while(end!=1){//开始求解s=next(queshi,h,l,&h,&l,aa);//查找下⼀个应该放进九宫格测试的数据 if(s==0){//如果找到则进⼊下⼀层s=nfrz(queshi,aa,h,l,&p);//判断能否插⼊数独⾥if(s==0){//如果可以则将插⼊的数据存放到栈⾥（⼊栈）s=rz(&t,h,l,p,queshi[h][l]);if(s==0){ //如果⼊栈成功则写⼊数独aa[h/3*3+(p-1)/3][h%3*3+(p-1)%3]=queshi[h][l];l++;//待选数跳到下⼀个p=1;//重新从第⼀个⼩格⼦开始判断是否插⼊}else{end=1;//循环结束}}else{s=cz(&t,&h,&l,&p,&num);if(s==0){//如果出栈成功则擦除插⼊的数据aa[h/3*3+(p-1)/3][h%3*3+(p-1)%3]=0;p++;}elseend=1;}}else if(s==-1){shuchu(aa,i);//输出求解完毕的数独end=1;}else{printf("发⽣未知错误");end=1;}}}return 0;}//函数将候选数数组⾥去除题⽬中有的数字void kongque(int queshi[9][9],int aa[9][9]){int i,j,x,y;for(i=0;i<j;i++){for(j=0;j<9;j++){if(aa[i][j]){x=i/3*3+j/3;//数独数组和候选数数组的坐标转换y=aa[i][j]-1;queshi[x][y]=0;}}}}//输出整个数组到⽂件中void shuchu(int aa[9][9],int q){int i,j;FILE *p;char qq[10];bbbb(qq,q);p=fopen(qq,"w");for(i=0;i<9;i++){for(j=0;j<9;j++){fprintf(p,"%d ",aa[i][j]);}fprintf(p,"\n");}fclose(p);}//判断是否结束int end(int aa[9][9]){int i,j,num=0;for(i=0;i<9;i++){num=0;for(j=0;j<0;j++){num+=aa[i][j];//检查每⼀⾏是否为1到9}if(num!=45)return -1;}for(j=0;j<9;j++){//检查每⼀列是否为1到9num=0;for(i=0;i<9;i++){num+=aa[i][j];}if(num!=45)return -1;}return 0;}//查找下⼀个应该放进九宫格测试的数据int next(int queshi[9][9],int m,int n,int *x,int *y,int aa[9][9]){ int qqq=0;if(n>8){//如果当前⼩九宫格填写完毕则进⼊下⼀个九宫格n=0;m++;}if(m>8){qqq=end(aa);//判断是否结束if(qqq!=0)return -1;elsereturn 1;}while(queshi[m][n]==0){if(n<8)n++;else{n=0;m++;if(m>8){qqq=end(aa);if(qqq!=0)return -1;elsereturn 1;}}}*x=m;//重新获取测试的值的x坐标和y坐标*y=n;return 0;}//查找同⼀⾏同⼀列是否有相同的值int chazhao(int aa[9][9],int m,int n,int num){int i;for(i=0;i<9;i++){//查找⾏if(aa[m][i]==num)return -1;}for(i=0;i<9;i++){//查找列if(aa[i][n]==num)return -1;}return 0;}//判断是否满⾜⼊栈条件（就是当前值是否可以插⼊九宫格）int nfrz(int queshi[9][9],int aa[9][9],int m,int n,int *p){int s=*p;int i,t1,t2,num;num=queshi[m][n];for(i=s;i<10;i++){t1=(m/3)*3+(s-1)/3;t2=(m%3)*3+(s-1)%3;if(aa[t1][t2]!=0){s++;continue;}if(chazhao(aa,t1,t2,num)!=0){s++;continue;}else{*p=s;return 0;}}return -1;}//⼊栈操作int rz(int *t,int x,int y,int p,int num){if(*t>=MAX){return -1;}else{(*t)++;zhan[*t].x=x;zhan[*t].y=y;zhan[*t].p=p;zhan[*t].n=num;return 0;}}//出栈操作int cz(int *t,int *x,int *y,int *p,int *num){ if(*t==-1){return -1;}else{*x=zhan[*t].x;*y=zhan[*t].y;*p=zhan[*t].p;*num=zhan[*t].n;(*t)--;return 0;}}//计算题⽬⽂件的⽂件名void aaaa(char aa[10],int a){if(a>=0&&a<10){aa[0]='0';aa[1]='0';aa[2]='0';aa[3]=a+'0';}else if(a<100){aa[0]='0';aa[1]='0';aa[2]=a/10+'0';aa[3]=a%10+'0';}else if(a<1000){aa[0]='0';aa[1]=a/100+'0';aa[2]=a/10%10+'0';aa[3]=a%10+'0';}aa[4]='.';aa[5]='t';aa[6]='x';aa[7]='t';aa[8]='\0';}//计算答案⽂件的⽂件名void bbbb(char aa[10],int a){if(a>=0&&a<10){aa[0]='a';aa[1]='0';aa[2]='0';aa[3]=a+'0';}else if(a<100){aa[0]='a';aa[1]='0';aa[2]=a/10+'0';aa[3]=a%10+'0';}else if(a<1000){aa[0]='a';aa[1]=a/100+'0';aa[2]=a/10%10+'0';aa[3]=a%10+'0';}aa[4]='.';aa[5]='t';aa[6]='x';aa[7]='t';aa[8]='\0';}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

1C#九宫格游戏报告

1C#九宫格游戏报告

1
一 实验目的
1. 熟悉 C#的基础操作。 2. 通过程序掌握 C#的操作环境。 3. 学会做好 C#的简单程序
二 实验内容
本程序通过VS2010建立窗体应用程序， 通过控件建立九宫格游戏窗口:
开始时 1-9 格黄橘两色随机分布，按动一个键，周围颜色会转换为相 反色，使 5 键为黄色，其余键为橘色，则游戏过关，具体规则如下： 1. 按动 1 键，则 1，2，4，5 键颜色变反；按动 3，7，9 键同理。 2. 按动 2 键，则 1，2，3 键颜色变反；按动 4，6，8 键同理。 3. 按动 5 键，则 2，4，5，6，8 键颜色变反。
2
当成功后游戏停止。 本游戏中预先设置按钮颜色以便更快达到游戏成功， 能用来检验游戏 的可操作性。
三 设计思路
本实验在 Microsoft Visual Studio 2010 环境中运行，建立相 关控件，游戏时使按键数字参与内部函数的计算，当按键颜色符合时 游戏成功并停止记时。另外设置开始，暂停，退出，清空，帮助键以 供用户更好操作，详情请查看代码。
namespace cs_nineplay
3
{ public partial class Form1 : Form { public Form1() { InitializeComponent(); } Color OnColor = Color.Coral;//橘色变量 Color OffColor = Color.Yellow;//黄色变量 int seconds1,seconds2=999;//当前时间和上一次记录的事件(开始时默认为999) int count1,count2=999;//同理 int[,] ChangeCells ={{-1,-1,-1,-1,-1}, {1,2,4,5,-1}, {2,1,3,-1,-1}, {3,2,5,6,-1}, {4,1,7,-1,-1}, {5,2,4,6,8}, {6,3,9,-1,-1}, {7,4,5,8,-1}, {8,7,9,-1,-1}, {9,5,6,8,-1} };//用于规则变化 Button[] Buttons = new Button[10]; int num = 0;//当前记录的项数 struct TM//记录的时间的次数的结构体 { public int Time, Times; } TM[] tm = new TM[100];//记?录? private void Button_Click(object sender, EventArgs e) { Button btnHit = (Button)sender;//把当前按钮赋给btnHit int No = int.Parse(btnHit.Text);//取当前按钮的数字 for (int i = 0; i < 5; i++) { int X = ChangeCells[No, i]; if (X != -1)//改变按钮相关颜色 { if (Buttons[X].BackColor == OffColor) Buttons[X].BackColor = OnColor; else Buttons[X].BackColor = OffColor; } }

九宫格的枚举算法C_编程_趣味编程_

九宫格的枚举算法C_编程_趣味编程_

第 6 卷第 27 期 (2010 年 9 月) Computer Knowledge and Technology 电脑知识与技术九宫格的枚举算法 C# 编程（趣味编程）江速勇 1，余新盟 2（1.福建商业高等专科学校 计算机系，福建 福州 350012；2.哈尔滨工业大学 深圳研究生院 城市与土木工程学科部，广东 深圳 518055）摘要：该文简要回顾了九宫格游戏的起源、发展和现状，然后详细介绍了如何用枚举法解九宫格的思路和 C# 实现方法，最后举了两 个九宫格难题的例子，希望起到抛砖引玉的效果。

关键词：九宫格；枚举法；C# 语言；趣味编程 中图分类号：TP311文献标识码：A文章编号：1009-3044(2010)27-7833-051 概述九宫格游戏 19 世纪起源于法国，虽然有别于现代九宫格，但要求行、列、对角线数的和相等。

在销声匿迹了近一个世纪后，1984 年九宫格被引入了日本，之后被命名为 Sudoku ，意思是“独数”[1]，并一直沿用至今。

九宫格还有许多变种，例如 3x3、4x4、6x6 宫格等 等。

现在许多的报刊杂志常会刊登一些九宫格的小游戏，例如英国的免费日报 Metro （赶早的话在任意车站都可以拿到）就刊登有九 宫格游戏（分为很难、难、易三种），而且读者若将答案寄往指定的地址还有可能获取 100 英镑的抽奖呢。

为了打发时间，笔者还见过 有人带着名为 Soduku 题库的书在火车上研究呢。

九宫格在 2005 年左右风靡全球，世界上每年也举办九宫格世锦赛（World SudokuCham pionshi p ）[2]，上一届（2009 年 4 月）在斯洛伐克的日利纳举行，今年将是第五届了。

有意思的是九宫格竟然如此让人着迷以至于出现了一些令人啼笑皆非的事情。

在 2004 年 12 月 12 日英国泰晤士报刊登九宫格题的第二天刊登了一则投诉，说由于九宫格导致 他地铁坐过了站。

数字游戏(九宫格)详解

数字游戏(九宫格)详解

数学游戏游戏对策问题因常与智力游戏相结合，因此具有很大的趣味性.又由于解题方法灵活，技巧性强，所以对开阔解题思路，提高分析问题解决问题的能力是很有益处的。

例1在一个3×3的方格纸中，甲乙两人轮流（甲先）往方格纸中填写1、3、4、5、6、7、8、9、10九个数中的一个，数不能重复.最后甲的得分是不计中间行的上下两行六个数之和，乙的得分是不计中间列的左右两列六个数之和，得分多者为胜.请你为甲找出一种必胜的策略。

分析：把题中的九个格标上字母：a、b、c、d、e、f、g、h、i。

甲的得分为：a＋b＋c＋g＋h+i=（a＋c＋g+i）+（b+h）；乙的得分为：a＋d＋g＋c＋f＋i=（a＋c＋g＋i）+（d＋f）要想使甲的得分高于乙的得分，必须且只需使b＋h＞d+f.要想使b＋h＞d＋f，甲有两种策略：一是增强自己的实力——使b、h格内填的数尽可能地大；二是削弱对方的实力——使d、f格内填的数尽可能地小.下面分两种情况进行讨论：取胜的总策略是“增强自己，削弱对方”两者兼顾。

为了使叙述方便起见，我们分别用（甲2）和（a5）分别表示“甲第二轮”和“在a处填数字5”，其余如（乙1），（甲1，b10）等含义类同。

一、甲首先使b、h处填的数尽可能大.譬如，（甲1，b10）。

1.乙为了不输，（乙1）必须在h处填数.（否则，即如（乙1）不在h处填数，（甲2）在h处填余下来的最大数后，无论（乙2）怎么填，最后总有b＋h≥10＋8=18＞16＝9＋7≥d+f，甲胜）.这样，必须（乙1，h1）.（乙当然在h处填最小数）2.（甲2）不能在d处或f处填数.（否则，如（甲2，dx），x为任一数，则（乙2）在f处填余下来的最大数后，即有d+f≥3＋9＝12＞11＝10＋1＝b+h，乙胜）.当然（甲2）填9，譬如（甲2，eg）.（以后，只要甲不填错，即只要把余下数中的最小者填入d或f，就不会输了）3.显然，（乙2，d8），乙就不会输了.因此不分胜负（此时（甲3）必须（f3））。

数字游戏题九宫格

数字游戏题九宫格

数字游戏题九宫格引言数字游戏题是一种常见而受欢迎的智力游戏，它既能锻炼我们的思维能力，又能带来乐趣。

在数字游戏题中，九宫格是一种常见的题型。

九宫格是由3×3的格子组成的方阵，其中每个格子内都填有一个数字，我们需要根据一定的规则或条件来完成九宫格的数字填充。

本文将介绍几种常见的数字游戏题九宫格的解法策略。

数字游戏题九宫格的规则在数字游戏题九宫格中，通常会给出一些已知的数字，我们需要根据已知数字以及一定的规则来填充九宫格的其余空格，使每行、每列和每个小方块内的数字都满足特定的条件。

以下是九宫格填充的规则：1.每个格子内的数字必须是1到9中的一个数字；2.每行中的数字不能重复；3.每列中的数字不能重复；4.每个小方块内的数字不能重复。

解法策略穷举法穷举法是一种最直接的解法，它通过尝试所有可能的数字组合来填充九宫格。

穷举法的基本思路是从左上角的格子开始，按照行序依次填充数字，然后逐个格子向右移动。

当一个格子的数字填完后，再尝试填充下一个格子。

如果在填充的过程中发现某个格子无法找到合适的数字填充，就需要回溯到前一个格子重新选择数字。

穷举法的优势是能够找到九宫格的所有解，但缺点是计算量较大，时间复杂度较高。

对于大规模的九宫格，穷举法可能需要很长的时间才能找到解。

以下是使用穷举法解决数字游戏题九宫格的示例代码：def solve_sudoku(board):for i in range(9):for j in range(9):if board[i][j] ==0:for num in range(1, 10):if is_valid(board, i, j, num):board[i][j] = numif solve_sudoku(board):return Trueboard[i][j] =0return Falsereturn Truedef is_valid(board, row, col, num):for i in range(9):if board[row][i] == num or board[i][col] == num or board[(row// 3)*3+i//3][(col//3)*3+i%3] == num:return Falsereturn True约束编程约束编程是一种更高效的解法，它利用数学规划的方法来解决九宫格问题。

教你如何用C#开发九宫格游戏（完整版代码,图文互解,轻松就可学会）

教你如何用C#开发九宫格游戏（完整版代码,图文互解,轻松就可学会）

教你如何用C#开发九宫格游戏（完整版代码,图文互解,轻松就可学会）图文互解，完整版代码加注释，新建项目我就不说了吧九宫格游戏的基本页面：using System;using System.Collections.Generic;using ponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Windows.Forms;namespace jiuGongGe{public partial class Form1 : Form{public Form1(){InitializeComponent();}int count = 0;//点击开始时，开始按钮变灰（不可点），点击次数初始为0private void btnOK_Click(object sender, EventArgs e) {this.btnOK.Enabled = false;this.lblCount.Text = "0";count = 0;}如：//点击格子，注意该事件可直接供9个控件一起使用（只需在相应的click事件中选中btn1_Click即可）private void btn1_Click(object sender, EventArgs e) {//如果开始按钮不变灰点格子无效果，即必须点击开始后才可进行游戏//注意开始按钮变灰了，此时可开始游戏了if(this.btnOK.Enabled==false){//获取点击的格子String temp = ((Button)sender).Text;switch(temp){case"1": //点击格子1时//此段代码用了三元运算符，表示如果当前格子1的颜色为黄色，点击1后变为红色，否则如果当前格子1的颜色为红色，点击1后变为黄色。

完整的九宫格算法程序

完整的九宫格算法程序

package ninegrid;import java.util.ArrayList;import java.util.List;/***功能说明：九宫格功能实现bean**@author ClarkJia**/public class NineGrid{protected Integer nineGrid[][] = new Integer[9][9]; //九宫格阵列图protected Boolean existsGrid[][] = new Boolean[9][9];//九宫每个位置是否已经存在值protected int x = 0; //当前填空点位x坐标protected int y = 0; //当前填空点位y坐标protected int times = 0;//计算次数统计// 初始构造九宫格public NineGrid(Integer[][] initData){//ArrayUtils.cloneArray(nineGrid, initData);//复制原始九宫格for (int i = 0; i < 9; i++){for (int j = 0; j < 9; j++){nineGrid[i][j] = initData[i][j];if(nineGrid[i][j]>0){existsGrid[i][j] = true;}else{existsGrid[i][j] = false;}}}}public NineGrid(){}/***查找可填充的合法的x,y值集*@return*/public Integer[] getValidData(){//空格中数字已经存在，则返回nullif (existsGrid[x][y]){return null;}List<Integer> tempList = new ArrayList<Integer>();// 找到x轴剩余的数字for (int i = 1; i < 10; i++)boolean hasValue = false;for (int k = 0; k < 9; k++){if (nineGrid[x][k] == i){hasValue = true;break;}}// 在x轴中没有找到if (!hasValue){tempList.add(i);}}// 找xy轴都没有的数字for (int i = 0; i < tempList.size(); i++){Integer t = (Integer) tempList.get(i);boolean hasValue = false;for (int k = 0; k < 9; k++){if (nineGrid[k][y] == t.intValue()){hasValue = true;break;}}// y轴中找到x的数字则删除它if (hasValue){tempList.remove(i);i--;}}for (int i = 0; i < tempList.size(); i++){Integer t = (Integer) tempList.get(i);// 检查这个是否能满足小三宫格int starti = (x / 3) * 3;int startj = (y / 3) * 3;boolean hasEqual = false;// 表示是否已经存在，若存在则删除for (int m = starti; m < starti + 3; m++){for (int n = startj; n < startj + 3; n++){if (nineGrid[m][n] != null && t.equals(nineGrid[m][n])) {hasEqual = true;break;}}}if (hasEqual){tempList.remove(i);i--;}Integer returnInts[] = new Integer[tempList.size()];for (int i = 0; i < tempList.size(); i++){Integer t = (Integer) tempList.get(i);returnInts[i] = t.intValue();}return returnInts;}/***查找横行或竖列中空格最少的那个点位置*@return*/public String getLeastLocation(){int xLeast = 10; // x 轴中空缺数最少个数int xI = 10; // 索引int yLeast = 100;int yI = 10;for (int i = 0; i < 9; i++){int temp = 0;for (int j = 0; j < 9; j++){if (nineGrid[i][j] == 0){temp++;}}if (temp > 0 && temp < xLeast){xLeast = temp;xI = i;}}// 如果x只剩下一个空位，则填写空位if (xLeast == 1){return"x" + xI;}else{for (int i = 0; i < 9; i++){int temp = 0;for (int j = 0; j < 9; j++){if (nineGrid[j][i] == 0){temp++;}}if (temp > 0 && temp < xLeast){yLeast = temp;yI = i;}}}{return"x" + xI;} else if (yLeast <= xLeast){return"y" + yI;} else{return null;}}/***打印结果**@return*/public void doPrint(){System.out.println(" ------------------------------------");for (int i = 0; i < 9; i++){for (int j = 0; j < 9; j++){System.out.print(" | " + nineGrid[i][j]);}System.out.println(" |");System.out.println(" ------------------------------------");}}/***检查是否生成成功**@return*/public boolean checkResult(){for (int i = 0; i < 9; i++){for (int j = 0; j < 9; j++){if (nineGrid[i][j].intValue() == 0) // 若仍存在0位置点，则求解失败 {return false;}}}return true;}public Integer[][] get_nine(){return nineGrid;}public void set_nine(Integer[][] _nine){this.nineGrid = _nine;}public Boolean[][] get_bool(){}public void set_bool(Boolean[][] _bool){this.existsGrid = _bool;}public int getX(){return x;}public void setX(int x){this.x = x;}public int getY(){return y;}public void setY(int y){this.y = y;}public void setValue(int value){nineGrid[x][y] = value;existsGrid[x][y] = true;}public int getValue(){return nineGrid[x][y];}public int getTimes(){return times;}public void setTimes(int times){this.times = times;}}package ninegrid;import java.util.ArrayList;import java.util.List;/*** 功能说明：九宫格堆栈模拟** @author ClarkJia**/public class NineGridList{private List<NineGrid> nineGridList = new ArrayList<NineGrid>();//模拟九宫格list堆栈//压栈public void push(NineGrid jiuGong){nineGridList.add(jiuGong);}//弹栈public NineGrid pop(){NineGrid jiuGong = newJiuGong((NineGrid) nineGridList.remove(nineGridList.size() - 1));return jiuGong;} else{// System.out.println("题目给定九宫格无解");return null;}}//复制九宫格public NineGrid newJiuGong(final NineGrid jiuGong){NineGrid temp = new NineGrid();Integer[][] d = new Integer[9][9];Boolean[][] b = new Boolean[9][9];for (int i = 0; i < 9; i++){for (int j = 0; j < 9; j++){int aa = jiuGong.get_nine()[i][j];boolean bb = jiuGong.get_bool()[i][j];d[i][j] = aa;b[i][j] = bb;}}temp.set_bool(b);temp.set_nine(d);return temp;}}package ninegrid;/***功能说明：九宫格计算**@author ClarkJia**/public class NineGridTest{/***九宫格功能实现核心算法*@return*/public NineGrid genGridResult(NineGrid nineGrid){NineGridList stack = new NineGridList();int times = 0;//计算次数while (nineGrid != null && !nineGrid.checkResult()){times++;String least = nineGrid.getLeastLocation();if (least == null){System.out.println("此题无解, 请检查题目给定九宫格是否错误! ");break;}else{char t = least.charAt(0);//取出x、y坐标标志for (int j = 0; j < 9; j++){if (t == 'x')// 判断x、y 轴{nineGrid.setX(location);nineGrid.setY(j);} else{nineGrid.setX(j);nineGrid.setY(location);}//九宫格功能实现核心算法Integer temp[] = nineGrid.getValidData();//获得合法值集if (temp != null)// 返回非null,则当前空格处可填入数字{if (temp.length > 0)// 找到可填充数据{for (int k = 0; k < temp.length; k++){nineGrid.setValue(temp[k]);//把合法数字填入九宫格，若存在多个合法值，则从最后一个开始检查if (temp.length > 1 && k < temp.length - 1)// 如果有多个可填写值，则把多余数字组合成临时表，并压入堆栈{NineGrid tJiuGong = stack.newJiuGong(nineGrid);stack.push(tJiuGong);}}} else// 未找到可填充数字，则弹出栈顶元素{nineGrid = stack.pop();// 取出堆栈中暂存的栈顶未检查九宫数据表格，开始下一轮计算break;}}}}}if(null != nineGrid)nineGrid.setTimes(times);return nineGrid;}public static void main(String[] agrs){// 九宫格初始数据阵列图Integer[][] initGrid = {{7, 8, 0, 2, 3, 0, 1, 0, 5},{6, 0, 1, 0, 0, 0, 7, 0, 0},{9, 5, 0, 0, 0, 0, 0, 0, 0},{3, 0, 0, 0, 0, 1, 6, 5, 0},{0, 2, 0, 5, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0, 0, 0},{0, 9, 6, 8, 7, 0, 3, 2, 0},{0, 0, 0, 0, 6, 0, 9, 0, 8},{0, 4, 0, 0, 0, 0, 0, 7, 6}};long startTime = System.currentTimeMillis();NineGridTest nineTest = new NineGridTest();long endTime = System.currentTimeMillis();if (null != nineGrid && nineGrid.checkResult())//结果是否正确{System.out.println();System.out.println(" 经过计算"+ nineGrid.getTimes() + "次，共耗时"+(endTime-startTime)+"微秒，求解九宫格结果如下：");nineGrid.doPrint();}else{System.out.println(" 对不起，题目给定九宫格无解！");}}}。

VC++实现九宫图

VC++实现九宫图

图6
SHAANXI NORMAL UNIVERSITY
SCHOOL OF COMPUTER SCIENCE
九个步骤：
• 3、添加各个按钮和Picture控件。 • 4、加入9个位图资源IDB_BITMAP1、 IDB_BITMAP2、…IDB_BITMAP8和 IDB_BITMAP_NULL，代表1—8这各个数字位与空格。 • 5、数据结构和函数定义 • 6、各种算法的实现。空格上下左右移动函数， MoveLeft()、 MoveRight()、MoveUp()、 MoveDown() • 7、可视化的实现。1）对话框的定义；2）初始化对话框； 3）手动游戏时，上下左右移动；4）计次数。 • 8、用8数码算法对九宫图初始化其状态。 • 9、比较两个状态是否相同.
2 1 7
实 现
8 6
3 4 5
实 现
1 2 3 8 4 7 6 5
图 1
SHAANXI NORMAL UNIVERSITY
SCHOOL OF COMPUTER SCIENCE
二、8数码游戏解存在性讨论
• 首先，将8数码游戏总的某一个 状态按行合并（空格用0表示）， 如图2所示 1 4ualC++6.0,创建一个MFC应用程序，取名 jiugong，如图5：
SHAANXI NORMAL UNIVERSITY
SCHOOL OF COMPUTER SCIENCE
九个步骤：
• 2、在MFC AppWizard Step-1中，选择“Dialong based”选项，如图6所示：
SHAANXI NORMAL UNIVERSITY
SCHOOL OF COMPUTER SCIENCE
SHAANXI NORMAL UNIVERSITY

c语言解数独程序

c语言解数独程序

一.绪论本课题的内容是解数独，数独作为一种经典的数字类游戏，具有很强的逻辑性和趣味性，效率高的解题方法对于程序算法的逻辑要求较高。

而试填入法方法简单，只是操作繁琐，但适合计算机进行。

我们小组采用的就是回溯法，利用栈和找出很明显的可唯一填入数使得运算更快一些，普通计算机解最难的17位数独题目一般不会超过5秒钟。

组内分工大致为：程序主体一起完成，另外一人负责文件导入的部分，一人负责美化，两人负责找唯一可填入数的部分。

二．数学模型们采用的数独解决的方法是直接填入加上回溯法，而主要使用回溯法。

对整个算法来说，首先输入待求解的九宫格矩阵，空白位置用0表示。

然后定义一个AlterArr二维数组，原数独的每一个小九宫格对应新数组的每一行，将已有的数字的项替换成0。

接着进行直接填入部分，对原数独逐九宫格进行查找数据。

这部分首先检索新数组，当为非零项时，开始对数独中对应九宫格的空缺部位进行检验，当发现某个空位行与列不冲突时，计算该位置能填入数的个数，若唯一则直接填入，不回溯，并回到开头位置重新检索以防遗漏；若否，则判断下一位置。

当直接填入完成后若仍有未填的就进入回溯部分。

该部分准备工作一样，当进行到某个空位可以填入时，将此位置记录储存，用以回溯。

当之后赋值错误时，可以返回原始位置，将数字清零，并对下一位置进行赋值。

如此循环直至结束。

三．程序设计确定了算法后，我们就开始程序的设计。

为了整个功能的实现，我们定义了许多函数来解决不同的部分。

ChangeAlter用来将新数组中已有位置的数变为零；Input函数导入题目；Count函数用来计算每一个能填数字的个数，若唯一返回0；反之返回1；CheckData函数雨来检查填入数字与每行每列数字是否重复，不重复返回0；ScanData函数用来检索新数组中需要填入的数及其位置；ScanPosition函数用来确定数据能够填入的位置；CheckEnd函数检查数独是否完成，完成就返回0。

输出乘法九九表的直三角形c语言

输出乘法九九表的直三角形c语言

输出乘法九九表的直三角形c语言本文将介绍如何使用C语言输出乘法九九表的直三角形。

乘法九九表是学习数学和计算的基础，而直三角形是一种常见的图形，将两者结合起来可以帮助初学者更好地理解和记忆乘法九九表。

首先，我们需要使用两个嵌套的for循环来生成乘法九九表。

外层循环控制行数，内层循环控制列数。

每次内层循环结束后，我们需要在该行的末尾输出一个换行符。

接下来，我们需要在每一行中输出直角三角形。

我们可以使用一个额外的循环来控制输出'*'的个数，同时也需要在每个直角三角形的顶部输出当前行数和列数的乘积。

最后，我们需要在每一行的最后输出一个换行符，以使下一行从新的一列开始。

以下是完整的代码实现：```c#include <stdio.h>int main() {int i, j;for(i = 1; i <= 9; i++) { //外层循环控制行数for(j = 1; j <= i; j++) { //内层循环控制列数printf('%d*%d=%-2d ', j, i, i * j); //输出乘法表}printf(''); //每行末尾输出一个换行符for(j = 1; j <= i; j++) { //输出直角三角形 printf('*');}printf(' %d', i); //在三角形顶部输出乘积}return 0;}```运行结果如下：```1*1=1* 11*2=2 2*2=4** 21*3=3 2*3=6 3*3=9*** 31*4=4 2*4=8 3*4=12 4*4=16**** 41*5=5 2*5=10 3*5=15 4*5=20 5*5=25***** 51*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36****** 61*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49******* 71*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 ******** 81*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81********* 9```通过上述代码，我们可以输出一个简单但有趣的乘法九九表直角三角形，帮助初学者更好地掌握乘法表的知识。

九宫格的实现及九宫格源码

九宫格的实现及九宫格源码

九宫格的实现及九宫格源码今天在坛子里看到有坛友问到九宫格的实现，我把我在项目中用的经验分享一下，九宫格用gridview实现代码如下：XML/HTML代码1<?xmlversion="1.0"encoding="utf-8"?>2<LinearLayoutxmlns:android="/apk/res/android"3xmlns:app="/apk/res/com.google.android.gx5weather"4android:orientation="vertical"5android:layout_width="fill_parent"6android:layout_height="fill_parent"7android:layout_weight="1.0"8android:background="@drawable/bg"9>10<ImageViewandroid:id="@+id/ImageView01"11android:layout_width="wrap_content"12android:layout_height="wrap_content"13android:layout_gravity="center_vertical"14android:background="@drawable/top"></ImageView>15<GridViewxmlns:android="/apk/res/android"16android:id="@+id/gridview"17android:layout_width="wrap_content"18android:layout_height="wrap_content"19android:numColumns="3"20android:verticalSpacing="30dip"21android:horizontalSpac ing="10dip"22android:columnWidth="90dip"//列宽23android:stretchMode="columnWidth"24android:gravity="center"25android:listSelector="@drawable/grid_selector_background"26>27</GridView>28</LinearLayout>Android:numColumns="3" //九宫格的列数auto_fit时为自动android:listSelector="@drawable/grid_selector_background" //九宫格的背景，可以找个圆角正方形Java代码29publicclassNineBoxextendsActivity{30/**Calledwhentheactivityisfirstcreated.*/31@Override32protectedvoidonCreate(BundlesavedInstanceState){33//TODOAuto-generatedmethodstub34super.onCreate(savedInstanceState);35this.requestWindowFeature(Window.FEA TURE_NO_TITLE);36this.getWindow().setFlags(youtParams.FLAG_FULLSCREEN,youtParams.FLAG_FULLSCREEN);3839setContentView(yout.main_activity);40GridViewgridview=(GridView)findView ById(R.id.gridview);41ArrayList<HashMap<String,Object>>lstImageItem=newArrayList<HashMap<String,Obj ect>>();42for(inti=1;i<10;i++)43{44HashMap<String,Object>map=newHashMap<String,Object>();45if(i==1){46map.put("ItemImage",R.drawable.g11);47map.put("ItemText",getResources().getString(R.string.gridview1));48}49if(i==2){50map.put("ItemImage",R.drawable.g12);51map.put("ItemText",getResources().getString(R.string.gridview2));52}53if(i==3){54map.put("ItemImage",R.drawable.g13);55map.put("ItemText",getResources().getString(R.string.gridview3));56}57if(i==4){58map.put("ItemImage",R.drawable.g14);59map.put("ItemText",getResources().getString(R.string.gridview4));60}61if(i==5){62map.put("ItemImage",R.drawable.g15);63map.put("ItemText",getResources().getString(R.string.gridview5));64}65if(i==6){66map.put("ItemImage",R.drawable.g16);67map.put("ItemText",getResources().getString(R.string.gridview6));68}69if(i==7){70map.put("ItemImage",R.drawable.g17);71map.put("ItemText",getResources().getString(R.string.gridview7));72}73if(i==8){74map.put("ItemImage",R.drawable.g18);75map.put("ItemText",getResources().getString(R.string.gridview8));76}77if(i==9){78map.put("ItemImage",R.drawable.g19);79map.put("ItemText",getResources().getString(R.string.gridview9));80}81lstImageItem.add(map);8283}8485SimpleAdaptersaImageItems=newSimpleAdapter(this,86lstImageItem,yout.grid_item,88newString[]{"ItemImage","ItemText"},89newint[]{R.id.ItemImage,R.id.ItemText});9091gridview.setAdapter(saImageItems);92gridview.setOnItemClickListener(newItemClickListener());93}949596classItemClickListenerimplementsOnItemClickListener97{9899@SuppressWarnings("unchecked")100publicvoidonItemClick(AdapterView<?>arg0,//TheAdapterViewwheretheclickhappened 101Viewarg1,//TheviewwithintheAdapterViewthatwasclicked102intarg2,//Thepositionoftheviewintheadapter103longarg3//Therowidoftheitemthatwasclicked104){105106HashMap<String,Object>item=(HashMap<String,Object>)arg0.getItemAtPosition(arg2); 107108if(item.get("ItemText").equals(getResources().getString(R.string.gridview1))){109Toast.makeText(NineBox.this,R.string.gridview1,Toast.LENGTH_LONG).show(); 110}111if(item.get("ItemText").equals(getResources().getString(R.string.gridview2))){112Toast.makeText(NineBox.this,R.string.gridview2,Toast.LENGTH_LONG).show(); 113}114if(item.get("ItemText").equals(getResources().getString(R.string.gridview3))){115Toast.makeText(NineBox.this,R.string.gridview3,Toast.LENGTH_LONG).show(); 116}117if(item.get("ItemText").equals(getResources().getString(R.string.gridview4))){118Toast.makeText(NineBox.this,R.string.gridview4,Toast.LENGTH_LONG).show(); 119}120if(item.get("ItemText").equals(getResources().getString(R.string.gridview5))){121Toast.makeText(NineBox.this,R.string.gridview5,Toast.LENGTH_LONG).show(); 122}123if(item.get("ItemText").equals(getResources().getString(R.string.gridview6))){ 124Toast.makeText(NineBox.this,R.string.gridview6,Toast.LENGTH_LONG).show(); 125}126127if(item.get("ItemText").equals(getResources().getString(R.string.gridview7))){ 128Toast.makeText(NineBox.this,R.string.gridview7,Toast.LENGTH_LONG).show(); 129}130if(item.get("ItemText").equals(getResources().getString(R.string.gridview8))){ 131Toast.makeText(NineBox.this,R.string.gridview8,Toast.LENGTH_LONG).show(); 132}133if(item.get("ItemText").equals(getResources().getString(R.string.gridview9))){ 134Toast.makeText(NineBox.this,R.string.gridview9,Toast.LENGTH_LONG).show(); 135}136}137}138}。

九宫格算法（C语言版）

九宫格算法（C语言版）

九宫格算法（C语⾔版）#include <iostream>#include<time.h>static int pu[9][9]={{0,0,0,7,2,8,0,0,0},{0,9,0,0,5,1,6,0,0},{0,0,0,0,6,0,0,8,2},{3,0,0,8,0,2,7,0,4},{1,7,4,0,3,0,0,2,0},{2,8,0,5,0,0,0,3,0},{0,1,0,3,0,0,2,0,0},{0,0,7,0,4,6,0,0,5},{0,0,6,1,0,0,0,4,9} };int isvalid(const int i, const int j)//验证函数当期i,j坐标是否符合游戏规则，不重复{const int n = pu[i][j];const static int query[] = {0, 0, 0, 3, 3, 3, 6, 6, 6};int t, u;for (t = 0; t < 9; t++)if (t != i && pu[t][j] == n || t != j && pu[i][t] == n)//0-9的数字，每⾏每列都不能重复return0;for (t = query[i]; t < query[i] + 3; t++) //9个宫的3×3⾥也不能重复for (u = query[j]; u < query[j] + 3; u++)if ((t != i || u != j) && pu[t][u] == n)return0;return1;}void output(void)//输⼊函数{static int n;cout << "Solution " << ++n << ":" <<endl;for (int i = 0; i < 9; i++) {for (int j = 0; j < 9; j++)cout<< pu[i][j] << " ";cout << endl;}cout << endl;}void Try(const int n)//核⼼函数，回溯算法{if (n == 81) {//是否已经是最后⼀个格⼦output();return;}const int i = n / 9, j = n % 9;if (pu[i][j] != 0) {//如果当前格⼦不需要填数字，就跳到下⼀个格⼦Try(n + 1);return;}for (int k = 0; k < 9; k++) {pu[i][j]++;//当前格⼦进⾏尝试所有解if (isvalid(i, j))Try(n + 1);//验证通过，就继续下⼀个}pu[i][j] = 0; //如果上⾯的单元⽆解，就回溯}int main(void){long start=clock();Try(0);long end=clock();cout<<"计算⼀共花了"<<(double)(end-start)<<"毫秒"<<endl;return0;}。

九宫格8个数字顺时针c语言代码讲解

九宫格8个数字顺时针c语言代码讲解

九宫格8个数字顺时针c语言代码讲解以下是九宫格8个数字顺时针的C语言代码：```c#include<stdio.h>int a[3][3]={{4,9,2},{3,5,7},{8,1,6}}; //九宫格数组void f(int,int); //函数声明int main(){int i,j;for(i=0;i<3;i++){for(j=0;j<3;j++)printf("%d ",a[i][j]);printf("\n"); //输出原先的九宫格}f(0,1); //调用函数fprintf("\n");for(i=0;i<3;i++){for(j=0;j<3;j++)printf("%d ",a[i][j]);printf("\n"); //输出旋转后的九宫格}return 0;}void f(int x,int y){int t;t=a[x][y];a[x][y]=a[2-y][x];a[2-y][x]=a[2-x][2-y];a[2-x][2-y]=a[y][2-x];a[y][2-x]=t;if(x==1&&y==2) //循环结束条件return ;if(y<2) //y坐标小于2，继续向右走f(x,y+1);else //否则，换行继续向右走f(x+1,0);}```代码说明：1. 首先定义了一个3x3的数组`a`作为九宫格数组，其中提前输入8个数字。

2. 然后定义了函数`f(int x, int y)`来完成顺时针旋转九宫格的操作。

该函数的参数`x`和`y`表示九宫格中的行列坐标，函数正式开始执行时坐标为`(0,1)`，即初始值为第一行第二个数字。

函数通过不断交换4个数字的位置来完成九宫格的旋转，直到所有数字都旋转了位置，即坐标为`(1,2)`时循环结束。

九宫格实现算法

九宫格实现算法

实验目的：通过visual c++进行算法编辑，准确掌握算法运行方式及流程。

通过程序实现类似九宫格的拼图效果，也叫做八方块。

用最快的时间实现最后的效果：1 2 34 5 67 8 0实验原理：先实现一个三行三列数组，再依次比较第一个数与上下左右数值的大小，进行移动，最后实现效果图。

计算出一共移动的步数和每移一步的效果。

实验内容：程序代码如下：// 8block.cpp : 定义控制台应用程序的入口点。

//#include "stdafx.h"#include <stdio.h>#include <stdlib.h>#include <time.h>#define GOAL 123804765//表示我们要找得目标状态struct Node{short state[9];//存放结点的状态short pos;//空格所在的位置,在数组中用0代表空格struct Node *up;//空格上移后的状态struct Node *down;//空格下移后的状态struct Node *left;//空格左移后的状态struct Node *right;//空格右移后的状态struct Node *parent;//它是从哪一状态变换而来的struct Node *next;//表示在队列中的下一个状态} ;struct Tree{short key;//表示当前结点的数值short * state;//表示当前状态的整个数组,当整颗树生成完毕后这一数组将被释放short index;//表示当前数值在数组中的位置bool visited;//对于叶子结点而言，表示这一结点是否被访问过struct Tree * next;//指向它的(下一个)兄弟结点，表示这一位置的下一个数struct Tree *down;//指向它的第一个孩子结点，表示下一位置的第一个数};struct Queue//定义一个队列用于广度优先遍历{struct Node * front;struct Node * rear;};void InitQueue(struct Queue *Q);//初始化一个空队列bool QueueEmpty(struct Queue *Q);//判断队列是否为空void EnQueue(struct Queue *Q,struct Node *N);//入队列struct Node * DeQueue(struct Queue *Q);//出队列，返回队结点void ClearQueue(struct Queue *Q);//清空队列struct Node * GetBestPath(struct Node *tree);//找到一个最短路径，并返回最后的状态结点，如果没有路径返回NULLstruct Tree * CreateCheckTree();//生成一个用于检查状态的查询树void CreateSubCheckTree(struct Tree * T);//生成状态检查子树void FreeCheckTree(struct Tree * checkTree);//释放状态检查树的空间int checkCount=0;//检查结点状态次数int deCount=0;//出队列次数int enCount=0;//入队列次数struct Tree * checkTree;void main(){struct Node* tree=new struct Node;tree->parent=NULL;printf("输入0-8的任意一个排列，其中0表示空格所在的位置:\n");for(int i=0;i<=8;i++){scanf("%d",&tree->state[i]);}for(int i=0;i<=8;i++){if(tree->state [i]==0){tree->pos =i;}}tree->next =NULL;int c1=clock();struct Node *result=GetBestPath(tree);int c2=clock();double t=(c2-c1)/1000.0;printf("状态检查次数:%d,入队列次数:=%d,出队列次数:%d\n",checkCount,enCount,deCount);if(result!=NULL){int path[200];int count=0;struct Node *N=result;while(N!=NULL){path[count]=N->pos;N=N->parent;count++;}printf("有最短路径，共须%d步。

C++实现数独快速求解

C++实现数独快速求解

C++实现数独快速求解什么是数独数独是源⾃18世纪瑞⼠的⼀种数学游戏。

是⼀种运⽤纸、笔进⾏演算的逻辑游戏。

玩家需要根据9×9盘⾯上的已知数字，推理出所有剩余空格的数字，并满⾜每⼀⾏、每⼀列、每⼀个粗线宫（3*3）内的数字均含1-9，不重复。

数独盘⾯是个九宫，每⼀宫⼜分为九个⼩格。

在这⼋⼗⼀格中给出⼀定的已知数字和解题条件，利⽤逻辑和推理，在其他的空格上填⼊1-9的数字。

使1-9每个数字在每⼀⾏、每⼀列和每⼀宫中都只出现⼀次，所以⼜称“九宫格”。

解决思路1、遍历数独表，找出数字为空（以0填充）的表格；2、找出每个数据中空的表格中可以填充的数字；3、找到其中可以填充的数字个数最少的表格；4、将每个数字分别填充到该表格中；5、递归重复步骤1-4，直到表格中不再有数字为0的表格#include <iostream>#include <ctime>using namespace std;struct Position{int row;int col;int *res;};Position* findMinBlank(int board[][9]){int *validNums(int board[][9], int row, int col);Position *pos = new Position();pos->res = 0;int *res;int total=0, minum = 10;for(int i=0; i<9; ++i)for(int j=0; j<9; ++j){if(board[i][j]!=0)continue;res = validNums(board, i, j);total = 0;for(int p=0; p<9; ++p){if(res[p]!=0){++ total;}}if(total<minum){delete []pos->res;pos->row = i;pos->col = j;pos->res = res;minum = total;}elsedelete []res;}return pos;}int *validNums(int board[][9], int row, int col){int *res = new int[9] {1,2,3,4,5,6,7,8,9};for (int i = 0; i < 9; i++){res[board[row][i]-1] = 0;res[board[i][col]-1] = 0;}int p = row / 3 * 3;int q = col / 3 * 3;for (int x = p; x < p + 3; x++)for (int y = q; y < q + 3; y++){res[board[x][y]-1] = 0;}return res;}void printResult(int result[][9] ){for (int i = 0; i < 9; i++){for (int j = 0; j < 9; j++){cout << result[i][j] << " ";}cout << endl;}cout << endl;}void sudoku(int board[][9]){Position *pos = findMinBlank(board);if(!pos->res){cout<<"time:"<<clock()/1e6<<endl;printResult(board);return;}for(int i=0;i<9;++i){if(pos->res[i]==0)continue;board[pos->row][pos->col] = pos->res[i];sudoku(board);}board[pos->row][pos->col] = 0;delete pos->res;delete pos;}int main(){int start = clock();cout<<start/1e6<<endl;int board[][9] ={0, 0, 0, 0, 0, 0, 0, 1, 0,4, 0, 0, 0, 0, 0, 0, 0, 0,0, 2, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 5, 0, 4, 0, 7,0, 0, 8, 0, 0, 0, 3, 0, 0,0, 0, 1, 0, 9, 0, 0, 0, 0,3, 0, 0, 4, 0, 0, 2, 0, 0,0, 5, 0, 1, 0, 0, 0, 0, 0,0, 0, 0, 8, 0, 6, 0, 0, 0};printResult(board);sudoku(board);int end = clock();cout <<"time:" << (end - start)/1e6 << endl;return 0;}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
m++;
goto K;
}
else
{
if(B[m][1]==B[m][0])
{
B[m][1]=0;
a[b[m][1]][b[m][2]]=0;
B[m][2]=0;
m--;
goto K;
}
else goto K;
}
}
else return 0;
}
void sort_b(int b[M1][M2],int n)
{
int i,j,k,p[M2];
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
{
//cin>>a[i][j];
}
cout<<endl<<"你输入的数据是："<<endl;
Output_a(a); //输出原数组a
for(i=0;i<M1;i++) //数组归零
{
for(j=0;j<3;j++)
void Output_b(int b[M1][M2]);//输出空缺处可填数据
void Output_a(int a[M][M]);
int JudgeRepeat(int i,int j,int m,int B[M1][3],int a[M][M]);//判断ij处所填数据是否发生重复
int Fblank(int n,int b[M1][M2],int B[M1][3],int a[M][M]);//填空数组B充当栈的功能
#define M 9
#define M1 M*M
#define M2 M+3
#include "iostream.h"
#include "stdlib.h"
#include "stdio.h"
void Search(int a[M][M],int b[M1][M2],int &n1);//寻找空缺处可填数据并以n1返回空缺数
for(j=3;j<M2&&b[i][j]!=0;j++)
cout<<b[i][j]<<" ";
cout<<"(所处坐标是:"<<"("<<b[i][1]+1<<","<<b[i][2]+1<<"))";
cout<<endl;
}
}
int JudgeRepeat(int i,int j,int m,int B[M1][3],int a[M][M])
{
B[i][j]=0;
}
for(j=0;j<M2;j++)
b[i][j]=0;
}
Search(a,b,n);//函数搜寻空缺处可填数据
sort_b(b,n);
cout<<"空缺个数："<<n<<endl;
Output_b(b);
if(n==0) goto G;
void sort_b(int b[M1][M2],int n);//给数组b排序
void main()
{
int i,j,a[M][M],b[M1][M2],B[M1][3],r,l;
int n=0;//记录空缺个数
int k[M][M]={{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,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}};
else t=1;
return t;
}
int Fblank(int n,int b[M1][M2],int B[M1][3],int a[M][M])
{
int m=0;
K:
if(m<n)
{
while(B[m][1]==B[m][0]&&m!=0)
{
B[m][1]=0;
b[n][2]=j;
n++;
}
}
n1=n;
}
void Output_b(int b[M1][M2])
{
int i,j;
for(i=0;i<M1&&b[i][0]!=0;i++)
{
cout<<"第"<<i+1<<"个可填数据是：";
if(b[i][0]>b[j][0])
{
for(k=0;k<M2;k++)
{
p[k]=b[i][k];
b[i][k]=b[j][k];
b[j][k]=p[k];
}
}
}
}
void Output_a(int a[M][M])
{
int t,l1,l2;
for(l1=0;l1<M;l1++)
if(a[i][l1]==B[m][2]&&l1!=j) break;
for(l2=0;l2<M;l2++)
if(a[l2][j]==B[m][2]&&l2!=i) break;
if(l1<M||l2<M) t=0;
{
int i,j;
for(i=0;i<M;i++)
{
for(j=0;j<M;j++)
{
cout<<a[i][j]<<" ";
}
cout<<endl;
}
}
a[b[m][1]][b[m][2]]=0;
B[m][2]=0;
m--;
}
B[m][1]++;
B[m][2]=b[m][B[m][1]+2];
a[b[m][1]][b[m][2]]=B[m][2];
if(JudgeRepeat(b[m][1],b[m][2],m,B,a)==1)
while(b[0][0]<2)
{
a[b[0][1]][b[0][2]]=b[0][3];
Search(a,b,n);//函数搜寻空缺处可填数据
if(n==0) goto G;
sort_b(b,n);
}
cout<<endl<<"整理后空缺个数："<<n<<endl;
Output_a(a); //输出计算所得数组a
}
void Search(int a[M][M],int b[M1][M2],intk,m,n=0;
for(i=0;i<M;i++)
for(j=0;j<M;j++)
{
if(a[l2][j]==k) break;
if(l1<M||l2<M) continue;
else
{
b[n][m]=k;
m++;
}
}
b[n][0]=m-3;
b[n][1]=i;
for(i=0;i<M;i++)
for(j=0;j<M;j++)
{
a[i][j]=k[i][j];
}
/*
for(i=0;i<M;i++)
for(j=0;j<M;j++)
{
a[i][j]=0;
*/
cout<<"请根据提示输入九宫格的数据（以0作为结束）"<<endl;
Output_b(b);
cout<<endl;
for(i=0;i<M1;i++) //数组B依次记录空缺处可填数据的个数
B[i][0]=b[i][0];
Fblank(n,b,B,a);
G: cout<<endl<<"计算后九宫格是："<<endl;
cin>>j;
cout<<"值为：";
cin>>a[i][j];
l++;
}
for(i=0;i<M;i++)
for(j=0;j<M;j++)
{
//cout<<"输入a["<<i<<"]["<<j<<"]=";
cout<<"请输入1以示开始";
相关文档
最新文档