### My aim is to explain this problem using multiple approaches because I was asked to solve it that way during an interview.\n\n# 1st Method :- Recursive (DFS) Preorder traversal \uD83D\uDD25\n\n## Intuition \uD83D\uDE80\nThe code is designed to determine if two binary trees `p` and `q` are identical or not. To consider the trees as identical, they must have the same structure, and corresponding nodes must have the same values.\n\n## Approach \uD83D\uDE80\n1. **Base Cases:**\n - The code starts with two base cases. If both `p` and `q` are `null`, this means both trees are empty, and they are considered identical. In this case, it returns `true`.\n - If one of the trees is `null` while the other is not, the trees cannot be identical, so it returns `false`.\n\n2. **Value Comparison:**\n - After handling the base cases, the code compares the values of the current nodes of `p` and `q`. If the values do not match, it means the trees are not identical, and it returns `false`.\n\n3. **Recursive Check of Left and Right Subtrees:**\n - If the values of the current nodes match, the code proceeds to recursively check the left and right subtrees of both trees.\n - The recursive call for the left subtree compares the left child of `p` with the left child of `q`.\n - The recursive call for the right subtree compares the right child of `p` with the right child of `q`.\n - The final result is computed by using the `&&` (logical AND) operator to ensure that both left and right subtrees are identical for the entire tree to be identical.\n\nBy following these steps, the code effectively checks the structure and values of the two trees to determine if they are identical or not. If all nodes match in terms of values and the tree structures are the same, it returns `true`, indicating that the trees are identical; otherwise, it returns `false`.\n\n# Code\n``` Java []\nclass Solution {\n public boolean isSameTree(TreeNode p, TreeNode q) {\n // Base case: If both trees are empty, they are identical.\n if (p == null && q == null) {\n return true;\n }\n // If one of the trees is empty and the other is not, they are not identical.\n if (p == null || q == null) {\n return false;\n }\n \n // Compare the values of the current nodes.\n if (p.val != q.val) {\n return false;\n }\n \n // Recursively check the left and right subtrees.\n return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);\n } \n}\n```\n``` C++ []\nclass Solution {\npublic:\n bool isSameTree(TreeNode* p, TreeNode* q) {\n // Base case: If both trees are empty, they are identical.\n if (p == nullptr && q == nullptr) {\n return true;\n }\n // If one of the trees is empty and the other is not, they are not identical.\n if (p == nullptr || q == nullptr) {\n return false;\n }\n \n // Compare the values of the current nodes.\n if (p->val != q->val) {\n return false;\n }\n \n // Recursively check the left and right subtrees.\n return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);\n }\n};\n```\n``` Python []\nclass Solution:\n def isSameTree(self, p, q):\n # Base case: If both trees are empty, they are identical.\n if not p and not q:\n return True\n # If one of the trees is empty and the other is not, they are not identical.\n if not p or not q:\n return False\n \n # Compare the values of the current nodes.\n if p.val != q.val:\n return False\n \n # Recursively check the left and right subtrees.\n return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)\n\n```\n``` JavaScript []\nvar isSameTree = function(p, q) {\n // Base case: If both trees are empty, they are identical.\n if (p === null && q === null) {\n return true;\n }\n\n // If one of the trees is empty and the other is not, they are not identical.\n if (p === null || q === null) {\n return false;\n }\n\n // Compare the values of the current nodes.\n if (p.val !== q.val) {\n return false;\n }\n\n // Recursively check the left and right subtrees.\n return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);\n}\n```\n``` C# []\npublic class Solution {\n public bool IsSameTree(TreeNode p, TreeNode q) {\n // Base case: If both trees are empty, they are identical.\n if (p == null && q == null) {\n return true;\n }\n\n // If one of the trees is empty and the other is not, they are not identical.\n if (p == null || q == null) {\n return false;\n }\n\n // Compare the values of the current nodes.\n if (p.val != q.val) {\n return false;\n }\n\n // Recursively check the left and right subtrees.\n return IsSameTree(p.left, q.left) && IsSameTree(p.right, q.right);\n }\n}\n```\n\n## Complexity \uD83D\uDE81\n### \uD83C\uDFF9Time complexity: O(n)\nThe time complexity of this code is O(n), where \'n\' is the number of nodes in the larger of the two trees. In the worst case, it needs to visit every node in both trees to determine if they are identical. The function performs a preorder traversal of the trees, and each node is visited exactly once.\n\n### \uD83C\uDFF9Space complexity: O(n)\nThe space complexity is O(h), where \'h\' is the height of the tree, and it represents the maximum depth of the recursion stack. In the worst case, when the trees are completely unbalanced and have a height of \'n\', the space complexity becomes O(n). However, for balanced trees, such as binary search trees, the space complexity is O(log n), where \'log n\' is the height of the tree.\n\nIt\'s important to note that the space complexity depends on the height of the tree, not just the number of nodes, and it\'s determined by the depth of the recursive function calls on the stack.\n\n![vote.jpg](https://assets.leetcode.com/users/images/3c37ecbc-23dd-4041-8ff3-232f7d6493f8_1699008828.968313.jpeg)\n\n---\n\n# 2nd Method :- level-order traversal using Queues\uD83D\uDD25\nlevel-order traversal approach to determine if two trees are the same.\n\n## Approach \uD83D\uDE80\n1. Two queues, `queue1` and `queue2`, are used to perform a level-order traversal of both trees `p` and `q`. Level-order traversal visits the nodes level by level, starting from the root.\n\n2. The root nodes of both trees `p` and `q` are added to their respective queues to begin the traversal.\n\n3. The while loop continues until both queues are empty or until a mismatch is detected.\n\n4. Inside the loop, it dequeues nodes from both queues: `node1` from `queue1` and `node2` from `queue2`.\n\n5. It checks if the values of the current nodes are equal. If they are not, the trees are not identical, and it returns `false`.\n\n6. If the values match and the nodes are not null, the left and right children of both nodes are enqueued in their respective queues.\n\n7. The traversal continues level by level until all nodes have been compared.\n\n8. After the while loop, if both queues are empty, it means that the trees are identical, and it returns `true`. If one queue is not empty while the other is, the trees are not identical, and it returns `false`.\n\nThis level-order traversal approach efficiently checks whether two trees are identical in terms of structure and values. It is based on a breadth-first search of the trees.\n\n\n## \u2712\uFE0FCode\n``` Java []\nclass Solution {\n public boolean isSameTree(TreeNode p, TreeNode q) {\n // Create queues for both trees.\n Queue queue1 = new LinkedList<>();\n Queue queue2 = new LinkedList<>();\n\n // Start by adding the root nodes of both trees to their respective queues.\n queue1.offer(p);\n queue2.offer(q);\n\n while (!queue1.isEmpty() && !queue2.isEmpty()) {\n TreeNode node1 = queue1.poll();\n TreeNode node2 = queue2.poll();\n\n // If the values of the current nodes are not equal, the trees are not identical.\n if (node1 == null && node2 == null) {\n continue;\n }\n if (node1 == null || node2 == null || node1.val != node2.val) {\n return false;\n }\n\n // Add the left and right children of both nodes to their respective queues.\n queue1.offer(node1.left);\n queue1.offer(node1.right);\n queue2.offer(node2.left);\n queue2.offer(node2.right);\n }\n\n // If both queues are empty, the trees are identical.\n return queue1.isEmpty() && queue2.isEmpty();\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n bool isSameTree(TreeNode* p, TreeNode* q) {\n // Create queues for both trees.\n std::queue queue1;\n std::queue queue2;\n\n // Start by adding the root nodes of both trees to their respective queues.\n queue1.push(p);\n queue2.push(q);\n\n while (!queue1.empty() && !queue2.empty()) {\n TreeNode* node1 = queue1.front();\n TreeNode* node2 = queue2.front();\n queue1.pop();\n queue2.pop();\n\n // If the values of the current nodes are not equal, the trees are not identical.\n if (node1 == NULL && node2 == NULL) {\n continue;\n }\n if (node1 == NULL || node2 == NULL || node1->val != node2->val) {\n return false;\n }\n\n // Add the left and right children of both nodes to their respective queues.\n queue1.push(node1->left);\n queue1.push(node1->right);\n queue2.push(node2->left);\n queue2.push(node2->right);\n }\n\n // If both queues are empty, the trees are identical.\n return queue1.empty() && queue2.empty();\n }\n};\n```\n``` Python []\nclass Solution:\n def isSameTree(self, p, q):\n # Create queues for both trees.\n queue1 = deque()\n queue2 = deque()\n\n # Start by adding the root nodes of both trees to their respective queues.\n queue1.append(p)\n queue2.append(q)\n\n while queue1 and queue2:\n node1 = queue1.popleft()\n node2 = queue2.popleft()\n\n # If the values of the current nodes are not equal, the trees are not identical.\n if not node1 and not node2:\n continue\n if not node1 or not node2 or node1.val != node2.val:\n return False\n\n # Add the left and right children of both nodes to their respective queues.\n queue1.append(node1.left)\n queue1.append(node1.right)\n queue2.append(node2.left)\n queue2.append(node2.right)\n\n # If both queues are empty, the trees are identical.\n return not queue1 and not queue2\n```\n``` JavaScript []\nvar isSameTree = function(p, q) {\n // Create queues for both trees.\n const queue1 = [p];\n const queue2 = [q];\n\n while (queue1.length > 0 && queue2.length > 0) {\n const node1 = queue1.shift();\n const node2 = queue2.shift();\n\n // If the values of the current nodes are not equal, the trees are not identical.\n if (!node1 && !node2) {\n continue;\n }\n if (!node1 || !node2 || node1.val !== node2.val) {\n return false;\n }\n\n // Add the left and right children of both nodes to their respective queues.\n queue1.push(node1.left);\n queue1.push(node1.right);\n queue2.push(node2.left);\n queue2.push(node2.right);\n }\n\n // If both queues are empty, the trees are identical.\n return queue1.length === 0 && queue2.length === 0;\n}\n```\n``` C# []\npublic class Solution {\n public bool IsSameTree(TreeNode p, TreeNode q) {\n // Create queues for both trees.\n Queue queue1 = new Queue();\n Queue queue2 = new Queue();\n\n // Start by adding the root nodes of both trees to their respective queues.\n queue1.Enqueue(p);\n queue2.Enqueue(q);\n\n while (queue1.Count > 0 && queue2.Count > 0) {\n TreeNode node1 = queue1.Dequeue();\n TreeNode node2 = queue2.Dequeue();\n\n // If the values of the current nodes are not equal, the trees are not identical.\n if (node1 == null && node2 == null) {\n continue;\n }\n if (node1 == null || node2 == null || node1.val != node2.val) {\n return false;\n }\n\n // Add the left and right children of both nodes to their respective queues.\n queue1.Enqueue(node1.left);\n queue1.Enqueue(node1.right);\n queue2.Enqueue(node2.left);\n queue2.Enqueue(node2.right);\n }\n\n // If both queues are empty, the trees are identical.\n return queue1.Count == 0 && queue2.Count == 0;\n }\n}\n```\n\n## Complexity \uD83D\uDE81\n### \uD83C\uDFF9Time complexity: O(N)\nThe code uses a level-order traversal approach, also known as a breadth-first search, to compare the two trees. In the worst case, the code visits every node once, making the time complexity O(N), where N is the total number of nodes in the larger of the two trees. This is because the code processes each node exactly once and does a constant amount of work for each node.\n\n### \uD83C\uDFF9Space complexity: O(N)\nThe space complexity of the code is determined by the space used by the two queues. In the worst case, both queues can hold all nodes of the two trees at the same level. Therefore, the space complexity is O(maxWidth), where maxWidth is the maximum width of the binary trees, which can be roughly proportional to the number of nodes at the widest level. In the worst case, the space complexity can be O(N), where N is the total number of nodes in the larger tree.\n\n\n![vote.jpg](https://assets.leetcode.com/users/images/08824924-1db3-4739-8101-bf8cd685267f_1699018273.2236676.jpeg)\n\n---\n# 3rd Method :- level-order traversal using Stack\uD83D\uDD25\n\n## Approach \uD83D\uDE80\nThis approach is called **iterative traversal-based approach** to determine if two trees are the same. Specifically, it is using **stacks** to perform a **level-order traversal** of the trees and compare the nodes iteratively.\n\nHere\'s how the code works:\n\n1. Two stacks, `stack1` and `stack2`, are used to perform a level-order traversal of the trees, starting with the root nodes `p` and `q`.\n\n2. In the while loop, the code pops the top nodes from both stacks and compares their values.\n - If both nodes are `null`, they are considered identical, and the traversal continues.\n - If one of the nodes is `null` or the values are different, the trees are not identical, and the function returns `false`.\n\n3. The code then pushes the left children of both nodes onto `stack1` and `stack2`.\n\n4. Next, it pushes the right children of both nodes onto the stacks.\n\n5. The loop continues until both stacks are empty or until a mismatch is found. If the loop completes without any mismatches and both stacks are empty, the trees are considered identical, and the function returns `true`.\n\nThis approach provides an alternative way to check if two trees are identical without using recursive function calls, making use of stacks for an iterative traversal of the trees.\n\n## \u2712\uFE0FCode\n``` Java []\nclass Solution {\n public boolean isSameTree(TreeNode p, TreeNode q) {\n Stack stack1 = new Stack<>();\n Stack stack2 = new Stack<>();\n\n // Push the root nodes of both trees onto their respective stacks.\n stack1.push(p);\n stack2.push(q);\n\n while (!stack1.isEmpty() && !stack2.isEmpty()) {\n TreeNode node1 = stack1.pop();\n TreeNode node2 = stack2.pop();\n\n // Compare the values of the current nodes.\n if (node1 == null && node2 == null) {\n // Both nodes are null, so they match.\n continue;\n } else if (node1 == null || node2 == null || node1.val != node2.val) {\n // Nodes are not identical, return false.\n return false;\n }\n\n // Push the left children onto the stacks.\n stack1.push(node1.left);\n stack2.push(node2.left);\n\n // Push the right children onto the stacks.\n stack1.push(node1.right);\n stack2.push(node2.right);\n }\n\n // If both stacks are empty, and no mismatches have been found, the trees are identical.\n return stack1.isEmpty() && stack2.isEmpty();\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n bool isSameTree(TreeNode* p, TreeNode* q) {\n std::stack stack1, stack2;\n\n // Push the root nodes of both trees onto their respective stacks.\n stack1.push(p);\n stack2.push(q);\n\n while (!stack1.empty() && !stack2.empty()) {\n TreeNode* node1 = stack1.top();\n stack1.pop();\n TreeNode* node2 = stack2.top();\n stack2.pop();\n\n // Compare the values of the current nodes.\n if (!node1 && !node2) {\n // Both nodes are null, so they match.\n continue;\n } else if (!node1 || !node2 || node1->val != node2->val) {\n // Nodes are not identical, return false.\n return false;\n }\n\n // Push the left children onto the stacks.\n stack1.push(node1->left);\n stack2.push(node2->left);\n\n // Push the right children onto the stacks.\n stack1.push(node1->right);\n stack2.push(node2->right);\n }\n\n // If both stacks are empty, and no mismatches have been found, the trees are identical.\n return stack1.empty() && stack2.empty();\n }\n};\n```\n``` Python []\nclass Solution:\n def isSameTree(self, p, q):\n stack1, stack2 = [p], [q]\n\n while stack1 and stack2:\n node1 = stack1.pop()\n node2 = stack2.pop()\n\n if not node1 and not node2:\n # Both nodes are None, so they match.\n continue\n elif not node1 or not node2 or node1.val != node2.val:\n # Nodes are not identical, return False.\n return False\n\n # Push the left children onto the stacks.\n stack1.append(node1.left)\n stack2.append(node2.left)\n\n # Push the right children onto the stacks.\n stack1.append(node1.right)\n stack2.append(node2.right)\n\n # If both stacks are empty, and no mismatches have been found, the trees are identical.\n return not stack1 and not stack2\n```\n``` JavaScript []\nvar isSameTree = function(p, q) {\n const stack1 = [p];\n const stack2 = [q];\n\n while (stack1.length > 0 && stack2.length > 0) {\n const node1 = stack1.pop();\n const node2 = stack2.pop();\n\n if (!node1 && !node2) {\n continue;\n } else if (!node1 || !node2 || node1.val !== node2.val) {\n return false;\n }\n\n stack1.push(node1.left);\n stack2.push(node2.left);\n stack1.push(node1.right);\n stack2.push(node2.right);\n }\n\n return stack1.length === 0 && stack2.length === 0;\n}\n```\n``` C# []\npublic class Solution {\n public bool IsSameTree(TreeNode p, TreeNode q) {\n Stack stack1 = new Stack();\n Stack stack2 = new Stack();\n\n stack1.Push(p);\n stack2.Push(q);\n\n while (stack1.Count > 0 && stack2.Count > 0) {\n TreeNode node1 = stack1.Pop();\n TreeNode node2 = stack2.Pop();\n\n if (node1 == null && node2 == null) {\n continue;\n } else if (node1 == null || node2 == null || node1.val != node2.val) {\n return false;\n }\n\n stack1.Push(node1.left);\n stack2.Push(node2.left);\n stack1.Push(node1.right);\n stack2.Push(node2.right);\n }\n\n return stack1.Count == 0 && stack2.Count == 0;\n }\n}\n\n```\n\n## Complexity \uD83D\uDE81\n### \uD83C\uDFF9Time complexity: O(N)\nThe algorithm involves a stack-based traversal of both trees. In the worst case, it will visit each node once. The while loop iterates through the nodes, and the key operations inside the loop (pushing and popping nodes from the stacks and comparing values) have constant time complexity. Therefore, the time complexity is linear, O(n).\n\n### \uD83C\uDFF9Space complexity: O(N)\nThe space complexity is determined by the space required for the two stacks. In the worst case, both stacks can contain all nodes of the trees. If the trees are completely unbalanced (e.g., skewed trees), both stacks can hold \'n\' nodes, leading to a space complexity of O(n).\n\nIt\'s worth noting that in the best-case scenario, where the trees are identical and perfectly balanced, the space complexity could be less than O(n). However, the worst-case space complexity is O(n) to account for all possible scenarios.\n\n![vote.jpg](https://assets.leetcode.com/users/images/d914ba0a-d6c0-43f1-9354-ea55a36896e7_1699018605.9668112.jpeg)\n\n---\n# 4th Method :- Tree Hashing\uD83D\uDD25\n\n## Approach \uD83D\uDE80\nThis approach involves generating a unique hash value for each tree by recursively encoding the structure and values of its nodes. The trees are then considered identical if their hash values are the same. Here\'s how this approach works:\n\n1. **Create a Hash for Each Tree:**\n - The `isSameTree` function takes two tree nodes, `p` and `q`, as input.\n - It calculates the hash value for each tree by calling the `computeTreeHash` function for both `p` and `q`.\n\n2. **Recursively Compute Tree Hash:**\n - The `computeTreeHash` function takes a tree node as input.\n - If the node is `null`, it returns the string "null" to represent an empty node.\n - For non-null nodes, it calculates the hash value by recursively computing the hash values of the left and right subtrees and concatenating them with the current node\'s value inside parentheses.\n\n3. **Compare Hash Values:**\n - After computing the hash values for both trees, the code compares these hash values using the `equals` method.\n - If the hash values are equal, the code returns `true`, indicating that the trees are identical; otherwise, it returns `false`.\n\nThis approach relies on the uniqueness and quality of the hash function to accurately determine if two trees are identical. It\'s important to choose a good hashing method that minimizes the risk of hash collisions. While this approach can be used to check tree identity, it may not always be as efficient as traversal-based methods for large or complex trees, as computing and comparing hash values can be time-consuming.\n\n\n## \u2712\uFE0FCode\n``` Java []\nclass Solution {\n public boolean isSameTree(TreeNode p, TreeNode q) {\n String hash1 = computeTreeHash(p);\n String hash2 = computeTreeHash(q);\n return hash1.equals(hash2);\n }\n \n private String computeTreeHash(TreeNode node) {\n if (node == null) {\n return "null";\n }\n String leftHash = computeTreeHash(node.left);\n String rightHash = computeTreeHash(node.right);\n return "(" + node.val + leftHash + rightHash + ")";\n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n bool isSameTree(TreeNode* p, TreeNode* q) {\n std::string hash1 = computeTreeHash(p);\n std::string hash2 = computeTreeHash(q);\n return hash1 == hash2;\n }\n\nprivate:\n std::string computeTreeHash(TreeNode* node) {\n if (node == nullptr) {\n return "null";\n }\n std::string leftHash = computeTreeHash(node->left);\n std::string rightHash = computeTreeHash(node->right);\n return "(" + std::to_string(node->val) + leftHash + rightHash + ")";\n }\n};\n```\n``` Python []\nclass Solution:\n def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:\n hash1 = self.computeTreeHash(p)\n hash2 = self.computeTreeHash(q)\n return hash1 == hash2\n\n def computeTreeHash(self, node: TreeNode) -> str:\n if node is None:\n return "null"\n left_hash = self.computeTreeHash(node.left)\n right_hash = self.computeTreeHash(node.right)\n return f"({node.val}{left_hash}{right_hash})"\n```\n``` JavaScript []\nvar isSameTree = function(p, q) {\n const hash1 = computeTreeHash(p);\n const hash2 = computeTreeHash(q);\n return hash1 === hash2;\n}\n\nfunction computeTreeHash(node) {\n if (node === null) {\n return "null";\n }\n const leftHash = computeTreeHash(node.left);\n const rightHash = computeTreeHash(node.right);\n return `(${node.val}${leftHash}${rightHash})`;\n}\n```\n``` C# []\npublic class Solution {\n public bool IsSameTree(TreeNode p, TreeNode q) {\n string hash1 = ComputeTreeHash(p);\n string hash2 = ComputeTreeHash(q);\n return hash1.Equals(hash2);\n }\n\n private string ComputeTreeHash(TreeNode node) {\n if (node == null) {\n return "null";\n }\n string leftHash = ComputeTreeHash(node.left);\n string rightHash = ComputeTreeHash(node.right);\n return $"({node.val}{leftHash}{rightHash})";\n }\n}\n```\n\n## Complexity \uD83D\uDE81\n### \uD83C\uDFF9Time complexity: O(N)\n- The `computeTreeHash` function performs a recursive traversal of both trees.\n- In the worst case, it visits every node of both trees.\n- The time complexity is O(n), where \'n\' is the total number of nodes in the trees.\n\n### \uD83C\uDFF9Space complexity: O(N)\n- The space complexity is determined by the space used by the recursive function calls and the space used for the string representations (hashes) of the trees.\n- In the worst case, the maximum depth of the recursion is equal to the height of the trees, which can be O(n) in an unbalanced tree.\n- Additionally, the space used for the hash strings is also O(n).\n- Therefore, the space complexity is O(n) in the worst case.\n\n---\n# Same as 1st Method but in short\n\n``` Java []\nclass Solution {\n public boolean isSameTree(TreeNode p, TreeNode q) {\n \n if (p == null || q == null) { return p == q;}\n \n return (p.val == q.val) && isSameTree(p.left, q.left) && isSameTree(p.right, q.right); \n }\n}\n```\n``` C++ []\nclass Solution {\npublic:\n bool isSameTree(TreeNode* p, TreeNode* q) {\n if (!p || !q) {\n return p == q;\n }\n return (p->val == q->val) && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);\n }\n};\n```\n``` Python []\nclass Solution:\n def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:\n if not p or not q:\n return p == q\n return (p.val == q.val) and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)\n```\n``` JavaScript []\nvar isSameTree = function(p, q) {\n if (!p || !q) {\n return p === q;\n }\n return (p.val === q.val) && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);\n}\n```\n``` C# []\npublic class Solution {\n public bool IsSameTree(TreeNode p, TreeNode q) {\n if (p == null || q == null) {\n return p == q;\n }\n return (p.val == q.val) && IsSameTree(p.left, q.left) && IsSameTree(p.right, q.right);\n }\n}\n```\n\n![upvote.png](https://assets.leetcode.com/users/images/738b30d1-b588-4b5a-b187-ef9a78f9eed3_1699018840.3116217.png)\n\n# Up Vote Guys\n\n

Same Tree

Problem Description

Problem Description

Answer Panel