Modified 4 solutions

Author: varunu28

Medium/Bulb Switcher.java

@@ -1,5 +1,5 @@
 class Solution {
-    public int bulbSwitch(int n) {
-        return (int)Math.sqrt(n);
-    }
+  public int bulbSwitch(int n) {
+    return (int) Math.sqrt(n);
+  }
 }

Medium/Kth Smallest Element in a BST.java

@@ -4,29 +4,28 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public int kthSmallest(TreeNode root, int k) {
-        Stack<TreeNode> stack = new Stack<>();
-        
-        while (root != null || !stack.empty()) {
-            while (root != null) {
-                stack.push(root);
-                root = root.left;
-            }
-            
-            root = stack.peek();
-            stack.pop();
-            
-            if (--k == 0) {
-                return root.val;
-            }
-            
-            root = root.right;
-        }
-        
-        return -1;
+  public int kthSmallest(TreeNode root, int k) {
+    Stack<TreeNode> stack = new Stack<>();
+    while (true) {
+      while (root != null) {
+        stack.push(root);
+        root = root.left;
+      }
+      root = stack.pop();
+      if (--k == 0) {
+        return root.val;
+      }
+      root = root.right;
     }
+  }
 }

Medium/Pow.java

@@ -1,5 +1,18 @@
 class Solution {
-    public double myPow(double x, int n) {
-        return Math.pow(x,n);
+  public double myPow(double x, int n) {
+    long N = n;
+    if (N < 0) {
+      x = 1 / x;
+      N = -N;
     }
+    double ans = 1;
+    double currProd = x;
+    for (long i = N; i > 0; i /= 2) {
+      if ((i % 2) == 1) {
+        ans = ans * currProd;
+      }
+      currProd = currProd * currProd;
+    }
+    return ans;
+  }
 }

Medium/Reconstruct Itinerary.java

@@ -2,24 +2,24 @@ class Solution {
   List<String> result = null;
   public List<String> findItinerary(List<List<String>> tickets) {
     Map<String, List<String>> map = new HashMap<>();
-    Map<String, boolean[]> visitMap = new HashMap<>();
     int flights = tickets.size();
     for (List<String> ticket : tickets) {
       map.computeIfAbsent(ticket.get(0), k -> new ArrayList<>()).add(ticket.get(1));
     }
+    Map<String, boolean[]> visited = new HashMap<>();
     for (Map.Entry<String, List<String>> entry : map.entrySet()) {
       Collections.sort(entry.getValue());
-      visitMap.put(entry.getKey(), new boolean[entry.getValue().size()]);
+      visited.put(entry.getKey(), new boolean[entry.getValue().size()]);
     }
     LinkedList<String> route = new LinkedList<String>();
     route.add("JFK");
-    backtrack(map, visitMap, flights, route, "JFK");
+    backtrack(map, visited, flights, route, "JFK");
     return result;
   }
 
   private boolean backtrack(
     Map<String, List<String>> map,
-    Map<String, boolean[]> visitMap,
+    Map<String, boolean[]> visited,
     int flights,
     LinkedList<String> route,
     String origin
@@ -31,20 +31,18 @@ private boolean backtrack(
     if (!map.containsKey(origin)) {
       return false;
     }
-    int i = 0;
-    boolean[] visited = visitMap.get(origin);
-    for (String dest : map.get(origin)) {
-      if (!visited[i]) {
-        visited[i] = true;
-        route.add(dest);
-        boolean res = backtrack(map, visitMap, flights, route, dest);
+    boolean[] visit = visited.get(origin);
+    for (int i = 0; i < map.get(origin).size(); i++) {
+      if (!visit[i]) {
+        visit[i] = true;
+        route.add(map.get(origin).get(i));
+        boolean res = backtrack(map, visited, flights, route, map.get(origin).get(i));
         route.pollLast();
-        visited[i] = false;
-        if (res == true) {
-          return true;
+        visit[i] = false;
+        if (res) {
+          return res;
         }
       }
-      i++;
     }
     return false;
   }