Added solutions 74-101

Author: javadev

Diff for: src/main/java/g0001_0100/s0074_search_a_2d_matrix/readme.md

@@ -28,4 +28,42 @@ Write an efficient algorithm that searches for a value in an `m x n` matrix. Thi
 *   `m == matrix.length`
 *   `n == matrix[i].length`
 *   `1 <= m, n <= 100`
-*   <code>-10<sup>4</sup> <= matrix[i][j], target <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= matrix[i][j], target <= 10<sup>4</sup></code>
+
+To solve the "Search a 2D Matrix" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `searchMatrix` in the `Solution` class that takes a 2D integer matrix `matrix` and an integer `target` as input and returns `true` if the target value is found in the matrix, otherwise returns `false`.
+2. Initialize two pointers `row` and `col` to start at the top-right corner of the matrix. `row` starts from 0 and `col` starts from the last column.
+3. Loop until `row` is less than the number of rows in the matrix and `col` is greater than or equal to 0:
+   - If `matrix[row][col]` is equal to the target, return `true`.
+   - If `matrix[row][col]` is greater than the target, decrement `col`.
+   - If `matrix[row][col]` is less than the target, increment `row`.
+4. If the target is not found after the loop, return `false`.
+
+Here's the implementation of the `searchMatrix` method in Java:
+
+```java
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+        
+        int row = 0;
+        int col = n - 1;
+        
+        while (row < m && col >= 0) {
+            if (matrix[row][col] == target) {
+                return true;
+            } else if (matrix[row][col] > target) {
+                col--;
+            } else {
+                row++;
+            }
+        }
+        
+        return false;
+    }
+}
+```
+
+This implementation searches for the target value efficiently in the given matrix by starting from the top-right corner and moving either left or down based on the comparison with the target value. The time complexity of this solution is O(m + n), where m is the number of rows and n is the number of columns in the matrix.

Diff for: src/main/java/g0001_0100/s0075_sort_colors/readme.md

@@ -38,4 +38,47 @@ You must solve this problem without using the library's sort function.
 *   `1 <= n <= 300`
 *   `nums[i]` is `0`, `1`, or `2`.
 
-**Follow up:** Could you come up with a one-pass algorithm using only constant extra space?
+**Follow up:** Could you come up with a one-pass algorithm using only constant extra space?
+
+To solve the "Sort Colors" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `sortColors` in the `Solution` class that takes an array of integers `nums` as input and sorts it in-place according to the colors red, white, and blue.
+2. Initialize three pointers: `low`, `mid`, and `high`. `low` points to the beginning of the array, `mid` points to the current element being processed, and `high` points to the end of the array.
+3. Loop while `mid` is less than or equal to `high`:
+   - If `nums[mid]` is 0, swap `nums[low]` with `nums[mid]`, increment `low` and `mid`.
+   - If `nums[mid]` is 1, increment `mid`.
+   - If `nums[mid]` is 2, swap `nums[mid]` with `nums[high]`, decrement `high`.
+4. After the loop, the array will be sorted in-place according to the colors red, white, and blue.
+
+Here's the implementation of the `sortColors` method in Java:
+
+```java
+class Solution {
+    public void sortColors(int[] nums) {
+        int low = 0;
+        int mid = 0;
+        int high = nums.length - 1;
+        
+        while (mid <= high) {
+            if (nums[mid] == 0) {
+                swap(nums, low, mid);
+                low++;
+                mid++;
+            } else if (nums[mid] == 1) {
+                mid++;
+            } else {
+                swap(nums, mid, high);
+                high--;
+            }
+        }
+    }
+    
+    private void swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
+```
+
+This implementation sorts the array in-place using a one-pass algorithm with constant extra space. It iterates through the array and swaps elements as needed to group them according to their colors. The time complexity of this solution is O(n), where n is the length of the array.

Diff for: src/main/java/g0001_0100/s0076_minimum_window_substring/readme.md

@@ -39,4 +39,75 @@ A **substring** is a contiguous sequence of characters within the string.
 *   <code>1 <= m, n <= 10<sup>5</sup></code>
 *   `s` and `t` consist of uppercase and lowercase English letters.
 
-**Follow up:** Could you find an algorithm that runs in `O(m + n)` time?
+**Follow up:** Could you find an algorithm that runs in `O(m + n)` time?
+
+To solve the "Minimum Window Substring" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `minWindow` in the `Solution` class that takes two strings `s` and `t` as input and returns the minimum window substring of `s` containing all characters from `t`.
+2. Create two frequency maps: `tFreqMap` to store the frequency of characters in string `t`, and `sFreqMap` to store the frequency of characters in the current window of string `s`.
+3. Initialize two pointers `left` and `right` to track the window boundaries. Initialize a variable `minLength` to store the minimum window length found so far.
+4. Iterate over string `s` using the `right` pointer until the end of the string:
+   - Update the frequency map `sFreqMap` for the character at index `right`.
+   - Check if the current window contains all characters from `t`. If it does, move the `left` pointer to minimize the window while maintaining the condition.
+   - Update the `minLength` if the current window length is smaller.
+   - Move the `right` pointer to expand the window.
+5. Return the minimum window substring found, or an empty string if no such substring exists.
+
+Here's the implementation of the `minWindow` method in Java:
+
+```java
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public String minWindow(String s, String t) {
+        Map<Character, Integer> tFreqMap = new HashMap<>();
+        Map<Character, Integer> sFreqMap = new HashMap<>();
+        
+        // Initialize tFreqMap with character frequencies from string t
+        for (char ch : t.toCharArray()) {
+            tFreqMap.put(ch, tFreqMap.getOrDefault(ch, 0) + 1);
+        }
+        
+        int left = 0;
+        int right = 0;
+        int minLength = Integer.MAX_VALUE;
+        int minStart = 0;
+        
+        while (right < s.length()) {
+            char rightChar = s.charAt(right);
+            sFreqMap.put(rightChar, sFreqMap.getOrDefault(rightChar, 0) + 1);
+            right++;
+            
+            // Check if the current window contains all characters from t
+            while (containsAllChars(sFreqMap, tFreqMap)) {
+                // Update the minimum window length
+                if (right - left < minLength) {
+                    minLength = right - left;
+                    minStart = left;
+                }
+                
+                char leftChar = s.charAt(left);
+                sFreqMap.put(leftChar, sFreqMap.get(leftChar) - 1);
+                left++;
+            }
+        }
+        
+        return minLength == Integer.MAX_VALUE ? "" : s.substring(minStart, minStart + minLength);
+    }
+    
+    // Helper method to check if sFreqMap contains all characters from tFreqMap
+    private boolean containsAllChars(Map<Character, Integer> sFreqMap, Map<Character, Integer> tFreqMap) {
+        for (Map.Entry<Character, Integer> entry : tFreqMap.entrySet()) {
+            char ch = entry.getKey();
+            int count = entry.getValue();
+            if (sFreqMap.getOrDefault(ch, 0) < count) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+This implementation finds the minimum window substring in `O(m + n)` time complexity, where `m` is the length of string `s` and `n` is the length of string `t`. It uses two frequency maps to keep track of character frequencies and adjusts the window boundaries to find the minimum window containing all characters from `t`.

Diff for: src/main/java/g0001_0100/s0078_subsets/readme.md

@@ -22,4 +22,49 @@ The solution set **must not** contain duplicate subsets. Return the solution in
 
 *   `1 <= nums.length <= 10`
 *   `-10 <= nums[i] <= 10`
-*   All the numbers of `nums` are **unique**.
+*   All the numbers of `nums` are **unique**.
+
+To solve the "Subsets" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `subsets` in the `Solution` class that takes an integer array `nums` as input and returns all possible subsets of `nums`.
+2. Initialize an empty list to store the result subsets.
+3. Implement a backtracking algorithm to generate all possible subsets:
+   - Define a recursive helper function `generateSubsets` that takes the current subset, the current index in the array, and the array `nums` as parameters.
+   - Base case: If the current index is equal to the length of `nums`, add the current subset to the result list.
+   - Recursive case:
+     - Include the current element in the subset and recursively call `generateSubsets` with the next index.
+     - Exclude the current element from the subset and recursively call `generateSubsets` with the next index.
+4. Call the `generateSubsets` function with an empty subset and the starting index 0.
+5. Return the list containing all subsets.
+
+Here's the implementation of the `subsets` method in Java:
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        generateSubsets(new ArrayList<>(), 0, nums, result);
+        return result;
+    }
+    
+    private void generateSubsets(List<Integer> subset, int index, int[] nums, List<List<Integer>> result) {
+        // Base case: add the current subset to the result list
+        result.add(new ArrayList<>(subset));
+        
+        // Recursive case
+        for (int i = index; i < nums.length; i++) {
+            // Include the current element in the subset
+            subset.add(nums[i]);
+            // Recursively generate subsets starting from the next index
+            generateSubsets(subset, i + 1, nums, result);
+            // Exclude the current element from the subset
+            subset.remove(subset.size() - 1);
+        }
+    }
+}
+```
+
+This implementation uses backtracking to generate all possible subsets of the input array `nums`. It has a time complexity of O(2^N), where N is the number of elements in the input array.

Diff for: src/main/java/g0001_0100/s0079_word_search/readme.md

@@ -38,4 +38,55 @@ The word can be constructed from letters of sequentially adjacent cells, where a
 *   `1 <= word.length <= 15`
 *   `board` and `word` consists of only lowercase and uppercase English letters.
 
-**Follow up:** Could you use search pruning to make your solution faster with a larger `board`?
+**Follow up:** Could you use search pruning to make your solution faster with a larger `board`?
+
+To solve the "Word Search" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `exist` in the `Solution` class that takes a 2D character array `board` and a string `word` as input and returns `true` if the `word` exists in the `board`.
+2. Implement a backtracking algorithm to search for the `word` in the `board`.
+3. Iterate through each cell in the `board`:
+   - For each cell, call a recursive helper function `search` to check if the `word` can be found starting from that cell.
+   - If `search` returns `true`, return `true` immediately.
+4. Define the `search` method to perform the recursive backtracking:
+   - Check if the current cell is out of bounds or if the current character in the `board` does not match the corresponding character in the `word`.
+   - If any of the conditions are met, return `false`.
+   - Mark the current cell as visited by changing its value to a special character (e.g., `#`) to avoid revisiting it.
+   - Recursively call `search` on neighboring cells (up, down, left, right) with the next character in the `word`.
+   - After exploring all possible paths from the current cell, backtrack by restoring the original value of the current cell.
+5. If the `search` method reaches the end of the `word`, return `true`.
+6. If no match is found after exploring all cells, return `false`.
+
+Here's the implementation of the `exist` method in Java:
+
+```java
+class Solution {
+    public boolean exist(char[][] board, String word) {
+        int m = board.length;
+        int n = board[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (search(board, word, i, j, 0))
+                    return true;
+            }
+        }
+        return false;
+    }
+    
+    private boolean search(char[][] board, String word, int i, int j, int index) {
+        if (index == word.length())
+            return true;
+        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != word.charAt(index))
+            return false;
+        char temp = board[i][j];
+        board[i][j] = '#'; // Mark as visited
+        boolean found = search(board, word, i + 1, j, index + 1) ||
+                        search(board, word, i - 1, j, index + 1) ||
+                        search(board, word, i, j + 1, index + 1) ||
+                        search(board, word, i, j - 1, index + 1);
+        board[i][j] = temp; // Restore original value
+        return found;
+    }
+}
+```
+
+This implementation uses backtracking to search for the word in the board, with a time complexity of O(M * N * 4^L), where M and N are the dimensions of the board and L is the length of the word.

Diff for: src/main/java/g0001_0100/s0084_largest_rectangle_in_histogram/readme.md

@@ -25,4 +25,48 @@ Given an array of integers `heights` representing the histogram's bar height whe
 **Constraints:**
 
 *   <code>1 <= heights.length <= 10<sup>5</sup></code>
-*   <code>0 <= heights[i] <= 10<sup>4</sup></code>
+*   <code>0 <= heights[i] <= 10<sup>4</sup></code>
+
+To solve the "Largest Rectangle in Histogram" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `largestRectangleArea` in the `Solution` class that takes an array of integers `heights` as input and returns the area of the largest rectangle in the histogram.
+2. Implement a stack-based algorithm to find the largest rectangle:
+   - Initialize a stack to store indices of bars in the histogram.
+   - Iterate through each bar in the histogram:
+     - If the stack is empty or the current bar's height is greater than or equal to the height of the bar at the top of the stack, push the current bar's index onto the stack.
+     - If the current bar's height is less than the height of the bar at the top of the stack, keep popping bars from the stack until either the stack is empty or the height of the bar at the top of the stack is less than the height of the current bar.
+       - Calculate the area of the rectangle formed by the popped bar using its height and width (the difference between the current index and the index of the previous bar in the stack or -1 if the stack is empty).
+       - Update the maximum area if the calculated area is greater.
+   - After iterating through all bars, pop the remaining bars from the stack and calculate the area of rectangles formed by them using the same method as above.
+3. Return the maximum area calculated.
+
+Here's the implementation of the `largestRectangleArea` method in Java:
+
+```java
+import java.util.Stack;
+
+class Solution {
+    public int largestRectangleArea(int[] heights) {
+        Stack<Integer> stack = new Stack<>();
+        int maxArea = 0;
+        int i = 0;
+        while (i < heights.length) {
+            if (stack.isEmpty() || heights[i] >= heights[stack.peek()]) {
+                stack.push(i++);
+            } else {
+                int top = stack.pop();
+                int width = stack.isEmpty() ? i : i - stack.peek() - 1;
+                maxArea = Math.max(maxArea, heights[top] * width);
+            }
+        }
+        while (!stack.isEmpty()) {
+            int top = stack.pop();
+            int width = stack.isEmpty() ? i : i - stack.peek() - 1;
+            maxArea = Math.max(maxArea, heights[top] * width);
+        }
+        return maxArea;
+    }
+}
+```
+
+This implementation uses a stack-based approach to find the largest rectangle in the histogram, with a time complexity of O(N), where N is the number of bars in the histogram.

Diff for: src/main/java/g0001_0100/s0094_binary_tree_inorder_traversal/readme.md

@@ -45,4 +45,46 @@ Given the `root` of a binary tree, return _the inorder traversal of its nodes' v
 *   The number of nodes in the tree is in the range `[0, 100]`.
 *   `-100 <= Node.val <= 100`
 
-**Follow up:** Recursive solution is trivial, could you do it iteratively?
+**Follow up:** Recursive solution is trivial, could you do it iteratively?
+
+To solve the "Binary Tree Inorder Traversal" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `inorderTraversal` in the `Solution` class that takes the root of a binary tree as input and returns the inorder traversal of its nodes' values.
+2. Implement an iterative algorithm to perform inorder traversal:
+   - Initialize an empty list to store the inorder traversal result.
+   - Initialize a stack to track the nodes during traversal.
+   - Start with the root node and push it onto the stack.
+   - While the stack is not empty:
+     - Traverse down the left subtree by pushing all left child nodes onto the stack.
+     - Pop the top node from the stack and add its value to the traversal result list.
+     - Move to the right subtree of the popped node and repeat the process.
+   - Return the traversal result list.
+3. Return the inorder traversal result list.
+
+Here's the implementation of the `inorderTraversal` method in Java:
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> inorder = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode curr = root;
+        while (curr != null || !stack.isEmpty()) {
+            while (curr != null) {
+                stack.push(curr);
+                curr = curr.left;
+            }
+            curr = stack.pop();
+            inorder.add(curr.val);
+            curr = curr.right;
+        }
+        return inorder;
+    }
+}
+```
+
+This implementation performs an iterative inorder traversal of the binary tree using a stack, with a time complexity of O(N), where N is the number of nodes in the tree.