BFS

最新推荐文章于 2023-04-20 21:29:43 发布

短尾黑猫

最新推荐文章于 2023-04-20 21:29:43 发布

阅读量374

点赞数 1

分类专栏：搜索文章标签： bfs

本文链接：https://blog.youkuaiyun.com/qq_45371462/article/details/115250226

版权

本文详细介绍了广度优先搜索（BFS）及其在各种问题中的应用，包括拓扑排序、可达性统计、矩阵距离、最短路模型等。通过实例展示了BFS如何解决迷宫问题、电路维修、字串变换等问题，同时探讨了BFS的变形，如双端队列BFS和优先队列BFS。文章旨在帮助读者深入理解BFS及其在信息技术领域的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

广度优先搜索（BFS）

BFS介绍

树和图的广度优先遍历都需要使用一个队列来实现。
在过程中，我们不断从队头取出一个节点x，对于x面对的多条分支，把沿着每条分支到达的下一个尚未访问过的节点插入队尾。

BFS有两个重要性质：

在访问完所有的第 $i$ 层节点后，才会开始访问第 $i + 1$ 层节点。
任意时刻，队列中至多有两个层次的节点。若其中一部分节点属于第 $i$ 层，那么另一部分节点就属于第 $i + 1$ 层，并且所有第 $i$ 层节点排在第 $i + 1$ 层节点之前。也就是说，广度优先遍历队列中的元素关于层次满足“两段性”和“单调性”。

拓扑排序

参考代码如下：

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++, d[b]++;
}

void topsort()
{
	queue<int> q;
	for(int i = 1; i <= n; i++)
        if(!d[i]) q.push(i);
    while(q.size()) {
        int u = q.front(); q.pop();
        top_q[++cnt] = u;
        for(int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            if(--d[v] == 0) q.push(v);
        }
    }
}

例题

可达性统计（CH2001）

代码实现

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <bitset>

using namespace std;

const int N = 3e4 + 10;

int n, m;
int h[N], e[N], ne[N], d[N], idx;
int q[N];
int a[N], cnt;
bitset<N> f[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++, d[b] ++;
}

void topsort()
{
    int hh = 0, tt = -1;
    for(int i = 1; i <= n; i++)
        if(d[i] == 0) q[++tt] = i;
        
    while(hh <= tt)
    {
        int u = q[hh ++];
        a[cnt++] = u;
        for(int i = h[u]; ~i; i = ne[i])
            if(--d[e[i]] == 0) q[++ tt] = e[i];
    }
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while(m--)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }
    
    topsort();
    
    for(int i = cnt - 1; i >= 0; i--)
    {
        int u = a[i];
        f[u][u] = 1;
        for(int j = h[u]; ~j; j = ne[j])
            f[u] |= f[e[j]];
    }
    
    for(int i = 1; i <= n; i++)
        cout << f[i].count() << endl;
    
    return 0;
}

Bloxorz (POJ3322)

详情见蓝书。

代码实现

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

const int N = 510;

struct rec { int x, y, lie; };

int n, m;
char s[N][N];
int d[N][N][3];
rec st, ed;

const int next_x[3][4] = { {0, 0, -2, 1}, {0, 0, -1, 1}, {0, 0, -1, 2} };
const int next_y[3][4] = { {-2, 1, 0, 0}, {-1, 2, 0, 0}, {-1, 1, 0, 0} };
const int next_lie[3][4] = { {1, 1, 2, 2}, {0, 0, 1, 1}, {2, 2, 0, 0} };

inline bool valid(int x, int y)
{
    return x >= 0 && x < n && y >= 0 && y < m;
}

inline bool valid(rec t)
{
    int x = t.x, y = t.y, lie = t.lie;
    if(!valid(x, y)) return false;
    if(s[x][y] == '#') return false;
    if(lie == 0 && s[x][y] != '.') return false;
    if(lie == 1 && s[x][y + 1] == '#') return false;
    if(lie == 2 && s[x + 1][y] == '#') return false;
    return true;
}

void parse_st_ed()
{
    int dx[4] = {0, 0, -1, 1}, dy[4] = {-1, 1, 0, 0};
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            if(s[i][j] == 'O') {
                ed.x = i, ed.y = j, ed.lie = 0, s[i][j] = '.';
            }
            else if(s[i][j] == 'X') {
                for(int k = 0; k < 4; k++) {
                    int x = i + dx[k], y = j + dy[k];
                    if(valid(x, y) && s[x][y] == 'X') {
                        st.x = min(i, x), st.y = min(j, y);
                        st.lie = k < 2 ? 1 : 2;
                        s[i][j] = s[x][y] = '.';
                        break;
                    }
                }
                if(s[i][j] == 'X') st.x = i, st.y = j, st.lie = 0;
            }
}

int bfs()
{
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            for(int k = 0; k < 3; k++)
                d[i][j][k] = -1;
                
    queue<rec> q;
    q.push(st);
    d[st.x][st.y][st.lie] = 0;
    
    while(q.size()) {
        rec now = q.front(); q.pop();
        
        if(now.x == ed.x && now.y == ed.y && now.lie == ed.lie) return d[now.x][now.y][now.lie];
        
        for(int i = 0; i < 4; i++) {
            rec next = {now.x + next_x[now.lie][i], now.y + next_y[now.lie][i], next_lie[now.lie][i]};
            if(!valid(next)) continue;
            int x = next.x, y = next.y, lie = next.lie;
            if(d[x][y][lie] == -1) {
                d[x][y][lie] = d[now.x][now.y][now.lie] + 1;
                q.push(next);
            }
        }
    }
    
    return -1;
}

int main()
{
    while(scanf("%d %d", &n, &m) != EOF && n)
    {
        for(int i = 0; i < n; i++) scanf("%s", s[i]);
        parse_st_ed();
        int ans = bfs();
        if(ans == -1) puts("Impossible");
        else printf("%d\n", ans);
    }
    return 0;
}