Update problem listings and some notes

Author: enginebai

leetcode/1052.grumpy-bookstore-owner.md

@@ -0,0 +1,45 @@
+# [1052. Grumpy Bookstore Owner](https://leetcode.com/problems/grumpy-bookstore-owner/)
+
+## Sliding Window
+We sum up the customers who are satisfied without the owner being grumpy, and then we use a fixed-size (`minutes`) sliding window to find the maximum number of customers who are satisfied with the owner being grumpy.
+
+Please note that the window keeps track of the number of customers who are satisfied with the owner being grumpy.
+
+```js
+
+index     0, 1, 2, 3, 4, 5, 6, 7
+customer: 1, 0, 1, 2, 1, 1, 7, 5
+grumpy:   0, 1, 0, 1, 0, 1, 0, 1
+base:     1,    1,    1,    7
+extra:    ^^^^^^^^ ->
+maxExtra:                1,    5
+```
+
+```kotlin
+fun maxSatisfied(customers: IntArray, grumpy: IntArray, minutes: Int): Int {
+    val n = customers.size
+    var base = 0
+    var extra = 0
+    var maxExtra = 0
+    for (i in customers.indices) {
+        if (grumpy[i] == 0) {
+            base += customers[i]
+        }
+        else {
+            extra += customers[i]
+        }
+
+        if (i >= minutes && grumpy[i - minutes] == 1) {
+            extra -= customers[i - minutes]
+        }
+        if (i >= minutes - 1) {
+            maxExtra = max(maxExtra, extra)
+        }
+    }
+    return base + maxExtra
+}
+```
+
+## Pitfalls
+- Forgetting checking if `grumpy[i - minutes] == 1` when shrinking `extra`.
+- Mixing up base satisfaction vs extra.

leetcode/1145.binary-tree-coloring-game.md

@@ -0,0 +1,47 @@
+# [1145. Binary Tree Coloring Game](https://leetcode.com/problems/binary-tree-coloring-game/)
+
+## Key Insights
+Player 1 colors any node `x` first, and player 2 then colors any other uncolored node `y` adjacent to `x`. Once player 1 colors node x, the tree is logically split into 3 disjoint regions:
+
+- Left subtree of `x`
+- Right subtree of `x`
+- Parent subtree of `x`
+
+```js
+      [parent of x]
+            |
+            x
+         /     \
+[left subtree] [right subtree]
+```
+
+Play 2 can choose one of the 3 subtrees to color, and play 1 can only color the rest of the 2 subtrees. Player 2 will take over that chosen subtree, and player 1 will not be able to color any node in that chosen subtree by player 2.
+
+So if player 2 chosen subtree > `n / 2`, then player 1 get < `n / 2` nodes to color, and player 2 wins.
+
+## Postorder Traversal
+We just calculate the node of each subtree and identify the 3 choices for player 2.
+
+```kotlin
+private var xSum = 0
+private var xLeftSum = 0
+private var xRightSum = 0
+
+fun btreeGameWinningMove(root: TreeNode?, n: Int, x: Int): Boolean {
+    val total = sum(root, x)
+    return (total - xSum) > n / 2 || xLeftSum > n / 2 || xRightSum > n / 2
+}
+
+private fun sum(root: TreeNode?, x: Int): Int {
+    if (root == null) return 0
+    val left = sum(root.left, x)
+    val right = sum(root.right, x)
+    val total = 1 + left + right
+    if (root.`val` == x) {
+        xSum = total
+        xLeftSum = left
+        xRightSum = right
+    }
+    return total
+}
+```