52单片机九宫格程序

❶ 求用C语言编一个解九宫格数独的程序

前两天刚写完,还没优化,已运行通过了.
晕，一维的好麻烦，这个也是碰巧前两天刚写好的，你看着自己修改下
#include <stdio.h>

typedef struct
{
int line;
int row;
int num;
}Node;

int main()
{
/*
int a[9][9]={
{4,0,3,6,0,0,0,0,0},
{0,0,0,0,0,1,0,2,4},
{0,1,0,0,4,0,5,0,0},
{0,0,0,9,0,4,0,6,0},
{3,0,2,0,0,0,4,0,9},
{0,7,4,1,0,3,0,0,0},
{0,0,1,0,9,0,0,4,0},
{2,4,0,3,0,0,0,0,0},
{0,0,0,4,0,8,2,0,7}};
*/
int a[9][9]={
{0,0,0,8,0,0,0,6,0},
{8,7,0,0,0,0,0,0,0},
{2,9,0,0,4,1,0,0,5},
{0,0,5,7,0,0,0,0,9},
{0,2,0,0,0,0,0,1,0},
{9,0,0,0,0,4,3,0,0},
{7,0,0,6,1,0,0,9,8},
{0,0,0,0,0,0,0,5,2},
{0,6,0,0,0,9,0,0,0}};
/*
int a[9][9]={
{0,2,0,0,6,0,0,0,0},
{0,9,0,4,0,5,1,3,0},
{0,0,8,7,0,0,0,0,5},
{6,0,0,3,0,0,4,0,0},
{0,0,0,9,0,6,0,0,0},
{0,0,7,0,0,1,0,0,3},
{4,0,0,0,0,7,3,0,0},
{0,8,5,2,0,4,0,7,0},
{0,0,0,0,9,0,0,1,0}};
*/
/*
int a[9][9]={
{0,0,3,0,2,0,0,0,6},
{0,0,2,0,9,0,0,0,4},
{7,0,0,8,0,0,2,0,3},
{0,8,0,0,7,0,5,0,0},
{0,7,0,1,0,6,0,3,0},
{0,0,0,2,0,0,0,9,0},
{4,0,6,0,0,8,0,0,5},
{6,0,0,0,4,0,3,0,0},
{9,0,0,0,1,0,7,0,0}};
*/
int i,j,n,en,flag,y,k=0,x,qu,p,q;
Node b[70];
for(i=0;i<9;i++)
{
for(j=0;j<9;j++)
{
if(!a[i][j])
{
b[k].line=i;
b[k].row=j;
b[k].num=0;
k+=1;
}
}
}
en=k;
/*从b[0]开始试，若b[k].num>9,则k-1,否则k+1*/
for(k=0;k<en;)
{
++b[k].num;
i=b[k].line;
j=b[k].row;
a[i][j]=b[k].num;
n=0;
while(n<9&&b[k].num<=9)
{
if(n==i)
{
for(y=0;y<9;y++)
{
if(y==j)
continue;
if(a[n][y]==a[i][j])
flag=1;
}
}
else if(n==j)
{
for(y=0;y<9;y++)
{
if(y==i)
continue;
if(a[y][n]==a[i][j])
flag=1;
}
}
/*判断同一块中有没有相同值*/
qu=3*(i/3)+j/3;
switch(qu)
{
case 0:x=0;
y=0;
break;
case 1:x=0;
y=3;
break;
case 2:x=0;
y=6;
break;
case 3:x=3;
y=0;
break;
case 4:x=3;
y=3;
break;
case 5:x=3;
y=6;
break;
case 6:x=6;
y=0;
break;
case 7:x=6;
y=3;
break;
default :x=6;
y=6;
break;
}
p=x;
q=y;
for(;x<p+3;x++)
{
for(;y<q+3;y++)
{
if(x==i&&y==j)
continue;
if(a[x][y]==a[i][j])
{
flag=1;
break;
}
}
if(flag==1)
break;
}
if(flag==1)
{
a[i][j]=++b[k].num;
flag=0;
n=0;
continue;
}
n++;
}
if(b[k].num>9)
{
a[i][j]=b[k].num=0;
k--;
if(k<0)
{
printf("error!\r\n");
return -1;
}
}
else
k++;
}
for(i=0;i<9;i++)
{
for(j=0;j<9;j++)
{
printf("%d",a[i][j]);
}
printf("\r\n");
}
return 1;
}

❷ 求解答这个九宫格数独

答案详见下图

数独是源自18世纪瑞士的一种数学游戏。是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。

数独盘面是个九宫，每一宫又分为九个小格。在这八十一格中给出一定的已知数字和解题条件，利用逻辑和推理，在其他的空格上填入1-9的数字。使1-9每个数字在每一行、每一列和每一宫中都只出现一次，所以又称“九宫格”。

起源

既然“数独”有一个字是“数”，人们也往往会联想到数学，那就不妨从大家都知道的数学家欧拉说起，但凡想了解数独历史的玩家在网络、书籍中搜索时，共同会提到的就是欧拉的“拉丁方块（Latin square）”。

拉丁方块的规则：每一行（Row）、每一列（Column）均含1-N（N即盘面的规格），不重复。这与前面提到的标准数独非常相似，但少了一个宫的规则。

近代发展

数独起源于18世纪初瑞士数学家欧拉等人研究的拉丁方阵（Latin Square）。19世纪80年代，一位美国的退休建筑师格昂斯（Howard Garns）根据这种拉丁方阵发明了一种填数趣味游戏，这就是数独的雏形。20世纪70年代，人们在美国纽约的一本益智杂志《Math Puzzles and Logic Problems》上发现了这个游戏，当时被称为填数字（Number Place），这也是目前公认的数独最早的见报版本。1984年一位日本学者将其介绍到了日本，发表在Nikoli公司的一本游戏杂志上，当时起名为“数字は独身に限る”（すうじはどくしんにかぎる），就改名为“数独”（すうどく），其中“数”（すう）是数字的意思，“独”（どく）是唯一的意思。后来一位前任香港高等法院的新西兰籍法官高乐德（Wayne Gould）在1997年3月到日本东京旅游时，无意中发现了。他首先在英国的《泰晤士报》上发表，不久其他报纸也发表，很快便风靡全英国，之后他用了6年时间编写了电脑程序，并将它放在网站上（这个网站也就是着名的数独玩家论坛），后来因一些原因，网站被关闭，幸好数独大师Glenn Fowler恢复了数据，玩家论坛有了新处所。在90年代国内就有部分的益智类书籍开始刊登，南海出版社在2005年出版了《数独1-2》，随后日本着名数独制题人西尾彻也的《数独挑战》也由辽宁教育出版社出版。《北京晚报》、《扬子晚报》、《羊城晚报》、《新民晚报》、《成都商报》等等报纸媒体也先后刊登了数独游戏。

❸ 如何用C＋＋编程一个解决九宫格问题的程序

/*
问题描述：九宫格（格子里面填数，隔行、列、对角线和相等）
PS：MS我在此之前从来没有写过如此暴力的代码...
*/
#include<algorithm>
#include<iostream>
#include<iomanip>
using namespace std;

struct PAIR
{
int a, b;
};

int data[3][3], rescount;
bool flag[10];

void outres()
{
int i, j;
cout << "Solution " << ++rescount << ":" << endl;
for(i = 0; i < 3; ++i)
{
for(j = 0; j < 3; ++j)
cout << left << setw(2) << data[i][j];
cout << endl;
}
cout << endl;
}

bool validate(int v)
{
int i, j, t, tt, sum = (45 - v) / 4 + 5;
for(i = 0; i < 3; ++i)
{
t = data[i][0];
tt = data[0][i];
for(j = 1; j < 3; ++j)
{
t += data[i][j];
tt += data[j][i];
}
if(t != sum || tt != sum) return false;
}
if(data[0][0] + data[1][1] + data[2][2] != sum) return false;
if(data[0][2] + data[1][1] + data[2][0] != sum) return false;
return true;
}

void search(int v)
{
int i, j, k, l, ii, jj, kk, ll, sum, cnt = 0;
PAIR pair[4];
bool flag[4] = {0};
if((45 - v) % 4) return; // 无解
else sum = (45 - v) / 4;
for(i = 1; i <= sum / 2; ++i)
{
if(i == v) continue;
pair[cnt].a = i;
pair[cnt].b = sum - i;
cnt++;
}
memset(flag, false, sizeof(flag));
for(i = 0; i < cnt; ++i)
{
flag[i] = true;
for(j = 0; j < cnt; ++j)
{
if(flag[j]) continue;
flag[j] = true;
for(k = 0; k < cnt; ++k)
{
if(flag[k]) continue;
flag[k] = true;
for(l = 1; l < cnt && flag[l]; ++l);
// 交换位置
for(ii = 0; ii < 2; ++ii)
for(jj = 0; jj < 2; ++jj)
for(kk = 0; kk < 2; ++kk)
for(ll = 0; ll < 2; ++ll)
{
data[1][ii << 1] = pair[i].a;
data[1][((ii << 1) + 2) % 4] = pair[i].b;
data[jj << 1][jj << 1] = pair[j].a;
data[((jj << 1) + 2) % 4][((jj << 1) + 2) % 4] = pair[j].b;
data[kk << 1][1] = pair[k].a;
data[((kk << 1) + 2) % 4][1] = pair[k].b;
data[ll << 1][((ll << 1) + 2) % 4] = pair[l].a;
data[((ll << 1) + 2) % 4][ll << 1] = pair[l].b;
if(validate(v)) outres();
}
flag[k] = false;
}
flag[j] = false;
}
flag[i] = false;
}
}

int main()
{
int i;
for(i = 1; i <= 9; i += 2)
{
data[1][1] = i;
memset(flag, false, sizeof(flag));
flag[i] = true;
search(i);
}
return 0;
}

❹ c语言 九宫格

#include<stdio.h>
#include<malloc.h>
int N=15;
int main()
{
int i,j,k,m,n;
int G[N][N];
printf("Input the odd number(number<=15) you want !\n");
scanf("%d",&m);
if((m>0)&&(m%2))
{
printf("Your intput number is %d\n",m);
n=m*m;
j=0;
k=m/2;
for(i=1;i<=n;i++)
{
G[j][k]=i;
if(i%m==0)
if(j==m-1)
j=0;
else
j++;
else
{
if(j==0)
j=m-1;
else
j--;
if(k==m-1)
k=0;
else
k++;
}
}
for(i=0;i<m;i++)
{
for(j=0;j<m;j++)
printf("%6d",G[i][j]);
printf("\n");
}
}
else
printf("The number you inputed is ERROR!!!");
system("pause");
}
可以接受15以内的任意魔方 你的九宫格按照这个程序输出是这样的：

❺ 九宫格拼图·求此问题解法~~思路~代码都可~~就是关于其还原算法的·急~在线等~多谢哈

http://www.cublog.cn/u/8780/showart.php?id=163291

在一个3×3的九宫中有1－8这8个数及一个空格随机的摆放在其中的格子里，如图1－1所示。现在要求实现这个问题：将其调整为如图1－1右图所示的形式。调整的规则是：每次只能将与空格（上、下、或左、右）相邻的一个数字平移到空格中。试编程实现这一问题的求解。

（图1－1）

二、题目分析：
这是人工智能中的经典难题之一，问题是在3×3方格棋盘中，放8格数，剩下的没有放到的为空，每次移动只能是和相邻的空格交换数。程序自动产生问题的初始状态，通过一系列交换动作将其转换成目标排列（如下图1－2到图1－3的转换）。

（图1－2） （图1－3）

该问题中，程序产生的随机排列转换成目标共有两种可能，而且这两种不可能同时成立，也就是奇数排列和偶数排列。可以把一个随机排列的数组从左到右从上到下用一个一维数组表示，如上图1－2我们就可以表示成｛8，7，1，5，2，6，3，4，0｝其中0代表空格。
在这个数组中我们首先计算它能够重排列出来的结果，公式就是：

∑（F（X））＝Y，其中F（X）

是一个数前面比这个数小的数的个数,Y为奇数和偶数时各有一种解法。（八数码问题是否有解的判定 ）

上面的数组可以解出它的结果。
F（8）＝0；
F（7）＝0；
F（1）＝0；
F（5）＝1；
F（2）＝1；
F（6）＝3；
F（3）＝2；
F（4）＝3；
Y＝0＋0＋0＋1＋1＋3＋2＋3＝10

Y＝10是偶数，所以其重排列就是如图1－3的结果，如果加起来的结果是奇数重排的结果就是如图1－1最右边的排法。

三、算法分析
求解方法就是交换空格（0）位置，直至到达目标位置为止。图形表示就是：

（图3－1）

要想得到最优的就需要使用广度优先搜索，九宫的所以排列有9！种，也就是362880种排法，数据量是非常大的，使用广度搜索，需要记住每一个结点的排列形式，要是用数组记录的话会占用很多的内存，可以把数据进行适当的压缩。使用DWORD形式保存，压缩形式是每个数字用3位表示，这样就是3×9＝27个字节，由于8的二进制表示形式1000，不能用3位表示，使用了一个小技巧就是将8表示为000，然后用多出来的5个字表示8所在的位置，就可以用DWORD表示了。用移位和或操作将数据逐个移入，比乘法速度要快点。定义了几个结果来存储遍历到了结果和搜索完成后保存最优路径。
类结构如下：

class CNineGird
{
public:
struct PlaceList
{
DWORD Place;
PlaceList* Left;
PlaceList* Right;
};
struct Scanbuf
{
DWORD Place;
int ScanID;
};
struct PathList
{
unsigned char Path[9];
};

private:
PlaceList *m_pPlaceList;
Scanbuf *m_pScanbuf;
RECT m_rResetButton;
RECT m_rAutoButton;

public:
int m_iPathsize;
clock_t m_iTime;
UINT m_iStepCount;
unsigned char m_iTargetChess[9];
unsigned char m_iChess[9];
HWND m_hClientWin;
PathList *m_pPathList;
bool m_bAutoRun;

private:
inline bool AddTree(DWORD place , PlaceList*& parent);
void FreeTree(PlaceList*& parent);
inline void ArrayToDword(unsigned char *array , DWORD & data);
inline void DwordToArray(DWORD data , unsigned char *array);
inline bool MoveChess(unsigned char *array , int way);
bool EstimateUncoil(unsigned char *array);
void GetPath(UINT depth);

public:
void MoveChess(int way);
bool ComputeFeel();
void ActiveShaw(HWND hView);
void DrawGird(HDC hDC , RECT clientrect);
void DrawChess(HDC hDC , RECT clientrect);
void Reset();
void OnButton(POINT pnt , HWND hView);

public:
CNineGird();
~CNineGird();
};

计算随机随机数组使用了vector模板用random_shuffle（，）函数来打乱数组数据，并计算目标结果是什么。代码：

void CNineGird::Reset()
{
if(m_bAutoRun) return;
vector vs;
int i;
for (i = 1 ; i < 9 ; i ++)
vs.push_back(i);
vs.push_back(0);
random_shuffle(vs.begin(), vs.end());
random_shuffle(vs.begin(), vs.end());
for ( i = 0 ; i < 9 ; i ++)
{
m_iChess[i] = vs[i];
}

if (!EstimateUncoil(m_iChess))
{
unsigned char array[9] = {1,2,3,8,0,4,7,6,5};
memcpy(m_iTargetChess , array , 9);
}
else
{
unsigned char array[9] = {1,2,3,4,5,6,7,8,0};
memcpy(m_iTargetChess , array , 9);
}

m_iStepCount = 0;
}

数据压缩函数实现：

inline void CNineGird::ArrayToDword(unsigned char *array , DWORD& data)
{
unsigned char night = 0;
for ( int i = 0 ; i < 9 ; i ++)
{
if (array[i] == 8)
{
night = (unsigned char)i;
break;
}
}

array[night] = 0;
data = 0;
data = (DWORD)((DWORD)array[0] << 29 | (DWORD)array[1] << 26 |
(DWORD)array[2] << 23 | (DWORD)array[3] << 20 |
(DWORD)array[4] << 17 | (DWORD)array[5] << 14 |
(DWORD)array[6] << 11 | (DWORD)array[7] << 8 |
(DWORD)array[8] << 5 | night);

array[night] = 8;
}

解压缩时跟压缩正好相反，解压代码：

inline void CNineGird::DwordToArray(DWORD data , unsigned char *array)
{
unsigned char chtem;
for ( int i = 0 ; i < 9 ; i ++)
{
chtem = (unsigned char)(data >> (32 - (i + 1) * 3) & 0x00000007);
array[i] = chtem;
}
chtem = (unsigned char)(data & 0x0000001F);
array[chtem] = 8;
}

由于可扩展的数据量非常的大，加上在保存的时候使用的是DWORD类型，将每一步数据都记录在一个排序二叉树中，按从小到大从左到有的排列，搜索的时候跟每次搜索将近万次的形式比较快几乎是N次方倍，把几个在循环中用到的函数声明为内联函数，并在插入的时候同时搜索插入的数据会不会在树中有重复来加快总体速度。二叉树插入代码：

inline bool CNineGird::AddTree(DWORD place , PlaceList*& parent)
{
if (parent == NULL)
{
parent = new PlaceList();
parent->Left = parent->Right = NULL;
parent->Place = place;
return true;
}
if (parent->Place == place)
return false;

if (parent->Place > place)
{
return AddTree(place , parent->Right);
}
return AddTree(place , parent->Left);
}

计算结果是奇数排列还是偶数排列的代码：

bool CNineGird::EstimateUncoil(unsigned char *array)
{
int sun = 0;
for ( int i = 0 ; i < 8 ; i ++)
{
for ( int j = 0 ; j < 9 ; j ++)
{
if (array[j] != 0)
{
if (array[j] == i +1 )
break;
if (array[j] < i + 1)
sun++;
}
}
}
if (sun % 2 == 0)
return true;
else
return false;
}

移动到空格位的代码比较简单，只要计算是否会移动到框外面就可以了，并在移动的时候顺便计算一下是不是已经是目标结果，这是用来给用户手工移动是给与提示用的，代码：

inline bool CNineGird::MoveChess(unsigned char *array , int way)
{
int zero , chang;
bool moveok = false;
for ( zero = 0 ; zero < 9 ; zero ++)
{
if (array[zero] == 0)
break;
}
POINT pnt;
pnt.x = zero % 3;
pnt.y = int(zero / 3);
switch(way)
{
case 0 : //up
if (pnt.y + 1 < 3)
{
chang = (pnt.y + 1) * 3 + pnt.x ;
array[zero] = array[chang];
array[chang] = 0;
moveok = true;
}
break;
case 1 : //down
if (pnt.y - 1 > -1)
{
chang = (pnt.y - 1) * 3 + pnt.x ;
array[zero] = array[chang];
array[chang] = 0;
moveok = true;
}
break;
case 2 : //left
if (pnt.x + 1 < 3)
{
chang = pnt.y * 3 + pnt.x + 1;
array[zero] = array[chang];
array[chang] = 0;
moveok = true;
}
break;
case 3 : //right
if (pnt.x - 1 > -1)
{
chang = pnt.y * 3 + pnt.x - 1;
array[zero] = array[chang];
array[chang] = 0;
moveok = true;
}
break;
}
if (moveok && !m_bAutoRun)
{
m_iStepCount ++ ;

DWORD temp1 ,temp2;
ArrayToDword(array , temp1);
ArrayToDword(m_iTargetChess , temp2);
if (temp1 == temp2)
{
MessageBox(NULL , "你真聪明这么快就搞定了!" , "^_^" , 0);
}
}
return moveok;
}

在进行广度搜索时候，将父结点所在的数组索引记录在子结点中了，所以得到目标排列的时候，只要从子结点逆向搜索就可以得到最优搜索路径了。用变量m_iPathsize来记录总步数，具体函数代码：

void CNineGird::GetPath(UINT depth)
{
int now = 0 , maxpos = 100 ;
UINT parentid;
if (m_pPathList != NULL)
{
delete[] m_pPathList;
}
m_pPathList = new PathList[maxpos];
parentid = m_pScanbuf[depth].ScanID;

DwordToArray(m_pScanbuf[depth].Place , m_pPathList[++now].Path);

while(parentid != -1)
{
if (now == maxpos)
{
maxpos += 10;
PathList * temlist = new PathList[maxpos];
memcpy(temlist , m_pPathList , sizeof(PathList) * (maxpos - 10));
delete[] m_pPathList;
m_pPathList = temlist;
}
DwordToArray(m_pScanbuf[parentid].Place , m_pPathList[++now].Path);
parentid = m_pScanbuf[parentid].ScanID;
}
m_iPathsize = now;
}

动态排列的演示函数最简单了，为了让主窗体有及时刷新的机会，启动了一个线程在需要主窗体刷新的时候，用Slee（UINT）函数来暂停一下线程就可以了。代码：

unsigned __stdcall MoveChessThread(LPVOID pParam)
{
CNineGird * pGird = (CNineGird *)pParam;
RECT rect;
pGird->m_iStepCount = 0;
::GetClientRect(pGird->m_hClientWin , &rect);
for ( int i = pGird->m_iPathsize ; i > 0 ; i --)
{
memcpy(pGird->m_iChess , pGird->m_pPathList[i].Path , 9);
pGird->m_iStepCount ++;
InvalidateRect( pGird->m_hClientWin , &rect , false);
Sleep(300);
}
char msg[100];
sprintf(msg , "^_^ ! 搞定了!\r\n计算步骤用时%d毫秒" , pGird->m_iTime);
MessageBox(NULL , msg , "~_~" , 0);
pGird->m_bAutoRun = false;
return 0L;
}

最后介绍一下搜索函数的原理，首先得到源数组，将其转换成DWORD型，与目标比较，如果相同完成，不同就交换一下数据和空格位置，加入二叉树，搜索下一个结果，直到没有步可走了，在搜索刚刚搜索到的位置的子位置，这样直到找到目标结果为止，函数：

bool CNineGird::ComputeFeel()
{
unsigned char *array = m_iChess;
UINT i;
const int MAXSIZE = 362880;
unsigned char temparray[9];

DWORD target , fountain , parent , parentID = 0 , child = 1;
ArrayToDword(m_iTargetChess , target);
ArrayToDword(array , fountain);
if (fountain == target)
{
return false;
}
if (m_pScanbuf != NULL)
{
delete[] m_pScanbuf;
}
m_pScanbuf = new Scanbuf[MAXSIZE];
AddTree(fountain ,m_pPlaceList);
m_pScanbuf[ 0 ].Place = fountain;
m_pScanbuf[ 0 ].ScanID = -1;
clock_t tim = clock();
while(parentID < MAXSIZE && child < MAXSIZE)
{
parent = m_pScanbuf[parentID].Place;
for ( i = 0 ; i < 4 ; i ++) // 0 :UP , 1:Down ,2:Left,3:Right
{
DwordToArray(parent , temparray);
if (MoveChess(temparray,i)) //是否移动成功
{
ArrayToDword(temparray , fountain);
if (AddTree(fountain, m_pPlaceList)) //加入搜索数
{
m_pScanbuf[ child ].Place = fountain;
m_pScanbuf[ child ].ScanID = parentID;
if (fountain == target) //是否找到结果
{
m_iTime = clock() - tim;
GetPath(child);//计算路径
FreeTree(m_pPlaceList);
delete[] m_pScanbuf;
m_pScanbuf = NULL;
return true;
}
child ++;
}
}
} // for i
parentID++;
}
m_iTime = clock() - tim;

FreeTree(m_pPlaceList);
delete[] m_pScanbuf;
m_pScanbuf = NULL;
return false;
}

重要函数的介绍结束;下面是程序的运行结果和运算结果：

❻ C++编写九宫格程序，要求和为15

#include <iostream>
using namespace std;
void main()
{
int a[3][3];
int flag=1,hang=0,lie=0,zhengxie=0,fanxie=0;
cout<<"please input "<<endl;
for(int i=0,j=0;i<3&&j<3;i++,j++)
{
cout<<"第"<<i+1<<"行"<<endl;
for(int j=0;j<3;j++)cin>>a[i][j];
}
cout<<"你输入的九宫格为"<<endl;
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)cout<<" "<<a[i][j];
cout<<endl;
}

//检验
for(int i=0;i<3;i++)
{
hang=0;
lie=0;

fanxie+=a[i][3-1];//饭斜对
zhengxie+=a[i][i];//正斜对角线之和
for(int j=0;j<3;j++)
{

hang+=a[i][j]; //行
lie=lie+a[j][i];//列

}
if(hang!=15){flag=0;break;}
if(lie!=15){flag=0;break;}

}

if(flag!=0 && zhengxie==15 && fanxie==15)cout<<"合乎九宫格"<<endl;
else cout<<"不符合九宫格"<<endl;
system("pause");
}

❼ 编写一个九宫格程序

var
z,a,b,c,d,e,f,g,h,i:longint;begin
for a:=1to 9do
for b:=1to 9do
if(a<>b)then
for c:=1to 9do
if(a<>c)and(b<>c)then
for d:=1to 9do
if(a<>d)and(b<>d)and(c<>d)then
for e:=1to 9do
if(a<>e)and(b<>e)and(c<>e)and(d<>e)then
for f:=1to 9do
if(a<>f)and(b<>f)and(c<>f)and(d<>f)and(e<>f)then
for g:=1to 9do
if(a<>g)and(b<>g)and(c<>g)and(d<>g)and(e<>g)and(f<>g)then
for h:=1to 9do
if(a<>h)and(b<>h)and(c<>h)and(d<>h)and(e<>h)and(f<>h)and(g<>h)then
begin
i:=45-a-b-c-d-e-f-g-h;
if(a+b+c=15)and(d+e+f=15)and(g+h+i=15)and(a+d+g=15)and(b+e+h=15)and(c+f+i=15)and(a+e+i=15)and(c+e+g=15)
then begin
inc(z);
writeln(z,':');
writeln(a,' ',b,' ',c);
writeln(d,' ',e,' ',f);
writeln(g,' ',h,' ',i);
end;
end;
writeln(z);
end.

❽ 求九宫格算发，即1到9填到格子里，横竖斜加起来等于12

给你一个思路，此思路不仅能解决3*3的格子相加的问题。
还能解决
5*5
7*7
9*9
等等奇数个格子的问题，以此类推。。。
这就是任意奇阶幻方的构造法，中国早在大禹治水的时候就已经发现了这个规律的。宋代数学家杨辉更有总结：“九子排列，上下对易，左右相更，四维挺出。”，闲话不说，开始吧：
我们以
3*3
为例，一共有9个格子，就是九宫格了。
那么我们要填写1~9
共9个数字。
我们用
r
表示行，c
表示列。例如
r9c7
就表示第9行第7列
首先，把
“1”填写到第一列，中间行的一个格子。对于3*3的格子来说就是
r2c1
好了，其他的数字只要按照以下规律填写就可以了：
从1开始，按顺序把其他数字填写在上一个数字的左上角。如果遇到左上角已经被填写，就填写在同一行的右边一个格即可，然后继续左上角。。。。注意：把上下左右看作是连接起来的
例如：现在3*3的格子。我们把“1”填写在
r2c1
那么“2”就应该填写在r2c1的左上角，也就是纵坐标和横坐标各减“1”，即，填写“2”的格子的坐标就是
r1c0
可是没有c0
这个列啊，刚才我们讲了，把左右看成是链接起来的。也就是可以吧
c3
看成是c0，那么我们就找到了“2”该填写的地方，也就是
r1c3，然后再来填写“3”，把上下看成是链接起来的，就应该把“3”填写在
r3c2，然后“4”应该填写在
r2c1，但是这个时候r2c1已经填写了“1”了，所以我们按照规则，把他填写在右边，就是在“3”的右边，即r3c3，接着又把“5”填写在
r2c2
以此类推就能得到正确结果。。。。。
填写好的形式如下：
6
7
2
1
5
9
8
3
4
建议你参考一下数学上面的“罗伯幻方”，这是中国在n年前就解决了的数学问题
程序写起来非常简单，我就不给你写了，你自己想想怎么写吧，实在不会写再来找我帮你写。

❾ 九宫格VC代码

这是数独啊，就是下面的图片所示，9*9的格，你还要输出所有的数独？你知道有6,670,903,752,021,072,936,960种不同的数独，就算计算机（运行效率极高的计算机）每秒生成10个数独你可以算算要几千年哈。具体的可以去看网络的网络，下面有一个用Pascal写的求数独的程序。

下面是有C++写的随机生成数独的算法，你要的输出所有数独在时间上来说是不可能的哈：

#ifndefSUDOKU_RICK_0701_

#defineSUDOKU_RICK_0701_

classCSudoku

{

intmap[9][9];

intsmod;

intsolves;

intcheck(int,int,int*);

voiddfs();

public:

enum{ANY=0,ALL=1};

CSudoku(intn=40);//随机生成数独,n越大越难

CSudoku(int*data);//人工指定数独

virtual~CSudoku();

voiddisplay();//显示数独

intresolve(intmod=ALL);//解数独

};

#endif

//#include"sudoku.h"

#include"stdio.h"

#include"stdlib.h"

#include"time.h"

CSudoku::CSudoku(intn)

{

inti,j;

srand(time(0));

do

{

for(i=0;i<9;++i)

{

for(j=0;j<9;++j)

map[i][j]=0;

j=rand()%9;

map[i][j]=i+1;

}

}

while(!resolve(ANY));

//挖窟窿

for(intk=0;k<n;)

{

i=rand()%81;

j=i%9;

i=i/9;

if(map[i][j]>0)

{

map[i][j]=0;

++k;

}

}

//printf("(randomizedsudokucreatedwith%dblanks.) ",blanks);

}

CSudoku::CSudoku(int*data)

{

int*pm=(int*)map;

for(inti=0;i<81;++i)

pm[i]=data[i];

}

CSudoku::~CSudoku()

{

return;

}

voidCSudoku::display()

{

for(inti=0;i<9;++i)

{

for(intj=0;j<9;++j)

{

if(map[i][j]>0)

printf("<%d>",map[i][j]);

else

printf("[]");

}

printf(" ");

}

}

intCSudoku::resolve(intmod)

{

smod=mod;

if(mod==ALL)

{

solves=0;

dfs();

returnsolves;

}

elseif(mod==ANY)

{

try

{

dfs();

return0;

}

catch(int)

{

return1;

}

}

return0;

}

intCSudoku::check(inty,intx,int*mark)

{

inti,j,is,js,count=0;

for(i=1;i<=9;++i)

mark[i]=0;

for(i=0;i<9;++i)

mark[map[y][i]]=1;

for(i=0;i<9;++i)

mark[map[i][x]]=1;

is=y/3*3;

js=x/3*3;

for(i=0;i<3;++i)

{

for(j=0;j<3;++j)

mark[map[is+i][js+j]]=1;

}

for(i=1;i<=9;++i)

if(mark[i]==0)

count++;

returncount;

}

voidCSudoku::dfs()

{

inti,j,im=-1,jm,min=10;

intmark[10];

for(i=0;i<9;++i)

{

for(j=0;j<9;++j)

{

if(map[i][j])

continue;

intc=check(i,j,mark);

if(c==0)

return;

if(c<min)

{

im=i;

jm=j;

min=c;

}

}

}

if(im==-1)

{

if(smod==ALL)

{

printf("No.%d: ",++solves);

display();

return;

}

elseif(smod==ANY)

{

throw(1);

}

}

check(im,jm,mark);

for(i=1;i<=9;++i)

{

if(mark[i]==0)

{

map[im][jm]=i;

dfs();

}

}

map[im][jm]=0;

}

#include<iostream>

//#include"sudoku.h"

usingnamespacestd;

intmain()

{

intdata1[]=

{4,9,0,0,0,6,0,2,7,

5,0,0,0,1,0,0,0,4,

6,0,0,0,0,8,0,0,3,

1,0,4,0,0,0,0,0,0,

0,6,0,0,0,0,0,5,0,

0,0,0,0,0,0,2,0,8,

7,0,0,2,0,0,0,0,5,

8,0,0,0,9,0,0,0,1,

3,4,0,5,0,0,0,6,2

};

intdata2[]=

{7,4,0,0,8,0,0,1,6,

9,0,0,0,3,5,0,0,4,

0,0,0,7,0,0,0,0,0,

0,7,0,0,0,9,5,0,0,

6,1,0,0,5,0,0,8,7,

0,0,2,6,0,0,0,4,0,

0,0,0,0,0,4,0,0,0,

3,0,0,5,6,0,0,0,2,

5,6,0,0,1,0,0,3,9

};

intdata3[]=

{

0,0,3,0,0,0,0,0,4,

9,0,0,0,0,3,0,5,0,

2,0,0,7,0,0,0,0,0,

0,8,0,0,1,0,0,0,6,

0,3,0,2,0,0,0,9,0,

4,0,0,0,0,0,0,1,0,

0,0,0,0,0,8,0,0,3,

0,6,0,9,0,0,0,0,8,

5,0,0,0,0,0,2,0,0

//0,3,0,9,0,0,0,1,0,

//0,8,0,0,0,0,0,7,0,

//7,0,2,4,0,0,9,0,0,

//0,7,0,0,1,0,0,4,0,

//1,0,0,0,0,6,0,0,9,

//0,6,0,0,0,0,0,3,0,

//0,0,8,0,0,9,5,0,3,

//0,1,0,0,0,0,0,9,0,

//0,9,0,0,0,2,0,6,0

};

intblanks;

cout<<"随机生成一个数独,输入空格数";

cin>>blanks;

CSudokus(blanks);

s.display();

cout<<"开始解数独:"<<endl;

s.resolve();

cout<<"解数独:"<<endl;

CSudokut(data3);

t.display();

cout<<"开始解数独:"<<endl;

t.resolve(1);

return0;

}

❿ 用c语言编写程序将1到9分别填入九宫格使得每行每列,对角和相等

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
main()
{
#define n 3
int a[n][n]={0},i,sum=0,j;
i=0;j=n/2;
a[0][j]=++sum;
while(sum<n*n+1)
{i--;j++;
if(i<0&&j>=n)
{i=i+2;j--;}
else
{if(i<0)
i=n-1;
if(j>=n)
j=0;
}
if(a[i][j]==0)
a[i][j]=++sum;
else
{
i=i+2;
j--;
a[i][j]=++sum;
continue;}
}
for(i=0;i<n;i++)
{for(j=0;j<n;j++)
printf("%5d",a[i][j]);
printf("\n");}
getch();
}