feat: add solutions to lc problem: No.0653

No.0653.Two Sum IV - Input is a BST

Author: YangFong

solution/0600-0699/0653.Two Sum IV - Input is a BST/README.md

@@ -139,6 +139,40 @@ function find(root: TreeNode | null, k: number, nodes: Set<number>): boolean {
 }
 ```
 
+```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 findTarget(root: TreeNode | null, k: number): boolean {
+    if (root == null) {
+      return false;
+    }
+    const set = new Set<number>();
+    const dfs = (root: TreeNode | null) => {
+        if (root == null) {
+          return false;
+        }
+        if (set.has(root.val)) {
+          return true;
+        }
+        set.add(k - root.val);
+        return dfs(root.left) || dfs(root.right);
+    };
+    return dfs(root);
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -199,6 +233,51 @@ func findTarget(root *TreeNode, k int) bool {
 }
 ```
 
+### **Rust**
+
+```rust
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::collections::{HashSet, VecDeque};
+impl Solution {
+    pub fn find_target(root: Option<Rc<RefCell<TreeNode>>>, k: i32) -> bool {
+        let mut set = HashSet::new();
+        let mut q = VecDeque::new();
+        q.push_back(root);
+        while let Some(node) = q.pop_front() {
+            if let Some(node) = node {
+                let mut node = node.as_ref().borrow_mut();
+                if set.contains(&node.val) {
+                    return true;
+                }
+                set.insert(k - node.val);
+                q.push_back(node.left.take());
+                q.push_back(node.right.take());
+            }
+        }
+        false
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0653.Two Sum IV - Input is a BST/README_EN.md

@@ -127,6 +127,40 @@ function find(root: TreeNode | null, k: number, nodes: Set<number>): boolean {
 }
 ```
 
+```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 findTarget(root: TreeNode | null, k: number): boolean {
+    if (root == null) {
+      return false;
+    }
+    const set = new Set<number>();
+    const dfs = (root: TreeNode | null) => {
+        if (root == null) {
+          return false;
+        }
+        if (set.has(root.val)) {
+          return true;
+        }
+        set.add(k - root.val);
+        return dfs(root.left) || dfs(root.right);
+    };
+    return dfs(root);
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -187,6 +221,51 @@ func findTarget(root *TreeNode, k int) bool {
 }
 ```
 
+### **Rust**
+
+```rust
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::collections::{HashSet, VecDeque};
+impl Solution {
+    pub fn find_target(root: Option<Rc<RefCell<TreeNode>>>, k: i32) -> bool {
+        let mut set = HashSet::new();
+        let mut q = VecDeque::new();
+        q.push_back(root);
+        while let Some(node) = q.pop_front() {
+            if let Some(node) = node {
+                let mut node = node.as_ref().borrow_mut();
+                if set.contains(&node.val) {
+                    return true;
+                }
+                set.insert(k - node.val);
+                q.push_back(node.left.take());
+                q.push_back(node.right.take());
+            }
+        }
+        false
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0653.Two Sum IV - Input is a BST/Solution.rs

@@ -0,0 +1,40 @@
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::cell::RefCell;
+use std::collections::{HashSet, VecDeque};
+use std::rc::Rc;
+impl Solution {
+    pub fn find_target(root: Option<Rc<RefCell<TreeNode>>>, k: i32) -> bool {
+        let mut set = HashSet::new();
+        let mut q = VecDeque::new();
+        q.push_back(root);
+        while let Some(node) = q.pop_front() {
+            if let Some(node) = node {
+                let mut node = node.as_ref().borrow_mut();
+                if set.contains(&node.val) {
+                    return true;
+                }
+                set.insert(k - node.val);
+                q.push_back(node.left.take());
+                q.push_back(node.right.take());
+            }
+        }
+        false
+    }
+}