Added descriptions 121-140.

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

@@ -0,0 +1,30 @@
+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>

src/main/java/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/readme.md

@@ -0,0 +1,38 @@
+122\. Best Time to Buy and Sell Stock II
+
+Medium
+
+You are given an integer array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+On each day, you may decide to buy and/or sell the stock. You can only hold **at most one** share of the stock at any time. However, you can buy it then immediately sell it on the **same day**.
+
+Find and return _the **maximum** profit you can achieve_.
+
+**Example 1:**
+
+**Input:** prices = \[7,1,5,3,6,4\]
+
+**Output:** 7
+
+**Explanation:** Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4. Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3. Total profit is 4 + 3 = 7. 
+
+**Example 2:**
+
+**Input:** prices = \[1,2,3,4,5\]
+
+**Output:** 4
+
+**Explanation:** Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4. Total profit is 4. 
+
+**Example 3:**
+
+**Input:** prices = \[7,6,4,3,1\]
+
+**Output:** 0
+
+**Explanation:** There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0. 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 3 * 10<sup>4</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>4</sup></code>

src/main/java/g0101_0200/s0123_best_time_to_buy_and_sell_stock_iii/readme.md

@@ -0,0 +1,44 @@
+123\. Best Time to Buy and Sell Stock III
+
+Hard
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+Find the maximum profit you can achieve. You may complete **at most two transactions**.
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+**Example 1:**
+
+**Input:** prices = \[3,3,5,0,0,3,1,4\]
+
+**Output:** 6
+
+**Explanation:** Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3. Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.
+
+**Example 2:**
+
+**Input:** prices = \[1,2,3,4,5\]
+
+**Output:** 4
+
+**Explanation:** Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4. Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again. 
+
+**Example 3:**
+
+**Input:** prices = \[7,6,4,3,1\]
+
+**Output:** 0
+
+**Explanation:** In this case, no transaction is done, i.e. max profit = 0. 
+
+**Example 4:**
+
+**Input:** prices = \[1\]
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>5</sup></code>

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

@@ -0,0 +1,34 @@
+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`

src/main/java/g0101_0200/s0125_valid_palindrome/readme.md

@@ -0,0 +1,36 @@
+125\. Valid Palindrome
+
+Easy
+
+A phrase is a **palindrome** if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.
+
+Given a string `s`, return `true` _if it is a **palindrome**, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s = "A man, a plan, a canal: Panama"
+
+**Output:** true
+
+**Explanation:** "amanaplanacanalpanama" is a palindrome. 
+
+**Example 2:**
+
+**Input:** s = "race a car"
+
+**Output:** false
+
+**Explanation:** "raceacar" is not a palindrome. 
+
+**Example 3:**
+
+**Input:** s = " "
+
+**Output:** true
+
+**Explanation:** s is an empty string "" after removing non-alphanumeric characters. Since an empty string reads the same forward and backward, it is a palindrome. 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 2 * 10<sup>5</sup></code>
+*   `s` consists only of printable ASCII characters.

src/main/java/g0101_0200/s0126_word_ladder_ii/readme.md

@@ -0,0 +1,37 @@
+126\. Word Ladder II
+
+Hard
+
+A **transformation sequence** from word `beginWord` to word `endWord` using a dictionary `wordList` is a sequence of words <code>beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub></code> such that:
+
+*   Every adjacent pair of words differs by a single letter.
+*   Every <code>s<sub>i</sub></code> for `1 <= i <= k` is in `wordList`. Note that `beginWord` does not need to be in `wordList`.
+*   <code>s<sub>k</sub> == endWord</code>
+
+Given two words, `beginWord` and `endWord`, and a dictionary `wordList`, return _all the **shortest transformation sequences** from_ `beginWord` _to_ `endWord`_, or an empty list if no such sequence exists. Each sequence should be returned as a list of the words_ <code>[beginWord, s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub>]</code>.
+
+**Example 1:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = \["hot","dot","dog","lot","log","cog"\]
+
+**Output:** \[\["hit","hot","dot","dog","cog"\],\["hit","hot","lot","log","cog"\]\]
+
+**Explanation:** There are 2 shortest transformation sequences: "hit" -> "hot" -> "dot" -> "dog" -> "cog" "hit" -> "hot" -> "lot" -> "log" -> "cog" 
+
+**Example 2:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = \["hot","dot","dog","lot","log"\]
+
+**Output:** \[\]
+
+**Explanation:** The endWord "cog" is not in wordList, therefore there is no valid transformation sequence. 
+
+**Constraints:**
+
+*   `1 <= beginWord.length <= 5`
+*   `endWord.length == beginWord.length`
+*   `1 <= wordList.length <= 1000`
+*   `wordList[i].length == beginWord.length`
+*   `beginWord`, `endWord`, and `wordList[i]` consist of lowercase English letters.
+*   `beginWord != endWord`
+*   All the words in `wordList` are **unique**.

src/main/java/g0101_0200/s0127_word_ladder/readme.md

@@ -0,0 +1,37 @@
+127\. Word Ladder
+
+Hard
+
+A **transformation sequence** from word `beginWord` to word `endWord` using a dictionary `wordList` is a sequence of words <code>beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub></code> such that:
+
+*   Every adjacent pair of words differs by a single letter.
+*   Every <code>s<sub>i</sub></code> for `1 <= i <= k` is in `wordList`. Note that `beginWord` does not need to be in `wordList`.
+*   <code>s<sub>k</sub> == endWord</code>
+
+Given two words, `beginWord` and `endWord`, and a dictionary `wordList`, return _the **number of words** in the **shortest transformation sequence** from_ `beginWord` _to_ `endWord`_, or_ `0` _if no such sequence exists._
+
+**Example 1:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = \["hot","dot","dog","lot","log","cog"\]
+
+**Output:** 5
+
+**Explanation:** One shortest transformation sequence is "hit" -> "hot" -> "dot" -> "dog" -> cog", which is 5 words long. 
+
+**Example 2:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = \["hot","dot","dog","lot","log"\]
+
+**Output:** 0
+
+**Explanation:** The endWord "cog" is not in wordList, therefore there is no valid transformation sequence. 
+
+**Constraints:**
+
+*   `1 <= beginWord.length <= 10`
+*   `endWord.length == beginWord.length`
+*   `1 <= wordList.length <= 5000`
+*   `wordList[i].length == beginWord.length`
+*   `beginWord`, `endWord`, and `wordList[i]` consist of lowercase English letters.
+*   `beginWord != endWord`
+*   All the words in `wordList` are **unique**.

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

@@ -0,0 +1,26 @@
+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>

src/main/java/g0101_0200/s0129_sum_root_to_leaf_numbers/readme.md

@@ -0,0 +1,39 @@
+129\. Sum Root to Leaf Numbers
+
+Medium
+
+You are given the `root` of a binary tree containing digits from `0` to `9` only.
+
+Each root-to-leaf path in the tree represents a number.
+
+*   For example, the root-to-leaf path `1 -> 2 -> 3` represents the number `123`.
+
+Return _the total sum of all root-to-leaf numbers_. Test cases are generated so that the answer will fit in a **32-bit** integer.
+
+A **leaf** node is a node with no children.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg)
+
+**Input:** root = \[1,2,3\]
+
+**Output:** 25
+
+**Explanation:** The root-to-leaf path `1->2` represents the number `12`. The root-to-leaf path `1->3` represents the number `13`. Therefore, sum = 12 + 13 = `25`. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg)
+
+**Input:** root = \[4,9,0,5,1\]
+
+**Output:** 1026
+
+**Explanation:** The root-to-leaf path `4->9->5` represents the number 495. The root-to-leaf path `4->9->1` represents the number 491. The root-to-leaf path `4->0` represents the number 40. Therefore, sum = 495 + 491 + 40 = `1026`. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `0 <= Node.val <= 9`
+*   The depth of the tree will not exceed `10`.

src/main/java/g0101_0200/s0130_surrounded_regions/readme.md

@@ -0,0 +1,30 @@
+130\. Surrounded Regions
+
+Medium
+
+Given an `m x n` matrix `board` containing `'X'` and `'O'`, _capture all regions that are 4-directionally surrounded by_ `'X'`.
+
+A region is **captured** by flipping all `'O'`s into `'X'`s in that surrounded region.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/xogrid.jpg)
+
+**Input:** board = \[\["X","X","X","X"\],\["X","O","O","X"\],\["X","X","O","X"\],\["X","O","X","X"\]\]
+
+**Output:** \[\["X","X","X","X"\],\["X","X","X","X"\],\["X","X","X","X"\],\["X","O","X","X"\]\]
+
+**Explanation:** Surrounded regions should not be on the border, which means that any 'O' on the border of the board are not flipped to 'X'. Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'. Two cells are connected if they are adjacent cells connected horizontally or vertically. 
+
+**Example 2:**
+
+**Input:** board = \[\["X"\]\]
+
+**Output:** \[\["X"\]\] 
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   `1 <= m, n <= 200`
+*   `board[i][j]` is `'X'` or `'O'`.

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

@@ -0,0 +1,24 @@
+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.