1.gcalcԴ??
2.有八数码问题的源代码吗？可以发给我吗 865488021@qq.com
3.oa办公软件有哪些

gcalcԴ??

       文件处理一直都是前端人的心头病，如何控制好文件大小，文件太大上传不了，文件下载时间太长，tcp直接给断开了?等

效果

       为了方便大家有意义的学习，这里就先放效果图，取值范围源码如果不满足直接返回就行，不浪费大家的时间。

文件上传

       文件上传实现，分片上传，暂停上传，恢复上传，文件合并等

文件下载

       为了方便测试，我上传了1个1g的大文件拿来下载，前端用的是流的方式来保存文件的，具体的可以看这个apiTransformStream

正文

       本项目的地址是：/post/

       requestIdleCallback有不明白的可以看这里：/post/

       接下来咋们来计算文件的hash,计算文件的hash需要使用spark-md5这个库，

全量计算文件hashexportasyncfunctioncalcHashSync(file:File){ //对文件进行分片，每一块文件都是分为2MB，这里可以自己来控制constsize=2**;letchunks:any[]=[];letcur=0;while(cur<file.size){ chunks.push({ file:file.slice(cur,cur+size)});cur+=size;}//可以拿到当前计算到第几块文件的进度lethashProgress=0returnnewPromise(resolve=>{ constspark=newSparkMD5.ArrayBuffer();letcount=0;constloadNext=(index:number)=>{ constreader=newFileReader();reader.readAsArrayBuffer(chunks[index].file);reader.onload=e=>{ //累加器不能依赖index，count++;//增量计算md5spark.append(e.target?.resultasArrayBuffer);if(count===chunks.length){ //通知主线程，计算结束hashProgress=;resolve({ hashValue:spark.end(),progress:hashProgress});}else{ //每个区块计算结束，通知进度即可hashProgress+=/chunks.length//计算下一个loadNext(count);}};};//启动loadNext(0);});}

       全量计算文件hash，在文件小的时候计算是很快的，但是在文件大的情况下，计算文件的hash就会非常慢，并且影响主进程哦?

抽样计算文件hash

       抽样就是取文件的一部分来继续，原理如下：

/***抽样计算hash值大概是1G文件花费1S的时间**采用抽样hash的方式来计算hash*我们在计算hash的时候，将超大文件以2M进行分割获得到另一个chunks数组，*第一个元素(chunks[0])和最后一个元素(chunks[-1])我们全要了*其他的元素(chunks[1,2,3,4....])我们再次进行一个分割，这个时候的分割是一个超小的大小比如2kb，我们取*每一个元素的头部，尾部，中间的2kb。*最终将它们组成一个新的文件，我们全量计算这个新的文件的hash值。*@paramfile{ File}*@returns*/exportasyncfunctioncalcHashSample(file:File){ returnnewPromise(resolve=>{ constspark=newSparkMD5.ArrayBuffer();constreader=newFileReader();//文件大小constsize=file.size;letoffset=2**;letchunks=[file.slice(0,offset)];//前面2mb的数据letcur=offset;while(cur<size){ //最后一块全部加进来if(cur+offset>=size){ chunks.push(file.slice(cur,cur+offset));}else{ //中间的前中后去两个字节constmid=cur+offset/2;constend=cur+offset;chunks.push(file.slice(cur,cur+2));chunks.push(file.slice(mid,mid+2));chunks.push(file.slice(end-2,end));}//前取两个字节cur+=offset;}//拼接reader.readAsArrayBuffer(newBlob(chunks));//最后Kreader.onload=e=>{ spark.append(e.target?.resultasArrayBuffer);resolve({ hashValue:spark.end(),progress:});};});}

       这个设计是不是发现挺灵活的，真是个人才哇

       在这两个的基础上，咋们还可以分别使用web-worker和requestIdleCallback来实现，源代码在hereヾ(≧▽≦*)o

       这里把我电脑配置说一下，公司给我分的电脑配置比较lower,8g内存的老机器。计算(3.3g文件的)hash的结果如下:

       结果很显然，全量无论怎么弄，都是dzdd源码比抽样的更慢。

文件分片的方式

       这里可能大家会说，文件分片方式不就是等分吗，其实还可以根据网速上传的速度来实时调整分片的大小哦！

consthandleUpload1=async(file:File)=>{ if(!file)return;constfileSize=file.sizeletoffset=2**letcur=0letcount=0//每一刻的大小需要保存起来，方便后台合并constchunksSize=[0,2**]constobj=awaitcalcHashSample(file)as{ hashValue:string};fileHash.value=obj.hashValue;//todo判断文件是否存在存在则不需要上传，也就是秒传while(cur<fileSize){ constchunk=file.slice(cur,cur+offset)cur+=offsetconstchunkName=fileHash.value+"-"+count;constform=newFormData();form.append("chunk",chunk);form.append("hash",chunkName);form.append("filename",file.name);form.append("fileHash",fileHash.value);form.append("size",chunk.size.toString());letstart=newDate().getTime()//todo上传单个碎片constnow=newDate().getTime()consttime=((now-start)/).toFixed(4)letrate=Number(time)///速率有最大和最小可以考虑更平滑的过滤比如1/tanif(rate<0.5)rate=0.5if(rate>2)rate=2offset=parseInt((offset/rate).toString())chunksSize.push(offset)count++}//todo可以发送合并操作了} ATTENTION!!!?如果是这样上传的文件碎片，如果中途断开是无法续传的（每一刻的网速都是不一样的），除非每一次上传都把chunksSize(分片的数组)保存起来哦

控制/post/

有八数码问题的源代码吗？可以发给我吗 @qq.com

       称为九宫问题。在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。所谓问题的一个状态就是棋子在棋盘上的一种摆法。棋子移动后，状态就会发生改变。解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。

       八数码问题一般使用搜索法来解。搜索法有广度优先搜索法、深度优先搜索法、A*算法等。这里通过用不同方法解八数码问题来比较一下不同搜索法的效果。

       二.搜索算法基类

       1.八数码问题的状态表示

       八数码问题的一个状态就是八个数字在棋盘上的一种放法。每个棋子用它上面所标的数字表示，并用0表示空格，这样就可以将棋盘上棋子的一个状态存储在一个一维数组p[9]中，存储的顺序是从左上角开始，自左至右，从上到下。也可以用一个二维数组来存放。

       2.结点

       搜索算法中，问题的状态用结点描述。结点中除了描述状态的数组p[9]外，还有一个父结点指针last，它记录了当前结点的父结点编号，如果一个结点v是从结点u经状态变化而产生的，则结点u就是结点v的父结点，结点v的last记录的就是结点u的编号。在到达目标结点后，mycncart 源码通过last 可以找出搜索的路径。

       3.类的结构

       在C++中用类来表示结点，类将结点有关的数据操作封装在一起。

       不同的搜索算法具有一定共性，也有各自的个性，因此这里将不同搜索算法的共有的数据和功能封装在一个基类中，再通过继承方式实现不同的搜索算法。

       4.结点扩展规则

       搜索就是按照一定规则扩展已知结点，直到找到目标结点或所有结点都不能扩展为止。

       八数码问题的结点扩展应当遵守棋子的移动规则。按照棋子移动的规则，每一次可以将一个与空格相邻棋子移动到空格中，实际上可以看作是空格作相反移动。空格移动的方向可以是右、下、左、上，当然不能移出边界。棋子的位置，也就是保存状态的数组元素的下标。空格移动后，它的位置发生变化，在不移出界时，空格向右、下、左和上移动后，新位置是原位置分别加上1、3、-1、-3，如果将空格向右、下、左和上移动分别用0、1、2、3表示，并将-3、3、-1、1放在静态数组d[4]中，空格位置用spac表示，那么空格向方向i移动后，fastim源码它的位置变为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[]=;//方向

       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() //构造函数

        int Getlen()const //成员函数，返回线性表长度

        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）如果扩展出的新结点与队列中的结点重复，则抛弃新结点，跳至第六步。librados 源码

       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算法只能适用于到达目标结点步数较少的情况，如果步数超过步，运行时间太长，实际上不再起作用。

       2.对于随机生成的同一个可解状态，BFS算法最慢，DBFS算法较慢，A*算法较快。但在步以内，DBFS算法与A*算法相差时间不大，超过步后，随步数增加，A*算法的优势就逐渐明显，A*算法要比DBFS算法快5倍以上，并随步数增大而增大。到步以上，DBFS同样因运行时间过长而失去价值。

       3.一般来说，解答的移动步数每增加1，程序运行时间就要增加5倍以上。由于八数码问题本身的特点，需要检查的节点随步数增大呈指数形式增加，即使用A*算法，也难解决移动步数更多的问题。

       八、问题可解性

       八数码问题的一个状态实际上是0~9的一个排列，对于任意给定的初始状态和目标，不一定有解，也就是说从初始状态不一定能到达目标状态。因为排列有奇排列和偶排列两类，从奇排列不能转化成偶排列或相反。

       如果一个数字0~8的随机排列，用F(X)表示数字X前面比它小的数的个数，全部数字的F(X)之和为Y=∑(F(X))，如果Y为奇数则称原数字的排列是奇排列，如果Y为偶数则称原数字的排列是偶排列。

       例如这个排列的

       Y=0+0+0+1+1+3+2+3+0=

       是偶数，所以他偶排列。

       Y=0+0+0+1+1+2+2+3+0=9

       9是奇数，所以他奇排列。

       因此，可以在运行程序前检查初始状态和目标状态的窘是否相同，相同则问题可解，应当能搜索到路径。否则无解。

       PS:整理自网络

       另外,团IDC网上有许多产品团购,便宜有口碑

oa办公软件有哪些

       OA（Office Automation）办公软件主要包括以下几种：

       1. Microsoft Office：这是一套由微软公司开发的办公软件套件，包括Word（文字处理）、Excel（电子表格）、PowerPoint（演示文稿）、Outlook（邮件管理）等组件，广泛应用于文档编辑、数据分析和报告制作等场景。

       2. Google Workspace（原G Suite）：这是谷歌提供的云端办公软件，包含Google Docs（文档）、Google Sheets（电子表格）、Google Slides（演示文稿）、Google Drive（云存储）等，支持实时协作和多设备同步。

       3. Apache OpenOffice：这是一个开源的办公软件套件，提供与Microsoft Office类似的组件，如Writer（文字处理）、Calc（电子表格）、Impress（演示文稿）等，适用于那些希望免费使用办公软件的个人或组织。

       4. WPS Office：这是由中国金山软件公司开发的一款办公软件，与Microsoft Office兼容性良好，包括WPS文字、WPS表格、WPS演示等，同时提供了免费版和付费版供用户选择。

       这些OA办公软件各有特点，满足了不同用户的需求。例如，Microsoft Office由于其悠久的历史和强大的功能，被许多企业和个人用户广泛使用；Google Workspace则因其云服务特性，适合远程协作和团队工作；Apache OpenOffice为开源软件，为预算有限或者重视开放源码的用户提供了一个选择；而WPS Office则以良好的兼容性和对中国用户的深入理解，在中国市场占有一定份额。