Add LeetCode Weekly Contest 251

Author: EndlessCheng

leetcode/251/a/a.go

@@ -0,0 +1,18 @@
+package main
+
+// Go 模拟
+
+// github.com/EndlessCheng/codeforces-go
+func getLucky(s string, k int) (sum int) {
+	for _, b := range s {
+		b -= 'a' - 1
+		sum += int(b/10 + b%10)
+	}
+	for k--; k > 0 && sum > 9; k-- {
+		s := sum
+		for sum = 0; s > 0; s /= 10 {
+			sum += s % 10
+		}
+	}
+	return
+}

leetcode/251/a/a_test.go

@@ -0,0 +1,15 @@
+package main
+
+// Go 贪心
+
+// github.com/EndlessCheng/codeforces-go
+func maximumNumber(num string, change []int) string {
+	s := []byte(num)
+	i, n := 0, len(s)
+	for ; i < n && byte(change[s[i]&15]) <= s[i]&15; i++ {
+	}
+	for ; i < n && byte(change[s[i]&15]) >= s[i]&15; i++ {
+		s[i] = '0' + byte(change[s[i]&15])
+	}
+	return string(s)
+}

leetcode/251/b/b.go

@@ -0,0 +1,92 @@
+package main
+
+// O(m^3) 二分图最大带权匹配
+
+// github.com/EndlessCheng/codeforces-go
+const inf int = 1e9
+
+func KuhnMunkres(wt [][]int) (sum int) {
+	match := make([]int, len(wt)) // 右部点匹配了哪一个左部点
+	la := make([]int, len(wt))
+	for i, row := range wt {
+		la[i] = -inf
+		for _, v := range row {
+			if v > la[i] {
+				la[i] = v
+			}
+		}
+	}
+	lb := make([]int, len(wt))
+	slack := make([]int, len(wt))
+	for i := 1; i < len(wt); i++ {
+		vb := make([]bool, len(wt))
+		for j := 1; j < len(wt); j++ {
+			slack[j] = inf
+		}
+		last := make([]int, len(wt)) // 右部点在交错树中的上一个右部点，用于倒推得到交错路
+		y := 0
+		match[0] = i // 一开始假设有一条 i-0 的匹配
+		for {
+			vb[y] = true
+			x, nextY := match[y], 0
+			delta := inf
+			for j := 1; j < len(wt); j++ {
+				if !vb[j] {
+					if d := la[x] + lb[j] - wt[x][j]; d < slack[j] {
+						slack[j] = d
+						last[j] = y
+					}
+					if slack[j] < delta {
+						delta = slack[j]
+						nextY = j
+					}
+				}
+			}
+			// 当 delta=0 时，相当于沿着相等子图向下搜索一层
+			// 当 delta>0 时，相当于直接回到最小边（新加入相等子图的边）处开始搜索
+			if delta > 0 {
+				for j := 0; j < len(wt); j++ {
+					if vb[j] {
+						la[match[j]] -= delta
+						lb[j] += delta
+					} else {
+						slack[j] -= delta
+					}
+				}
+			}
+			y = nextY
+			if match[y] == 0 {
+				break
+			}
+		}
+		// 倒推更新增广路
+		for ; y > 0; y = last[y] {
+			match[y] = match[last[y]]
+		}
+	}
+	for w := 1; w < len(wt); w++ {
+		sum += wt[match[w]][w]
+	}
+	return
+}
+
+func maxCompatibilitySum(students [][]int, mentors [][]int) int {
+	m := len(students)
+	wt := make([][]int, m+1)
+	wt[0] = make([]int, m+1)
+	for i := range wt[0] {
+		wt[0][i] = -inf
+	}
+	for i, st := range students {
+		wt[i+1] = make([]int, m+1)
+		wt[i+1][0] = -inf
+		for j, mt := range mentors {
+			for k, v := range st {
+				if v == mt[k] {
+					wt[i+1][j+1]++
+				}
+			}
+		}
+	}
+	return KuhnMunkres(wt)
+}

leetcode/251/b/b_test.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"sort"
+	"strings"
+)
+
+/* 字典树+哈希表
+
+我们用一颗字典树去表示整个文件系统，然后 DFS 这颗字典树，并用括号表达式按字典序拼接所有子树。
+
+以示例 $4$ 为例，文件夹 $\texttt{a}$ 的子树的括号表达式为 $\texttt{(x(y))(z)}$。
+
+![](https://assets.leetcode.com/uploads/2021/07/19/lc-dupfolder4_.jpg)
+
+这一表达方式包含了子树的节点名称和父子关系，因此可用于判断两个文件夹是否为相同文件夹。
+
+代码实现时，可以用一个哈希表去存储括号表达式及其对应的文件夹节点列表。在 DFS 结束后，遍历哈希表，若一个括号表达式对应的节点个数大于 $1$，则将该括号表达式对应的所有节点标记为待删除。然后再次 DFS 这颗字典树，仅访问未被删除的节点，并将路径记录到答案中。
+
+*/
+
+// github.com/EndlessCheng/codeforces-go
+type folder struct {
+	son map[string]*folder
+	val string // 文件夹名称
+	del bool   // 删除标记
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+	root := &folder{}
+	for _, path := range paths {
+		// 将 path 加入字典树
+		f := root
+		for _, s := range path {
+			if f.son == nil {
+				f.son = map[string]*folder{}
+			}
+			if f.son[s] == nil {
+				f.son[s] = &folder{}
+			}
+			f = f.son[s]
+			f.val = s
+		}
+	}
+
+	folders := map[string][]*folder{} // 存储括号表达式及其对应的文件夹节点列表
+	var dfs func(*folder) string
+	dfs = func(f *folder) string {
+		if f.son == nil {
+			return "(" + f.val + ")"
+		}
+		expr := []string{}
+		for _, son := range f.son {
+			expr = append(expr, dfs(son))
+		}
+		sort.Strings(expr)
+		subTreeExpr := strings.Join(expr, "") // 按字典序拼接所有子树
+		folders[subTreeExpr] = append(folders[subTreeExpr], f)
+		return "(" + f.val + subTreeExpr + ")"
+	}
+	dfs(root)
+
+	for _, fs := range folders {
+		if len(fs) > 1 { // 将括号表达式对应的节点个数大于 1 的节点全部删除
+			for _, f := range fs {
+				f.del = true
+			}
+		}
+	}
+
+	// 再次 DFS 这颗字典树，仅访问未被删除的节点，并将路径记录到答案中
+	path := []string{}
+	var dfs2 func(*folder)
+	dfs2 = func(f *folder) {
+		if f.del {
+			return
+		}
+		path = append(path, f.val)
+		ans = append(ans, append([]string(nil), path...))
+		for _, son := range f.son {
+			dfs2(son)
+		}
+		path = path[:len(path)-1]
+	}
+	for _, son := range root.son {
+		dfs2(son)
+	}
+	return
+}