三叉树解2011年度最变态的迷宫难题

最新推荐文章于 2022-11-26 08:30:00 发布
最新推荐文章于 2022-11-26 08:30:00 发布
阅读量719 收藏 1
点赞数
分类专栏： 原创 算法 文章标签： null tree struct archive matrix blog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alphabuilder/article/details/7200489
版权

 

        问题出处：Matrix67: My Blog ? Blog Archive ? 2011年度最变态的迷宫难题

        问题描述：“下面大家将会看到的是一个极其简单而又极其复杂的“迷宫”，这无疑是我在本年度见到的最变态的谜题：从左边入口处的 2011 进去，在迷宫里转悠，最后变成 2012 从右边出来。你可以在迷宫里转圈，可以重复之前走过的路，但不能往回退着走。”

       

       你能成功走出来吗？

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

 .

答案：2011+7/2+7/2+7-5*3/2+7/2+7*3-5/2+7/2+7-5*3-5*3/2+7-5*3/2+7-5=2012

 

        用三叉树解一下。如果不设终止条件直接建树很快就会溢出，所以设定了树的深度和计算值两个终止条件。计算值终止条件设为值大于10000或小于-10000终止子树搜索。具体搜索过程从左向右经过加7路径后偶数有三条路径：÷2，×3，-5；奇数有两条路径：×3，-5。从右向左经过+7路径后只有一条路径：÷2。从左向右经过÷2路径后有三条路径：+7，×3，-5。从右向左经过÷2路径后只有一条路径：+7。从左向右经过×3路径后只有一条路径：-5。从右向左经过×3路径后偶数有三条路径：+7，÷2，-5；奇数有两条路径：+7，-5。从左向右经过-5路径后是2012找到结果，否则只有一条路径：×3。从右向左经过-5路径后偶数有三条路径：+7，÷2，×3；奇数有两条路径：+7，×3。

       因为2012不能被3整除所以满足条件的结果最后只能是自左向右经过-5的路径。找到结果后利用parent指针标记自根下来的路径用于显示结果。

/* 三叉树求解2011年度最变态的迷宫难题 */
#include <stdio.h>
#include <conio.h>
#include <malloc.h>

typedef struct tagtree
{
   char op;
    int value;
 struct tagtree *parent;
 struct tagtree *lchild;
 struct tagtree *mchild;
 struct tagtree *rchild;
}tree;              

#define Alloctree ((tree *)malloc(sizeof(tree)))

void createchild(tree **parent, int level);
void destory(tree **root);
void markroute(tree *treenode);

int finded = 0; /* 全局变量，找到结果的标记 */
int MAXDEPTH;   /* 全局变量，搜索深度 */

int main(void)
{
 tree *root;
 tree *p;

 for (MAXDEPTH = 5; MAXDEPTH <= 150; MAXDEPTH += 5)
  {	 
   finded = 0;	 
   root = Alloctree;
   root->value = 2011;
   root->op = 0;
   root->lchild = Alloctree;
   root->mchild = NULL;
   root->rchild = NULL;
   root->lchild->lchild = NULL;
   root->lchild->mchild = NULL;
   root->lchild->rchild = NULL;
   root->lchild->parent = root;
   root->lchild->value = 2018;
   root->lchild->op = 1;
  
   createchild(&(root->lchild), 2);
   if (finded)
    {
     printf("\n2011");
     p = root->lchild;
     while(1)
      {	
       if ((p-> op & 0xf) == 1 || (p-> op & 0xf) == 2)
        printf("+7");
       else if ((p-> op & 0xf) == 3 || (p-> op & 0xf) == 4)
        printf("/2");
       else if ((p-> op & 0xf) == 5 || (p-> op & 0xf) == 6)
        printf("*3");
       else
        printf("-5");
       if (p->lchild == NULL)
		break;   
	   
	   if ((p->lchild->op & 0x10) == 0x10) 
	    p = p->lchild; 
	   else if ((p->mchild->op & 0x10) == 0x10) 
	    p = p->mchild; 
	   else 
	    p = p->rchild; 
      }
     printf("=2012\n");
    } 
   destory(&root);
  }
 
 getch();
}

/* 
  op记录路线方向：
  1-从左向右经过7,2-从右向左经过7,3-从左向右经过2,4-从右向左经过2,
  5-从左向右经过3,6-从右向左经过3,7-从左向右经过5,8-从右向左经过5
  op: 1-7-L,2-7-R,3-2-L,4-2-R,5-3-L,6-3-R,7-5-L,8-5-R 
*/

void createchild(tree **parent, int level)
{
 if (*parent == NULL)
  return;

 if (finded || level == MAXDEPTH)
  return;
	 
 if ((*parent)->value == 2012 && (*parent)->op == 7)
  {
   finded = 1;	  
   markroute(*parent);
   return;
  } 

 if ((*parent)->value < -10000 || (*parent)->value > 10000)
  return;	 
	 
 (*parent)->lchild = NULL;
 (*parent)->mchild = NULL;
 (*parent)->rchild = NULL;
 
 /* op: 1-7-L,2-7-R,3-2-L,4-2-R,5-3-L,6-3-R,7-5-L,8-5-R */
 if ((*parent)->op == 1)
  {
   if (((*parent)->value & 1) == 0)
    {
     (*parent)->lchild = Alloctree;
     (*parent)->lchild->value = (*parent)->value >> 1;
     (*parent)->lchild->op = 4;
	 (*parent)->lchild->lchild = NULL;
	 (*parent)->lchild->mchild = NULL;
	 (*parent)->lchild->rchild = NULL;
	 (*parent)->lchild->parent = *parent;

     (*parent)->mchild = Alloctree;
     (*parent)->mchild->value = (*parent)->value * 3;
     (*parent)->mchild->op = 5;
     (*parent)->mchild->lchild = NULL;
     (*parent)->mchild->mchild = NULL;
     (*parent)->mchild->rchild = NULL;
	 (*parent)->mchild->parent = *parent;
	 
	 (*parent)->rchild = Alloctree;
     (*parent)->rchild->value = (*parent)->value - 5;
     (*parent)->rchild->op = 7;
     (*parent)->rchild->lchild = NULL;
     (*parent)->rchild->mchild = NULL;
     (*parent)->rchild->rchild = NULL;
	 (*parent)->rchild->parent = *parent;

     createchild(&(*parent)->lchild, level + 1);
     createchild(&(*parent)->mchild, level + 1);
     createchild(&(*parent)->rchild, level + 1);
    }
   else
    {
     (*parent)->lchild = Alloctree;
     (*parent)->lchild->value = (*parent)->value * 3;
     (*parent)->lchild->op = 5;
     (*parent)->lchild->lchild = NULL;
     (*parent)->lchild->mchild = NULL;
     (*parent)->lchild->rchild = NULL;
	 (*parent)->lchild->parent = *parent;
	 
 	 (*parent)->mchild = Alloctree;
     (*parent)->mchild->value = (*parent)->value - 5;
     (*parent)->mchild->op = 7;
     (*parent)->mchild->lchild = NULL;
     (*parent)->mchild->mchild = NULL;
     (*parent)->mchild->rchild = NULL;
	 (*parent)->mchild->parent = *parent;

     createchild(&(*parent)->lchild, level + 1);
     createchild(&(*parent)->mchild, level + 1);
    }
  }
 else if ((*parent)->op == 2)
  {
   if (((*parent)->value & 1) == 0)
    {
     (*parent)->lchild = Alloctree;
     (*parent)->lchild->value = (*parent)->value >> 1;
     (*parent)->lchild->op = 3;
     (*parent)->lchild->lchild = NULL;
     (*parent)->lchild->mchild = NULL;
     (*parent)->lchild->rchild = NULL;
	 (*parent)->lchild->parent = *parent;

     createchild(&(*parent)->lchild, level + 1);
    }
  }
 else if ((*parent)->op == 3)
  {
   (*parent)->lchild = Alloctree;
   (*parent)->lchild->value = (*parent)->value + 7;
   (*parent)->lchild->op = 2;
   (*parent)->lchild->lchild = NULL;
   (*parent)->lchild->mchild = NULL;
   (*parent)->lchild->rchild = NULL;
   (*parent)->lchild->parent = *parent;

   (*parent)->mchild = Alloctree;
   (*parent)->mchild->value = (*parent)->value * 3;
   (*parent)->mchild->op = 5;
   (*parent)->mchild->lchild = NULL;
   (*parent)->mchild->mchild = NULL;
   (*parent)->mchild->rchild = NULL;
   (*parent)->mchild->parent = *parent;

   (*parent)->rchild = Alloctree;
   (*parent)->rchild->value = (*parent)->value - 5;
   (*parent)->rchild->op = 7;
   (*parent)->rchild->lchild = NULL;
   (*parent)->rchild->mchild = NULL;
   (*parent)->rchild->rchild = NULL;
   (*parent)->rchild->parent = *parent;

   createchild(&(*parent)->lchild, level + 1);
   createchild(&(*parent)->mchild, level + 1);
   createchild(&(*parent)->rchild, level + 1);
  }
 else if ((*parent)->op == 4)
  {
   (*parent)->lchild = Alloctree;
   (*parent)->lchild->value = (*parent)->value + 7;
   (*parent)->lchild->op = 1;
   (*parent)->lchild->lchild = NULL;
   (*parent)->lchild->mchild = NULL;
   (*parent)->lchild->rchild = NULL;
   (*parent)->lchild->parent = *parent;

   createchild(&(*parent)->lchild, level + 1);
  }
 else if ((*parent)->op == 5)
  {
   (*parent)->lchild = Alloctree;
   (*parent)->lchild->value = (*parent)->value - 5;
   (*parent)->lchild->op = 8;
   (*parent)->lchild->lchild = NULL;
   (*parent)->lchild->mchild = NULL;
   (*parent)->lchild->rchild = NULL;
   (*parent)->lchild->parent = *parent;

   createchild(&(*parent)->lchild, level + 1);
  }
 else if ((*parent)->op == 6)
  {
   if (((*parent)->value & 1) == 0)
    {
     (*parent)->lchild = Alloctree;
     (*parent)->lchild->value = (*parent)->value >> 1;
     (*parent)->lchild->op = 4;
	 (*parent)->lchild->lchild = NULL;
	 (*parent)->lchild->mchild = NULL;
	 (*parent)->lchild->rchild = NULL;
	 (*parent)->lchild->parent = *parent;

     (*parent)->mchild = Alloctree;
     (*parent)->mchild->value = (*parent)->value + 7;
     (*parent)->mchild->op = 2;
	 (*parent)->mchild->lchild = NULL;
	 (*parent)->mchild->mchild = NULL;
	 (*parent)->mchild->rchild = NULL;
	 (*parent)->mchild->parent = *parent;

	 (*parent)->rchild = Alloctree;
     (*parent)->rchild->value = (*parent)->value - 5;
     (*parent)->rchild->op = 7;
     (*parent)->rchild->lchild = NULL;
     (*parent)->rchild->mchild = NULL;
     (*parent)->rchild->rchild = NULL;
	 (*parent)->rchild->parent = *parent;

     createchild(&(*parent)->lchild, level + 1);
     createchild(&(*parent)->mchild, level + 1);
     createchild(&(*parent)->rchild, level + 1);
    }
   else
    {
     (*parent)->lchild = Alloctree;
     (*parent)->lchild->value = (*parent)->value + 7;
     (*parent)->lchild->op = 2;
	 (*parent)->lchild->lchild = NULL;
	 (*parent)->lchild->mchild = NULL;
	 (*parent)->lchild->rchild = NULL;
	 (*parent)->lchild->parent = *parent;

	 (*parent)->mchild = Alloctree;
     (*parent)->mchild->value = (*parent)->value - 5;
     (*parent)->mchild->op = 7;
     (*parent)->mchild->lchild = NULL;
     (*parent)->mchild->mchild = NULL;
     (*parent)->mchild->rchild = NULL;
	 (*parent)->mchild->parent = *parent;

     createchild(&(*parent)->lchild, level + 1);
     createchild(&(*parent)->mchild, level + 1);
    }
  }
 else if ((*parent)->op == 7)
  {
   (*parent)->lchild = Alloctree;
   (*parent)->lchild->value = (*parent)->value * 3;
   (*parent)->lchild->op = 6;
   (*parent)->lchild->lchild = NULL;
   (*parent)->lchild->mchild = NULL;
   (*parent)->lchild->rchild = NULL;
   (*parent)->lchild->parent = *parent;

   createchild(&(*parent)->lchild, level + 1);
  }
 else if ((*parent)->op == 8)
  {
   if (((*parent)->value & 1) == 0)
    {
     (*parent)->lchild = Alloctree;
     (*parent)->lchild->value = (*parent)->value >> 1;
     (*parent)->lchild->op = 4;
	 (*parent)->lchild->lchild = NULL;
	 (*parent)->lchild->mchild = NULL;
	 (*parent)->lchild->rchild = NULL;
	 (*parent)->lchild->parent = *parent;

     (*parent)->mchild = Alloctree;
     (*parent)->mchild->value = (*parent)->value + 7;
     (*parent)->mchild->op = 2;
	 (*parent)->mchild->lchild = NULL;
	 (*parent)->mchild->mchild = NULL;
	 (*parent)->mchild->rchild = NULL;
	 (*parent)->mchild->parent = *parent;

	 (*parent)->rchild = Alloctree;
     (*parent)->rchild->value = (*parent)->value * 3;
     (*parent)->rchild->op = 5;
     (*parent)->rchild->lchild = NULL;
     (*parent)->rchild->mchild = NULL;
     (*parent)->rchild->rchild = NULL;
	 (*parent)->rchild->parent = *parent;

     createchild(&(*parent)->lchild, level + 1);
     createchild(&(*parent)->mchild, level + 1);
     createchild(&(*parent)->rchild, level + 1);
    }
   else
    {
     (*parent)->lchild = Alloctree;
     (*parent)->lchild->value = (*parent)->value + 7;
     (*parent)->lchild->op = 2;
	 (*parent)->lchild->lchild = NULL;
	 (*parent)->lchild->mchild = NULL;
	 (*parent)->lchild->rchild = NULL;
	 (*parent)->lchild->parent = *parent;

     (*parent)->mchild = Alloctree;
     (*parent)->mchild->value = (*parent)->value * 3;
     (*parent)->mchild->op = 5;
     (*parent)->mchild->lchild = NULL;
     (*parent)->mchild->mchild = NULL;
     (*parent)->mchild->rchild = NULL;
	 (*parent)->mchild->parent = *parent;

     createchild(&(*parent)->lchild, level + 1);
     createchild(&(*parent)->mchild, level + 1);
    }
  }
}

/* 标记结果路径 */
void markroute(tree *treenode)
{
 tree *parent = treenode;
 while(parent->op != 0)
  {
   parent->op |= 0x10;
   parent = parent->parent;
  }	 
}

void destory(tree **root)
{
 if (*root == NULL)
  return;
 
 destory(&(*root)->lchild);  
 destory(&(*root)->mchild);  
 destory(&(*root)->rchild);  
 
 free(*root);
 *root = NULL;
}


 

       为了简化程序中每次都是从头建树开始搜索，而没有在原有树的基础上继续搜索。

 

满足条件的结果不止一个：

2011+7/2+7/2+7-5*3/2+7/2+7*3-5/2+7/2+7-5*3-5*3/2+7-5*3/2+7-5=2012

2011+7/2+7/2+7*3-5/2+7*3-5/2+7/2+7/2+7-5*3/2+7/2+7/2+7/2+7*3-5*3-5+7/2-5*3-5*3/2+7-5*3/2+7-5=2012

2011+7/2+7/2+7*3-5/2+7*3-5/2+7/2+7/2+7*3-5/2+7*3-5/2+7*3-5/2+7/2+7*3-5/2+7-5*3+7/2+7/2-5*3+7/2*3-5+7/2-5*3/2+7-5=2012

2011+7/2+7/2+7*3-5/2+7*3-5/2+7/2+7/2+7*3-5/2+7*3-5/2+7*3-5/2+7/2+7*3-5/2+7/2+7/2+7/2+7/2+7-5*3/2+7-5*3+7/2-5*3/2+7-5*3-5*3+7/2*3-5+7/2-5*3/2+7-5=2012

2011+7/2+7/2+7*3-5/2+7*3-5/2+7/2+7/2+7*3-5/2+7*3-5/2+7*3-5/2+7/2+7*3-5/2+7/2+7/2+7/2+7/2+7*3-5/2+7*3-5/2+7*3-5/2+7/2+7/2+7*3-5*3-5+7/2-5*3-5*3/2+7-5*3/2+7-5=2012

...

 

        要验证结果正确不正确恐怕不能用计算器，因为这些算式是按从左向右依次运算的，而不是按先乘除后加减的四则运算法则，要用计算器就上括号吧。

alphabuilder
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树拓展--三叉树的遍历、路径算法
weixin_42095500的博客
10-10 4299
nodes = ['a',['b',['e',['k','#','#','#'],['l','#','#','#'],'#'],['f',['m','#','#','#'],'#','#'],'#'],\ ['c',['g',['n',['t','#','#','#'],['u','#','#','#'],'#'],'#','#'],['h',['o',['v',['y','#','#','#']...
经典迷宫问题DFS
That
10-14 8598
给定一个迷宫，入口为左上角，出口为右下角，问是否有路径从入口到出口，若有则输出一条这样的路径。注意移动可以从上、下、左、右、上左、上右、下左、下右八个方向进行。迷宫输入0表示可走，输入1表示墙。易得可以用1将迷宫围起来避免边界问题。 本题采用DFS算法给出解。 /* 迷宫问题（八方向） input: 1 6 8 0 1 1 1 0 1 1 1 1 0 1 0 1 0 1 0 0 1 0 0 1
数据结构题目收录（二十五）
星霖的博客
11-26 2167
数据结构题目收录
三叉搜索树（Ternary Search Trie）和中文分词原理分析
No.⑩號²º¹4
12-30 1万+
三叉搜索树（Ternary Search Trie） 三叉搜索树是二叉搜索树和数字搜索树的混合体。它有和数字搜索树差不多的速度但是只需要和二叉搜索树一样相对较少的内存空间。在一个三叉搜索树中，每一个节点包含一个字符，和数字搜索树不同，三叉搜索树只有三个指针：一个指向左边的树；一个指向右边的树；还有一个向下，指向单词的下一个数据单元。 树是否平衡取决于单词的读入顺序。如果按排序后的顺序插入，
严格m叉树（正则m叉树）
乐行僧的博客
11-13 4837
严格m叉树：只有度为0的节点和度为m的节点。 如何构造正则m叉树：首先寻找N0节点的个数与Nm节点的个数之间的关系。 （1）从节点个数看：N = N0 + Nm （2）从分支数看：N - 1 = mNm 联立两个方程得：(m-1)*Nm = N0-1 所以：Nm = (N0-1)/(m-1) 开始时，有n个节点，即叶子节点有n个。计算Nm=(N0-1)%(m-1)，如果Nm=0则说明刚刚好可以构造...
Python迷宫生成和迷宫破解算法实例
09-18
今天小编就为大家分享一篇Python迷宫生成和迷宫破解算法实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
逃离迷宫.cpp，逃离迷宫题目正解
07-23
逃离迷宫题目正解
Python使用回溯法子集树模板解决迷宫问题示例
09-21
在Python中，我们可以使用回溯法的子集树模板来解决迷宫问题。这个模板适用于解决具有多个可能分支的问题，如迷宫中的路径选择。迷宫问题的关键在于，每个格子都有多个可能的移动方向，包括上、下、左、右以及它们的...
破解迷宫算法（需要预先下载随即迷宫生成算法）
02-29
下载该资源前请确认已下载前置资源（随机迷宫生成算法），使用时先使用随即迷宫生成算法生成迷宫.txt文件，再将该文件复制到破解迷宫算法C文件同目录下才可使用。请确保头文件中的raw值和column值与随机迷宫生成算法...
用Python代码来解图片迷宫的方法整理
12-25
当给定上面那样一张JPEG图片，如何才能更好地将这张图转换为合适的数据结构并且解出这个迷宫？ 我的第一直觉是将这张图按像素逐个读入，并存储在一个包含布尔类型元素的列表或数组中，其中True代表白色像素，False...
迷宫问题（回溯）
noingw96的博客
11-30 3463
问题： 随机产生一个n阶的迷宫，障碍用 * 表示，通路使用 0 表示，给定起点和终点，要求给出起点到终点的通路（完整代码在最下方，如有需要可以直接拉至最下方） 解题思路： 第一步、需要产生一个n阶的迷宫maze，先构建一个n * n的二维数组，全赋值为0。之后我们可以考虑先给迷宫加上外围一圈的障碍，若 i 表示迷宫的行，j 表示迷宫的列，那么我们令i = 0 ，i = n-1，j = 0，j...
优化的三叉哈夫曼树
wbcg111的专栏
03-28 1万+
1. 背景 在通讯、计算机网络、数据压缩、图像处理中，哈夫曼编码是一项极其重要的技术。哈夫曼编码是建立在二叉哈夫曼树的基础上，如果能够找到比二叉哈夫曼树更好的数据结构，那么对数据压缩等将起到促进作用。本文通过论述二叉哈夫曼树编码算法以及普通的三叉哈夫曼树编码算法，给出一种优化的三叉哈夫曼编码算法。 2. 哈夫曼编码2.1 哈夫曼编码 哈夫曼编码是根据每个字符出现的频率进行编码的，依据字符出现
BFS经典例题—迷宫问题
llzhh的博客
04-05 1万+
Description 定义一个二维数组：  int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短
经典迷宫问题
lzy2014的专栏
09-10 912
全文转自：http://blog.csdn.net/that163/article/details/8069780       http://blog.csdn.net/that163/article/details/8069764
回溯算法之迷宫问题（Maze）
YING—country的博客
07-22 1万+
回溯算法之迷宫问题前言算法思路一、回溯算法二、经典问题之迷宫问题（Maze）（一）问题阐述 前言     迷宫问题是回溯算法的经典问题 算法思路 一、回溯算法     回溯算法实际上是一个类似枚举的搜索尝试过程，主要是在搜素尝试过程中寻找问题的解，当发现已满足求解条件时，就“回溯”返回，尝试别的路径。     回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标，但当搜索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种不通就回退再走的技术称为回溯法，而满足回溯条件的某个状态的点称为“回
迷宫问题求解
热门推荐
sandmm112的博客
04-21 3万+
问题一：在迷宫中找到出口（只需找到一个即可）        给定一张迷宫地图和一个迷宫入口，然后进入迷宫探索找到一个出口。问题分析：1. 首先要有一张迷宫地图，地图由两部分组成：    （1）一是迷宫中各处的位置坐标，    （2）二是迷宫各位置处的状态信息，即该处是墙还是路        所以，该迷宫地图可由一个二维数组来表示。数组的横纵坐标表示迷宫各处的位置坐标，数组元素表示各位置处的状态信息...
迷宫问题 （BFS）
薄荷糖
10-08 3193
定义一个二维数组：  int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 Input 一个5 ×...
迷宫问题(图)
一个吃水不忘挖井人的博客。希望能帮助到你
05-03 1572
...1111111111111111111111111111111.111111........1111111111.111111.111111..111.11111111.....111111.11111111111.1111111111.11111111.111111.................11111111.111111.11111111111.11111.111111.11111...
用c语言找出迷宫的最优解并且输出
最新发布
06-05
好的，针对您的问题，我给出一个简单的C语言程序，可以用来找出迷宫的最优解并输出。 ```c #include #include #define MAX_ROW 20 #define MAX_COL 30 int maze[MAX_ROW][MAX_COL] = { {0,0,0,0,0,0,0,0,0,0,0...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值