算法竞赛题目中有一种常见的一维BFS模型。

这种模型的特点是，某一个状态的值可以有上一个状态的值+1来获得（也就是说一条通道的权重是1）。

比如例题：

农夫知道一头牛的位置，想要抓住它。

农夫和牛都位于数轴上，农夫起始位于点 N，牛位于点 K。

农夫有两种移动方式：

1. 从 X 移动到 X−1 或X+1，每次移动花费一分钟
2. 从 X移动到2∗X，每次移动花费一分钟

假设牛没有意识到农夫的行动，站在原地不动。

农夫最少要花多少时间才能抓住牛？

输入格式

共一行，包含两个整数N和K。

输出格式

输出一个整数，表示抓到牛所花费的最少时间。

数据范围

0≤N,K≤10^5

输入样例：

5 17

输出样例：

4

我们来分析一下这个题：每次都有3种不同的选择，我现在知道一个起点了，那我是不是可以由起点去依次推出来每个点需要的时间？这里用到了贪心的思想，我们可以想一下，一旦一个点被遍历了，那么这个点此时被更新的值一定是最小的。因为每次3种走法都是“处于同一级别上的（或者说同一层上的）”。

比如下面的图：

我们假设起点是4

第一次遍历（三种走法）：

第二次遍历：

第三次遍历：

这样就可以求解到每一个点距离起点的时间了。

代码：

#include<iostream>
#include<utility>
#include<algorithm>
#include<queue>
using namespace std;
const int N = 1e5+10;
int n,k;
int dist[N];
bool st[N];

int bfs(int start,int end){
    queue<int> q;
    dist[start]=0;
    q.push(start);
    st[start]=true;
    while(!q.empty()){
        int t = q.front();
        q.pop();
        if(t==end) return dist[end];
        //加一
        if(t+1<=N && !st[t+1]){//在范围内。并且没有访问过
            dist[t+1] = dist[t]+1;
            q.push(t+1);
            st[t+1] = true;
        }
        
        //减一
        if(t-1>=0 && !st[t-1]){
            dist[t-1] = dist[t]+1;
            q.push(t-1);
            st[t-1] = true;
        }
        
        //乘二
        if(2*t<=N && !st[2*t]){
            dist[2*t] = dist[t] +1;
            q.push(2*t);
            st[2*t] = true;
        }
    }
    
    return -1;
}

int main(){
    cin>>n>>k;
    int res = bfs(n,k);
    cout<<res;
    return 0;
}