Modified 2 solutions

Author: varunu28

Easy/Longest Word in Dictionary.java

@@ -1,16 +1,51 @@
 class Solution {
-    public String longestWord(String[] words) {
-        Arrays.sort(words);
-        
-        Set<String> built = new HashSet<String>();
-        String ans = "";
-        
-        for (String word : words) {
-            if (word.length() == 1 || built.contains(word.substring(0, word.length() - 1))) {
-                ans = word.length() > ans.length() ? word : ans;
-                built.add(word);
-            }
-        }
-        return ans;
+  Map<Integer, List<String>> map;
+  int maxVal;
+  public String longestWord(String[] words) {
+    map = new HashMap<>();
+    maxVal = Integer.MIN_VALUE;
+    Node root = new Node('-');
+    Arrays.sort(words);
+    for (String word : words) {
+      addWord(word, root, 0);
     }
+    if (maxVal == Integer.MIN_VALUE) {
+      return "";
+    }
+    List<String> possibleAns = map.get(maxVal);
+    Collections.sort(possibleAns);
+    return possibleAns.get(0);
+  }
+  
+  private void addWord(String word, Node root, int idx) {
+    char c = word.charAt(idx);
+    if (!root.children.containsKey(c) && idx != word.length() - 1) {
+      return;
+    }
+    if (!root.children.containsKey(c)) {
+      root.children.put(c, new Node(c));
+    }
+    root = root.children.get(c);
+    if (idx == word.length() - 1) {
+      root.isWord = true;
+      int wordLength = word.length();
+      map.computeIfAbsent(wordLength, k -> new ArrayList<>()).add(word);
+      maxVal = Math.max(maxVal, wordLength);
+    }
+    else {
+      addWord(word, root, idx + 1);
+    }
+  }
+}
+
+class Node {
+  char val;
+  boolean isWord;
+  Map<Character, Node> children;
+  
+  public Node(char val) {
+    this.val = val;
+    isWord = true;
+    children = new HashMap<>();
+  }
 }

Medium/Contiguous Array.java

@@ -1,20 +1,18 @@
 class Solution {
-    public int findMaxLength(int[] nums) {  
-        Map<Integer, Integer> map = new HashMap<>();
-        map.put(0, -1);
-        int maxLen = 0;
-        int count = 0;
-        
-        for (int i=0; i<nums.length; i++) {
-            count += nums[i] == 0 ? -1 : 1;
-            if (map.containsKey(count)) {
-                maxLen = Math.max(maxLen, i-map.get(count));
-            }
-            else {
-                map.put(count, i);
-            }
-        }
-        
-        return maxLen;
+  public int findMaxLength(int[] nums) {
+    Map<Integer, Integer> map = new HashMap<>();
+    map.put(0, -1);
+    int maxLen = 0;
+    int count = 0;
+    for (int i = 0; i < nums.length; i++) {
+      count += nums[i] == 0 ? -1 : 1;
+      if (map.containsKey(count)) {
+        maxLen = Math.max(maxLen, i - map.get(count));
+      }
+      else {
+        map.put(count, i);
+      }
     }
+    return maxLen;
+  }
 }