edit 653

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_653.java

@@ -1,9 +1,12 @@
 package com.fishercoder.solutions;
 
 import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.Notes;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * 653. Two Sum IV - Input is a BST
@@ -59,4 +62,35 @@ private void dfs(TreeNode root, List<Integer> list) {
             }
         }
     }
+
+    @Notes(todo = "This solution fails by _653Test.test6(), need to fix it.")
+    public static class MapSolution {
+        public boolean findTarget(TreeNode root, int k) {
+            if (root == null) return false;
+            Map<Integer, Integer> map = new HashMap();//value is index
+            int index = 0;
+            preorder(root, map, index);
+            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+                if (map.containsKey(k - entry.getKey()) &&
+                        map.get(k - entry.getKey()) != entry.getValue()) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private void preorder(TreeNode root, Map<Integer, Integer> map, int index) {
+            if (root == null) {
+                return;
+            }
+            map.put(root.val, index++);
+            if (root.left != null) {
+                preorder(root.left, map, ++index);
+            }
+            if (root.right != null) {
+                preorder(root.right, map, ++index);
+            }
+        }
+
+    }
 }

src/test/java/com/fishercoder/_653Test.java

@@ -1,21 +1,27 @@
 package com.fishercoder;
 
 import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
 import com.fishercoder.solutions._653;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+
 import static junit.framework.Assert.assertEquals;
 
 public class _653Test {
     private static _653.ListSolution listSolution;
+    private static _653.MapSolution mapSolution;
     private static boolean expected;
     private static TreeNode root;
 
     @BeforeClass
     public static void setup(){
         listSolution = new _653.ListSolution();
+        mapSolution = new _653.MapSolution();
     }
 
     @Before
@@ -25,51 +31,70 @@ public void setupForEachTest(){
 
     @Test
     public void test1(){
-        root = new TreeNode(5);
-        root.left = new TreeNode(3);
-        root.left.left = new TreeNode(2);
-        root.left.right = new TreeNode(4);
-        root.right = new TreeNode(6);
-        root.right.right = new TreeNode(7);
+        root = TreeUtils.constructBinaryTree(new ArrayList<>(Arrays.asList(5, 3, 2, 4, 6, 7)));
         expected = true;
         assertEquals(expected, listSolution.findTarget(root, 9));
+        assertEquals(expected, mapSolution.findTarget(root, 9));
     }
 
     @Test
     public void test2(){
-        root = new TreeNode(2);
-        root.left = new TreeNode(1);
-        root.right = new TreeNode(3);
+        root = TreeUtils.constructBinaryTree(new ArrayList<>(Arrays.asList(2, 1, 3)));
         expected = true;
         assertEquals(expected, listSolution.findTarget(root, 4));
+        assertEquals(expected, mapSolution.findTarget(root, 4));
     }
 
     @Test
     public void test3(){
         root = new TreeNode(1);
         expected = false;
         assertEquals(expected, listSolution.findTarget(root, 2));
+        assertEquals(expected, mapSolution.findTarget(root, 2));
     }
 
     @Test
     public void test4(){
-        root = new TreeNode(2);
-        root.left = new TreeNode(0);
-        root.left.left = new TreeNode(-4);
-        root.left.right = new TreeNode(1);
-        root.right = new TreeNode(3);
+        /**
+         *       2
+         *      / \
+         *     0   3
+         *    / \
+         *   -4  1
+         *
+         *   target = 1;
+         *   expected = true;
+         * */
+
+        root = TreeUtils.constructBinaryTree(new ArrayList<>(Arrays.asList(2, 0, -4, 1, 3)));
         expected = true;
         assertEquals(expected, listSolution.findTarget(root, -1));
+        assertEquals(expected, mapSolution.findTarget(root, -1));
     }
 
     @Test
     public void test5(){
-        TreeNode root = new TreeNode(2);
-        root.left = new TreeNode(1);
-        root.right = new TreeNode(3);
-        root.left.left = new TreeNode(-4);
-        root.left.left.right = new TreeNode(0);
+        root = TreeUtils.constructBinaryTree(new ArrayList<>(Arrays.asList(2, 1, 3, -4, 0)));
         expected = true;
         assertEquals(expected, listSolution.findTarget(root, 2));
+        assertEquals(expected, mapSolution.findTarget(root, 2));
+    }
+
+    @Test
+    public void test6(){
+        root = TreeUtils.constructBinaryTree(new ArrayList<>(Arrays.asList(
+                3393, 2264, 4972, 1908, 3252, 4128, 5140, 965, 2018,
+                3082, null, 3838, 4196, 5085, null, 559, 1187, null, 2143, 2968,
+                null, 3810, 3957, null, 4825, null, null, 0, 908, 1135, 1659, null,
+                null, 2764, null, 3581, null, null, 4106, 4498, null, null,
+                498, 821, null, null, null, 1262, 1826, 2513, 2910, 3486, 3708,
+                null, null, 4377, 4673, 231, null, null, null, null, 1482,
+                null, null, 2386, 2690, null, null, null, null, null, null, 4349, null,
+                null, null, 170, 376, 1421, 1613, null, null, 2534, null,
+                null, null, 96, null, null, null, 1303)));
+        expected = true;
+        assertEquals(expected, listSolution.findTarget(root, 5831));
+        TreeUtils.printBinaryTree(root);
+//        assertEquals(expected, mapSolution.findTarget(root, 5831));
     }
 }