• 1 <= k <= num.length <= 10⁵
• num consists of only digits
• num does not have any leading zeros except for '0' itself

A digit's value depends far more on where it sits than on what it is: the leftmost digit is worth thousands, the rightmost almost nothing. So to shrink the number, the digits you most want to delete are large ones sitting in high, leftward positions. Trying every choice of which k digits to drop is exponential, so we need a rule that picks correctly in one pass.

Here's the rule. Read the digits left to right and build the answer on a stack. The best answer has its digits rising as much as possible near the front, so whenever the digit you're about to add is smaller than the digit currently on top, that top digit is a bump that makes the number bigger than it needs to be — spend one deletion to pop it (as long as you still have deletions left), and keep popping while the new digit undercuts the top. In "43…", meeting the 3 tells you the 4 is wasteful: dropping it to reach "3…" beats any other single removal, because it lowers the most significant place.

Notice what the stack ends up holding: digits kept in (mostly) increasing order, with the pops happening exactly when a smaller digit threatens to break that order. That's a monotonic stack — an ordinary stack maintained in sorted order — paired here with a deletion budget k that limits how many out-of-order pops you're allowed.

Three loose ends: if you finish the string with budget left over (the digits were already ascending, like "1234"), just chop the last k digits, since the smallest number keeps the smallest front. Then strip leading zeros, and if nothing remains, the answer is "0".

# Monotonic stack + deletion budget (O(N) Time, O(N) Space)
stack = []
for digit in num:
    while k > 0 and stack and stack[-1] > digit:
        stack.pop()          # drop a larger digit sitting in a more significant spot
        k -= 1
    stack.append(digit)

final = stack[:-k] if k > 0 else stack   # budget left over: trim from the end
res = "".join(final).lstrip('0')
return res if res else "0"

Each digit is pushed once and popped at most once, so it's linear. And because a digit is only ever removed when a strictly smaller one can take its place further left, every deletion provably lowers the result.