feat: update solutions to lc problems: No.0790,0875

* No.0790.Domino and Tromino Tiling
* No.0875.Koko Eating Bananas

Author: yanglbme

solution/0100-0199/0146.LRU Cache/README.md

@@ -66,7 +66,7 @@ lRUCache.get(4);    // 返回 4
 “哈希表 + 双向链表”实现。其中：
 
 -   双向链表按照被使用的顺序存储 kv 键值对，靠近头部的 kv 键值对是最近使用的，而靠近尾部的键值对是最久未使用的。
--   哈希表通过缓存的 key 映射到双向链表中的位置。我们可以在 `O(1)` 时间内定位到缓存的 key 所对应的 value 在链表中的位置。
+-   哈希表通过缓存的 key 映射到双向链表中的位置。我们可以在 $O(1)$ 时间内定位到缓存的 key 所对应的 value 在链表中的位置。
 
 对于 `get` 操作，判断 key 是否存在哈希表中：
 

solution/0700-0799/0790.Domino and Tromino Tiling/README.md

@@ -47,6 +47,35 @@
 
 **方法一：动态规划**
 
+我们首先要读懂题意，题目实际上是让我们求铺满 $2\times n$ 的面板的方案数，其中面板上的每个正方形只能被一个瓷砖覆盖。
+
+瓷砖的形状有两种，分别是 `2 x 1` 型 和 `L` 型，并且两种瓷砖都可以旋转。我们将旋转后的瓷砖分别记为 `1 x 2` 型 和 `L'` 型。
+
+我们定义 $f[i][j]$ 表示平铺前 $2\times i$ 的面板，其中 $j$ 表示最后一列的状态。最后一列有 $4$ 种状态，分别是：
+
+-   最后一列铺满，记为 $0$
+-   最后一列只铺了上方一个瓷砖，记为 $1$
+-   最后一列只铺了下方一个瓷砖，记为 $2$
+-   最后一列没有铺瓷砖，记为 $3$
+
+那么答案就是 $f[n][0]$。初始时 $f[0][0]=1$，其余 $f[0][j]=0$。
+
+我们考虑铺到第 $i$ 列，来看看状态转移方程：
+
+当 $j=0$ 时，最后一列铺满，可由前一列的 $0,1,2,3$ 四种状态铺上对应的瓷砖转移而来，即 $f[i-1][0]$ 铺上 `1 x 2` 型瓷砖，或者 $f[i-1][1]$ 铺上 `L'` 型瓷砖，或者 $f[i-1][2]$ 铺上 `L'` 型瓷砖，或者 $f[i-1][3]$ 铺上两块 `2 x 1` 型瓷砖。因此 $f[i][0]=\sum_{j=0}^3f[i-1][j]$。
+
+当 $j=1$ 时，最后一列只铺了上方一个瓷砖，可由前一列的 $2,3$ 两种状态转移而来，即 $f[i-1][2]$ 铺上 `2 x 1` 型瓷砖，或者 $f[i-1][3]$ 铺上 `L` 型瓷砖。因此 $f[i][1]=f[i-1][2]+f[i-1][3]$。
+
+当 $j=2$ 时，最后一列只铺了下方一个瓷砖，可由前一列的 $1,3$ 两种状态转移而来，即 $f[i-1][1]$ 铺上 `2 x 1` 型瓷砖，或者 $f[i-1][3]$ 铺上 `L'` 型瓷砖。因此 $f[i][2]=f[i-1][1]+f[i-1][3]$。
+
+当 $j=3$ 时，最后一列没有铺瓷砖，可由前一列的 $0$ 一种状态转移而来，即 $f[i-1][0]$ 铺上两块 `2 x 1` 型瓷砖。因此 $f[i][3]=f[i-1][0]$。
+
+可以发现，状态转移方程中只涉及到前一列的状态，因此我们可以使用滚动数组优化空间复杂度。
+
+注意，过程中的状态数值可能会很大，因此需要对 $10^9+7$ 取模。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为面板的列数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -70,7 +99,7 @@ class Solution:
             else:
                 ans = dfs(i + 2, j) + dfs(i + 2, j + 1)
             return ans % mod
-        
+
         mod = 10**9 + 7
         return dfs(0, 0)
 ```

solution/0800-0899/0875.Koko Eating Bananas/README.md

@@ -130,20 +130,16 @@ public:
 
 ```go
 func minEatingSpeed(piles []int, h int) int {
-	left, right := 1, int(1e9)
-	for left < right {
-		mid := (left + right) >> 1
+	return sort.Search(1e9, func(i int) bool {
+		if i == 0 {
+			return false
+		}
 		s := 0
 		for _, x := range piles {
-			s += (x + mid - 1) / mid
-		}
-		if s <= h {
-			right = mid
-		} else {
-			left = mid + 1
+			s += (x + i - 1) / i
 		}
-	}
-	return left
+		return s <= h
+	})
 }
 ```
 

solution/0800-0899/0875.Koko Eating Bananas/README_EN.md

@@ -113,20 +113,16 @@ public:
 
 ```go
 func minEatingSpeed(piles []int, h int) int {
-	left, right := 1, int(1e9)
-	for left < right {
-		mid := (left + right) >> 1
+	return sort.Search(1e9, func(i int) bool {
+		if i == 0 {
+			return false
+		}
 		s := 0
 		for _, x := range piles {
-			s += (x + mid - 1) / mid
-		}
-		if s <= h {
-			right = mid
-		} else {
-			left = mid + 1
+			s += (x + i - 1) / i
 		}
-	}
-	return left
+		return s <= h
+	})
 }
 ```
 

solution/0800-0899/0875.Koko Eating Bananas/Solution.go

@@ -1,16 +1,12 @@
 func minEatingSpeed(piles []int, h int) int {
-	left, right := 1, int(1e9)
-	for left < right {
-		mid := (left + right) >> 1
+	return sort.Search(1e9, func(i int) bool {
+		if i == 0 {
+			return false
+		}
 		s := 0
 		for _, x := range piles {
-			s += (x + mid - 1) / mid
-		}
-		if s <= h {
-			right = mid
-		} else {
-			left = mid + 1
+			s += (x + i - 1) / i
 		}
-	}
-	return left
+		return s <= h
+	})
 }