[Swift]LeetCode1202. 交换字符串中的元素 | Smallest String With Swaps

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（let_us_code）
➤博主域名：https://www.zengqiang.org
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11565807.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

You are given a string s, and an array of pairs of indices in the string pairs where pairs[i] = [a, b] indicates 2 indices(0-indexed) of the string.

You can swap the characters at any pair of indices in the given pairs any number of times.

Return the lexicographically smallest string that s can be changed to after using the swaps.

Example 1:

Input: s = "dcab", pairs = [[0,3],[1,2]]
Output: "bacd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[1] and s[2], s = "bacd"

Example 2:

Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
Output: "abcd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[0] and s[2], s = "acbd"
Swap s[1] and s[2], s = "abcd"

Example 3:

Input: s = "cba", pairs = [[0,1],[1,2]]
Output: "abc"
Explaination: 
Swap s[0] and s[1], s = "bca"
Swap s[1] and s[2], s = "bac"
Swap s[0] and s[1], s = "abc"

Constraints:

• 1 <= s.length <= 10^5
• 0 <= pairs.length <= 10^5
• 0 <= pairs[i][0], pairs[i][1] < s.length
• s only contains lower case English letters.

---

给你一个字符串 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"

提示：

• 1 <= s.length <= 10^5
• 0 <= pairs.length <= 10^5
• 0 <= pairs[i][0], pairs[i][1] < s.length
• s 中只含有小写英文字母

---

968ms

class Solution {
    func smallestStringWithSwaps(_ s: String, _ pairs: [[Int]]) -> String {
        let s = Array(s)
        var res = [Character](repeating: "a", count: s.count)
        var uf = UnionFind(s.count)
        for pair in pairs {
            uf.union(pair[0], pair[1])
        }
        var _comps = [Int: [Character]]()
        for (i, char) in s.enumerated() {
            let parent = uf.find(i)
            _comps[parent, default: []].append(char)
        }
        var comps = [Int: Queue]()
        for (k, v) in _comps {
            let newV = v.sorted()
            comps[k] = Queue(newV)
        }
        for i in 0..<s.count {
            let parent = uf.find(i)
            let comp = comps[parent]!
            res[i] = comp.remove()
        }
        return String(res)
    }
}

class Queue {
    let arr: [Character]
    var index = 0
    
    init(_ arr: [Character]) {
        self.arr = arr
    }
    
    func remove() -> Character {
        let res = arr[index]
        index += 1
        return res
    }
}

struct UnionFind {
    var arr: [Int]
    var size: [Int]
    
    init(_ n: Int) {
        arr = [Int](repeating: 0, count: n)
        for i in 0..<n {
            arr[i] = i
        }
        size = [Int](repeating: 1, count: n)
    }
    
    mutating func union(_ a: Int, _ b: Int) -> Bool {
        let rootA = find(a)
        let rootB = find(b)
        if rootA == rootB { return false }
        if size[rootA] > size[rootB] {
            arr[rootB] = rootA
            size[rootA] += size[rootB]
        } else {
            arr[rootA] = rootB
            size[rootB] += size[rootA]
        }
        return true
    }
    
    mutating func find(_ a: Int) -> Int {
        var a = a
        while arr[a] != a {
            arr[a] = arr[arr[a]]
            a = arr[a]
        }
        return a
    }
}

---

1184ms

class Solution {
    var roots = [Int]()
    var ranks = [Int]()
    func smallestStringWithSwaps(_ s: String, _ pairs: [[Int]]) -> String {
        var chars = Array(s)
        (0...chars.count-1).forEach{ roots.append($0) }
        ranks = Array(repeating: 1, count: s.count)
        
        for pair in pairs {
            union(pair[0], pair[1])
        }
        
        var dict1 = [Int: [Int]]()
        var dict2 = [Int: [Character]]()
        
        
        for i in roots.indices {
            find(i)
        }
        
        
        for i in roots.indices {
            dict1[roots[i], default: [Int]()].append(i)
            dict2[roots[i], default: [Character]()].append(chars[i])
        }
        for (key, indices) in dict1 {
            if indices.count > 1 {
                let arr = dict2[key]!.sorted()
                var curr = 0 
                for idx in indices {
                    chars[idx] = arr[curr]
                    curr += 1
                }
            }
        }
        
        return String(chars)
    }
    
    fileprivate func union(_ x: Int, _ y: Int) -> Bool {
        let xRoot = find(x)
        let yRoot = find(y)
        
        if xRoot == yRoot {
            return false
        }
        if ranks[xRoot] > ranks[yRoot] {
            roots[yRoot] = xRoot
        } else if ranks[xRoot] < ranks[yRoot] {
            roots[xRoot] = yRoot
        } else {
            ranks[xRoot] += 1
            roots[yRoot] = xRoot
        }
        
        return true
    }
    
    fileprivate func find(_ current: Int) -> Int {
        var path = [Int]()
        var current = current
        while roots[current] != current {
            path.append(current)
            current = roots[current]
        }
        
        for p in path {
            roots[p] = current
            ranks[p] == 1
        }
        ranks[current] = 2
        return current
    }
}

---

1408ms

 class Solution {
    func smallestStringWithSwaps(_ s: String, _ pairs: [[Int]]) -> String {
               var indices = [Int]()                                                //Stored indices of same group
        var visited = [Bool](repeating: false, count: s.count)
        var adjList = [[Int]](repeating: [Int](), count: s.count)
        var indiceString = ""                                                 //Stores  string formed by indices in the same group
        func dfs(_ chars: [Character], _ n: Int) {                            //DFS to get all indices in same group
            visited[n] = true
            indices.append(n)
            indiceString += "(chars[n])"
            for i in adjList[n] where !visited[i] {
                dfs(chars, i)
            }
        }

        for pair in pairs {
            adjList[pair[0]].append(pair[1])
            adjList[pair[1]].append(pair[0])
        }

        var chars = Array(s)
        for i in chars.indices {
            indiceString = "" //Clear string formed by one group of indices before finding next group
            indices.removeAll() //clear indices vector before finding another group
            dfs(chars, i)
            let indiceStringChars = indiceString.sorted() //Sort the string in same group
            //Sort the indices in the same group
            indices = indices.sorted()

            for i in indices.indices { //Replace all the indices in the same group with the sorted character replacement
                chars[indices[i]] = indiceStringChars[i]
            }
        }
        return String(chars)
    }
}

---

Runtime: 4484 ms

Memory Usage: 36.6 MB

class Solution {
    func smallestStringWithSwaps(_ s: String, _ pairs: [[Int]]) -> String {
        var s:[Character] = Array(s)
        let n:Int = s.count
        let unionFind = UnionFind(size: n, count: n)
        for p in pairs
        {
            unionFind.union(p[0], p[1])
        }
        var components:[[Int]] = [[Int]](repeating:[Int](),count:n)
        for i in 0..<n
        {
            components[unionFind.find(i)].append(i)
        }
        for component in components
        {
            var chars:[Character] = [Character]()
            for index in component
            {
                chars.append(s[index])
            }
            chars.sort()
            for i in 0..<component.count
            {
                s[component[i]] = chars[i]
            }
        }
        return String(s)
    }
}

class UnionFind {
    private var parent: [Int]
    private (set) var count = 0
    
    init(size: Int, count: Int) {
        self.parent = Array(0..<size)
        self.count = count
    }

    func union(_ x: Int, _ y: Int) {
        let px = find(x)
        let py = find(y)
        if px != py {
            parent[px] = py
            count -= 1
        }
    }

    func find(_ x: Int) -> Int {
        if parent[x] == x {
            return x
        }
        parent[x] = find(parent[x])
        return parent[x]
    }
}