（LeetCode402移掉K位数字）整数构成的字符串删除K个字符后，剩余字符对应的整数值最小

力扣402（https://leetcode-cn.com/problems/remove-k-digits/submissions/）

输入一串整数构成的字符串，和一个整数K，从字符串中随即删除K个字符，使得剩下的字符按照原来顺序构成的整数最小。

输入：

第一行 整数构成的字符串

第二行是一个整数K

K小于字符串长度

输出：删除K个字符后剩下的字符串

举例：

输入：
100
1
输出：
0

输入：
12345
1
输出：
1234

输入
3753219382
2
输出
35321382

1.代码如下：单调栈

class Solution:
    def removeKdigits(self, num: str, k: int) -> str:
        stack = []
        flag = 0
        num += '0'
        for i in range(len(num)):
            
            while stack and flag < k and stack[-1] > num[i]:
                stack.pop()
                flag += 1

            stack.append(num[i])
        
        stack = stack[k-flag:-1]

        if not ''.join(stack).lstrip('0'):
            return '0'
        else:
            return ''.join(stack).lstrip('0')

 

 

我的奇葩代码，思路错了。

"1432219"
3

都通不过

import copy

def get_first_inv(tmp):
    cur_ele = sorted(tmp[:k], key=lambda x: x[1])[0]
    flag=False
    for ele in sorted(tmp[:k], key=lambda x: x[1]):
        if ele[0] < cur_ele[0]:
            flag=True
            break
        else:
            cur_ele = ele
    return flag,cur_ele

if __name__ == '__main__':
    # dd=[[1,0],[2,1],[3,2]]
    # print(list(zip(*dd))[0])
    # exit()
    string = '12453233708'#input()
    k=4#int(input())
    # string='1683212'
    # k=3
    data=[]
    for idx,i in enumerate(string):
        data.append([int(i),idx])
    sort_data=sorted(data, key=lambda x:[-x[0],x[1]])
    tmp=copy.deepcopy(data)  # data的备份tmp
    tmp_idx=[]  # 记录删除的元素
    for i in sort_data[:k]:
        tmp_idx.append(i)  #添加删除的元素到记录中
        tmp.remove(i)  # tmp移除删除元素
    sort_tmp = sorted(tmp[:k])
    print(sort_tmp,"\t",tmp,"\t",tmp_idx)

    flag,first = get_first_inv(tmp)
    print("flag,first,tmp",flag,first,tmp)
    cnt=0
    while flag:
        cnt+=1
        # 如果不是非递减序列，# 看看删除的元素是否有在剩下前面K个元素的后边
        if sorted(tmp[:k], key=lambda x: x[1])[-1][1]>sorted(tmp_idx[:k], key=lambda  x:x[1])[-1][1]:  # 如果没有，结束
            break
        else: #if tmp[:k][-1][1]<tmp_idx[:k][-1][1]:  #如果有，把剩余元素前K个中最大的元素(出现逆序的元素中第一个删除)删除，保留后面那个曾经被删除的元素,保留谁需要判断
            judge = []
            '''            [[[1,0],[2,1],[3,2]],[[1,0],[2,1],[3,2]],[[1,0],[2,1],[3,2]]]'''
            # for ele in tmp[k:]:
            last_del_ele = []  # 记录删除元素的索引大于前k个剩余元素的索引的元素, last_del_ele中元素的位置对应judge中dd = copy.deepcopy(tmp[k:])； dd.append(de)，dd元素的位置
            tmp_idx_copy = copy.deepcopy(tmp_idx)  # 记录被删除元素的一个临时备份，用来遍历，防止遍历过程中，列表发生变化，遍历出错
            print("tmp_idx", tmp_idx)
            for de in tmp_idx_copy:
                if de[1] > sorted(tmp[:k], key=lambda x: x[1])[-1][1]:  # 如果被删除元素的索引，大于前k个剩余元素的索引
                    # tmp_idx[:k].remove(de)
                    last_del_ele.append(de)
                    '''把剩余元素tmp除了前面K个元素之外后面的元素，加上de，用来判断last_del_ele中保留哪一个'''
                    dd = copy.deepcopy(tmp[k:])
                    dd.append(de)
                    judge.append(dd)
            print("tmp_idx, last_del_ele, judge,tmp", tmp_idx, last_del_ele, judge,tmp)

            ss = sorted(judge, key=lambda x: int("".join([str(ele) for ele in list(zip(*sorted(x,key=lambda ele:ele[1])))[0]])))[0]
            left = 0
            for idx, ele in enumerate(judge):
                if ele == ss:
                    left = idx
            # last_del_ele[idx] 这个元素需要保留下来
            print("tmp,last_del_ele[idx]",tmp,last_del_ele[idx])
            tmp.remove(first)  # 删除前面K个元素第一次出现逆序的元素，eg:11323564,删除3
            tmp_idx.append(first)  # 把删除的元素添加到tmp_idx
            tmp_idx.remove(last_del_ele[left])  #需要保留的元素从tmp_idx删除，并放回tmp
            tmp.append(last_del_ele[left]) #需要保留的元素从tmp_idx删除，并放回tmp
            # print("tmp.append(last_del_ele[left])",tmp)
            # print("第",str(cnt),"".join([str(ele) for ele in list(zip(*sorted(tmp, key=lambda x: x[1])))[0]]))
            flag, first = get_first_inv(tmp)
    print("last=","".join([str(ele) for ele in list(zip(*sorted(tmp, key=lambda x: x[1])))[0]]))