Add solution 0810

halfrost · halfrost · commit 9dbefba7cd75 · 2021-05-22T22:40:52.000+08:00
diff --git a/README.md b/README.md
diff --git a/leetcode/0810.Chalkboard-XOR-Game/810. Chalkboard XOR Game.go b/leetcode/0810.Chalkboard-XOR-Game/810. Chalkboard XOR Game.go
@@ -0,0 +1,12 @@
+package leetcode
+
+func xorGame(nums []int) bool {
+	if len(nums)%2 == 0 {
+		return true
+	}
+	xor := 0
+	for _, num := range nums {
+		xor ^= num
+	}
+	return xor == 0
+}
diff --git a/leetcode/0810.Chalkboard-XOR-Game/810. Chalkboard XOR Game_test.go b/leetcode/0810.Chalkboard-XOR-Game/810. Chalkboard XOR Game_test.go
@@ -0,0 +1,42 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question810 struct {
+	para810
+	ans810
+}
+
+// para 是参数
+// one 代表第一个参数
+type para810 struct {
+	nums []int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans810 struct {
+	one bool
+}
+
+func Test_Problem810(t *testing.T) {
+
+	qs := []question810{
+
+		{
+			para810{[]int{1, 1, 2}},
+			ans810{false},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 810------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans810, q.para810
+		fmt.Printf("【input】:%v       【output】:%v\n", p, xorGame(p.nums))
+	}
+	fmt.Printf("\n\n\n")
+}
diff --git a/leetcode/0810.Chalkboard-XOR-Game/README.md b/leetcode/0810.Chalkboard-XOR-Game/README.md
@@ -0,0 +1,58 @@
+# [810. Chalkboard XOR Game](https://leetcode.com/problems/chalkboard-xor-game/)
+
+
+## 题目
+
+We are given non-negative integers nums[i] which are written on a chalkboard.  Alice and Bob take turns erasing exactly one number from the chalkboard, with Alice starting first.  If erasing a number causes the bitwise XOR of all the elements of the chalkboard to become 0, then that player loses.  (Also, we'll say the bitwise XOR of one element is that element itself, and the bitwise XOR of no elements is 0.)
+
+Also, if any player starts their turn with the bitwise XOR of all the elements of the chalkboard equal to 0, then that player wins.
+
+Return True if and only if Alice wins the game, assuming both players play optimally.
+
+```
+Example:Input: nums = [1, 1, 2]
+Output: false
+Explanation:
+Alice has two choices: erase 1 or erase 2.
+If she erases 1, the nums array becomes [1, 2]. The bitwise XOR of all the elements of the chalkboard is 1 XOR 2 = 3. Now Bob can remove any element he wants, because Alice will be the one to erase the last element and she will lose.
+If Alice erases 2 first, now nums becomes [1, 1]. The bitwise XOR of all the elements of the chalkboard is 1 XOR 1 = 0. Alice will lose.
+```
+
+**Notes:**
+
+- `1 <= N <= 1000`.
+- `0 <= nums[i] <= 2^16`.
+
+## 题目大意
+
+黑板上写着一个非负整数数组 nums[i] 。Alice 和 Bob 轮流从黑板上擦掉一个数字，Alice 先手。如果擦除一个数字后，剩余的所有数字按位异或运算得出的结果等于 0 的话，当前玩家游戏失败。 (另外，如果只剩一个数字，按位异或运算得到它本身；如果无数字剩余，按位异或运算结果为 0。）并且，轮到某个玩家时，如果当前黑板上所有数字按位异或运算结果等于 0，这个玩家获胜。假设两个玩家每步都使用最优解，当且仅当 Alice 获胜时返回 true。
+
+## 解题思路
+
+- Alice 必胜情况之一，Alice 先手，起始数组全部元素本身异或结果就为 0 。不需要擦除数字便自动获胜。除去这个情况，还有其他情况么？由于 2 人是交替擦除数字，且每次都恰好擦掉一个数字，因此对于这两人中的任意一人，其每次在擦除数字前，黑板上剩余数字的个数的奇偶性一定都是相同的。于是奇偶性成为突破口。
+- 如果 nums 的长度是偶数，Alice 先手是否必败呢？如果必败，代表无论擦掉哪一个数字，剩余所有数字的异或结果都等于 0。利用反证法证明上述结论是错误的。首先 $num[0] \oplus num[1] \oplus num[2] \oplus \cdots \oplus num[n-1] = X ≠ 0$，初始所有元素异或结果不为 0。假设 Alice 当前擦掉第 i 个元素，0 ≤ i < n。令 $X_{n}$ 代表擦掉第 n 位元素以后剩余元素异或的结果。由证题，无论擦掉哪一个数字，剩余所有数字的异或结果都等于 0。所以 $X_{0} \oplus X_{1} \oplus X_{2} \oplus \cdots  \oplus X_{n-1} = 0$。
+
+    $$\begin{aligned}0 &= X_{0} \oplus  X_{1} \oplus X_{2} \oplus \cdots  \oplus X_{n-1} \\0 &= (X \oplus nums[0]) \oplus (X \oplus nums[1]) \oplus (X \oplus nums[2]) \oplus \cdots  \oplus (X \oplus nums[n-1])\\ 0 &= (X \oplus X \oplus \cdots  \oplus X) \oplus (nums[0] \oplus nums[1] \oplus nums[2] \oplus \cdots  \oplus nums[n-1])\\0 &= 0 \oplus X\\\\\Rightarrow X &= 0\\\end{aligned}$$
+
+    由于 n 为偶数，所以 n 个 X 的异或结果为 0。最终推出 X = 0，很明显与前提 X ≠ 0 冲突。所以原命题，代表无论擦掉哪一个数字，剩余所有数字的异或结果都等于 0 是错误的。也就是说，当 n 为偶数时，代表无论擦掉哪一个数字，剩余所有数字的异或结果都不等于 0。即 Alice 有必胜策略。换句话说，当数组的长度是偶数时，先手 Alice 总能找到一个数字，在擦掉这个数字之后剩余的所有数字异或结果不等于 0。
+
+- 综上，Alice 必胜策略有 2 种情况：
+    1. 数组 nums 的全部元素初始本身异或结果就等于 0。
+    2. 数组 nums 的长度是偶数。
+
+## 代码
+
+```go
+package leetcode
+
+func xorGame(nums []int) bool {
+	if len(nums)%2 == 0 {
+		return true
+	}
+	xor := 0
+	for _, num := range nums {
+		xor ^= num
+	}
+	return xor == 0
+}
+```
diff --git a/website/content/ChapterFour/0800~0899/0803.Bricks-Falling-When-Hit.md b/website/content/ChapterFour/0800~0899/0803.Bricks-Falling-When-Hit.md
@@ -128,5 +128,5 @@ func getUnionFindFromGrid(grid [][]int, x, y int, uf template.UnionFindCount) {
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0802.Find-Eventual-Safe-States/">⬅️上一页</a></p>
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0811.Subdomain-Visit-Count/">下一页➡️</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0810.Chalkboard-XOR-Game/">下一页➡️</a></p>
 </div>
diff --git a/website/content/ChapterFour/0800~0899/0810.Chalkboard-XOR-Game.md b/website/content/ChapterFour/0800~0899/0810.Chalkboard-XOR-Game.md
@@ -0,0 +1,67 @@
+# [810. Chalkboard XOR Game](https://leetcode.com/problems/chalkboard-xor-game/)
+
+
+## 题目
+
+We are given non-negative integers nums[i] which are written on a chalkboard.  Alice and Bob take turns erasing exactly one number from the chalkboard, with Alice starting first.  If erasing a number causes the bitwise XOR of all the elements of the chalkboard to become 0, then that player loses.  (Also, we'll say the bitwise XOR of one element is that element itself, and the bitwise XOR of no elements is 0.)
+
+Also, if any player starts their turn with the bitwise XOR of all the elements of the chalkboard equal to 0, then that player wins.
+
+Return True if and only if Alice wins the game, assuming both players play optimally.
+
+```
+Example:Input: nums = [1, 1, 2]
+Output: false
+Explanation:
+Alice has two choices: erase 1 or erase 2.
+If she erases 1, the nums array becomes [1, 2]. The bitwise XOR of all the elements of the chalkboard is 1 XOR 2 = 3. Now Bob can remove any element he wants, because Alice will be the one to erase the last element and she will lose.
+If Alice erases 2 first, now nums becomes [1, 1]. The bitwise XOR of all the elements of the chalkboard is 1 XOR 1 = 0. Alice will lose.
+```
+
+**Notes:**
+
+- `1 <= N <= 1000`.
+- `0 <= nums[i] <= 2^16`.
+
+## 题目大意
+
+黑板上写着一个非负整数数组 nums[i] 。Alice 和 Bob 轮流从黑板上擦掉一个数字，Alice 先手。如果擦除一个数字后，剩余的所有数字按位异或运算得出的结果等于 0 的话，当前玩家游戏失败。 (另外，如果只剩一个数字，按位异或运算得到它本身；如果无数字剩余，按位异或运算结果为 0。）并且，轮到某个玩家时，如果当前黑板上所有数字按位异或运算结果等于 0，这个玩家获胜。假设两个玩家每步都使用最优解，当且仅当 Alice 获胜时返回 true。
+
+## 解题思路
+
+- Alice 必胜情况之一，Alice 先手，起始数组全部元素本身异或结果就为 0 。不需要擦除数字便自动获胜。除去这个情况，还有其他情况么？由于 2 人是交替擦除数字，且每次都恰好擦掉一个数字，因此对于这两人中的任意一人，其每次在擦除数字前，黑板上剩余数字的个数的奇偶性一定都是相同的。于是奇偶性成为突破口。
+- 如果 nums 的长度是偶数，Alice 先手是否必败呢？如果必败，代表无论擦掉哪一个数字，剩余所有数字的异或结果都等于 0。利用反证法证明上述结论是错误的。首先 {{< katex >}} num[0] \oplus num[1] \oplus num[2] \oplus \cdots  \oplus num[n-1] = X ≠ 0 {{< /katex >}} ，初始所有元素异或结果不为 0。假设 Alice 当前擦掉第 i 个元素，0 ≤ i < n。令 {{< katex >}}X_{n}{{< /katex >}} 代表擦掉第 n 位元素以后剩余元素异或的结果。由证题，无论擦掉哪一个数字，剩余所有数字的异或结果都等于 0。所以 {{< katex >}} X_{0} \oplus X_{1} \oplus X_{2} \oplus \cdots  \oplus X_{n-1} = 0{{< /katex >}} 。
+
+	{{< katex display >}} 
+    \begin{aligned}0 &= X_{0} \oplus  X_{1} \oplus X_{2} \oplus \cdots  \oplus X_{n-1} \\0 &= (X \oplus nums[0]) \oplus (X \oplus nums[1]) \oplus (X \oplus nums[2]) \oplus \cdots  \oplus (X \oplus nums[n-1])\\ 0 &= (X \oplus X \oplus \cdots  \oplus X) \oplus (nums[0] \oplus nums[1] \oplus nums[2] \oplus \cdots  \oplus nums[n-1])\\0 &= 0 \oplus X\\\\\Rightarrow X &= 0\\\end{aligned}
+	{{< /katex >}} 
+
+    由于 n 为偶数，所以 n 个 X 的异或结果为 0。最终推出 X = 0，很明显与前提 X ≠ 0 冲突。所以原命题，代表无论擦掉哪一个数字，剩余所有数字的异或结果都等于 0 是错误的。也就是说，当 n 为偶数时，代表无论擦掉哪一个数字，剩余所有数字的异或结果都不等于 0。即 Alice 有必胜策略。换句话说，当数组的长度是偶数时，先手 Alice 总能找到一个数字，在擦掉这个数字之后剩余的所有数字异或结果不等于 0。
+
+- 综上，Alice 必胜策略有 2 种情况：
+    1. 数组 nums 的全部元素初始本身异或结果就等于 0。
+    2. 数组 nums 的长度是偶数。
+
+## 代码
+
+```go
+package leetcode
+
+func xorGame(nums []int) bool {
+	if len(nums)%2 == 0 {
+		return true
+	}
+	xor := 0
+	for _, num := range nums {
+		xor ^= num
+	}
+	return xor == 0
+}
+```
+
+
+----------------------------------------------
+<div style="display: flex;justify-content: space-between;align-items: center;">
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0803.Bricks-Falling-When-Hit/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0811.Subdomain-Visit-Count/">下一页➡️</a></p>
+</div>
diff --git a/website/content/ChapterFour/0800~0899/0811.Subdomain-Visit-Count.md b/website/content/ChapterFour/0800~0899/0811.Subdomain-Visit-Count.md
@@ -145,6 +145,6 @@ func splitDomain(domain string, domains map[string]int) {
 
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0803.Bricks-Falling-When-Hit/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0810.Chalkboard-XOR-Game/">⬅️上一页</a></p>
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0800~0899/0812.Largest-Triangle-Area/">下一页➡️</a></p>
 </div>
diff --git a/website/content/ChapterTwo/Array.md b/website/content/ChapterTwo/Array.md
@@ -169,7 +169,7 @@ weight: 1
 |1636|Sort Array by Increasing Frequency|[Go]({{< relref "/ChapterFour/1600~1699/1636.Sort-Array-by-Increasing-Frequency.md" >}})|Easy||||67.1%|
 |1640|Check Array Formation Through Concatenation|[Go]({{< relref "/ChapterFour/1600~1699/1640.Check-Array-Formation-Through-Concatenation.md" >}})|Easy||||59.6%|
 |1646|Get Maximum in Generated Array|[Go]({{< relref "/ChapterFour/1600~1699/1646.Get-Maximum-in-Generated-Array.md" >}})|Easy||||53.0%|
-|1652|Defuse the Bomb|[Go]({{< relref "/ChapterFour/1600~1699/1652.Defuse-the-Bomb.md" >}})|Easy||||61.0%|
+|1652|Defuse the Bomb|[Go]({{< relref "/ChapterFour/1600~1699/1652.Defuse-the-Bomb.md" >}})|Easy||||60.9%|
 |1656|Design an Ordered Stream|[Go]({{< relref "/ChapterFour/1600~1699/1656.Design-an-Ordered-Stream.md" >}})|Easy||||82.2%|
 |1672|Richest Customer Wealth|[Go]({{< relref "/ChapterFour/1600~1699/1672.Richest-Customer-Wealth.md" >}})|Easy||||88.1%|
 |1700|Number of Students Unable to Eat Lunch|[Go]({{< relref "/ChapterFour/1700~1799/1700.Number-of-Students-Unable-to-Eat-Lunch.md" >}})|Easy||||67.6%|
diff --git a/website/content/ChapterTwo/Bit_Manipulation.md b/website/content/ChapterTwo/Bit_Manipulation.md
@@ -64,7 +64,7 @@ X & ~X = 0
 |0397|Integer Replacement|[Go]({{< relref "/ChapterFour/0300~0399/0397.Integer-Replacement.md" >}})|Medium| O(n)| O(1)||33.6%|
 |0401|Binary Watch|[Go]({{< relref "/ChapterFour/0400~0499/0401.Binary-Watch.md" >}})|Easy| O(1)| O(1)||48.8%|
 |0405|Convert a Number to Hexadecimal|[Go]({{< relref "/ChapterFour/0400~0499/0405.Convert-a-Number-to-Hexadecimal.md" >}})|Easy| O(n)| O(1)||44.7%|
-|0421|Maximum XOR of Two Numbers in an Array|[Go]({{< relref "/ChapterFour/0400~0499/0421.Maximum-XOR-of-Two-Numbers-in-an-Array.md" >}})|Medium| O(n)| O(1)|❤️|54.6%|
+|0421|Maximum XOR of Two Numbers in an Array|[Go]({{< relref "/ChapterFour/0400~0499/0421.Maximum-XOR-of-Two-Numbers-in-an-Array.md" >}})|Medium| O(n)| O(1)|❤️|54.5%|
 |0461|Hamming Distance|[Go]({{< relref "/ChapterFour/0400~0499/0461.Hamming-Distance.md" >}})|Easy| O(n)| O(1)||73.3%|
 |0476|Number Complement|[Go]({{< relref "/ChapterFour/0400~0499/0476.Number-Complement.md" >}})|Easy| O(n)| O(1)||65.2%|
 |0477|Total Hamming Distance|[Go]({{< relref "/ChapterFour/0400~0499/0477.Total-Hamming-Distance.md" >}})|Medium| O(n)| O(1)||50.8%|
diff --git a/website/content/ChapterTwo/Math.md b/website/content/ChapterTwo/Math.md
@@ -58,6 +58,7 @@ weight: 12
 |0753|Cracking the Safe|[Go]({{< relref "/ChapterFour/0700~0799/0753.Cracking-the-Safe.md" >}})|Hard||||52.8%|
 |0775|Global and Local Inversions|[Go]({{< relref "/ChapterFour/0700~0799/0775.Global-and-Local-Inversions.md" >}})|Medium||||46.2%|
 |0781|Rabbits in Forest|[Go]({{< relref "/ChapterFour/0700~0799/0781.Rabbits-in-Forest.md" >}})|Medium||||56.0%|
+|0810|Chalkboard XOR Game|[Go]({{< relref "/ChapterFour/0800~0899/0810.Chalkboard-XOR-Game.md" >}})|Hard||||50.7%|
 |0812|Largest Triangle Area|[Go]({{< relref "/ChapterFour/0800~0899/0812.Largest-Triangle-Area.md" >}})|Easy||||59.2%|
 |0836|Rectangle Overlap|[Go]({{< relref "/ChapterFour/0800~0899/0836.Rectangle-Overlap.md" >}})|Easy||||43.1%|
 |0869|Reordered Power of 2|[Go]({{< relref "/ChapterFour/0800~0899/0869.Reordered-Power-of-2.md" >}})|Medium||||61.2%|
@@ -82,7 +83,7 @@ weight: 12
 |1037|Valid Boomerang|[Go]({{< relref "/ChapterFour/1000~1099/1037.Valid-Boomerang.md" >}})|Easy||||37.5%|
 |1073|Adding Two Negabinary Numbers|[Go]({{< relref "/ChapterFour/1000~1099/1073.Adding-Two-Negabinary-Numbers.md" >}})|Medium||||34.8%|
 |1093|Statistics from a Large Sample|[Go]({{< relref "/ChapterFour/1000~1099/1093.Statistics-from-a-Large-Sample.md" >}})|Medium||||48.3%|
-|1154|Day of the Year|[Go]({{< relref "/ChapterFour/1100~1199/1154.Day-of-the-Year.md" >}})|Easy||||49.4%|
+|1154|Day of the Year|[Go]({{< relref "/ChapterFour/1100~1199/1154.Day-of-the-Year.md" >}})|Easy||||49.3%|
 |1175|Prime Arrangements|[Go]({{< relref "/ChapterFour/1100~1199/1175.Prime-Arrangements.md" >}})|Easy||||51.8%|
 |1201|Ugly Number III|[Go]({{< relref "/ChapterFour/1200~1299/1201.Ugly-Number-III.md" >}})|Medium||||26.5%|
 |1217|Minimum Cost to Move Chips to The Same Position|[Go]({{< relref "/ChapterFour/1200~1299/1217.Minimum-Cost-to-Move-Chips-to-The-Same-Position.md" >}})|Easy||||70.8%|
@@ -95,7 +96,7 @@ weight: 12
 |1641|Count Sorted Vowel Strings|[Go]({{< relref "/ChapterFour/1600~1699/1641.Count-Sorted-Vowel-Strings.md" >}})|Medium||||75.2%|
 |1648|Sell Diminishing-Valued Colored Balls|[Go]({{< relref "/ChapterFour/1600~1699/1648.Sell-Diminishing-Valued-Colored-Balls.md" >}})|Medium||||30.8%|
 |1680|Concatenation of Consecutive Binary Numbers|[Go]({{< relref "/ChapterFour/1600~1699/1680.Concatenation-of-Consecutive-Binary-Numbers.md" >}})|Medium||||52.3%|
-|1685|Sum of Absolute Differences in a Sorted Array|[Go]({{< relref "/ChapterFour/1600~1699/1685.Sum-of-Absolute-Differences-in-a-Sorted-Array.md" >}})|Medium||||63.3%|
+|1685|Sum of Absolute Differences in a Sorted Array|[Go]({{< relref "/ChapterFour/1600~1699/1685.Sum-of-Absolute-Differences-in-a-Sorted-Array.md" >}})|Medium||||63.4%|
 |1716|Calculate Money in Leetcode Bank|[Go]({{< relref "/ChapterFour/1700~1799/1716.Calculate-Money-in-Leetcode-Bank.md" >}})|Easy||||64.3%|
 |------------|-------------------------------------------------------|-------| ----------------| ---------------|-------------|-------------|-------------|
 
diff --git a/website/content/ChapterTwo/String.md b/website/content/ChapterTwo/String.md
@@ -31,7 +31,7 @@ weight: 2
 |0115|Distinct Subsequences|[Go]({{< relref "/ChapterFour/0100~0199/0115.Distinct-Subsequences.md" >}})|Hard||||40.2%|
 |0125|Valid Palindrome|[Go]({{< relref "/ChapterFour/0100~0199/0125.Valid-Palindrome.md" >}})|Easy| O(n)| O(1)||38.8%|
 |0126|Word Ladder II|[Go]({{< relref "/ChapterFour/0100~0199/0126.Word-Ladder-II.md" >}})|Hard| O(n)| O(n^2)|❤️|24.0%|
-|0151|Reverse Words in a String|[Go]({{< relref "/ChapterFour/0100~0199/0151.Reverse-Words-in-a-String.md" >}})|Medium||||24.5%|
+|0151|Reverse Words in a String|[Go]({{< relref "/ChapterFour/0100~0199/0151.Reverse-Words-in-a-String.md" >}})|Medium||||24.6%|
 |0227|Basic Calculator II|[Go]({{< relref "/ChapterFour/0200~0299/0227.Basic-Calculator-II.md" >}})|Medium||||39.0%|
 |0344|Reverse String|[Go]({{< relref "/ChapterFour/0300~0399/0344.Reverse-String.md" >}})|Easy| O(n)| O(1)||71.0%|
 |0345|Reverse Vowels of a String|[Go]({{< relref "/ChapterFour/0300~0399/0345.Reverse-Vowels-of-a-String.md" >}})|Easy| O(n)| O(1)||45.4%|
diff --git a/website/content/ChapterTwo/Union_Find.md b/website/content/ChapterTwo/Union_Find.md
@@ -36,7 +36,7 @@ weight: 16
 |0947|Most Stones Removed with Same Row or Column|[Go]({{< relref "/ChapterFour/0900~0999/0947.Most-Stones-Removed-with-Same-Row-or-Column.md" >}})|Medium| O(n)| O(n)||55.8%|
 |0952|Largest Component Size by Common Factor|[Go]({{< relref "/ChapterFour/0900~0999/0952.Largest-Component-Size-by-Common-Factor.md" >}})|Hard| O(n)| O(n)|❤️|36.5%|
 |0959|Regions Cut By Slashes|[Go]({{< relref "/ChapterFour/0900~0999/0959.Regions-Cut-By-Slashes.md" >}})|Medium| O(n^2)| O(n^2)|❤️|67.4%|
-|0990|Satisfiability of Equality Equations|[Go]({{< relref "/ChapterFour/0900~0999/0990.Satisfiability-of-Equality-Equations.md" >}})|Medium| O(n)| O(n)||47.1%|
+|0990|Satisfiability of Equality Equations|[Go]({{< relref "/ChapterFour/0900~0999/0990.Satisfiability-of-Equality-Equations.md" >}})|Medium| O(n)| O(n)||47.2%|
 |1202|Smallest String With Swaps|[Go]({{< relref "/ChapterFour/1200~1299/1202.Smallest-String-With-Swaps.md" >}})|Medium||||49.3%|
 |1319|Number of Operations to Make Network Connected|[Go]({{< relref "/ChapterFour/1300~1399/1319.Number-of-Operations-to-Make-Network-Connected.md" >}})|Medium||||55.5%|
 |1579|Remove Max Number of Edges to Keep Graph Fully Traversable|[Go]({{< relref "/ChapterFour/1500~1599/1579.Remove-Max-Number-of-Edges-to-Keep-Graph-Fully-Traversable.md" >}})|Hard||||46.5%|
