保留最大的数

num, cut = [n for n in input().split()]

num_list = list(num)
for i in range(int(cut)):
    num_list.remove(min(num_list))
    
print(''.join(num_list))

def func1(n,cnt):
    '''
    n: str
    cnt: int
    '''
    c = cnt
    ch = ''  # 用以保存要保留的数字
    i = 0
    while c:
        if i+c == len(n):  # index i 后的数都要删
            return ch
        s = max(n[i:i+c+1])
        max_index = n.index(s,i)
        ch = ch + s
        c = c - len(range(i,max_index))
        i = max_index +1
    else:
        if i == len(n):  # i-1 为n最后一位数的index
            return ch
        else:
            ch = ch + n[i:]  # 已删除固定数目的数字，将n[i]后的字符保留
    return ch

思路：
用一个栈记录答案，依次遍历给出的数。
    当满足栈不为空，且当前遍历数大于栈顶数，且删除了栈顶数后，剩下的未遍历的数的个数加上剩下的栈的深度要达到题目要求的保留数时，就删除栈顶，一直到不满足这几个要求之一。
    如果栈的深度小于题目要求，就把当前遍历数push入栈（因为前面没对栈深限制，没有此限制，会出现输出长度大于题目要求的答案长度）

N= input()
c = int(input())
len_N = len(N)
remain = len_N-c
ans = []
for i in range(len_N):
    while ans and (len(ans)+len_N-i)>remain and N[i]>ans[-1]:
        ans.pop()
    if len(ans)<remain:
        ans.append(N[i])
print(''.join(ans))

#复杂度O(n)，从左至右，删除小于下一位的数，最后不够删除结尾数
number = list(input())
cnt = int(input())
l = len(number)#number长度
i = 0
while cnt > 0 and i < l-1: 
    if number[i] >= number[i+1]: #当前数字大于等于后一位数字时，跳过，继续往后比较
        i += 1
    else: #当前数字小于后一位数字时
        number.pop(i) #去掉当前数字
        cnt -= 1 #希望去掉的数字-1
        l -= 1 #number长度-1
        if i > 0: #当前位不是首位，则回退一位
            i = i - 1
        else: 
            i = 0
if cnt > 0: #数字前一位均大于等于后一位，且待删除数字个数大于0，直接去掉末尾的数
    number = number[:-cnt]
print(''.join(number))

#通过90%，实在是想不到是哪里有问题
number = input()
cnt = int(input())
number = '_'.join(number)
number = number.split(sep = '_')
count = 0
k = 0
while True:#构造前数大于等于后数的列表，例如（9877655432100）
    if number[k] < number[k + 1]:#后一个比前一个数大就删除前一个数
        del number[k]
        count += 1
        if k > 0:#如果不是第一位则将比较点前移一位，例如（911113，删除3个）
            k -= 1
    else:#否则将比较点后移一位
        k += 1
    if count >= cnt or k >= len(number)-cnt:#是否已删除cnt个 或已经比较到最后
        break
a = [str(i) for i in number]
a.sort()
if count < cnt:#已经比较到最后但没有删除cnt个则删除相对小的，例如（987651000，删除3）
    for i in range(cnt-count):
        del number[number.index(a[i])]
print(''.join(number))

	

def getMax(n,k):
    res = []
    while k>0:
        if len(n)==k:
            n = []
            break
        maxN = max(n[:k+1])
        res.append(maxN)
        maxin = n.index(maxN)
        n = n[maxin+1:]
        k = k-maxin
    res.extend(n)
    return res

num = input()
k = int(input())
n = ' '.join(str(num)).split()
n = list(map(int,n))     
print(''.join([str(x) for x in getMax(n,k)]))

从左向又扫描number,每次比较后一个数与前一个数的大小，若后一个数比前一个数大，则说明该数为输出数的某一位，重复扫描工作，此时扫描无需重头开始，只需重删除数的前一个数开始即可，直到找到cnt个这样的数，输出最终值；若扫描完均为发现后一个数比前一个数大说明，该number各位为降序，此时只需不断从尾部删除数，直到剩余位数为cnt就行，打印输出。
通过率100%,运行29ms~52ms(受网络影响)，占用空间2940K,python代码如下:

def reserve_max():
    number = raw_input()
    cnt = raw_input()
    length = 0
    if number.isdigit():
        length = len(number)
    if cnt.isdigit():
        cnt = int(cnt)
    if isinstance(cnt,str) or length<1 or length>50000 or cnt<1 or cnt>length:
        print False
    else:
        idx = 0
        while cnt:
            flag = False
            i = idx
            while i<len(number)-1:
                if number[i]<number[i+1]:
                    number = number[:i]+number[i+1:] if i!=0 else(number[i+1:])
                    flag = True
                    idx = i-1 if i!=0 else(i)
                    break
                i+=1
            if not flag:
                number = number[:-1]
                idx = len(number)
            cnt-=1
        print number

number = raw_input()
n = int(raw_input())
str = ''
while n:
    if len(number) == n:
        number = ''
        break
    m = max(number[:min(n + 1, len(number))])
    index = number.index(m)
    n = n - index
    str = str + m
    number = number[index + 1:]

print(str + number)

"""
可以通过所有案例
"""
def max_num(num, count):
    i = 0
    j = len(num) - 1
    while i+1 <= j and count > 0:
        if num[i] < num[i+1] and i >= 0:
            num.pop(i)
            i -= 1
            j -= 1
            count -= 1
        else:
            i += 1
    while count > 0:
        num.pop(-1)
        count -= 1
    return ''.join(num)
                

if __name__ == "__main__":
    num = list(input())
    count = int(input())
    print(max_num(num, count))

num_lists = [num for num in input()]
count, init = int(input()), 0
while init < count:
    for a in range(len(num_lists) - 1):
        if int(num_lists[a + 1]) > int(num_lists[a]):
            num_lists.remove(num_lists[a])
            break
    else:
        num_lists.remove(num_lists[len(num_lists) - 1])
    init += 1
print("".join(num_lists))

 nums = list(input())
cnt = int(input())
n, j, i= len(nums), cnt, 0
while j > 0 and i < n-1:
    if nums[i]>= nums[i+1]:
        i += 1
    else:
        nums.pop(i)
        j -= 1
        n -= 1
        i = i-1 if i > 0 else 0
if j > 0:
    nums = nums[:-j]
print(''.join(nums)) 

number = input()
cnt = input()
num = list(str(number))
for i in range(cnt):
    num.remove(min(num))
print eval(''.join(num))

然而提示算法复杂度过大....