2021 力扣杯秋季个人赛（Rank 26）

Author: EndlessCheng

leetcode/season/2021fall/a/a.go

@@ -0,0 +1,28 @@
+package main
+
+/*
+用哈希表统计差异
+
+*/
+
+// github.com/EndlessCheng/codeforces-go
+func minimumSwitchingTimes(source, target [][]int) (ans int) {
+	cnt := map[int]int{}
+	for i, row := range source {
+		for j, v := range row {
+			cnt[v]++
+			cnt[target[i][j]]--
+		}
+	}
+	for _, c := range cnt {
+		ans += abs(c)
+	}
+	return ans / 2
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}

leetcode/season/2021fall/a/a_test.go

@@ -0,0 +1,51 @@
+package main
+
+import "sort"
+
+/*
+排序+贪心
+
+将 $\textit{cards}$ 从大到小排序，并累加前 $\textit{cnt}$ 个元素之和，记作 $\textit{sum}$，若 $\textit{sum}$ 是偶数则直接返回，若不是偶数，则我们需要从前 $\textit{cnt}$ 个元素中选一个元素 $x$，并从后面找一个最大的且奇偶性和 $x$ 不同的元素替换 x，这样就可以使 $\textit{sum}$ 为偶数。
+
+为了使 $\textit{sum}$ 尽可能大，我们需要使替换前后的变化尽可能地小，我们分两种情况讨论：
+
+- 替换 $\textit{card}[\textit{cnt}-1]$；
+- 替换前 $\textit{cnt}$ 个元素中，最小的且奇偶性和 $\textit{card}[\textit{cnt}-1]$ 不同的元素。
+
+*/
+
+// github.com/EndlessCheng/codeforces-go
+func maxmiumScore(cards []int, cnt int) (ans int) {
+	sort.Sort(sort.Reverse(sort.IntSlice(cards)))
+	sum := 0
+	for _, v := range cards[:cnt] {
+		sum += v
+	}
+	if sum&1 == 0 {
+		return sum
+	}
+	// 在 cards[cnt:] 中找一个最大的且奇偶性和 x 不同的元素，替换 x
+	replace := func(x int) {
+		for _, v := range cards[cnt:] {
+			if v&1 != x&1 {
+				ans = max(ans, sum-x+v)
+				break
+			}
+		}
+	}
+	replace(cards[cnt-1]) // 替换 cards[cnt-1]
+	for i := cnt - 2; i >= 0; i-- {
+		if cards[i]&1 != cards[cnt-1]&1 { // 找一个最小的且奇偶性不同于 cards[cnt-1] 的元素，将其替换掉
+			replace(cards[i])
+			break
+		}
+	}
+	return
+}
+
+func max(a, b int) int {
+	if b > a {
+		return b
+	}
+	return a
+}

leetcode/season/2021fall/b/b.go

@@ -0,0 +1,71 @@
+package main
+
+// 暴力枚举
+
+// 枚举每个空格，放上黑棋后，统计能翻转多少白棋，然后就是一些实现细节了，具体见代码注释
+
+// github.com/EndlessCheng/codeforces-go
+var dir8 = []struct{ x, y int }{{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}}
+
+func cntFlip(g [][]byte) (cnt int) {
+	n, m := len(g), len(g[0])
+	for { // 不断循环，直到无法翻转白棋
+		flip := false
+		for i, row := range g {
+			for j, ch := range row {
+				if ch != 'O' {
+					continue
+				}
+				// 对于每个白棋，检查行、列或对角线中是否存在两端均有黑棋，且中间没有空白
+			outer:
+				for k, d := range dir8[:4] {
+					// 检查一个方向
+					for x, y := i, j; ; x, y = x+d.x, y+d.y {
+						if x < 0 || x >= n || y < 0 || y >= m || g[x][y] == '.' {
+							continue outer
+						}
+						if g[x][y] == 'X' {
+							break
+						}
+					}
+					// 检查相反的另一方向
+					d = dir8[k+4]
+					for x, y := i, j; ; x, y = x+d.x, y+d.y {
+						if x < 0 || x >= n || y < 0 || y >= m || g[x][y] == '.' {
+							continue outer
+						}
+						if g[x][y] == 'X' {
+							break
+						}
+					}
+					// 将其翻转为黑棋
+					g[i][j] = 'X'
+					flip = true
+					cnt++
+					break
+				}
+			}
+		}
+		if !flip {
+			return
+		}
+	}
+}
+
+func flipChess(g []string) (ans int) {
+	g2 := make([][]byte, len(g))
+	for i, row := range g {
+		for j, ch := range row {
+			if ch == '.' {
+				for k, r := range g {
+					g2[k] = []byte(r)
+				}
+				g2[i][j] = 'X' // 放上黑棋
+				if cnt := cntFlip(g2); cnt > ans {
+					ans = cnt
+				}
+			}
+		}
+	}
+	return
+}

leetcode/season/2021fall/b/b_test.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"sort"
+)
+
+/* 二分+暴力枚举
+
+注意到半径很小，我们可以枚举每个玩具，并暴力枚举该玩具**周围**是否有可以套住该玩具的圈。
+
+具体来说，将 $\textit{circles}$ 排序后，将横坐标相同的圈分为一组。对每个玩具，可以套住该玩具的圈，在横坐标上，必然满足圈的最右端点不小于玩具的最右端点，且圈的最左端点不超过玩具的最左端点。对于纵坐标也是类似。这样我们可以二分要枚举的圈的初始位置，并向后遍历即可。
+
+*/
+
+// github.com/EndlessCheng/codeforces-go
+func circleGame(toys [][]int, circles [][]int, r0 int) (ans int) {
+	sort.Slice(circles, func(i, j int) bool { a, b := circles[i], circles[j]; return a[0] < b[0] || a[0] == b[0] && a[1] < b[1] })
+
+	// 将横坐标相同的圈分为一组
+	type pair struct{ x, y int }
+	a, y := [][]pair{}, -1
+	for _, p := range circles {
+		if len(a) == 0 || p[0] > a[len(a)-1][0].x {
+			a = append(a, []pair{{p[0], p[1]}})
+			y = -1
+		} else if p[1] > y { // 去重
+			a[len(a)-1] = append(a[len(a)-1], pair{p[0], p[1]})
+			y = p[1]
+		}
+	}
+
+outer:
+	for _, t := range toys {
+		x, y, r := t[0], t[1], t[2]
+		if r > r0 {
+			continue
+		}
+		i := sort.Search(len(a), func(i int) bool { return a[i][0].x+r0 >= x+r })
+		for ; i < len(a); i++ {
+			col := a[i]
+			if col[0].x-r0 > x-r {
+				break
+			}
+			j := sort.Search(len(col), func(j int) bool { return col[j].y+r0 >= y+r })
+			for ; j < len(col); j++ {
+				c := col[j]
+				if c.y-r0 > y-r {
+					break
+				}
+				if (x-c.x)*(x-c.x)+(y-c.y)*(y-c.y) <= (r0-r)*(r0-r) {
+					ans++
+					continue outer
+				}
+			}
+		}
+	}
+	return
+}