solution added by anjha

Author: anjha1

0118.pascals-triangle/PascalsTriangle.java

@@ -0,0 +1,20 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class PascalsTriangle {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> ans = new ArrayList<>();
+        for (int i = 0; i < numRows; i++) {
+            List<Integer> temp = new ArrayList<>();
+            for (int j = 0; j < i + 1; j++) {
+                if (j == 0 || j == i) {
+                    temp.add(1);
+                } else {
+                    temp.add(ans.get(i - 1).get(j - 1) + ans.get(i - 1).get(j));
+                }
+            }
+            ans.add(temp);
+        }
+        return ans;
+    }
+}

0118.pascals-triangle/README.md

@@ -0,0 +1,2 @@
+# [118. Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/)
+

0120.triangle/README.md

@@ -0,0 +1,2 @@
+# [120. Triangle](https://leetcode.com/problems/triangle/)
+

0120.triangle/Triangle.java

@@ -0,0 +1,27 @@
+import java.util.Arrays;
+import java.util.List;
+
+class Triangle {
+    public int minimumTotal(List<List<Integer>> triangle) {
+        int[] dp = new int[triangle.size()];
+        dp[0] = triangle.get(0).get(0);
+        for (int i = 1; i < triangle.size(); i++) {
+            int[] mem = dp.clone();
+            for (int j = 0; j < triangle.get(i).size(); j++) {
+                if (j == 0) {
+                    dp[j] = triangle.get(i).get(j) + mem[j];
+                } else if (j == triangle.get(i).size() - 1) {
+                    dp[j] = triangle.get(i).get(j) + mem[j - 1];
+                } else {
+                    dp[j] = triangle.get(i).get(j) + Math.min(mem[j], mem[j - 1]);
+                }
+            }
+        }
+
+        int res = Integer.MAX_VALUE;
+        for (int num : dp) {
+            res = Math.min(res, num);
+        }
+        return res;
+    }
+}

0121.best-time-to-buy-and-sell-stock/BestTimeToBuyAndSellStock.java

@@ -0,0 +1,12 @@
+class BestTimeToBuyAndSellStock {
+    public int maxProfit(int[] prices) {
+        int minPrice = Integer.MAX_VALUE, maxProfit = 0;
+        for (int i = 0; i < prices.length; i++) {
+            if (prices[i] < minPrice)
+                minPrice = prices[i];
+            else if (prices[i] - minPrice > maxProfit)
+                maxProfit = prices[i] - minPrice;
+        }
+        return maxProfit;
+    }
+}

0121.best-time-to-buy-and-sell-stock/README.md

@@ -0,0 +1,7 @@
+# [121. Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of prices.
+- Space Complexity: $O(1)$. We only use extra space for variables.

0122.best-time-to-buy-and-sell-stock-ii/BestTimeToBuyAndSellStockIi.java

@@ -0,0 +1,11 @@
+class BestTimeToBuyAndSellStockIi {
+    public int maxProfit(int[] prices) {
+        int profit = 0;
+        for (int i = 1; i < prices.length; i++) {
+            if (prices[i] > prices[i - 1]) {
+                profit += prices[i] - prices[i - 1] ;
+            }
+        }
+        return profit;
+    }
+}

0122.best-time-to-buy-and-sell-stock-ii/README.md

@@ -0,0 +1,2 @@
+# [122. Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)
+

0126.word-ladder-ii/README.md

@@ -0,0 +1 @@
+# [126. Word Ladder II](https://leetcode.com/problems/word-ladder-ii/)

0126.word-ladder-ii/WordLadderIi.java

@@ -0,0 +1,81 @@
+import java.util.*;
+
+class WordLadderIi {
+    private void bfs(Set<String> startSet, Set<String> endSet, Map<String, List<String>> map, Set<String> dict, boolean reverse) {
+        if (startSet.size() == 0) return;
+        if (startSet.size() > endSet.size()) {
+            bfs(endSet, startSet, map, dict, !reverse);
+            return;
+        }
+
+        Set<String> tmp = new HashSet<>();
+        boolean finish = false;
+        dict.removeAll(startSet);
+
+        for (String s : startSet) {
+            char[] chs = s.toCharArray();
+            for (int i = 0; i < chs.length; i++) {
+                char old = chs[i];
+                for (char c = 'a'; c <= 'z'; c++) {
+                    chs[i] = c;
+                    String word = new String(chs);
+
+                    if (dict.contains(word)) {
+                        if (endSet.contains(word)) {
+                            finish = true;
+                        } else {
+                            tmp.add(word);
+                        }
+
+                        String key = reverse ? word : s;
+                        String val = reverse ? s : word;
+
+                        if (map.get(key) == null) {
+                            map.put(key, new ArrayList<>());
+                        }
+
+                        map.get(key).add(val);
+                    }
+                }
+                chs[i] = old;
+            }
+        }
+
+        if (!finish) {
+            bfs(tmp, endSet, map, dict, reverse);
+        }
+    }
+
+    private void dfs(List<List<String>> res, List<String> list, String endWord, String word, Map<String, List<String>> map) {
+        if (word.equals(endWord)) {
+            res.add(new ArrayList<>(list));
+            return;
+        }
+
+        if (map.get(word) == null) return;
+        for (String next : map.get(word)) {
+            list.add(next);
+            dfs(res, list, endWord, next, map);
+            list.remove(list.size() - 1);
+        }
+    }
+
+    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
+        List<List<String>> res = new ArrayList<>();
+        Set<String> dict = new HashSet<>(wordList);
+        if (!dict.contains(endWord)) return res;
+
+        Map<String, List<String>> map = new HashMap<>();
+        Set<String> startSet = new HashSet<>();
+        Set<String> endSet = new HashSet<>();
+        startSet.add(beginWord);
+        endSet.add(endWord);
+        bfs(startSet, endSet, map, dict, false);
+
+        List<String> list = new ArrayList<>();
+        list.add(beginWord);
+        dfs(res, list, endWord, beginWord, map);
+
+        return res;
+    }
+}

0128.longest-consecutive-sequence/LongestConsecutiveSequence.java

@@ -0,0 +1,36 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class LongestConsecutiveSequence {
+    private int forward(Map<Integer, Integer> countForNum, int num) {
+        if (!countForNum.containsKey(num)) {
+            return 0;
+        }
+        int cnt = countForNum.get(num);
+        if (cnt > 1) {
+            return cnt;
+        }
+        cnt = forward(countForNum, num + 1) + 1;
+        countForNum.put(num, cnt);
+        return cnt;
+    }
+
+    private int maxCount(Map<Integer, Integer> countForNum) {
+        int max = 0;
+        for (int num : countForNum.keySet()) {
+            max = Math.max(max, countForNum.get(num));
+        }
+        return max;
+    }
+
+    public int longestConsecutive(int[] nums) {
+        Map<Integer, Integer> countForNum = new HashMap<>();
+        for (int num : nums) {
+            countForNum.put(num, 1);
+        }
+        for (int num : nums) {
+            forward(countForNum, num);
+        }
+        return maxCount(countForNum);
+    }
+}

0128.longest-consecutive-sequence/README.md

@@ -0,0 +1 @@
+# [128. Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/)

0129.sum-root-to-leaf-numbers/README.md

@@ -0,0 +1,7 @@
+# [129. Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the amount of nodes in the tree.
+- Space Complexity: $O(n)$. Recursion is using stack and the space complexity is $O(n)$.

0129.sum-root-to-leaf-numbers/SumRootToLeafNumbers.java

@@ -0,0 +1,37 @@
+/**
+ * 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 SumRootToLeafNumbers {
+    private int sum = 0;
+
+    public int sumNumbers(TreeNode root) {
+        dfs(root, 0);
+        return sum;
+    }
+
+    private void dfs(TreeNode root, int currSum) {
+        int tempSum = currSum * 10 + root.val;
+        if (root.left == null && root.right == null) {
+            sum += tempSum;
+            return;
+        }
+        if (root.left != null) {
+            dfs(root.left, tempSum);
+        }
+        if (root.right != null) {
+            dfs(root.right, tempSum);
+        }
+    }
+}

0130.surrounded-regions/README.md

@@ -0,0 +1,2 @@
+# [130. Surrounded Regions](https://leetcode.com/problems/surrounded-regions/)
+

0130.surrounded-regions/SurroundedRegions.java

@@ -0,0 +1,29 @@
+class SurroundedRegions {
+    private void DFS(char[][] board, int row, int col) {
+        if (row < 0 || row > board.length - 1 || col < 0 || col > board[0].length) return;
+        if (board[row][col] == 'O') board[row][col] = '*';
+        if (row > 1 && board[row - 1][col] == 'O') DFS(board, row - 1, col);
+        if (row < board.length - 2 && board[row + 1][col] == 'O') DFS(board, row + 1, col);
+        if (col > 1 && board[row][col - 1] == 'O') DFS(board, row, col - 1);
+        if (col < board[row].length - 2 && board[row][col + 1] == 'O') DFS(board, row, col + 1);
+    }
+
+    public void solve(char[][] board) {
+        if (board.length < 2 || board[0].length < 2) return;
+        int m = board.length, n = board[0].length;
+        for (int i = 0; i < m; i++) {
+            if (board[i][0] == 'O') DFS(board, i, 0);
+            if (board[i][n - 1] == 'O') DFS(board, i, n - 1);
+        }
+        for (int j = 0; j < n; j++) {
+            if (board[0][j] == 'O') DFS(board, 0, j);
+            if (board[m - 1][j] == 'O') DFS(board, m - 1, j);
+        }
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (board[i][j] == 'O') board[i][j] = 'X';
+                else if (board[i][j] == '*') board[i][j] = 'O';
+            }
+        }
+    }
+}

0131.palindrome-partitioning/PalindromePartitioning.java

@@ -0,0 +1,39 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class PalindromePartitioning {
+    boolean[][] f;
+    List<List<String>> ans  = new ArrayList<>();
+    List<String> temp = new ArrayList<>();
+    int n;
+
+    public List<List<String>> partition(String s) {
+        n = s.length();
+        f = new boolean[n][n];
+        for (int i = 0; i < n; i++)
+            Arrays.fill(f[i], true);
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = i + 1; j < n; j++) {
+                f[i][j] = (s.charAt(i) == s.charAt(j)) && f[i + 1][j - 1];
+            }
+        }
+
+        dfs(s, 0);
+        return ans;
+    }
+
+    private void dfs(String s, int i) {
+        if (i == n) {
+            ans.add(new ArrayList<>(temp));
+            return;
+        }
+        for (int j = i; j < n; j++) {
+            if (f[i][j]) {
+                temp.add(s.substring(i, j + 1));
+                dfs(s, j + 1);
+                temp.remove(temp.size() - 1);
+            }
+        }
+    }
+}

0131.palindrome-partitioning/README.md

@@ -0,0 +1,7 @@
+# [131. Palindrome Partitioning](https://leetcode.com/problems/palindrome-partitioning/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\times2^n)$. $n$ is the length of s. In the worst case, s has completely same characters in $n$ length , and the time complexity is $O(n\times2^n)$.
+- Space Complexity: $O(n^2)$. We use $O(n^2)$ for array f and use $O(n)$ in backtracking. The total space complexity is $O(n^2)$.

0134.gas-station/GasStation.java

@@ -0,0 +1,21 @@
+class GasStation {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+        int n = gas.length, i = 0;
+        while (i < n) {
+            int sumOfGas = 0, sumOfCost = 0, cnt = 0;
+            while (cnt < n) {
+                int j = (i + cnt) % n;
+                sumOfGas += gas[j];
+                sumOfCost += cost[j];
+                if (sumOfCost > sumOfGas)
+                    break;
+                cnt++;
+            }
+            if (cnt == n)
+                return i;
+            else
+                i = i + cnt + 1;
+        }
+        return -1;
+    }
+}

0134.gas-station/README.md

@@ -0,0 +1 @@
+# [134. Gas Station](https://leetcode.com/problems/gas-station/)