LeetCode：854. K-Similar Strings - Python

最新推荐文章于 2021-08-04 09:27:29 发布

原创最新推荐文章于 2021-08-04 09:27:29 发布 · 2.4k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#BFS #算法题 #LeetCode #K-Similar Strings

Python 同时被 3 个专栏收录

197 篇文章

订阅专栏

算法

189 篇文章

订阅专栏

LeetCode

151 篇文章

订阅专栏

本文通过广度优先搜索(BFS)解决LeetCode上K相似字符串问题，介绍如何计算两个字母异位词A和B的最小相似度K。利用队列实现算法流程，详细解释了获取每个节点所有可能子节点的方法。

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

题目描述：

如果可以通过将 A 中的两个小写字母精确地交换位置 K 次得到与 B 相等的字符串，我们称字符串 A 和 B 的相似度为 K（K 为非负整数）。

给定两个字母异位词 A 和 B ，返回 A 和 B 的相似度 K 的最小值。

示例 1：

输入：A = "ab", B = "ba"
输出：1

示例 2：

输入：A = "abc", B = "bca"
输出：2

示例 3：

输入：A = "abac", B = "baca"
输出：2

示例 4：

输入：A = "aabc", B = "abca"
输出：2

提示：

1 <= A.length == B.length <= 20
A 和 B 只包含集合 {'a', 'b', 'c', 'd', 'e', 'f'} 中的小写字母。

题目连接：https://leetcode-cn.com/problems/k-similar-strings/description/。这是一个比较有意思的题目，也许是第一次见的缘故，甚是喜欢。参考了官方的解答，现在整理一下。

问题分析：（广度优先，BFS）

采用广度优先搜索的思想，用队列实现，首先字符串A入队queue，并记录字典 cnt（当前结点已经扩展了几次或者已经走了几步）。那么问题来了，如何获取当前节点的所有子节点那？ 取出队首节点S，与字符串B比较，获取第一个不相等的字符的位置 i，那么，现在用这个位置 i 上面的字符与其后面的字符进行一次交换，使其交换后的 i 位置字符与 B 字符串 i 位置上的字符相等，每交换一次，就获得一个子节点。

列如：当前节点S = 'abcaabb', B = 'abbaabc', 所以现在 i=2，把S串中的字符 c 换成字符 b 有两种方案，所以得出该节点的所有子节点为'abbaacb'、'abbaabc'。每次入队的时，并把交换的次数（前节点的次数加 1 ）记录到字典cnt中，直到结束。

Python3实现：

# @Time   :2018/6/22
# @Author :LiuYinxing
# 解题思路 BFS


class Solution:
    def kSimilarity(self, A, B):
        def getSwap(S):  # 用于获取一个节点下可以扩展的所有节点
            for i, c in enumerate(S):  # 找到第一个不相等的字符的-位置-
                if c != B[i]: break
            T = list(S)
            for j in range(i + 1, len(S)):  # 获取所有的可扩展的子节点
                if S[j] == B[i]:  # 找到就交换
                    T[i], T[j] = T[j], T[i]
                    yield ''.join(T)  # 返回一个节点
                    T[j], T[i] = T[i], T[j]  # 恢复当前环境，以便寻找下一个可扩展的节点

        queue, cnt = [A], {A: 0}  # 初始化队列，cnt用于记录当前结点已经走了多少步
        while queue:
            S = queue[0]  # 出队
            del queue[0]
            if S == B: return cnt[S]  # 结束
            for T in getSwap(S):  # 获取当前节点所有扩展子节点
                if T not in cnt:  # 如果没有出现过，则入队
                    cnt[T] = cnt[S] + 1
                    queue.append(T)


if __name__ == '__main__':
    A, B = 'aabc', 'abca'
    solu = Solution()
    print(solu.kSimilarity(A, B))

Python3官方实现：

import collections


class Solution(object):
    def kSimilarity(self, A, B):
        def neighbors(S):
            for i, c in enumerate(S):
                if c != B[i]:
                    break

            T = list(S)
            for j in range(i+1, len(S)):
                if S[j] == B[i]:
                    T[i], T[j] = T[j], T[i]
                    print("".join(T))
                    yield "".join(T)
                    T[j], T[i] = T[i], T[j]

        queue = collections.deque([A])
        seen = {A: 0}
        while queue:
            S = queue.popleft() 
            if S == B: return seen[S]
            for T in neighbors(S):
                if T not in seen:
                    seen[T] = seen[S] + 1
                    queue.append(T)

欢迎指正哦