feat: update lc problems (doocs#2517)

Author: yanglbme

solution/0100-0199/0191.Number of 1 Bits/README.md

@@ -8,48 +8,39 @@
 
 <!-- 这里写题目描述 -->
 
-<p>编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为<a href="https://baike.baidu.com/item/%E6%B1%89%E6%98%8E%E9%87%8D%E9%87%8F" target="_blank">汉明重量</a>）。</p>
-
-<p>&nbsp;</p>
-
-<p><strong>提示：</strong></p>
-
-<ul>
-	<li>请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。</li>
-	<li>在 Java 中，编译器使用<a href="https://baike.baidu.com/item/二进制补码/5295284" target="_blank">二进制补码</a>记法来表示有符号整数。因此，在&nbsp;<strong>示例 3</strong>&nbsp;中，输入表示有符号整数 <code>-3</code>。</li>
-</ul>
+<p>编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中 <span data-keyword="set-bit">设置位</span> 的个数（也被称为<a href="https://baike.baidu.com/item/%E6%B1%89%E6%98%8E%E9%87%8D%E9%87%8F" target="_blank">汉明重量</a>）。</p>
 
 <p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 
 <pre>
-<strong>输入：</strong>n = 00000000000000000000000000001011
+<strong>输入：</strong>n = 11
 <strong>输出：</strong>3
-<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong>&nbsp;中，共有三位为 '1'。</code>
+<strong>解释：</strong>输入的二进制串 <code><strong>1011</strong>&nbsp;中，共有 3 个设置位。</code>
 </pre>
 
 <p><strong>示例 2：</strong></p>
 
 <pre>
-<strong>输入：</strong>n = 00000000000000000000000010000000
+<strong>输入：</strong>n = 128
 <strong>输出：</strong>1
-<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong>&nbsp;中，共有一位为 '1'。
+<strong>解释：</strong>输入的二进制串 <strong>10000000</strong>&nbsp;中，共有 1 个设置位。
 </pre>
 
 <p><strong>示例 3：</strong></p>
 
 <pre>
-<strong>输入：</strong>n = 11111111111111111111111111111101
-<strong>输出：</strong>31
-<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 中，共有 31 位为 '1'。</pre>
+<strong>输入：</strong>n = 2147483645
+<strong>输出：</strong>30
+<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 中，共有 30 个设置位。</pre>
 
 <p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li>输入必须是长度为 <code>32</code> 的 <strong>二进制串</strong> 。</li>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
 </ul>
 
 <ul>

solution/0100-0199/0191.Number of 1 Bits/README_EN.md

@@ -49,7 +49,7 @@
 <p><strong>Constraints:</strong></p>
 
 <ul>
-	<li>The input must be a <strong>binary string</strong> of length <code>32</code>.</li>
+	<li><code>1 &lt;= n&nbsp;&lt;= 2<sup>31</sup>&nbsp;- 1</code></li>
 </ul>
 
 <p>&nbsp;</p>

solution/0200-0299/0231.Power of Two/README.md

@@ -10,9 +10,9 @@
 
 <p>给你一个整数 <code>n</code>，请你判断该整数是否是 2 的幂次方。如果是，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
 
-<p>如果存在一个整数 <code>x</code> 使得 <code>n == 2<sup>x</sup></code> ，则认为 <code>n</code> 是 2 的幂次方。</p>
+<p>如果存在一个整数 <code>x</code> 使得&nbsp;<code>n == 2<sup>x</sup></code> ，则认为 <code>n</code> 是 2 的幂次方。</p>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 
@@ -37,29 +37,15 @@
 <strong>输出：</strong>false
 </pre>
 
-<p><strong>示例 4：</strong></p>
-
-<pre>
-<strong>输入：</strong>n = 4
-<strong>输出：</strong>true
-</pre>
-
-<p><strong>示例 5：</strong></p>
-
-<pre>
-<strong>输入：</strong>n = 5
-<strong>输出：</strong>false
-</pre>
-
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>-2<sup>31</sup> <= n <= 2<sup>31</sup> - 1</code></li>
+	<li><code>-2<sup>31</sup> &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
 </ul>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>进阶：</strong>你能够不使用循环/递归解决此问题吗？</p>
 

solution/0300-0399/0321.Create Maximum Number/README.md

@@ -8,43 +8,37 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给定长度分别为&nbsp;<code>m</code>&nbsp;和&nbsp;<code>n</code>&nbsp;的两个数组，其元素由&nbsp;<code>0-9</code>&nbsp;构成，表示两个自然数各位上的数字。现在从这两个数组中选出 <code>k (k &lt;= m + n)</code>&nbsp;个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。</p>
+<p>给你两个整数数组 <code>nums1</code> 和 <code>nums2</code>，它们的长度分别为 <code>m</code> 和 <code>n</code>。数组 <code>nums1</code> 和 <code>nums2</code> 分别代表两个数各位上的数字。同时你也会得到一个整数 <code>k</code>。</p>
 
-<p>求满足该条件的最大数。结果返回一个表示该最大数的长度为&nbsp;<code>k</code>&nbsp;的数组。</p>
+<p>请你利用这两个数组中的数字中创建一个长度为 <code>k &lt;= m + n</code> 的最大数，在这个必须保留来自同一数组的数字的相对顺序。</p>
 
-<p><strong>说明: </strong>请尽可能地优化你算法的时间和空间复杂度。</p>
+<p>返回代表答案的长度为 <code>k</code> 的数组。</p>
 
-<p><strong>示例&nbsp;1:</strong></p>
+<p>&nbsp;</p>
+
+<p><strong class="example">示例 1：</strong></p>
 
 <pre>
-<strong>输入:</strong>
-nums1 = <code>[3, 4, 6, 5]</code>
-nums2 = <code>[9, 1, 2, 5, 8, 3]</code>
-k = <code>5</code>
-<strong>输出:</strong>
-<code>[9, 8, 6, 5, 3]</code></pre>
+<strong>输入：</strong>nums1 = [3,4,6,5], nums2 = [9,1,2,5,8,3], k = 5
+<strong>输出：</strong>[9,8,6,5,3]
+</pre>
 
-<p><strong>示例 2:</strong></p>
+<p><strong class="example">示例 2：</strong></p>
 
 <pre>
-<strong>输入:</strong>
-nums1 = <code>[6, 7]</code>
-nums2 = <code>[6, 0, 4]</code>
-k = <code>5</code>
-<strong>输出:</strong>
-<code>[6, 7, 6, 0, 4]</code></pre>
+<strong>输入：</strong>nums1 = [6,7], nums2 = [6,0,4], k = 5
+<strong>输出：</strong>[6,7,6,0,4]
+</pre>
 
-<p><strong>示例 3:</strong></p>
+<p><strong class="example">示例 3：</strong></p>
 
 <pre>
-<strong>输入:</strong>
-nums1 = <code>[3, 9]</code>
-nums2 = <code>[8, 9]</code>
-k = <code>3</code>
-<strong>输出:</strong>
-<code>[9, 8, 9]</code>
+<strong>输入：</strong>nums1 = [3,9], nums2 = [8,9], k = 3
+<strong>输出：</strong>[9,8,9]
 </pre>
 
+<p>&nbsp;</p>
+
 <p><strong>提示：</strong></p>
 
 <ul>

solution/0300-0399/0366.Find Leaves of Binary Tree/README.md

@@ -8,52 +8,40 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给你一棵二叉树，请按以下要求的顺序收集它的全部节点：</p>
+<p>给你一棵二叉树的 <code>root</code> 节点，请按照以下方式收集树的节点：</p>
 
-<ol>
-	<li>依次从左到右，每次收集并删除所有的叶子节点</li>
-	<li>重复如上过程直到整棵树为空</li>
-</ol>
+<ul>
+	<li>收集所有的叶子节点。</li>
+	<li>移除所有的叶子节点。</li>
+	<li>重复以上步骤，直到树为空。</li>
+</ul>
 
 <p>&nbsp;</p>
 
-<p><strong>示例:</strong></p>
-
-<pre><strong>输入: </strong>[1,2,3,4,5]
-&nbsp; 
-&nbsp;         1
-         / \
-        2   3
-       / \     
-      4   5    
-
-<strong>输出: </strong>[[4,5,3],[2],[1]]
+<p><strong class="example">示例 1：</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0300-0399/0366.Find%20Leaves%20of%20Binary%20Tree/images/remleaves-tree.jpg" style="width: 500px; height: 215px;" />
+<pre>
+<strong>输入：</strong>root = [1,2,3,4,5]
+<strong>输出：</strong>[[4,5,3],[2],[1]]
+<strong>解释：</strong>
+[[3,5,4],[2],[1]] 和 [[3,4,5],[2],[1]] 也被视作正确答案，因为每一层返回元素的顺序不影响结果。
 </pre>
 
-<p>&nbsp;</p>
-
-<p><strong>解释:</strong></p>
-
-<p>1. 删除叶子节点&nbsp;<code>[4,5,3]</code> ，得到如下树结构：</p>
+<p><strong class="example">示例 2：</strong></p>
 
-<pre>          1
-         / 
-        2          
+<pre>
+<strong>输入：</strong>root = [1]
+<strong>输出：</strong>[[1]]
 </pre>
 
 <p>&nbsp;</p>
 
-<p>2. 现在删去叶子节点&nbsp;<code>[2]</code>&nbsp;，得到如下树结构：</p>
+<p><strong>提示：</strong></p>
 
-<pre>          1          
-</pre>
-
-<p>&nbsp;</p>
-
-<p>3. 现在删去叶子节点&nbsp;<code>[1]</code>&nbsp;，得到空树：</p>
-
-<pre>          []         
-</pre>
+<ul>
+	<li>树中节点的数量在<code>[1, 100]</code>范围内。</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
 
 ## 解法
 

solution/0400-0499/0442.Find All Duplicates in an Array/README_EN.md

@@ -8,7 +8,7 @@
 
 <p>Given an integer array <code>nums</code> of length <code>n</code> where all the integers of <code>nums</code> are in the range <code>[1, n]</code> and each integer appears <strong>once</strong> or <strong>twice</strong>, return <em>an array of all the integers that appears <strong>twice</strong></em>.</p>
 
-<p>You must write an algorithm that runs in&nbsp;<code>O(n)&nbsp;</code>time and uses only constant extra space.</p>
+<p>You must write an algorithm that runs in&nbsp;<code>O(n)</code>&nbsp;time and uses only constant extra space.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>

solution/0700-0799/0760.Find Anagram Mappings/README.md

@@ -8,37 +8,40 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给定两个列表 <code>A</code>and <code>B</code>，并且 <code>B</code> 是 <code>A</code> 的变位（即&nbsp;<code>B</code> 是由&nbsp;<code>A</code> 中的元素随机排列后组成的新列表）。</p>
+<p>给你两个整数数组 <code>nums1</code> 和 <code>nums2</code>，其中 <code>nums2</code> 是 <code>nums1</code> 的一个<strong> 变位词 </strong>。两个数组都可能包含重复元素。</p>
 
-<p>我们希望找出一个从 <code>A</code> 到 <code>B</code>&nbsp;的索引映射 <code>P</code> 。一个映射 <code>P[i] = j</code>&nbsp;指的是列表&nbsp;<code>A</code> 中的第 <code>i</code> 个元素出现于列表&nbsp;<code>B</code> 中的第 <code>j</code> 个元素上。</p>
+<p>返回一个下标映射数组 <code>mapping</code>，它将 <code>nums1</code> 映射到 <code>nums2</code>，其中 <code>mapping[i] = j</code> 表示 <code>nums1</code> 中的第 <code>i</code> 个元素出现在 <code>nums2</code> 的第 <code>j</code> 个下标上。如果有多个答案，返回 <strong>任意一个 </strong>。</p>
 
-<p>列表 <code>A</code> 和 <code>B</code> 可能出现重复元素。如果有多于一种答案，输出任意一种。</p>
-
-<p>例如，给定</p>
-
-<pre>A = [12, 28, 46, 32, 50]
-B = [50, 12, 32, 46, 28]
-</pre>
+<p>数组 <code>a</code> 是数组 <code>b</code> 的一个 <strong>变位词 </strong>意味着 <code>b</code> 是通过将 <code>a</code> 中元素的顺序随机打乱生成的。</p>
 
 <p>&nbsp;</p>
 
-<p>需要返回</p>
+<p><strong class="example">示例 1：</strong></p>
 
-<pre>[1, 4, 3, 2, 0]
+<pre>
+<strong>输入：</strong>nums1 = [12,28,46,32,50], nums2 = [50,12,32,46,28]
+<strong>输出：</strong>[1,4,3,2,0]
+<strong>解释：</strong>因为 nums1 中的第 0 个元素出现在 nums2[1] 上，所以 mapping[0] = 1，而 nums1 中的第 1 个元素出现在 nums2[4] 上，所以 mapping[1] = 4，以此类推。
 </pre>
 
-<p><code>P[0] = 1</code>&nbsp;，因为 <code>A</code> 中的第 <code>0</code> 个元素出现于 <code>B[1]</code>，而且 <code>P[1] = 4</code> 因为 <code>A</code> 中第 <code>1</code> 个元素出现于 <code>B[4]</code>，以此类推。</p>
+<p><strong class="example">示例 2：</strong></p>
 
-<p>&nbsp;</p>
+<pre>
+<strong>输入：</strong>nums1 = [84,46], nums2 = [84,46]
+<strong>输出：</strong>[0,1]
+</pre>
 
-<p><strong>注：</strong></p>
+<p>&nbsp;</p>
 
-<ol>
-	<li><code>A, B</code>&nbsp;有相同的长度，范围为&nbsp;<code>[1, 100]</code>。</li>
-	<li><code>A[i], B[i]</code> 都是范围在&nbsp;<code>[0, 10^5]</code> 的整数。</li>
-</ol>
+<p><strong>提示：</strong></p>
 
-<p>&nbsp;</p>
+<ul>
+	<li><code>1 &lt;= nums1.length &lt;= 100</code></li>
+	<li><code>nums2.length == nums1.length</code></li>
+	<li><code>0 &lt;= nums1[i], nums2[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums2</code> 是 <code>nums1</code> 的一个变位词。</li>
+</ul>
+<!-- 保持注释以帮助理解题目要求 -->
 
 ## 解法
 

solution/0800-0899/0866.Prime Palindrome/README.md

@@ -2,7 +2,7 @@
 
 [English Version](/solution/0800-0899/0866.Prime%20Palindrome/README_EN.md)
 
-<!-- tags:数学 -->
+<!-- tags:数学,数论 -->
 
 ## 题目描述
 

solution/0800-0899/0866.Prime Palindrome/README_EN.md

@@ -2,7 +2,7 @@
 
 [中文文档](/solution/0800-0899/0866.Prime%20Palindrome/README.md)
 
-<!-- tags:Math -->
+<!-- tags:Math,Number Theory -->
 
 ## Description
 

solution/0800-0899/0895.Maximum Frequency Stack/README_EN.md

@@ -55,7 +55,15 @@ freqStack.pop();   // return 4, as 4, 5 and 7 is the most frequent, but 4 is clo
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Hash Table + Priority Queue (Max Heap)
+
+According to the problem description, we need to design a data structure that supports popping out the element with the highest frequency. If multiple elements have the same frequency, the element closest to the top of the stack should be popped out.
+
+We can use a hash table $cnt$ to record the frequency of each element, and a priority queue (max heap) $q$ to maintain the frequency of elements and their corresponding timestamps.
+
+When performing a push operation, we first increment the current timestamp, i.e., $ts \gets ts + 1$; then we increment the frequency of the element $val$, i.e., $cnt[val] \gets cnt[val] + 1$, and finally, we add the triplet $(cnt[val], ts, val)$ to the priority queue $q$. The time complexity of the push operation is $O(\log n)$.
+
+When performing a pop operation, we directly pop an element from the priority queue $q$. Since the elements in the priority queue $q$ are sorted in descending order of frequency, the popped element is definitely the one with the highest frequency. If multiple elements have the same frequency, the element closest to the top of the stack is popped out, i.e., the element with the largest timestamp is popped out. After popping, we decrement the frequency of the popped element, i.e., $cnt[val] \gets cnt[val] - 1$. The time complexity of the pop operation is $O(\log n)$.
 
 <!-- tabs:start -->
 
@@ -189,7 +197,15 @@ func (h *hp) Pop() any     { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; retur
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Double Hash Tables
+
+In Solution 1, in order to pop out the required element, we maintained a priority queue and had to operate on it each time, which has a time complexity of $O(\log n)$. If we can find the required element in $O(1)$ time, then the time complexity of each operation of the entire data structure can be reduced to $O(1)$.
+
+In fact, we can use a variable $mx$ to record the current maximum frequency, a hash table $d$ to record the list of elements corresponding to each frequency, and as in Solution 1, a hash table $cnt$ to record the frequency of each element.
+
+When performing a push operation, we increment the frequency of the element, i.e., $cnt[val] \gets cnt[val] + 1$, and then add the element $val$ to the corresponding frequency list in the hash table $d$, i.e., $d[cnt[val]].push(val)$. If the current element's frequency is greater than $mx$, then update $mx$, i.e., $mx \gets cnt[val]$. The time complexity of the push operation is $O(1)$.
+
+When performing a pop operation, we take the list of elements with frequency $mx$ from the hash table $d$, pop out the last element $val$ in the list, and then remove $val$ from the hash table $d$, i.e., $d[mx].pop()$. Finally, we decrement the frequency of $val$, i.e., $cnt[val] \gets cnt[val] - 1$. If the list $d[mx]$ is empty, it means that all elements with the current maximum frequency have been popped out, and we need to decrement $mx$, i.e., $mx \gets mx - 1$. The time complexity of the pop operation is $O(1)$.
 
 <!-- tabs:start -->