Add: new

Author: openset

README.md

@@ -62,6 +62,11 @@ LeetCode Problems' Solutions
 
 | # | Title | Solution | Difficulty |
 | :-: | - | - | :-: |
+| <span id="1210">1210</span> | [Minimum Moves to Reach Target with Rotations](https://leetcode.com/problems/minimum-moves-to-reach-target-with-rotations "穿过迷宫的最少移动次数") | [Go](https://github.com/openset/leetcode/tree/master/problems/minimum-moves-to-reach-target-with-rotations) | Hard |
+| <span id="1209">1209</span> | [Remove All Adjacent Duplicates in String II](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string-ii "删除字符串中的所有相邻重复项 II") | [Go](https://github.com/openset/leetcode/tree/master/problems/remove-all-adjacent-duplicates-in-string-ii) | Medium |
+| <span id="1208">1208</span> | [Get Equal Substrings Within Budget](https://leetcode.com/problems/get-equal-substrings-within-budget "尽可能使字符串相等") | [Go](https://github.com/openset/leetcode/tree/master/problems/get-equal-substrings-within-budget) | Medium |
+| <span id="1207">1207</span> | [Unique Number of Occurrences](https://leetcode.com/problems/unique-number-of-occurrences "独一无二的出现次数") | [Go](https://github.com/openset/leetcode/tree/master/problems/unique-number-of-occurrences) | Easy |
+| <span id="1206">1206</span> | [Design Skiplist](https://leetcode.com/problems/design-skiplist) | [Go](https://github.com/openset/leetcode/tree/master/problems/design-skiplist) | Hard |
 | <span id="1205">1205</span> | [Monthly Transactions II](https://leetcode.com/problems/monthly-transactions-ii) 🔒 | [MySQL](https://github.com/openset/leetcode/tree/master/problems/monthly-transactions-ii) | Medium |
 | <span id="1204">1204</span> | [Last Person to Fit in the Elevator](https://leetcode.com/problems/last-person-to-fit-in-the-elevator) 🔒 | [MySQL](https://github.com/openset/leetcode/tree/master/problems/last-person-to-fit-in-the-elevator) | Medium |
 | <span id="1203">1203</span> | [Sort Items by Groups Respecting Dependencies](https://leetcode.com/problems/sort-items-by-groups-respecting-dependencies "项目管理") | [Go](https://github.com/openset/leetcode/tree/master/problems/sort-items-by-groups-respecting-dependencies) | Hard |

problems/design-skiplist/README.md

@@ -0,0 +1,68 @@
+<!--|This file generated by command(leetcode description); DO NOT EDIT.    |-->
+<!--+----------------------------------------------------------------------+-->
+<!--|@author    openset <[email protected]>                           |-->
+<!--|@link      https://github.com/openset                                 |-->
+<!--|@home      https://github.com/openset/leetcode                        |-->
+<!--+----------------------------------------------------------------------+-->
+
+[< Previous](https://github.com/openset/leetcode/tree/master/problems/monthly-transactions-ii "Monthly Transactions II")
+　　　　　　　　　　　　　　　　
+[Next >](https://github.com/openset/leetcode/tree/master/problems/unique-number-of-occurrences "Unique Number of Occurrences")
+
+## [1206. Design Skiplist (Hard)](https://leetcode.com/problems/design-skiplist "")
+
+<p>Design a Skiplist without using any built-in libraries.</p>
+
+<p><em>A Skiplist is a data structure that takes&nbsp;O(log(n)) time&nbsp;to <code>add</code>, <code>erase</code> and <code>search</code>. Comparing with treap and red-black tree which has the same function and performance, the code length of Skiplist can be&nbsp;comparatively short and the idea behind Skiplists are just simple linked lists.</em></p>
+
+<p><em>For example:&nbsp;we have a Skiplist containing <code>[30,40,50,60,70,90]</code> and we want to add <code>80</code> and <code>45</code> into it. The&nbsp;Skiplist works this way:</em></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2019/09/27/1506_skiplist.gif" style="width: 960px; height: 332px;" /><br />
+<small>Artyom Kalinin [CC BY-SA 3.0], via <a href="https://commons.wikimedia.org/wiki/File:Skip_list_add_element-en.gif" target="_blank" title="Artyom Kalinin [CC BY-SA 3.0 (https://creativecommons.org/licenses/by-sa/3.0)], via Wikimedia Commons">Wikimedia Commons</a></small></p>
+
+<p><em>You can see there are many layers in the Skiplist. Each layer is a sorted linked list. With the help of the top layers, <code>add</code>&nbsp;,&nbsp;<code>erase</code>&nbsp;and <code>search&nbsp;</code>can be faster than O(n).&nbsp;It can be proven&nbsp;that the average time complexity for each operation is O(log(n)) and space complexity is O(n).</em></p>
+
+<p>To be specific, your design should include these functions:</p>
+
+<ul>
+	<li><code>bool search(int target)</code> : Return whether&nbsp;the <code>target</code> exists in the Skiplist&nbsp;or not.</li>
+	<li><code>void add(int num)</code>:&nbsp;Insert a value into the SkipList.&nbsp;</li>
+	<li><code>bool erase(int num)</code>: Remove a value in&nbsp;the Skiplist.&nbsp;If <code>num</code>&nbsp;does not exist in the Skiplist, do nothing and return false. If there exists multiple <code>num</code> values, removing&nbsp;any one of them is fine.</li>
+</ul>
+
+<p>See more about Skiplist :&nbsp;<a href="https://en.wikipedia.org/wiki/Skip_list" target="_blank">https://en.wikipedia.org/wiki/Skip_list</a></p>
+
+<p>Note that duplicates may exist in the Skiplist, your code needs to handle this situation.</p>
+
+<p>&nbsp;</p>
+
+<p><b>Example:</b></p>
+
+<pre>
+Skiplist skiplist = new Skiplist();
+
+skiplist.add(1);
+skiplist.add(2);
+skiplist.add(3);
+skiplist.search(0);   // return false.
+skiplist.add(4);
+skiplist.search(1);   // return true.
+skiplist.erase(0);    // return false, 0 is not in skiplist.
+skiplist.erase(1);    // return true.
+skiplist.search(1);   // return false, 1 has already been erased.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= num, target&nbsp;&lt;= 20000</code></li>
+	<li>At most <code>50000</code>&nbsp;calls will be made to <code>search</code>, <code>add</code>, and <code>erase</code>.</li>
+</ul>
+
+### Related Topics
+  [[Design](https://github.com/openset/leetcode/tree/master/tag/design/README.md)]
+
+### Similar Questions
+  1. [Design HashSet](https://github.com/openset/leetcode/tree/master/problems/design-hashset) (Easy)
+  1. [Design HashMap](https://github.com/openset/leetcode/tree/master/problems/design-hashmap) (Easy)
+  1. [Design Linked List](https://github.com/openset/leetcode/tree/master/problems/design-linked-list) (Easy)

problems/get-equal-substrings-within-budget/README.md

@@ -0,0 +1,64 @@
+<!--|This file generated by command(leetcode description); DO NOT EDIT.    |-->
+<!--+----------------------------------------------------------------------+-->
+<!--|@author    openset <[email protected]>                           |-->
+<!--|@link      https://github.com/openset                                 |-->
+<!--|@home      https://github.com/openset/leetcode                        |-->
+<!--+----------------------------------------------------------------------+-->
+
+[< Previous](https://github.com/openset/leetcode/tree/master/problems/unique-number-of-occurrences "Unique Number of Occurrences")
+　　　　　　　　　　　　　　　　
+[Next >](https://github.com/openset/leetcode/tree/master/problems/remove-all-adjacent-duplicates-in-string-ii "Remove All Adjacent Duplicates in String II")
+
+## [5207. Get Equal Substrings Within Budget (Medium)](https://leetcode.com/problems/get-equal-substrings-within-budget "尽可能使字符串相等")
+
+<p>You are given two strings <code>s</code> and <code>t</code> of the same length. You want to change <code>s</code> to <code>t</code>. Changing the <code>i</code>-th character of <code>s</code> to <code>i</code>-th character of <code>t</code> costs <code>|s[i] - t[i]|</code> that is, the absolute difference between the ASCII values of the characters.</p>
+
+<p>You are also given an integer <code>maxCost</code>.</p>
+
+<p>Return the maximum length of a substring of <code>s</code> that can be changed to be the same as the corresponding substring of <code>t</code>with a cost less than or equal to <code>maxCost</code>.</p>
+
+<p>If there is no substring from&nbsp;<code>s</code> that can be changed to its corresponding substring from <code>t</code>, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcd&quot;, t = &quot;bcdf&quot;, cost = 3
+<strong>Output:</strong> 3
+<strong>Explanation: </strong>&quot;abc&quot; of s can change to &quot;bcd&quot;. That costs 3, so the maximum length is 3.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcd&quot;, t = &quot;cdef&quot;, cost = 3
+<strong>Output:</strong> 1
+<strong>Explanation: </strong>Each charactor in s costs 2 to change to charactor in <code>t, so the maximum length is 1.</code>
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcd&quot;, t = &quot;acde&quot;, cost = 0
+<strong>Output:</strong> 1
+<strong>Explanation: </strong>You can&#39;t make any change, so the maximum length is 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length, t.length &lt;= 10^5</code></li>
+	<li><code>0 &lt;= maxCost &lt;= 10^6</code></li>
+	<li><code>s</code> and&nbsp;<code>t</code> only contain lower case English letters.</li>
+</ul>
+
+### Hints
+<details>
+<summary>Hint 1</summary>
+Calculate the differences between a[i] and b[i].
+</details>
+
+<details>
+<summary>Hint 2</summary>
+Use a sliding window to track the longest valid substring.
+</details>

problems/minimum-moves-to-reach-target-with-rotations/README.md

@@ -0,0 +1,78 @@
+<!--|This file generated by command(leetcode description); DO NOT EDIT.    |-->
+<!--+----------------------------------------------------------------------+-->
+<!--|@author    openset <[email protected]>                           |-->
+<!--|@link      https://github.com/openset                                 |-->
+<!--|@home      https://github.com/openset/leetcode                        |-->
+<!--+----------------------------------------------------------------------+-->
+
+[< Previous](https://github.com/openset/leetcode/tree/master/problems/remove-all-adjacent-duplicates-in-string-ii "Remove All Adjacent Duplicates in String II")
+　　　　　　　　　　　　　　　　
+Next >
+
+## [5208. Minimum Moves to Reach Target with Rotations (Hard)](https://leetcode.com/problems/minimum-moves-to-reach-target-with-rotations "穿过迷宫的最少移动次数")
+
+<p>In an&nbsp;<code>n*n</code>&nbsp;grid, there is a snake that spans 2 cells and starts moving from the top left corner at <code>(0, 0)</code> and <code>(0, 1)</code>. The grid has empty cells represented by zeros and blocked cells represented by ones. The snake wants to reach the lower right corner at&nbsp;<code>(n-1, n-2)</code>&nbsp;and&nbsp;<code>(n-1, n-1)</code>.</p>
+
+<p>In one move the snake can:</p>
+
+<ul>
+	<li>Move one cell to the right&nbsp;if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.</li>
+	<li>Move down one cell&nbsp;if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.</li>
+	<li>Rotate clockwise if it&#39;s in a horizontal position and the two cells under it are both empty. In that case the snake moves from&nbsp;<code>(r, c)</code>&nbsp;and&nbsp;<code>(r, c+1)</code>&nbsp;to&nbsp;<code>(r, c)</code>&nbsp;and&nbsp;<code>(r+1, c)</code>.<br />
+	<img alt="" src="https://assets.leetcode.com/uploads/2019/09/24/image-2.png" style="width: 300px; height: 134px;" /></li>
+	<li>Rotate counterclockwise&nbsp;if it&#39;s in a vertical position and the two cells to its right are both empty. In that case the snake moves from&nbsp;<code>(r, c)</code>&nbsp;and&nbsp;<code>(r+1, c)</code>&nbsp;to&nbsp;<code>(r, c)</code>&nbsp;and&nbsp;<code>(r, c+1)</code>.<br />
+	<img alt="" src="https://assets.leetcode.com/uploads/2019/09/24/image-1.png" style="width: 300px; height: 121px;" /></li>
+</ul>
+
+<p>Return the minimum number of moves to reach the target.</p>
+
+<p>If there is no way to reach the target, return&nbsp;<code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/09/24/image.png" style="width: 400px; height: 439px;" /></strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[0,0,0,0,0,1],
+               [1,1,0,0,1,0],
+&nbsp;              [0,0,0,0,1,1],
+&nbsp;              [0,0,1,0,1,0],
+&nbsp;              [0,1,1,0,0,0],
+&nbsp;              [0,1,1,0,0,0]]
+<strong>Output:</strong> 11
+<strong>Explanation:
+</strong>One possible solution is [right, right, rotate clockwise, right, down, down, down, down, rotate counterclockwise, right, down].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[0,0,1,1,1,1],
+&nbsp;              [0,0,0,0,1,1],
+&nbsp;              [1,1,0,0,0,1],
+&nbsp;              [1,1,1,0,0,1],
+&nbsp;              [1,1,1,0,0,1],
+&nbsp;              [1,1,1,0,0,0]]
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 100</code></li>
+	<li><code>0 &lt;= grid[i][j] &lt;= 1</code></li>
+	<li>It is guaranteed that the snake starts at empty cells.</li>
+</ul>
+
+### Hints
+<details>
+<summary>Hint 1</summary>
+Use BFS to find the answer.
+</details>
+
+<details>
+<summary>Hint 2</summary>
+The state of the BFS is the position (x, y) along with a binary value that specifies if the position is horizontal or vertical.
+</details>

problems/monthly-transactions-ii/README.md

@@ -7,7 +7,7 @@
 
 [< Previous](https://github.com/openset/leetcode/tree/master/problems/last-person-to-fit-in-the-elevator "Last Person to Fit in the Elevator")
 
-Next >
+[Next >](https://github.com/openset/leetcode/tree/master/problems/design-skiplist "Design Skiplist")
 
 ## [1205. Monthly Transactions II (Medium)](https://leetcode.com/problems/monthly-transactions-ii "")
 

problems/remove-all-adjacent-duplicates-in-string-ii/README.md

@@ -0,0 +1,65 @@
+<!--|This file generated by command(leetcode description); DO NOT EDIT.    |-->
+<!--+----------------------------------------------------------------------+-->
+<!--|@author    openset <[email protected]>                           |-->
+<!--|@link      https://github.com/openset                                 |-->
+<!--|@home      https://github.com/openset/leetcode                        |-->
+<!--+----------------------------------------------------------------------+-->
+
+[< Previous](https://github.com/openset/leetcode/tree/master/problems/get-equal-substrings-within-budget "Get Equal Substrings Within Budget")
+　　　　　　　　　　　　　　　　
+[Next >](https://github.com/openset/leetcode/tree/master/problems/minimum-moves-to-reach-target-with-rotations "Minimum Moves to Reach Target with Rotations")
+
+## [5206. Remove All Adjacent Duplicates in String II (Medium)](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string-ii "删除字符串中的所有相邻重复项 II")
+
+<p>Given a string&nbsp;<code>s</code>, a <em>k</em>&nbsp;<em>duplicate removal</em>&nbsp;consists of choosing <code>k</code>&nbsp;adjacent and equal letters from&nbsp;<code>s</code> and removing&nbsp;them causing the left and the right side of the deleted substring to concatenate together.</p>
+
+<p>We repeatedly make <code>k</code> duplicate removals on <code>s</code> until we no longer can.</p>
+
+<p>Return the final string after all such duplicate removals have been made.</p>
+
+<p>It is guaranteed that the answer is unique.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcd&quot;, k = 2
+<strong>Output:</strong> &quot;abcd&quot;
+<strong>Explanation: </strong>There&#39;s nothing to delete.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;deeedbbcccbdaa&quot;, k = 3
+<strong>Output:</strong> &quot;aa&quot;
+<strong>Explanation: 
+</strong>First delete &quot;eee&quot; and &quot;ccc&quot;, get &quot;ddbbbdaa&quot;
+Then delete &quot;bbb&quot;, get &quot;dddaa&quot;
+Finally delete &quot;ddd&quot;, get &quot;aa&quot;</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;pbbcggttciiippooaais&quot;, k = 2
+<strong>Output:</strong> &quot;ps&quot;
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10^5</code></li>
+	<li><code>2 &lt;= k &lt;= 10^4</code></li>
+	<li><code>s</code> only contains lower case English letters.</li>
+</ul>
+
+### Hints
+<details>
+<summary>Hint 1</summary>
+Use a stack to store the characters, when there are k same characters, delete them.
+</details>
+
+<details>
+<summary>Hint 2</summary>
+To make it more efficient, use a pair to store the value and the count of each character.
+</details>

problems/unique-number-of-occurrences/README.md

@@ -0,0 +1,55 @@
+<!--|This file generated by command(leetcode description); DO NOT EDIT.    |-->
+<!--+----------------------------------------------------------------------+-->
+<!--|@author    openset <[email protected]>                           |-->
+<!--|@link      https://github.com/openset                                 |-->
+<!--|@home      https://github.com/openset/leetcode                        |-->
+<!--+----------------------------------------------------------------------+-->
+
+[< Previous](https://github.com/openset/leetcode/tree/master/problems/design-skiplist "Design Skiplist")
+　　　　　　　　　　　　　　　　
+[Next >](https://github.com/openset/leetcode/tree/master/problems/get-equal-substrings-within-budget "Get Equal Substrings Within Budget")
+
+## [5205. Unique Number of Occurrences (Easy)](https://leetcode.com/problems/unique-number-of-occurrences "独一无二的出现次数")
+
+<p>Given an array of integers <code>arr</code>,&nbsp;write a function that returns <code>true</code> if and only if the number of occurrences of each value in the array is unique.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> arr = [1,2,2,1,1,3]
+<strong>Output:</strong> true
+<strong>Explanation:</strong>&nbsp;The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> arr = [1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> arr = [-3,0,1,-3,1,1,1,-3,10,0]
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length&nbsp;&lt;= 1000</code></li>
+	<li><code>-1000 &lt;= arr[i] &lt;= 1000</code></li>
+</ul>
+
+### Hints
+<details>
+<summary>Hint 1</summary>
+Find the number of occurrences of each element in the array using a hash map.
+</details>
+
+<details>
+<summary>Hint 2</summary>
+Iterate through the hash map and check if there is a repeated value.
+</details>