update readme 50-72

Author: ThanhNIT

src/main/java/g0001_0100/s0050_powx_n/readme.md

@@ -28,4 +28,6 @@ Implement [pow(x, n)](http://www.cplusplus.com/reference/valarray/pow/), which c
 
 *   `-100.0 < x < 100.0`
 *   <code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code>
+*   `n` is an integer.
+*   Either `x` is not zero or `n > 0`.
 *   <code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code>

src/main/java/g0001_0100/s0053_maximum_subarray/readme.md

@@ -1,30 +1,32 @@
 53\. Maximum Subarray
 
-Easy
+Medium
 
-Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return _its sum_.
-
-A **subarray** is a **contiguous** part of an array.
+Given an integer array `nums`, find the **non-empty subarrays** with the largest sum, and return _its sum_.
 
 **Example 1:**
 
 **Input:** nums = [-2,1,-3,4,-1,2,1,-5,4]
 
 **Output:** 6
 
-**Explanation:** [4,-1,2,1] has the largest sum = 6. 
+**Explanation:** The subarray [4,-1,2,1] has the largest sum 6. 
 
 **Example 2:**
 
 **Input:** nums = [1]
 
-**Output:** 1 
+**Output:** 1
+
+**Explanation:** The subarray [1] has the largest sum 1. 
 
 **Example 3:**
 
 **Input:** nums = [5,4,-1,7,8]
 
-**Output:** 23 
+**Output:** 23
+
+**Explanation:** The subarray [5,4,-1,7,8] has the largest sum 23. 
 
 **Constraints:**
 

src/main/java/g0001_0100/s0056_merge_intervals/readme.md

@@ -10,7 +10,7 @@ Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end
 
 **Output:** [[1,6],[8,10],[15,18]]
 
-**Explanation:** Since intervals [1,3] and [2,6] overlaps, merge them into [1,6]. 
+**Explanation:** Since intervals [1,3] and [2,6] overlap, merge them into [1,6]. 
 
 **Example 2:**
 
@@ -20,41 +20,16 @@ Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end
 
 **Explanation:** Intervals [1,4] and [4,5] are considered overlapping. 
 
+**Example 3:**
+
+**Input:** intervals = [[4,7],[1,4]]
+
+**Output:** [[1,7]]
+
+**Explanation:** Intervals [1,4] and [4,7] are considered overlapping. 
+
 **Constraints:**
 
 *   <code>1 <= intervals.length <= 10<sup>4</sup></code>
 *   `intervals[i].length == 2`
-*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>
-
-To solve the "Merge Intervals" problem in Java with the Solution class, follow these steps:
-
-1. Define a method `merge` in the `Solution` class that takes an array of integer arrays `intervals` as input and returns an array of the non-overlapping intervals that cover all the intervals in the input.
-2. Sort the intervals based on the start times.
-3. Initialize an ArrayList to store the merged intervals.
-4. Iterate through the sorted intervals:
-   - If the list of merged intervals is empty or the current interval's start time is greater than the end time of the last merged interval, add the current interval to the list of merged intervals.
-   - Otherwise, merge the current interval with the last merged interval by updating its end time if needed.
-5. Convert the ArrayList of merged intervals into an array and return it as the result.
-
-Here's the implementation of the `merge` method in Java:
-
-```java
-import java.util.*;
-
-class Solution {
-    public int[][] merge(int[][] intervals) {
-        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
-        List<int[]> merged = new ArrayList<>();
-        for (int[] interval : intervals) {
-            if (merged.isEmpty() || interval[0] > merged.get(merged.size() - 1)[1]) {
-                merged.add(interval);
-            } else {
-                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], interval[1]);
-            }
-        }
-        return merged.toArray(new int[merged.size()][]);
-    }
-}
-```
-
-This implementation efficiently merges overlapping intervals in the given array `intervals` using sorting and iteration, with a time complexity of O(n log n) due to sorting.
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>

src/main/java/g0001_0100/s0057_insert_interval/readme.md

@@ -8,6 +8,8 @@ Insert `newInterval` into `intervals` such that `intervals` is still sorted in a
 
 Return `intervals` _after the insertion_.
 
+**Note** that you don't need to modify `intervals` in-place. You can make a new array and return it.
+
 **Example 1:**
 
 **Input:** intervals = [[1,3],[6,9]], newInterval = [2,5]
@@ -20,25 +22,7 @@ Return `intervals` _after the insertion_.
 
 **Output:** [[1,2],[3,10],[12,16]]
 
-**Explanation:** Because the new interval `[4,8]` overlaps with `[3,5],[6,7],[8,10]`.
-
-**Example 3:**
-
-**Input:** intervals = [], newInterval = [5,7]
-
-**Output:** [[5,7]] 
-
-**Example 4:**
-
-**Input:** intervals = [[1,5]], newInterval = [2,3]
-
-**Output:** [[1,5]] 
-
-**Example 5:**
-
-**Input:** intervals = [[1,5]], newInterval = [2,7]
-
-**Output:** [[1,7]] 
+**Explanation:** Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10]. 
 
 **Constraints:**
 

src/main/java/g0001_0100/s0058_length_of_last_word/readme.md

@@ -2,9 +2,9 @@
 
 Easy
 
-Given a string `s` consisting of some words separated by some number of spaces, return _the length of the **last** word in the string._
+Given a string `s` consisting of words and spaces, return _the length of the **last** word in the string._
 
-A **word** is a maximal substring consisting of non-space characters only.
+A **word** is a maximal **substring** consisting of non-space characters only.
 
 **Example 1:**
 

src/main/java/g0001_0100/s0062_unique_paths/readme.md

@@ -2,11 +2,11 @@
 
 Medium
 
-A robot is located at the top-left corner of a `m x n` grid (marked 'Start' in the diagram below).
+There is a robot on an `m x n` grid. The robot is initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m - 1][n - 1]`). The robot can only move either down or right at any point in time.
 
-The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+Given the two integers `m` and `n`, return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
 
-How many possible unique paths are there?
+The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
 
 **Example 1:**
 
@@ -22,24 +22,7 @@ How many possible unique paths are there?
 
 **Output:** 3
 
-**Explanation:**
-
-    From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
-    1. Right -> Down -> Down
-    2. Down -> Down -> Right
-    3. Down -> Right -> Down 
-
-**Example 3:**
-
-**Input:** m = 7, n = 3
-
-**Output:** 28 
-
-**Example 4:**
-
-**Input:** m = 3, n = 3
-
-**Output:** 6 
+**Explanation:** From the top-left corner, there are a total of 3 ways to reach the bottom-right corner: 1. Right -> Down -> Down 2. Down -> Down -> Right 3. Down -> Right -> Down 
 
 **Constraints:**
 

src/main/java/g0001_0100/s0063_unique_paths_ii/readme.md

@@ -2,13 +2,13 @@
 
 Medium
 
-A robot is located at the top-left corner of a `m x n` grid (marked 'Start' in the diagram below).
+You are given an `m x n` integer array `grid`. There is a robot initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m - 1][n - 1]`). The robot can only move either down or right at any point in time.
 
-The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+An obstacle and space are marked as `1` or `0` respectively in `grid`. A path that the robot takes cannot include **any** square that is an obstacle.
 
-Now consider if some obstacles are added to the grids. How many unique paths would there be?
+Return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
 
-An obstacle and space is marked as `1` and `0` respectively in the grid.
+The testcases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
 
 **Example 1:**
 

src/main/java/g0001_0100/s0064_minimum_path_sum/readme.md

@@ -27,7 +27,7 @@ Given a `m x n` `grid` filled with non-negative numbers, find a path from top le
 *   `m == grid.length`
 *   `n == grid[i].length`
 *   `1 <= m, n <= 200`
-*   `0 <= grid[i][j] <= 100`
+*   `0 <= grid[i][j] <= 200`
 
 To solve the "Minimum Path Sum" problem in Java with the Solution class, follow these steps:
 

src/main/java/g0001_0100/s0066_plus_one/readme.md

@@ -2,7 +2,7 @@
 
 Easy
 
-You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the `ith` digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.
+You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the <code>i<sup>th</sup></code> digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.
 
 Increment the large integer by one and return _the resulting array of digits_.
 
@@ -24,14 +24,6 @@ Increment the large integer by one and return _the resulting array of digits_.
 
 **Example 3:**
 
-**Input:** digits = [0]
-
-**Output:** [1]
-
-**Explanation:** The array represents the integer 0. Incrementing by one gives 0 + 1 = 1. Thus, the result should be [1]. 
-
-**Example 4:**
-
 **Input:** digits = [9]
 
 **Output:** [1,0]

src/main/java/g0001_0100/s0068_text_justification/readme.md

@@ -8,12 +8,12 @@ You should pack your words in a greedy approach; that is, pack as many words as
 
 Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line does not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.
 
-For the last line of text, it should be left-justified and no extra space is inserted between words.
+For the last line of text, it should be left-justified, and no extra space is inserted between words.
 
 **Note:**
 
 *   A word is defined as a character sequence consisting of non-space characters only.
-*   Each word's length is guaranteed to be greater than 0 and not exceed maxWidth.
+*   Each word's length is guaranteed to be greater than `0` and not exceed `maxWidth`.
 *   The input array `words` contains at least one word.
 
 **Example 1:**
@@ -28,7 +28,7 @@ For the last line of text, it should be left-justified and no extra space is ins
 
 **Output:** [ "What must be", "acknowledgment ", "shall be " ]
 
-**Explanation:** Note that the last line is "shall be " instead of "shall be", because the last line must be left-justified instead of fully-justified. Note that the second line is also left-justified becase it contains only one word.
+**Explanation:** Note that the last line is "shall be " instead of "shall be", because the last line must be left-justified instead of fully-justified. Note that the second line is also left-justified because it contains only one word.
 
 **Example 3:**