Question

2343. 裁剪数字后查询第 K 小的数字

English Version

题目描述

给你一个下标从 0 开始的字符串数组 nums ，其中每个字符串 长度相等 且只包含数字。

再给你一个下标从 0 开始的二维整数数组 queries ，其中 queries[i] = [ki, trimi] 。对于每个 queries[i] ，你需要：

• 将 nums 中每个数字 裁剪 到剩下 最右边 trimi 个数位。
• 在裁剪过后的数字中，找到 nums 中第 ki 小数字对应的 下标 。如果两个裁剪后数字一样大，那么下标 更小 的数字视为更小的数字。
• 将 nums 中每个数字恢复到原本字符串。

请你返回一个长度与 queries 相等的数组_ _answer，其中_ _answer[i]是第_ _i_ _次查询的结果。

提示：

• 裁剪到剩下最右边 x 个数位的意思是不断删除最左边的数位，直到剩下 x 个数位。
• nums 中的字符串可能会有前导 0 。

 

示例 1：

输入：nums = ["102","473","251","814"], queries = [[1,1],[2,3],[4,2],[1,2]]
输出：[2,2,1,0]
解释：
1. 裁剪到只剩 1 个数位后，nums = ["2","3","1","4"] 。最小的数字是 1 ，下标为 2 。
2. 裁剪到剩 3 个数位后，nums 没有变化。第 2 小的数字是 251 ，下标为 2 。
3. 裁剪到剩 2 个数位后，nums = ["02","73","51","14"] 。第 4 小的数字是 73 ，下标为 1 。
4. 裁剪到剩 2 个数位后，最小数字是 2 ，下标为 0 。
   注意，裁剪后数字 "02" 值为 2 。

示例 2：

输入：nums = ["24","37","96","04"], queries = [[2,1],[2,2]]
输出：[3,0]
解释：
1. 裁剪到剩 1 个数位，nums = ["4","7","6","4"] 。第 2 小的数字是 4 ，下标为 3 。
   有两个 4 ，下标为 0 的 4 视为小于下标为 3 的 4 。
2. 裁剪到剩 2 个数位，nums 不变。第二小的数字是 24 ，下标为 0 。

 

提示：

• 1 <= nums.length <= 100
• 1 <= nums[i].length <= 100
• nums[i] 只包含数字。
• 所有 nums[i].length 的长度 相同 。
• 1 <= queries.length <= 100
• queries[i].length == 2
• 1 <= ki <= nums.length
• 1 <= trimi <= nums[0].length

 

进阶：你能使用 基数排序算法 解决此问题吗？这种解法的复杂度又是多少？

解法

方法一：模拟

根据题意，我们可以模拟裁剪过程，然后对裁剪后的字符串进行排序，最后根据下标找到对应的数字即可。

时间复杂度 $O(m \times \ n \times \log n \times s)$，空间复杂度 $O(n)$。其中 $m$ 和 $n$ 分别为 nums 和 queries 的长度，而 $s$ 为 $nums[i]$ 字符串的长度。

class Solution:
  def smallestTrimmedNumbers(
    self, nums: List[str], queries: List[List[int]]
  ) -> List[int]:
    ans = []
    for k, trim in queries:
      t = sorted((v[-trim:], i) for i, v in enumerate(nums))
      ans.append(t[k - 1][1])
    return ans

class Solution {
  public int[] smallestTrimmedNumbers(String[] nums, int[][] queries) {
    int n = nums.length;
    int m = queries.length;
    int[] ans = new int[m];
    String[][] t = new String[n][2];
    for (int i = 0; i < m; ++i) {
      int k = queries[i][0], trim = queries[i][1];
      for (int j = 0; j < n; ++j) {
        t[j] = new String[] {nums[j].substring(nums[j].length() - trim), String.valueOf(j)};
      }
      Arrays.sort(t, (a, b) -> {
        int x = a[0].compareTo(b[0]);
        return x == 0 ? Long.compare(Integer.valueOf(a[1]), Integer.valueOf(b[1])) : x;
      });
      ans[i] = Integer.valueOf(t[k - 1][1]);
    }
    return ans;
  }
}

class Solution {
public:
  vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& queries) {
    int n = nums.size();
    vector<pair<string, int>> t(n);
    vector<int> ans;
    for (auto& q : queries) {
      int k = q[0], trim = q[1];
      for (int j = 0; j < n; ++j) {
        t[j] = {nums[j].substr(nums[j].size() - trim), j};
      }
      sort(t.begin(), t.end());
      ans.push_back(t[k - 1].second);
    }
    return ans;
  }
};

func smallestTrimmedNumbers(nums []string, queries [][]int) []int {
  type pair struct {
    s string
    i int
  }
  ans := make([]int, len(queries))
  t := make([]pair, len(nums))
  for i, q := range queries {
    for j, s := range nums {
      t[j] = pair{s[len(s)-q[1]:], j}
    }
    sort.Slice(t, func(i, j int) bool { a, b := t[i], t[j]; return a.s < b.s || a.s == b.s && a.i < b.i })
    ans[i] = t[q[0]-1].i
  }
  return ans
}