一刷1387

Author: diguage

README.adoc

@@ -9735,12 +9735,12 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 //|Medium
 //|
 
-//|{counter:codes}
-//|{leetcode_base_url}/sort-integers-by-the-power-value/[1387. Sort Integers by The Power Value^]
-//|{source_base_url}/_1387_SortIntegersByThePowerValue.java[Java]
-//|{doc_base_url}/1387-sort-integers-by-the-power-value.adoc[题解]
-//|Medium
-//|
+|{counter:codes}
+|{leetcode_base_url}/sort-integers-by-the-power-value/[1387. Sort Integers by The Power Value^]
+|{source_base_url}/_1387_SortIntegersByThePowerValue.java[Java]
+|{doc_base_url}/1387-sort-integers-by-the-power-value.adoc[题解]
+|Medium
+|
 
 //|{counter:codes}
 //|{leetcode_base_url}/pizza-with-3n-slices/[1388. Pizza With 3n Slices^]

docs/1387-sort-integers-by-the-power-value.adoc

@@ -1,61 +1,55 @@
 [#1387-sort-integers-by-the-power-value]
-= 1387. Sort Integers by The Power Value
+= 1387. 将整数按权重排序
 
-{leetcode}/problems/sort-integers-by-the-power-value/[LeetCode - 1387. Sort Integers by The Power Value ^]
+https://leetcode.cn/problems/sort-integers-by-the-power-value/[LeetCode - 1387. 将整数按权重排序 ^]
 
-The power of an integer `x` is defined as the number of steps needed to transform `x` into `1` using the following steps:
+我们将整数 `x` 的 *权重* 定义为按照下述规则将 `x` 变成 `1` 所需要的步数：
 
+* 如果 `x` 是偶数，那么 `+x = x / 2+`
+* 如果 `x` 是奇数，那么 `+x = 3 * x + 1+`
 
-* if `x` is even then `x = x / 2`
-* if `x` is odd then `x = 3 * x + 1`
+比方说，x=3 的权重为 7 。因为 3 需要 7 步变成 1 （3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1）。
 
+给你三个整数 `lo`， `hi` 和 `k` 。你的任务是将区间 `[lo, hi]` 之间的整数按照它们的权重 *升序排序 *，如果大于等于 2 个整数有 *相同* 的权重，那么按照数字自身的数值 *升序排序* 。
 
-For example, the power of `x = 3` is `7` because `3` needs `7` steps to become `1` (`3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1`).
+请你返回区间 `[lo, hi]` 之间的整数按权重排序后的第 `k` 个数。
 
-Given three integers `lo`, `hi` and `k`. The task is to sort all integers in the interval `[lo, hi]` by the power value in *ascending order*, if two or more integers have *the same* power value sort them by *ascending order*.
+注意，题目保证对于任意整数 `x` `+（lo <= x <= hi）+` ，它变成 `1` 所需要的步数是一个 32 位有符号整数。
 
-Return the `k^th^` integer in the range `[lo, hi]` sorted by the power value.
+*示例 1：*
 
-Notice that for any integer `x` `(lo <= x <= hi)` it is *guaranteed* that `x` will transform into `1` using these steps and that the power of `x` is will *fit* in a 32-bit signed integer.
+....
+输入：lo = 12, hi = 15, k = 2
+输出：13
+解释：12 的权重为 9（12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1）
+13 的权重为 9
+14 的权重为 17
+15 的权重为 17
+区间内的数按权重排序以后的结果为 [12,13,14,15] 。对于 k = 2 ，答案是第二个整数也就是 13 。
+注意，12 和 13 有相同的权重，所以我们按照它们本身升序排序。14 和 15 同理。
+....
 
- 
-*Example 1:*
+*示例 2：*
 
-[subs="verbatim,quotes"]
-----
-*Input:* lo = 12, hi = 15, k = 2
-*Output:* 13
-*Explanation:* The power of 12 is 9 (12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1)
-The power of 13 is 9
-The power of 14 is 17
-The power of 15 is 17
-The interval sorted by the power value [12,13,14,15]. For k = 2 answer is the second element which is 13.
-Notice that 12 and 13 have the same power value and we sorted them in ascending order. Same for 14 and 15.
-----
-
-*Example 2:*
-
-[subs="verbatim,quotes"]
-----
-*Input:* lo = 7, hi = 11, k = 4
-*Output:* 7
-*Explanation:* The power array corresponding to the interval [7, 8, 9, 10, 11] is [16, 3, 19, 6, 14].
-The interval sorted by power is [8, 10, 11, 7, 9].
-The fourth number in the sorted array is 7.
-----
+....
+输入：lo = 7, hi = 11, k = 4
+输出：7
+解释：区间内整数 [7, 8, 9, 10, 11] 对应的权重为 [16, 3, 19, 6, 14] 。
+按权重排序后得到的结果为 [8, 10, 11, 7, 9] 。
+排序后数组中第 4 个数字为 7 。
+....
 
- 
-*Constraints:*
 
+*提示：*
 
-* `1 <= lo <= hi <= 1000`
-* `1 <= k <= hi - lo + 1`
-
+* `+1 <= lo <= hi <= 1000+`
+* `+1 <= k <= hi - lo + 1+`
 
 
 
 == 思路分析
 
+先计算每个数字的权重，再进行比较：使用集合存储下标，通过下标找到对应的权重。计算权重时，可以递归，也可以直接循环。使用递归时，可以使用备忘录把已经计算的值存储起来，防止重复计算。
 
 [[src-1387]]
 [tabs]
@@ -82,4 +76,5 @@ include::{sourcedir}/_1387_SortIntegersByThePowerValue.java[tag=answer]
 
 == 参考资料
 
-
+. https://leetcode.cn/problems/sort-integers-by-the-power-value/solutions/168355/jiang-zheng-shu-an-quan-zhong-pai-xu-by-leetcode-s/[1387. 将整数按权重排序 - 官方题解^]
+. https://leetcode.cn/problems/sort-integers-by-the-power-value/solutions/3011028/bing-bao-cai-xiang-ji-yi-hua-sou-suo-pyt-q5iz/[1387. 将整数按权重排序 - 冰雹猜想，记忆化搜索^]

docs/index.adoc

@@ -2857,7 +2857,7 @@ include::1349-maximum-students-taking-exam.adoc[leveloffset=+1]
 
 // include::1386-cinema-seat-allocation.adoc[leveloffset=+1]
 
-// include::1387-sort-integers-by-the-power-value.adoc[leveloffset=+1]
+include::1387-sort-integers-by-the-power-value.adoc[leveloffset=+1]
 
 // include::1388-pizza-with-3n-slices.adoc[leveloffset=+1]
 

logbook/202503.adoc

@@ -838,6 +838,10 @@ endif::[]
 |{doc_base_url}/0915-partition-array-into-disjoint-intervals.adoc[题解]
 |✅ 两遍遍历。有题解可以不到一遍遍历即可解决问题。
 
+|{counter:codes2503}
+|{leetcode_base_url}/sort-integers-by-the-power-value/[1387. 将整数按权重排序^]
+|{doc_base_url}/1387-sort-integers-by-the-power-value.adoc[题解]
+|✅ 先计算每个数字的权重，再进行比较：使用集合存储下标，通过下标找到对应的权重。计算权重时，可以递归，也可以直接循环。使用递归时，可以使用备忘录把已经计算的值存储起来，防止重复计算。
 
 |===
 

src/main/java/com/diguage/algo/leetcode/_1387_SortIntegersByThePowerValue.java

@@ -0,0 +1,50 @@
+package com.diguage.algo.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class _1387_SortIntegersByThePowerValue {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-05-27 19:55:53
+   */
+  public int getKth(int lo, int hi, int k) {
+    int length = hi - lo + 1;
+    int[] step = new int[length];
+    for (int i = lo; i <= hi; i++) {
+      step[i - lo] = calc(i);
+    }
+    List<Integer> index = new ArrayList<>(length);
+    for (int i = 0; i < length; i++) {
+      index.add(i);
+    }
+    index.sort((a, b) -> {
+      int result = Integer.compare(step[a], step[b]);
+      if (result == 0) {
+        return Integer.compare(a, b);
+      } else {
+        return result;
+      }
+    });
+    return index.get(k - 1) + lo;
+  }
+
+  private int calc(int num) {
+    int result = 0;
+    while (num > 1) {
+      if ((num & 1) == 0) {
+        num /= 2;
+      } else {
+        num = 3 * num + 1;
+      }
+      result++;
+    }
+    return result;
+  }
+  // end::answer[]
+
+  public static void main(String[] args) {
+    new _1387_SortIntegersByThePowerValue().getKth(7, 11, 4);
+  }
+}