bfs

#include<iostream>
using namespace std;
#include<string.h>
#include<queue>
int vis[1000];
struct node{
	int x,step;
}; 
int a,b;
bool check(int k)
{
	if(k>1000||k<0||vis[k==1])return false;
	return true;
}
queue<node> q;
int bfs(int a,int b)
{
	while(!q.empty())q.pop();
	vis[a]=1; q.push({a,0});
	while(!q.empty())
	{
		node ss=q.front();
		if(ss.x==b)return ss.step;
		q.pop();
		if(check(ss.x+1))
		{
			vis[ss.x+1]=1;
			q.push({ss.x+1,ss.step+1});
		}
			if(check(ss.x-1))
		{
			vis[ss.x-1]=1;
			q.push({ss.x-1,ss.step+1});
		}
			if(check(ss.x*2))
		{
			vis[ss.x*2]=1;
			q.push({ss.x*2,ss.step+1});
		}
	}
//	return -1;
}
int main()
{
	while(cin>>a>>b)
	{
		memset(vis,0,sizeof(vis));
		cout<<bfs(a,b)<<endl;
	}
	return 0;
}

　　

有一个奇怪的电梯可以停止在任何一个你想去的楼层，并且在每个楼层有一个Ki（0 <= Ki <= N）。电梯只有两个按钮：上下。当你在第i层，如果你按下“UP”按钮，你将上升到Ki楼层，也就是说，你将会到达第i + Ki层，如果你按下“DOWN”按钮，你将会下降Ki楼层，即您将前往第i层。当然，电梯不能高于N，并且不能低于1.例如，有5层的建筑物，并且k1 = 3，k2 = 3，k3 = 1，k4 = 2，k5 = 5。从1楼开始，你可以按下“UP”按钮，你会到4楼，如果你按下“DOWN”按钮，电梯不能做它，因为它不能下到-2楼，如你所知，-2楼是不存在的。
问题出在这里：当你在A楼，而你想去B楼时，至少他必须按下“UP”或“DOWN”按钮多少次？
输入
输入包含多个测试用例。每个测试用例包含两行。
第一行包含上述三个整数N，A，B（1 <= N，A，B <= 200），第二行由N个整数k1，k2，... kn组成。
单个0表示输入结束。
产量
对于每种情况的输入输出一个整数，最少的次数，你必须按下按钮，当你在A楼，而你想要去B楼。如果你不能达到B层，printf“-1”。
示例输入
5 1 5
3 3 1 2 5
0
示例输出
3

#include<iostream>
#include<string.h>
#include<queue>
using namespace std;
int N, A, B;
int k[10000];
int vis[10000];
struct Node
{
        int f, step;
};
queue<Node> q;
bool check(int n)
{
        if(n > N || n <= 0 || vis[n])
                return false;
        return true;
}
int bfs()
{

        while(!q.empty())
                q.pop();//////////
        vis[A] = 1;
        q.push(Node{A, 0});
        while(!q.empty())
        {
                Node ss = q.front();
                if(ss.f == B)
                        return ss.step;
                q.pop();
                if(check(ss.f + k[ss.f]))
                {
                        vis[ss.f + k[ss.f]] = 1;
                        q.push(Node{ss.f + k[ss.f], ss.step + 1});
                }
                if(check(ss.f - k[ss.f]))
                {
                        vis[ss.f - k[ss.f]] = 1;
                        q.push(Node{ss.f - k[ss.f], ss.step + 1});
                }
        }
        return -1;
}
int main()
{
        while(cin>>N && N != 0)
        {
                cin>>A>>B;
                for(int i = 1; i <= N; i++)
                        cin>>k[i];
                memset(vis, 0, sizeof(vis));
                cout<<bfs()<<endl;
        }
        return 0;
}