吉林大学 博士入学考试试题 计算智能 2001 答案

八数码问题： 取一个 3*3 的矩阵，将1-8(或者任意从小到大的八个数字)，随机分布在矩阵中，留下一个空格(可以用0代替)，作为初始状态；再去一个3*3的矩阵，将1-8(或者任意从小到大的八个数字，其取值必须与初始状态相同)，随机分布在矩阵中，留下一个空格(可以用0代替)，作为目标状态；对初始状态进行操作，其允许的操作是：将空格向上，下，左，右移动(即将空格与周边的数字进行交换)，操作初始状态的矩阵，在若干步后达目标状态。求解其过程为八数码问题。如图： 八数码问题的有解条件： 将矩阵从上到下从左到右的顺序分布成一个数列，并去掉空格，例如： 2 8 3 (0为空格) 分布成数列后： 1 0 4 u2003u2003u2003u20032 8 3 1 4 7 6 5 7 6 5 如果此 初始状态的数列(矩阵) 的 逆序数 与 目标状态的数列(矩阵) 的 逆序数 的 奇偶性一样 ，则此问题有解。 逆序数 的定义： 有一个数列，在这个数列中任意取一对数字(两个数字)，其两个数字在数列中的(从前到后)顺序与数字数值的大小相反，称其为一个逆序。这个数列中所有的逆序的和为逆序数。 证明 ： 空格向左右移动时，不改变逆序数的大小；空格向上下移动时，会改变逆序数，改变的幅度为±2或者0 (1)。所以±2或者0的改变幅度不会对逆序数造成奇偶性的改变。所以如果两个矩阵状态如果能互相到达，则必须有其逆序数的奇偶性一样。 (1) 在矩阵中操作空格上下移动时，在数列中的表现是将被交换的数字提前到他前面两个数字之前或者推后到他后面两个数字之后；例如，被交换的数字的下标是 Z 的话，空格向下移动(即被交换数向上移动)后，被交换数在数列中的位置是 Z-2 ；空格向上移动(即被交换数向下移动)后，则被交换数在数列中的位置是 Z+2。这种交换不会影响到被交换数与被它跨过的两个数以外的数字的顺序。比如说：被交换数的位置 Z ，如果空格向上移动，被交换数位置变成 Z+2，但是Z-1处的数字 与 Z 的顺序没有因为 Z 变成 Z+2 而失去了Z-1 在 Z 的前面的顺序，Z-1在Z前面，也在Z+2前面，同样的，Z变成Z+2也不会改变Z与Z+3的顺序。并且，如果有顺序 2 3 4 ，这个顺序的逆序数为0，如果我把4放到2 3前面，变成4 2 3，其逆序数就变成了+2，逆序数就增长了2；如果有顺序 4 2 3，其逆序数为+2，如果我把4放到2 3后面，变成2 3 4，其逆序数就变成了0，逆序数减少了2；如果有6 4 5，其逆序数为+2，如果我把5放在6 4 的前面，变成5 6 4，其逆序数为2，逆序数改变为0。所以改变的幅度为±2，或者0。 八数码问题的解法以及算法(宽度优先)： 解法： 空格可以上下左右移动，则父状态可以衍生出若干个子状态(考虑其空格不能越3*3的界以及其不返回到父状态或者父父状态等等之类的情况的话，最大的子状态数量为4 最小为0)，这种思路的话实际上这个问题就是一个树的搜索问题，所以用搜索的算法可以解决。 算法(宽度优先)： (1)判断初始状态与目标状态的逆序数的奇偶性来判断是否有解 (2)建立一个OPEN表(队列)，用于存放待展开子节点(状态)的父节点 (3)建立一个CLOSED表(队列)，用于存放已经展开了子节点的父节点 (4)将初始状态放到OPEN表中，作为第一个 (5)将OPEN表中第一个节点取出(并在OPEN表中删除这个节点)，放到CLOSED表中，排在CLOSED表中最后一个，整理好OPEN表 (6)把CLOSED表最后一个节点按照条件(不越界，不返回到父节点)展开其子节点，并且将可能的子节点按照顺序存入OPEN表中 (7)判断此父节点是否为目标状态： u2003①是，退出，打印答案 u2003②不是，回到步骤(4) 问题： (1)如果不用数字，而是用毫无关系的符号来填充矩阵，怎么判断是否有解呢？ 想法：将初始状态作为参考，将其不同的符号的顺序作为其符号的值的大小，计算出初始状态的逆序数为0，按照初始状态的值大小来判断目标状态的逆序数，然后判断奇偶性进而判断是否有解。

八数码问题是一个经典的排列问题，也被称为滑动拼图游戏。它的目标是将一组数字（1-8）和一个空格的矩阵重新排列到特定的目标状态，一次只能将数字移动到周围相邻的空格中。通过广度优先搜索算法，可以确定任何初始状态是否可以达到目标状态，并计算出达到目标状态需要的最少步数。根据维基百科上的数据，最多需要31步才能从任意起始状态解决这个问题。

会的。八数码问题本身就有可能是无解的，这和用什么算法什么语言无关。如果从初始状态成为下面的状态：12345687而通常的目标状态如下:1 2 34 5 67 8就是无解的。

八数码问题有一个3*3的棋盘，其中有0-8 9个数字，0表示空格，其他的数字可以和0交换位置。求由初始状态1 2 34 5 67 8 0到达目标状态步数最少的解。其典型算法是广度优先搜索，具体算法是：struct 类名 m_ar[可能结点数];int h,rmain(){ h=0;r=1; while ((h<r)&&(r<可能结点数)) { if (判断每一种可能性，如果某一种操作符合要求)&nbs……

利用奇偶性判断所给出的初始状态有无解.判别方法是：以数组为一维的举例子.将八数码的一个结点表示成一个数组a[9]，空格用0表示，设临时函数p(x)定义为：x数所在位置前面的数比x小的数的个数，其中0空格不算在之内，那设目标状态为b[9]，那r=sigma(p(x)) sigma()表示取所有的x:1-8并求和，那对于初始状态a[9]，t=sigma(p(x))，如果r和t同为奇数或者同为偶数，那么该状态有解，否则无解。考虑到四种移动方法对sigma(p(x))的影响，左移和右移是不会影响它的值的，更不会影响奇偶性，如果是上移或者下移就会影响：上移:一次上移会使一个元素向前跳两个数字的位置，设这两个数字为a1,a2，不妨设a1<a2，移的这个数字设为a0，那无非只有以下三次情况：1，a0<a1<a2，考虑它们三者的p(x)值，p(a0)不变，p(a1)++，p(a2)++，总体增加了22，a1<a0<a2，p(a0)--,p(a1)不变,p(a2)++，总体不变3，a1<a2<a0，p(a0)-=2,p(a1),p(a2)不变，总体减小了2综合起来的结论就是不会影响sigma(p(x))的奇偶性。

基于A算法求解八数码问题是一种规划问题，即用有限步骤把初始状态转换成目标状态的过程。A算法是一种带有启发式函数的搜索算法，用于通过估价函数指导搜索，提高搜索效率。为了实现上述功能，需要定义若干个变量和函数，如下所示：定义变量：init_state：初始状态，即八数码问题的初始排列；goal_state：目标状态，即八数码问题的最终排列；f_score：估价函数值，即启发函数和实际代价之和；g_score：实际代价，即当前状态到起始状态的实际步数；h_score：启发函数值，即当前状态到目标状态的估计步数。定义函数：get_successor_states()：用于获取当前状态的所有后继状态；get_heuristic_value()：用于计算当前状态到目标状态的估计步数，即启发函数值；get_g_value()：用于计算当前状态到起始状态的实际步数；get_f_value()：用于计算当前状态的估价函数值，即启发函数值与实际代价之和；compare_f_values()：用于比较两个状态的估价函数值的大小；A*_search()：用于执行A*搜索算法，求解八数码问题。在定义了上述变量和函数后，我们就可以编写A*搜索算法的代码了。下面是一个可能的实现方式：Copy code# 定义估价函数def get_heuristic_value(state):h_value = 0# 计算估价函数值for i in range(len(state)):for j in range(len(state[i])):if state[i][j] != goal_state[i][j]:h_value += 1return h_value# 定义实际代价函数def get_g_value(state):g_value = 0# 计算实际代价值for i in range(len(state)):for j in range(len(state[i])):if state[i][j] != init_state[i][j]:g_value += 1return g_value# 定义估价函数值函数def get_f_value(state):# 计算估价函数值f_value = get_g_value(state) + get_heuristic_value(state)return f_value# 定义估价函数值比较函数def compare_f_values(state1, state2):# 比较两个状态的估价函数值f1 = get_f_value(state1)f2 = get_f_value(state2)if f1 < f2:return -1elif f1 > f2:return 1else:return 0# 定义A*搜索算法def A*_search():# 初始化OPEN表和CLOSED表open_list = []closed_list = []# 将初始状态加入OPEN表并更新估价函数值 open_list.append(init_state) f_values[init_state] = get_f_value(init_state)# 循环执行直到OPEN表为空while len(open_list) > 0:# 从OPEN表中选择估价函数值最小的状态current_state = min(open_list, key=get_f_value)# 如果当前状态是目标状态，则算法执行成功if current_state == goal_state:return True# 将当前状态从OPEN表中移除，并加入CLOSED表open_list.remove(current_state)closed_list.append(current_state)# 获取当前状态的所有后继状态successor_states = get_successor_states(current_state)# 遍历所有后继状态for successor_state in successor_states:# 如果后继状态已在CLOSED表中，则跳过if successor_state in closed_list:continue# 如果后继状态不在OPEN表中，则加入OPEN表并更新估价函数值if successor_state not in open_list:open_list.append(successor_state)f_values[successor_state] = get_f_value(successor_state)# 如果新的路径更优，则更新估价函数值elif get_f_value(successor_state) < f_values[successor_state]:f_values[successor_state] = get_f_value(successor_state)# 如果OPEN表为空，则算法执行失败return False上面的代码实现了A*搜索算法的基本流程，包括初始化、主循环、状态扩展和结束条件判断。它使用了估价函数值来比较 不同状态的优劣，从而决定搜索的方向和顺序。为了实现上述需求，我们还需要对代码进行一些改进和完善，如下所示：定义3种不同的启发式函数：我们可以定义3种不同的启发式函数，分别用于计算曼哈顿距离、欧几里得距离和拼图曼哈顿距离。这些启发式函数的实现方式略有不同，但都基于当前状态与目标状态之间的位置关系进行计算。提供可视化界面：我们可以创建一个可视化界面，用于展示搜索过程。该界面应能够显示搜索树、估价函数值、OPEN表和CLOSED表的动态变化情况。同时，用户应能够选择预定义的启发式函数，随机初始化初始状态，单步执行或连续执行搜索算法。统计扩展节点数和执行时间：为了对采用不同启发式函数的A*算法进行性能对比研究，我们需要统计算法执行过程中的扩展节点数和执行时间。这些信息可以用来评估算法的效率和优劣。通过上述改进和完善，我们就可以实现一个能够求解八数码问题的A*算法，具有较好的可视化展示和性能分析能力。

#include<iostream>#include<cstdio>#include<cstring> using namespace std;const int N=370000,HN=1000003;int data[N][10],f[N],step[N],z[N];//data用于BFS队列存储，f记录节点的父亲，step记录节点的步数 int mv[10][5]={0,0,0,0,0, 2,2,4,0,0,3,3,1,5,0,2,2,6,0,0,3,1,5,7,0,4,2,4,6,8,3,3,5,9,0,2,4,8,0,0,3,5,7,9,0,2,6,8,0,0,};int en[10],head[HN],next[N];//en记录目标状态，head记录hash表头，next记录hash后继指针 void shuchu(int k) //输出路径 {if(f[k]!=0) shuchu(f[k]);for(int i=1;i<=9;i++){cout<<data[k][i]<<" ";if(i==3||i==6) cout<<endl;}cout<<endl<<endl; }int hash(int a){int x=0;for(int i=1;i<=9;i++)x=x*10+data[a][i]; //将新节点的状态映射成9位整数return x%HN; //确保hash值不超过hash表的大小； }bool can(int a){int h=hash(a);//取回当前节点的hash值 int u=head[h];//取回当前节点hash值的链表的表头 while(u){if(memcmp(data[u],data[a],sizeof(data[0]))==0) return 0; //状态重复，返回假 u=next[u]; //利用链表找到下一个余数相同的节点 }next[a]=head[h]; //新节点的next指针指向原来的hash值的表头 head[h]=a; //新节点成为新的hash值的表头 return 1; //合法的新节点 }void bfs(){int h=0,t=1; while(h<t){h++; //扩展队首 for(int i=1;i<=mv[z[h]][0];i++) //z[h]队头（当前扩展节点）空格所在位置 {memcpy(&data[t+1],&data[h],sizeof(data[h]));//把父节点的内容复制到扩展节点中 data[t+1][z[h]]=data[h][mv[z[h]][i]]; //原来（父节点）空格位置填值（交换） data[t+1][mv[z[h]][i]]=0; //新的（子节点）空格置空 z[t+1]=mv[z[h]][i]; //记录新的空格位置 if(can(t+1)){t++; //增加新节点 f[t]=h;step[t]=step[h]+1; if(memcmp(data[t],en,sizeof(en))==0){cout<<step[t]<<endl;shuchu(t);fclose(stdin);fclose(stdout);exit(0);}} } }}int main(){freopen("eight.in","r",stdin);freopen("eight.out","w",stdout);for(int i=1;i<=9;i++) //将出发状态直接装入队列 {cin>>data[1][i]; if(data[1][i]==0) z[1]=i;} f[1]=0;step[1]=0;for(int i=1;i<=9;i++) //存储目标状态 cin>>en[i];if(memcmp(data[1],en,sizeof(en))==0) //memcmp是比较内存区域buf1和buf2的前count个字节。该函数是按字节比较的{ //特殊情况，出发状态跟目标状态一样 cout<<0<<endl;shuchu(1);fclose(stdin);fclose(stdout);return 0;} bfs();return 0; }

基于51的程序：#include <reg52.h>sbit sda=P0^5;sbit scl=P0^6;code char led_code[19]={0x11,0xd7,0x32,0x92,0xd4, // 0,1,2,3,4 0x98,0x18,0xd3,0x10,0x90, // 5,6,7,8,9 0x50,0x1c,0x39,0x16,0x38, // a,b,c,d,e, 0x78,0xfe,0xef,0xff}; // f - dot dark void seperate(unsigned char second,minute,hour); //1调用拆分函数void display(unsigned char second,minute,hour); // 2调用显示函数 一定要在各处强调unsignde吗？void shift(unsigned char); //3调用移位函数void delay_1s(unsigned int x); //4调用延时函数unsigned char second,minute,hour;unsigned char second0,second1, minute0,minute1, hour0,hour1; // 这三行表示了时、分、秒所占数码管的个数和位置。 叫形参？void main(){ while(1) { for(hour=0;hour<24;hour++) //三个for语句的安排妙啊！ 我们看到的钟表时分秒的变化！ { for(minute=0;minute<60;minute++) { for(second=0;second<60;second++) { display(second,minute,hour); delay_1s(65535); } } } }}void display(unsigned char second,minute,hour) //2对显示函数的说明{ seperate(second,minute,hour); shift(second0); shift(second1); shift(16); shift(minute0); shift(minute1); shift(16); shift(hour0); shift(hour1);}void seperate(unsigned char second,minute,hour) //1对拆分函数的说明{ second0=second%10; second1=second/10; minute0=minute%10; minute1=minute/10; hour0=hour%10; hour1=hour/10;}void shift(unsigned char n) //3对移位函数的说明{ unsigned char dat,minute; dat=led_code[n]; scl=0; for(minute=0;minute<8;minute++) { if (dat&0x80) sda=1; else sda=0; scl=1; scl=0; dat<<=1; }}void delay_1s(unsigned int a) //4对延时函数的说明{ while(a--);}

可以给你看看我的程序，已发送，记得给分喔

问题求解过程是 搜索答案（目标） 的过程，所以问题求解技术也叫做搜索技术——通过对 状态空间 的搜索而求解问题的技术。 问题可形式化地定义成四个组成部分 在解题过程中 达到过的所有状态 的集合。不同于状态空间，搜索空间是其中一部分。状态空间和搜索空间都属于 过程性知识表示 。 八数码问题详解 两种搜索技术 无信息搜索策略也称 盲目搜索 ：没有任何附加信息，只有生成后继和区分目标和非目标状态。 五种盲目搜索策略有：广度优先搜索，代价一直搜索，深度优先搜索，深度有限搜索，迭代深入深度优先搜索。 从四种度量来评价广度优先搜索 性能：通常使用递归函数实现，一次对当前节点的子节点调用该函数。相比广度优先，内存需求少(分支因子 * 最大深度+1)。但 不是完备的也不是最优的 *。 深度优先搜索的无边界问题可以通过提供一个 预先设定的深度限制I 来解决。深度=I的节点当作无后继节点看待；虽然解决了无边界问题，但 有可能无解 ； 如果选择I>d则深度优先原则也不是最优解 。 每次改变限制深度 ，多次调用深度有限搜索，当 搜索到达最浅的目标节点深度 时就可以发现目标节点，称为迭代深入深度优先搜索。这种搜索结合了广度优先和深度优先两种搜索方式的优势。 解决了深度优先的完备性问题 。空间需求是(b * d),时间需求是(b d )。当搜索空间很大且深度未知时，迭代深入深度优先搜索 是首选的无信息搜索方式 。 迭代深入搜索中因为多次重复搜索上层节点，使部分状态反复生成，看起来很浪费内存空间和时间。但是因为 在分支因子比较均衡的搜索树 中， 多数节点都是叶子节点 *（叶子节点数远大于上层节点总和），所以上层节点多次生成的影响并不大，与广度优先相比，效率还是很高。 用于目标状态已知，求解过程的问题。通常通过 广度优先搜索 实现。从 起始节点和目标状态两个方向 开始扩展，当 两个OPEN表出现交集 时表明搜索到了一条从起始到结果的一条路径。 缺点 ：算法编写难。但一旦实现，效率要远高于其他盲目搜索。 评价函数 ：f ( n ) = h ( n ) ；评价函数等于启发函数 解释：贪婪最佳优先搜索中 无条件选择 当前离目标最近（代价最小）的结点进行扩展。但是 局部最佳不是全局最佳，即非最优。 其中h（ n ）称为 启发函数 ，是从节点n到目标节点的最低代价的 估计值 。 评价函数 ：f ( n ) = g ( n ) + h ( n )；评价函数等于启发函数加路径耗散函数 解释： 另，对于有向图的搜索还可以采用图搜索方式。详情： 图搜索和树搜索详解 称启发函数是可采纳的，如果h( n ) 满足 h( n ) ≤ h * ( n ) ，其中 h * ( n )是从当前节点 n到达目标的最低真实代价 ，即h( n )的估值永远小于真实耗散值；因为f ( n ) = g ( n ) + h ( n )，且g（n）为已知常数，所以 f（n）永远不会高估经过结点n的解的实际代价 ，所以是最优解。 如果采用 A* 图搜索算法，则不一定返回最优解 。因为如果最优路径不是第一个生成的，可能因为有重复状态而被丢弃了。见上个链接： 图搜索和树搜索详解 如果对于每个结点n，以及n的行为a产生的后继结点n"满足如下公式： h ( n ) ≤ c ( n, n", a) + h( n ") （c ( n, n", a)可以理解为g（n"）），则称这个h ( n )启发函数是一致的。 A* 搜索由初始结点出发开始搜索，以同心带状增长f（n）耗散值的方式扩展结点。如果h（n）= 0 意味着只按g（n）值排序，即同心带为“圆形”。使用启发函数则同心带向目标节点拉伸（椭圆越来越扁）。 如果C*是最优路径的耗散值，则： A* 搜索的关键就是 设计可采纳的或一致的（单调的）启发函数 。 绝不高估 到达目标的耗散值，尽可能的接近真实耗散值 子问题的解耗散是完整问题的 耗散下界 。 从实例中学习，每个实例包含了解路径上各状态及其到达解的耗散值。每个最优解实例提供了可学习h(n)的实例，由此产生可预测其他状态解消耗的启发函数。 联机搜索智能体需要行动和感知，然后扩展当前状态的环境地图 智能体初始位置在S，其已知信息为： A* 搜索在不同子空间结点的跳跃式扩展， 模拟而非实际行动 ；联机搜索只扩展实际占据的结点——采用深度优先。 联机搜索必须维护一个回溯表 博弈搜索是智能体之间的对抗，每个智能体的目的是冲突的。本节需要解决两个问题：如何搜索到取胜的 路径 /如何提高搜索 效率 。相应的办法是 极大极小决策和α-β剪枝 。 两个智能体博弈时，可令一方为MAX，一方为MIN。MAX希望终局得分高，MIN希望终局得分低。 博弈搜索中，最优解是导致取胜的终止状态的一系列招数。MAX制定取胜策略时，必须不断考虑MIN应对条件下如何取胜。 如果博弈双方 都按照最优策略 进行，则一个结点的 极大极小值就是对应状态的效用值 简单的递归算法——按照定义计算每个后继结点的极大极小值/搜索是从目标到初始结点的 反向推导 如果博弈树最大深度为m，每个节点的合法招数为b，则 剪掉那些不可能影响最后决策的分支，返回和极大极小值相同的结果。 α-β剪枝可以应用树的任何深度。 如果在结点n的父节点或更上层有一个更好的选择m，则在搜索中永远不会到达n。 很大程度上取决于检查后继节点的次序—— 应先检查那些可能更好的后继 。如果能先检查那些最好的后继，则 时间复杂度为O(b (d/2) ) 。优于极大极小算法的O(b d ) 许多问题中 路径是无关紧要的 。从当前状态出发，通常 只移动到相邻状态 ，且路径不保留。 内存消耗少，通常是一个常数。 向目标函数值增加的方向持续移动，直到相邻状态没有比它更高的值。 取到一个局部最优则终止 。 使新状态估计值优于当前状态值和其他所有候补结点值，则取新状态放弃其他状态。 将 爬山法 （停留在局部最优）和 随机行走 （下山）以某种方式结合，同时拥有 完备性和效率 。 技巧是，概率足够大可以弹出局部最优；但概率不能太大而弹出全局最优。 按照模拟退火的思想， T随时间逐渐减小 。如果 T下降的足够慢 ，则找到全局最优解是 完备的 。 随机移动，如果评价值改善则采纳； 否则以小于一的概率接受 。 从 k个随机生成的状态开始 ，每步生成k个结点的所有后继状态。如果其中之一是目标状态则停止算法；否则从全部后继状态中选择最佳的k个状态继续搜索。 有用的信息 在k个并行的 搜索线程之间传递 ，算法会很快放弃没有成果的搜索，而把资源放在取得最大进展的搜索上。 局部剪枝搜索的变种。因为局部剪枝搜索搜索是贪婪的，因而用随机剪枝搜索代替。不是选择最好的k个后代，而是按照一定概率选取k个后继状态。 类似于自然界的选择过程。状态对应个体，其 值对应适应性 ，后代就是状态。因此如果k个状态缺乏多样性，则局部搜索会受影响。 局部剪枝算法已有 群体进化 （优胜劣汰）的趋势。遗传算法是随机剪枝的变种。 包括选择，交叉和变异 又称繁殖，按照一定的概率选择两对个体生成后继状态 计算每个个体i被选中的概率： pi = f(i) / [f(1)+...+f(n)] .然后根据概率将圆盘分为n个扇形，每个扇形大小为 2Πpi 。 繁殖过程中，后代是父串在杂交点上进行杂交得来的。这样一来，后代子串保留了父串的优良特性又与父串不同。 首先以概率p随机在种群中选择pa和pb两个个体，再从{1,2,...,m}中（可以按一定概率，如两边概率小于中间概率）选择一个数i，作为交叉点。而后将两个个体的交叉点后面的部分交换。 在新生成的后继状态中各个位置都会按照一个 独立的很小的概率 随机变异。 变异时要做到 一致变异 ；即相同概率地变异所有个体的每一位。 结合了“上山”和随机行走，并在并行搜索线程之间交换信息。遗传算法的 最大优点在于杂交 。因为杂交可以 将独立发展的若干个砖块组合起来 ，提高搜索的粒度。 个体编码某些位置上数字仍未确定的一个状态子串。 如果 一个模式的实例的平均适应值超过均值 ，则种群内这个模式的实例数量会随时间而增长（优胜）；反之则减少（劣汰） 长度较短，高于平均适应度的模式在遗传算子的作用下， 相互结合 ，能生成长度较长、适应度较高的 模式 。 Constraint Satisfying Problem，CSP。 由一个 变量集合{X1~Xn} 和一个 约束集合{C1~Cn} ；每个变量都有一个 非空可能的值域Di 。每个约束指定了 若干变量的一个子集内各变量的赋值范围 。 CSP的一个状态是，对一些或每个变量赋值 一组既是 相容赋值 又是 完全赋值 的对变量的赋值就是CSP的解。 提前考虑某些约束，以减少搜索空间 若X被赋值，检查与X相连的Y，判断是否满足约束，去掉Y中不满足约束的赋值。（进行某种检验，可以不为有问题的Y集合赋值 ）

nclude "stdio.h"typedef int datatype; /*假定线性表元素的类型为整型*/#define maxsize 1024 /*假定线性表的最大长度为1024*/# define n 100 /* 图的顶点最大个数 */typedef char VEXTYPE; /* 顶点的数据类型 */typedef float ADJTYPE; /* 权值类型 */typedef struct{ VEXTYPE vexs[n] ; /* 顶点信息数组 */ ADJTYPE arcs[n][n] ; /* 边权数组 */ int num ; /* 顶点的实际个数 */}GRAPH;/***********************1。置空图**********************/void GraphInit(GRAPH *L){ L->num=0;}/***********************2。求结点数**********************/int GraphVexs(GRAPH *L){ return(L->num);}/***********************3。创建图**********************/void GraphCreate(GRAPH *L){ int i,j; GraphInit(L); printf("请输入顶点数目："); scanf("%d",&L->num); printf("请输入各顶点的信息(单个符号）："); for(i=0;i<L->num;i++) { fflush(stdin); scanf("%c",&L->vexs[i]); } printf("请输入边权矩阵的信息："); for(i=0;i<L->num;i++) { for(j=0;j<L->num;j++) { scanf("%f",&L->arcs[i][j]); } } printf("图已经创建完毕！");}/***********************4。图的输出**********************/void GraphOut(GRAPH L){ int i,j; printf(" 图的顶点数目为：%d",L.num); printf(" 图的各顶点的信息为： "); for(i=0;i<L.num;i++) printf("%c ",L.vexs[i]); printf(" 图的边权矩阵的信息为： "); for(i=0;i<L.num;i++) { for(j=0;j<L.num;j++) { printf("%6.2f ",L.arcs[i][j]); } printf(" "); } printf("图已经输出完毕！");}/***********************5。图的深度周游**********************/void DFS(GRAPH g,int qidian,int mark[])//从第qidian个点出发深度优先周游图g中能访问的各个顶点{ int v1; mark[qidian]=1; printf("%c ",g.vexs[qidian]); for(v1=0;v1<g.num;v1++) { if(g.arcs[qidian][v1]!=0&&mark[v1]==0) DFS(g,v1,mark); }}/***********************6。图的深度周游**********************/void GraphDFS(GRAPH g)//深度优先周游图g中能访问的各个顶点{ int qidian,v,v1,mark[maxsize]; printf(" 深度周游："); printf(" 请输入起点的下标："); scanf("%d",&qidian); for(v=0;v<g.num;v++) { mark[v]=0; } for(v=qidian;v<g.num+qidian;v++) { //printf("v=%d ",v); v1=v%g.num; if(mark[v1]==0) DFS(g,v1,mark); }}typedef int DATATYPE; //队列元素的数据类型typedef struct{ DATATYPE data[maxsize]; //队中元素 int front,rear; //队头元素下标、队尾元素后面位置的下标} SEQQUEUE;/*****************************************************************************/void QueueInit(SEQQUEUE *sq)//将顺序循环队列sq置空（初始化）{ sq->front=0; sq->rear=0;}/*****************************************************************************/int QueueIsEmpty(SEQQUEUE sq)//如果顺序循环队列sq为空，成功返回1，否则返回0{ if (sq.rear==sq.front) return(1); else return(0);} /*****************************************************************************/int QueueFront(SEQQUEUE sq,DATATYPE *e)//将顺序循环队列sq的队头元素保存到e所指地址，成功返回1，失败返回0{ if (QueueIsEmpty(sq)) else}/*****************************************************************************/int QueueIn (SEQQUEUE *sq,DATATYPE x)//将元素x入队列sq的队尾，成功返回1，失败返回0{ if (sq->front==(sq->rear+1)%maxsize) { printf("queue is full! "); return 0; } else { sq->data[sq->rear]=x; sq->rear=(sq->rear+1)%maxsize; return(1); }}/*****************************************************************************/int QueueOut(SEQQUEUE *sq)//将队列sq队首元素出队列，成功返回1,失败返回0{ if (QueueIsEmpty(*sq)) { printf("queue is empty! "); return 0; } else { sq->front=(sq->front+1)%maxsize; return 1; }}/***********************7。图的广度周游**********************/void BFS(GRAPH g,int v,int mark[])//从v出发广度优先周游图g中能访问的各个顶点{ int v1,v2; SEQQUEUE q; QueueInit(&q); QueueIn(&q,v); mark[v]=1; printf("%c ",g.vexs[v]); while(QueueIsEmpty(q)==0) { QueueFront(q,&v1); QueueOut(&q); for(v2=0;v2<g.num;v2++) { if(g.arcs[v1][v2]!=0&&mark[v2]==0) { QueueIn(&q,v2); mark[v2]=1; printf("%c ",g.vexs[v2]); } } }}/***********************8。图的广度周游**********************/void GraphBFS(GRAPH g)//深度优先周游图g中能访问的各个顶点{ int qidian,v,v1,mark[maxsize]; printf(" 广度周游："); printf(" 请输入起点的下标："); scanf("%d",&qidian); for(v=0;v<g.num;v++) { mark[v]=0; } for(v=qidian;v<g.num+qidian;v++) { v1=v%g.num; if(mark[v1]==0) BFS(g,v1,mark); }}/***********************主函数**********************/void main(){ GRAPH tu; GraphCreate(&tu); GraphOut(tu); GraphDFS(tu); GraphBFS(tu);}另外,虚机团上产品团购,超级便宜

其实A*算法也是一种最好优先的算法只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A*就是干这种事情的！我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：f"(n)=g"(n)+h"(n)这里，f"(n)是估价函数，g"(n)是起点到节点n的最短路径值，h"(n)是n到目标的最短路经的启发值。由于这个f"(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g"(n)，但g(n)>=g"(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h"(n)，但h(n)<=h"(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。举一个例子，其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h"(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了，谁叫它的h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。

启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无谓的搜索路径，提高了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。我们先看看估价是如何表示的。　　启发中的估价是用估价函数表示的，如：　　最佳优先搜索的最广为人知的形式称为A*搜索(发音为“A星搜索”).它把到达节点的耗散g(n)　　和从该节点到目标节点的消耗h(n)结合起来对节点进行评价：f(n)=g(n)+h(n)　　因为以g(n)给出了从起始节点到节点n的路径耗散，而h(n)是从节点n到目标节点的最低耗散路径的估计耗散值，因此f(n)=经过节点n的最低耗散解的估计耗散.这样，如果我们想要找到最低耗散解，首先尝试找到g(n)+h(n)值最小的节点是合理的。可以发现这个策略不只是合理的:倘若启发函数h(n)满足一定的条件，A*搜索既是完备的也是最优的。　　如果把A*搜索用于Tree-Search,它的最优性是能够直接分折的。在这种情况下，如果h(n)是一个可采纳启发式--也就是说，倘若h(n)从不会过高估计到达目标的耗散--A*算法是最优的。可采纳启发式天生是最优的，因为他们认为求解问题的耗散是低于实际耗散的。因为g(n)是到达节点n的确切耗散，我们得到一个直接的结论：f(n)永远不会高估经过节点n的解的实际耗散.　　启发算法有：蚁群算法，遗传算法、模拟退火算法等　　蚁群算法是一种来自大自然的随机搜索寻优方法，是生物界的群体启发式行为，现己陆续应用到组合优化、人工智能、通讯等多个领域。蚁群算法的正反馈性和协同性使其可用于分布式系统，隐含的并行性更使之具有极强的发展潜力。从数值仿真结果来看，它比目前风行一时的遗传算法、模拟退火算法等有更好的适应性。

题目地址:http://acm.pku.edu.cn/JudgeOnline/problem?id=1077BFS:#include <iostream>using namespace std;int fac[10]={1,1};bool tflag[9];struct bbit{ unsigned int val:4;};struct bbbit{ unsigned int val:2;};struct Node{ bbit s[9],pos; int step; bbbit path[21],tag; int hashval() { int ret=0,i,j,tmp; memset(tflag,false,sizeof(tflag)); for(i=0;i<8;i++) { tmp=0; for(j=0;j<s[i].val;j++) if(!tflag[j]) tmp++; ret+=tmp*fac[8-i]; tflag[s[i].val]=true; } return ret; } bool up() { if(pos.val<=2)return false; s[pos.val].val^=s[pos.val-3].val; s[pos.val-3].val^=s[pos.val].val; s[pos.val].val^=s[pos.val-3].val; path[step].val=0; pos.val-=3; return true; } bool down() { if(pos.val>=6)return false; s[pos.val].val^=s[pos.val+3].val; s[pos.val+3].val^=s[pos.val].val; s[pos.val].val^=s[pos.val+3].val; path[step].val=1; pos.val+=3; return true; } bool left() { if(pos.val==0||pos.val==3||pos.val==6)return false; s[pos.val].val^=s[pos.val-1].val; s[pos.val-1].val^=s[pos.val].val; s[pos.val].val^=s[pos.val-1].val; path[step].val=2; pos.val--; return true; } bool right() { if(pos.val==2||pos.val==5||pos.val==8)return false; s[pos.val].val^=s[pos.val+1].val; s[pos.val+1].val^=s[pos.val].val; s[pos.val].val^=s[pos.val+1].val; path[step].val=3; pos.val++; return true; } bool operator==(const Node&x)const { int i; for(i=0;i<9;i++)if(s[i].val!=x.s[i].val)return false; return true; }}Q[362880],S,A,tmp,top;struct Hash{ bool d1,d2; Node D;}hash[362880];inline void mkfac(){int i;for(i=2;i<=9;i++)fac[i]=fac[i-1]*i;}inline int eval(char c){return c=="x"?0:c-"0";}void o(Node x,Node y){ int i; for(i=1;i<=x.step;i++) { switch(x.path[i].val) { case 0:putchar("u");break; case 1:putchar("d");break; case 2:putchar("l");break; case 3:putchar("r");break; } } for(i=y.step;i>=1;i--) switch(y.path[i].val){ case 0:putchar("d");break; case 1:putchar("u");break; case 2:putchar("r");break; case 3:putchar("l");break; } puts("");}int main(){ char buf[11]; int i,t,l,r; bool flag; mkfac(); while(NULL!=gets(buf)) { t=0; for(i=0;i<=7;i++)A.s[i].val=i+1;A.s[8].val=0;A.pos.val=8; for(i=0;buf[i];i++) { if(buf[i]==" ")continue; S.s[t].val=eval(buf[i]); if(S.s[t].val==0) S.pos.val=t; t++; } l=r=0; flag=false; for(i=0;i<362880;i++)hash[i].d1=hash[i].d2=false; S.step=0;S.tag.val=1; A.step=0;A.tag.val=2; Q[r++]=S;//tag.val:1 Q[r++]=A;//tag.val:2 while(l<=r) { top=Q[l++]; top.step++; tmp=top; if(tmp.up()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } tmp=top; if(tmp.down()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } tmp=top; if(tmp.left()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } tmp=top; if(tmp.right()) { if(tmp.tag.val==1) { if(!hash[t=tmp.hashval()].d1) { hash[t].d1=true; Q[r++]=tmp; if(hash[t].d2&&hash[t].D==tmp) { //find ans... o(tmp,hash[t].D); goto AA; } if(!hash[t].d2)hash[t].D=tmp; } } else { if(!hash[t=tmp.hashval()].d2) { hash[t].d2=true; Q[r++]=tmp; if(hash[t].d1&&hash[t].D==tmp) { //find ans... o(hash[t].D,tmp); goto AA; } if(!hash[t].d1)hash[t].D=tmp; } } } } AA:flag=true; if(!flag) puts("unsolvable"); } return 0;}A*:#include <iostream>#include <queue>using namespace std;int fac[10]={1,1};struct Node{ int s[9],step,pos; char path[501]; int hashval() { int ret=0,i,j,tmp; bool flag[9]; memset(flag,false,sizeof(flag)); for(i=0;i<8;i++) { tmp=0; for(j=0;j<s[i];j++) if(!flag[j]) tmp++; ret+=tmp*fac[8-i]; flag[s[i]]=true; } return ret; } bool up() { if(pos<=2)return false; s[pos]^=s[pos-3]; s[pos-3]^=s[pos]; s[pos]^=s[pos-3]; path[step]="u"; pos-=3; return true; } bool down() { if(pos>=6)return false; s[pos]^=s[pos+3]; s[pos+3]^=s[pos]; s[pos]^=s[pos+3]; path[step]="d"; pos+=3; return true; } bool left() { if(pos==0||pos==3||pos==6)return false; s[pos]^=s[pos-1]; s[pos-1]^=s[pos]; s[pos]^=s[pos-1]; path[step]="l"; pos--; return true; } bool right() { if(pos==2||pos==5||pos==8)return false; s[pos]^=s[pos+1]; s[pos+1]^=s[pos]; s[pos]^=s[pos+1]; path[step]="r"; pos++; return true; } bool operator==(const Node&x)const { int i; for(i=0;i<9;i++)if(s[i]!=x.s[i])return false; return true; } void show() { int i,j; for(i=0;i<=6;i+=3,cout<<endl) for(j=i;j<=i+2;j++) cout<<s[j]; } bool operator<(const Node&x)const { int la=0,lb=0,i; for(i=0;i<8;i++)if(s[i]!=i+1)la++;la+=(s[8]!=0); for(i=0;i<8;i++)if(x.s[i]!=i+1)lb++;lb+=(x.s[8]!=0); return la>lb; }}S,A,tmp,top;priority_queue<Node> Q;bool hash[362880];void mkfac(){int i;for(i=2;i<=9;i++)fac[i]=fac[i-1]*i;}int eval(char c){return c=="x"?0:c-"0";}void output(Node x){ int i; for(i=1;i<=x.step;i++) putchar(x.path[i]); puts("");}int main(){ char buf[11]; int i,t,l,r; bool flag; mkfac(); while(NULL!=gets(buf)) { t=0; for(i=0;i<=7;i++)A.s[i]=i+1;A.s[8]=0;A.pos=8; for(i=0;buf[i];i++) { if(buf[i]==" ")continue; S.s[t]=eval(buf[i]); if(S.s[t]==0) S.pos=t; t++; } l=r=0; flag=false; memset(hash,false,sizeof(hash)); S.step=0; while(!Q.empty())Q.pop(); Q.push(S); while(!Q.empty()) { top=Q.top(); Q.pop(); top.step++; tmp=top; if(tmp.up()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } tmp=top; if(tmp.down()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } tmp=top; if(tmp.left()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } tmp=top; if(tmp.right()) { if(!hash[t=tmp.hashval()]) { hash[t]=true; Q.push(tmp); if(tmp==A) { //find ans... output(tmp); goto AA; } } } } AA:flag=true; if(!flag) puts("unsolvable"); } return 0;}

求逆序数的时候不要算0的。如果算上零的逆序数，对换之后奇偶性可能改变。

八数码 估价函数可以选h(s)=ΣΣ[|i-u230as[i,j]-1)/3u230b| + |j-(s[i,j]-1)mod3|]

二叉树中双分支结点就是度为2的结点,叶子就是度为0的结点 根据二叉树的性质:n0 = n2 + 1 所以叶子结点个数= 15+1 = 16个

#pragma warning(disable:4786) #include <algorithm> #include <cstdio> #include <set> #include <utility> #include <ctime> #include <cassert> #include <cstring> #include <iostream>using namespace std;/*item记录搜索空间中一个结点 state 记录用整数形式表示的8数码格局 blank 记录当前空格位置，主要用于程序优化，扩展时可不必在寻找空格位置 g, h 对应g(n), h(n) pre 记录当前结点由哪个结点扩展而来 */struct item { int state; int blank; int g; int h; int pre; };const int MAXSTEPS = 100000; const int MAXCHAR = 100; char buf[MAXCHAR][MAXCHAR]; //open表 item open[MAXSTEPS]; //vector<item> open;int steps = 0;//closed表，已查询状态只要知道该状态以及它由哪个结点扩展而来即可，用于输出路径 //每次只需得到对应f值最小的待扩展结点，用堆实现提高效率pair<int, int> closed[MAXSTEPS];//读入，将8数码矩阵格局转换为整数表示 bool read(pair<int,int> &state) { if (!gets(buf[0])) return false; if (!gets(buf[1])) return false; if (!gets(buf[2])) return false; //cout << strlen(buf[0]) << " " << strlen(buf[1]) << " " << strlen(buf[2]) << endl; assert(strlen(buf[0]) == 5 && strlen(buf[1]) == 5 && strlen(buf[2]) == 5); // astar.in中的每行数据长度必须为5 state.first = 0; for (int i = 0, p = 1; i < 3; ++i) { for (int j = 0; j < 6; j += 2) { if (buf[i][j] == "0") state.second = i * 3 + j / 2; // state.second为0（空格）在节点中的位置 else state.first += p * (buf[i][j] - "0"); p *= 10; } } /* 若初试节点为: 1 2 3 8 0 4 7 6 5 则state.first为567408321，state.second为4 */ return true;}//计算当前结点距目标的距离 int calculate(int current, int target) // return h=the sum of distances each block have to move to the right position,这里的each block不包括空格{ int c[9], t[9]; int i, cnt = 0; for (i = 0; i < 9; ++i) { c[current % 10] = t[target % 10] = i; current /= 10; target /= 10; } for (i = 1; i < 9; ++i) cnt += abs(c[i] / 3 - t[i] / 3) + abs(c[i] % 3 - t[i] % 3); return cnt; }//open表中结点间选择时的规则 f(n) = g(n) + h(n)class cmp { public: inline bool operator()(item a, item b) { return a.g + a.h > b.g + b.h; } }; //将整数形式表示转换为矩阵表示输出void pr(int state) { memset(buf, " ", sizeof(buf)); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 6; j += 2) { if (state % 10) buf[i][j] = state % 10 + "0"; state /= 10; } buf[i][5] = ""; puts(buf[i]); }}//用于判断当前空格是否可以向对应方向移动inline bool suit(int a, int b) //空格移动后的坐标为(a,b){ return (a >= 0 && a < 3 && b >= 0 && b < 3); } //递归输出搜索路径void path(int index) { if (index == 0) { pr(closed[index].first); puts(""); return; } path(closed[index].second); pr(closed[index].first); //将整数形式表示转换为矩阵表示输出 puts(""); ++steps; }int getNixuNum( int state ) //求节点的逆序对数{ int sum = 0; int result[9]; memset( result, 0, sizeof(result) ); //cout << result[8] << result[7] << endl; char buf[10]; itoa( state, buf, 10 ); //cout << buf << endl; int k = 0; while( buf[k] != "" ) { result[9-k-1] = buf[k] - "0"; k++; } for( int i = 0; i < 9; i++ ) { for( int j = i + 1; j < 9; j++ ) { if( result[i] && result[j] && result[i] > result[j] ) { sum++; } } } return sum; //返回3*3方格数组的逆序对数}int main() { //cout << getNixuNum(87654321); //open.resize(MAXSTEPS); unsigned int t1 = clock(); //cout << open.size() << endl; if( freopen("astar.in", "r", stdin) == NULL ) { cout << "file not find "; exit(0); }; freopen("astar2.out", "w", stdout); set<int>states; char tmp[100]; int i, x, y, a, b, nx, ny, end, next, index, kase = 0; pair<int,int> start, target; item head; //4个方向移动时的偏移量 const int xtran[4] = {-1, 0, 1, 0}; const int ytran[4] = {0, 1, 0, -1}; const int p[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000}; while (read(start)) // 读取初试状态节点 { unsigned int t2 = clock(); printf("Case %d: ", ++kase); gets(tmp); read(target); // 读取目标状态节点 gets(tmp); int targetNixuNum = getNixuNum(target.first); //若两者的逆序对数不是同为奇数或同为偶数，则无解 if( !(getNixuNum(start.first)&1 && targetNixuNum&1 || !(getNixuNum(start.first)&1) && !(targetNixuNum&1)) ) { cout << "无法从初始节点到终态节点 "; exit(0); } //初始化open表，将初始状态加入 open[0].state = start.first; open[0].h = calculate(start.first, target.first); // 计算当前节点到目标节点的估计距离 open[0].blank = start.second; open[0].pre = -1; // 初始节点无父节点 open[0].g = 0; // 初始节点的g为0 index = 0; states.insert(start.first); // 扩展过节点保存在states中，即出现过的状态保存在states中，states为set<int>类型，其中的states中的元素唯一 //提取open表中f值最小元素放入closed表，并对该结点进行扩展 for (end = 1; end > 0; ++index) // end为open表中的元素个数，一直循环到open表为空 { assert(index < MAXSTEPS); //临时存储 head = open[0]; // 由于使用pop_heap函数和push_heap函数，所以open[0]为g+h最小的元素 //放入closed表记录当前格局和由哪个结点扩展而来（该结点肯定已在closed表中） closed[index].first = open[0].state; //放入close表中，表示已经扩展完的节点，下面的for循环会扩展其节点 closed[index].second = open[0].pre; // index表示当前close表中当前扩展节点的下标 //从open表中删除该结点 pop_heap(open, open + end, cmp());//为algorithm文件中的函数，第一个参数指定开始位置，第二个指定结束，第三个指定比较函数 --end; //得到结果，递归输出路径 if (head.state == target.first) { path(index); break; } x = head.blank / 3; y = head.blank % 3; //空格在3*3方格中的x,y坐标 /* |2 0 3| A = |1 8 4| |7 6 5| // 看成3*3的数组 则head.blank=1 x=0,y=1,即空格的在3*3的数组中下标为(0,1) */ for (i = 0; i < 4; ++i) { nx = x + xtran[i]; ny = y + ytran[i]; /* i=0时：(nx,ny）为当前空格向上移动一格后的坐标 i=1时：(nx,ny）为当前空格向右移动一格后的坐标 i=2时：(nx,ny）为当前空格向下移动一格后的坐标 i=3时：(nx,ny）为当前空格向左移动一格后的坐标 */ if (suit(nx, ny)) // 判断是否能够移动 { a = head.blank; // 空格当前位置,以上面矩阵A为例，a=1 b = nx * 3 + ny; // 空格移动后的新位置,开始是能够向右边移动，故b=0*3+2=2 //调换十进制表示整数对应两个数字位 next = head.state + ((head.state % p[a + 1]) / p[a] - (head.state % p[b + 1]) / p[b]) * p[b] + ((head.state % p[b + 1]) / p[b] - (head.state % p[a + 1]) / p[a]) * p[a]; // 如head.state=567481302,空格向右移动一次后，next=567481032,即为移动后的节点 // 判断能否由当前节点到达目标节点 if( ( getNixuNum(next)&1 && targetNixuNum&1 ) || ( !(getNixuNum(next)&1) && !(targetNixuNum&1) ) ) { //判断是否已经扩展过，即已经出现过 if (states.find(next) == states.end()) //没出现就保存一下，也存入open表 { states.insert(next); open[end].pre = index; //扩展后的子节点，其父节点为当前扩展节点 open[end].blank = b; open[end].state = next; open[end].h = calculate(next,target.first); open[end].g = head.g + 1; ++end; //open表中元素加1 push_heap(open, open + end, cmp()); //压入堆中 } } } } } if (end <= 0) puts("No solution"); else { printf("Num of steps: %d ", steps); printf("Num of expanded: %d ", index); printf("Num of generated: %d ", index + end); printf("Time consumed: %d ", clock() - t2); } states.clear(); steps = 0; } printf("Total time consumed: %d ", clock() - t1); return 0;}

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;elsereturn 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 : //upif (pnt.y + 1 < 3){chang = (pnt.y + 1) * 3 + pnt.x ;array[zero] = array[chang];array[chang] = 0;moveok = true;}break;case 1 : //downif (pnt.y - 1 > -1){chang = (pnt.y - 1) * 3 + pnt.x ;array[zero] = array[chang];array[chang] = 0;moveok = true;}break;case 2 : //leftif (pnt.x + 1 < 3){chang = pnt.y * 3 + pnt.x + 1;array[zero] = array[chang];array[chang] = 0;moveok = true;}break;case 3 : //rightif (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 , "^_^ ! 搞定了! 计算步骤用时%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 iparentID++;}m_iTime = clock() - tim;FreeTree(m_pPlaceList);delete[] m_pScanbuf;m_pScanbuf = NULL;return false;}重要函数的介绍结束;下面是程序的运行结果和运算结果：

空调he模式的故障代码问题主要是室外机主控板双八数码管上出现问题，又或者RFC过电流保护等问题，根据检查室外机主控板双八数码管上的故障代码、维修手册、检测电网及电压变化。1、可能故障点：电网电压突然变化、电抗器、PFC电感短路、外机控制器故障。2、hc也可能代表在化霜。空调器在暖房运转时，经过一段时间后，室外机冷凝器会大量结霜而影响空调的正常制热，这时空调器会自动进入化霜模式。3、通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障，可能原因是由于风机驱动板异常所导致。4、根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件5、PFC过电流保护，检测电网电压是否发生突然变化，如果是，则是属于正常保护。如果不是，要来确定电抗器、PFC电感是否短路，如果是电抗器、PFC电感短路，则需要更换电抗器、PFC电感，如果不是电抗器、PFC电感短路，则需要更换外机电器盒。

格力空调显示HC，可能是外机控制板PFC保护。一般空调上的PFC保护是指压缩机启动系统上有问题；可能是风机驱动电流检测电路故障，通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障，建议立即报修。格力空调显示hc的解决方法1、首先检查电源格力空调有电源的表现为，刚通电时，都会发出很清脆的“嘀”的一声响，那么空调电源就是正常的，然后看空调遥控器有没有电池或电池电量是否足够。2、检查连接线是否断裂可能是因为室内机和室外机之间的连接线被老鼠咬断了，联系工作人员接好即可正常运行。3、长时间不保养长时间的不保养会使空调室外机无法正常运转从而提示hc故障，需要保养或者清理一下污垢，即可正常使用。4、环境温度过高导致系统保护环境温度过高、室外机通风不良有网罩或墙体在室外机前方遮挡导致空调热量吹不出去，温度过高时，压缩机自动启动保护，只需暂停使用30分钟到一小时，重新启动即可解决。5、电压的原因检查电压是不是达到额定电压。如果不是电压低的原因就请检查室内、外机连接是否接对，是否因为移动空调导致线路错误。6、检查是内机和外机的通讯如室外机有电源，红色指示灯亮，外机不启动，可检查是内机和外机的通讯，任何一种灯闪烁为正常，否则通讯有问题。7、氟立昂不足下运转造成制冷剂不足的根本原因。解决方法：为空调补充氟利昂。

格力显示"HC"故障的原因分析HC是风机驱动电流检测电路故障故障显示：室外机主板显示HC故障判断条件和方法：通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。可能原因：风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件；可能故障点：电网电压突然变化；电抗器、PFC电感短路；外机控制器故障。处理流程如下：建议联系格力专业网点维修！扩展资料：常见故障一、室外机不工作1、开机后检查室外机有无220V电压，如没有，请检查室内、外机连接是否接对，室内机主板接线是否正确，否则更换内机主板。2、如上电蜂鸣器不响，请检查变压器。3、如外机有220V电压，检查外机主板上红色指示灯是否亮，否则检查外机连接线是否松动，电源模块P+、N-间是否有300V左右的直接电压，如没有，则检查电抗器，整流桥及接线。如果有，但外机主板指示灯不亮，先检查电源模块到主板信号连接线（共10根）是否松脱或接触不良，再不行，请更换电源模块，更换模块时，在散热器与模块之间一定要均匀涂上散热膏。4、如室外机有电源，红色指示灯亮，外机不启动，可检查是内、外机通讯，（检查方法：开机后按“TEST”键一次，观察室内机指示灯），任何一种灯闪烁为正常，否则通讯有问题；检查内外机连接线是否为专用的扁平线，否则更换之。如通讯正常，请检查室内外机感温包是否开路或短路或阻值不正常，过载保护器端子北京空调维修是否接好。以上两方法均不能解决，则更换室外控制器。5、如空调开机11分钟左右停机，且不能启动，请检查室内管温感温包是否开路；如开机后再启动，外风机不启动，检查室内、外感温头是否短路。二、空调开机后一直低频运转请检查室内管温、室外环境、压缩机及化霜感温包是否有开路或短路、阻值不正常现象。参考资料：百度百科—格力空调故障代码

有以下几种情况。第一、风机驱动电流检测电路出现故障。第二、风机驱动板异常，一般都是电网电压突然变化等的故障原因。1、室外机主板显示HC，可以通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。2、风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件.3、压机过流保护，故障包括压机卡缸，若定变包括启动电容，变频调速包括驱动模块等。4、制冷剂不足引起的保护，这种现象若是控装了几年的机器，在加制冷剂前必须测试制冷剂压力，若差得不多，就可补点制冷剂，若差得太多，就需要捡查漏点，维修好后才能加压24小_不漏，在抽真空加制冷剂试机。5、室内机器过滤网太脏堵塞，造成热保护，如果这个问题自己去掉就可以清洗。包括传感器和传感器控制电路自身损坏不良也可能引起保护不工作。

空调室内机P8表示IPM模块温度过高保护，主要是保证IPM模块工作在可靠的温度范围内，防止温度过高损坏。还可能是室外机系统异常，压缩机电流太大，要买合适的稳压器，给空调适当的电压。空调显示屏出现P8是压缩机过热保护动作。这种情况一般是空调电压不正常，或者空调制冷系统出现故障造成空调室外机不工作，或者是空调室外机的高低压保护，还有可能是空调的温度传感器出现损坏。空调显示P8还有一种情况是空调散热片温度过高。建议查看空调室内机、室外机翅片是不是灰尘堆积，或者室内机滤网是不出现堵塞情况。外机控制板PFC保护。大多数情况下，空调上的PFC保护是指压缩机启动系统上出现故障。很有可能是风机驱动电流检测电路故障，建议查看室外机主控板双八数码管上的故障代码，如果空调的数码管上显示HC字样，那么就是风机驱动电流检测电路出现故障，建议找专业人员维修。不同的空调的故障情况和代码含义是完全不同的。如果参照以上代码仍然无法解决问题，建议直接找售后维修。

HC代表风机驱动电流检测电路故障。通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障，可能原因是由于风机驱动板异常所导致。根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件。扩展资料：1、如果电压过低，考虑安装电压调节器。2、室外机散热不良，室内机滤网和室外机冷凝器太脏。3、外部机械和电气容量或压缩机问题。4、如果已经修复，系统中可能有过量的氟化物或空气。解决方案：1、供电电压低于187V。今天的空调都设计了宽电源，但是如果低于这个数，空调是不会启动的！2、建议清洗内机的过滤网和外机的冷凝器，以免太脏造成保护。3、如果控制板故障，请检查电压是否正常后再更换控制板。如果不稳定，建议安装稳压器。

空调出现hc代码时，可能是风机驱动电流检测电路故障，如果确定是这个故障，检测是否PFC电路元器件损坏。通过查看室外机主控百板双八数码管上的故障代码，如度果数码管上显示HC，则可判断为风机驱动电流检测电路故障。故障显示：室外机主板显示HC故障判断条件和方法：通过查看室外机主控百板双八数码管上的故障代码，如度果数码管上显示HC，则可判断为风机驱动电流检测电路故障。可能原因：风机驱动板异常根据维修手册室内机显示“问HC”为PFC过电流保答护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件。可能故障点电网电压突然变化、电抗器、PFC电感短路、外机控制器故障。处理流程如下：结语：以上就是空调显示“HC”故障，对我们来说出现故障并不可怕，这是非常正常的事情，最主要的是找到正确的方法来解决故障问题，避免影响我们的使用效果。在日常使用的时候，大家一定要保持正确的使用方法，只有这样才能够更好的容保证空调的正常使用，也不会容易出现故障问题，希望上文的介绍能够帮到大家，在以后使用空调的时候都能够有更好的效果。

格力空调显示HC，可能是外机控制板PFC保护，一般空调上的PFC保护是指压缩机启动系统上有问题；可能是风机驱动电流检测电路故障，通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障，建议立即报修。

格力空调显示HC，可能是外机控制板PFC保护。一般空调上的PFC保护是指压缩机启动系统上有问题；可能是风机驱动电流检测电路故障，通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障，建议立即报修。格力空调显示hc的解决方法1、首先检查电源格力空调有电源的表现为，刚通电时，都会发出很清脆的“嘀”的一声响，那么空调电源就是正常的，然后看空调遥控器有没有电池或电池电量是否足够。2、检查连接线是否断裂可能是因为室内机和室外机之间的连接线被老鼠咬断了，联系工作人员接好即可正常运行。3、长时间不保养长时间的不保养会使空调室外机无法正常运转从而提示hc故障，需要保养或者清理一下污垢，即可正常使用。4、环境温度过高导致系统保护环境温度过高、室外机通风不良有网罩或墙体在室外机前方遮挡导致空调热量吹不出去，温度过高时，压缩机自动启动保护，只需暂停使用30分钟到一小时，重新启动即可解决。5、电压的原因检查电压是不是达到额定电压。如果不是电压低的原因就请检查室内、外机连接是否接对，是否因为移动空调导致线路错误。6、检查是内机和外机的通讯如室外机有电源，红色指示灯亮，外机不启动，可检查是内机和外机的通讯，任何一种灯闪烁为正常，否则通讯有问题。7、氟立昂不足下运转造成制冷剂不足的根本原因。解决方法：为空调补充氟利昂。

U2:外机容量码/跳线帽设定错误；L0:室内机故障；d9:跳线帽故障；先解决第一个U2故障代码，检查一下外机的容量是不是错了？前面提到更换过外机主板，更换新主板需要把新板的容量码和其它功能码全部从新拨码，设定的和旧主板一样。现场询问得知，是维修人员新更换了新外机主板，更换后开始报故障，同时出现多个故障代码，有点慌，不知道从哪里下手！使用电脑软件检测，发现外机的容量不对，软件显示外机容量是250，实际是450，问题出在哪里了？出在外机的容量码没有拨对，从新设定正确地址码以后，再上电，U2故障消失，解决一个故障，外机主板双八数码管还显示L0和d9故障；再解决d9跳线帽故障，怎么会出现跳线帽故障呢？是不是跳线帽忘记安装了呢？检查外机主板安装跳线帽的位置是空的，看来判断是正确的，从其台同型号主机上拆一个，把跳线帽小心的拆下来，插到主板上，再给主板供电，d9故障代码消失！又排除一个故障！最后来解决L0“内机故障”，现场查看内机主板为更换过，不是原装板，原装板子的容量码用棒棒胶封着！既然是更换的主板，先把主板上的接线端子插件检查一遍，都到位了。再去核实内机主板的容量，新板拨码方式和旧板一致！那么这个故障经过要转走了，暂时销售单位请示了上级单位，他们要求一定处理妥当！L0故障代码是什么呢？是内机故障，只能先排除外接电压问题，调整了主板和插件以后，再次上电开机，空调能正常运行，说明是新更换的主板忘记拨码造成的，把容量码拨好，上电开机，竟然没有故障了！

HC是因为风机驱动电流出现了一个故障，具体还是风机驱动板异常导致的一个情况，还有就是出现了电流保护，或者是离心风机驱动板出现异常才导致的一个问题。1、风机驱动电流检测电路出现故障，通过查看室外机主控板上的双八数码管故障码，如果数码管上显示 HC，就可以判断出风机驱动电流检测电路有故障，可能是风机驱动电流检测电路出现故障。2、过流保护，室外机黄灯闪烁14次。在压缩机起动时检测电路的电流，若超过保护值则保护停机，防止 PFC电路元件电流过大损坏。具体是电网电压突变，电抗器、 PFC感应短路，外部控制器故障。3、也许是离心式风机的驱动电流检测电路出现故障，假如确定是这个故障，检验是否是 PFC电路的电子元件损坏。如果数字管上显示了 HC，那么根据查询室外机双八数码管的故障编码，就可以判断出散热风扇驱动电流检测电路有故障。4、离心式风机的驱动板不正常，室外机灯闪烁14次。假如制冷压缩机启动检查电路的电流量，假如超出维护值则维持关闭，以免 PFC电路电子器件损坏。电力系统工作电压骤降、串联电抗器、 PFC感应器短路故障、外部控制板故障。

1.娃娃机故障常见问题和处理方法：一、新娃娃机买回去通电后天车不归位，机台双八数码管（机台显示屏）报01不断闪烁的处理方法： 1.先打开娃娃机的门关机，监测天车上面的捆绑带是否完全去除。二、平时可正常运行的机台报01故障的处理办法： 先关机，再监测天车最后的停留位置。 （1）娃娃机的天车爪子停留半空处理方法： 将主板与其它机台的主板兑换，看看问题是否随主板故障移动。 （2）天车未完全归为，即向左与右，前和后或者两个方向都没有归位处理办法： 1.将主板与其它机台的主板兑换一下，看看问题是天车归位了，还是跟之前的毛病一样。 2.天车归位的话是主板的问题，跟之前一样的，还是不归位的是天车的问题哦。 （3）天车还没归位到原点处理方法： 1.关机，2.将天车用手推到中间，开机。 3.观察天车的运作情况，看看天车运行到原点后向左与右操作人观察两个方向中那个方向在报01之前还在继续运作的。 如果向左还在运作，则可能是左停微动开关来压到为损坏。此时可用手按住左停微动，重新开机，则为左停微动来压到位，在微动开关将其上的铁皮向外弯即可。 如上面的都无效，可以将微动开关上的两接线引脚短路，重新开机，不报故障则为微动开关损坏了，更换即可。（向操作者方向则检查回停微动）三、娃娃机机台无显示的处理办法： 1.观察在主板哪里的小排插的电源灯是否亮着，不亮看看是不是娃娃机里面的排插坏了。 2.观察电源盒的灯是否正常亮灯，不正常那就是电源盒坏了。正常的话可以更换一个好的电源盒再观察娃娃机的问题。四、娃娃机一通电就烧保险丝的处理办法： 1.先关机，将娃娃机里边的排插插头拔掉，就是在主板旁边的那个小排插拔了，再开机，看看还有没有烧保险丝。 2.将娃娃机里边的插头一个个插上，插一个重新开机一次，当那个插头插上时再次烧保险丝即该插头的某部分损坏。注意问题：对于电源盒娃娃机上边更新，在维护中，可先将好的娃娃机部件往坏的娃娃机上更换，不可先将坏的，不知道坏没有坏的往正常的娃娃机上更换，以防止损坏好的娃娃机。如上述都不能解答您的问题，请与原厂家联系，因为每个厂家的制造工艺这里都没有一个制造标准的，以上为娃娃机故障处理的问题。

....好好看书吧．．．

空调显示E0初判断是整机交流电压下降降频这个问题。这时候可以找专业人员来维修。要是自身有维修技术那具体的还要打开室外侧板，查看外机主板显示什么故障？找到原因有针对性的排除故障。下面是找室外机故障原因的四步骤。1.打开室外机面板，查看室外机主板指示灯上的双八数码管，根据室外机主板指示灯的故障代码查找说明书中的故障代码表，确认详细故障并进行排查。2.机线控器显示“E0”外机显示“U3”是电源缺逆相保护原因。3.机线控器显示E0，外机数码管显示“Ed”冷媒不足保护导致。4.机线控器显示“E0”，外机主板双八数码管显示“Fd”高压开关故障。按上面步骤找到原因再进行维修。

一、夏普空调出现e0故障代码怎么办? 空调显示E0初判断是整机交流电压下降降频这个问题。这时候可以找专业人员来维修。要是自身有维修技术那具体的还要打开室外侧板，查看外机主板显示什么故障?找到原因有针对性的排除故障。下面是找室外机故障原因的四步骤。 1、打开室外机面板，查看室外机主板指示灯上的双八数码管，根据室外机主板指示灯的故障代码查找说明书中的故障代码表，确认详细故障并进行排查。 2、内机线控器显示“E0”外机显示“U3”是电源缺逆相保护原因。 3、内机线控器显示E0，外机数码管显示“Ed”冷媒不足保护导致。 4、内机线控器显示“E0”，外机主板双八数码管显示“Fd”高压开关故障。 按上面步骤找到原因再进行维修。 二、夏普空调显示e0怎么解决 夏普空调显示e0，说明出现压缩机低压保护的现象。可能是环境温度过低导致出现低压保护，也可能是控制故障或者系统故障。以下是具体原因和解决方法： 1、可能是环境温度过低导致出现低压保护： 这种情况建议用温度枪探测周围环境温度确认，如果环境温度正常，则建议联系售后派工程师上门检查空调温度探测设备部分是否异常。 2、可能是控制故障或者系统故障： 这种情况可以先把主控板上的LPP插头和主板上的零线N短接起来，如果室内机运行正常，可确定室内机主板或显示板没问题，故障出现在室内、外机连接线、插接头或室外机低压开关上。 3、可能是线路问题或者低压开关问题： 这种情况可以把外机连接线和插头，把万用表调在欧姆挡上，把一个表笔接在主板上拔掉的LPP保护线上，另一个表笔接在零线N上，如果阻值为0，说明故障在低压开关上，反之是线路问题。 最后可以通过压力表来判断是系统漏氟，还是堵塞。

启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无谓的搜索路径，提高了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。我们先看看估价是如何表示的。 　　启发中的估价是用估价函数表示的，如： 　　最佳优先搜索的最广为人知的形式称为A*搜索(发音为“A星搜索”).它把到达节点的耗散g(n) 　　和从该节点到目标节点的消耗h(n)结合起来对节点进行评价：f(n)=g(n)+h(n) 　　因为以g(n)给出了从起始节点到节点n的路径耗散，而h(n)是从节点n到目标节点的最低耗散路径的估计耗散值，因此f(n)=经过节点n的最低耗散解的估计耗散.这样，如果我们想要找到最低耗散解，首先尝试找到g(n)+h(n)值最小的节点是合理的。可以发现这个策略不只是合理的:倘若启发函数h(n)满足一定的条件，A*搜索既是完备的也是最优的。 　　如果把A*搜索用于Tree-Search,它的最优性是能够直接分折的。在这种情况下，如果h(n)是一个可采纳启发式--也就是说，倘若h(n)从不会过高估计到达目标的耗散--A*算法是最优的。可采纳启发式天生是最优的，因为他们认为求解问题的耗散是低于实际耗散的。因为g(n)是到达节点n的确切耗散，我们得到一个直接的结论：f(n)永远不会高估经过节点n的解的实际耗散. 　　启发算法有： 蚁群算法，遗传算法、模拟退火算法等 　　蚁群算法是一种来自大自然的随机搜索寻优方法，是生物界的群体启发式行为，现己陆续应用到组合优化、人工智能、通讯等多个领域。蚁群算法的正反馈性和协同性使其可用于分布式系统，隐含的并行性更使之具有极强的发展潜力。从数值仿真结果来看，它比目前风行一时的遗传算法、模拟退火算法等有更好的适应性。

　　动态规划解0-1背包：　　#include<iostream>　　using namespace std;　　//显然定义为全局变量不好　　const int item=3;//物品数量　　const int max_wgt=10;//背包最大容量　　int c[item+1][max_wgt+1];//从1…i…item物品中,背包剩余空间为0<=j<=max_wgt的最大价值　　int w[item+1]={0,3,4,5};//物品质量　　int vl[item+1]={0,4,5,6}; //物品价值　　int knapbag()　　{　　for (int i=0;i<=item;i++)//初始化　　{　　for (int j=0;j<=max_wgt;j++)　　{　　c[i][j]=0;　　}　　}　　//c(i,j)=max{c(i-1,j), c(i-1,j-w[i])+vl(i)}　　for (int i=1;i<=item;i++)　　{　　for (int j=1;j<=max_wgt;j++)　　{　　if (w[i]<=j)　　{　　if (vl[i]+c[i-1][j-w[i]]>c[i-1][j])　　{　　c[i][j]=vl[i]+c[i-1][j-w[i]];//选择第i物品　　}　　else　　c[i][j]=c[i-1][j];//不选择第i个物品　　}　　else　　c[i][j]=c[i-1][j];//剩余容量不够　　}//endfor　　}//endfor　　return c[item][max_wgt];//返回最大值　　}　　int main()　　{　　cout<<knapbag()<<endl;　　return 0;　　}　　void trackback()//算出是由哪几个物品组成　　{　　int temp_wei=max_wgt;　　int x[item+1]={0,0,0,0};　　for (int i=item;i>0;i--)　　{　　if (c[i][temp_wei]==c[i-1][temp_wei])//最后一个肯定是最大价值的　　{　　x[i]=0;　　}　　else　　{　　x[i]=1;　　temp_wei-=w[i];　　}　　}　　for (int i=0;i<=item;i++)　　{　　if (x[i])　　{　　std::cout<<i<<",";　　}　　}　　std::cout<<std::endl;　　}　　最长公共子序列：　　最长公共子序列的定义是，一个数列z分别是已知数列的子序列（子序列不一定是连续序列，是在该序列中删去若干元素后得到的序列），且是所有符合此条件序列中最长的，则z成为最长公共子序列lcs(Longest Common Subsequences)。有些地方则说公共子串就是要求连续的子序列，有些地方则不是，这里要注意区分。下面是完整实现代码。　　#include <iostream>　　using namespace std;　　void LCS_Length(char *x,char *y,int **b,int m,int n)　　{　　//c[i][j]表示x[i-1],y[j-1]之前公共子序列的长度,i表示x数组前进，j表示y数组前进　　//不用c[i][j]表示x[i],y[j]之前公共子序列的长度是因为需要使用c[0][0]来表示没有公共子序列，　　//即c[0][0]恒等于0，因此c数组最大下标为c[m+1][n+1]　　int **c;　　c=new int*[m+1];　　for( int i=0;i<m+1;i++)　　c[i]=new int[n+1];　　for(int i=0;i<m+1;i++)　　c[i][0]=0;　　for(int i=0;i<n+1;i++)　　c[0][i]=0;　　for(int i=1;i<=m;i++)　　{　　for(int j=1;j<=n;j++)　　{　　if(x[i-1]==y[j-1])//找到一个公共“字符”　　{　　c[i][j]=c[i-1][j-1]+1;//公共子序列的长度在原来的基础上加1　　b[i][j]=0;//做一个辅助标志，表示要达到目前的长度，x，y数组均需“前进”一步　　//即x[i-1]，y[j-1]都要作出贡献　　}　　//当前字符不相同，且x数组后退一步（即c[i-1][j]）比y数组后退一步（即c[i][j-1]）　　//所得到的公共子序列的长度要长，隐含的意思是当前最长公共子序列可以不需要x[i-1]　　else if(c[i-1][j]>=c[i][j-1])　　{　　c[i][j]=c[i-1][j];//当前最长公共子序列可以不需要x[i-1]　　b[i][j]=-1;　　}　　//和上面分析类似　　else　　{　　c[i][j]=c[i][j-1];//当前最长公共子序列可以不需要y[j-1]　　b[i][j]=1;　　}　　}　　}　　for(int i=0;i<m+1;i++)　　{　　delete c[i];　　c[i]=NULL;　　}　　delete []c;　　c=NULL;　　}　　//打印结果　　void Print_LCS(int **b,char *x,int i,int j)　　{　　if(i==0||j==0)　　return ;　　if(b[i][j]==0)　　{　　Print_LCS(b,x,i-1,j-1);　　cout<<x[i-1];　　}　　else if(b[i][j]==-1)　　Print_LCS(b,x,i-1,j);　　else　　Print_LCS(b,x,i,j-1);　　}　　int _tmain(int argc, _TCHAR* argv[])　　{　　char x[]="ADAB";　　char y[]="ADCA";　　int m=strlen(x);　　int n=strlen(y);　　int **b;　　b=new int*[m+1];　　for( int i=0;i<m+1;i++)　　b[i]=new int[n+1];　　LCS_Length(x,y,b,m,n);　　Print_LCS(b,x,m,n);　　for(int i=0;i<m+1;i++)　　{　　delete b[i];　　b[i]=NULL;　　}　　delete []b;　　b=NULL;　　return 0;　　}　　A*算法　　1.启发式搜索　　广度优先搜索和双向广度优先搜索都属于盲目搜索，这在状态空间不大的情况下是很合适的算法，可是当状态空间十分庞大时，它们的效率实在太低，往往都是在搜索了大量无关的状态结点后才碰到解答，甚至更本不能碰到解答。　　搜索是一种试探性的查寻过程，为了减少搜索的盲目性引，增加试探的准确性，就要采用启发式搜索了。所谓启发式搜索就是在搜索中要对每一个搜索的位置进行评估，从中选择最好、可能容易到达目标的位置，再从这个位置向前进行搜索，这样就可以在搜索中省略大量无关的结点，提高了效率。　　2.A*算法　　A*算法是一种常用的启发式搜索算法。　　在A*算法中，一个结点位置的好坏用估价函数来对它进行评估。A*算法的估价函数可表示为：　　f"(n) = g"(n) + h"(n)　　这里，f"(n)是估价函数，g"(n)是起点到终点的最短路径值（也称为最小耗费或最小代价），h"(n)是n到目标的最短路经的启发值。由于这个f"(n)其实是无法预先知道的，所以实际上使用的是下面的估价函数：　　f(n) = g(n) + h(n)　　其中g(n)是从初始结点到节点n的实际代价，h(n)是从结点n到目标结点的最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。用f(n)作为f"(n)的近似，也就是用g(n)代替g"(n)，h(n)代替h"(n)。这样必须满足两个条件：（1）g(n)>=g"(n)（大多数情况下都是满足的，可以不用考虑），且f必须保持单调递增。（2）h必须小于等于实际的从当前节点到达目标节点的最小耗费h(n)<=h"(n)。第二点特别的重要。可以证明应用这样的估价函数是可以找到最短路径的。　　3.A*算法的步骤　　A*算法基本上与广度优先算法相同，但是在扩展出一个结点后，要计算它的估价函数，并根据估价函数对待扩展的结点排序，从而保证每次扩展的结点都是估价函数最小的结点。　　A*算法的步骤如下：　　1）建立一个队列，计算初始结点的估价函数f，并将初始结点入队，设置队列头和尾指针。　　2）取出队列头（队列头指针所指）的结点，如果该结点是目标结点，则输出路径，程序结束。否则对结点进行扩展。　　3）检查扩展出的新结点是否与队列中的结点重复，若与不能再扩展的结点重复（位于队列头指针之前），则将它抛弃；若新结点与待扩展的结点重复（位于队列头指针之后），则比较两个结点的估价函数中g的大小，保留较小g值的结点。跳至第五步。　　4）如果扩展出的新结点与队列中的结点不重复，则按照它的估价函数f大小将它插入队列中的头结点后待扩展结点的适当位置，使它们按从小到大的顺序排列，最后更新队列尾指针。　　5）如果队列头的结点还可以扩展，直接返回第二步。否则将队列头指针指向下一结点，再返回第二步。　　4.八数码问题的A*算法的估价函数　　估价函数中，主要是计算h，对于不同的问题，h有不同的含义。那么在八数码问题中，h的含意是各什么？八数码问题的一个状态实际上是数字0~8的一个排列，用一个数组p[9]来存储它，数组中每个元素的下标，就是该数在排列中的位置。例如，在一个状态中，p[3]=7，则数字7的位置是3。如果目标状态数字3的位置是8，那么数字7对目标状态的偏移距离就是3，因为它要移动3步才可以回到目标状态的位置。　　八数码问题中，每个数字可以有9个不同的位置，因此，在任意状态中的每个数字和目标状态中同一数字的相对距离就有9*9种，可以先将这些相对距离算出来，用一个矩阵存储，这样只要知道两个状态中同一个数字的位置，就可查出它们的相对距离，也就是该数字的偏移距离：　　0 1 2 3 4 5 6 7 8　　0 0 1 2 1 2 3 2 3 4　　1 1 0 1 2 1 2 3 2 3　　2 2 1 0 3 2 1 4 3 2　　3 1 2 3 0 1 2 1 2 3　　4 2 1 2 1 0 1 2 1 2　　5 3 2 1 2 1 0 3 2 1　　6 2 3 4 1 2 3 0 1 2　　7 3 2 3 2 1 2 1 0 1　　8 4 3 2 3 2 1 2 1 0　　例如在一个状态中，数字8的位置是3，在另一状态中位置是7，那么从矩阵的3行7列可找到2，它就是8在两个状态中的偏移距离。　　估价函数中的h就是全体数字偏移距离之和。　　显然，要计算两个不同状态中同一数字的偏移距离，需要知道该数字在每个状态中的位置，这就要对数组p[9]进行扫描。由于状态发生变化，个数字的位置也要变化，所以每次计算h都沿线扫描数组，以确定每个数字在数组中的位置。为了简化计算，这里用一个数组存储状态中各个数字的位置，并让它在状态改变时随着变化，这样就不必在每次计算h时，再去扫描状态数组。　　例如，某个状态中，数字5的位置是8，如果用数组r[9]存储位置，那么就有r[5]=8。　　现在用数组r[9]存储当前状态的数字位置，而用s[9]存储目标状态的数字位置，那么当前状态数字i对目标状态的偏移距离就是矩阵中r[i]行s[i]列对应的值。　　5.A*算法的类结构　　A*算法的类声明如下：　　class TAstar:public TEight　　{　　public:　　TAstar(){} //构造函数　　TAstar(char *fname); //带参数构造函数　　virtual void Search(); //A*搜索法　　private:　　int f,g,h; //估价函数　　int r[Num]; //存储状态中各个数字位置的辅助数组　　static int s[Num]; //存储目标状态中各个数字位置的辅助数组　　static int e[]； //存储各个数字相对距离的辅助数组　　void Printl(TList<TAstar> L); //成员函数，输出搜索路径　　int Expend(int i); //成员函数，A*算法的状态扩展函数　　int Calcuf(); //成员函数，计算估价函数　　void Sort(TList<TAstar>& L,int k); //成员函数，将新扩展结点按f从小到大　　//顺序插入待扩展结点队列　　int Repeat(TList<TAstar> &L); //成员函数，检查结点是否重复　　};　　int TAstar::s[Num],TAstar::e[Num*Num];　　TAstar::TAstar(char *fname):TEight(fname)　　{　　for(int i=0;i<Num;)　　{　　r[p[i]]=i; //存储初始状态个个数字的位置　　s[q[i]]=i++; //存储目标状态个个数字的位置　　}　　ifstream fin;　　fin.open(".Eightd.txt",ios::in | ios::nocreate);//打开数据文件　　if(!fin)　　{　　cout<<"不能打开数据文件!"<<endl;　　return;　　}　　for(i=0;i<Num*Num;i++) //读入各个数字相对距离值　　fin>>e[i];　　fin.close();　　f=g=h=0; //估价函数初始值　　}　　void TAstar::Printl(TList<TAstar> L)　　{　　TAstar T=*this;　　if(T.last==-1)　　return;　　else　　{　　T=L.GetData(T.last);　　T.Printl(L);　　T.Printf();　　}　　}　　int TAstar::Expend(int i)　　{　　if(Extend(i)) //结点可扩展　　{　　int temp=r[p[r[0]]]; //改变状态后数字位置变化，存储改变后的位置　　r[p[r[0]]]=r[0];　　r[0]=temp;　　return 1;　　}　　return 0;　　}　　int TAstar::Calcuf()　　{　　h=0;　　for(int i=0;i<Num;i++) //计算估价函数的h　　h+=e[Num*r[i]+s[i]];　　return ++g+h;　　}　　void TAstar::Sort(TList<TAstar>& L,int k)　　{　　int n=L.Getlen();　　for(int i=k+1;i<n;i++)　　{　　TAstar T=L.GetData(i);　　if(this->f<=T.f)　　break;　　}　　L.Insert(*this,i);　　}　　int TAstar::Repeat(TList<TAstar> &L)　　{　　int n=L.Getlen();　　for(int i=0;i<n;i++)　　if(L.GetData(i)==*this)　　break;　　return i;　　}　　void TAstar::Search()　　{　　TAstar T=*this; //初始结点　　T.f=T.Calcuf(); //初始结点的估价函数　　TList<TAstar> L; //建立队列　　L.Append(T); //初始结点入队　　int head=0,tail=0; //队列头和尾指针　　while(head<=tail) //队列不空则循环　　{　　for(int i=0;i<4;i++) //空格可能移动方向　　{　　T=L.GetData(head); //去队列头结点　　if(T.h==0) //是目标结点　　{　　T.Printl(L);//输出搜索路径　　T.Print(); //输出目标状态　　return; //结束　　}　　if(T.Expend(i)) //若结点可扩展　　{　　int k=T.Repeat(L); //返回与已扩展结点重复的序号 if(k<head) //如果是不能扩展的结点　　continue; //丢弃　　T.last=head; //不是不能扩展的结点，记录父结点　　T.f=T.Calcuf(); //计算f　　if(k<=tail) //新结点与可扩展结点重复　　{　　TAstar Temp=L.GetData(k);　　if(Temp.g>T.g) //比较两结点g值　　L.SetData(T,k); //保留g值小的　　continue;　　}　　T.Sort(L,head) ; //新结点插入可扩展结点队列 tail++; //队列尾指针后移　　}　　}　　head++; //一个结点不能再扩展，队列头指针指向下一结点　　}　　}　　n皇后问题　　#include <iostream.h>　　#include <math.h>　　void Queue(int n)　　{　　for (i=1; i<=n; i++) //初始化　　x[i]=0;　　k=1;　　while (k>=1)　　{　　x[k]=x[k]+1; //在下一列放置第k个皇后　　while (x[k]<=n && !Place(k))　　x[k]=x[k]+1; //搜索下一列　　if (x[k]<=n && k= =n) { //得到一个解，输出　　for (i=1; i<=n; i++)　　cout<<x[i];　　return;　　}　　else if (x[k]<=n && k<n)　　k=k+1; //放置下一个皇后　　else {　　x[k]=0; //重置x[k]，回溯　　k=k-1;　　}　　}　　}　　bool Place(int k) //考察皇后k放置在x[k]列是否发生冲突　　{　　for (i=1; i<k; i++)　　if (x[k]= =x[i] | | abs(k-i)= =abs(x[k]-x[i]))　　return false;　　return true;　　}

格力显示"HC"故障的原因分析HC是风机驱动电流检测电路故障故障显示：室外机主板显示HC故障判断条件和方法：通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。可能原因：风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件；可能故障点：电网电压突然变化；电抗器、PFC电感短路；外机控制器故障。处理流程如下：建议联系格力专业网点维修！扩展资料：常见故障一、室外机不工作①开机后检查室外机有无220V电压，如没有，请检查室内、外机连接是否接对，室内机主板接线是否正确，否则更换内机主板。②如上电蜂鸣器不响，请检查变压器。③如外机有220V电压，检查外机主板上红色指示灯是否亮，否则检查外机连接线是否松动，电源模块P+、N-间是否有300V左右的直接电压，如没有，则检查电抗器，整流桥及接线。如果有，但外机主板指示灯不亮，先检查电源模块到主板信号连接线（共10根）是否松脱或接触不良，再不行，请更换电源模块，更换模块时，在散热器与模块之间一定要均匀涂上散热膏。④如室外机有电源，红色指示灯亮，外机不启动，可检查是内、外机通讯，（检查方法：开机后按“TEST”键一次，观察室内机指示灯），任何一种灯闪烁为正常，否则通讯有问题；检查内外机连接线是否为专用的扁平线，否则更换之。如通讯正常，请检查室内外机感温包是否开路或短路或阻值不正常，过载保护器端子北京空调维修是否接好。以上两方法均不能解决，则更换室外控制器。⑤如空调开机11分钟左右停机，且不能启动，请检查室内管温感温包是否开路；如开机后再启动，外风机不启动，检查室内、外感温头是否短路。二、空调开机后一直低频运转请检查室内管温、室外环境、压缩机及化霜感温包是否有开路或短路、阻值不正常现象。参考资料：百度百科——格力空调故障代码格力空调售后服务站——格力中央空调显示HC是什么故障？

格力显示"HC"故障的原因分析HC是风机驱动电流检测电路故障故障显示：室外机主板显示HC故障判断条件和方法：通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。可能原因：风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件；可能故障点：电网电压突然变化；电抗器、PFC电感短路；外机控制器故障。处理流程如下：建议联系格力专业网点维修！扩展资料：常见故障一、室外机不工作①开机后检查室外机有无220V电压，如没有，请检查室内、外机连接是否接对，室内机主板接线是否正确，否则更换内机主板。②如上电蜂鸣器不响，请检查变压器。③如外机有220V电压，检查外机主板上红色指示灯是否亮，否则检查外机连接线是否松动，电源模块P+、N-间是否有300V左右的直接电压，如没有，则检查电抗器，整流桥及接线。如果有，但外机主板指示灯不亮，先检查电源模块到主板信号连接线（共10根）是否松脱或接触不良，再不行，请更换电源模块，更换模块时，在散热器与模块之间一定要均匀涂上散热膏。④如室外机有电源，红色指示灯亮，外机不启动，可检查是内、外机通讯，（检查方法：开机后按“TEST”键一次，观察室内机指示灯），任何一种灯闪烁为正常，否则通讯有问题；检查内外机连接线是否为专用的扁平线，否则更换之。如通讯正常，请检查室内外机感温包是否开路或短路或阻值不正常，过载保护器端子北京空调维修是否接好。以上两方法均不能解决，则更换室外控制器。⑤如空调开机11分钟左右停机，且不能启动，请检查室内管温感温包是否开路；如开机后再启动，外风机不启动，检查室内、外感温头是否短路。二、空调开机后一直低频运转请检查室内管温、室外环境、压缩机及化霜感温包是否有开路或短路、阻值不正常现象。参考资料：百度百科——格力空调故障代码格力空调售后服务站——格力中央空调显示HC是什么故障？

空调的风扇驱动电流检测电路有故障。如果空调室外机主控板的双八进制数码管上显示HC，则可以判断风扇驱动电流检测电路出现故障。可能是空调内部风扇驱动板异常引起的。空调显示屏上出现“HC”表示PFC过流保护已经发生。具体来说，空调室外机的黄灯闪烁14次。检测方法如下:当空调压缩机启动时，检测电路的电流；如果超过保护值，空调就会停机保护。这样做是为了防止空调内部电流过大损坏PFC电路元件。HC很可能是由电抗器和PFC电感短路、电网电压突变和外部控制器故障引起的。空调室外机不工作的原因:1。室内机和室外机的接线有问题，或者室内机主板的接线出现故障。建议及时更换室内机主板。2.空调的电蜂鸣器不响，变压器故障。

格力显示"HC"故障的原因分析HC是风机驱动电流检测电路故障故障显示：室外机主板显示HC故障判断条件和方法：通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。可能原因：风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件；可能故障点：电网电压突然变化；电抗器、PFC电感短路；外机控制器故障。处理流程如下：建议联系格力专业网点维修！扩展资料：常见故障一、室外机不工作①开机后检查室外机有无220V电压，如没有，请检查室内、外机连接是否接对，室内机主板接线是否正确，否则更换内机主板。②如上电蜂鸣器不响，请检查变压器。③如外机有220V电压，检查外机主板上红色指示灯是否亮，否则检查外机连接线是否松动，电源模块P+、N-间是否有300V左右的直接电压，如没有，则检查电抗器，整流桥及接线。如果有，但外机主板指示灯不亮，先检查电源模块到主板信号连接线（共10根）是否松脱或接触不良，再不行，请更换电源模块，更换模块时，在散热器与模块之间一定要均匀涂上散热膏。④如室外机有电源，红色指示灯亮，外机不启动，可检查是内、外机通讯，（检查方法：开机后按“TEST”键一次，观察室内机指示灯），任何一种灯闪烁为正常，否则通讯有问题；检查内外机连接线是否为专用的扁平线，否则更换之。如通讯正常，请检查室内外机感温包是否开路或短路或阻值不正常，过载保护器端子北京空调维修是否接好。以上两方法均不能解决，则更换室外控制器。⑤如空调开机11分钟左右停机，且不能启动，请检查室内管温感温包是否开路；如开机后再启动，外风机不启动，检查室内、外感温头是否短路。二、空调开机后一直低频运转请检查室内管温、室外环境、压缩机及化霜感温包是否有开路或短路、阻值不正常现象。参考资料：百度百科——格力空调故障代码格力空调售后服务站——格力中央空调显示HC是什么故障？

有以下几种情况。第一、风机驱动电流检测电路出现故障。第二、风机驱动板异常，一般都是电网电压突然变化等的故障原因。1、室外机主板显示HC，可以通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。2、风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件.3、压机过流保护，故障包括压机卡缸，若定变包括启动电容，变频调速包括驱动模块等。4、制冷剂不足引起的保护，这种现象若是控装了几年的机器，在加制冷剂前必须测试制冷剂压力，若差得不多，就可补点制冷剂，若差得太多，就需要捡查漏点，维修好后才能加压24小_不漏，在抽真空加制冷剂试机。5、室内机器过滤网太脏堵塞，造成热保护，如果这个问题自己去掉就可以清洗。包括传感器和传感器控制电路自身损坏不良也可能引起保护不工作。

格力空调显示HC，可能是外机控制板PFC保护。一般空调上的PFC保护是指压缩机启动系统上有问题；可能是风机驱动电流检测电路故障，通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障，建议立即报修。格力空调显示hc的解决方法1、首先检查电源格力空调有电源的表现为，刚通电时，都会发出很清脆的“嘀”的一声响，那么空调电源就是正常的，然后看空调遥控器有没有电池或电池电量是否足够。2、检查连接线是否断裂可能是因为室内机和室外机之间的连接线被老鼠咬断了，联系工作人员接好即可正常运行。3、长时间不保养长时间的不保养会使空调室外机无法正常运转从而提示hc故障，需要保养或者清理一下污垢，即可正常使用。4、环境温度过高导致系统保护环境温度过高、室外机通风不良有网罩或墙体在室外机前方遮挡导致空调热量吹不出去，温度过高时，压缩机自动启动保护，只需暂停使用30分钟到一小时，重新启动即可解决。5、电压的原因检查电压是不是达到额定电压。如果不是电压低的原因就请检查室内、外机连接是否接对，是否因为移动空调导致线路错误。6、检查是内机和外机的通讯如室外机有电源，红色指示灯亮，外机不启动，可检查是内机和外机的通讯，任何一种灯闪烁为正常，否则通讯有问题。7、氟立昂不足下运转造成制冷剂不足的根本原因。解决方法：为空调补充氟利昂。

有以下几种情况。第一、风机驱动电流检测电路出现故障。第二、风机驱动板异常，一般都是电网电压突然变化等的故障原因。1、室外机主板显示HC，可以通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。2、风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件.3、压机过流保护，故障包括压机卡缸，若定变包括启动电容，变频调速包括驱动模块等。4、制冷剂不足引起的保护，这种现象若是控装了几年的机器，在加制冷剂前必须测试制冷剂压力，若差得不多，就可补点制冷剂，若差得太多，就需要捡查漏点，维修好后才能加压24小_不漏，在抽真空加制冷剂试机。5、室内机器过滤网太脏堵塞，造成热保护，如果这个问题自己去掉就可以清洗。包括传感器和传感器控制电路自身损坏不良也可能引起保护不工作。

空调显示E0初判断是整机交流电压下降降频这个问题。这时候可以找专业人员来维修。要是自身有维修技术那具体的还要打开室外侧板，查看外机主板显示什么故障？找到原因有针对性的排除故障。下面是找室外机故障原因的四步骤。1.打开室外机面板，查看室外机主板指示灯上的双八数码管，根据室外机主板指示灯的故障代码查找说明书中的故障代码表，确认详细故障并进行排查。2.机线控器显示“E0”外机显示“U3”是电源缺逆相保护原因。3.机线控器显示E0，外机数码管显示“Ed”冷媒不足保护导致。4.机线控器显示“E0”，外机主板双八数码管显示“Fd”高压开关故障。按上面步骤找到原因再进行维修。

空调的风扇驱动电流检测电路有故障。如果空调室外机主控板的双八进制数码管上显示HC，则可以判断风扇驱动电流检测电路出现故障。可能是空调内部风扇驱动板异常引起的。空调显示屏上出现“HC”表示PFC过流保护已经发生。具体来说，空调室外机的黄灯闪烁14次。检测方法如下:当空调压缩机启动时，检测电路的电流；如果超过保护值，空调就会停机保护。这样做是为了防止空调内部电流过大损坏PFC电路元件。HC很可能是由电抗器和PFC电感短路、电网电压突变和外部控制器故障引起的。空调室外机不工作的原因:1。室内机和室外机的接线有问题，或者室内机主板的接线出现故障。建议及时更换室内机主板。2.空调的电蜂鸣器不响，变压器故障。

人工智能的方法，先定义个目标函数，用剪枝策略搜索

看提示就是 stream != NULL出错了。如果stream不是一个指针的话，可能就会出这样的错。

有以下几种情况。第一、风机驱动电流检测电路出现故障。第二、风机驱动板异常，一般都是电网电压突然变化等的故障原因。/1、室外机主板显示HC，可以通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障。2、风机驱动板异常根据维修手册室内机显示“HC”为PFC过电流保护，室外机黄灯闪烁14次。当压缩机启动时检测电路电流，如果超过保护值则保护停机，防止电流过大损坏PFC电路元器件.3、压机过流保护，故障包括压机卡缸，若定变包括启动电容，变频调速包括驱动模块等。4、制冷剂不足引起的保护，这种现象若是控装了几年的机器，在加制冷剂前必须测试制冷剂压力，若差得不多，就可补点制冷剂，若差得太多，就需要捡查漏点，维修好后才能加压24小吋不漏，在抽真空加制冷剂试机。5、室内机器过滤网太脏堵塞，造成热保护，如果这个问题自己去掉就可以清洗。包括传感器和传感器控制电路自身损坏不良也可能引起保护不工作。

格力空调显示HC，可能是外机控制板PFC保护。一般空调上的PFC保护是指压缩机启动系统上有问题；可能是风机驱动电流检测电路故障，通过查看室外机主控板双八数码管上的故障代码，如果数码管上显示HC，则可判断为风机驱动电流检测电路故障，建议立即报修。格力空调显示hc的解决方法1、首先检查电源格力空调有电源的表现为，刚通电时，都会发出很清脆的“嘀”的一声响，那么空调电源就是正常的，然后看空调遥控器有没有电池或电池电量是否足够。2、检查连接线是否断裂可能是因为室内机和室外机之间的连接线被老鼠咬断了，联系工作人员接好即可正常运行。3、长时间不保养长时间的不保养会使空调室外机无法正常运转从而提示hc故障，需要保养或者清理一下污垢，即可正常使用。4、环境温度过高导致系统保护环境温度过高、室外机通风不良有网罩或墙体在室外机前方遮挡导致空调热量吹不出去，温度过高时，压缩机自动启动保护，只需暂停使用30分钟到一小时，重新启动即可解决。5、电压的原因检查电压是不是达到额定电压。如果不是电压低的原因就请检查室内、外机连接是否接对，是否因为移动空调导致线路错误。6、检查是内机和外机的通讯如室外机有电源，红色指示灯亮，外机不启动，可检查是内机和外机的通讯，任何一种灯闪烁为正常，否则通讯有问题。7、氟立昂不足下运转造成制冷剂不足的根本原因。解决方法：为空调补充氟利昂。

是实物开发板吗？还是仿真？是8位共阴数码管吗？38译码器应该是控制数码管的位选吧？是8个LED灯吗？与38译码器接在同一个并口上了吗？那数码管的段选由哪个口控制的？点亮LED灯时，位选不能改，可以改段选输出全0啊，不管位选38译码器输出什么，8个数码管都不亮啦。这么问题也不说清楚，就来问，只能猜测，多费劲。