Leetcode 3734. Lexicographically Smallest Palindromic Permutation Greater Than Target-优快云博客

Leetcode 3734. Lexicographically Smallest Palindromic Permutation Greater Than Target
- 1. 解题思路
- 2. 代码实现

题目链接：3734. Lexicographically Smallest Palindromic Permutation Greater Than Target

1. 解题思路

这一题是leetcode周赛474的第四题，是一道hard的题目。

不过这道题事实上就是题目3720. Lexicographically Smallest Permutation Greater Than Target的一个变体，根据我们之前已经给出的题目3720的题解，我们事实上很快就能够给出这道题目的解答。

这一题的思路上来说，我们首先先判断给定的字符串s本身是否可以构成一个回文字符串，如果不行，那么直接返回空字符串就行了。

然后，已知s可以构成一个回文字符串，此时我么只需要取出其一半的字符串，然后与目标字符串target的前半段进行对比。

如果s的一半恰好可以组成与target的前半段完全相同的的字符串，那么，我们需要对比一下此时构成的回文字符串是否满足要求，如果可以，那么这个字符串就是满足要求的最小字符串。

如果不满足要求，那么，我们要求的就是用s的一半字符来构成一个比target的前半段字符大的最小字符串了，而这个就是题目3720的内容，我们用题目3720的题解中给到的代码实现即可完成剩余的工作。

2. 代码实现

给出python代码实现如下：

class Solution:
    def lexGreaterPermutation(self, s: str, target: str) -> str:
        n = len(s)
        src, tgt = Counter(s), Counter(target)

        def dfs(idx):
            nonlocal src, tgt
            if idx == n-1:
                # print(src, tgt)
                r, t = list(src.keys())[0], list(tgt.keys())[0]
                if r > t:
                    src.pop(r)
                    tgt.pop(t)
                    return r
                else:
                    return ""
            elif max(src.keys()) <= min(tgt.keys()):
                return ""
            t = target[idx]
            candi = sorted([ch for ch in src.keys() if ch >= t])
            if len(candi) == 0:
                return ""
            elif t == candi[0]:
                src[t] -= 1
                if src[t] == 0:
                    src.pop(t)
                tgt[t] -= 1
                if tgt[t] == 0:
                    tgt.pop(t)
                remain = dfs(idx+1)
                src[t] = 1 if t not in src else src[t]+1
                tgt[t] = 1 if t not in tgt else tgt[t]+1
                if remain != "":
                    return t + remain
                elif len(candi) == 1:
                    return ""
                else:
                    candi = candi[1]
            else:
                candi = candi[0]
            src[candi] -= 1
            remain = ""
            for ch in string.ascii_lowercase:
                remain += ch * src[ch]
            src[ch] += 1
            return candi + remain

        ans = dfs(0)
        return ans
        
    def lexPalindromicPermutation(self, s: str, target: str) -> str:
        cnt = Counter(s)
        mid = [ch for ch in cnt if cnt[ch] % 2 == 1]
        if len(mid) > 1:
            return ""
        elif len(mid) == 1:
            mid = mid[0]
        else:
            mid = ""
        src = ""
        for ch in cnt:
            src += ch * (cnt[ch] // 2)
        tgt = target[:len(src)]
        if src == "":
            return s if s > target else ""
        if "".join(sorted(src)) == "".join(sorted(tgt)):
            ans = tgt + mid + tgt[::-1]
            if ans > target:
                return ans
        ans = self.lexGreaterPermutation(src, tgt)
        if len(ans) < len(src):
            return ""
        ans = ans + mid + ans[::-1]
        return ans if ans > target else ""