Code is Added

Author: anjha1

0944.delete-columns-to-make-sorted/DeleteColumnsToMakeSorted.java

@@ -0,0 +1,14 @@
+class DeleteColumnsToMakeSorted {
+    public int minDeletionSize(String[] strs) {
+        int ans = 0, n = strs.length;
+        for (int i = 0; i < strs[0].length(); i++) {
+            for (int j = 1; j < n; j++) {
+                if (strs[j].charAt(i) < strs[j - 1].charAt(i)) {
+                    ans++;
+                    break;
+                }
+            }
+        }
+        return ans;
+    }
+}

0944.delete-columns-to-make-sorted/README.md

@@ -0,0 +1,8 @@
+# [944. Delete Columns to Make Sorted](https://leetcode.com/problems/delete-columns-to-make-sorted/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(m\times n)$. $m$ is the length of the string array and $n$ is the length of a single string in the string array.
+- Space Complexity: $O(1)$.

0946.validate-stack-sequences/README.md

@@ -0,0 +1,7 @@
+# [946. Validate Stack Sequences](https://leetcode.com/problems/validate-stack-sequences/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `pushed`, since `pushed` and `popped` has the length, so the time complexity is $O(n)$.
+- Space Complexity: $O(n)$.

0946.validate-stack-sequences/ValidateStackSequences.java

@@ -0,0 +1,22 @@
+import java.util.Stack;
+
+class ValidateStackSequences {
+    public boolean validateStackSequences(int[] pushed, int[] popped) {
+        Stack<Integer> stack = new Stack<>();
+        int pushIndex = 0, popIndex = 0;
+        while (popIndex < popped.length) {
+            if (stack.isEmpty() && pushIndex < pushed.length) {
+                stack.push(pushed[pushIndex++]);
+            } else if (stack.peek() == popped[popIndex]) {
+                stack.pop();
+                popIndex++;
+            } else if (pushIndex < pushed.length) {
+                stack.push(pushed[pushIndex++]);
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

0947.most-stones-removed-with-same-row-or-column/MostStonesRemovedWithSameRowOrColumn.java

@@ -0,0 +1,43 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class MostStonesRemovedWithSameRowOrColumn {
+    private boolean shareSameRowOrColumn(int[] a, int[] b) {
+        return a[0] == b[0] || a[1] == b[1];
+    }
+
+    private void dfs(int[][] stones, List<Integer>[] adj, int[] visited, int src) {
+        visited[src] = 1;
+        for (int adjacent : adj[src]) {
+            if (visited[adjacent] == 0) {
+                dfs(stones, adj, visited, adjacent);
+            }
+        }
+    }
+
+    public int removeStones(int[][] stones) {
+        List<Integer>[] adj = new ArrayList[stones.length];
+        for (int i = 0; i < stones.length; i++) {
+            adj[i] = new ArrayList<>();
+        }
+
+        for (int i = 0; i < stones.length; i++) {
+            for (int j = i + 1; j < stones.length; j++) {
+                if (shareSameRowOrColumn(stones[i], stones[j])) {
+                    adj[i].add(j);
+                    adj[j].add(i);
+                }
+            }
+        }
+
+        int[] visited = new int[stones.length];
+        int componentCount = 0;
+        for (int i = 0; i < stones.length; i++) {
+            if (visited[i] == 0) {
+                componentCount++;
+                dfs(stones, adj, visited, i);
+            }
+        }
+        return stones.length - componentCount;
+    }
+}

0947.most-stones-removed-with-same-row-or-column/README.md

@@ -0,0 +1,2 @@
+# [947. Most Stones Removed with Same Row or Column](https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/)
+

0948.bag-of-tokens/BagOfTokens.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+
+class BagOfTokens {
+    public int bagOfTokensScore(int[] tokens, int power) {
+        Arrays.sort(tokens);
+        int left = 0, right = tokens.length - 1, res = 0;
+        while (left <= right) {
+            if (tokens[left] <= power) {
+                power -= tokens[left];
+                res++;
+                left++;
+            } else {
+                if (left != right && res > 0) {
+                    power += tokens[right];
+                    res--;
+                    right--;
+                } else {
+                    break;
+                }
+            }
+        }
+        return res;
+    }
+}

0948.bag-of-tokens/README.md

@@ -0,0 +1,2 @@
+# [948. Bag of Tokens](https://leetcode.com/problems/bag-of-tokens/)
+

0953.verifying-an-alien-dictionary/README.md

@@ -0,0 +1,7 @@
+# [953. Verifying an Alien Dictionary](https://leetcode.com/problems/verifying-an-alien-dictionary/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(m\times n)$. $m$ is the length of the words array and $n$ is the maximum length of string in the words array. Because we compared all words two by two, so the total time complexity is $O(m\times n)$.
+- Space Complexity: $O(C)$. $C$ is the length of order. We use an extra array to save it, so the total space complexity is $O(C)$.

0953.verifying-an-alien-dictionary/VerifyingAnAlienDictionary.java

@@ -0,0 +1,25 @@
+class VerifyingAnAlienDictionary {
+    public boolean isAlienSorted(String[] words, String order) {
+        int[] index = new int[26];
+        for (int i = 0; i < order.length(); i++)
+            index[order.charAt(i) - 'a'] = i;
+        for (int i = 1; i < words.length; i++) {
+            boolean valid = false;
+            for (int j = 0; j < words[i - 1].length() && j < words[i].length(); j++) {
+                int prev = index[words[i - 1].charAt(j) - 'a'];
+                int curr = index[words[i].charAt(j) - 'a'];
+                if (prev < curr) {
+                    valid = true;
+                    break;
+                } else if (prev > curr) {
+                    return false;
+                }
+            }
+            if (!valid) {
+                if (words[i - 1].length() > words[i].length())
+                    return false;
+            }
+        }
+        return true;
+    }
+}

0958.check-completeness-of-a-binary-tree/CheckCompletenessOfABinaryTree.java

@@ -0,0 +1,44 @@
+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 CheckCompletenessOfABinaryTree {
+    public boolean isCompleteTree(TreeNode root) {
+        List<ANode> nodes = new ArrayList<>();
+        nodes.add(new ANode(root, 1));
+        int i = 0;
+        while (i < nodes.size()) {
+            ANode anode = nodes.get(i++);
+            if (anode.node != null) {
+                nodes.add(new ANode(anode.node.left, anode.code * 2));
+                nodes.add(new ANode(anode.node.right, anode.code * 2 + 1));
+            }
+        }
+
+        return nodes.get(i - 1).code == nodes.size();
+    }
+}
+
+class ANode {
+    TreeNode node;
+    int code;
+
+    ANode(TreeNode node, int code) {
+        this.node = node;
+        this.code = code;
+    }
+}

0958.check-completeness-of-a-binary-tree/README.md

@@ -0,0 +1,8 @@
+# [958. Check Completeness of a Binary Tree](https://leetcode.com/problems/check-completeness-of-a-binary-tree/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the amount of nodes in the tree.
+- Space Complexity: $O(n)$.

0967.numbers-with-same-consecutive-differences/NumbersWithSameConsecutiveDifferences.java

@@ -0,0 +1,31 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class NumbersWithSameConsecutiveDifferences {
+    private void DFS(int n, int num, int k, List<Integer> results) {
+        if (n == 0) {
+            results.add(num);
+            return;
+        }
+        List<Integer> nextDigits = new ArrayList<>();
+        int tailDigit = num % 10;
+        nextDigits.add(tailDigit + k);
+        if (k != 0) nextDigits.add(tailDigit - k);
+        for (Integer nextDigit : nextDigits) {
+            if (nextDigit >= 0 && nextDigit < 10) {
+                int newNum = num * 10 + nextDigit;
+                DFS(n - 1, newNum, k, results);
+            }
+        }
+    }
+
+    public int[] numsSameConsecDiff(int n, int k) {
+        if (n == 1) return new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        List<Integer> res = new ArrayList<>();
+        for (int num = 1; num < 10; num++) {
+            DFS(n - 1, num, k, res);
+        }
+
+        return res.stream().mapToInt(i->i).toArray();
+    }
+}

0967.numbers-with-same-consecutive-differences/README.md

@@ -0,0 +1,2 @@
+# [967. Numbers With Same Consecutive Differences](https://leetcode.com/problems/numbers-with-same-consecutive-differences/)
+

0974.subarray-sums-divisible-by-k/README.md

@@ -0,0 +1,8 @@
+# [974. Subarray Sums Divisible by K](https://leetcode.com/problems/subarray-sums-divisible-by-k/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `nums`.
+- Space Complexity: $O(k)$. $k$ is the maximum size of hash map.

0974.subarray-sums-divisible-by-k/SubarraySumsDivisibleByK.java

@@ -0,0 +1,19 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class SubarraySumsDivisibleByK {
+    public int subarraysDivByK(int[] nums, int k) {
+        Map<Integer, Integer> counter = new HashMap<>();
+        counter.put(0, 1);
+
+        int prefixSum = 0, ans = 0;
+        for (int i = 0; i < nums.length; i++) {
+            prefixSum += nums[i];
+            int remainder = (prefixSum % k + k) % k;
+            int getCount = counter.getOrDefault(remainder, 0);
+            ans += getCount;
+            counter.put(remainder, getCount + 1);
+        }
+        return ans;
+    }
+}

0976.largest-perimeter-triangle/LargestPerimeterTriangle.java

@@ -0,0 +1,12 @@
+import java.util.Arrays;
+
+class LargestPerimeterTriangle {
+    public int largestPerimeter(int[] nums) {
+        Arrays.sort(nums);
+        for (int i = nums.length - 3; i >= 0; i--) {
+            if (nums[i] + nums[i + 1] > nums[i + 2])
+                return nums[i] + nums[i + 1] + nums[i + 2];
+        }
+        return 0;
+    }
+}

0976.largest-perimeter-triangle/README.md

@@ -0,0 +1,2 @@
+# [976. Largest Perimeter Triangle](https://leetcode.com/problems/largest-perimeter-triangle/)
+

0977.squares-of-a-sorted-array/README.md

@@ -0,0 +1,2 @@
+# [977. Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array/)
+

0977.squares-of-a-sorted-array/SquaresOfASortedArray.java

@@ -0,0 +1,12 @@
+import java.util.Arrays;
+
+class SquaresOfASortedArray {
+    public int[] sortedSquares(int[] nums) {
+        int[] squares = new int[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            squares[i] = nums[i] * nums[i];
+        }
+        Arrays.sort(squares);
+        return squares;
+    }
+}

0980.unique-paths-iii/README.md

@@ -0,0 +1,8 @@
+# [980. Unique Paths III](https://leetcode.com/problems/unique-paths-iii/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(m\times n\times 2^{m\times n})$. The first iteration costs $O(m\times n)$. FindPath function costs $O(m\times n\times 4^{m\times n})$ because every grid has four directions and we have $m \times n$ grids. The total time complexity is $O(m\times n\times 2^{m\times n})$.
+- Space Complexity: $O(m\times n\times 2^{m\times n})$. The space complexity is as same as the function time complexity because we put the same amount of recursion functions to the stack.

0980.unique-paths-iii/UniquePathsIii.java

@@ -0,0 +1,36 @@
+class UniquePathsIii {
+    int ans = 0;
+    int[] start;
+    int totalSteps = 0;
+
+    public int uniquePathsIII(int[][] grid) {
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1)
+                    start = new int[]{i, j};
+                else
+                    if (grid[i][j] != -1)
+                        totalSteps++;
+            }
+        }
+        findPath(start[0], start[1], 0, grid);
+        return ans;
+    }
+
+    private void findPath(int i, int j, int step, int[][] grid) {
+        if (i < 0 || j < 0 || i == grid.length || j == grid[0].length || grid[i][j] == -1)
+            return;
+        if (grid[i][j] == 2) {
+            if (totalSteps == step)
+                ans++;
+        } else {
+            int g = grid[i][j];
+            grid[i][j] = -1;
+            findPath(i + 1, j, step + 1, grid);
+            findPath(i - 1, j, step + 1, grid);
+            findPath(i, j + 1, step + 1, grid);
+            findPath(i, j - 1, step + 1, grid);
+            grid[i][j] = g;
+        }
+    }
+}