1202 accepted. 124 ms, faster than 61.54%

Author: aQuaYi

Algorithms/1202.smallest-string-with-swaps/README.md

@@ -0,0 +1,46 @@
+# [1202. Smallest String With Swaps](https://leetcode.com/problems/smallest-string-with-swaps/)
+
+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:
+
+```text
+Input: s = "dcab", pairs = [[0,3],[1,2]]
+Output: "bacd"
+Explanation:
+Swap s[0] and s[3], s = "bcad"
+Swap s[1] and s[2], s = "bacd"
+```
+
+Example 2:
+
+```text
+Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
+Output: "abcd"
+Explanation:
+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:
+
+```text
+Input: s = "cba", pairs = [[0,1],[1,2]]
+Output: "abc"
+Explanation:
+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.`

Algorithms/1202.smallest-string-with-swaps/smallest-string-with-swaps.go

@@ -0,0 +1,61 @@
+package problem1202
+
+import "sort"
+
+func smallestStringWithSwaps(s string, pairs [][]int) string {
+	n := len(s)
+	un := newUnion(n)
+
+	for _, p := range pairs {
+		un.unite(p[0], p[1])
+	}
+
+	group := make(map[int][]int, n)
+	for c, p := range un.parent {
+		group[un.find(p)] = append(group[un.find(p)], c)
+	}
+
+	bytes := []byte(s)
+	res := make([]byte, n)
+	for _, children := range group {
+		size := len(children)
+		t := make([]int, size)
+		copy(t, children)
+		if size > 1 {
+			sort.Slice(t, func(i, j int) bool {
+				return bytes[t[i]] < bytes[t[j]]
+			})
+			sort.Ints(children)
+		}
+		for i := 0; i < size; i++ {
+			res[children[i]] = bytes[t[i]]
+		}
+	}
+
+	return string(res)
+}
+
+type union struct {
+	parent []int
+}
+
+func newUnion(size int) *union {
+	parent := make([]int, size)
+	for i := range parent {
+		parent[i] = i
+	}
+	return &union{
+		parent: parent,
+	}
+}
+
+func (u *union) unite(x, y int) {
+	u.parent[u.find(x)] = u.find(y)
+}
+
+func (u *union) find(i int) int {
+	if u.parent[i] != i {
+		u.parent[i] = u.find(u.parent[i])
+	}
+	return u.parent[i]
+}

Algorithms/1202.smallest-string-with-swaps/smallest-string-with-swaps_test.go

@@ -0,0 +1,51 @@
+package problem1202
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// tcs is testcase slice
+var tcs = []struct {
+	s     string
+	pairs [][]int
+	ans   string
+}{
+
+	// {
+	// 	"dcab",
+	// 	[][]int{{0, 3}, {1, 2}},
+	// 	"bacd",
+	// },
+
+	{
+		"dcab",
+		[][]int{{0, 3}, {1, 2}, {0, 2}},
+		"abcd",
+	},
+
+	{
+		"cba",
+		[][]int{{0, 1}, {1, 2}},
+		"abc",
+	},
+
+	// 可以有多个 testcase
+}
+
+func Test_smallestStringWithSwaps(t *testing.T) {
+	a := assert.New(t)
+
+	for _, tc := range tcs {
+		a.Equal(tc.ans, smallestStringWithSwaps(tc.s, tc.pairs), "输入:%v", tc)
+	}
+}
+
+func Benchmark_smallestStringWithSwaps(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, tc := range tcs {
+			smallestStringWithSwaps(tc.s, tc.pairs)
+		}
+	}
+}