leetcode——广度优先算法(BFS)总结 & 模板

什么是广度优先算法？

广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。但是BFS访问节点代价为1，即为对无权图求解最短路径。

BFS特性

广度优先算法需要满足以下几个条件：

• 一层一层地进行遍历
• 遍历一个距离能访问到的所有节点
• 遍历过的节点不能再次被遍历

所以针对以上条件，我们需要有如下对策：

• 设计队列，对每层元素依次搜索
• 通过分析问题发现节点的搜索规律
• 对已搜索到的数据标记

BFS求解模板

综上，我们可以得到一个求解BFS问题的模板：

1. 定义 数据标记集合 mark_list
2. 定义 搜索规则 search_func
3. 定义 待搜索队列 queue ，并将搜索起点载入
4. 定义 当前级数 level
5. 遍历 queue：

• 得到当前 level 的待搜索的全部数据，并对其挨个搜索：
  • 得到队首 待搜索元素 head_data
    • 通过搜索规则得到下一个元素 next_data
    1. 判断 next_data 是否为终点数据 若是：返回 level
    2. 判断 next_data 是否在范围内 若否：跳出当前循环（continue/pass）
    3. 判断 next_data 是否在mark_list 若否：添加 next_data 至mark_list和 queue （还有一种情况是mark_list 采用已知条件，即初始为满，若 next_data 在mark_list ，则将其删去）

6. 结束遍历 返回 未完成查找标志（0/-1）

举例：

leetcode——279. 完全平方数：
给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

1. 确定搜索规律：搜索小于n的完全平方数（1，4，16……）
2. 确定终点条件：待搜索的数据正好等于某个完全平方数
3. 确定边界和跳出规则：待搜索的数据小于某个完全平方数，因为这里的搜索规则是从小到大，所以若一个完全平方数数大于这个数，那么后面的都会大于，所以采用break提高效率

注：由于每个正整数都由可以由最小完全平方数1组成，所以这里不用设置未完成返回
代码如下：

class Solution:
    def numSquares(self, n: int) -> int:
        if n == 1:
            return 1
        def sqr(n):
            i =1 
            sqr_i = i**2
            while i**2 <= n:
                yield i**2
                i+=1
        squre_list = list(sqr(n))

        mark_list =set()
        queue = []
        queue.append(n)
        level = 0
        while queue!= 0:
            level+=1
            size = len(queue)
            while size != 0:
                num = queue.pop(0)
                for i in squre_list:
                    next_num = num -i
                    if next_num == 0:
                        return level
                    if next_num  < 0:
                        break
                    if next_num  not in mark_list:
                        mark_list.add(next_num )
                        queue.append(next_num )
                size -= 1

leetcode——127. 最短单词路径：
给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

1. 每次转换只能改变一个字母。
2. 转换过程中的中间单词必须是字典中的单词。

1. 确定搜索规律：对每个单词的每个字母搜索小写的字母
2. 确定终点条件：待搜索的数据等于endWord
3. 确定边界和跳出规则：待搜索的数据不在给定字典

这里直接采用 字典 当作 mark_list , 所以采用删除 字典 中出现的字段即可

class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        if not endWord in wordList:
            return 0
        len_word = len(beginWord)
        char_list = 'qwertyuiopasdfghjklzxcvbnm'
        wordList = set(wordList)
        
        queue = []
        queue.append(beginWord)
        level = 0
        
        while len(queue)!=0:
            size = len(queue)
            level += 1
            while size !=0:
                word = queue.pop(0)
                for i in range(len_word):
                    word_change = word
                    for j in range(len(char_list)):
                        if word_change[i] == char_list[j]:
                            continue
                        word_change = word_change[:i] +char_list[j]+word_change[i+1:]

                        if word_change == endWord:
                            return level+1
                        if word_change not in wordList:
                            continue

                        wordList.remove(word_change)
                        queue.append(word_change)
                size-=1
        return 0