Solution Added by Achhuta Nand Jha (anjha)

Author: anjha1

Diff for: 0458.poor-pigs/PoorPigs.java

@@ -0,0 +1,10 @@
+class PoorPigs {
+    public int poorPigs(int buckets, int minutesToDie, int minutesToTest) {
+        int testBuckets = minutesToTest / minutesToDie;
+        int pigs = 0;
+        while (Math.pow(testBuckets + 1, pigs) < buckets) {
+            pigs++;
+        }
+        return pigs;
+    }
+}

Diff for: 0458.poor-pigs/README.md

@@ -0,0 +1,2 @@
+# [458. Poor Pigs](https://leetcode.com/problems/poor-pigs/)
+

Diff for: 0461.hamming-distance/HammingDistance.java

@@ -0,0 +1,11 @@
+class HammingDistance {
+    public int hammingDistance(int x, int y) {
+        int z = x ^ y;
+        int cnt = 0;
+        while (z != 0) {
+            if ((z & 1) == 1) cnt++;
+            z = z >> 1;
+        }
+        return cnt;
+    }
+}

Diff for: 0461.hamming-distance/README.md

@@ -0,0 +1,2 @@
+# [461. Hamming Distance](https://leetcode.com/problems/hamming-distance/)
+

Diff for: 0462.minimum-moves-to-equal-array-elements-ii/MinimumMovesToEqualArrayElementsIi.java

@@ -0,0 +1,14 @@
+import java.util.Arrays;
+
+class MinimumMovesToEqualArrayElementsIi {
+    public int minMoves2(int[] nums) {
+        int l = nums.length;
+        Arrays.sort(nums);
+        int m = nums.length % 2 == 0 ? (nums[l / 2] + nums[l / 2 - 1]) / 2 : nums[l / 2];
+        int steps = 0;
+        for (int num : nums) {
+            steps += Math.abs(num - m);
+        }
+        return steps;
+    }
+}

Diff for: 0462.minimum-moves-to-equal-array-elements-ii/README.md

@@ -0,0 +1,2 @@
+# [462. Minimum Moves to Equal Array Elements II](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/)
+

Diff for: 0472.concatenated-words/ConcatenatedWords.java

@@ -0,0 +1,65 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class ConcatenatedWords {
+    WordTrie trie = new WordTrie();
+
+    public List<String> findAllConcatenatedWordsInADict(String[] words) {
+        List<String> ans = new ArrayList<>();
+        Arrays.sort(words, (a, b) -> a.length() - b.length());
+        for (int i = 0; i < words.length; i++) {
+            String word = words[i];
+            if (word.length() == 0)
+                continue;
+            boolean[] visited = new boolean[word.length()];
+            if (dfs(word, 0, visited))
+                ans.add(word);
+            else
+                insert(word);
+        }
+        return ans;
+    }
+
+    private boolean dfs(String word, int start, boolean[] visited) {
+        if (word.length() == start)
+            return true;
+        if (visited[start])
+            return false;
+        visited[start] = true;
+        WordTrie node = trie;
+        for (int i = start; i < word.length(); i++) {
+            char c = word.charAt(i);
+            int index = c - 'a';
+            node = node.children[index];
+            if (node == null)
+                return false;
+            if (node.isEnd)
+                if (dfs(word, i + 1, visited))
+                    return true;
+        }
+        return false;
+    }
+
+    private void insert(String word) {
+        WordTrie node = trie;
+        for (int i = 0; i < word.length(); i++) {
+            char c = word.charAt(i);
+            int index = c - 'a';
+            if (node.children[index] == null)
+                node.children[index] = new WordTrie();
+            node = node.children[index];
+        }
+        node. isEnd = true;
+    }
+}
+
+class WordTrie {
+    WordTrie[] children;
+    boolean isEnd;
+
+    public WordTrie() {
+        children = new WordTrie[26];
+        isEnd = false;
+    }
+}

Diff for: 0472.concatenated-words/README.md

@@ -0,0 +1,8 @@
+# [472. Concatenated Words](https://leetcode.com/problems/concatenated-words/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\log n + m)$. $n$ is the length of `words`. $m$ is the length of the longest string in the array `words`. Sort words costs $O(n\log n)$ and determine a word is concatenated word costs $O(m)$. The total time complexity is $O(n\log n + m)$
+- Space Complexity: $O(m\times n)$. We have $n$ words and the worst case is all words with $m$ length. Thus, the total space complexity is $O(m\times n)$.

Diff for: 0473.matchsticks-to-square/MatchsticksToSquare.java

@@ -0,0 +1,41 @@
+import java.util.Arrays;
+
+class MatchsticksToSquare {
+    private void reverse(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            int tmp = nums[left];
+            nums[left] = nums[right];
+            nums[right] = tmp;
+            left++;
+            right--;
+        }
+    }
+
+    private boolean dfs(int[] nums, int[] sums, int index, int target) {
+        if (index == nums.length) {
+            return sums[0] == target && sums[1] == target && sums[2] == target;
+        }
+        for (int i = 0; i < 4; i++) {
+            if (sums[i] + nums[index] > target) continue;
+            sums[i] += nums[index];
+            if (dfs(nums, sums, index + 1, target)) return true;
+            sums[i] -= nums[index];
+        }
+        return false;
+    }
+
+    public boolean makesquare(int[] matchsticks) {
+        if (matchsticks == null || matchsticks.length < 4) return false;
+        int l = matchsticks.length;
+        int perimeter = 0;
+        for (int i = 0; i < l; i++) {
+            perimeter += matchsticks[i];
+        }
+        if (perimeter % 4 != 0) return false;
+        Arrays.sort(matchsticks);
+        reverse(matchsticks);
+        return dfs(matchsticks, new int[4], 0, perimeter / 4);
+    }
+}

Diff for: 0473.matchsticks-to-square/README.md

@@ -0,0 +1,2 @@
+# [473. Matchsticks to Square](https://leetcode.com/problems/matchsticks-to-square/)
+

Diff for: 0476.number-complement/NumberComplement.java

@@ -0,0 +1,9 @@
+class NumberComplement {
+    public int findComplement(int num) {
+        if (num == 0) return 1;
+        int mask = 1 << 30;
+        while ((mask & num) == 0) mask >>= 1;
+        mask = (mask << 1) - 1;
+        return num ^ mask;
+    }
+}

Diff for: 0476.number-complement/README.md

@@ -0,0 +1,2 @@
+# [476. Number Complement](https://leetcode.com/problems/number-complement/)
+

Diff for: 0485.max-consecutive-ones/MaxConsecutiveOnes.java

@@ -0,0 +1,10 @@
+class MaxConsecutiveOnes {
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int max = 0, cur = 0;
+        for (int num : nums) {
+            cur = num == 0 ? 0 : cur + 1;
+            max = Math.max(max, cur);
+        }
+        return max;
+    }
+}

Diff for: 0485.max-consecutive-ones/README.md

@@ -0,0 +1,2 @@
+# [485. Max Consecutive Ones](https://leetcode.com/problems/max-consecutive-ones/)
+

Diff for: 0501.find-mode-in-binary-search-tree/FindModeInBinarySearchTree.java

@@ -0,0 +1,52 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class FindModeInBinarySearchTree {
+    private int curCnt = 1;
+    private int maxCnt = 1;
+    private TreeNode preNode = null;
+
+    private void inOrder(TreeNode node, List<Integer> nums) {
+        if (node == null) return;
+        inOrder(node.left, nums);
+        if (preNode != null) {
+            if (preNode.val == node.val) curCnt++;
+            else curCnt = 1;
+        }
+        if (curCnt > maxCnt) {
+            maxCnt = curCnt;
+            nums.clear();
+            nums.add(node.val);
+        } else if (curCnt == maxCnt) {
+            nums.add(node.val);
+        }
+        preNode = node;
+        inOrder(node.right, nums);
+    }
+
+    public int[] findMode(TreeNode root) {
+        List<Integer> maxCntNums = new ArrayList<>();
+        inOrder(root, maxCntNums);
+        int[] ret = new int[maxCntNums.size()];
+        int idx = 0;
+        for (int num : maxCntNums) {
+            ret[idx++] = num;
+        }
+        return ret;
+    }
+}

Diff for: 0501.find-mode-in-binary-search-tree/README.md

@@ -0,0 +1,2 @@
+# [501. Find Mode in Binary Search Tree](https://leetcode.com/problems/find-mode-in-binary-search-tree/)
+

Diff for: 0502.ipo/Ipo.java

@@ -0,0 +1,30 @@
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+class Ipo {
+    public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
+        int n = profits.length;
+        int curr = 0;
+        int[][] arr = new int[n][2];
+
+        for (int i = 0; i < n; i++) {
+            arr[i][0] = capital[i];
+            arr[i][1] = profits[i];
+        }
+        Arrays.sort(arr, Comparator.comparingInt(a -> a[0]));
+
+        PriorityQueue<Integer> pq = new PriorityQueue<>((x, y) -> y - x);
+        for (int i = 0; i < k; i++) {
+            while (curr < n && arr[curr][0] <= w) {
+                pq.add(arr[curr][1]);
+                curr++;
+            }
+            if (!pq.isEmpty())
+                w += pq.poll();
+            else
+                break;
+        }
+        return w;
+    }
+}

Diff for: 0502.ipo/README.md

@@ -0,0 +1,8 @@
+# [502. IPO](https://leetcode.com/problems/ipo/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `profits` and `capitals`. Sorting array costs $O(n\log n)$ and adding an element to heap and sorting heap costs $O(k\log n)$. The total time complexity is $O((n+k)\log n)$.
+- Space Complexity: $O(n)$.

Diff for: 0503.next-greater-element-ii/NextGreaterElementIi.java

@@ -0,0 +1,21 @@
+import java.util.Arrays;
+import java.util.Stack;
+
+class NextGreaterElementIi {
+    public int[] nextGreaterElements(int[] nums) {
+        int n = nums.length;
+        int[] next = new int[n];
+        Arrays.fill(next, -1);
+        Stack<Integer> pre = new Stack<>();
+        for (int i = 0; i < 2 * n; i++) {
+            int num = nums[i % n];
+            while (!pre.isEmpty() && nums[pre.peek()] < num) {
+                next[pre.pop()] = num;
+            }
+            if (i < n) {
+                pre.push(i);
+            }
+        }
+        return next;
+    }
+}

Diff for: 0503.next-greater-element-ii/README.md

@@ -0,0 +1,2 @@
+# [503. Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii/)
+

Diff for: 0509.fibonacci-number/FibonacciNumber.java

@@ -0,0 +1,7 @@
+class FibonacciNumber {
+    public int fib(int n) {
+        if (n == 0) return 0;
+        if (n == 1) return 1;
+        return fib(n - 1) + fib(n - 2);
+    }
+}

Diff for: 0509.fibonacci-number/README.md

@@ -0,0 +1,2 @@
+# [509. Fibonacci Number](https://leetcode.com/problems/fibonacci-number/)
+

Diff for: 0513.find-bottom-left-tree-value/FindBottomLeftTreeValue.java

@@ -0,0 +1,30 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class FindBottomLeftTreeValue {
+    public int findBottomLeftValue(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            root = queue.poll();
+            if (root.right != null) queue.add(root.right);
+            if (root.left != null) queue.add(root.left);
+        }
+        return root.val;
+    }
+}

Diff for: 0513.find-bottom-left-tree-value/README.md

@@ -0,0 +1,2 @@
+# [513. Find Bottom Left Tree Value](https://leetcode.com/problems/find-bottom-left-tree-value/)
+