add code for 653.

Author: Li Li

Algorithms Basics/Chapter 1. Array_String/167. Two Sum II - Input array is sorted/similar problem/653. Two Sum IV - Input is a BST.cs

@@ -0,0 +1,64 @@
+// HashSet + recursion traverse
+public class Solution {
+    HashSet<int> set = new HashSet<int>();
+    public bool FindTarget(TreeNode root, int k) {
+        if (root == null) {
+            return false;
+        }
+        if (set.Contains(k - root.val)) {
+            return true;
+        }
+        set.Add(root.val);
+        return FindTarget(root.left, k) || FindTarget(root.right, k);
+    }
+}
+
+// BFS + HashSet
+public class Solution {
+    public bool FindTarget(TreeNode root, int k) {
+        if (root == null) {
+            return false;
+        }
+        HashSet<int> set = new HashSet<int>();
+        Queue<TreeNode> q = new Queue<TreeNode>();
+        q.Enqueue(root);
+        while (q.Count != 0) {
+            var node = q.Dequeue();
+            if (set.Contains(k - node.val)) {
+                return true;
+            }
+            set.Add(node.val);
+            if (node.left != null) q.Enqueue(node.left);
+            if (node.right != null) q.Enqueue(node.right);
+        }
+        return false;
+    }
+}
+
+// use the feature of BST, flatten it into ordered list.
+// then use two pointer.
+public class Solution {
+    public bool FindTarget(TreeNode root, int k) {
+        if (root == null) 
+            return false;
+        var list = new List<int>();
+        TreeToList(root, list);
+        for (int l = 0, r = list.Count - 1; l < r;) {
+            int sum = list[l] + list[r];
+            if (sum == k) 
+                return true;
+            if (sum < k) 
+                l++;
+            else 
+                r--;
+        }
+        return false;
+    }
+    private void TreeToList(TreeNode root, List<int> list) {
+        if (root == null) 
+            return;
+        TreeToList(root.left, list);
+        list.Add(root.val);
+        TreeToList(root.right, list);
+    }
+}

LeetcodeCShaprDotNetCore/TreeNode.cs

@@ -0,0 +1,12 @@
+namespace LeetcodeCShaprDotNetCore
+{
+    public class TreeNode
+    {
+        public int val;
+        public TreeNode left;
+        public TreeNode right;
+        public TreeNode(int x) {
+            val = x;
+        }
+    }
+}

README.md

@@ -54,4 +54,5 @@ This problem can be solved by typical double pointer technique.
 Since the array is already sorted, we can keep two pointers *left* and *right*. let v = nums[*left*] + nums[*right*], if v < target, left++; if v > target, right--; if v == target, then return.
 
 Similar problems:
-*1.* Two Sum (use dict for O(1) check time) 
+*1.* Two Sum (use dict for each item just use almost O(1) check time, so totally O(n) time);
+*653.* Two Sum IV - Input is a BST (3 solution to revisit)