这是一道BFS入门题

A - 这是一道BFS入门题
Time Limit:1000MS Memory Limit:32768KB 64bit IO Format:%I64d & %I64u
Description
There is a strange lift.The lift can stop can at every floor as you want, and there is a number Ki(0 <= Ki <= N) on every floor.The lift have just two buttons: up and down.When you at floor i,if you press the button “UP” , you will go up Ki floor,i.e,you will go to the i+Ki th floor,as the same, if you press the button “DOWN” , you will go down Ki floor,i.e,you will go to the i-Ki th floor. Of course, the lift can’t go up high than N,and can’t go down lower than 1. For example, there is a buliding with 5 floors, and k1 = 3, k2 = 3,k3 = 1,k4 = 2, k5 = 5.Begining from the 1 st floor,you can press the button “UP”, and you’ll go up to the 4 th floor,and if you press the button “DOWN”, the lift can’t do it, because it can’t go down to the -2 th floor,as you know ,the -2 th floor isn’t exist.
Here comes the problem: when you are on floor A,and you want to go to floor B,how many times at least he has to press the button “UP” or “DOWN”?

Input
The input consists of several test cases.,Each test case contains two lines.
The first line contains three integers N ,A,B( 1 <= N,A,B <= 200) which describe above,The second line consist N integers k1,k2,….kn.
A single 0 indicate the end of the input.

Output
For each case of the input output a interger, the least times you have to press the button when you on floor A,and you want to go to floor B.If you can’t reach floor B,printf “-1”.

Sample Input
5 1 5
3 3 1 2 5
0

Sample Output
3

有一个序列 第一个数字对应在一楼,能往上或往下移动的层数,第二个数字对应第二层,以此类推。

#include "iostream"
#include "string.h"
#include "queue"
using namespace std;
int N,A,B;
int cnt;
int a[205];
bool mark[205]; //用来记录该点是否走过 走过了就不用再走了
int flag=false;
struct ehh
{
    int floor,step;
} m,n,o;
int main()
{
    while(scanf("%d",&N)!=EOF)
    {
        queue<ehh> q;  //大坑 一直WA 因为之前生命在全局的位置 忘记清了 这告诉我们要保持良好习惯
        flag=false;
        if(N==0)
            return 0;
        cin>>A>>B;
        memset(a,0,sizeof(a));
        memset(mark,false,sizeof(mark));
        for(int i=1;i<=N;i++)
        {
            cin>>a[i];
        }
        m.floor=A;
        m.step=0;
        q.push(m);
        //BFS
        while(!q.empty())
        {
            n=q.front();
            q.pop();
            if(n.floor==B)
            {
                flag=true;
                cout<<n.step<<endl;
                break;
            }

            if((n.floor-a[n.floor])>0&&(n.floor-a[n.floor])<=N&&!mark[n.floor-a[n.floor]])// 不会走到不存在的楼层 go down
            {
                o.floor=n.floor-a[n.floor];
                o.step=n.step+1;
                mark[o.floor]=true;
                q.push(o);
            }
            if((n.floor+a[n.floor])>0&&(n.floor+a[n.floor])<=N&&!mark[n.floor+a[n.floor]]) //go up
            {
                o.floor=n.floor+a[n.floor];
                o.step=n.step+1;
                mark[o.floor]=true;
                q.push(o);
            }

        }
        if(flag==false)
            cout<<"-1"<<endl;



    }
}
BFS(广度优先搜索)是一种基础的图论算法,常用于解决最短路径问、连通性问等。在编程中,BFS一般通过队列来实现,具体步骤如下: 1. 将起始节点放入队列中; 2. 当队列不为空时,取出队头元素,并遍历其所有邻居节点; 3. 将未访问的邻居节点加入队列中,并标记为已访问; 4. 重复执行步骤2~3,直到队列为空。 下面是一个例子,假设我们要求解从节点1到节点6的最短路径: ``` 1--2--3 | | | 4--5--6 ``` 我们可以使用BFS来解决这个问。首先将起始节点1加入队列,然后遍历其邻居节点2和4,将它们加入队列中,并标记为已访问。然后从队列中取出节点2,遍历其邻居节点3和5,将它们加入队列中,并标记为已访问。然后从队列中取出节点4,遍历其邻居节点5,将它加入队列中,并标记为已访问。然后从队列中取出节点3,遍历其邻居节点5和6,发现6是终点节点,于是得到最短路径长度为3。可以使用一个字典来记录每个节点的前驱节点,从终点节点开始往回走即可得到最短路径。 以下是BFS的Python代码实现: ```python from collections import deque # 图的邻接表表示 graph = { 1: [2, 4], 2: [1, 3, 5], 3: [2, 6], 4: [1, 5], 5: [2, 4, 6], 6: [3, 5] } # 起始节点和终点节点 start_node = 1 end_node = 6 # BFS求解最短路径 queue = deque() queue.append(start_node) visited = set([start_node]) predecessors = {start_node: None} while queue: curr_node = queue.popleft() if curr_node == end_node: break for neighbor in graph[curr_node]: if neighbor not in visited: visited.add(neighbor) queue.append(neighbor) predecessors[neighbor] = curr_node # 回溯最短路径 path = [end_node] curr_node = end_node while predecessors[curr_node] is not None: path.insert(0, predecessors[curr_node]) curr_node = predecessors[curr_node] # 输出结果 print('最短路径长度:', len(path)-1) print('最短路径:', path) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值