update

leetcode/problem/divide-intervals-into-minimum-number-of-groups.html

@@ -0,0 +1,37 @@
+<p>You are given a 2D integer array <code>intervals</code> where <code>intervals[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> represents the <strong>inclusive</strong> interval <code>[left<sub>i</sub>, right<sub>i</sub>]</code>.</p>
+
+<p>You have to divide the intervals into one or more <strong>groups</strong> such that each interval is in <strong>exactly</strong> one group, and no two intervals that are in the same group <strong>intersect</strong> each other.</p>
+
+<p>Return <em>the <strong>minimum</strong> number of groups you need to make</em>.</p>
+
+<p>Two intervals <strong>intersect</strong> if there is at least one common number between them. For example, the intervals <code>[1, 5]</code> and <code>[5, 8]</code> intersect.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> intervals = [[5,10],[6,8],[1,5],[2,3],[1,10]]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> We can divide the intervals into the following groups:
+- Group 1: [1, 5], [6, 8].
+- Group 2: [2, 3], [5, 10].
+- Group 3: [1, 10].
+It can be proven that it is not possible to divide the intervals into fewer than 3 groups.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> intervals = [[1,3],[5,6],[8,10],[11,13]]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> None of the intervals overlap, so we can put all of them in one group.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= intervals.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>intervals[i].length == 2</code></li>
+	<li><code>1 &lt;= left<sub>i</sub> &lt;= right<sub>i</sub> &lt;= 10<sup>6</sup></code></li>
+</ul>

leetcode/problem/longest-increasing-subsequence-ii.html

@@ -0,0 +1,52 @@
+<p>You are given an integer array <code>nums</code> and an integer <code>k</code>.</p>
+
+<p>Find the longest subsequence of <code>nums</code> that meets the following requirements:</p>
+
+<ul>
+	<li>The subsequence is <strong>strictly increasing</strong> and</li>
+	<li>The difference between adjacent elements in the subsequence is <strong>at most</strong> <code>k</code>.</li>
+</ul>
+
+<p>Return<em> the length of the <strong>longest</strong> <strong>subsequence</strong> that meets the requirements.</em></p>
+
+<p>A <strong>subsequence</strong> is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [4,2,1,4,3,4,5,8,15], k = 3
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+The longest subsequence that meets the requirements is [1,3,4,5,8].
+The subsequence has a length of 5, so we return 5.
+Note that the subsequence [1,3,4,5,8,15] does not meet the requirements because 15 - 8 = 7 is larger than 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [7,4,5,1,8,12,4,7], k = 5
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+The longest subsequence that meets the requirements is [4,5,8,12].
+The subsequence has a length of 4, so we return 4.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,5], k = 1
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>
+The longest subsequence that meets the requirements is [1].
+The subsequence has a length of 1, so we return 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i], k &lt;= 10<sup>5</sup></code></li>
+</ul>

leetcode/problem/make-two-arrays-equal-by-reversing-subarrays.html

@@ -0,0 +1,42 @@
+<p>You are given two integer arrays of equal length <code>target</code> and <code>arr</code>. In one step, you can select any <strong>non-empty subarray</strong> of <code>arr</code> and reverse it. You are allowed to make any number of steps.</p>
+
+<p>Return <code>true</code> <em>if you can make </em><code>arr</code><em> equal to </em><code>target</code><em>&nbsp;or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = [1,2,3,4], arr = [2,4,1,3]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> You can follow the next steps to convert arr to target:
+1- Reverse subarray [2,4,1], arr becomes [1,4,2,3]
+2- Reverse subarray [4,2], arr becomes [1,2,4,3]
+3- Reverse subarray [4,3], arr becomes [1,2,3,4]
+There are multiple ways to convert arr to target, this is not the only way to do so.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = [7], arr = [7]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> arr is equal to target without any reverses.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = [3,7,9], arr = [3,7,11]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> arr does not have value 9 and it can never be converted to target.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>target.length == arr.length</code></li>
+	<li><code>1 &lt;= target.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= target[i] &lt;= 1000</code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 1000</code></li>
+</ul>

leetcode/problem/most-frequent-even-element.html

@@ -0,0 +1,37 @@
+<p>Given an integer array <code>nums</code>, return <em>the most frequent even element</em>.</p>
+
+<p>If there is a tie, return the <strong>smallest</strong> one. If there is no such element, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1,2,2,4,4,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+The even elements are 0, 2, and 4. Of these, 2 and 4 appear the most.
+We return the smallest one, which is 2.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [4,4,4,9,2,4]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> 4 is the even element appears the most.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [29,47,21,41,13,37,25,7]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> There is no even element.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2000</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>

leetcode/problem/optimal-partition-of-string.html

@@ -0,0 +1,33 @@
+<p>Given a string <code>s</code>, partition the string into one or more <strong>substrings</strong> such that the characters in each substring are <strong>unique</strong>. That is, no letter appears in a single substring more than <strong>once</strong>.</p>
+
+<p>Return <em>the <strong>minimum</strong> number of substrings in such a partition.</em></p>
+
+<p>Note that each character should belong to exactly one substring in a partition.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abacaba&quot;
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+Two possible partitions are (&quot;a&quot;,&quot;ba&quot;,&quot;cab&quot;,&quot;a&quot;) and (&quot;ab&quot;,&quot;a&quot;,&quot;ca&quot;,&quot;ba&quot;).
+It can be shown that 4 is the minimum number of substrings needed.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;ssssss&quot;
+<strong>Output:</strong> 6
+<strong>Explanation:
+</strong>The only valid partition is (&quot;s&quot;,&quot;s&quot;,&quot;s&quot;,&quot;s&quot;,&quot;s&quot;,&quot;s&quot;).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of only English lowercase letters.</li>
+</ul>