feat: add solutions to lc problem: No.0854

No.0854.K-Similar Strings

Author: yanglbme

solution/0100-0199/0100.Same Tree/README.md

@@ -46,12 +46,18 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：DFS**
+
+**方法二：BFS**
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+DFS：
+
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -68,6 +74,41 @@ class Solution:
         return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
 ```
 
+BFS：
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
+        if p == q:
+            return True
+        if p is None or q is None:
+            return False
+        q1, q2 = deque([p]), deque([q])
+        while q1 and q2:
+            a, b = q1.popleft(), q2.popleft()
+            if a.val != b.val:
+                return False
+            la, ra = a.left, a.right
+            lb, rb = b.left, b.right
+            if (la and not lb) or (lb and not la):
+                return False
+            if (ra and not rb) or (rb and not ra):
+                return False
+            if la:
+                q1.append(la)
+                q2.append(lb)
+            if ra:
+                q1.append(ra)
+                q2.append(rb)
+        return True
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -97,6 +138,62 @@ class Solution {
 }
 ```
 
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if (p == q) {
+            return true;
+        }
+        if (p == null || q == null) {
+            return false;
+        }
+        Deque<TreeNode> q1 = new ArrayDeque<>();
+        Deque<TreeNode> q2 = new ArrayDeque<>();
+        q1.offer(p);
+        q2.offer(q);
+        while (!q1.isEmpty() && !q2.isEmpty()) {
+            p = q1.poll();
+            q = q2.poll();
+            if (p.val != q.val) {
+                return false;
+            }
+            TreeNode la = p.left, ra = p.right;
+            TreeNode lb = q.left, rb = q.right;
+            if ((la != null && lb == null) || (lb != null && la == null)) {
+                return false;
+            }
+            if ((ra != null && rb == null) || (rb != null && ra == null)) {
+                return false;
+            }
+            if (la != null) {
+                q1.offer(la);
+                q2.offer(lb);
+            }
+            if (ra != null) {
+                q1.offer(ra);
+                q2.offer(rb);
+            }
+        }
+        return true;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -121,6 +218,52 @@ public:
 };
 ```
 
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    bool isSameTree(TreeNode* p, TreeNode* q) {
+        if (p == q) return true;
+        if (!p || !q) return false;
+        queue<TreeNode*> q1{{p}};
+        queue<TreeNode*> q2{{q}};
+        while (!q1.empty() && !q2.empty())
+        {
+            p = q1.front();
+            q = q2.front();
+            if (p->val != q->val) return false;
+            q1.pop();
+            q2.pop();
+            TreeNode *la = p->left, *ra = p->right;
+            TreeNode *lb = q->left, *rb = q->right;
+            if ((la && !lb) || (lb && !la)) return false;
+            if ((ra && !rb) || (rb && !ra)) return false;
+            if (la)
+            {
+                q1.push(la);
+                q2.push(lb);
+            }
+            if (ra)
+            {
+                q1.push(ra);
+                q2.push(rb);
+            }
+        }
+        return true;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -143,6 +286,51 @@ func isSameTree(p *TreeNode, q *TreeNode) bool {
 }
 ```
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func isSameTree(p *TreeNode, q *TreeNode) bool {
+	if p == q {
+		return true
+	}
+	if p == nil || q == nil {
+		return false
+	}
+	q1 := []*TreeNode{p}
+	q2 := []*TreeNode{q}
+	for len(q1) > 0 && len(q2) > 0 {
+		p, q = q1[0], q2[0]
+		if p.Val != q.Val {
+			return false
+		}
+		q1, q2 = q1[1:], q2[1:]
+		la, ra := p.Left, p.Right
+		lb, rb := q.Left, q.Right
+		if (la != nil && lb == nil) || (lb != nil && la == nil) {
+			return false
+		}
+		if (ra != nil && rb == nil) || (rb != nil && ra == nil) {
+			return false
+		}
+		if la != nil {
+			q1 = append(q1, la)
+			q2 = append(q2, lb)
+		}
+		if ra != nil {
+			q1 = append(q1, ra)
+			q2 = append(q2, rb)
+		}
+	}
+	return true
+}
+```
+
 ### **JavaScript**
 
 ```js