leetcode 791. Custom Sort String

leetcode 791. Custom Sort String

题目描述

S and T are strings composed of lowercase letters. In S, no letter occurs more than once.

S was sorted in some custom order previously. We want to permute the characters of T so that they match the order that S was sorted. More specifically, if x occurs before y in S, then x should occur before y in the returned string.

Note:

• S has length at most 26, and no character is repeated in S.
• T has length at most 200.
• S and T consist of lowercase letters only.

Difficulty: medium
791. Custom Sort String

---

中文描述
给你两个只包含小写字母的字符串S和T，S中每个字符并不会重复，S表示了一种特定的字符排序方式。希望你对T重新组合，使得其满足S的排序方式，只需要返回一种满足的情况就好。

---

输入格式
输入两个字符串S和T，S表示特定的排序方式，T表示你需要重新排序的字符串。

---

Examples:

1. Input: S = “cba”，T = “abcd”
   Output: “cbad”
   解释:
   由于S，所以排序方式一定是c在b前，b在a前。所以T排序后一定是cba，至于d没在S中出现，所以可以排在任意位置，所以cbad，dcba，cdba，cbda都是可以的。只用选择其中一个即可。

---

解答思路

这题写是medium难度，不过感觉只有easy的难度。因为我们只用考虑一种可行的情况即可，所以自然而然我们考虑把不再S中出现的字符随意排在重构T的最末位（最开头），我们只需要考虑如何高效的把在T中包含在S中的出现的字符按S的要求排序。

• 解法一：运用heapq

  1.先把 $S$ 字符串出现的字符，按先后顺序进行编号，用一个字典记录，默认没在 $S$ 出现的字符的编号为0。

  2.对 $T$ 中的字符按照之前S记录的编号存放到heapq中。

  3.因为heapq可以按照标号顺序从小到大的一个个取出。所以每次从heapq弹出最小的编号的字符，最后把这些重新组合就得到了重构的 $T$。

  4.存放到heapy和从heapy取出操作都是$O\left(log\left(n\right) \right)$的，所以复杂度估计$O\left(nlog\left(n\right) \right)$

• 解法二：字符串替代

  思路和之前类似，不过不需要用到heapy

  1.新建一个空字符用来存放 $S$ 中出现的字符。

  2.按照 $S$ 中字符出现的顺序去 $T$ 中查找字符，如果有就按顺序把这个字符放到前面新建的字符串中。同时把 $T$ 中该位置用空字符串代替掉。（最优情况下只需要$O\left(n\right)$时间）

  3.把 $S$ 中字符遍历完，则 $T$ 只剩下不再 $S$ 中出现的字符，然后把第一步的字符串与现在的 $T$ 合并就得到最后的结果了。

  4.复杂度估计$O\left(kn\right)，k$ 为 S S <script type="math/tex" id="MathJax-Element-7561">S</script> 的长度，不超过26。

---

代码

解法一

class Solution(object):
    def customSortString(self, S, T):
        """
        :type S: str
        :type T: str
        :rtype: str
        39MS
        """
        import heapq, collections
        h = []
        char_dicts = collections.defaultdict(int)
        # 把S中每个字符按出现顺序记录，没出现的字符默认为0
        for i, char in enumerate(S):
            char_dicts[char] = i + 1
        # 把T中字符按S的顺序编号放入heapy中
        for char in T:
            heapq.heappush(h, (char_dicts[char], char))
        ans = ''
        # 标号从小到大取出，重构T
        while h:
            ans += heapq.heappop(h)[1]
        return ans

解法二，两种实现方法，后一种参考别人的代码。

class Solution(object):
    def customSortString(self, S, T):
        """
        :type S: str
        :type T: str
        :rtype: str
        40MS
        """
        R = ""
        # 找出每次最优的字母
        T = list(T)
        for char in S:
            for i, T_char in enumerate(T):
            # 如果T中有这个字符，取出来放前面
                if T_char == char:
                    R += char
                    T[i] = ''
        # 优先的放前面，剩余的放后面
        return R + ''.join(T)

class Solution(object):
    def customSortString(self, S, T):
        """
        :type S: str
        :type T: str
        :rtype: str
        33MS
        """
        R = ""
        # 找出每次最优的字母
        for char in S:
            while char in T:
                # 如果T中有这个字符，取出来放前面
                T = T.replace(char, "", 1)
                R += char
        # 优先的放前面，剩余的放后面
        return R + T

---