Ⅰ 小波算法是什么
王卫国 郭宝龙
（西安电子科技大学机电工程学院，西安 710071）
摘 要 随着互联网的普及和图象应用范围的不断扩大,对图象的编码提出了新的要求,即不仅要求具有高的压缩比,还要求有许多新的功能,如渐进编解码、从有损压缩到无损压缩等。嵌入式零树小波编码较好地实现了这一思想,因此奠定了它在图象编码中的地位。近年来，在嵌入式零树小波编码(EZW)算法的基础上出现了许多新的改进算法，如多级树集合分裂算法(SPIHT),集合分裂嵌入块编码(SPECK),可逆的嵌入小波压缩法(CREW)等.本文对这些算法从原理到性能进行了比较和讨论,说明了嵌入式图象编码的研究方向。
关 键 词 图象编码 嵌入式 零树 小波变换
On Embedded Zerotree Wavelets Coding and other Improved Algorithms
WANG Wei-guo, GUO Bao-long
(School of Mechano-Electronic Engineering,Xidian Univ.,Xi’an 710071)
Abstract With the extensive application of internet and image,some new requirements on image coding,such as high compression rate ,pregressive codec,and compression from lossy to lossless ,are to be satisfied.These functions can be performed well by EZW(Embedded Zerotree Wavelets) coding.On the bases of EZW,many newly improved algorithms have been developed in recent years.They can illustrated by algorithms like SPIHT(Set Partitioning in Hierarchical Trees),SPECK(Set Partitioned Embedded block coder),In this paper,the writer discusses the principles and performances of these algorithms,thus explains the research tendency in the area of embedded image coding.
Keywords Image coding,Embedded,Zerotree,Wavelet transform
0. 引言
在基于小波变换的图象压缩方案中,嵌入式零树小波 EZW(Embedded Zerotree Wavelets)[1]编码很好地利用小波系数的特性使得输出的码流具有嵌入特性。它的重要性排序和分级量化的思想被许多编码算法所采用。近年来,在对EZW改进的基础上，提出了许多新的性能更好的算法,如多级树集合分裂算法(SPIHT :Set Partitioning In Hierarchical Trees)[2],集合分裂嵌入块编码(SPECK：Set Partitioned Embedded bloCK coder),可逆嵌入小波压缩算法(CREW:Compression with Reversible Embedded Wavelets)[3] 。本文对这些算法进行了原理分析、性能比较,说明了嵌入式小波图象编码的研究方向。
Ⅱ 算法工程师应该学哪些
一、算法工程师简介
（通常是月薪15k以上，年薪18万以上，只是一个概数，具体薪资可以到招聘网站如拉钩，猎聘网上看看）
算法工程师目前是一个高端也是相对紧缺的职位；
算法工程师包括
音/视频算法工程师（通常统称为语音/视频/图形开发工程师）、图像处理算法工程师、计算机视觉算法工程师、通信基带算法工程师、信号算法工程师、射频/通信算法工程师、自然语言算法工程师、数据挖掘算法工程师、搜索算法工程师、控制算法工程师（云台算法工程师，飞控算法工程师，机器人控制算法）、导航算法工程师（
@之介
感谢补充）、其他【其他一切需要复杂算法的行业】
专业要求：计算机、电子、通信、数学等相关专业；
学历要求：本科及其以上的学历，大多数是硕士学历及其以上；
语言要求：英语要求是熟练，基本上能阅读国外专业书刊，做这一行经常要读论文；
必须掌握计算机相关知识，熟练使用仿真工具MATLAB等，必须会一门编程语言。
算法工程师的技能树（不同方向差异较大，此处仅供参考）
1 机器学习
2 大数据处理：熟悉至少一个分布式计算框架Hadoop/Spark/Storm/ map-rece/MPI
3 数据挖掘
4 扎实的数学功底
5 至少熟悉C/C++或者java，熟悉至少一门编程语言例如java/python/R
加分项：具有较为丰富的项目实践经验（不是水论文的哪种）
二、算法工程师大致分类与技术要求
（一）图像算法/计算机视觉工程师类
包括
图像算法工程师，图像处理工程师，音/视频处理算法工程师，计算机视觉工程师
要求
l
专业：计算机、数学、统计学相关专业；
l
技术领域：机器学习，模式识别
l
技术要求：
（1） 精通DirectX HLSL和OpenGL GLSL等shader语言，熟悉常见图像处理算法GPU实现及优化；
（2） 语言：精通C/C++；
（3） 工具：Matlab数学软件，CUDA运算平台，VTK图像图形开源软件【医学领域：ITK，医学图像处理软件包】
（4） 熟悉OpenCV/OpenGL/Caffe等常用开源库；
（5） 有人脸识别，行人检测，视频分析，三维建模，动态跟踪，车识别，目标检测跟踪识别经历的人优先考虑；
（6） 熟悉基于GPU的算法设计与优化和并行优化经验者优先；
（7） 【音/视频领域】熟悉H.264等视频编解码标准和FFMPEG，熟悉rtmp等流媒体传输协议，熟悉视频和音频解码算法，研究各种多媒体文件格式，GPU加速；
应用领域：
（1） 互联网：如美颜app
（2） 医学领域：如临床医学图像
（3） 汽车领域
（4） 人工智能
相关术语：
（1） OCR：OCR （Optical Character Recognition，光学字符识别）是指电子设备（例如扫描仪或数码相机）检查纸上打印的字符，通过检测暗、亮的模式确定其形状，然后用字符识别方法将形状翻译成计算机文字的过程
（2） Matlab：商业数学软件；
（3） CUDA： (Compute Unified Device Architecture)，是显卡厂商NVIDIA推出的运算平台（由ISA和GPU构成）。 CUDA™是一种由NVIDIA推出的通用并行计算架构，该架构使GPU能够解决复杂的计算问题
（4） OpenCL: OpenCL是一个为异构平台编写程序的框架，此异构平台可由CPU，GPU或其他类型的处理器组成。
（5） OpenCV：开源计算机视觉库；OpenGL：开源图形库；Caffe：是一个清晰，可读性高，快速的深度学习框架。
（6） CNN：（深度学习）卷积神经网络（Convolutional Neural Network）CNN主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。
（7） 开源库：指的是计算机行业中对所有人开发的代码库，所有人均可以使用并改进代码算法。
（二）机器学习工程师
包括
机器学习工程师
要求
l
专业：计算机、数学、统计学相关专业；
l
技术领域：人工智能，机器学习
l
技术要求：
（1） 熟悉Hadoop/Hive以及Map-Rece计算模式，熟悉Spark、Shark等尤佳；
（2） 大数据挖掘；
（3） 高性能、高并发的机器学习、数据挖掘方法及架构的研发；
应用领域：
（1）人工智能，比如各类仿真、拟人应用，如机器人
（2）医疗用于各类拟合预测
（3）金融高频交易
（4）互联网数据挖掘、关联推荐
（5）无人汽车，无人机
相关术语：
（1） Map-Rece：MapRece是一种编程模型，用于大规模数据集（大于1TB）的并行运算。概念"Map（映射）"和"Rece（归约）"，是它们的主要思想，都是从函数式编程语言里借来的，还有从矢量编程语言里借来的特性。
（三）自然语言处理工程师
包括
自然语言处理工程师
要求
l
专业：计算机相关专业；
l
技术领域：文本数据库
l
技术要求：
（1） 熟悉中文分词标注、文本分类、语言模型、实体识别、知识图谱抽取和推理、问答系统设计、深度问答等NLP 相关算法；
（2） 应用NLP、机器学习等技术解决海量UGC的文本相关性；
（3） 分词、词性分析、实体识别、新词发现、语义关联等NLP基础性研究与开发；
（4） 人工智能，分布式处理Hadoop；
（5） 数据结构和算法；
应用领域：
口语输入、书面语输入
、语言分析和理解、语言生成、口语输出技术、话语分析与对话、文献自动处理、多语问题的计算机处理、多模态的计算机处理、信息传输与信息存储 、自然语言处理中的数学方法、语言资源、自然语言处理系统的评测。
相关术语：
（2） NLP：人工智能的自然语言处理，NLP (Natural Language Processing) 是人工智能（AI）的一个子领域。NLP涉及领域很多，最令我感兴趣的是“中文自动分词”（Chinese word segmentation）：结婚的和尚未结婚的【计算机中却有可能理解为结婚的“和尚“】
（四）射频/通信/信号算法工程师类
包括
3G/4G无线通信算法工程师， 通信基带算法工程师，DSP开发工程师（数字信号处理），射频通信工程师，信号算法工程师
要求
l
专业：计算机、通信相关专业；
l
技术领域：2G、3G、4G，BlueTooth（蓝牙），WLAN，无线移动通信, 网络通信基带信号处理
l
技术要求：
（1） 了解2G，3G，4G，BlueTooth，WLAN等无线通信相关知识，熟悉现有的通信系统和标准协议，熟悉常用的无线测试设备；
（2） 信号处理技术，通信算法；
（3） 熟悉同步、均衡、信道译码等算法的基本原理；
（4） 【射频部分】熟悉射频前端芯片，扎实的射频微波理论和测试经验，熟练使用射频电路仿真工具（如ADS或MW或Ansoft）；熟练使用cadence、altium designer PCB电路设计软件；
（5） 有扎实的数学基础，如复变函数、随机过程、数值计算、矩阵论、离散数学
应用领域：
通信
VR【用于快速传输视频图像，例如乐客灵境VR公司招募的通信工程师（数据编码、流数据）】
物联网，车联网
导航，军事，卫星，雷达
相关术语：
（1） 基带信号：指的是没有经过调制（进行频谱搬移和变换）的原始电信号。
（2） 基带通信（又称基带传输）：指传输基带信号。进行基带传输的系统称为基带传输系统。传输介质的整个信道被一个基带信号占用.基带传输不需要调制解调器，设备化费小，具有速率高和误码率低等优点,.适合短距离的数据传输，传输距离在100米内，在音频市话、计算机网络通信中被广泛采用。如从计算机到监视器、打印机等外设的信号就是基带传输的。大多数的局域网使用基带传输，如以太网、令牌环网。
（3） 射频：射频（RF）是Radio Frequency的缩写，表示可以辐射到空间的电磁频率（电磁波），频率范围从300KHz～300GHz之间（因为其较高的频率使其具有远距离传输能力）。射频简称RF射频就是射频电流，它是一种高频交流变化电磁波的简称。每秒变化小于1000次的交流电称为低频电流，大于10000次的称为高频电流，而射频就是这样一种高频电流。高频(大于10K)；射频（300K-300G）是高频的较高频段；微波频段（300M-300G）又是射频的较高频段。【有线电视就是用射频传输方式】
（4） DSP：数字信号处理，也指数字信号处理芯片
（五）数据挖掘算法工程师类
包括
推荐算法工程师，数据挖掘算法工程师
要求
l
专业：计算机、通信、应用数学、金融数学、模式识别、人工智能；
l
技术领域：机器学习，数据挖掘
l
技术要求：
（1） 熟悉常用机器学习和数据挖掘算法，包括但不限于决策树、Kmeans、SVM、线性回归、逻辑回归以及神经网络等算法；
（2） 熟练使用SQL、Matlab、Python等工具优先；
（3） 对Hadoop、Spark、Storm等大规模数据存储与运算平台有实践经验【均为分布式计算框架】
（4） 数学基础要好，如高数，统计学，数据结构
l
加分项：数据挖掘建模大赛；
应用领域
（1） 个性化推荐
（2） 广告投放
（3） 大数据分析
相关术语
Map-Rece：MapRece是一种编程模型，用于大规模数据集（大于1TB）的并行运算。概念"Map（映射）"和"Rece（归约）"，是它们的主要思想，都是从函数式编程语言里借来的，还有从矢量编程语言里借来的特性。
（六）搜索算法工程师
要求
l
技术领域：自然语言
l
技术要求：
（1） 数据结构，海量数据处理、高性能计算、大规模分布式系统开发
（2） hadoop、lucene
（3） 精通Lucene/Solr/Elastic Search等技术，并有二次开发经验
（4） 精通Lucene/Solr/Elastic Search等技术，并有二次开发经验；
（5） 精通倒排索引、全文检索、分词、排序等相关技术；
（6） 熟悉Java，熟悉Spring、MyBatis、Netty等主流框架；
（7） 优秀的数据库设计和优化能力，精通MySQL数据库应用 ；
（8） 了解推荐引擎和数据挖掘和机器学习的理论知识，有大型搜索应用的开发经验者优先。
（七）控制算法工程师类
包括了云台控制算法，飞控控制算法，机器人控制算法
要求
l
专业：计算机，电子信息工程，航天航空，自动化
l
技术要求：
（1） 精通自动控制原理（如PID）、现代控制理论，精通组合导航原理，姿态融合算法，电机驱动，电机驱动
（2） 卡尔曼滤波，熟悉状态空间分析法对控制系统进行数学模型建模、分析调试；
l
加分项：有电子设计大赛，机器人比赛，robocon等比赛经验，有硬件设计的基础；
应用领域
（1）医疗/工业机械设备
（2）工业机器人
（3）机器人
（4）无人机飞控、云台控制等
（八）导航算法工程师
要求
l 专业：计算机，电子信息工程，航天航空，自动化
l 技术要求（以公司职位JD为例）
公司一（1）精通惯性导航、激光导航、雷达导航等工作原理；
（2）精通组合导航算法设计、精通卡尔曼滤波算法、精通路径规划算法；
（3）具备导航方案设计和实现的工程经验；
（4）熟悉C/C++语言、熟悉至少一种嵌入式系统开发、熟悉Matlab工具；
公司二（1）熟悉基于视觉信息的SLAM、定位、导航算法，有1年以上相关的科研或项目经历；
（2）熟悉惯性导航算法，熟悉IMU与视觉信息的融合;
应用领域
无人机、机器人等。
Ⅲ 如何计算出一个波形的面积的算法
我有一种思路,那就是用积分中值定理来近似计算一个区间的面积.在计算机中离散的计算两点或多点间的面积,然后在一段时间内做平均就可以出来波形的面积.
积分中值定理：f(x)在a到b上的积分等于(a-b)f(c)，其中c满足a<c<b。
积分中值定理公式的c怎么取?这个在数字化波形中,,我们可以用两点或多点之间取均值、中位数、范围内随机数等方法来选取函数在c点的函数值,也就是f(c)=均值、中位数、范围内随机数等.
传感器实时采集回来的数据(想表达波形每个点的数据按顺序到来这种情况下),我们可以用S=(a*T_last+(1-a)*T)*b和T_last=T这 两个公式顺序计算求取面积.注意:①T_last在第一次计算时可以为0,也可以就等于T;②T表示传感器当前采集回来的值,T_last代表传感器以前的数值.③0≤a≤1,a根据实际情况进行选取或调整,代表传感器以前的数值对此次数值的影响程度.④b是周期,也可以是两点间的间隔,可以是距离也可以是时间长,也可以是固定选取的某常数,比如我一般就选常数1.
其实有现成的的工具可用,比如labview中就有专门的计算波形平均值、期望值、强度等.MATLAB中也有相对应的函数库.
简单易行的方法都或多或少都有误差在里面,但是在实验室外,生活中误差有时是可以接受的.一定要最求精度的话,可以拜读下导航路径计算相关论文或教材.
Ⅳ 求八数码问题算法，并说明下该算法优缺点，要算法，不是源代码（可以没有）。
八数码问题
一.八数码问题
八数码问题也称为九宫问题。在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。所谓问题的一个状态就是棋子在棋盘上的一种摆法。棋子移动后，状态就会发生改变。解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。
八数码问题一般使用搜索法来解。搜索法有广度优先搜索法、深度优先搜索法、A*算法等。这里通过用不同方法解八数码问题来比较一下不同搜索法的效果。
二.搜索算法基类
1.八数码问题的状态表示
八数码问题的一个状态就是八个数字在棋盘上的一种放法。每个棋子用它上面所标的数字表示，并用0表示空格，这样就可以将棋盘上棋子的一个状态存储在一个一维数组p[9]中，存储的顺序是从左上角开始，自左至右，从上到下。也可以用一个二维数组来存放。
2.结点
搜索算法中，问题的状态用结点描述。结点中除了描述状态的数组p[9]外，还有一个父结点指针last，它记录了当前结点的父结点编号，如果一个结点v是从结点u经状态变化而产生的，则结点u就是结点v的父结点，结点v的last记录的就是结点u的编号。在到达目标结点后，通过last 可以找出搜索的路径。
3.类的结构
在C++中用类来表示结点，类将结点有关的数据操作封装在一起。
不同的搜索算法具有一定共性，也有各自的个性，因此这里将不同搜索算法的共有的数据和功能封装在一个基类中，再通过继承方式实现不同的搜索算法。
4.结点扩展规则
搜索就是按照一定规则扩展已知结点，直到找到目标结点或所有结点都不能扩展为止。
八数码问题的结点扩展应当遵守棋子的移动规则。按照棋子移动的规则，每一次可以将一个与空格相邻棋子移动到空格中，实际上可以看作是空格作相反移动。空格移动的方向可以是右、下、左、上，当然不能移出边界。棋子的位置，也就是保存状态的数组元素的下标。空格移动后，它的位置发生变化，在不移出界时，空格向右、下、左和上移动后，新位置是原位置分别加上1、3、-1、-3，如果将空格向右、下、左和上移动分别用0、1、2、3表示，并将-3、3、-1、1放在静态数组d[4]中，空格位置用spac表示，那么空格向方向i移动后，它的位置变为spac+d[i]。空格移动所产生的状态变化，反映出来则是将数组p[]中，0的新位置处的数与0交换位置。
5.八数码问题的基类
八数码问题的基类及其成员函数的实现如下：
#define Num 9
class TEight
{
public:
TEight(){}
TEight(char *fname); //用文件数据构造节点
virtual void Search()=0; //搜索
protected:
int p[Num];
int last,spac;
static int q[Num],d[],total;
void Printf();
bool operator==(const TEight &T);
bool Extend(int i);
};
int TEight::q[Num];//储存目标节点
int TEight::d[]={1,3,-1,-3};//方向
int TEight::total=0;//步数
TEight::TEight(char *fname)
{
ifstream fin;
fin.open(fname,ios::in);
if(!fin)
{
cout<<"不能打开数据文件!"<<endl;
return;
}
int i;
for(i=0;i<Num;)//得到源节点
fin>>p[i++];
fin>>spac;
for(i=0;i<Num;)//得到目标节点
fin>>q[i++];
fin.close();
last=-1;
total=0;
}
void TEight::Printf()//把路径打印到结果文件
{
ofstream fout;
fout.open("eight_result.txt",ios::ate|ios::app);
fout<<total++<<"t";
for(int i=0;i<Num;)
fout<<" "<<p[i++];
fout<<endl;
fout.close();
}
bool TEight::operator==(const TEight &T)//判断两个状态是否相同
{
for(int i=0;i<Num;)
if(T.p[i]!=p[i++])
return 0;
return 1;
}
bool TEight::Extend(int i)//扩展
{
if(i==0 && spac%3==2 || i==1 && spac>5
|| i==2 && spac%3==0 || i==3 && spac<3)
return 0;
int temp=spac;
spac+=d[i];
p[temp]=p[spac];
p[spac]=0;
return 1;
}
数据文件的结构：
一共三行，第一行是用空格隔开的九个数字0~8，这是初始状态。第二行是一个数字，空格（数字0）的位置，第三行也是用空格隔开的九个数字0~8，这是目标状态。
三.线性表
搜索法在搜索过程中，需要使用一个队列存储搜索的中间结点，为了在找到目标结点后，能够找到从初始结点到目标结点的路径，需要保留所有搜索过的结点。另一方面，不同问题甚至同一问题的不同搜索方法中，需要存储的结点数量相差很大，所以这里采用链式线性表作为存储结构，同时，为适应不同问题，线性表设计成类模板形式。
template<class Type> class TList; //线性表前视定义
template<class Type> class TNode //线性表结点类模板
{
friend class TList<Type>;
public:
TNode(){}
TNode(const Type& dat);
private:
TNode<Type>* Next;
Type Data;
};
template<class Type> class TList
{
public:
TList(){Last=First=0;Length=0;} //构造函数
int Getlen()const{return Length;} //成员函数，返回线性表长度
int Append(const Type& T); //成员函数，从表尾加入结点
int Insert(const Type& T,int k); //成员函数，插入结点
Type GetData(int i); //成员函数，返回结点数据成员
void SetData(const Type& T,int k); //成员函数，设置结点数据成员
private:
TNode<Type> *First,*Last; //数据成员，线性表首、尾指针
int Length; //数据成员，线性表长度
};
template<class Type> int TList<Type>::Append(const Type& T)
{
Insert(T,Length);
return 1;
}
template<class Type> int TList<Type>::Insert(const Type& T,int k)
{
TNode<Type> *p=new TNode<Type>;
p->Data=T;
if(First)
{
if(k<=0)
{
p->Next=First;
First=p;
}
if(k>Length-1)
{
Last->Next=p;
Last=Last->Next;
Last->Next=0;
}
if(k>0 && k<Length)
{
k--;
TNode<Type> *q=First;
while(k-->0)
q=q->Next;
p->Next=q->Next;
q->Next=p;
}
}
else
{
First=Last=p;
First->Next=Last->Next=0;
}
Length++;
return 1;
}
template<class Type> Type TList<Type>::GetData(int k)
{
TNode<Type> *p=First;
while(k-->0)
p=p->Next;
return p->Data;
}
template<class Type> void TList<Type>::SetData(const Type& T,int k)
{
TNode<Type> *p=First;
while(k-->0)
p=p->Next;
p->Data=T;
}
线性表单独以头文件形式存放。
四.广度优先搜索法
在搜索法中，广度优先搜索法是寻找最短路经的首选。
1.广度优先搜索算法的基本步骤
1）建立一个队列，将初始结点入队，并设置队列头和尾指针
2）取出队列头（头指针所指）的结点进行扩展，从它扩展出子结点，并将这些结点按扩展的顺序加入队列。
3）如果扩展出的新结点与队列中的结点重复，则抛弃新结点，跳至第六步。
4）如果扩展出的新结点与队列中的结点不重复，则记录其父结点，并将它加入队列，更新队列尾指针。
5）如果扩展出的结点是目标结点，则输出路径，程序结束。否则继续下一步。
6）如果队列头的结点还可以扩展，直接返回第二步。否则将队列头指针指向下一结点，再返回第二步。
2.搜索路径的输出
搜索到目标结点后，需要输出搜索的路径。每个结点有一个数据域last，它记录了结点的父结点，因此输出搜索路径时，就是从目标结点Q出发，根据last找到它的父结点，再根据这个结点的last找到它的父结点，....,最后找到初始结点。搜索的路径就是从初始结点循相反方向到达目标结点的路径。
3.广度优先搜索法TBFS类的结构
广度优先搜索法TBFS类是作为TEight类的一个子类。其类的结构和成员函数的实现如下：
class TBFS:public TEight
{
public:
TBFS(){}
TBFS(char *fname):TEight(fname){}
virtual void Search();
private:
void Printl(TList<TBFS> &L);
int Repeat(TList<TBFS> &L);
int Find();
};
void TBFS::Printl(TList<TBFS> &L)
{
TBFS T=*this;
if(T.last==-1)
return;
else
{
T=L.GetData(T.last);
T.Printl(L);
T.Printf();
}
}
int TBFS::Repeat(TList<TBFS> &L)
{
int n=L.Getlen();
int i;
for(i=0;i<n;i++)
if(L.GetData(i)==*this)
break;
return i;
}
int TBFS::Find()
{
for(int i=0;i<Num;)
if(p[i]!=q[i++])
return 0;
return 1;
}
void TBFS::Search()
{
TBFS T=*this;
TList<TBFS> 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.Extend(i) && T.Repeat(L)>tail)
{
T.last=head;
L.Append(T);
tail++;
}
if(T.Find())
{
T.Printl(L);
T.Printf();
return;
}
}
head++;
}
}
4.广度优先搜索法的缺点
广度优先搜索法在有解的情形总能保证搜索到最短路经，也就是移动最少步数的路径。但广度优先搜索法的最大问题在于搜索的结点数量太多，因为在广度优先搜索法中，每一个可能扩展出的结点都是搜索的对象。随着结点在搜索树上的深度增大，搜索的结点数会很快增长，并以指数形式扩张，从而所需的存储空间和搜索花费的时间也会成倍增长。
五、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("eight_dis.txt",ios::in); //打开数据文件
if(!fin)
{
cout<<"不能打开数据文件!"<<endl;
return;
}
for(int 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();
int i;
for(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();
int i;
for(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.Printf(); //输出目标状态
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++; //一个结点不能再扩展，队列头指针指向下一结点
}
}
六、测试程序
A*算法的测试：
int main()
{
TAstar aStar("eight.txt");
aStar.Search();
system("pauze");
return 0;
}
eight.txt文件中的数据（初始态和目标态）：
一共三行，第一行是用空格隔开的九个数字0~8，这是初始状态。第二行是一个数字，空格（数字0）的位置，第三行也是用空格隔开的九个数字0~8，这是目标状态。
8 3 5 1 2 7 4 6 0
8
1 2 3 4 5 6 7 8 0
eight_dis.txt中的数据（估计函数使用）
0 1 2 1 2 3 2 3 4
1 0 1 2 1 2 3 2 3
2 1 0 3 2 1 4 3 2
1 2 3 0 1 2 1 2 3
2 1 2 1 0 1 2 1 2
3 2 1 2 1 0 3 2 1
2 3 4 1 2 3 0 1 2
3 2 3 2 1 2 1 0 1
4 3 2 3 2 1 2 1 0
eight_Result.txt中的结果（运行后得到的结果）
七、算法运行结果
1.BFS算法只能适用于到达目标结点步数较少的情况，如果步数超过15步，运行时间太长，实际上不再起作用。
2.对于随机生成的同一个可解状态，BFS算法最慢，DBFS算法较慢，A*算法较快。但在15步以内，DBFS算法与A*算法相差时间不大，超过15步后，随步数增加，A*算法的优势就逐渐明显，A*算法要比DBFS算法快5倍以上，并随步数增大而增大。到25步以上，DBFS同样因运行时间过长而失去价值。
3.一般来说，解答的移动步数每增加1，程序运行时间就要增加5倍以上。由于八数码问题本身的特点，需要检查的节点随步数增大呈指数形式增加，即使用A*算法，也难解决移动步数更多的问题。
八、问题可解性
八数码问题的一个状态实际上是0~9的一个排列，对于任意给定的初始状态和目标，不一定有解，也就是说从初始状态不一定能到达目标状态。因为排列有奇排列和偶排列两类，从奇排列不能转化成偶排列或相反。
如果一个数字0~8的随机排列871526340，用F(X)表示数字X前面比它小的数的个数，全部数字的F(X)之和为Y=∑(F(X))，如果Y为奇数则称原数字的排列是奇排列，如果Y为偶数则称原数字的排列是偶排列。
例如871526340这个排列的
Y=0+0+0+1+1+3+2+3+0=10
10是偶数，所以他偶排列。871625340
Y=0+0+0+1+1+2+2+3+0=9
9是奇数，所以他奇排列。
因此，可以在运行程序前检查初始状态和目标状态的窘是否相同，相同则问题可解，应当能搜索到路径。否则无解。
PS:整理自网络
Ⅳ 知道频率怎吗算波长要公式和算法。
首先要知道波速v，如果是空气中电磁波或者光波，那就是光速，30万公里每小时,如果是空气中声波，就是340m/s，然后知道频率，求倒数得到周期T，波在一个周期跑的距离就是波长了。也就是L=v*T
Ⅵ 关于示波器波形的算法，请赐教
简单来说sin插值就是在俩点之间用正弦曲线连接
而线性插值则是直接连线
正弦插值会使波形更加平滑，其实在现在的示波器采样率都足够的情况下，俩种插值方式表现结果差不多