add a solution for 987

Author: fishercoder1534

Diff for: src/main/java/com/fishercoder/solutions/_987.java

@@ -2,10 +2,7 @@
 
 import com.fishercoder.common.classes.TreeNode;
 
-import java.util.List;
-import java.util.ArrayList;
-import java.util.PriorityQueue;
-import java.util.TreeMap;
+import java.util.*;
 
 public class _987 {
     public static class Solution1 {
@@ -42,4 +39,64 @@ private void dfs(TreeNode root, int x, int y, TreeMap<Integer, TreeMap<Integer,
             dfs(root.right, x + 1, y + 1, map);
         }
     }
+
+    public static class Solution2 {
+
+        /**
+         * My completely original solution on 6/13/2024.
+         */
+        public List<List<Integer>> verticalTraversal(TreeNode root) {
+            TreeMap<Integer, List<NodeWithCoords>> map = new TreeMap<>();
+            Queue<NodeWithCoords> q = new LinkedList<>();
+            q.offer(new NodeWithCoords(root, 0, 0));
+            while (!q.isEmpty()) {
+                int size = q.size();
+                for (int i = 0; i < size; i++) {
+                    NodeWithCoords curr = q.poll();
+                    int col = curr.col;
+                    int row = curr.row;
+                    List<NodeWithCoords> list = map.getOrDefault(col, new ArrayList<>());
+                    list.add(curr);
+                    map.put(col, list);
+                    if (curr.node.left != null) {
+                        q.offer(new NodeWithCoords(curr.node.left, row + 1, col - 1));
+                    }
+                    if (curr.node.right != null) {
+                        q.offer(new NodeWithCoords(curr.node.right, row + 1, col + 1));
+                    }
+                }
+            }
+            List<List<Integer>> result = new ArrayList<>();
+            for (Integer key : map.keySet()) {
+                List<NodeWithCoords> list = map.get(key);
+                Collections.sort(list, (a, b) -> {
+                    if (a.row != b.row) {
+                        return a.row - b.row;
+                    } else if (a.col != b.col) {
+                        return a.col - b.col;
+                    } else {
+                        return a.node.val - b.node.val;
+                    }
+                });
+                List<Integer> intList = new ArrayList<>();
+                for (NodeWithCoords nodeWithCoords : list) {
+                    intList.add(nodeWithCoords.node.val);
+                }
+                result.add(intList);
+            }
+            return result;
+        }
+
+        class NodeWithCoords {
+            TreeNode node;
+            int row;
+            int col;
+
+            public NodeWithCoords(TreeNode node, int row, int col) {
+                this.node = node;
+                this.row = row;
+                this.col = col;
+            }
+        }
+    }
 }

Diff for: src/test/java/com/fishercoder/_987Test.java

@@ -3,23 +3,25 @@
 import com.fishercoder.common.classes.TreeNode;
 import com.fishercoder.common.utils.TreeUtils;
 import com.fishercoder.solutions._987;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 import java.util.List;
 
-import static junit.framework.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class _987Test {
     private static _987.Solution1 solution1;
+    private static _987.Solution2 solution2;
     private static TreeNode root;
     private static List<List<Integer>> expected;
     private static List<List<Integer>> actual;
 
-    @BeforeClass
-    public static void setup() {
+    @BeforeEach
+    public void setup() {
         solution1 = new _987.Solution1();
+        solution2 = new _987.Solution2();
     }
 
     @Test
@@ -28,6 +30,8 @@ public void test1() {
         expected = Arrays.asList(Arrays.asList(9), Arrays.asList(3, 15), Arrays.asList(20), Arrays.asList(7));
         actual = solution1.verticalTraversal(root);
         assertEquals(expected, actual);
+        actual = solution2.verticalTraversal(root);
+        assertEquals(expected, actual);
     }
 
     @Test