Added cpp tasks 96-155

Author: javadev

src/main/cpp/g0001_0100/s0096_unique_binary_search_trees/readme.md

@@ -0,0 +1,56 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 96\. Unique Binary Search Trees
+
+Medium
+
+Given an integer `n`, return _the number of structurally unique **BST'**s (binary search trees) which has exactly_ `n` _nodes of unique values from_ `1` _to_ `n`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg)
+
+**Input:** n = 3
+
+**Output:** 5 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `1 <= n <= 19`
+
+To solve the "Unique Binary Search Trees" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `numTrees` in the `Solution` class that takes an integer `n` as input and returns the number of structurally unique BSTs (binary search trees) with exactly `n` nodes.
+2. Implement a dynamic programming approach to solve the problem:
+   - Create an array `dp` of size `n + 1` to store the number of unique BSTs for each number of nodes from 0 to `n`.
+   - Initialize `dp[0] = 1` and `dp[1] = 1`, as there is only one unique BST for 0 and 1 node(s).
+   - Use a nested loop to calculate `dp[i]` for each `i` from 2 to `n`.
+   - For each `i`, calculate `dp[i]` by summing up the products of `dp[j]` and `dp[i - j - 1]` for all possible values of `j` from 0 to `i - 1`.
+   - Return `dp[n]`, which represents the number of unique BSTs with `n` nodes.
+
+Here's the implementation of the `numTrees` method in Java:
+
+```java
+class Solution {
+    public int numTrees(int n) {
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+        dp[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            for (int j = 0; j < i; j++) {
+                dp[i] += dp[j] * dp[i - j - 1];
+            }
+        }
+        return dp[n];
+    }
+}
+```
+
+This implementation uses dynamic programming to compute the number of structurally unique BSTs with `n` nodes in O(n^2) time complexity.

src/main/cpp/g0001_0100/s0098_validate_binary_search_tree/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 98\. Validate Binary Search Tree
+
+Medium
+
+Given the `root` of a binary tree, _determine if it is a valid binary search tree (BST)_.
+
+A **valid BST** is defined as follows:
+
+*   The left subtree of a node contains only nodes with keys **less than** the node's key.
+*   The right subtree of a node contains only nodes with keys **greater than** the node's key.
+*   Both the left and right subtrees must also be binary search trees.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/01/tree1.jpg)
+
+**Input:** root = [2,1,3]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/01/tree2.jpg)
+
+**Input:** root = [5,1,4,null,null,3,6]
+
+**Output:** false
+
+**Explanation:** The root node's value is 5 but its right child's value is 4. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.
+*   <code>-2<sup>31</sup> <= Node.val <= 2<sup>31</sup> - 1</code>
+
+To solve the "Validate Binary Search Tree" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `isValidBST` in the `Solution` class that takes the root of a binary tree as input and returns true if the tree is a valid binary search tree (BST), and false otherwise.
+2. Implement a recursive approach to validate if the given binary tree is a valid BST:
+   - Define a helper method `isValidBSTHelper` that takes the root node, a lower bound, and an upper bound as input parameters.
+   - In the `isValidBSTHelper` method, recursively traverse the binary tree nodes.
+   - At each node, check if its value is within the specified bounds (lower bound and upper bound) for a valid BST.
+   - If the node's value violates the BST property, return false.
+   - Otherwise, recursively validate the left and right subtrees by updating the bounds accordingly.
+   - If both the left and right subtrees are valid BSTs, return true.
+3. Call the `isValidBSTHelper` method with the root node and appropriate initial bounds to start the validation process.
+
+Here's the implementation of the `isValidBST` method in Java:
+
+```java
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        return isValidBSTHelper(root, null, null);
+    }
+    
+    private boolean isValidBSTHelper(TreeNode node, Integer lower, Integer upper) {
+        if (node == null) {
+            return true;
+        }
+        
+        int val = node.val;
+        if ((lower != null && val <= lower) || (upper != null && val >= upper)) {
+            return false;
+        }
+        
+        return isValidBSTHelper(node.left, lower, val) && isValidBSTHelper(node.right, val, upper);
+    }
+}
+```
+
+This implementation recursively validates whether the given binary tree is a valid BST in O(n) time complexity, where n is the number of nodes in the tree.

src/main/cpp/g0101_0200/s0101_symmetric_tree/readme.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 101\. Symmetric Tree
+
+Easy
+
+Given the `root` of a binary tree, _check whether it is a mirror of itself_ (i.e., symmetric around its center).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/symtree1.jpg)
+
+**Input:** root = [1,2,2,3,4,4,3]
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/symtree2.jpg)
+
+**Input:** root = [1,2,2,null,3,null,3]
+
+**Output:** false 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `-100 <= Node.val <= 100`
+
+**Follow up:** Could you solve it both recursively and iteratively?
+
+To solve the "Symmetric Tree" problem in Java with the Solution class, follow these steps:
+
+1. Define a method `isSymmetric` in the `Solution` class that takes the root of a binary tree as input and returns true if the tree is symmetric, and false otherwise.
+2. Implement a recursive approach to check if the given binary tree is symmetric:
+   - Define a helper method `isMirror` that takes two tree nodes as input parameters.
+   - In the `isMirror` method, recursively compare the left and right subtrees of the given nodes.
+   - At each step, check if the values of the corresponding nodes are equal and if the left subtree of one node is a mirror image of the right subtree of the other node.
+   - If both conditions are satisfied for all corresponding nodes, return true; otherwise, return false.
+3. Call the `isMirror` method with the root's left and right children to check if the entire tree is symmetric.
+
+Here's the implementation of the `isSymmetric` method in Java:
+
+```java
+class Solution {
+    public boolean isSymmetric(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        return isMirror(root.left, root.right);
+    }
+    
+    private boolean isMirror(TreeNode left, TreeNode right) {
+        if (left == null && right == null) {
+            return true;
+        }
+        if (left == null || right == null) {
+            return false;
+        }
+        return (left.val == right.val) && isMirror(left.left, right.right) && isMirror(left.right, right.left);
+    }
+}
+```
+
+This implementation recursively checks whether the given binary tree is symmetric around its center in O(n) time complexity, where n is the number of nodes in the tree.

src/main/cpp/g0101_0200/s0102_binary_tree_level_order_traversal/readme.md

@@ -0,0 +1,105 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 102\. Binary Tree Level Order Traversal
+
+Medium
+
+Given the `root` of a binary tree, return _the level order traversal of its nodes' values_. (i.e., from left to right, level by level).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** [[3],[9,20],[15,7]] 
+
+**Example 2:**
+
+**Input:** root = [1]
+
+**Output:** [[1]] 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 2000]`.
+*   `-1000 <= Node.val <= 1000`
+
+To solve the "Binary Tree Level Order Traversal" problem in Java with a `Solution` class, we'll perform a breadth-first search (BFS) traversal of the binary tree. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `levelOrder` method**: This method takes the root node of the binary tree as input and returns the level order traversal of its nodes' values.
+
+3. **Initialize a queue**: Create a queue to store the nodes during BFS traversal.
+
+4. **Check for null root**: Check if the root is null. If it is, return an empty list.
+
+5. **Perform BFS traversal**: Enqueue the root node into the queue. While the queue is not empty:
+   - Dequeue the front node from the queue.
+   - Add the value of the dequeued node to the current level list.
+   - Enqueue the left and right children of the dequeued node if they exist.
+   - Move to the next level when all nodes in the current level are processed.
+
+6. **Return the result**: After the BFS traversal is complete, return the list containing the level order traversal of the binary tree.
+
+Here's the Java implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>(); // Initialize list to store level order traversal
+        if (root == null) return result; // Check for empty tree
+        
+        Queue<TreeNode> queue = new LinkedList<>(); // Initialize queue for BFS traversal
+        queue.offer(root); // Enqueue the root node
+        
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size(); // Get the number of nodes in the current level
+            List<Integer> level = new ArrayList<>(); // Initialize list for the current level
+            
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode node = queue.poll(); // Dequeue the front node
+                level.add(node.val); // Add node value to the current level list
+                
+                // Enqueue the left and right children if they exist
+                if (node.left != null) queue.offer(node.left);
+                if (node.right != null) queue.offer(node.right);
+            }
+            
+            result.add(level); // Add the current level list to the result list
+        }
+        
+        return result; // Return the level order traversal
+    }
+    
+    // Definition for a TreeNode
+    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;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently computes the level order traversal of the binary tree in Java using BFS.

src/main/cpp/g0101_0200/s0104_maximum_depth_of_binary_tree/readme.md

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 104\. Maximum Depth of Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, return _its maximum depth_.
+
+A binary tree's **maximum depth** is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** 3 
+
+**Example 2:**
+
+**Input:** root = [1,null,2]
+
+**Output:** 2 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** 0 
+
+**Example 4:**
+
+**Input:** root = [0]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   `-100 <= Node.val <= 100`
+
+To solve the "Maximum Depth of Binary Tree" problem in Java with a `Solution` class, we'll perform a depth-first search (DFS) traversal of the binary tree. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `maxDepth` method**: This method takes the root node of the binary tree as input and returns its maximum depth.
+
+3. **Check for null root**: Check if the root is null. If it is, return 0 as the depth.
+
+4. **Perform DFS traversal**: Recursively compute the depth of the left and right subtrees. The maximum depth of the binary tree is the maximum depth of its left and right subtrees, plus 1 for the current node.
+
+5. **Return the result**: After the DFS traversal is complete, return the maximum depth of the binary tree.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) return 0; // Check for empty tree
+        int leftDepth = maxDepth(root.left); // Compute depth of left subtree
+        int rightDepth = maxDepth(root.right); // Compute depth of right subtree
+        return Math.max(leftDepth, rightDepth) + 1; // Return maximum depth of left and right subtrees, plus 1 for the current node
+    }
+    
+    // Definition for a TreeNode
+    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;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently computes the maximum depth of the binary tree in Java using DFS traversal.

src/main/cpp/g0101_0200/s0105_construct_binary_tree_from_preorder_and_inorder_traversal/readme.md

@@ -0,0 +1,108 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 105\. Construct Binary Tree from Preorder and Inorder Traversal
+
+Medium
+
+Given two integer arrays `preorder` and `inorder` where `preorder` is the preorder traversal of a binary tree and `inorder` is the inorder traversal of the same tree, construct and return _the binary tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree.jpg)
+
+**Input:** preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
+
+**Output:** [3,9,20,null,null,15,7] 
+
+**Example 2:**
+
+**Input:** preorder = [-1], inorder = [-1]
+
+**Output:** [-1] 
+
+**Constraints:**
+
+*   `1 <= preorder.length <= 3000`
+*   `inorder.length == preorder.length`
+*   `-3000 <= preorder[i], inorder[i] <= 3000`
+*   `preorder` and `inorder` consist of **unique** values.
+*   Each value of `inorder` also appears in `preorder`.
+*   `preorder` is **guaranteed** to be the preorder traversal of the tree.
+*   `inorder` is **guaranteed** to be the inorder traversal of the tree.
+
+To solve the "Construct Binary Tree from Preorder and Inorder Traversal" problem in Java with a `Solution` class, we'll use a recursive approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `buildTree` method**: This method takes two integer arrays, `preorder` and `inorder`, as input and returns the constructed binary tree.
+
+3. **Check for empty arrays**: Check if either of the arrays `preorder` or `inorder` is empty. If so, return null, as there's no tree to construct.
+
+4. **Define a helper method**: Define a recursive helper method `build` to construct the binary tree.
+   - The method should take the indices representing the current subtree in both `preorder` and `inorder`.
+   - The start and end indices in `preorder` represent the current subtree's preorder traversal.
+   - The start and end indices in `inorder` represent the current subtree's inorder traversal.
+   
+5. **Base case**: If the start index of `preorder` is greater than the end index or if the start index of `inorder` is greater than the end index, return null.
+
+6. **Find the root node**: The root node is the first element in the `preorder` array.
+
+7. **Find the root's position in `inorder`**: Iterate through the `inorder` array to find the root's position.
+
+8. **Recursively build left and right subtrees**: 
+   - Recursively call the `build` method for the left subtree with updated indices.
+   - Recursively call the `build` method for the right subtree with updated indices.
+   
+9. **Return the root node**: After constructing the left and right subtrees, return the root node.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        if (preorder.length == 0 || inorder.length == 0) return null; // Check for empty arrays
+        return build(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1); // Construct binary tree
+    }
+    
+    // Recursive helper method to construct binary tree
+    private TreeNode build(int[] preorder, int[] inorder, int preStart, int preEnd, int inStart, int inEnd) {
+        if (preStart > preEnd || inStart > inEnd) return null; // Base case
+        
+        int rootValue = preorder[preStart]; // Root node value
+        TreeNode root = new TreeNode(rootValue); // Create root node
+        
+        // Find root node's position in inorder array
+        int rootIndex = 0;
+        for (int i = inStart; i <= inEnd; i++) {
+            if (inorder[i] == rootValue) {
+                rootIndex = i;
+                break;
+            }
+        }
+        
+        // Recursively build left and right subtrees
+        root.left = build(preorder, inorder, preStart + 1, preStart + rootIndex - inStart, inStart, rootIndex - 1);
+        root.right = build(preorder, inorder, preStart + rootIndex - inStart + 1, preEnd, rootIndex + 1, inEnd);
+        
+        return root; // Return root node
+    }
+    
+    // TreeNode definition
+    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;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently constructs the binary tree from preorder and inorder traversals in Java.

src/main/cpp/g0101_0200/s0114_flatten_binary_tree_to_linked_list/readme.md

@@ -0,0 +1,115 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 114\. Flatten Binary Tree to Linked List
+
+Medium
+
+Given the `root` of a binary tree, flatten the tree into a "linked list":
+
+*   The "linked list" should use the same `TreeNode` class where the `right` child pointer points to the next node in the list and the `left` child pointer is always `null`.
+*   The "linked list" should be in the same order as a [**pre-order** **traversal**](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR) of the binary tree.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg)
+
+**Input:** root = [1,2,5,3,4,null,6]
+
+**Output:** [1,null,2,null,3,null,4,null,5,null,6] 
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** root = [0]
+
+**Output:** [0] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 2000]`.
+*   `-100 <= Node.val <= 100`
+
+**Follow up:** Can you flatten the tree in-place (with `O(1)` extra space)?
+
+To solve the "Flatten Binary Tree to Linked List" problem in Java with a `Solution` class, we'll use a recursive approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `flatten` method**: This method takes the root node of the binary tree as input and flattens the tree into a linked list using preorder traversal.
+
+3. **Check for null root**: Check if the root is null. If so, there's no tree to flatten, so return.
+
+4. **Recursively flatten the tree**: Define a recursive helper method `flattenTree` to perform the flattening.
+   - The method should take the current node as input.
+   - Perform a preorder traversal of the tree.
+   - For each node, if it has a left child:
+     - Find the rightmost node in the left subtree.
+     - Attach the right subtree of the current node to the right of the rightmost node.
+     - Move the left subtree to the right subtree position.
+     - Set the left child of the current node to null.
+   - Recursively call the method for the right child.
+
+5. **Call the helper method**: Call the `flattenTree` method with the root node.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public void flatten(TreeNode root) {
+        if (root == null) return; // Check for empty tree
+        flattenTree(root); // Flatten the tree
+    }
+    
+    // Recursive helper method to flatten the tree
+    private void flattenTree(TreeNode node) {
+        if (node == null) return;
+        
+        // Flatten left subtree
+        flattenTree(node.left);
+        
+        // Flatten right subtree
+        flattenTree(node.right);
+        
+        // Save right subtree
+        TreeNode rightSubtree = node.right;
+        
+        // Attach left subtree to the right of the current node
+        node.right = node.left;
+        
+        // Set left child to null
+        node.left = null;
+        
+        // Move to the rightmost node of the flattened left subtree
+        TreeNode current = node;
+        while (current.right != null) {
+            current = current.right;
+        }
+        
+        // Attach the saved right subtree to the right of the rightmost node
+        current.right = rightSubtree;
+    }
+    
+    // TreeNode definition
+    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;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently flattens the binary tree into a linked list using preorder traversal in Java.

src/main/cpp/g0101_0200/s0121_best_time_to_buy_and_sell_stock/readme.md

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 121\. Best Time to Buy and Sell Stock
+
+Easy
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+You want to maximize your profit by choosing a **single day** to buy one stock and choosing a **different day in the future** to sell that stock.
+
+Return _the maximum profit you can achieve from this transaction_. If you cannot achieve any profit, return `0`.
+
+**Example 1:**
+
+**Input:** prices = [7,1,5,3,6,4]
+
+**Output:** 5
+
+**Explanation:** Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell. 
+
+**Example 2:**
+
+**Input:** prices = [7,6,4,3,1]
+
+**Output:** 0
+
+**Explanation:** In this case, no transactions are done and the max profit = 0. 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>4</sup></code>
+
+To solve the "Best Time to Buy and Sell Stock" problem in Java with a `Solution` class, we'll use a greedy algorithm. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `maxProfit` method**: This method takes an array `prices` as input and returns the maximum profit that can be achieved by buying and selling the stock.
+
+3. **Initialize variables**: Initialize two variables, `minPrice` to store the minimum price seen so far and `maxProfit` to store the maximum profit seen so far. Initialize `maxProfit` to 0.
+
+4. **Iterate through the prices array**:
+   - For each price in the array:
+     - Update `minPrice` to the minimum of the current price and `minPrice`.
+     - Update `maxProfit` to the maximum of the current profit (price - `minPrice`) and `maxProfit`.
+
+5. **Return the maximum profit**: After iterating through the entire array, return `maxProfit`.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if (prices == null || prices.length <= 1) return 0; // Check for empty array or single element
+        
+        int minPrice = prices[0]; // Initialize minPrice to the first price
+        int maxProfit = 0; // Initialize maxProfit to 0
+        
+        // Iterate through the prices array
+        for (int i = 1; i < prices.length; i++) {
+            minPrice = Math.min(minPrice, prices[i]); // Update minPrice
+            maxProfit = Math.max(maxProfit, prices[i] - minPrice); // Update maxProfit
+        }
+        
+        return maxProfit; // Return the maximum profit
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently calculates the maximum profit that can be achieved by buying and selling the stock in Java.

src/main/cpp/g0101_0200/s0124_binary_tree_maximum_path_sum/readme.md

@@ -0,0 +1,109 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 124\. Binary Tree Maximum Path Sum
+
+Hard
+
+A **path** in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence **at most once**. Note that the path does not need to pass through the root.
+
+The **path sum** of a path is the sum of the node's values in the path.
+
+Given the `root` of a binary tree, return _the maximum **path sum** of any **non-empty** path_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg)
+
+**Input:** root = [1,2,3]
+
+**Output:** 6
+
+**Explanation:** The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg)
+
+**Input:** root = [-10,9,20,null,null,15,7]
+
+**Output:** 42
+
+**Explanation:** The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 3 * 10<sup>4</sup>]</code>.
+*   `-1000 <= Node.val <= 1000`
+
+To solve the "Binary Tree Maximum Path Sum" problem in Java with a `Solution` class, we'll use a recursive approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `maxPathSum` method**: This method takes the root node of the binary tree as input and returns the maximum path sum.
+
+3. **Define a recursive helper method**: Define a recursive helper method `maxSumPath` to compute the maximum path sum rooted at the current node.
+   - The method should return the maximum path sum that can be obtained from the current node to any of its descendants.
+   - We'll use a post-order traversal to traverse the tree.
+   - For each node:
+     - Compute the maximum path sum for the left and right subtrees recursively.
+     - Update the maximum path sum by considering three cases:
+       1. The current node itself.
+       2. The current node plus the maximum path sum of the left subtree.
+       3. The current node plus the maximum path sum of the right subtree.
+     - Update the global maximum path sum if necessary by considering the sum of the current node, left subtree, and right subtree.
+
+4. **Initialize a variable to store the maximum path sum**: Initialize a global variable `maxSum` to store the maximum path sum.
+
+5. **Call the helper method**: Call the `maxSumPath` method with the root node.
+
+6. **Return the maximum path sum**: After traversing the entire tree, return the `maxSum`.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    int maxSum = Integer.MIN_VALUE; // Initialize global variable to store maximum path sum
+    
+    public int maxPathSum(TreeNode root) {
+        maxSumPath(root);
+        return maxSum; // Return maximum path sum
+    }
+    
+    // Recursive helper method to compute maximum path sum rooted at current node
+    private int maxSumPath(TreeNode node) {
+        if (node == null) return 0; // Base case
+        
+        // Compute maximum path sum for left and right subtrees recursively
+        int leftSum = Math.max(maxSumPath(node.left), 0); // Ignore negative sums
+        int rightSum = Math.max(maxSumPath(node.right), 0); // Ignore negative sums
+        
+        // Update maximum path sum by considering three cases:
+        // 1. Current node itself
+        // 2. Current node + maximum path sum of left subtree
+        // 3. Current node + maximum path sum of right subtree
+        int currentSum = node.val + leftSum + rightSum;
+        maxSum = Math.max(maxSum, currentSum); // Update global maximum path sum
+        
+        // Return the maximum path sum that can be obtained from the current node to any of its descendants
+        return node.val + Math.max(leftSum, rightSum);
+    }
+    
+    // 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;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently computes the maximum path sum in a binary tree in Java.

src/main/cpp/g0101_0200/s0128_longest_consecutive_sequence/readme.md

@@ -0,0 +1,79 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 128\. Longest Consecutive Sequence
+
+Medium
+
+Given an unsorted array of integers `nums`, return _the length of the longest consecutive elements sequence._
+
+You must write an algorithm that runs in `O(n)` time.
+
+**Example 1:**
+
+**Input:** nums = [100,4,200,1,3,2]
+
+**Output:** 4
+
+**Explanation:** The longest consecutive elements sequence is `[1, 2, 3, 4]`. Therefore its length is 4. 
+
+**Example 2:**
+
+**Input:** nums = [0,3,7,2,5,8,4,6,0,1]
+
+**Output:** 9 
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+
+To solve the "Longest Consecutive Sequence" problem in Java with a `Solution` class, we'll use a HashSet and a greedy approach. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `longestConsecutive` method**: This method takes an array `nums` as input and returns the length of the longest consecutive elements sequence.
+
+3. **Initialize a HashSet**: Create a HashSet named `numSet` to store all the numbers in the array `nums`.
+
+4. **Iterate through the array**: Add all the numbers from the array `nums` to the `numSet`.
+
+5. **Find the longest sequence**: Iterate through the array `nums` again. For each number `num` in the array:
+   - Check if `num - 1` exists in the `numSet`. If it does not, `num` could be the start of a new sequence.
+   - If `num - 1` does not exist, start a new sequence from `num`. Increment `currentNum` by 1 and check if `currentNum` exists in the `numSet`. Keep incrementing `currentNum` until it does not exist in the `numSet`. Update the maximum length of the sequence accordingly.
+
+6. **Return the maximum length**: After iterating through the entire array, return the maximum length of the consecutive sequence.
+
+Here's the Java implementation:
+
+```java
+import java.util.HashSet;
+
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        HashSet<Integer> numSet = new HashSet<>();
+        for (int num : nums) {
+            numSet.add(num); // Add all numbers to HashSet
+        }
+        
+        int maxLength = 0;
+        for (int num : nums) {
+            if (!numSet.contains(num - 1)) { // Check if num - 1 exists in numSet
+                int currentNum = num;
+                int currentLength = 1;
+                
+                while (numSet.contains(currentNum + 1)) { // Increment currentNum until it does not exist in numSet
+                    currentNum++;
+                    currentLength++;
+                }
+                
+                maxLength = Math.max(maxLength, currentLength); // Update maximum length
+            }
+        }
+        
+        return maxLength; // Return the maximum length of the consecutive sequence
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently calculates the length of the longest consecutive elements sequence in Java.

src/main/cpp/g0101_0200/s0131_palindrome_partitioning/readme.md

@@ -0,0 +1,95 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 131\. Palindrome Partitioning
+
+Medium
+
+Given a string `s`, partition `s` such that every substring of the partition is a **palindrome**. Return all possible palindrome partitioning of `s`.
+
+A **palindrome** string is a string that reads the same backward as forward.
+
+**Example 1:**
+
+**Input:** s = "aab"
+
+**Output:** [["a","a","b"],["aa","b"]] 
+
+**Example 2:**
+
+**Input:** s = "a"
+
+**Output:** [["a"]] 
+
+**Constraints:**
+
+*   `1 <= s.length <= 16`
+*   `s` contains only lowercase English letters.
+
+To solve the "Palindrome Partitioning" problem in Java with a `Solution` class, we'll use backtracking. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `partition` method**: This method takes a string `s` as input and returns all possible palindrome partitioning of `s`.
+
+3. **Define a recursive helper method**: Define a recursive helper method `backtrack` to find all possible palindrome partitions.
+   - The method should take the current index `start`, the current partition `partition`, and the list to store all partitions `result`.
+   - Base case: If `start` reaches the end of the string `s`, add the current partition to the result list and return.
+   - Iterate from `start` to the end of the string:
+     - Check if the substring from `start` to `i` is a palindrome.
+     - If it is a palindrome, add the substring to the current partition and recursively call the `backtrack` method with the updated index and partition.
+     - After the recursive call, remove the last substring added to the partition to backtrack and explore other partitions.
+
+4. **Initialize a list to store all partitions**: Create an ArrayList named `result` to store all possible palindrome partitions.
+
+5. **Call the helper method**: Call the `backtrack` method with the initial index, an empty partition list, and the result list.
+
+6. **Return the result list**: After exploring all possible partitions, return the list containing all palindrome partitions.
+
+Here's the Java implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    public List<List<String>> partition(String s) {
+        List<List<String>> result = new ArrayList<>();
+        backtrack(s, 0, new ArrayList<>(), result);
+        return result;
+    }
+    
+    // Recursive helper method to find all possible palindrome partitions
+    private void backtrack(String s, int start, List<String> partition, List<List<String>> result) {
+        if (start == s.length()) {
+            result.add(new ArrayList<>(partition));
+            return;
+        }
+        
+        for (int i = start; i < s.length(); i++) {
+            String substring = s.substring(start, i + 1);
+            if (isPalindrome(substring)) {
+                partition.add(substring);
+                backtrack(s, i + 1, partition, result);
+                partition.remove(partition.size() - 1); // Backtrack
+            }
+        }
+    }
+    
+    // Helper method to check if a string is a palindrome
+    private boolean isPalindrome(String s) {
+        int left = 0;
+        int right = s.length() - 1;
+        while (left < right) {
+            if (s.charAt(left) != s.charAt(right)) {
+                return false;
+            }
+            left++;
+            right--;
+        }
+        return true;
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently finds all possible palindrome partitions of the given string in Java.

src/main/cpp/g0101_0200/s0136_single_number/readme.md

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 136\. Single Number
+
+Easy
+
+Given a **non-empty** array of integers `nums`, every element appears _twice_ except for one. Find that single one.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [2,2,1]
+
+**Output:** 1 
+
+**Example 2:**
+
+**Input:** nums = [4,1,2,1,2]
+
+**Output:** 4 
+
+**Example 3:**
+
+**Input:** nums = [1]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>-3 * 10<sup>4</sup> <= nums[i] <= 3 * 10<sup>4</sup></code>
+*   Each element in the array appears twice except for one element which appears only once.
+
+To solve the "Single Number" problem in Java with a `Solution` class, we'll use bitwise XOR operation. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `singleNumber` method**: This method takes an array `nums` as input and returns the single number that appears only once.
+
+3. **Initialize a variable to store the result**: Initialize a variable `singleNumber` to 0.
+
+4. **Iterate through the array and perform bitwise XOR operation**: Iterate through the array `nums`. For each number `num` in the array, perform bitwise XOR operation with the `singleNumber`.
+
+5. **Return the result**: After iterating through the entire array, the `singleNumber` variable will store the single number that appears only once. Return `singleNumber`.
+
+Here's the Java implementation:
+
+```java
+class Solution {
+    public int singleNumber(int[] nums) {
+        int singleNumber = 0; // Initialize variable to store result
+        
+        // Perform bitwise XOR operation on all elements in the array
+        for (int num : nums) {
+            singleNumber ^= num;
+        }
+        
+        return singleNumber; // Return the single number
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently finds the single number that appears only once in the given array using bitwise XOR operation in Java.

src/main/cpp/g0101_0200/s0138_copy_list_with_random_pointer/readme.md

@@ -0,0 +1,123 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 138\. Copy List with Random Pointer
+
+Medium
+
+A linked list of length `n` is given such that each node contains an additional random pointer, which could point to any node in the list, or `null`.
+
+Construct a [**deep copy**](https://en.wikipedia.org/wiki/Object_copying#Deep_copy) of the list. The deep copy should consist of exactly `n` **brand new** nodes, where each new node has its value set to the value of its corresponding original node. Both the `next` and `random` pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. **None of the pointers in the new list should point to nodes in the original list**.
+
+For example, if there are two nodes `X` and `Y` in the original list, where `X.random --> Y`, then for the corresponding two nodes `x` and `y` in the copied list, `x.random --> y`.
+
+Return _the head of the copied linked list_.
+
+The linked list is represented in the input/output as a list of `n` nodes. Each node is represented as a pair of `[val, random_index]` where:
+
+*   `val`: an integer representing `Node.val`
+*   `random_index`: the index of the node (range from `0` to `n-1`) that the `random` pointer points to, or `null` if it does not point to any node.
+
+Your code will **only** be given the `head` of the original linked list.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/12/18/e1.png)
+
+**Input:** head = \[\[7,null],[13,0],[11,4],[10,2],[1,0]]
+
+**Output:** [[7,null],[13,0],[11,4],[10,2],[1,0]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2019/12/18/e2.png)
+
+**Input:** head = \[\[1,1],[2,1]]
+
+**Output:** [[1,1],[2,1]] 
+
+**Example 3:**
+
+**![](https://assets.leetcode.com/uploads/2019/12/18/e3.png)**
+
+**Input:** head = \[\[3,null],[3,0],[3,null]]
+
+**Output:** [[3,null],[3,0],[3,null]] 
+
+**Example 4:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Explanation:** The given linked list is empty (null pointer), so return null. 
+
+**Constraints:**
+
+*   `0 <= n <= 1000`
+*   `-10000 <= Node.val <= 10000`
+*   `Node.random` is `null` or is pointing to some node in the linked list.
+
+To solve the "Copy List with Random Pointer" problem in Java with a `Solution` class, we'll use a HashMap to maintain a mapping between the original nodes and their corresponding copied nodes. Below are the steps:
+
+1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
+
+2. **Create a `copyRandomList` method**: This method takes the head node of the original linked list as input and returns the head node of the copied linked list.
+
+3. **Initialize a HashMap**: Create a HashMap named `nodeMap` to store the mapping between original nodes and their corresponding copied nodes.
+
+4. **Create a deep copy of the list**: Iterate through the original linked list and create a deep copy of each node. For each node `originalNode` in the original linked list:
+   - Create a new node `copyNode` with the same value as `originalNode`.
+   - Put the mapping between `originalNode` and `copyNode` in the `nodeMap`.
+   - Set the `copyNode`'s `next` and `random` pointers accordingly.
+   - Attach the `copyNode` to the copied linked list.
+
+5. **Return the head of the copied linked list**: After creating the deep copy of the entire list, return the head node of the copied linked list.
+
+Here's the Java implementation:
+
+```java
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public Node copyRandomList(Node head) {
+        if (head == null) return null; // Check for empty list
+        
+        Map<Node, Node> nodeMap = new HashMap<>(); // Initialize HashMap to store mapping between original and copied nodes
+        
+        // Create a deep copy of each node in the list
+        Node current = head;
+        while (current != null) {
+            Node copyNode = new Node(current.val); // Create a new copy node
+            nodeMap.put(current, copyNode); // Put mapping between original and copied nodes in the map
+            current = current.next; // Move to the next node
+        }
+        
+        // Set the next and random pointers of copied nodes
+        current = head;
+        while (current != null) {
+            Node copyNode = nodeMap.get(current); // Get copied node
+            copyNode.next = nodeMap.getOrDefault(current.next, null); // Set next pointer
+            copyNode.random = nodeMap.getOrDefault(current.random, null); // Set random pointer
+            current = current.next; // Move to the next node
+        }
+        
+        return nodeMap.get(head); // Return the head of the copied linked list
+    }
+    
+    // Definition for a Node
+    class Node {
+        int val;
+        Node next, random;
+        
+        Node(int val) {
+            this.val = val;
+            this.next = null;
+            this.random = null;
+        }
+    }
+}
+```
+
+This implementation follows the steps outlined above and efficiently constructs a deep copy of the linked list with random pointers in Java.

src/main/cpp/g0101_0200/s0139_word_break/readme.md

@@ -0,0 +1,86 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 139\. Word Break
+
+Medium
+
+Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s` can be segmented into a space-separated sequence of one or more dictionary words.
+
+**Note** that the same word in the dictionary may be reused multiple times in the segmentation.
+
+**Example 1:**
+
+**Input:** s = "leetcode", wordDict = ["leet","code"]
+
+**Output:** true
+
+**Explanation:** Return true because "leetcode" can be segmented as "leet code". 
+
+**Example 2:**
+
+**Input:** s = "applepenapple", wordDict = ["apple","pen"]
+
+**Output:** true
+
+**Explanation:** Return true because "applepenapple" can be segmented as "apple pen apple". Note that you are allowed to reuse a dictionary word. 
+
+**Example 3:**
+
+**Input:** s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
+
+**Output:** false 
+
+**Constraints:**
+
+*   `1 <= s.length <= 300`
+*   `1 <= wordDict.length <= 1000`
+*   `1 <= wordDict[i].length <= 20`
+*   `s` and `wordDict[i]` consist of only lowercase English letters.
+*   All the strings of `wordDict` are **unique**.
+
+## Solution
+
+```cpp
+#include <string>
+#include <vector>
+#include <unordered_set>
+using namespace std;
+
+class Solution {
+public:
+    bool wordBreak(string s, vector<string>& wordDict) {
+        unordered_set<string> set;
+        int maxLen = 0;
+        vector<bool> flag(s.length() + 1, false);
+
+        for (const string& word : wordDict) {
+            set.insert(word);
+            maxLen = max(maxLen, (int)word.length());
+        }
+
+        for (int i = 1; i <= maxLen; ++i) {
+            if (dfs(s, 0, i, maxLen, set, flag)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+private:
+    bool dfs(const string& s, int start, int end, int maxLen, unordered_set<string>& set, vector<bool>& flag) {
+        if (!flag[end] && set.count(s.substr(start, end - start))) {
+            flag[end] = true;
+            if (end == s.length()) {
+                return true;
+            }
+            for (int i = 1; i <= maxLen; ++i) {
+                if (end + i <= s.length() && dfs(s, end, end + i, maxLen, set, flag)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+};
+```

src/main/cpp/g0101_0200/s0141_linked_list_cycle/readme.md

@@ -0,0 +1,81 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 141\. Linked List Cycle
+
+Easy
+
+Given `head`, the head of a linked list, determine if the linked list has a cycle in it.
+
+There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to. **Note that `pos` is not passed as a parameter**.
+
+Return `true` _if there is a cycle in the linked list_. Otherwise, return `false`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png)
+
+**Input:** head = [3,2,0,-4], pos = 1
+
+**Output:** true
+
+**Explanation:** There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed). 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png)
+
+**Input:** head = [1,2], pos = 0
+
+**Output:** true
+
+**Explanation:** There is a cycle in the linked list, where the tail connects to the 0th node. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png)
+
+**Input:** head = [1], pos = -1
+
+**Output:** false
+
+**Explanation:** There is no cycle in the linked list. 
+
+**Constraints:**
+
+*   The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+*   `pos` is `-1` or a **valid index** in the linked-list.
+
+**Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
+
+## Solution
+
+```cpp
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode* head) {
+        if (head == nullptr) {
+            return false;
+        }
+        ListNode* fast = head->next;
+        ListNode* slow = head;
+        while (fast != nullptr && fast->next != nullptr) {
+            if (fast == slow) {
+                return true;
+            }
+            fast = fast->next->next;
+            slow = slow->next;
+        }
+        return false;
+    }
+};
+```

src/main/cpp/g0101_0200/s0142_linked_list_cycle_ii/readme.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 142\. Linked List Cycle II
+
+Medium
+
+Given the `head` of a linked list, return _the node where the cycle begins. If there is no cycle, return_ `null`.
+
+There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to (**0-indexed**). It is `-1` if there is no cycle. **Note that** `pos` **is not passed as a parameter**.
+
+**Do not modify** the linked list.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png)
+
+**Input:** head = [3,2,0,-4], pos = 1
+
+**Output:** tail connects to node index 1
+
+**Explanation:** There is a cycle in the linked list, where tail connects to the second node. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png)
+
+**Input:** head = [1,2], pos = 0
+
+**Output:** tail connects to node index 0
+
+**Explanation:** There is a cycle in the linked list, where tail connects to the first node. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png)
+
+**Input:** head = [1], pos = -1
+
+**Output:** no cycle
+
+**Explanation:** There is no cycle in the linked list. 
+
+**Constraints:**
+
+*   The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+*   `pos` is `-1` or a **valid index** in the linked-list.
+
+**Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
+
+## Solution
+
+```cpp
+class Solution {
+public:
+    ListNode* detectCycle(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) {
+            return nullptr;
+        }
+        ListNode* slow = head;
+        ListNode* fast = head;
+        while (fast != nullptr && fast->next != nullptr) {
+            fast = fast->next->next;
+            slow = slow->next;
+            // Intersected inside the loop.
+            if (slow == fast) {
+                break;
+            }
+        }
+        if (fast == nullptr || fast->next == nullptr) {
+            return nullptr;
+        }
+        slow = head;
+        while (slow != fast) {
+            slow = slow->next;
+            fast = fast->next;
+        }
+        return slow;
+    }
+};
+```

src/main/cpp/g0101_0200/s0146_lru_cache/readme.md

@@ -0,0 +1,141 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 146\. LRU Cache
+
+Medium
+
+Design a data structure that follows the constraints of a **[Least Recently Used (LRU) cache](https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU)**.
+
+Implement the `LRUCache` class:
+
+*   `LRUCache(int capacity)` Initialize the LRU cache with **positive** size `capacity`.
+*   `int get(int key)` Return the value of the `key` if the key exists, otherwise return `-1`.
+*   `void put(int key, int value)` Update the value of the `key` if the `key` exists. Otherwise, add the `key-value` pair to the cache. If the number of keys exceeds the `capacity` from this operation, **evict** the least recently used key.
+
+The functions `get` and `put` must each run in `O(1)` average time complexity.
+
+**Example 1:**
+
+**Input** ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+
+**Output:** [null, null, null, 1, null, -1, null, -1, 3, 4]
+
+**Explanation:**
+
+    LRUCache lRUCache = new LRUCache(2);
+    lRUCache.put(1, 1); // cache is {1=1}
+    lRUCache.put(2, 2); // cache is {1=1, 2=2}
+    lRUCache.get(1); // return 1
+    lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
+    lRUCache.get(2); // returns -1 (not found)
+    lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+    lRUCache.get(1); // return -1 (not found)
+    lRUCache.get(3); // return 3
+    lRUCache.get(4); // return 4 
+
+**Constraints:**
+
+*   `1 <= capacity <= 3000`
+*   <code>0 <= key <= 10<sup>4</sup></code>
+*   <code>0 <= value <= 10<sup>5</sup></code>
+*   At most 2<code> * 10<sup>5</sup></code> calls will be made to `get` and `put`.
+
+## Solution
+
+```cpp
+#include <unordered_map>
+
+class LRUCache {
+private:
+    struct LruCacheNode {
+        int key;
+        int value;
+        LruCacheNode* prev;
+        LruCacheNode* next;
+
+        LruCacheNode(int k, int v) : key(k), value(v), prev(nullptr), next(nullptr) {}
+    };
+
+    int capacity;
+    std::unordered_map<int, LruCacheNode*> cacheMap;
+    LruCacheNode* head;
+    LruCacheNode* tail;
+
+public:
+    LRUCache(int cap) : capacity(cap), head(nullptr), tail(nullptr) {}
+
+    int get(int key) {
+        auto it = cacheMap.find(key);
+        if (it == cacheMap.end()) {
+            return -1;
+        }
+        LruCacheNode* val = it->second;
+        moveToHead(val);
+        return val->value;
+    }
+
+    void put(int key, int value) {
+        auto it = cacheMap.find(key);
+        if (it != cacheMap.end()) {
+            LruCacheNode* valNode = it->second;
+            valNode->value = value;
+            moveToHead(valNode);
+        } else {
+            if (cacheMap.size() < capacity) {
+                LruCacheNode* node = new LruCacheNode(key, value);
+                cacheMap[key] = node;
+                if (head == nullptr) {
+                    head = node;
+                    tail = node;
+                } else {
+                    node->next = head;
+                    head->prev = node;
+                    head = node;
+                }
+            } else {
+                // Remove from tail
+                LruCacheNode* last = tail;
+                tail = last->prev;
+                if (tail != nullptr) {
+                    tail->next = nullptr;
+                }
+                cacheMap.erase(last->key);
+                delete last;
+                if (cacheMap.size() == 0) {
+                    head = nullptr;
+                }
+                // Call recursively
+                put(key, value);
+            }
+        }
+    }
+
+private:
+    void moveToHead(LruCacheNode* node) {
+        if (node == head) {
+            return;
+        }
+        if (node == tail) {
+            tail = node->prev;
+        }
+        LruCacheNode* prev = node->prev;
+        LruCacheNode* next = node->next;
+        prev->next = next;
+        if (next != nullptr) {
+            next->prev = prev;
+        }
+        node->prev = nullptr;
+        node->next = head;
+        head->prev = node;
+        head = node;
+    }
+};
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache* obj = new LRUCache(capacity);
+ * int param_1 = obj->get(key);
+ * obj->put(key,value);
+ */
+```

src/main/cpp/g0101_0200/s0148_sort_list/readme.md

@@ -0,0 +1,81 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 148\. Sort List
+
+Medium
+
+Given the `head` of a linked list, return _the list after sorting it in **ascending order**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg)
+
+**Input:** head = [4,2,1,3]
+
+**Output:** [1,2,3,4] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg)
+
+**Input:** head = [-1,5,3,4,0]
+
+**Output:** [-1,0,3,4,5] 
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+
+**Follow up:** Can you sort the linked list in `O(n logn)` time and `O(1)` memory (i.e. constant space)?
+
+## Solution
+
+```cpp
+class Solution {
+public:
+    ListNode* sortList(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) {
+            return head;
+        }
+        ListNode* slow = head;
+        ListNode* fast = head;
+        ListNode* pre = slow;
+        while (fast != nullptr && fast->next != nullptr) {
+            pre = slow;
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        pre->next = nullptr;
+        ListNode* first = sortList(head);
+        ListNode* second = sortList(slow);
+        ListNode* res = new ListNode(1);
+        ListNode* cur = res;
+        while (first != nullptr || second != nullptr) {
+            if (first == nullptr) {
+                cur->next = second;
+                break;
+            } else if (second == nullptr) {
+                cur->next = first;
+                break;
+            } else if (first->val <= second->val) {
+                cur->next = first;
+                first = first->next;
+                cur = cur->next;
+            } else {
+                cur->next = second;
+                second = second->next;
+                cur = cur->next;
+            }
+        }
+        return res->next;
+    }
+};
+```

src/main/cpp/g0101_0200/s0152_maximum_product_subarray/readme.md

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 152\. Maximum Product Subarray
+
+Medium
+
+Given an integer array `nums`, find a contiguous non-empty subarray within the array that has the largest product, and return _the product_.
+
+It is **guaranteed** that the answer will fit in a **32-bit** integer.
+
+A **subarray** is a contiguous subsequence of the array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,-2,4]
+
+**Output:** 6
+
+**Explanation:** [2,3] has the largest product 6. 
+
+**Example 2:**
+
+**Input:** nums = [-2,0,-1]
+
+**Output:** 0
+
+**Explanation:** The result cannot be 2, because [-2,-1] is not a subarray. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   `-10 <= nums[i] <= 10`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+## Solution
+
+```cpp
+#include <vector>
+#include <algorithm>
+
+class Solution {
+public:
+    int maxProduct(std::vector<int>& nums) {
+        int ans = INT_MIN;
+        int cprod = 1;
+        for (int j : nums) {
+            cprod *= j;
+            ans = std::max(ans, cprod);
+            if (cprod == 0) {
+                cprod = 1;
+            }
+        }
+        cprod = 1;
+        for (int i = nums.size() - 1; i >= 0; i--) {
+            cprod *= nums[i];
+            ans = std::max(ans, cprod);
+            if (cprod == 0) {
+                cprod = 1;
+            }
+        }
+        return ans;
+    }
+};
+```

src/main/cpp/g0101_0200/s0153_find_minimum_in_rotated_sorted_array/readme.md

@@ -0,0 +1,84 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 153\. Find Minimum in Rotated Sorted Array
+
+Medium
+
+Suppose an array of length `n` sorted in ascending order is **rotated** between `1` and `n` times. For example, the array `nums = [0,1,2,4,5,6,7]` might become:
+
+*   `[4,5,6,7,0,1,2]` if it was rotated `4` times.
+*   `[0,1,2,4,5,6,7]` if it was rotated `7` times.
+
+Notice that **rotating** an array `[a[0], a[1], a[2], ..., a[n-1]]` 1 time results in the array `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`.
+
+Given the sorted rotated array `nums` of **unique** elements, return _the minimum element of this array_.
+
+You must write an algorithm that runs in `O(log n) time.`
+
+**Example 1:**
+
+**Input:** nums = [3,4,5,1,2]
+
+**Output:** 1
+
+**Explanation:** The original array was [1,2,3,4,5] rotated 3 times. 
+
+**Example 2:**
+
+**Input:** nums = [4,5,6,7,0,1,2]
+
+**Output:** 0
+
+**Explanation:** The original array was [0,1,2,4,5,6,7] and it was rotated 4 times. 
+
+**Example 3:**
+
+**Input:** nums = [11,13,15,17]
+
+**Output:** 11
+
+**Explanation:** The original array was [11,13,15,17] and it was rotated 4 times. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   `1 <= n <= 5000`
+*   `-5000 <= nums[i] <= 5000`
+*   All the integers of `nums` are **unique**.
+*   `nums` is sorted and rotated between `1` and `n` times.
+
+## Solution
+
+```cpp
+#include <vector>
+
+class Solution {
+private:
+    int findMinUtil(std::vector<int>& nums, int l, int r) {
+        if (l == r) {
+            return nums[l];
+        }
+        int mid = (l + r) / 2;
+        if (mid == l && nums[mid] < nums[r]) {
+            return nums[l];
+        }
+        if (mid - 1 >= 0 && nums[mid - 1] > nums[mid]) {
+            return nums[mid];
+        }
+        if (nums[mid] < nums[l]) {
+            return findMinUtil(nums, l, mid - 1);
+        } else if (nums[mid] > nums[r]) {
+            return findMinUtil(nums, mid + 1, r);
+        }
+        return findMinUtil(nums, l, mid - 1);
+    }
+
+public:
+    int findMin(std::vector<int>& nums) {
+        int l = 0;
+        int r = nums.size() - 1;
+        return findMinUtil(nums, l, r);
+    }
+};
+```

src/main/cpp/g0101_0200/s0155_min_stack/readme.md

@@ -0,0 +1,113 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 155\. Min Stack
+
+Easy
+
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+Implement the `MinStack` class:
+
+*   `MinStack()` initializes the stack object.
+*   `void push(int val)` pushes the element `val` onto the stack.
+*   `void pop()` removes the element on the top of the stack.
+*   `int top()` gets the top element of the stack.
+*   `int getMin()` retrieves the minimum element in the stack.
+
+**Example 1:**
+
+**Input**
+
+    ["MinStack","push","push","push","getMin","pop","top","getMin"]
+    [[],[-2],[0],[-3],[],[],[],[]]
+
+**Output:** [null,null,null,null,-3,null,0,-2]
+
+**Explanation:**
+
+    MinStack minStack = new MinStack();
+    minStack.push(-2);
+    minStack.push(0);
+    minStack.push(-3);
+    minStack.getMin(); // return -3
+    minStack.pop();
+    minStack.top(); // return 0
+    minStack.getMin(); // return -2 
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   Methods `pop`, `top` and `getMin` operations will always be called on **non-empty** stacks.
+*   At most <code>3 * 10<sup>4</sup></code> calls will be made to `push`, `pop`, `top`, and `getMin`.
+
+## Solution
+
+```cpp
+#include <stack>
+#include <algorithm>
+
+class MinStack {
+private:
+    struct Node {
+        int min;
+        int data;
+        Node* nextNode;
+        Node* previousNode;
+
+        Node(int min, int data, Node* previousNode, Node* nextNode)
+            : min(min), data(data), previousNode(previousNode), nextNode(nextNode) {}
+    };
+
+    Node* currentNode;
+
+public:
+    MinStack() : currentNode(nullptr) {}
+
+    void push(int val) {
+        if (currentNode == nullptr) {
+            currentNode = new Node(val, val, nullptr, nullptr);
+        } else {
+            currentNode->nextNode = new Node(std::min(currentNode->min, val), val, currentNode, nullptr);
+            currentNode = currentNode->nextNode;
+        }
+    }
+
+    void pop() {
+        if (currentNode != nullptr) {
+            currentNode = currentNode->previousNode;
+        }
+    }
+
+    int top() {
+        if (currentNode != nullptr) {
+            return currentNode->data;
+        }
+        return -1;
+    }
+
+    int getMin() {
+        if (currentNode != nullptr) {
+            return currentNode->min;
+        }
+        return -1;
+    }
+
+    ~MinStack() {
+        while (currentNode != nullptr) {
+            Node* temp = currentNode;
+            currentNode = currentNode->previousNode;
+            delete temp;
+        }
+    }
+};
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack* obj = new MinStack();
+ * obj->push(val);
+ * obj->pop();
+ * int param_3 = obj->top();
+ * int param_4 = obj->getMin();
+ */
+```