九宫图算法

最新推荐文章于 2023-07-06 09:06:48 发布
最新推荐文章于 2023-07-06 09:06:48 发布
阅读量1.2w 收藏
点赞数
文章标签： 算法 function null

///
// 九宫图算法；
//

#include<stdio.h>
#include<time.h>
#include<stdlib.h>

//
     the function defination
//

void create(int [][3]);
void show(int [][3]);
void set_value(int [][3]);
void aim_get(int [][3]);
void target(int [][3]);
void judge_x1(int [][3]);
void judge_x2(int [][3]);
void judge_x3(int [][3]);
void judge_x4(int [][3]);
void judge_x5(int [][3]);
void shift_all(int [][3]);
void shift_low_six(int [][3]);
void anti_shift_all(int [][3]);
void shift_low_four(int [][3]);
void last_shift(int [][3]);
void set_x5(int [][3]);

///
//    the main function body 

main()
{
 
 srand(time(NULL));
 int cDiagram[3][3];
 create(cDiagram);     ///   creat the new array ,set the value are 10;
 set_value(cDiagram);
 //last_shift(cDiagram);
 return 0;
}

///
///  建立一个3*3数组，初值都设为10；//
//

void create(int array[][3])
{
 printf("/n/n***********************************/n/n");
    printf("九宫图算法实现过程/n/n");
 printf("***********************************/n/n");
 
    int line;
 int row;
 
 for(line=0;line<3;line++)
 {
  for(row=0;row<3;row++)
  {
   array[line][row]=10;
  }
 }
    // set_value(array);
 //show(array);
}

/
///  显示数组状态 

void show(int array[][3])
{  
 for(int i=0;i<3;i++)
 {
  for(int j=0;j<3;j++)
  {
   printf("%3d",array[i][j]);
   
  }
  printf("/n/n");
 }
 
 
}

///
/// 产生数组的初始状态  ///
///

void set_value(int array[][3])
{
 int i=0;
 int rand_num_line;
    int rand_num_row;
 
 printf("    /n/n九宫图的初始值为：/n/n");
 
 while(i<=8)
 {
  rand_num_line=rand()%3;
  rand_num_row=rand()%3;
  
  if(array[rand_num_line][rand_num_row]!=i&& array[rand_num_line][rand_num_row]==10)
  {
   array[rand_num_line][rand_num_row]=i;
   ++i;
  }
  
 }
 
 show(array);
 //printf(" let's begin!!/n");
    aim_get(array);
}


  judge the initial array get the target or no !  ///
//


void aim_get(int array[][3])
{
 int aim[3][3]={{1,2,3},{8,0,4},{7,6,5}};
 int line;
 int row;
 int judge=0;
 for(line=0;line<3;line++)
 {
  for(row=0;row<3;row++)
  {
   if(array[line][row]!=aim[line][row])
   {
    judge=1;
   }
  }
 }
 if(judge==1)
 {
  judge_x1(array);
 }
 else
 {
  target(array);
  
  
 }
}


/
/// the target diagram //
/


void target(int array[][3])
{
 printf("/n/n     the last diagram is :/n");
 show(array);
}



///judge the x1 is 1 or no!  ///

void judge_x1(int array[3][3])
{
 //int x1=1;
 
 int temp;
 //printf("  /n/n/n the array[0][2]=%d/n/n",array[0][2]);
 
 if(array[0][2]!=1 && array[0][2]!=0)              // x3!=1 || x3!=0;
 {
  
  while(array[0][0]!=1)
  {  
   //printf("i am here!!1");
   temp=array[0][0];
   array[0][0]=array[0][1];
   array[0][1]=array[1][1];
   array[1][1]=array[1][2];
   array[1][2]=array[2][2];
   array[2][2]=array[2][1];
   array[2][1]=array[2][0];
   array[2][0]=array[1][0];
   array[1][0]=temp;
  }
 }
 else
 {     
  
  if(array[0][2]==0)                       // x3==0;
  {
   // printf("/n/n array[0][2]=0/n/n");
   temp=array[0][2];
   array[0][1]=array[0][2];
   array[0][2]=temp;
   judge_x1(array);
   goto tt;
  }
  else                                    /// x3==1;
  {   //printf("/n/narray[0][2] should is 1,   %d",array[0][2]);
   if(array[1][1]==0)                  x0==0;
   {
    temp=array[0][1];
    array[0][1]=array[1][1];
    array[1][1]=temp;
    judge_x1(array);
   }
   else                                x3==1 && x0!=0;
   {   
    shift_all(array);
    judge_x1(array);
   }
   
  }
 }
 printf("  确定了X1位置后，九宫图为：/n");
 show(array);
 judge_x2(array);
tt:
 int p=1;
}


//
/// judge the x2's position /
//

void judge_x2(int array[][3])
{
 int temp;
 
 while(array[0][1]!=2)
 {
  temp=array[0][1];
  array[0][1]=array[0][2];
  array[0][2]=array[1][2];
  array[1][2]=array[2][2];
  array[2][2]=array[2][1];
  array[2][1]=array[2][0];
  array[2][0]=array[1][0];
  array[1][0]=array[1][1];
  array[1][1]=temp;
 }
 printf("  确定了X2位置后,九宫图为: /n");
 show(array);
 judge_x3(array);
 
}


///
/       shift from array[1][0] to array[2][2] 
///

void shift_low_six(int array[][3])
{
 int temp;
 temp=array[1][0];
 array[1][0]=array[1][1];
 array[1][1]=array[1][2];
 array[1][2]=array[2][2];
 array[2][2]=array[2][1];
 array[2][1]=array[2][0];
 array[2][0]=temp;
 
 
}

 


   shift from array[0][0]  to array[2][2]  /

void shift_all(int array[][3])
{
 int temp;
 
 temp=array[0][0];
 array[0][0]=array[0][1];
 array[0][1]=array[0][2];
 array[0][2]=array[1][2];
 array[1][2]=array[2][2];
 array[2][2]=array[2][1];
 array[2][1]=array[2][0];
 array[2][0]=array[1][0];
 array[1][0]=temp;
}

 

//
/// shift aiti-direction ///

void anti_shift_all(int array[][3])
{
 int temp;
 
    temp=array[1][0];
 array[1][0]=array[2][0];
 array[2][0]=array[2][1];
 array[2][1]=array[2][2];
 array[2][2]=array[1][2];
 array[1][2]=array[0][2];
 array[0][2]=array[0][1];
 array[0][1]=array[0][0];
 array[0][0]=temp;       
}

//
/      judge x3's position     ///
//

void judge_x3(int array[][3])
{
 
 int line;
 int row;
 int temp;
 if(array[0][2]!=3)
 {
  while(array[1][1]!=3)                      // shift the int ,untill 3 stay in x0
  {
   shift_low_six(array);
  }
  for(int i=0;i<=2;i++)
  {
   for(int j=0;j<=2;j++)
   {
    if(array[i][j]==0)
    {
     line= i;
     row=j;
    }
   }
  }
  if(line==0&&row==2)
  {
            shift_all(array);
   
  }
  else if(line==1&&row==2)
  {
   shift_all(array);
   temp=array[0][1];
   array[0][1]=array[0][2];
   array[0][2]=temp;
  }
  else if(line==2&&row==2)
  {
   shift_all(array);
   temp=array[1][2];
   array[1][2]=array[0][2];
   array[0][2]=array[0][1];
   array[0][1]=temp;
  }
  else if(line==2&&row==1)
  {
   shift_all(array);
   temp=array[2][2];
   array[2][2]=array[1][2];
   array[1][2]=array[0][2];
   array[0][2]=array[0][1];
   array[0][1]=temp;
  }
  else if(line==2&&row==0)
  {
   array[2][0]=array[1][0];
   array[1][0]=array[0][0];
   array[0][0]=array[0][1];
   array[0][1]=0;
  }
  else
  {
   array[1][0]=array[0][0];
   array[0][0]=array[0][1];
   array[0][1]=0;
  }
  
  array[0][1]=3;
  array[1][1]=0;
  anti_shift_all(array);
 }
 
 printf("   确定了X3位置后，九宫图为：/n");
 show(array);
 judge_x4(array);
}


//
//   judge x4's position    ///
/


void judge_x4(int array[][3])
{
 while(array[1][2]!=4)
 {
  shift_low_six(array);
 }
 printf("  确定了X4位置后，九宫图为：/n");
 show(array);
 judge_x5(array);
}
/
//    shift_low_four    /
/
void shift_low_four(int array[][3])
{
 int temp;
 
 temp=array[1][1];
 array[1][1]=array[2][1];
 array[2][1]=array[2][0];
    array[2][0]=array[1][0];
    array[1][0]=temp;
 
}
//
//     judge x5's position     ///
//
void judge_x5(int array[][3])
{
 if(array[2][2]==0)
 {
  while(array[1][1]!=5)
   shift_low_four(array);
  shift_all(array);
  set_x5(array);
 }
 else if(array[2][2]!=5)
 {  
  while(array[1][1]!=5)
   shift_low_four(array);
  if(array[2][1]==0)
  {
   shift_all(array);
   array[2][2]=array[1][2];
   set_x5(array);
  }
  else if(array[2][0]==0)
  {
   shift_all(array);
   array[2][1]=array[2][2];
   array[2][2]=array[1][2];
   set_x5(array);
  }
  else if(array[1][0]==0)
  {
   shift_all(array);
   array[2][0]=array[2][1];
   array[2][1]=array[2][2];
   array[2][2]=array[1][2];
   set_x5(array);
   
  }
 }
 
 printf("  确定了X5位置后，九宫图为：/n");
 show(array);
 last_shift(array);
 
}


void set_x5(int array[][3])
{
 array[1][2]=5;
    array[1][1]=0;
    anti_shift_all(array);
}
/*
void judge_x7(int array[][3])
{
if(array[2][2]!=0 || array[2][2]!=5)    //x5!=0||x5!=5
{  
while(array[1][1]!=5)             
{
shift_low_four(array);
}
if(array[2][1]==0)
{
shift_all(array);
array[2][2]=array[1][2];
array[1][2]=0;
}
else
if(array[2][0]==0)
{
shift_all(array);
array[2][1]=array[2][2];
array[2][2]=array[1][2];
array[1][2]=0;

  }
 
 else
 {
    if(array[1][0]==0)
    {
 array[1][0]=array[0][0];
 array[0][0]=array[0][1];
 array[0][1]=array[0][2];
 array[0][2]=array[1][2];
 array[1][2]=0;   
    }
 }
 array[1][2]=5;
 array[1][1]=0;
 printf("/nthe array[2][1]=%d/n",array[2][1]);
 show(array);
 //anti_shift_all(array);
 printf("/nthe array[2][1]=%d/n",array[2][1]);
 
   }
   else   
   if(array[2][2]==0)               //x5==5
   {
   while(array[2][1]!=5)
   {
   shift_low_four(array);
   }
   array[2][2]=5;
   array[2][1]=0;
   }
   }
   printf("  确定了X5位置后，九宫图为：/n");
   show(array);
   last_shift(array);
*/

/
///         last_shift   ///
// to determine the last four numbers//
/  x6,x7,x8,x0         
/

void last_shift(int array[][3])
{  
 int temp;
 while(array[2][1]!=6)
 {
  shift_low_four(array);
 }
 
 if(array[1][1]!=0)
 {
  if(array[1][0]==0)
  {
   temp=array[1][0];
   array[1][0]=array[1][1];
   array[1][1]=temp;
  }
  else
  {
   array[2][0]=array[1][0];
   array[1][0]=array[1][1];
   array[1][1]=0;
  }
 }
 
 printf("***********************************/n");
 printf("***********************************/n/n");
 printf("  经过计算，最终的九宫图为: /n");
 show(array);
 if(array[2][0]==7)
 {
  
  printf("****************************/n");
  printf("**  此为九宫图的最终解！  **/n");
  printf("****************************/n");
 }
    else
 {
  printf("****************************/n");
  printf("**  对不起，此无解九宫图！**/n");
  printf("****************************/n");
 }
 
}

 

iu_81
关注
A*算法九宫图
12-28
A*算法解九宫图，可以计算时间，和执行的可行性。输入原图，得到目的图
九宫图计算九宫图计算九宫图计算九宫图计算九宫图计算九宫图计算九宫图计算九宫图计算九宫图计算九宫图计算九宫图计算九宫图,计算九宫图,计算九宫图计算九宫图计算九宫图计算九宫图计算
06-04
九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode九宫图计算九宫图计算九宫图计算,soursecode
我的九宫格算法
guokeno1－－JEFF的技术博客
09-23 3053
//GUOKE000 21:56:43#include #include #include /*九宫格的数据结构*/typedef struct nodetype{ char elements[9]; struct nodetype *mother;/*指向母亲节点*/ struct nodetype *nchild;/*东西南北四个方向上的孩子节点*/ struct nodetype *
VC 九宫图算法(递归算法).rar
07-10
VC 使用递归算法生成九宫图，控制台程序，只是演示如何计算出九宫图，程序比较小，不过挺精确，值得一看。
jiugongtu.rar_九宫图_九宫图算法
09-21
在现代计算机科学中，九宫图被广泛应用于逻辑思维训练、游戏设计以及算法实现等多个领域。本资源包含的"jiugongtu.rar"是一个关于九宫图算法的压缩包，主要提供了算法的源码和相关的文本文档，方便用户理解和应用。 ...
九宫算法 九宫算法
07-31
九宫算法，也被称为“数独”或者“拉丁方块”，是一种源于中国古代的数学游戏，其目标是在一个3x3的宫格内填入数字1到9，使得每一行、每一列以及每个小3x3的宫格内的数字都不重复。这种算法在现代被广泛应用于逻辑...
九宫阵算法
12-25
在本篇中，我们将深入探讨如何实现九宫阵的算法，特别是通过回溯法来解决这一问题。 一、九宫阵的基础概念 九宫阵是由9个小的3x3的子网格构成的3x3的大网格。每个小网格内有9个单元格，总计81个单元格。目标是将1到...
搜索算法解决九宫重排问题
12-02
首先，广度优先搜索是一种用于遍历或搜索树或图的算法。在九宫重排问题中，我们可以将每个可能的九宫格状态视为一个节点，每一步操作（比如改变一个格子的数字）作为边，从初始状态开始，BFS会按照“先来后到”的...
九宫图的启发式和广度优先算法
11-03
九宫图的启发式搜索算法程序和广度搜索算法程序及报告
倩女幽魂藏宝洞九宫图计算器《工具+源代码》
12-08
给倩女幽魂Online2的玩家提供一项便利，工具描述：在109一条大闹宝藏洞中计算九宫图任务试用方便计算，并附赠源代码，有精力的同仁可以一起研究优化，注意使用VS2013以上版本打开。
九宫格的计算
诠释完美
07-17 2794
说明： (1).黄色框代表父控件 (2).红色方块代表子控件 (3).绿色框代表列宽 (4).蓝色框代表行高 (5).0-8数字代表索引 九宫格的计算方式： (1).自定义一些变量 列数 = 自定义 子控件宽 = 自定义 子控件高 = 自定义 (2).计算列宽和行高 列宽 = (父控件的宽 - 子控件宽 * 列数) / (列数 - 1) 行高 = 自定义 (3
基于D3D技术实现的九宫格算法绘制图片
jujueduoluo的专栏
12-09 1598
九宫格示意图： 下面是代码实现： #include #include #include #include #pragma comment(lib, "D3D9.lib") #pragma comment(lib, "D3dx9.lib") #define D3D_FVF_VECTOR (D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1
简单九宫格算法
JAVA
07-09 3012
/** * */ package com.test; public class ShuDu { static boolean next(int[][] n, int i, int j) { // 寻找需填充的格子 while (n[i][j] != 0) { if (j < 8) j++; else if (i < 8) { i
九宫算
Leibnezz的博客
12-04 4560
**神龟背洛书，龙马载河图。**九宫算由来已久，《数术记遗》中首称九宫。南北朝甄鸾批注：“九宫者，二四为肩，八六为足，左三右七，戴九履一，五居中央。” ...
转：九宫图算法对屏幕监控软件的精准度分析及应用场景
最新发布
MOMO203010532的博客
07-06 228
总的来说，九宫图算法在屏幕监控软件中可以实现对屏幕图像的精准度分析，通过比较不同区域的像素值和颜色差异，判断位置关系和识别目标。它适用于监控系统、用户界面交互和游戏开发等场景，提供精准度分析和位置判断的功能。九宫图算法（Nine-grid algorithm）是一种用于屏幕监控软件的图像处理算法，通过将屏幕分割成九个等大小的网格区域，并对每个区域进行像素值的分析和比较，从而实现对屏幕图像的精准度分析。
用两种方法求解九宫算问题
06-28 2779
问题：在一个3*3的方格内填入9个数字，数字的范围从1~9，每个数字仅出现一次，使得每行、每列以及两个对角线的数字之和为15。 一、VBA程序算法思路：1、将9个数字分成3组，每组3个数字，使得每组数字之和为15。2、将第二个数字为5个分组单独选出，作为方格的第二行数组。3、循环抽取其它的分组，与第二分组进行重复性判断。4、如果没有重复，记录这3种分组。5、将这3种分组传人判断函数，核实是否满足条...
关于九宫图的处理
我想问问天的专栏
05-09 1291
问题：在引入项目的图片后，运行项目报错 AAPT err(1304209106): Frame pixels must be either solid or transparent (not intermediate alphas).  AAPT err(1304209106): Found at pixel #58 along top edge.  报错的原因是一张图片
【算法口诀】记不住算法流程，写成歌谣朗朗上口
三川小哥 狂想曲
03-20 1087
文章目录1. dijkstra 最短路径法2. potential filed 人工势场法3. 置信域优化算法4. 泰勒展开5. A* 算法 1. dijkstra 最短路径法 单源最短路径法，当前最短永最短。 起点所有子方向，全部加入活集中 从中找出最小点，等于目标就退出。 不同加入死集中，把他子路加活集。 重复活集找最小，凡入死集皆最小。 2. potential filed 人工势场法 目标...
广度优先算法实现九宫重排
05-15
九宫重排问题可以使用广度优先搜索算法来解决。下面是算法的实现过程： 1. 定义状态：首先需要定义状态，这里将九宫重排问题看作一个状态空间，每个状态都是一个 $3\times3$ 的矩阵，表示当前九宫格的状态。 2. ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值