49, 380, 931, 1026, 1074, 1207, 1289, 1347, 1657, 1704, 2225.

Author: emfomy

README.md

@@ -41,7 +41,7 @@ LeetCode Problems' Solutions
 | 45 | [Jump Game II](//leetcode.com/problems/jump-game-ii/) | [Go](./problems/algorithms/0045.go) [Python](./problems/algorithms/0045.py) | Hard |
 | 46 | [Permutations](//leetcode.com/problems/permutations/) | [Python](./problems/algorithms/0046.py) | Medium |
 | 48 | [Rotate Image](//leetcode.com/problems/rotate-image/) | [Python](./problems/algorithms/0048.py) | Medium |
-| 49 | [Group Anagrams](//leetcode.com/problems/group-anagrams/) | [Python](./problems/algorithms/0049.py) | Medium |
+| 49 | [Group Anagrams](//leetcode.com/problems/group-anagrams/) | [Go](./problems/algorithms/0049.go) [Python](./problems/algorithms/0049.py) | Medium |
 | 51 | [N-Queens](//leetcode.com/problems/n-queens/) | [Go](./problems/algorithms/0051.go) | Hard |
 | 52 | [N-Queens II](//leetcode.com/problems/n-queens-ii/) | [Go](./problems/algorithms/0052.go) | Hard |
 | 53 | [Maximum Subarray](//leetcode.com/problems/maximum-subarray/) | [Go](./problems/algorithms/0053.go) [Python](./problems/algorithms/0053.py) | Easy |
@@ -120,6 +120,7 @@ LeetCode Problems' Solutions
 | 376 | [Wiggle Subsequence](//leetcode.com/problems/wiggle-subsequence/) | [Go](./problems/algorithms/0376.go) | Medium |
 | 377 | [Combination Sum IV](//leetcode.com/problems/combination-sum-iv/) | [Go](./problems/algorithms/0377.go) | Medium |
 | 378 | [Kth Smallest Element in a Sorted Matrix](//leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/) | [Go](./problems/algorithms/0378.go) | Medium |
+| 380 | [Insert Delete GetRandom O(1)](//leetcode.com/problems/insert-delete-getrandom-o1/) | [Go](./problems/algorithms/0380.go) | Medium |
 | 383 | [Ransom Note](//leetcode.com/problems/ransom-note/) | [Go](./problems/algorithms/0383.go) | Easy |
 | 387 | [Roman to Integer](//leetcode.com/problems/first-unique-character-in-a-string/) | [Go](./problems/algorithms/0387.go) | Easy |
 | 389 | [Find the Difference](//leetcode.com/problems/find-the-difference/) | [Go](./problems/algorithms/0389.go) | Easy |
@@ -163,20 +164,24 @@ LeetCode Problems' Solutions
 | 968 | [Binary Tree Cameras](//leetcode.com/problems/binary-tree-cameras/) | [Go](./problems/algorithms/0968.go) | Hard |
 | 976 | [Largest Perimeter Triangle](//leetcode.com/problems/largest-perimeter-triangle/) | [Go](./problems/algorithms/0976.go) | Easy |
 | 1014 | [Best Sightseeing Pair](//leetcode.com/problems/best-sightseeing-pair/) | [Go](./problems/algorithms/1014.go) | Medium |
+| 1026 | [Determine if String Halves Are Alike](//leetcode.com/problems/maximum-difference-between-node-and-ancestor/) | [Go](./problems/algorithms/1026.go) | Medium |
 | 1048 | [Longest String Chain](//leetcode.com/problems/longest-string-chain/) | [Go](./problems/algorithms/1048.go) | Medium |
 | 1074 | [Number of Submatrices That Sum to Target](//leetcode.com/problems/number-of-submatrices-that-sum-to-target/) | [Go](./problems/algorithms/1074.go) | Hard |
 | 1137 | [N-th Tribonacci Number](//leetcode.com/problems/n-th-tribonacci-number/) | [Go](./problems/algorithms/1137.go) | Easy |
 | 1143 | [Longest Common Subsequence](//leetcode.com/problems/longest-common-subsequence/) | [Go](./problems/algorithms/1143.go) | Medium |
+| 1207 | [Unique Number of Occurrences](//leetcode.com/problems/unique-number-of-occurrences) | [Go](./problems/algorithms/1207.go) | Easy |
 | 1220 | [Count Vowels Permutation](//leetcode.com/problems/count-vowels-permutation/) | [Go](./problems/algorithms/1220.go) | Hard |
 | 1232 | [Check If It Is a Straight Line](//leetcode.com/problems/check-if-it-is-a-straight-line/) | [Go](./problems/algorithms/1232.go) | Easy |
 | 1268 | [Search Suggestions System](//leetcode.com/problems/search-suggestions-system/) | [Go](./problems/algorithms/1268.go) | Medium |
 | 1281 | [Subtract the Product and Sum of Digits of an Integer](//leetcode.com/problems/subtract-the-product-and-sum-of-digits-of-an-integer/) | [Go](./problems/algorithms/1281.go) | Easy |
+| 1289 | [Minimum Falling Path Sum II](//leetcode.com/problems/minimum-falling-path-sum-ii) | [Go](./problems/algorithms/1289.go) | Hard |
 | 1290 | [Convert Binary Number in a Linked List to Integer](//leetcode.com/problems/convert-binary-number-in-a-linked-list-to-integer/) | [Go](./problems/algorithms/1290.go) | Easy |
 | 1309 | [Decrypt String from Alphabet to Integer Mapping](//leetcode.com/problems/decrypt-string-from-alphabet-to-integer-mapping/) | [Go](./problems/algorithms/1309.go) | Easy |
 | 1314 | [Matrix Block Sum](//leetcode.com/problems/matrix-block-sum/) | [Go](./problems/algorithms/1314.go) | Medium |
 | 1332 | [Remove Palindromic Subsequences](//leetcode.com/problems/remove-palindromic-subsequences/) | [Go](./problems/algorithms/1332.go) | Easy |
 | 1338 | [Reduce Array Size to The Half](//leetcode.com/problems/reduce-array-size-to-the-half/) | [Go](./problems/algorithms/1338.go) | Medium |
 | 1342 | [Number of Steps to Reduce a Number to Zero](//leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/) | [C++](./problems/algorithms/1342.cpp) [Go](./problems/algorithms/1342.go) | Easy |
+| 1347 | [Minimum Number of Steps to Make Two Strings Anagram](//leetcode.com/problems/minimum-number-of-steps-to-make-two-strings-anagram/) | [Go](./problems/algorithms/1347.go) | Medium |
 | 1354 | [Construct Target Array With Multiple Sums](//leetcode.com/problems/construct-target-array-with-multiple-sums/) | [Go](./problems/algorithms/1354.go) | Hard |
 | 1356 | [Sort Integers by The Number of 1 Bits](//leetcode.com/problems/sort-integers-by-the-number-of-1-bits/) | [Go](./problems/algorithms/1356.go) | Easy |
 | 1423 | [Maximum Points You Can Obtain from Cards](//leetcode.com/problems/maximum-points-you-can-obtain-from-cards/) | [Go](./problems/algorithms/1423.go) | Medium |
@@ -193,18 +198,21 @@ LeetCode Problems' Solutions
 | 1603 | [Design Parking System](//leetcode.com/problems/design-parking-system/) | [Go](./problems/algorithms/1603.go) | Easy |
 | 1642 | [Furthest Building You Can Reach](//leetcode.com/problems/furthest-building-you-can-reach/) | [Go](./problems/algorithms/1642.go) | Medium |
 | 1647 | [Minimum Deletions to Make Character Frequencies Unique](//leetcode.com/problems/minimum-deletions-to-make-character-frequencies-unique/) | [Go](./problems/algorithms/1647.go) | Medium |
+| 1657 | [Determine if Two Strings Are Close](//leetcode.com/problems/determine-if-two-strings-are-close/) | [Go](./problems/algorithms/1657.go) | Medium |
 | 1658 | [Minimum Operations to Reduce X to Zero](//leetcode.com/problems/minimum-operations-to-reduce-x-to-zero/) | [Go](./problems/algorithms/1658.go) | Medium |
 | 1672 | [Richest Customer Wealth](//leetcode.com/problems/richest-customer-wealth/) | [Go](./problems/algorithms/1672.go) | Easy |
 | 1678 | [Goal Parser Interpretation](//leetcode.com/problems/goal-parser-interpretation/) | [Go](./problems/algorithms/1678.go) | Easy |
 | 1689 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](//leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/) | [Go](./problems/algorithms/1689.go) | Medium |
 | 1695 | [Maximum Erasure Value](//leetcode.com/problems/maximum-erasure-value/) | [Go](./problems/algorithms/1695.go) | Medium |
 | 1696 | [Jump Game VI](//leetcode.com/problems/jump-game-vi/) | [Go](./problems/algorithms/1696.go) | Medium |
+| 1704 | [Determine if String Halves Are Alike](//leetcode.com/problems/determine-if-string-halves-are-alike/) | [Go](./problems/algorithms/1704.go) | Easy |
 | 1710 | [Maximum Units on a Truck](//leetcode.com/problems/maximum-units-on-a-truck/) | [Go](./problems/algorithms/1710.go) | Easy |
 | 1768 | [Merge Strings Alternately](//leetcode.com/problems/merge-strings-alternately/) | [Go](./problems/algorithms/1768.go) | Easy |
 | 1779 | [Find Nearest Point That Has the Same X or Y Coordinate](//leetcode.com/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate/) | [Go](./problems/algorithms/1779.go) | Easy |
 | 1790 | [Check if One String Swap Can Make Strings Equal](//leetcode.com/problems/check-if-one-string-swap-can-make-strings-equal/) | [Go](./problems/algorithms/1790.go) | Easy |
 | 1822 | [Sign of the Product of an Array](//leetcode.com/problems/sign-of-the-product-of-an-array/) | [Go](./problems/algorithms/1822.go) | Easy |
 | 2125 | [Number of Laser Beams in a Bank](//leetcode.com/problems/number-of-laser-beams-in-a-bank) | [Go](./problems/algorithms/2125.go) | Medium |
+| 2225 | [Find Players With Zero or One Losses](//leetcode.com/problems/number-of-laser-beams-in-a-bank) | [Go](./problems/algorithms/2225.go) | Medium |
 | 2319 | [Check if Matrix Is X-Matrix](//leetcode.com/problems/check-if-matrix-is-x-matrix/) | [Go](./problems/algorithms/2319.go) | Easy |
 | 2320 | [Count Number of Ways to Place Houses](//leetcode.com/problems/count-number-of-ways-to-place-houses/) | [Go](./problems/algorithms/2320.go) | Medium |
 | 2321 | [Maximum Score Of Spliced Array](//leetcode.com/problems/maximum-score-of-spliced-array/) | [Go](./problems/algorithms/2321.go) | Hard |

problems/algorithms/0049.go

@@ -0,0 +1,62 @@
+// Source: https://leetcode.com/problems/group-anagrams/
+// Title: Group Anagrams
+// Difficulty: Medium
+// Author: Mu Yang <http://muyang.pro>
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Given an array of strings strs, group the anagrams together. You can return the answer in any order.
+// An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+//
+// Example 1:
+//
+//   Input: strs = ["eat","tea","tan","ate","nat","bat"]
+//   Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
+//
+// Example 2:
+//
+//   Input: strs = [""]
+//   Output: [[""]]
+//
+// Example 3:
+//
+//   Input: strs = ["a"]
+//   Output: [["a"]]
+//
+// Constraints:
+//
+//   * 1 <= strs.length <= 10^4
+//   * 0 <= strs[i].length <= 100
+//   * strs[i] consists of lowercase English letters.
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+package main
+
+import (
+	"sort"
+)
+
+type RuneSlice []rune
+
+func (x RuneSlice) Len() int           { return len(x) }
+func (x RuneSlice) Less(i, j int) bool { return x[i] < x[j] }
+func (x RuneSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
+
+func groupAnagrams(strs []string) [][]string {
+	groupMap := make(map[string][]string, len(strs))
+	for _, str := range strs {
+		r := RuneSlice(str)
+		sort.Sort(r)
+		sorted := string(r)
+		if _, ok := groupMap[sorted]; !ok {
+			groupMap[sorted] = make([]string, 0)
+		}
+		groupMap[sorted] = append(groupMap[sorted], str)
+	}
+
+	groups := make([][]string, 0, len(groupMap))
+	for _, group := range groupMap {
+		groups = append(groups, group)
+	}
+	return groups
+}

problems/algorithms/0380.go

@@ -0,0 +1,96 @@
+// Source: https://leetcode.com/problems/insert-delete-getrandom-o1/
+// Title: Insert Delete GetRandom O(1)
+// Difficulty: Medium
+// Author: Mu Yang <http://muyang.pro>
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Implement the RandomizedSet class:
+//
+// * RandomizedSet() Initializes the RandomizedSet object.
+// * bool insert(int val) Inserts an item val into the set if not present. Returns true if the item was not present, false otherwise.
+// * bool remove(int val) Removes an item val from the set if present. Returns true if the item was present, false otherwise.
+// * int getRandom() Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the same probability of being returned.
+//
+// You must implement the functions of the class such that each function works in average O(1) time complexity.
+//
+// Example 1:
+//
+//   Input
+//     ["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
+//     [[], [1], [2], [2], [], [1], [2], []]
+//   Output
+//     [null, true, false, true, 2, true, false, 2]
+//   Explanation
+//     RandomizedSet randomizedSet = new RandomizedSet();
+//     randomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully.
+//     randomizedSet.remove(2); // Returns false as 2 does not exist in the set.
+//     randomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2].
+//     randomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly.
+//     randomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2].
+//     randomizedSet.insert(2); // 2 was already in the set, so return false.
+//     randomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.
+//
+// Constraints:
+//
+//   * -2^31 <= val <= 2^31-1
+//   * At most 2 * 10^5 calls will be made to insert, remove, and getRandom.s
+//   * There will be at least one element in the data structure when getRandom is called.
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+package main
+
+import (
+	"math/rand"
+)
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * obj := Constructor();
+ * param_1 := obj.Insert(val);
+ * param_2 := obj.Remove(val);
+ * param_3 := obj.GetRandom();
+ */
+
+type RandomizedSet struct {
+	keys []int
+	idxs map[int]int // map key to its index
+}
+
+func Constructor() RandomizedSet {
+	return RandomizedSet{
+		keys: make([]int, 0),
+		idxs: make(map[int]int),
+	}
+}
+
+func (this *RandomizedSet) Insert(val int) bool {
+	_, exist := this.idxs[val]
+	if exist {
+		return false
+	}
+
+	this.keys = append(this.keys, val)
+	this.idxs[val] = len(this.keys) - 1
+	return true
+}
+
+func (this *RandomizedSet) Remove(val int) bool {
+	idx, exist := this.idxs[val]
+	if !exist {
+		return false
+	}
+
+	// Swap with last element
+	lastVal := this.keys[len(this.keys)-1]
+	this.keys[idx] = lastVal
+	this.idxs[lastVal] = idx
+	delete(this.idxs, val)
+	this.keys = this.keys[:len(this.keys)-1]
+	return true
+}
+
+func (this *RandomizedSet) GetRandom() int {
+	idx := rand.Intn(len(this.keys))
+	return this.keys[idx]
+}

problems/algorithms/0931.go

@@ -51,30 +51,19 @@ func minFallingPathSum(matrix [][]int) int {
 	}
 
 	for _, row := range matrix[1:] {
-		next[0] = _min(prev[0], prev[1]) + row[0]
+		next[0] = min(prev[0], prev[1]) + row[0]
 		for i := 1; i < n-1; i++ {
-			next[i] = _min3(prev[i-1], prev[i], prev[i+1]) + row[i]
+			next[i] = min(prev[i-1], prev[i], prev[i+1]) + row[i]
 		}
-		next[n-1] = _min(prev[n-2], prev[n-1]) + row[n-1]
+		next[n-1] = min(prev[n-2], prev[n-1]) + row[n-1]
 
 		prev, next = next, prev
 	}
 
 	res := math.MaxInt32
 	for _, v := range prev {
-		res = _min(res, v)
+		res = min(res, v)
 	}
 
 	return res
 }
-
-func _min3(a, b, c int) int {
-	return _min(_min(a, b), c)
-}
-
-func _min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

problems/algorithms/1026.go

@@ -0,0 +1,81 @@
+// Source: https://leetcode.com/problems/maximum-difference-between-node-and-ancestor/
+// Title: Determine if String Halves Are Alike
+// Difficulty: Medium
+// Author: Mu Yang <http://muyang.pro>
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Given the root of a binary tree, find the maximum value v for which there exist different nodes a and b where v = |a.val - b.val| and a is an ancestor of b.
+//
+// A node a is an ancestor of b if either: any child of a is equal to b or any child of a is an ancestor of b.
+//
+// Example 1:
+//
+//   https://assets.leetcode.com/uploads/2020/11/09/tmp-tree.jpg
+//
+//   Input: root = [8,3,10,1,6,null,14,null,null,4,7,13]
+//   Output: 7
+//   Explanation:
+//     We have various ancestor-node differences, some of which are given below :
+//     |8 - 3| = 5
+//     |3 - 7| = 4
+//     |8 - 1| = 7
+//     |10 - 13| = 3
+//     Among all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.
+//
+// Example 2:
+//
+//   https://assets.leetcode.com/uploads/2020/11/09/tmp-tree-1.jpg
+//
+//   Input: root = [1,null,2,null,0,3]
+//   Output: 3
+//
+// Constraints:
+//
+//   The number of nodes in the tree is in the range [2, 5000].
+//   0 <= Node.val <= 10^5
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+package main
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func maxAncestorDiff(root *TreeNode) int {
+	return _maxAncestorDiff(root, root.Val, root.Val)
+}
+
+func _maxAncestorDiff(root *TreeNode, min, max int) int {
+	if root == nil {
+		return 0
+	}
+
+	min = _min(min, root.Val)
+	max = _max(max, root.Val)
+	res := _max(root.Val-min, max-root.Val)
+
+	// Left
+	res = _max(res, _maxAncestorDiff(root.Left, min, max))
+
+	// Right
+	res = _max(res, _maxAncestorDiff(root.Right, min, max))
+
+	return res
+}
+
+func _max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func _min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

problems/algorithms/1074.go

@@ -43,13 +43,13 @@ func numSubmatrixSumTarget(matrix [][]int, target int) int {
 	n := len(matrix[0])
 
 	// Compute prefix sums
-	sum := make([][]int, m+1)
+	presum := make([][]int, m+1)
 	for i := 0; i < m+1; i++ {
-		sum[i] = make([]int, n+1)
+		presum[i] = make([]int, n+1)
 	}
 	for i := 0; i < m; i++ {
 		for j := 0; j < n; j++ {
-			sum[i+1][j+1] = matrix[i][j] + sum[i][j+1] + sum[i+1][j] - sum[i][j]
+			presum[i+1][j+1] = matrix[i][j] + presum[i][j+1] + presum[i+1][j] - presum[i][j]
 		}
 	}
 
@@ -59,7 +59,7 @@ func numSubmatrixSumTarget(matrix [][]int, target int) int {
 		for x2 := x1 + 1; x2 <= m; x2++ {
 			for y1 := 0; y1 < n; y1++ {
 				for y2 := y1 + 1; y2 <= n; y2++ {
-					subsum := sum[x2][y2] - sum[x2][y1] - sum[x1][y2] + sum[x1][y1]
+					subsum := presum[x2][y2] - presum[x2][y1] - presum[x1][y2] + presum[x1][y1]
 					if subsum == target {
 						res++
 					}