【数据结构与算法】广度优先搜索1

　　广度优先搜索算法：先查找离起始顶点最近的，然后是第二进的，这样依次往外搜索。树的层次遍历就是一个广度搜索算法。

　　一般需要用到队列这个数据结构，但是如果你是C语言开发，并且是在考试中，时间有限。一般临时写一个队列出来还是很耗时间的，所以一般用一个大数组来模拟队列。

根据百度百科：广度优先搜索算法在求解最短路径或者最短步数上有很多的应用。应用最多的是在走迷宫上。

今天做了两道力扣题目，总结一下BFS的套路：

第一题： 542. 01 矩阵

C代码实现：

/* 广度优先: 用大数组实现队列 */
#define MAX_SIZE 10000
int numSquares(int n)
{
    int queue[MAX_SIZE] = {0};
    int front = 0; // 队首
    int rear = 0; // 队尾
    int size = 0; // 当前队列中元素的个数
    int visit[MAX_SIZE] = {0}; // visit[i]表示元素i是否已经访问过

    // 初始化队列
    queue[0] = n;
    rear++;
    visit[n] = 1;
    int result = 0;
    while (front < rear) { // 循环终止的条件是队列为空
        size = rear - front;
        result++; // 每循环一轮，说明遍历了一层，离答案就近了一层
        for (int i = 0; i < size; i++) {
            int topElem = queue[front]; // 队首元素出队列
            front++;
            for (int j = 1; j * j <= topElem; j++) {
                int nextElem = topElem - j * j;
                if (nextElem == 0) {
                    return result;
                }
                // 入队列
                if (visit[nextElem] != 1) {
                    visit[nextElem] = 1;
                    queue[rear++] = nextElem;
                }
            }
        }
    }
    return result;
}

第二题：490. 迷宫

C代码实现：

typedef struct tagPos {
    int rowIndex;
    int colIndex;
} Pos;

bool hasPath(int** maze, int mazeSize, int* mazeColSize, int* start, int startSize, int* destination, int destinationSize){
    int rowSize = mazeSize;
    int colSize = mazeColSize[0];
    int visit[rowSize][colSize];
    for (int i = 0; i < rowSize; i++) {
        for (int j = 0; j < colSize; j++) {
            visit[i][j] = 0;
        }
    }
    int max_size = rowSize * colSize;
    Pos queue[max_size];
    int front = 0;
    int rear = 0;
   // int size;
    queue[0].rowIndex = start[0];
    queue[0].colIndex = start[1];
    rear++;
    visit[start[0]][start[1]] = 1;
    int direct[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    while (front < rear) {
        Pos curr = queue[front];
        front++;
        if (curr.rowIndex == destination[0] && curr.colIndex == destination[1]) {
            return true;
        }
        for (int i = 0; i < 4; i++) {
            int x = curr.rowIndex + direct[i][0];
            int y = curr.colIndex + direct[i][1];
            while (x >= 0 && x < rowSize && y >= 0 && y < colSize && maze[x][y] == 0) {
                printf("go on, x:%d, y%d  ", x, y);
                x += direct[i][0];
                y += direct[i][1];
            }
            /* 走到这里x, y如果是有效的。那么maze[x][y]一定为 1
             * 所以需要按照原来的方向退一格。所以是:
             * x -= direct[i][0] y -= direct[i][1];
             * 然后再判断移位之后x,y 的情况
             */
            x -= direct[i][0];
            y -= direct[i][1];
            if (x >= 0 && x < rowSize && y >= 0 && y < colSize && visit[x][y] != 1) {
                queue[rear].rowIndex = x;
                queue[rear].colIndex = y;
                printf("keep: x:%d, y:%d
", x, y);
                rear++;
                visit[x][y] = 1;
            }
        }
    }
    return false;
}

总结：

经过上面两道题，看到别人总结了BFS的套路，现摘抄如下：

BFS 使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS 总共有两个模板：

1、如果不需要确定当前遍历到了哪一层，BFS 模板如下。

while queue 不空：
    cur = queue.pop()
    for 节点 in cur的所有相邻节点：
        if 该节点有效且未访问过：
            queue.push(该节点)

2、

如果要确定当前遍历到了哪一层，BFS 模板如下。
这里增加了 level 表示当前遍历到二叉树中的哪一层了，也可以理解为在一个图中，现在已经走了多少步了。size 表示在当前遍历层有多少个元素，也就是队列中的元素数，我们把这些元素一次性遍历完，即把当前层的所有元素都向外走了一步。

level = 0
while queue 不空：
    size = queue.size()
    while (size --) {
        cur = queue.pop()
        for 节点 in cur的所有相邻节点：
            if 该节点有效且未被访问过：
                queue.push(该节点)
    }
    level ++;

参考资料：

(1) : https://leetcode-cn.com/problems/01-matrix/solution/tao-lu-da-jie-mi-gao-dong-ti-mu-kao-cha-shi-yao-2/