Accepted Solutions

Author: gouthampradhan

README.md

@@ -249,6 +249,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [One Edit Distance](problems/src/string/OneEditDistance.java) (Medium)
 - [Count and Say](problems/src/string/CountAndSay.java) (Easy)
 - [Multiply Strings](problems/src/string/MultiplyStrings.java) (Medium)
+- [Longest Word in Dictionary through Deleting](problems/src/string/LongestWordInDictonary.java) (Medium)
 
 #### [Tree](problems/src/tree)
 
@@ -285,6 +286,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Convert Binary Search Tree to Sorted Doubly Linked List](problems/src/tree/BSTtoDoublyLinkedList.java) (Easy)
 - [Same Tree](problems/src/tree/SameTree.java) (Easy)
 - [Binary Tree Longest Consecutive Sequence II](problems/src/tree/BinaryTreeLongestConsecutiveSequenceII.java) (Medium)
+- [Minimum Absolute Difference in BST](problems/src/tree/MinimumAbsoluteDifferenceInBST.java) (Medium)
 
 #### [Two Pointers](problems/src/two_pointers)
 

problems/src/string/LongestWordInDictonary.java

@@ -0,0 +1,60 @@
+package string;
+
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 15/02/2018.
+ * Given a string and a string dictionary, find the longest string in the dictionary that can be formed by deleting
+ * some characters of the given string. If there are more than one possible results, return the longest word with the
+ * smallest lexicographical order. If there is no possible result, return the empty string.
+
+ Example 1:
+ Input:
+ s = "abpcplea", d = ["ale","apple","monkey","plea"]
+
+ Output:
+ "apple"
+ Example 2:
+ Input:
+ s = "abpcplea", d = ["a","b","c"]
+
+ Output:
+ "a"
+ Note:
+ All the strings in the input will only contain lower-case letters.
+ The size of the dictionary won't exceed 1,000.
+ The length of all the strings in the input won't exceed 1,000.
+
+ Solution: O((n x m x log n) + (m ^ 2 + m x n))) sort the dictionary based on the longest first and then
+ lexicographically and compare each sorted word with given word and do a two pointer comparison to check for
+ sub-sequence.
+ */
+public class LongestWordInDictonary {
+
+    /**
+     * Main method
+     * @param args
+     */
+    public static void main(String[] args) throws Exception{
+        List<String> dict = Arrays.asList("ale","apple","monkey","plea");
+        System.out.println(new LongestWordInDictonary().findLongestWord("abpcplea", dict));
+    }
+
+    public String findLongestWord(String s, List<String> d) {
+        Collections.sort(d, Comparator.comparing(String::length).reversed().thenComparing(String::compareTo));
+        for(String str : d){
+            if(str.length() <= s.length()){
+                int i = 0, j = 0;
+                for(int l1 = s.length(), l2 = str.length(); i < l1 && j < l2; ){
+                    if(s.charAt(i) == str.charAt(j)){
+                        i++; j++;
+                    } else{
+                        i++;
+                    }
+                }
+                if(j >= str.length()) return str;
+            }
+        }
+        return "";
+    }
+}

problems/src/tree/MinimumAbsoluteDifferenceInBST.java

@@ -0,0 +1,57 @@
+package tree;
+
+/**
+ * Created by gouthamvidyapradhan on 15/02/2018.
+ * Given a binary search tree with non-negative values, find the minimum absolute difference between values of any
+ * two nodes.
+
+ Example:
+
+ Input:
+
+ 1
+ \
+ 3
+ /
+ 2
+
+ Output:
+ 1
+
+ Explanation:
+ The minimum absolute difference is 1, which is the difference between 2 and 1 (or between 2 and 3).
+ Note: There are at least two nodes in this BST.
+ */
+public class MinimumAbsoluteDifferenceInBST {
+
+    public static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+
+    int min = Integer.MAX_VALUE;
+
+    public static void main(String[] args) throws Exception{
+        TreeNode root = new TreeNode(1);
+        root.right = new TreeNode(2);
+        root.right.right = new TreeNode(3);
+        new MinimumAbsoluteDifferenceInBST().getMinimumDifference(root);
+    }
+
+    public int getMinimumDifference(TreeNode root) {
+        getMin(root, null);
+        return min;
+    }
+
+    private Integer getMin(TreeNode node, Integer prev){
+        if(node == null) return prev;
+        Integer left = getMin(node.left, prev);
+        if(left != null){
+            min = Math.min(min, Math.abs(node.val - left));
+        }
+        return getMin(node.right, node.val);
+    }
+
+}