Python 越大的问题越大-如何优化解决方案

问题

给定一个单词，通过交换部分或全部单词来创建一个新词 人物。这个新词必须符合两个标准：

• 它必须大于原始单词它必须是最小的单词

• 它必须是满足第一个条件的最小单词

请查看完整问题的答案

我的努力

我试图解决这个问题，但不想使用排列

下面的代码适用于一小段测试数据，但无法通过

100000

案例。任何人都可以提供一些建议来优化以下代码：

t=int(raw_input())
for _ in range(t):
    s=list(raw_input().strip())#change to list
    pos = -1#check pos, if pos is bigger, it's smallest bigger lexilogical, so only choose big pos
    i_temp=0

    for i in reversed(range(len(s))):
        for j in reversed(range(i)):
            if s[i]>s[j]: #last letter is bigger than previous, in this case , we can swap to previous one, and found bigger one.
                if j>pos:
                    pos=j#new place
                    i_temp=i
                    break
                if j<pos:
                    break #already found good one
            if i<pos:
                break #already found good one
    if  pos>=0:                                              
        s_tmp=s[pos]                                          
        s[pos]=s[i_temp]                                      
        s[i_temp]=s_tmp                                          
        s1 = s[pos+1:]                  #get string for smallest   
        s1.sort()                                                
        print ("".join(s[:pos+1]+s1))            
    else:                                                        
        print ("no answer")   

t=int（原始输入（）
对于范围（t）内的uu：
s=列表（原始输入（）.strip（））#更改为列表
pos=-1#检查pos，如果pos更大，它是最小的更大词汇，所以只选择大pos
i_temp=0
对于反向（范围（len（s））中的i：
对于反向（范围（i））中的j：
如果s[i]>s[j]：#最后一个字母比前一个大，在这种情况下，我们可以切换到前一个，找到更大的。
如果j>pos：
pos=j#新位置
i_temp=i
打破
如果你的直觉是对的，那么我会尽力帮助你

步骤1：你在反向迭代寻找一个例子，其中a[i]
让自己轻松一点：首先找到解决方案，然后计算输出。不要试图跟踪步骤1中步骤2所需的变量。每个字符串只调用步骤2一次：

def f(w):
    best = ''
    for i in range(len(w)):
        idx = -i-1
        c = w[idx]
        if c >= best:
            best = c
        else:
            l = sorted(w[idx:])
            for j, ch in enumerate(l):
                if ch > c:
                    return w[:idx] + ch + ''.join(l[:j] + l[j+1:])
    return 'no answer'

n = input()
for i in range(n):
    print f(raw_input())

我的简单语言解决方案：PYTHON 3

从相反的顺序检查单词，如果发现大于上一个的单词，将单词分成两部分。之后，对第二部分进行排序，如果发现较大的单词，则将第一部分的最后一个单词与第二部分进行比较。
最后把两部分都连接起来

s="fedcbabcd"
s=list(s)
if (sorted(s,reverse=True))==s:
    print("no answer")
else:
    for i in range(len(s) - 1, 0, -1):
        if s[i] > s[i - 1]:
            lft = s[:i]
            rgt = s[i:]
            break

    rgt =(sorted(rgt))

    for i in range(len(rgt)):
        if lft[len(lft) - 1] < rgt[i]:
            t = lft[len(lft) - 1]
            lft[len(lft) - 1] = rgt[i]
            rgt[i] = t
            break


    print(''.join(lft+rgt))

s=“fedcbabcd”
s=列表
如果（已排序（s，reverse=True））==s：
打印（“无答案”）
其他：
对于范围内的i（len（s）-1，0，-1）：
如果s[i]>s[i-1]：
lft=s[：i]
rgt=s[i:]
打破
rgt=（已排序（rgt））
对于范围内的i（len（rgt））：
如果lft[len（lft）-1]
欢迎来到StackOverflow。请考虑将这个问题移到堆栈交换的网站，因为您的代码确实有效，并且只需要优化。嗯，好好想想。如何移动
w
中的字符以获得一个按字典顺序排列的更大字符串
s
？根据定义，如果
w
，则
w[0]
或
w[0]==s[0]和w[1:
。如何确保
w[0]
？好的：如果
s[0]
是字符串中最大的字符，那么您一定要获得该比较，或者至少获得
w[0]==s[0]
并递归进行。。。继续这个推理，最后你会发现答案是
“”。join（sorted（text，reversed=True））
快速思考：这个问题可以通过使用分而治之的范例来解决吗？