最短路模型

为什么能用bfs求解？

bfs适用于求解权值为定值的最短路问题。

bfs是先把一个点加入队列，然后将它能够直接到达的点再加入到队列。整个队列中的元素距离起点的举例是非严格单调递增的。所以我们第一次拓展到该点的时候，起点到这个点的距离就是最小距离。

能用dfs求解这个问题吗？

可以，但是需要注意的是，dfs执行放入时候是一条路走到黑，也就是说你并不知道单前点到起点的距离是不是最优的，需要dfs完整张图才能够的到最优解。

题目1： 迷宫问题

分析：

这道题求的是左上角到右下角的最短路，没有规定每条边的权值，我们可以默认转移的代价为1。
因为题目求的是从(0, 0) 走到(n - 1, n - 1),我们这里采取的做法是记录当前点是由哪个点拓展过来。
所以我们可以从(n - 1, n - 1)开始， 记录每个点的前缀信息。最后从(0, 0)开始输出每个点的前缀信息即可。

时间复杂度：

代码区：

#include<iostream>
#include<cstring>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

const int N = 1010;

int n;
int g[N][N];
PII q[N * N];// bfs的队列
PII pre[N][N];//即可以充当记录每个点是由哪个点拓展过来的，还可进行判断该点是否已经被加入到队列中。

//偏移量
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

void bfs(int sx, int sy)
{
    int hh = 0, tt = 0;
    q[0] = {sx, sy};
    memset(pre, -1, sizeof pre);
    pre[sx][sy] = {-2, -2};
    
    
    while(hh <= tt)
    {
        auto t = q[hh ++];
        for(int i = 0; i < 4; i ++)
        {
            int a = t.x + dx[i], b = t.y + dy[i];
            if(a < 0 || a >= n || b < 0 || b >= n) continue;
            if(pre[a][b].x != -1 || g[a][b]) continue;
            
            q[++ tt] = {a, b};
            pre[a][b] = t;
        }
    }    
}

int main()
{
    cin >> n;
    
    for(int i = 0; i < n; i ++)
    {
        for(int j = 0; j < n; j ++)
        {
            cin >> g[i][j];
        }
    }
    
    bfs(n - 1, n - 1);
    
    PII end(0, 0);
    while(true)
    {
        cout << end.x << " " << end.y << endl;
        if(end.x == n - 1 && end.y == n - 1) break;
        end = pre[end.x][end.y];
    }
    
    return  0;
}

题目2： 武士风度的牛

分析：

用dist数组维护该点是第几次被扩展， dist[a][b] = dist[t.x][t.y] + 1

时间复杂度：

#include<iostream>
#include<cstring>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

const int N = 160;

int n, m;
char g[N][N];
int dist[N][N];
PII q[N * N];
int cnt;

int dx[] = {-1, -2, -2, -1, 1, 2, 2, 1};
int dy[] = {-2, -1, 1, 2, -2, -1, 1, 2};

int bfs(int sx, int sy)
{
    int hh = 0, tt = 0;
    q[0] = {sx, sy};
    memset(dist, -1, sizeof dist);
    dist[sx][sy] = 0;
    
    while(hh <= tt)
    {
        auto t = q[hh ++];
        
        for(int i = 0; i < 8; i ++)
        {
            int a = t.x + dx[i], b = t.y + dy[i];
            if(a < 0 || a >= n || b < 0 || b >= m) continue;
            if(g[a][b] == '*' || dist[a][b] != -1) continue;
            
            q[++ tt] = {a, b};
            dist[a][b] = dist[t.x][t.y] + 1;
            if(g[a][b] == 'H') return dist[a][b];
        }
        
    }
}

int main()
{
    cin >> m >> n;
    
    int sx, sy;
    for(int i = 0; i < n; i ++)
    {
        for(int j = 0; j < m; j ++)
        {
            cin >> g[i][j];
            if(g[i][j] == 'K')
            {
                sx = i;
                sy = j;
            }
        }
    }
    
    cout << bfs(sx, sy) << endl;
    
    return 0;
}

---

题目3： 抓住那头牛

分析：

因为每种方式的转移的代价都是一样的，所以我们第一次拓展出来的一定是最小值。因为权值都一样，且求的是最短路。所以我们直接用bfs求解进行，第一次搜索到的就是答案。这道题注意下区间的判断即可。确保每种状态转移之后任然会有意义，即数组的下标不能越界。

时间复杂度：

代码区：

#include<iostream>
#include<cstring>

using namespace std;

const int N = 1e5 + 10;

int q[N];
int dist[N];
int n, k;

int bfs()
{
    int hh = 0, tt = 0;
    q[0] = n;

    while(hh <= tt)
    {
        int t = q[hh ++];
        if(t == k) return dist[t];

        if(t + 1 < N && !dist[t + 1])
        {
            q[++ tt] = t + 1;
            dist[t + 1] = dist[t] + 1;
        }

        if(t - 1 >= 0 && !dist[t - 1])
        {
            q[++ tt] = t - 1;
            dist[t - 1] = dist[t] + 1;
        }

        if(t * 2 < N && !dist[t * 2])
        {
            q[++ tt] = t * 2;
            dist[t * 2] = dist[t] + 1;
        }

    }

    return -1;
}

int main()
{
    cin >> n >> k;

    cout << bfs() << endl;

    return 0;
}