双向搜索算法

最新推荐文章于 2024-05-27 20:18:54 发布
最新推荐文章于 2024-05-27 20:18:54 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： 世界经典算法问题交流探讨 文章标签： 算法 struct byte
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lionkid/article/details/466673
版权

   

typedef struct _POINT

{

       int nx;

       int ny;

}POINT;

 

typedef struct _WORLDUNIT

{

       BYTE nColorIndex;//颜色索引

   

       boolean bClear;  //

    boolean bFind;  //是否已经查找过了…

       POINT Father; ///正向,逆向求解路径

       int nChild;//表示数目了.

       POINT CHILD[4];///正向,逆向求解路径

}WorldUnit;

 

void ResetPathData(AIGoogleApp * pMe)//重置搜索路径的所有数据….

{

       int x,y;

    for(x=0;x<Line_Num;x++)

       {

              for(y=0;y<Col_Num;y++)

              {

                     pMe->Cell[x][y].nChild=0;

                  pMe->Cell[x][y].Father.nx=NOVALUE;

                     pMe->Cell[x][y].Father.ny=NOVALUE;      

                     pMe->Cell[x][y].bFind =FALSE; 

                     pMe->Cell[x][y].bClear=FALSE;          

              }

       }   

       //已保存数据也要重置了.

}

 

 

void InitFindData(AIGoogleApp * pMe)//初始化搜索的数据了….

{

       pMe->nSelOld=1;  ///正在目标搜索的节点数目

       pMe->SelOld[0].nx =pMe->nSelx; ///正在目标搜索的节点

       pMe->SelOld[0].ny =pMe->nSely;  

       pMe->Cell[pMe->nSelx][pMe->nSely].bFind=TRUE;  标志为查找过了…

       pMe->nSelNew=0; //新添加的可搜索节点个数

 

       pMe->nAimOld=1; ///正在目标搜索的节点数目,主要是双向的问题,才这样定义.

       pMe->AimOld[0].nx =pMe->nAimx;

       pMe->AimOld[0].ny =pMe->nAimy;  

       pMe->Cell[pMe->nAimx][pMe->nAimy].bFind=TRUE;

       pMe->nAimNew=0;

}

 

static boolean FindGoodPath(AIGoogleApp * pMe)

{

       int x,y;//用于自身周围的数据了.

       int m,n;//临时变量

 

       ResetPathData(pMe);//重置数据,然后开始了.

 

       InitFindData(pMe); //重置查找数据了.

       //从两个点出发查找问题.吧

       while((pMe->nSelOld!=0)&&(pMe->nAimOld!=0))//任意一个正在搜索的节点集为空的话,停止搜索…

       {

              //处理了,先处理选中的,再处理目的的.

              //逐个判断算了

              /*

              if(pMe->nSelOld==0)

              {

             

              }

              if(pMe->nAimOld==0)

              {

                    

              }

        */

              while(pMe->nSelOld!=0)//将该外圈全部查找完毕才算结束了.

              {

                     //首先不可能是了.原因:是的话就不可能调用查找路径了.

            //把已经浏览过得给毖掉.哈哈,就可以了.                  

                    

                     x=pMe->SelOld[pMe->nSelOld-1].nx;

                     y=pMe->SelOld[pMe->nSelOld-1].ny;

                    

                     pMe->Cell[x][y].bFind=TRUE;              

           

                     //上面的判断

                     m=x-1;

                     n=y;

                     if(m>=0)

                     { 

                            if(FindOrAdd(pMe,m,n,x,y,0,TRUE))//检测是否查找到了,呵呵…

                            {

                                   return TRUE;

                            }

                     }

                    

                     //下面的判断

                     m=x+1;

                     n=y;

                     if(m<Line_Num)

                     {

                            if(FindOrAdd(pMe,m,n,x,y,1,TRUE)) //检测是否查找到了,呵呵

                            {

                                   return TRUE;

                            }

                     }

             

                     //左面的判断

                     m=x;

                     n=y-1;

                     if(n>=0)

                     {

                            if(FindOrAdd(pMe,m,n,x,y,2,TRUE)) //检测是否查找到了,呵呵

                            {

                                   return TRUE;

                            }

                     }

             

                     //右面的判断

                     m=x;

                     n=y+1;

                     if(n<Col_Num)

                     {

                            if(FindOrAdd(pMe,m,n,x,y,3,TRUE)) //检测是否查找到了,呵呵

                            {

                                   return TRUE;

                            }

                     }

                    

                     pMe->nSelOld--;

                    

              }

              //然后新的赋给老的

        //新的赋给老的             

              NewToOld(pMe,FALSE);//将新生成的搜索集赋给老的了…

             

        while(pMe->nAimOld!=0)//将该外圈全部查找完毕才算结束了.

              {

                     //首先不可能是了.原因:是的话就不可能调用查找路径了.

            //把已经浏览过得给毖掉.哈哈,就可以了.                  

                    

                     x=pMe->AimOld[pMe->nAimOld-1].nx;

                     y=pMe->AimOld[pMe->nAimOld-1].ny;

                    

                     pMe->Cell[x][y].bFind=TRUE;              

           

             

                     //上面的判断

                     m=x-1;

                     n=y;

                     if(m>=0)

                     { 

                            if(FindOrAdd(pMe,m,n,x,y,0,FALSE))

                            {

                                   return TRUE;

                            }

                     }

             

                     //下面的判断

                     m=x+1;

                     n=y;

                     if(m<Line_Num)

                     {

                            if(FindOrAdd(pMe,m,n,x,y,1,FALSE))

                            {

                                   return TRUE;

                            }

                     }

                    

                     //左面的判断

                     m=x;

                     n=y-1;

                     if(n>=0)

                     {

                            if(FindOrAdd(pMe,m,n,x,y,2,FALSE))

                            {

                                   return TRUE;

                            }

                     }

                    

                     //右面的判断

                     m=x;

                     n=y+1;

                     if(n<Col_Num)

                     {

                            if(FindOrAdd(pMe,m,n,x,y,3,FALSE))

                            {

                                   return TRUE;

                            }

                     }

                    

                     pMe->nAimOld--;

                    

              }

        //然后新的赋给老的

             

              NewToOld(pMe,TRUE);

       }

       return FALSE;

}

boolean FindOrAdd(AIGoogleApp * pMe,int m,int n,int x,int y,int nChild,boolean bInAim)

{    

       POINT ToCheck;

 

       if(pMe->Cell[m][n].nColorIndex!=0)

       {

              return FALSE;

       }

             

       ToCheck.nx=m;

       ToCheck.ny=n;

       if(CheckFind(pMe,ToCheck,bInAim))

       {

              pMe->PosFind.nx=ToCheck.nx ;

              pMe->PosFind.ny=ToCheck.ny ;

              ConStructPath(pMe,x,y,bInAim);//转过去的是找到点的准父 接点了.但目前尚无父子关系.

              return TRUE;

       }

       else

       {

              if(pMe->Cell[m][n].bFind==TRUE)

                     return FALSE;

              if(bInAim)                   

              {

                     pMe->Cell[x][y].CHILD[nChild].nx=m;//将其儿子进行赋值  

                     pMe->Cell[x][y].CHILD[nChild].ny=n;

                    

                     pMe->SelNew[pMe->nSelNew].nx=m;

                     pMe->SelNew[pMe->nSelNew].ny=n;

                    

                     pMe->nSelNew++;//儿子数目增加

                    

                     pMe->Cell[m][n].Father.nx=x;//儿子指向父亲

                     pMe->Cell[m][n].Father.ny=y;

                     pMe->Cell[m][n].bFind=TRUE;//设置为已经找到过了.

              }

              else

              {

                     pMe->Cell[x][y].CHILD[nChild].nx=m;//将其儿子进行赋值  

                     pMe->Cell[x][y].CHILD[nChild].ny=n;

                    

                     pMe->AimNew[pMe->nAimNew].nx=m;

                     pMe->AimNew[pMe->nAimNew].ny=n;

                    

                     pMe->nAimNew++;//儿子数目增加

                    

                     pMe->Cell[m][n].Father.nx=x;//儿子指向父亲

                     pMe->Cell[m][n].Father.ny=y;

                     pMe->Cell[m][n].bFind=TRUE;//设置为已经找到过了.

              }

       }                         

       //检测是否找到了.如果找到退出.                                  

       //如果没找到呢,就添加到新的里面去

       //进行处理

      

       return FALSE;

}

 

boolean CheckFind(AIGoogleApp * pMe,POINT ToCheck,boolean bInAim)

{

       int x;      

       if(bInAim)//如果在目标里查找

       {       

              for(x=0;x<pMe->nAimOld;x++)

              {

                     if(IsEqual(pMe,ToCheck,pMe->AimOld[x]))

                     {                         

                            return TRUE;

                     }

              }

       }

       else

       {

              for(x=0;x<pMe->nSelOld;x++)

              {

                     if(IsEqual(pMe,ToCheck,pMe->SelOld[x]))

                     {

                            return TRUE;

                     }

              }

       }

       return FALSE;

}

 

///

boolean IsEqual(AIGoogleApp * pMe,POINT Check1,POINT Check2)

{

       if((Check1.nx==Check2.nx)&&(Check1.ny==Check2.ny))

              return TRUE;

       else

              return FALSE;     

}

//

void NewToOld(AIGoogleApp * pMe,boolean bAim)

{

       int x;

       if(bAim)

       {

              pMe->nAimOld=0;

             

              for(x=0;x<pMe->nAimNew;x++)

              {

                     pMe->AimOld[pMe->nAimOld].nx =pMe->AimNew[x].nx;

                     pMe->AimOld[pMe->nAimOld].ny =pMe->AimNew[x].ny;

                     pMe->nAimOld++;

                    

              }

              pMe->nAimNew=0;

       }

       else

       {

              pMe->nSelOld=0;

             

              for(x=0;x<pMe->nSelNew;x++)

              {

                     pMe->SelOld[pMe->nSelOld].nx =pMe->SelNew[x].nx;

                     pMe->SelOld[pMe->nSelOld].ny =pMe->SelNew[x].ny;

                     pMe->nSelOld++;                   

              }

              pMe->nSelNew=0;

       }

}

///

void ConStructPath(AIGoogleApp * pMe,int x,int y,boolean bAim)

{

       int x1,y1,m,n;

       int nChildx,nChildy;

       //转过去的是找到点的准父 接点了.但目前尚无父子关系.

     PathToSel(pMe,x,y,bAim);

        PathToAim(pMe,x,y,bAim);

        if(bAim)//连接起来了//

        {

               pMe->Cell[x][y].nChild=1; 

               pMe->Cell[x][y].CHILD[0].nx=pMe->PosFind.nx ;

               pMe->Cell[x][y].CHILD[0].ny=pMe->PosFind.ny ; 

        }

        else

        {

               pMe->Cell[pMe->PosFind.nx][pMe->PosFind.ny].CHILD[0].nx=x;

               pMe->Cell[pMe->PosFind.nx][pMe->PosFind.ny].CHILD[0].ny=y;

               pMe->Cell[pMe->PosFind.nx][pMe->PosFind.ny].nChild=1;

        }

 

        x1=pMe->nSelx;

        y1=pMe->nSely;

 

     while((x1!=pMe->nAimx)||(y1!=pMe->nAimy))

        {

        

               if((pMe->Cell[x1][y1].CHILD[0].nx==x1)&&(pMe->Cell[x1][y1].CHILD[0].ny==y1))

               {

                      break;

               }

 

               nChildx=pMe->Cell[x1][y1].CHILD[0].nx;

               nChildy=pMe->Cell[x1][y1].CHILD[0].ny;

               

               m=pMe->Cell[x1][y1].CHILD[0].nx;

               n=pMe->Cell[x1][y1].CHILD[0].ny;

               x1=m;

               y1=n;

        }

 

}

///

void PathToSel(AIGoogleApp * pMe,int x,int y,boolean bAim)

{

       //转过去的是找到点的准父 接点了.但目前尚无父子关系.

       int m,n;

       if(bAim)//在目标集中找到的话

       {

              //指向选择者的.

              while(pMe->Cell[x][y].Father.nx!=NOVALUE)

              {

                     m=pMe->Cell[x][y].Father.nx;

                     n=pMe->Cell[x][y].Father.ny;

                     pMe->Cell[m][n].CHILD[0].nx=x;

                     pMe->Cell[m][n].CHILD[0].ny=y;

                     pMe->Cell[m][n].nChild=1; 

                     x=m;

                     y=n;

              }

       }

       else

       {

              x=pMe->PosFind.nx;

              y=pMe->PosFind.ny;

              while(pMe->Cell[x][y].Father.nx!=NOVALUE)

              {           

                     m=pMe->Cell[x][y].Father.nx;

                     n=pMe->Cell[x][y].Father.ny;

                     pMe->Cell[m][n].CHILD[0].nx=x;

                     pMe->Cell[m][n].CHILD[0].ny=y;

                     pMe->Cell[m][n].nChild=1;

                     x=m;

                     y=n;

              }

       }

 

}

void PathToAim(AIGoogleApp * pMe,int x,int y,boolean bAim)

{

       //转过去的是找到点的准父 接点了.但目前尚无父子关系.

       int m,n;

       if(bAim)

       {

              //指向选择者的.

 

              x=pMe->PosFind.nx;

              y=pMe->PosFind.ny;

              while(pMe->Cell[x][y].Father.nx!=NOVALUE)

              {                  

                     m=pMe->Cell[x][y].Father.nx;

                     n=pMe->Cell[x][y].Father.ny;

                     pMe->Cell[x][y].CHILD[0].nx=m;

                     pMe->Cell[x][y].CHILD[0].ny=n;

                     pMe->Cell[x][y].nChild=1;

                     x=m;

                     y=n;

              }

       }

       else

       {

              while(pMe->Cell[x][y].Father.nx!=NOVALUE)

              {           

                     m=pMe->Cell[x][y].Father.nx;

                     n=pMe->Cell[x][y].Father.ny;

                     pMe->Cell[x][y].CHILD[0].nx=m;

                     pMe->Cell[x][y].CHILD[0].ny=n;

                     pMe->Cell[x][y].nChild=1;

                     x=m;

                     y=n;

              }

       }

}

 

lionkid
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
算法第十三期——BFS-双向广搜
荷叶田田的博客
01-16 973
BFS优化---双向广搜
双向a*搜索算法_双向搜索算法
cumtb2002的博客
07-29 3215
双向a*搜索算法 什么是双音搜索？ (What is bitonic search?) Searching a bitonic array is known as bitonic search. An array is said to be bitonic if it has an increasing sequence of integers followed immediately by a ...
双向搜索总结
ZhuRanCheng的博客
02-01 2093
双向搜索总结
双向搜索算法（基于深度优先搜索算法的优化）
lslskkkyy的博客
04-26 1138
这种算法通常用于搜索问题，其中起点和终点之间的距离较远，而搜索空间较大，例如在图形搜索、字符串匹配和游戏搜索中。双向搜索算法的应用非常广泛，例如在图形搜索中，可以从起点和终点同时开始搜索，以找到最短路径。4. 可能会忽略一些解：深度优先算法只会搜索一条路径，如果存在多个解决方案，但是它们不在同一条路径上，那么深度优先算法可能会忽略其中一些解决方案。3. 空间复杂度高：深度优先算法需要使用递归或者栈来保存搜索过程中的状态，因此在搜索深度较大的情况下，空间复杂度会很高，可能会导致内存溢出。
双向搜索-meet in middle
最新发布
m0_75103840的博客
05-27 947
​在广度优先搜索中，如果结点数扩展增长过快，可以考虑双向广 搜。（若扩展快，但总状态量不大，也可直接用广搜）⚫ 应用场合：有确定的起点和终点，并且能把从起点到终点的单个 搜索，变换为分别从起点出发和从终点出发的“相遇”问题。⚫ 实现方法：(1)合用一个队列，交替进行。两个方向的搜索产生相 同的子状态，结束。适合正反方向扩展新节点数量差不多的情况；(2)分成两个队列，让子状态少的BFS先扩展，可以减少搜索的总 状态数，尽快相遇。以一道例题进行讲解。
双向搜索的理解和板子
louisdlee的博客
01-18 1261
/开一个二维map，m[i][string]= step;无论0在哪个位置，它都可以往四个方向交换，当然，这里面有很多无效的操作，所以我们考虑剪枝，如果它交换后的坐标，是合法坐标，那么我们认为这次交换时有效的。//在字符串中，向左移动，向右移动，向上移动，向下移动。//在字符串中，向左移动，向右移动，向上移动，向下移动。//在字符串中，向左移动，向右移动，向上移动，向下移动。//在字符串中，向左移动，向右移动，向上移动，向下移动。
第五十二章 BFS进阶（二）——双向广搜
Turing_Sheep的博客
02-12 1217
第五十二章 BFS进阶（二）——双向广搜
【高级算法设计与分析】实验2：单向与双向A*搜索算法
Can__er的博客
04-26 925
1. 实验目的 1、掌握搜索算法的基本设计思想与方法， 2、掌握 A*算法的设计思想与方法， 3、熟练使用高级编程语言实现搜索算法， 4、利用实验测试给出的搜索算法的正确性。
BiRch：一种处理k步可达性查询的双向搜索算法
01-14
针对现有方法低效或索引规模庞大的问题，提出一种双向搜索算法BiRch。当判断顶点u是否满足k步可达顶点v时，首先比较u的出度和v的入度，优先处理度小的顶点。其优点体现在使用较小的索引，同时避免由于u的出度过大所...
matlab 双向A星算法
05-11
相比于单向搜索，双向搜索减少了探索不必要的节点，提高了效率。 在描述中提到“适用于论文研究”，这暗示了双向A*算法可能被用于学术研究，比如在路径规划、人工智能、机器人导航、游戏设计或者图形学等领域进行...
双向链表算法.zip
04-24
搜索算法：搜索算法用于在数据集中查找特定元素的算法。常见的搜索算法包括线性搜索、二分搜索等。 图算法：图算法用于处理图结构的数据，如最短路径算法（如Dijkstra算法、Floyd-Warshall算法）、最小生成树算法...
双向广度优先搜索
05-23
这个就才一点点，帮助理解下就行。。我资源里有其他更详细的
双向广搜总结
11-15
双向广搜在竞赛中是很有战斗力的，比单向的广搜快很多
基于matlab的双向A*算法
04-30
A*算法是从起始点开始向目标点搜索，而双向A*是在A*的基础上由起始点和目标点同时搜索，当一方检测到另一方的已检查节点时，搜索结束，在搜索时间效率上，双向A*更快。
基于遗传算法的双向搜索Chord算法.pdf
11-20
【双向搜索算法】双向搜索算法是从源节点和目标节点同时进行查找，两股搜索路径在中间相遇，从而减少总的查找步数。在Chord算法中，引入双向搜索可以加速数据查找过程，尤其是在物理拓扑复杂的情况下。 【论文贡献...
改进双向启发式搜索算法及其车载导航仪中应用
12-08
为此，研究人员提出了各种改进算法，如启发式搜索算法和双向搜索算法。 启发式搜索算法引入了估价函数，结合实际费用和目标节点的估计费用，提高了搜索效率。而双向搜索算法则同时从前向和后向两个方向进行搜索，...
双向搜索(bfs,dfs)
人工智能方向，计算机视觉
07-25 1937
双向搜索的基本思路： 从状态图上的起点和终点同时开始进行 广搜 或 深搜。如果发现搜索的两端相遇了，那么可以认为是获得了可行解 例题： 字串变换 代码： #include <cstring> #include <iostream> #include <algorithm> #include <unordered_map> #include <queue> #define SI unordered_map<string, int> usi
双向广搜（bfs）
qq_56253743的博客
08-09 1050
双向广度优先搜索 广度优先搜索遵循从初始结点开始一层层扩展直到找到目标结点的搜索规则，它只能较好地解决状态不是太多的情况，承受力很有限。如果扩展结点较多，而目标结点又处在较深层，采用前文叙述的广度搜索解题，搜索量巨大是可想而知的，往往就会出现内存空间不够用的情况。双向搜索和A算法对广度优先的搜索方式进行了改良或改造，加入了一定的“智能因素”，使搜索能尽快接近目标结点，减少了在空间和时间上的复杂度。 　　(1)搜索过程 　　有些问题按照广度优先搜索法则扩展结点的规则，既适合顺序，也适合逆序，于是我们考虑在
双向广搜
佛系更新
05-22 1512
文章目录前言一、双向广搜二、AcWing 190. 字串变换本题分析AC代码三、时间复杂度 前言 复习acwing算法提高课的内容，本篇为讲解算法：双向广搜，关于时间复杂度：目前博主不太会计算，先鸽了，日后一定补上。 一、双向广搜 双向广搜其实就是两个bfs，我们知道bfs是一种暴力的做题方法，搜索树长下图所示： 我们会发现搜索树越来越宽，每一层的搜索量增加，如果数据范围很大的话，显然是会TLE的，那么为了避免TLE，我们可以采用双向广搜，即两个bfs，如下图所示： 这个样子就可以省去很多不必要的.
matlab双向搜索算法
10-17
双向搜索算法是一种从起点和终点同时进行搜索的算法，可以有效地减少搜索的时间和空间复杂度。在MATLAB中，可以使用双向搜索算法来解决一些图论问题，如最短路径问题等。 双向搜索算法的基本思路是从起点和终点同时...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值