(lecture_08)搜索入门2 ACM课件
C语言基础,简单数据结构,acm入门,第一讲,搜索
Bjut：mark063 2010.10.30
1
C语言是什么
• • • • • • • • for while if…else… switch , case 函数调用 变量，数组，结构体声明 &,*,->,||,&&,==,++,+= 输入输出scanf, printf,freopen(“in.txt”,”r”,stdin);
• 输入N、K,然后输入N个整数，N个整数可 列出若干加减运算式；若存在一个算式， 它的值能被K整除,输出“Divisible”，否则 输出“Not divisible”.
输入： 输出：
2
4 7 17 5 -21 15 4 5 17 5 -21 15
Divisible
Not divisible
35
7
• • • •
Description Zombies love to eat brains. Yum. Input The first line contains a single integer n indicating the number of data sets. The following n lines each represent a data set. Each data set will be formatted according to the following description: A single data set consists of a line "X Y", where X is the number of brains the zombie eats and Y is the number of brains the zombie requires to stay alive. • Output • For each data set, there will be exactly one line of output. This line will be "MMM BRAINS" if the number of brains the zombie eats is greater than or equal to the number of brains the zombie requires to stay alive. 8 Otherwise, the line will be "NO BRAINS".
ACM培训材料PPT课件
}
2020/10/13
7
注意上面程序的M的好处
上面M定义为10000,这样不仅提高了效率而 且也节省了空间
如果要你把N阶乘转成2或3进制你会吗? 如:把18!转换成2进制. 如果你不会,那么你还没对那个程序M深刻
理解.
2020/10/13
8
N!末尾有多少个0
很简单,只要N!有多少个5这个因子,就有多少 个0.
进位e=0 (e=(a[1]+b[1]+e)/10) c[2]=(a[2]+b[2])%10+e=0, 百位进位e=1,依次下去,
最后把数组输出就是结果(要倒过来输出)
2020/10/13
4
对上面例子的实现
#include<stdio.h>
#include<string.h>
#define N
{
p=a[i]+b[i]+e;
c[i]=p%10;
e=p/10;
}
lc=lb;
while(e>0)
{
lc++;
c[lc]=e%10;
e/=10;
}
for(i=lc;i>=0;i--)
{
printf("%d",c[i]);
}
printf("\n");
return 0;
}
2020/10/13
5
用高精度算N阶乘
汇报人：XXXX 日期：20XX年XX月XX日
11
详细见课堂分析.
2020/10/13
9
fjnu:1743 fjnu:1185 fjnu:1307 fjnu:1191 fjnu:1158
(讲课课件)优先队列与搜索
广度优先搜索：
广度优先搜索时，我们先要寻找当前节点可以直接遍历到的所有节点 （即直接连通的节点），并将这些节点加入一个队列。每次我们将队头元 素做出相同的操作，之后将队头元素出队。直到找到目标为止。
*使用邻接表建图
数据结构-图：
图是由一定数量的点和 连接这些点的 边构成的一种数据结构，通常我们构建图 都是会通过构建边来完成的，下面我们就来看看一条边应该包含什么样的信息： 1、确定一条边的两个端点start和end，但是往往在有向图中只需知道一个固定 的端点即可（例如可以只知道每条边的终点） 2、边的权值，权值是非常重要的，可能会影响到很多东西。 3、指向下一条以这条边起点为起始点边的指针，但是通常这个不会用指针来实 现，因为指针的使用相对比较麻烦。 4、还需要一个额外的变量记录图中一共有多少条边，这个变量一般是 全局的 5、需要一个全局的整型数组head作为辅助
优先队列运用注意事项
1、如果我们仅仅是关心每次使用的元素是所有元素中的拥有最值 的元素，而且不关心其它元素，那么这个时候可以使用涌现队列。 2、建议使用STL中的优先队列，因为这个优先队列实现是绝对靠 谱的。避免了自己用二叉堆实现优先队列时可能出现的错误。 3、如果选择使用STL实现优先队列，建议对运算符的重载知识进 行一下简单的复习，我们需要重载大于或者小于号来实现对多优 先级的元素进行优先级比较。
一个可供参考的自定义数据结构Edge：
struct Edge { int start; int end; int next; value_t val; };
/*通常我们建图的过程中总是将点映射为一个整数*/ /*用一个整数next来替代指针，需要配合head数组使用*/ /*value_t是自定义的数据类型，val可能是任何的数据类型*/
最新HNUSTC语言基础简单数据结构acm入门第一讲搜索
ACM题型分类
• 1，基本算法 • 2，图算法 • 3，数据结构 • 4，搜索 • 5，动态规划 • 6，贪心 • 7，数学 • 8，计算几何 • 9，模拟
9
搜索概论
• 搜索被称为“通用解题法”，在算法和人 工智能中占据重要地位。
• 但由于它巨大的局限性和自身灵活性，也 被认为是最难学难用的算法之一。
28
POJ 2243 Knight Moves
• 国际象棋棋盘上有一个马，要从起点跳到 指定目标，最少跳几步？
a1
a bcd ef gh
输入：
1
2
a1 h8
3
输出：
4
To get from a1 to h8 takes 6 knight moves.
5
6
7
h8
8
29
跳马规则
在2×3的矩形里：
a bcd ef gh
26
BFS
• 广搜例子:你的眼镜掉在地上以后，你趴在 地板上找。你总是先摸最接近你的地方， 如果没有，再摸远一点的地方……
27
BFS程序基本结构
定义一个队列; 起始点加入队列;
while(队列不空) {
取出队头结点; 若它是所求的目标状态,跳出循环; 否则，从它扩展出子结点,全都添到队尾;
}
若循环中找到目标,输出结果; 否则输出无解;
1 2 3 4 5 6 7 8
30
• 例如：从a1到e4
当目标出现在所扩展出的结点里， 结果就找到了。
帮助小明
• 这是一个0-1背包问题。 • 对于每件物品，有两种选择： • 1）拿这件物品（条件是最大重量不超过m） • 2）不拿这件物品 • 下面程序给出0-1背包的dfs解法，效率无法忍
ACM算法设计-BFS(广度搜索)-DFS入门(深度搜索)详解
i i i i i i i
2
3
4
5
6
7
8
9
栈
(8,6) (8,5) (7,5) (6,5) (6,4) (6,3) (5,3) (5,2) (5,1) (4,1) (3,1) (2,1) (1,1)
0 1 2 3 4 5
6
7 8 9
@
@
i
i
i
i i
27 break
迷宫问题-DFS
下方路不通，向右方前进一步
17 break
迷宫问题-DFS
• 向下方 、右方、左方均不能前进，上方是来路，则后退
0
0 1 2 3 4 5 i i i i i
1
2
3
4
5
6
7
8
9
栈
(7,1) (6,1) (5,1) (4,1) (3,1) (2,1) (1,1)
6
7 8 9
i
@
18 break
迷宫问题-DFS
• 向右方、左方均不能前进，下方路不通，上方是来路，则后退
按层次的顺序来遍历搜索树
6
BFS框架
通常用队列(先进先出,FIFO)实现 初始化队列Q. Q={起点s}; 标记s为己访问; while (Q非空) { 取Q队首元素u; u出队; if (u == 目标状态) {…} 所有与u相邻且未被访问的点进入队列; 标记u为已访问; }
7
迷宫问题
• 寻找一条从入口到出口的通路
7 8 9
14 break
迷宫问题-DFS
• 向下方前进一步
0
0 1 2 3 4 5 i i i i
1
2
ACM2008小结(LT版)
ACM校赛总结(LT版)主要负责：搜索，字符串，高精度，数论搜索问题 (2)双向广度搜索深度搜索（递归or堆栈）字符串 (6)高精度 (11)数论,组合数学 (19)一．搜索问题：算法一：双向广度搜索适用情况：已知目标状态，初始状态的搜索题目。
如：八数码，魔板之类的问题。
代码写法很多，我就写了两种版本。
一种先搜索正向，到达指定层数停止，然后反向搜索；二是正向方向交替搜索。
必备条件：1.两个标记数组（标记已经搜索的状态，我一般用map标记）;2.节点的结构体；3.状态迁移函数；4.搜索函数。
下面以sicily1644为例:http://202.116.77.69/sicily/show_problem.php?pid=1644#include<iostream>#include<map>#include<queue>using namespace std;#define the_num 34 //控制正向搜索的层数map<int,int> flag; //正向标记map<int,int> flag2; //反向标记bool is_find = false; //正向查找判断struct node{ node(){…} //结点结构体int item; //结点内容int num; //结点所在层数node operator =(node b){…}};//状态迁移函数int change_1(int num,int n) //num, 实际n位 //变换{ ………省略……… }int change_2(int num ,int n){………省略……… }int change_3(int num,int n) //状态迁移函数,逆向搜索需要，与正向迁移函数对应{………省略……… }//正向搜索函数int fun(int str,int aim,int len) //正向搜到the_num层结束：主要参数：初始状态，目标状态,附加属性{flag[str] = 1;//标记node first;//定义结点first.item = str;first.num = 0;queue<node> open; //宽搜队列open.push(first);while(!open.empty()) //宽度搜索;{node temp = open.front();open.pop();int x = temp.item;int foot = temp.num;if(aim == x) //到达目标节点{is_find = true;return temp.num;}//~~~~~~~~~~~~~~~~~~~~~~~~if(foot == the_num) //搜完到the_num层返回return foot;int front = change_1(x,len);if(flag[front] == 0){if(foot < the_num-1)//不标记第到the_num+1层flag[front] = foot+1;temp.item = front;temp.num = foot+1;open.push(temp);}front = change_2(x,len);if(flag[front] == 0){if(foot < the_num-1)//不标记第到the_num+1层flag[front] = foot+1;temp.item = front;temp.num = foot+1;open.push(temp);}}return 10000;//无法到达}//反向搜索函数int r_fun(int aim,int len)//反方向搜索{flag2[aim] = 1; //标记node first;first.item = aim;first.num = 0; //方向第层queue<node> open;open.push(first);while(!open.empty()){node temp = open.front();open.pop();int x = temp.item;int foot = temp.num;int front = change_1(x,len);if(flag[front]!=0)return foot+1;if(flag2[front] == 0){flag2[front] = foot+1;temp.item = front;temp.num = foot+1;open.push(temp);}front = change_3(x,len);if(flag[front]!=0)return foot+1;if(flag2[front] == 0){flag2[front] = foot+1;temp.item = front;temp.num = foot+1;open.push(temp);}}return 10000; //无法到达}int hash_fun(char *s) //hash转换函数：把字符串对应到整数A = 00 T = 01 C = 10 G = 11; { ………… }int main(){//////////////////////////////////////////////////////////////////////////char a[15];char b[15];int n;while(scanf("%d",&n)!=EOF){flag.clear();flag2.clear();is_find = false;scanf("%s",&a);scanf("%s",&b);int num_a = hash_fun(a);int num_b = hash_fun(b);int x = fun(num_a,num_b,2*n);if(is_find)cout<<x<<endl;elsecout<<x+r_fun(num_b,2*n)-1<<endl;}return 0;}算法二：深度搜索（递归or堆栈）迷宫问题(起点)11011011100101010111 (终点)深度搜索部分的函数bool exitmaze(int row,int col){bool done = false;if(is_right(row,col))//该格可以走{char temp = cells[row][col]; //暂存cells[row][col] = '*';output();if(row == (rows-1) && col == (cols - 1))//到达终点done = true;else{done = exitmaze(row,col+1);//向右走if(!done)done = exitmaze(row+1,col);//向下走if(!done)done = exitmaze(row,col-1);//向左走if(!done)done = exitmaze(row-1,col);//向上走}if(!done)cells[row][col] = temp; // 用于回溯}return done;}马周游例程：poj_2488bool have_road(int n,int m){num[n][m] = 1; //标记if(all_pass())return true;bool done = false;//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~if (!done && n-1>=0 && m-2>=0 && num[n-1][m-2] == 0)//7 done = have_road(n-1,m-2);if(!done && n+1<x && m-2>=0 && num[n+1][m-2] == 0) //6 done = have_road(n+1,m-2);if(!done && n-2>=0 && m-1>=0 && num[n-2][m-1] == 0)//8 done = have_road(n-2,m-1);if(!done && n+2<x && m-1>=0 && num[n+2][m-1] == 0) //5 done = have_road(n+2,m-1);if(!done && n-2>=0 && m+1<y && num[n-2][m+1] == 0) //1 done = have_road(n-2,m+1);if(!done && n+2<x && m+1<y && num[n+2][m+1] == 0) //4 done = have_road(n+2,m+1);if(!done && n-1>=0 && m+2<y && num[n-1][m+2] == 0) //2 done = have_road(n-1,m+2);if(!done && n+1<x && m+2<y && num[n+1][m+2] == 0) //3 done = have_road(n+1,m+2);//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~if(!done) //回溯num[n][m] = 0;return done;}二．字符串1. 整个文本读入：char s[1000];text_input(s); //子函数如下:void text_input(char *s) //读入整个文本{int n = 0;while( (s[n] = getchar()) != EOF)n++;s[n] = '\0';｝2. 一行文本读入：方法一：char *s = new char[1000];gets(s); //读入一行方法二：string str;getline(cin,str); //读入一行3. 字符串分隔：vector<string> v;char *s = new char[1000];string temp;text_input(s);for(int i = 0;i<strlen(s);i++){while(s[i]!=' '&&s[i]!='\t'&&s[i]!='\n'&&s[i]!='\0') //以空白字符分隔文本中的字符串temp += s[i++];if(!temp.empty())v.push_back(temp);temp = "";}for(int i = 0;i<v.size();i++)cout<<v[i]<<endl;扩展：以数字串分隔呢？以特殊字符串分隔呢？如2A123B4C,A->B等.vector<string> fun(string str,string cut_str) //输入字符串，返回以cut_str 分隔的字符串数组。
[理学]20130316ACM课件lecture_02简单数学题
Problem Description
The highest building in our city has only one elevator. A request list is made up with N positive numbers. The numbers denote at which floors the elevator will stop, in specified order. It costs 6 seconds to move the elevator up one floor, and 4 seconds to move down one floor. The elevator will stay for 5 seconds at each stop.
2020/11/14
h
25
Problem Description
FatMouse prepared M pounds of cat food, ready to trade with the cats guarding the warehouse containing his favorite food, JavaBean. The warehouse has N rooms. The i-th room contains J[i] pounds of JavaBeans and requires F[i] pounds of cat food. FatMouse does not have to trade for all the JavaBeans in the room, instead, he may get J[i]* a% pounds of JavaBeans if he pays F[i]* a% pounds of cat food. Here a is a real number. Now he is assigning this homework to you: tell him the maximum amount of JavaBeans he can obtain.
高级人工智能：搜索Search--第二讲
e f
S
h
p
q
r
ห้องสมุดไป่ตู้
S
d
e
p
Search
bc
e
hr
q
Tiers
a ah r
pq f
pq f
q
q
cG
cG a
a
广度优先搜索(BFS) 特性
▪ BFS扩展哪些节点?
▪ Processes all nodes above shallowest solution
▪ Let depth of shallowest solution be s ▪ Search takes time O(bs)
▪ 状态空间图中，每个状态只出现一次！
▪ 几乎不在内存中构建完整的状态空间图（太 大了），但它是非常有用的
状态空间图
▪ 状态空间图: 搜索问题的数学表示
▪ Nodes are (abstracted) world configurations ▪ Arcs represent successors (action results) ▪ The goal test is a set of goal nodes (maybe only one)
▪ 搜索树:
▪ 根节点对应了初始状态 ▪ 子节点对应了父节点的后继
▪ 节点显示状态，但对应的是到达这些状态的行动
▪ 对大多数问题，实际上不会构建整个树
状态空间图 vs. 搜索树
State Space Graph
Each NODE in the search tree is an entire PATH in the state space graph.
一般的树搜索
▪ Important ideas:
北大 ACM 搜索
IDA*: 迭代加深的A*算法
IDA*与A*
IDA*与A*算法相比，主要的优点是对于内存的 需求
A*算法需要指数级数量的存储空间，因为没有 深度方面的限制 而IDA*算法只有当节点n的所有子节点n’的f(n’) 小于限制值c时才扩展它，这样就可以节省大 量的内存。
搜索的剪枝
通常情况下，搜索的剪枝考虑下面几个方 面： 判重：避免枚举重复的节点 最优化剪枝：如果当前部分搜索方案比目 前求得的最优方案还要差，则剪枝。 可行性剪枝：如果可以判断继续按当前方 向搜索下去，必定无解或者达不到最优解， 则剪枝。
A*算法的条件
一种具有f(n)=g(n)+h(n)策略的启发式算法能成为 A*算法的充分条件是：
1）搜索树上存在着从起始点到终了点的最优路径。 2）问题域是有限的。 3）所有结点的子结点的搜索代价值>0。 4）h(n)<=h*(n) （h*(n)为实际问题的代价值）。
当此四个条件都满足时，一个具有f(n)=g(n)+h(n) 策略的启发式算法能成为A*算法，并一定能找到 最优解。
宽度优先搜索
优点
目标节点如果存在，用宽度优先搜索算法总可 以找到该目标节点，而且是最小（即最短路径） 的节点
缺点
当目标节点距离初始节点较远时，会产生许多 无用的节点，搜索效率低
双向宽度优先搜索
从初始结点和目标结点分别做广度优先搜索， 每次检查两边是否重合。 械的两边交替。
例 聪明的打字员
例： 如果通过k次可达到排列356124(其中红色表示 光标达到过的位置） 最后的密码如果是371194，则通过这种方案需 要一共操作k+(7-5)+(6-1)+(9-2)=14+k步
ACM培训课程算法设计课件
【例】编程求当N<=100时，N！的准确值 问题分析：问题要求对输入的正整数N，计算N！的准 确值，而N！的增长速度仅次于指数增长的速度，所以 这是一个高精度计算问题。 例如： 9！=362880 100！ = 93 326215 443944 152681 699263 856266 700490 715968 264381 621468 592963 895217 599993 229915 608914 463976 156578 286253 697920 827223 758251 185210 916864 000000 000000 000000 000000
for(x=1;x<=20;x=x+1) for(y=1;y<=33;y=y+1) { z=100-x-y; if(z mod 3=0 and
5*x+3*y+z/3=100)
{print(the cock number is",x)； print(the hen number is", y)；
print(the chick number is "z);} }
而链表中按序号访问的时间性能O(n)，所以如果经 常做的运算是按序号访问数据元素，显然顺序表优 于链表； ３）基于环境的考虑
顺序表容易实现，任何高级语言中都有数 组类型，链表的操作是基于指针的，操作简单。
34
【例3】一次考试共考了语文、代数和外语三科。某小组 共有九人，考后各科及格名单如下表，请编写算法找出
１）基于存储的考虑 顺序表的存储空间是静态分配的，在程
序执行之前必须明确规定它的存储规模，也就 是说事先对“MAXSIZE”要有合适的设定，过 大造成浪费，过小造成溢出。可见对线性表的 长度或存储规模难以估计时，不宜采用顺序表； 链表不用事先估计存储规模，但链表的存储密 度较低，
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
19 2020/12/3
面临的问题：
超时！
从1—100000的质数运算约为1e+8,而这 只是准备工作。
因此，如不加以分析简化此题无法在规 定时间内出解
14 2020/12/3
说明：
本题除了可以练习基本搜索算法，也是 练习字符串处理的好题目，题中用到的 相关知识点有：
求反串 求子串 字符串查找 求字符串长度
强烈推荐！！
15 2020/12/3
再来一道数值型搜索题
16 2020/12/3
HDOJ_1239
Calling Extraterrestrial Intelligence Again 题目链接
101010
010101
101010
010101 从为 0 的格子走一步，必
然走向为 1 的格子 从为 1 的格子走一步，必
然走向为 0 的格子 即： 0 ->1或1->0 必然是奇数步 0->0 走1->1 必然是偶数步
结论：
所以当遇到从 0 走向 0 但是要求 时间是奇数的， 或者， 从 1 走向 0 但是要求时间是 偶数的 都可以直 接判断不可达！
ACM 程序设 计
计算机学院 刘春英
1 2020/12/3
今天，
你
了吗？
2 2020/12/3
每周一星（7）：
NPEG-MP4 && OPPO MP4
3 2020/12/3
搜索题特点分析:
题意容易理解 算法相对固定 编程有路可循 竞赛必备知识
6 2020/12/3
引言
“算法中最基本和常用的是搜索，主要是回溯和
37 2020/12/3
BFS算法：
（1）把起始节点S线放到OPEN表中 （2）如果OPEN是空表，则失败退出，否则 继续。 （3）在OPEN表中取最前面的节点node移到 CLOSED 表中。 （4）扩展node节点。若没有后继（即叶节 点），则转向（2）循环。 （5）把node的所有后继节点放在OPEN表的 末端。各后继结点指针指向node节点。 （6）若后继节点中某一个是目标节点，则找 到一个解，成功退出。否则转向（2）循环。
b.需要找到两个数(不妨设为p,q)满足以下 条件：
p,q均为质数； p*q<=m; a/b <= p/q <= 1;
c.输出所有满足以上条件的p,q中乘积最大 的一对p,q
18 2020/12/3
算法分析
1.典型的搜索 从所有可能的p,q中寻找满足条件的一对
2.p,q的要求 p,q均为质数,且p<=q<=100000;
1.先访问左子树 2.再访问右子树 3.最后访问根结点 4.对于左右子树的访问也要满足以上规则
示例如下：
29 2020/12/3
1
2
3
4
5
6
7
以上二叉树的后根遍历序列是：？？ 4、5、 2、 6、7 、 3、 1
30 2020/12/3
（4）层次遍历
对树的访问次序是:
1.先访问根结点 2.再访问根结点的子节点（即第二层节点） 3.再访问第三层节点
41 2020/12/3
搜索过程如下：
S
A
H
B
F
I
L
C
D
E
J
K
G
深度优先搜索示意图 42
2020/12/3
DFS算法
（1）把起始节点S线放到OPEN表中。 （2）如果OPEN是空表，则失败退出，否则继 续。 （3）从OPEN表中取最前面的节点node移到 CLOSED 表中。 （4）若node节点是叶结点（若没有后继节 点），则转向（2）。 （5）扩展node的后继节点，产生全部后继节 点，并把他们放在OPEN表的前面。各后继结点 指针指向node节点。 （6）若后继节点中某一个是目标节点，则找 到一个解，成功退出。否则转向（2）循环。
（2）中根遍历
对树的访问次序是:
1.先访问左子树 2.再访问根结点 3.最后访问右子树 4.对于左右子树的访问也要满足以上规则
示例如下：
27 2020/12/3
1
2
3
4
5
6
7
以上二叉树的中根遍历序列是：？？
4、 2、 5、 1、 6、 3、 7
28 2020/12/3
（3）后根遍历
对树的访问次序是:
——摘自《ACM竞赛之新人向导 》
7 2020/12/3
什么是搜索算法呢？
搜索算法是利用计算机的高性能来有目 的地穷举一个问题的部分或所有的可能情况， 从而求出问题的解的一种方法。
搜索过程实际上是根据初始条件和扩展 规则构造一棵解答树并寻找符合目标状态的 节点的过程。
8 2020/12/3
预热一下：二分查找
33 2020/12/3
例 九宫重排问题
28 3 16 4 75
初始状态：
123 84 765
目标状态：
34 2020/12/3
283 164
75
283 14
765
28 3
16 4
7
5
283 14 765
23 184 765
283 164 75
283 14 765
83 214 765
283 714
Sample Input 512 99999 999 999 1680 5 16 1970 1 1 2002 4 11 000
Sample Output 22 313 313 23 73 43 43 37 53
17 2020/12/3
获取有用信息
a.给定整数m,a,b(4 < m <= 100000 and 1 <= a <= b <= 1000)
典型的迷宫搜索，做出该题将具有里程 碑式的意义！
每个block只能走一次 要求恰好某个给定的时间到达出口
47 2020/12/3
想到了什么剪枝条件？
如果可走的block的总数小于时间，将会 产生什么情况？
还想到什么剪枝？
48 2020/12/3
奇偶性剪枝
可以把map看成这样： 010101
65
23 184 765
23 184 765
35 2020/12/3
123 84 765
23 184 765
123 84
765
123 784
65
36 2020/12/3
三、广度优先搜索
基本思想：从初始状态S开始，利用规
则，生成所有可能的状态。构成树的下一 层节点，检查是否出现目标状态G，若未 出现，就对该层所有状态节点，分别顺序 利用规则。生成再下一层的所有状态节点， 对这一层的所有状态节点检查是否出现G， 若未出现，继续按上面思想生成再下一层 的所有状态节点，这样一层一层往下展开。 直到出现目标状态为止。
所以，在这里再次强调“剪枝”！
45 2020/12/3
HDOJ_1010 Tempter of the Bone
Sample Input 445 S.X. ..X. ..XD .... 345 S.X. ..X. ...D 000
Sample Output
NO YES
46 2020/12/3
要点分析：
注意剪枝：
If ( a[j]>m || a[j]*a[i]>m || ( (double)aБайду номын сангаасi]/a[j])<s )
……
22 2020/12/3
真正的搜索题
迷宫搜索
23 2020/12/3
预备知识——树的遍历
树的遍历主要有如下四种方法：
1.先根/序遍历 2.中根/序遍历 3.后根/序遍历 4.层次遍历
2 3 4 5 6 8 12 20 32 45 65 74 86 95 100
head
mid
tail
9 2020/12/3
查找示意图：
A[1]~A[15]
A[1]~A[7]
A[9]~A[15]
A[1]~A[3] A[5]~A[7] A[1]~A[1] A[3]~A[3]
……
10 2020/12/3
49 2020/12/3
这个题目没问题了吧？
50 2020/12/3
思考：
求某给定时间以内能否找到出口 找到出口的最短时间 条件变为可以停留
51 2020/12/3
附录：推荐搜索题：
1010、1240、1241、1242 1072、 1253 、 1312、1372 (以上题目类似于1010) 1238、1239、1015、1016 1401、1515、1548
4. ……
示例如下：
31 2020/12/3
1
2
3
4
5
6
7
以上二叉树的层次遍历序列是：？？
1、2、 3、 4、5、6、7
32 2020/12/3
几个基本概念：
初始状态：略 目标状态：略 状态空间：由于求解问题的过程中分枝有很
多（主要是求解过程中求解条件的不确定性、 不完备性造成的），使得求解的路径很多， 这就构成了一个图，我们说这个图就是状态 空间。 状态空间搜索：就是将问题求解过程表现为 从初始状态到目标状态寻找这个路径的过程。 通俗点说，就是在解一个问题时，找到一条 解题的过程，可以从求解的开始到问题的结 果。
Sample Output 2 2
13 2020/12/3