feat: add solutions to lc problem: No.1612

No.1612.Check If Two Expression Trees are Equivalent

Author: yanglbme

solution/1600-1699/1612.Check If Two Expression Trees are Equivalent/README.md

@@ -58,6 +58,16 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：递归**
+
+我们定义一个计数器 $cnt$，用于统计每个字母出现的次数。
+
+然后我们分别对两棵二叉表达式树进行深度优先搜索，如果字母出现在左子树，则 $cnt$ 中对应的字母的值加 $1$，如果出现在右子树，则 $cnt$ 中对应的字母的值减 $1$。
+
+最后，我们遍历 $cnt$，如果所有字母的值都为 $0$，则返回 `true`，否则返回 `false`。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉表达式树的节点个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -73,18 +83,18 @@
 #         self.right = right
 class Solution:
     def checkEquivalence(self, root1: 'Node', root2: 'Node') -> bool:
-        counter = [0] * 26
-
-        def dfs(root, incr):
-            if root:
-                dfs(root.left, incr)
-                dfs(root.right, incr)
-                if root.val != '+':
-                    counter[ord(root.val) - ord('a')] += incr
-
+        def dfs(root, v):
+            if root is None:
+                return
+            if root.val != '+':
+                cnt[root.val] += v
+            dfs(root.left, v)
+            dfs(root.right, v)
+
+        cnt = Counter()
         dfs(root1, 1)
         dfs(root2, -1)
-        return counter.count(0) == 26
+        return all(x == 0 for x in cnt.values())
 ```
 
 ```python
@@ -96,23 +106,18 @@ class Solution:
 #         self.right = right
 class Solution:
     def checkEquivalence(self, root1: 'Node', root2: 'Node') -> bool:
-        def calc(ans, left, right, op):
-            for i in range(26):
-                if op == '+':
-                    ans[i] = left[i] + right[i]
-                else:
-                    ans[i] = left[i] - right[i]
-
         def dfs(root):
-            ans = [0] * 26
-            if not root:
-                return ans
-            if root.val in ['+', '-']:
-                left, right = dfs(root.left), dfs(root.right)
-                calc(ans, left, right, root.val)
+            cnt = [0] * 26
+            if root is None:
+                return cnt
+            if root.val in '+-':
+                l, r = dfs(root.left), dfs(root.right)
+                k = 1 if root.val == '+' else -1
+                for i in range(26):
+                    cnt[i] += l[i] + r[i] * k
             else:
-                ans[ord(root.val) - ord('a')] += 1
-            return ans
+                cnt[ord(root.val) - ord('a')] += 1
+            return cnt
 
         return dfs(root1) == dfs(root2)
 ```
@@ -138,29 +143,28 @@ class Solution:
  * }
  */
 class Solution {
-    private int[] counter;
+    private int[] cnt = new int[26];
 
     public boolean checkEquivalence(Node root1, Node root2) {
-        counter = new int[26];
         dfs(root1, 1);
         dfs(root2, -1);
-        for (int n : counter) {
-            if (n != 0) {
+        for (int x : cnt) {
+            if (x != 0) {
                 return false;
             }
         }
         return true;
     }
 
-    private void dfs(Node root, int incr) {
+    private void dfs(Node root, int v) {
         if (root == null) {
             return;
         }
-        dfs(root.left, incr);
-        dfs(root.right, incr);
         if (root.val != '+') {
-            counter[root.val - 'a'] += incr;
+            cnt[root.val - 'a'] += v;
         }
+        dfs(root.left, v);
+        dfs(root.right, v);
     }
 }
 ```
@@ -183,35 +187,32 @@ class Solution {
  */
 class Solution {
     public boolean checkEquivalence(Node root1, Node root2) {
-        int[] ans1 = dfs(root1);
-        int[] ans2 = dfs(root2);
+        int[] cnt1 = dfs(root1);
+        int[] cnt2 = dfs(root2);
         for (int i = 0; i < 26; ++i) {
-            if (ans1[i] != ans2[i]) {
+            if (cnt1[i] != cnt2[i]) {
                 return false;
             }
         }
         return true;
     }
 
     private int[] dfs(Node root) {
-        int[] ans = new int[26];
+        int[] cnt = new int[26];
         if (root == null) {
-            return ans;
+            return cnt;
         }
         if (root.val == '+' || root.val == '-') {
-            int[] left = dfs(root.left);
-            int[] right = dfs(root.right);
-            calc(ans, left, right, root.val);
+            int[] l = dfs(root.left);
+            int[] r = dfs(root.right);
+            int k = root.val == '+' ? 1 : -1;
+            for (int i = 0; i < 26; ++i) {
+                cnt[i] += l[i] + r[i] * k;
+            }
         } else {
-            ++ans[root.val - 'a'];
-        }
-        return ans;
-    }
-
-    private void calc(int[] ans, int[] left, int[] right, char op) {
-        for (int i = 0; i < 26; ++i) {
-            ans[i] = op == '+' ? left[i] + right[i] : left[i] - right[i];
+            cnt[root.val - 'a']++;
         }
+        return cnt;
     }
 }
 ```
@@ -232,20 +233,26 @@ class Solution {
  */
 class Solution {
 public:
-    vector<int> counter;
-
     bool checkEquivalence(Node* root1, Node* root2) {
-        counter.resize(26);
+        int cnt[26]{};
+        function<void(Node*, int)> dfs = [&](Node* root, int v) {
+            if (!root) {
+                return;
+            }
+            if (root->val != '+') {
+                cnt[root->val - 'a'] += v;
+            }
+            dfs(root->left, v);
+            dfs(root->right, v);
+        };
         dfs(root1, 1);
         dfs(root2, -1);
-        return count(counter.begin(), counter.end(), 0) == 26;
-    }
-
-    void dfs(Node* root, int incr) {
-        if (!root) return;
-        dfs(root->left, incr);
-        dfs(root->right, incr);
-        if (root->val != '+') counter[root->val - 'a'] += incr;
+        for (int& x : cnt) {
+            if (x) {
+                return false;
+            }
+        }
+        return true;
     }
 };
 ```
@@ -265,27 +272,107 @@ public:
 class Solution {
 public:
     bool checkEquivalence(Node* root1, Node* root2) {
+        function<vector<int>(Node*)> dfs = [&](Node* root) -> vector<int> {
+            vector<int> cnt(26);
+            if (!root) {
+                return cnt;
+            }
+            if (root->val == '+' || root->val == '-') {
+                auto l = dfs(root->left);
+                auto r = dfs(root->right);
+                int k = root->val == '+' ? 1 : -1;
+                for (int i = 0; i < 26; ++i) {
+                    cnt[i] += l[i] + r[i] * k;
+                }
+            } else {
+                cnt[root->val - 'a']++;
+            }
+            return cnt;
+        };
         return dfs(root1) == dfs(root2);
     }
+};
+```
+
+### **JavaScript**
 
-    vector<int> dfs(Node* root) {
-        vector<int> ans(26);
-        if (!root) return ans;
-        if (root->val == '+' || root->val == '-')
-        {
-            auto left = dfs(root->left);
-            auto right = dfs(root->right);
-            calc(ans, left, right, root->val);
-            return ans;
+```js
+/**
+ * Definition for a binary tree node.
+ * function Node(val, left, right) {
+ *     this.val = (val===undefined ? " " : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {Node} root1
+ * @param {Node} root2
+ * @return {boolean}
+ */
+var checkEquivalence = function (root1, root2) {
+    const cnt = new Array(26).fill(0);
+    const dfs = (root, v) => {
+        if (!root) {
+            return;
+        }
+        if (root.val !== '+') {
+            cnt[root.val.charCodeAt(0) - 'a'.charCodeAt(0)] += v;
+        }
+        dfs(root.left, v);
+        dfs(root.right, v);
+    };
+    dfs(root1, 1);
+    dfs(root2, -1);
+    for (const x of cnt) {
+        if (x) {
+            return false;
         }
-        ++ans[root->val - 'a'];
-        return ans;
     }
+    return true;
+};
+```
 
-    void calc(vector<int>& ans, vector<int>& left, vector<int>& right, char op) {
-        for (int i = 0; i < 26; ++i)
-            ans[i] = op == '+' ? left[i] + right[i] : left[i] - right[i];
+```js
+/**
+ * Definition for a binary tree node.
+ * function Node(val, left, right) {
+ *     this.val = (val===undefined ? " " : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {Node} root1
+ * @param {Node} root2
+ * @return {boolean}
+ */
+var checkEquivalence = function (root1, root2) {
+    const dfs = root => {
+        const cnt = new Array(26).fill(0);
+        if (!root) {
+            return cnt;
+        }
+        if (root.val === '+' || root.val === '-') {
+            const l = dfs(root.left);
+            const r = dfs(root.right);
+            const k = root.val === '+' ? 1 : -1;
+            for (let i = 0; i < 26; ++i) {
+                cnt[i] = l[i] + k * r[i];
+            }
+        } else {
+            cnt[root.val.charCodeAt(0) - 'a'.charCodeAt(0)]++;
+        }
+        return cnt;
+    };
+    const cnt1 = dfs(root1);
+    const cnt2 = dfs(root2);
+    for (let i = 0; i < 26; ++i) {
+        if (cnt1[i] !== cnt2[i]) {
+            return false;
+        }
     }
+    return true;
 };
 ```