Question

1585. 检查字符串是否可以通过排序子字符串得到另一个字符串

English Version

题目描述

给你两个字符串 s 和 t ，请你通过若干次以下操作将字符串 s 转化成字符串 t ：

• 选择 s 中一个 非空 子字符串并将它包含的字符就地 升序 排序。

比方说，对下划线所示的子字符串进行操作可以由 "14234" 得到 "12344" 。

如果可以将字符串 s 变成 t ，返回 true 。否则，返回 false 。

一个 子字符串 定义为一个字符串中连续的若干字符。

 

示例 1：

输入：s = "84532", t = "34852"
输出：true
解释：你可以按以下操作将 s 转变为 t ：
"84532" （从下标 2 到下标 3）-> "84352"
"84352" （从下标 0 到下标 2） -> "34852"

示例 2：

输入：s = "34521", t = "23415"
输出：true
解释：你可以按以下操作将 s 转变为 t ：
"34521" -> "23451"
"23451" -> "23415"

示例 3：

输入：s = "12345", t = "12435"
输出：false

示例 4：

输入：s = "1", t = "2"
输出：false

 

提示：

• s.length == t.length
• 1 <= s.length <= 105
• s 和 t 都只包含数字字符，即 '0' 到 '9' 。

解法

方法一：冒泡排序

题目实际上等价于判断：将字符串 $s$ 中任意长度为 $2$ 的子字符串采用冒泡排序交换，是否能得到 $t$。

因此我们用一个长度为 $10$ 的数组 $pos$ 记录字符串 $s$ 中每个字符数字的下标，其中 $pos[i]$ 表示数字 $i$ 出现的下标列表，按从小到大排序。

接下来，我们遍历字符串 $t$，对于 $t$ 中的每个字符 $t[i]$，我们转为数字 $x$，我们判断 $pos[x]$ 是否为空，若是，说明字符串 $s$ 中不存在 $t$ 中的数字，直接返回 false。否则，若要将 $pos[x]$ 的第一个位置下标的字符交换到下标 $i$ 的位置，需要满足小于 $x$ 的所有数字的下标均不小于 $pos[x]$ 的第一个位置下标，若不满足，返回 false。否则，我们将 $pos[x]$ 的第一个位置下标弹出，然后继续遍历字符串 $t$。

遍历结束，返回 true。

时间复杂度 $O(n \times C)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 $s$ 的长度，而 $C$ 是数字集的大小，本题中 $C=10$。

class Solution:
  def isTransformable(self, s: str, t: str) -> bool:
    pos = defaultdict(deque)
    for i, c in enumerate(s):
      pos[int(c)].append(i)
    for c in t:
      x = int(c)
      if not pos[x] or any(pos[i] and pos[i][0] < pos[x][0] for i in range(x)):
        return False
      pos[x].popleft()
    return True

class Solution {
  public boolean isTransformable(String s, String t) {
    Deque<Integer>[] pos = new Deque[10];
    Arrays.setAll(pos, k -> new ArrayDeque<>());
    for (int i = 0; i < s.length(); ++i) {
      pos[s.charAt(i) - '0'].offer(i);
    }
    for (int i = 0; i < t.length(); ++i) {
      int x = t.charAt(i) - '0';
      if (pos[x].isEmpty()) {
        return false;
      }
      for (int j = 0; j < x; ++j) {
        if (!pos[j].isEmpty() && pos[j].peek() < pos[x].peek()) {
          return false;
        }
      }
      pos[x].poll();
    }
    return true;
  }
}

class Solution {
public:
  bool isTransformable(string s, string t) {
    queue<int> pos[10];
    for (int i = 0; i < s.size(); ++i) {
      pos[s[i] - '0'].push(i);
    }
    for (char& c : t) {
      int x = c - '0';
      if (pos[x].empty()) {
        return false;
      }
      for (int j = 0; j < x; ++j) {
        if (!pos[j].empty() && pos[j].front() < pos[x].front()) {
          return false;
        }
      }
      pos[x].pop();
    }
    return true;
  }
};

func isTransformable(s string, t string) bool {
  pos := [10][]int{}
  for i, c := range s {
    pos[c-'0'] = append(pos[c-'0'], i)
  }
  for _, c := range t {
    x := int(c - '0')
    if len(pos[x]) == 0 {
      return false
    }
    for j := 0; j < x; j++ {
      if len(pos[j]) > 0 && pos[j][0] < pos[x][0] {
        return false
      }
    }
    pos[x] = pos[x][1:]
  }
  return true
}