feat: add solutions to lcp problem: No.44

Author: yanglbme

lcp/LCP 44. 开幕式焰火/README.md

@@ -49,15 +49,116 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+class Solution:
+    def numColor(self, root: TreeNode) -> int:
+        s = set()
+
+        def dfs(root):
+            if root:
+                s.add(root.val)
+                dfs(root.left)
+                dfs(root.right)
+        
+        dfs(root)
+        return len(s)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    private Set<Integer> s;
+
+    public int numColor(TreeNode root) {
+        s = new HashSet<>();
+        dfs(root);
+        return s.size();
+    }
+
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        s.add(root.val);
+        dfs(root.left);
+        dfs(root.right);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    unordered_set<int> s;
+
+    int numColor(TreeNode* root) {
+        dfs(root);
+        return s.size();
+    }
+
+    void dfs(TreeNode* root) {
+        if (!root) return;
+        s.insert(root->val);
+        dfs(root->left);
+        dfs(root->right);
+    }
+};
+```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+var s map[int]bool
+
+func numColor(root *TreeNode) int {
+	s = make(map[int]bool)
+	dfs(root)
+	return len(s)
+}
+
+func dfs(root *TreeNode) {
+	if root != nil {
+		s[root.Val] = true
+		dfs(root.Left)
+		dfs(root.Right)
+	}
+}
 ```
 
 ### **...**

lcp/LCP 44. 开幕式焰火/Solution.cpp

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    unordered_set<int> s;
+
+    int numColor(TreeNode* root) {
+        dfs(root);
+        return s.size();
+    }
+
+    void dfs(TreeNode* root) {
+        if (!root) return;
+        s.insert(root->val);
+        dfs(root->left);
+        dfs(root->right);
+    }
+};

lcp/LCP 44. 开幕式焰火/Solution.go

@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+var s map[int]bool
+
+func numColor(root *TreeNode) int {
+	s = make(map[int]bool)
+	dfs(root)
+	return len(s)
+}
+
+func dfs(root *TreeNode) {
+	if root != nil {
+		s[root.Val] = true
+		dfs(root.Left)
+		dfs(root.Right)
+	}
+}

lcp/LCP 44. 开幕式焰火/Solution.java

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    private Set<Integer> s;
+
+    public int numColor(TreeNode root) {
+        s = new HashSet<>();
+        dfs(root);
+        return s.size();
+    }
+
+    private void dfs(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        s.add(root.val);
+        dfs(root.left);
+        dfs(root.right);
+    }
+}

lcp/LCP 44. 开幕式焰火/Solution.py

@@ -0,0 +1,18 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+class Solution:
+    def numColor(self, root: TreeNode) -> int:
+        s = set()
+
+        def dfs(root):
+            if root:
+                s.add(root.val)
+                dfs(root.left)
+                dfs(root.right)
+
+        dfs(root)
+        return len(s)