HDU-1548(BFS+剪枝)

最新推荐文章于 2022-10-16 04:57:01 发布

原创最新推荐文章于 2022-10-16 04:57:01 发布 · 446 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#HDUACM #bfs #算法 #c语言 #stl

本文探讨了使用队列和优先队列优化BFS算法的实现方式，通过实例展示了如何在不同场景下选择合适的队列结构以提高算法效率。重点讨论了避免重复搜索和处理特殊条件（如A等于B的情况）的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

//一开始没有考虑A==B的情况，一直WA T_T

//用优先队列是0ms，用普通队列是15ms；
#include<cstdio> 
#include<queue> 
int N,A,B; 
typedef struct lift {
    int time,FLOOR;
}floor;//普通队列，用结构体带入数据
int BFS(int k[],int k2[],int k1[]);
using namespace std;
int main(){
	while(scanf("%d",&N)!=EOF){
		if(N==0){break;}
		scanf("%d%d",&A,&B);
		int k[201],k2[3]={0,1,-1},k1[202]={0};//k1用来进行剪枝，防止重复回溯；
		int i;
		for(i=1;i<=N;i++){
			scanf("%d",&k[i]);
		}
		int t;
		t=BFS(k,k2,k1);
		printf("%d\n",t);
	}
	return 0;
}
int BFS(int k[],int k2[],int k1[]) {
	queue<floor> que;
	floor start,next,cur;
	start.FLOOR=A;
	start.time=0;
	k1[A]=1;
	que.push(start);
	while(!que.empty()){
		cur=que.front();
		que.pop();
		if (cur.FLOOR==B)//防止少搜索
		return cur.time;
		int z;
		for(z=1;z<=2;z++){
			next.FLOOR=cur.FLOOR+k[cur.FLOOR]*k2[z];
			next.time=cur.time+1;
			if(next.FLOOR>N || next.FLOOR<1){continue;}
			if(k1[next.FLOOR]==1){continue;}
			k1[next.FLOOR]=1;//1代表已经走过
			que.push(next);
		}
	}
	return -1;
}
//优先队列方法<pre name="code" class="cpp">#include<iostream>
#include<cstdio>
#include<queue>
#include<stdlib.h>
int sum=0;
int N,A,B;
typedef struct lift
{
   int time,FLOOR;
   bool operator < (const lift &a) const{
         return time>a.time;
   }
}floor;//重载队列，小的先出队
int BFS(int k[],int k2[],int k1[]);
using namespace std;
int main()
{
        while(scanf("%d",&N)!=EOF)
        {
                if(N==0){break;}
                scanf("%d%d",&A,&B);
             int k[201],k2[3]={0,1,-1},k1[202]={0};
             int i;
             for(i=1;i<=N;i++)
             {
                     scanf("%d",&k[i]);
             }
             int t;
             if(A==B){printf("0\n");continue;}//注意A==B的情况
             t=BFS(k,k2,k1);
             printf("%d\n",t);

        }
        return 0;


}
int BFS(int k[],int k2[],int k1[])
{
             priority_queue<floor> que;
             floor start,next,cur;
             start.FLOOR=A;
             start.time=0;
             k1[A]=1;
             que.push(start);
             while(!que.empty())
             {
                     cur=que.top();
                     que.pop();
                     int z;
                    // if(cur.FLOOR==B){return cur.time;}
                     for(z=1;z<=2;z++)
                     {
                        next.FLOOR=cur.FLOOR+k[cur.FLOOR]*k2[z];
                        next.time=cur.time+1;

                        if((next.FLOOR>N)||(next.FLOOR<1)){continue;}

                        if(k1[next.FLOOR]==1){continue;}

                        k1[next.FLOOR]=1;//1代表已经走过；

                        if(next.FLOOR==B){return next.time;}
                        else
                         {que.push(next);}


                     }


             }
             return -1;


}