feat: add solutions to lc problem: No.1145

No.1145.Binary Tree Coloring Game

Author: yanglbme

solution/1100-1199/1145.Binary Tree Coloring Game/README.md

@@ -58,9 +58,9 @@
 
 **方法一：DFS**
 
-先通过 $DFS$，找到 $x$ 所在的节点，我们记为 $node$。然后统计 $node$ 的左子树、右子树、父节点方向上的节点个数。如果这三个方向上有任何一个节点个数超过了节点总数的一半，则存在一个必胜策略。
+我们先通过 $DFS$，找到「一号」玩家着色点 $x$ 所在的节点，记为 $node$。
 
-这里 $node$ 父节点方向上的节点个数，可以由节点总数 $n$ 减去 $node$ 及其 $node$ 的左右子树节点数之和得到。
+接下来，我们统计 $node$ 的左子树、右子树的节点个数，分别记为 $l$ 和 $r$，而 $node$ 父节点方向上的个数为 $n - l - r - 1$。只要满足 $\max(l, r, n - l - r - 1) > \frac{n}{2}$，则「二号」玩家存在一个必胜策略。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是节点总数。
 
@@ -91,9 +91,7 @@ class Solution:
 
         node = dfs(root)
         l, r = count(node.left), count(node.right)
-        t = n - l - r - 1
-        m = max(l, r, t)
-        return m > n - m
+        return max(l, r, n - l - r - 1) > n // 2
 ```
 
 ### **Java**
@@ -121,26 +119,22 @@ class Solution {
         TreeNode node = dfs(root, x);
         int l = count(node.left);
         int r = count(node.right);
-        int m = Math.max(Math.max(l, r), n - l - r - 1);
-        return m > n - m;
-    }
-
-    private int count(TreeNode node) {
-        if (node == null) {
-            return 0;
-        }
-        return 1 + count(node.left) + count(node.right);
+        return Math.max(Math.max(l, r), n - l - r - 1) > n / 2;
     }
 
     private TreeNode dfs(TreeNode root, int x) {
         if (root == null || root.val == x) {
             return root;
         }
-        TreeNode l = dfs(root.left, x);
-        if (l != null) {
-            return l;
+        TreeNode node = dfs(root.left, x);
+        return node == null ? dfs(root.right, x) : node;
+    }
+
+    private int count(TreeNode root) {
+        if (root == null) {
+            return 0;
         }
-        return dfs(root.right, x);
+        return 1 + count(root.left) + count(root.right);
     }
 }
 ```
@@ -162,22 +156,24 @@ class Solution {
 class Solution {
 public:
     bool btreeGameWinningMove(TreeNode* root, int n, int x) {
-        TreeNode* node = dfs(root, x);
-        int l = count(node->left);
-        int r = count(node->right);
-        int m = max(max(l, r), n - l - r - 1);
-        return m > n - m;
+        auto node = dfs(root, x);
+        int l = count(node->left), r = count(node->right);
+        return max({l, r, n - l - r - 1}) > n / 2;
     }
 
-    int count(TreeNode* root) {
-        if (!root) return 0;
-        return 1 + count(root->left) + count(root->right);
+    TreeNode* dfs(TreeNode* root, int x) {
+        if (!root || root->val == x) {
+            return root;
+        }
+        auto node = dfs(root->left, x);
+        return node ? node : dfs(root->right, x);
     }
 
-    TreeNode* dfs(TreeNode* root, int x) {
-        if (!root || root->val == x) return root;
-        auto l = dfs(root->left, x);
-        return l ? l : dfs(root->right, x);
+    int count(TreeNode* root) {
+        if (!root) {
+            return 0;
+        }
+        return 1 + count(root->left) + count(root->right);
     }
 };
 ```
@@ -226,6 +222,88 @@ func max(a, b int) int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} n
+ * @param {number} x
+ * @return {boolean}
+ */
+var btreeGameWinningMove = function (root, n, x) {
+    const dfs = root => {
+        if (!root || root.val === x) {
+            return root;
+        }
+        return dfs(root.left) || dfs(root.right);
+    };
+
+    const count = root => {
+        if (!root) {
+            return 0;
+        }
+        return 1 + count(root.left) + count(root.right);
+    };
+
+    const node = dfs(root);
+    const l = count(node.left);
+    const r = count(node.right);
+    return Math.max(l, r, n - l - r - 1) > n / 2;
+};
+```
+
+### **TypeScript**
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function btreeGameWinningMove(
+    root: TreeNode | null,
+    n: number,
+    x: number,
+): boolean {
+    const dfs = (root: TreeNode | null): TreeNode | null => {
+        if (!root || root.val === x) {
+            return root;
+        }
+        return dfs(root.left) || dfs(root.right);
+    };
+
+    const count = (root: TreeNode | null): number => {
+        if (!root) {
+            return 0;
+        }
+        return 1 + count(root.left) + count(root.right);
+    };
+
+    const node = dfs(root);
+    const l = count(node.left);
+    const r = count(node.right);
+    return Math.max(l, r, n - l - r - 1) > n / 2;
+}
+```
+
 ### **...**
 
 ```

solution/1100-1199/1145.Binary Tree Coloring Game/README_EN.md

@@ -68,9 +68,7 @@ class Solution:
 
         node = dfs(root)
         l, r = count(node.left), count(node.right)
-        t = n - l - r - 1
-        m = max(l, r, t)
-        return m > n - m
+        return max(l, r, n - l - r - 1) > n // 2
 ```
 
 ### **Java**
@@ -96,26 +94,22 @@ class Solution {
         TreeNode node = dfs(root, x);
         int l = count(node.left);
         int r = count(node.right);
-        int m = Math.max(Math.max(l, r), n - l - r - 1);
-        return m > n - m;
-    }
-
-    private int count(TreeNode node) {
-        if (node == null) {
-            return 0;
-        }
-        return 1 + count(node.left) + count(node.right);
+        return Math.max(Math.max(l, r), n - l - r - 1) > n / 2;
     }
 
     private TreeNode dfs(TreeNode root, int x) {
         if (root == null || root.val == x) {
             return root;
         }
-        TreeNode l = dfs(root.left, x);
-        if (l != null) {
-            return l;
+        TreeNode node = dfs(root.left, x);
+        return node == null ? dfs(root.right, x) : node;
+    }
+
+    private int count(TreeNode root) {
+        if (root == null) {
+            return 0;
         }
-        return dfs(root.right, x);
+        return 1 + count(root.left) + count(root.right);
     }
 }
 ```
@@ -137,22 +131,24 @@ class Solution {
 class Solution {
 public:
     bool btreeGameWinningMove(TreeNode* root, int n, int x) {
-        TreeNode* node = dfs(root, x);
-        int l = count(node->left);
-        int r = count(node->right);
-        int m = max(max(l, r), n - l - r - 1);
-        return m > n - m;
+        auto node = dfs(root, x);
+        int l = count(node->left), r = count(node->right);
+        return max({l, r, n - l - r - 1}) > n / 2;
     }
 
-    int count(TreeNode* root) {
-        if (!root) return 0;
-        return 1 + count(root->left) + count(root->right);
+    TreeNode* dfs(TreeNode* root, int x) {
+        if (!root || root->val == x) {
+            return root;
+        }
+        auto node = dfs(root->left, x);
+        return node ? node : dfs(root->right, x);
     }
 
-    TreeNode* dfs(TreeNode* root, int x) {
-        if (!root || root->val == x) return root;
-        auto l = dfs(root->left, x);
-        return l ? l : dfs(root->right, x);
+    int count(TreeNode* root) {
+        if (!root) {
+            return 0;
+        }
+        return 1 + count(root->left) + count(root->right);
     }
 };
 ```
@@ -201,6 +197,88 @@ func max(a, b int) int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} n
+ * @param {number} x
+ * @return {boolean}
+ */
+var btreeGameWinningMove = function (root, n, x) {
+    const dfs = root => {
+        if (!root || root.val === x) {
+            return root;
+        }
+        return dfs(root.left) || dfs(root.right);
+    };
+
+    const count = root => {
+        if (!root) {
+            return 0;
+        }
+        return 1 + count(root.left) + count(root.right);
+    };
+
+    const node = dfs(root);
+    const l = count(node.left);
+    const r = count(node.right);
+    return Math.max(l, r, n - l - r - 1) > n / 2;
+};
+```
+
+### **TypeScript**
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function btreeGameWinningMove(
+    root: TreeNode | null,
+    n: number,
+    x: number,
+): boolean {
+    const dfs = (root: TreeNode | null): TreeNode | null => {
+        if (!root || root.val === x) {
+            return root;
+        }
+        return dfs(root.left) || dfs(root.right);
+    };
+
+    const count = (root: TreeNode | null): number => {
+        if (!root) {
+            return 0;
+        }
+        return 1 + count(root.left) + count(root.right);
+    };
+
+    const node = dfs(root);
+    const l = count(node.left);
+    const r = count(node.right);
+    return Math.max(l, r, n - l - r - 1) > n / 2;
+}
+```
+
 ### **...**
 
 ```

solution/1100-1199/1145.Binary Tree Coloring Game/Solution.cpp

@@ -12,21 +12,23 @@
 class Solution {
 public:
     bool btreeGameWinningMove(TreeNode* root, int n, int x) {
-        TreeNode* node = dfs(root, x);
-        int l = count(node->left);
-        int r = count(node->right);
-        int m = max(max(l, r), n - l - r - 1);
-        return m > n - m;
+        auto node = dfs(root, x);
+        int l = count(node->left), r = count(node->right);
+        return max({l, r, n - l - r - 1}) > n / 2;
     }
 
-    int count(TreeNode* root) {
-        if (!root) return 0;
-        return 1 + count(root->left) + count(root->right);
+    TreeNode* dfs(TreeNode* root, int x) {
+        if (!root || root->val == x) {
+            return root;
+        }
+        auto node = dfs(root->left, x);
+        return node ? node : dfs(root->right, x);
     }
 
-    TreeNode* dfs(TreeNode* root, int x) {
-        if (!root || root->val == x) return root;
-        auto l = dfs(root->left, x);
-        return l ? l : dfs(root->right, x);
+    int count(TreeNode* root) {
+        if (!root) {
+            return 0;
+        }
+        return 1 + count(root->left) + count(root->right);
     }
 };