Leetcode 1202. 交换字符串中的元素 最小堆与并查集

给你一个字符串 s，以及该字符串中的一些「索引对」数组 pairs，其中 pairs[i] = [a, b] 表示字符串中的两个索引（编号从 0 开始）。

你可以 任意多次交换 在 pairs 中任意一对索引处的字符。

返回在经过若干次交换后，s 可以变成的按字典序最小的字符串。

示例 1:

输入：s = “dcab”, pairs = [[0,3],[1,2]]
输出：“bacd”
解释：
交换 s[0] 和 s[3], s = “bcad”
交换 s[1] 和 s[2], s = “bacd”
示例 2：

输入：s = “dcab”, pairs = [[0,3],[1,2],[0,2]]
输出：“abcd”
解释：
交换 s[0] 和 s[3], s = “bcad”
交换 s[0] 和 s[2], s = “acbd”
交换 s[1] 和 s[2], s = “abcd”
示例 3：

输入：s = “cba”, pairs = [[0,1],[1,2]]
输出：“abc”
解释：
交换 s[0] 和 s[1], s = “bca”
交换 s[1] 和 s[2], s = “bac”
交换 s[0] 和 s[1], s = “abc”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/smallest-string-with-swaps
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

官方题解中引入了按秩合并 本文中没有涉及。只用了路径压缩。 路径压缩和按秩合并同时使用在理论上会使得时间复杂度降低 如果数据量足够大的话

核心思路就是对连通量进行排序 采用自身带有排序性质的数据结构免去排序部分如平衡树，优先队列与堆都可以实现

class Solution:
    import heapq
    def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
        # 并查集 对连通量排序 
        # 需路径压缩 将x的所有长辈结点全部指向当前根
        def find(x):
            parent.setdefault(x, x)  # 初始化
            node = x 
            while node != parent[node]:
                node = parent[node]
            while x != node:  # x在的这棵树中 根被合并 
                originalOfx = parent[x]  # 原来x的根
                parent[x] = node  # 现在的node是根
                x = originalOfx
            return node 

        def union(i, j):
            parent[find(j)] = find(i)
        
        def Creat(pairs):
            for i, j in pairs:
                union(i, j)
        
        def sortOfpart(s):  # 将所有父亲相同的结点压进最小堆 省去排序
            partOfs = defaultdict(list)  # leetcode已经导入了collections
            for i in range(len(s)):
                heappush(partOfs[find(i)], s[i])
            return partOfs

        def main(s, pairs):
            Creat(pairs)
            partOfs = sortOfpart(s)
            n = len(s)
            ans = [0]*n 
            for i in range(n):
                ans[i] = heappop(partOfs[parent[i]])
            return "".join(ans)
        parent = {
     }
        return main(s, pairs)