add 2096

Author: fishercoder1534

paginated_contents/algorithms/3rd_thousand/README.md

@@ -151,6 +151,7 @@
 | 2108 | [Find First Palindromic String in the Array](https://leetcode.com/problems/find-first-palindromic-string-in-the-array/)                                                                       | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2108.java)                                       || Easy                                 ||
 | 2103 | [Rings and Rods](https://leetcode.com/problems/rings-and-rods/)                                                                                                                               | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2103.java)                                       || Easy                                 ||
 | 2099 | [Find Subsequence of Length K With the Largest Sum](https://leetcode.com/problems/find-subsequence-of-length-k-with-the-largest-sum/)                                                         | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2099.java)                                       || Easy                                 ||
+| 2096 | [Step-By-Step Directions From a Binary Tree Node to Another](https://leetcode.com/problems/step-by-step-directions-from-a-binary-tree-node-to-another/)                                                                             | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2096.java)                                       || Medium                               |DFS, Tree
 | 2095 | [Delete the Middle Node of a Linked List](https://leetcode.com/problems/delete-the-middle-node-of-a-linked-list/)                                                                             | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2095.java)                                       || Medium                               ||
 | 2094 | [Finding 3-Digit Even Numbers](https://leetcode.com/problems/finding-3-digit-even-numbers/)                                                                                                   | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2094.java)                                       || Easy                                 ||
 | 2091 | [Removing Minimum and Maximum From Array](https://leetcode.com/problems/removing-minimum-and-maximum-from-array/)                                                                             | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2091.java)                                       || Medium                               ||

src/main/java/com/fishercoder/solutions/thirdthousand/_2096.java

@@ -0,0 +1,63 @@
+package com.fishercoder.solutions.thirdthousand;
+
+import com.fishercoder.common.classes.TreeNode;
+
+public class _2096 {
+    public static class Solution1 {
+        /**
+         * Steps for this problem:
+         * 1. find the path from root the start and dest respectively, mark them using two directions: 'L' and 'R', i.e. you can only go down from root, so there's no up, 'U' direction;
+         * 2. the LCA (the lowest common ancestor) of start and dest will be the joint of the shortest path;
+         * 3. find the longest common prefix of these two paths, that can be cut off;
+         * 4. reverse the startPath, so it becomes the path from start to LCA, then concatenate with destPath
+         */
+        public String getDirections(TreeNode root, int startValue, int destValue) {
+            StringBuilder sb = new StringBuilder();
+            String pathForStart = "";
+            if (findPathFromRoot(root, startValue, sb)) {
+                pathForStart = sb.toString();
+            }
+            sb.setLength(0);
+            String pathForDest = "";
+            if (findPathFromRoot(root, destValue, sb)) {
+                pathForDest = sb.toString();
+            }
+            int lastIdenticalCharIndex = -1;
+            int minLen = Math.min(pathForStart.length(), pathForDest.length());
+            for (int i = 0; i < minLen; i++) {
+                if (pathForStart.charAt(i) == pathForDest.charAt(i)) {
+                    lastIdenticalCharIndex = i;
+                } else {
+                    break;
+                }
+            }
+            sb.setLength(0);
+            sb.append(pathForStart.substring(lastIdenticalCharIndex + 1));
+            for (int i = 0; i < sb.length(); i++) {
+                if (sb.charAt(i) == 'L' || sb.charAt(i) == 'R') {
+                    sb.setCharAt(i, 'U');
+                }
+            }
+            sb.append(pathForDest.substring(lastIdenticalCharIndex + 1));
+            return sb.toString();
+        }
+
+        private boolean findPathFromRoot(TreeNode root, int target, StringBuilder sb) {
+            if (root == null) {
+                return false;
+            }
+            if (root.val == target) {
+                return true;
+            }
+            if (findPathFromRoot(root.left, target, sb.append("L"))) {
+                return true;
+            }
+            sb.setLength(sb.length() - 1);
+            if (findPathFromRoot(root.right, target, sb.append("R"))) {
+                return true;
+            }
+            sb.setLength(sb.length() - 1);
+            return false;
+        }
+    }
+}

src/test/java/com/fishercoder/thirdthousand/_2096Test.java

@@ -0,0 +1,49 @@
+package com.fishercoder.thirdthousand;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions.thirdthousand._2096;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class _2096Test {
+    private static _2096.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _2096.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        TreeNode root = TreeUtils.constructBinaryTree(Arrays.asList(5, 1, 2, 3, null, 6, 4));
+        TreeUtils.printBinaryTree(root);
+        assertEquals("UURL", solution1.getDirections(root, 3, 6));
+    }
+
+    @Test
+    public void test2() {
+        TreeNode root = TreeUtils.constructBinaryTree(Arrays.asList(2, 1));
+        TreeUtils.printBinaryTree(root);
+        assertEquals("L", solution1.getDirections(root, 2, 1));
+    }
+
+    @Test
+    public void test3() {
+        TreeNode root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2));
+        TreeUtils.printBinaryTree(root);
+        assertEquals("U", solution1.getDirections(root, 2, 1));
+    }
+
+    @Test
+    public void test4() {
+        TreeNode root = TreeUtils.constructBinaryTree(Arrays.asList(5, 8, 3, 1, null, 4, 7, 6, null, null, null, null, null, null, 2));
+        TreeUtils.printBinaryTree(root);
+        assertEquals("U", solution1.getDirections(root, 4, 3));
+    }
+
+}