bfs

BFS就是廣度或者說是寬度優先搜索，用於圖的搜索，每次都是從一個節點開始，向四周都搜索一邊，放進隊列裡面，然後每次從隊列頭開始拿，再重複這個搜索的過程；

因為這樣，他的特別之處在於　“广搜的特性，返回的第一个一定是最短的路径”　！！！

不同於深搜dfs，which is每次都是一個方向一路搜到底，而不是每次向四周都搜索一邊...

來一題：

poj.3278 Catch That Cow

這題找一種需要步數最少的方法，從起始位置a走到目標位置b，走的方式有三種：-1,+1,*2；So，找最短路，用bfs；三種方式，就是每次走三個方向了；

但是有可能會耗時很多導致TLE，所以要加個vis數組剪枝，把訪問過的標誌一下，防止走重複了...

那麼很自然地要注意，-1的情況不能導致vis數組下標為負，並且*2的時候防止數組越界，這兩個問題可以把你RE死...

// poj.3278 Catch That Cow
// bfs
// references:
// http://blog.csdn.net/lyy289065406/article/details/6647886
// http://blog.csdn.net/zhengnanlee/article/details/12952097
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 400015;    //注意因为要乘以2，所以弄大点 

struct node {
    int pos;
    int count;
    node():pos(-1), count(0){}
    node(int a, int b):pos(a), count(b){}
};

bool vis[N];

int main()
{
    int a, b;
    while(scanf("%d%d", &a, &b) != EOF)    //广搜的特性，返回的第一个一定是最短的路径
    {
        memset(vis, 0, sizeof(vis));
        int ans = 0x3f3f3f3f;
        queue <node> q;
        node s(a, 0);
        vis[a] = 1;
        q.push(s);
        while(!q.empty())
        {
            node temp = q.front();
            q.pop();
            if(temp.pos == b)
            {
                printf("%d
", temp.count);
                break;
            }
            if(!vis[temp.pos + 1] && temp.pos <= b)    //不剪枝的同学试试输入n=0  k=100000。。。。。。铁定RE
            {
                vis[temp.pos + 1] = 1;
                node next1(temp.pos + 1, temp.count + 1);
                q.push(next1);
            }
            if(!vis[temp.pos - 1] && temp.pos > 0)
            {
                vis[temp.pos - 1] = 1;
                node next2(temp.pos - 1, temp.count + 1);
                q.push(next2);
            }
            if(!vis[temp.pos * 2] && temp.pos <= b)
            {
                vis[temp.pos * 2] = 1;
                node next3(temp.pos * 2, temp.count + 1);
                q.push(next3);
            }    
        }
    }
    return 0;
}