Minimum Possible Integer After at Most K Adjacent Swaps On Digits

Minimum Possible Integer After at Most K Adjacent Swaps On Digits - Problem

You're given a string of digits representing a very large integer and an integer k representing the maximum number of adjacent swaps you can perform.

Your goal is to find the lexicographically smallest integer possible by strategically using at most k adjacent digit swaps. Think of it like rearranging digits in a number to make it as small as possible, but you can only swap neighboring digits!

Key Points:

You can swap any two adjacent digits
You can perform at most k swaps (you don't have to use all k)
Goal: minimize the resulting integer
Return the result as a string

Example: If you have "4321" and k=4, you could transform it to "1234" by strategically moving the smallest digits to the front.

Input & Output

example_1.py — Basic case

$ Input: num = "4321", k = 4

› Output: "1234"

💡 Note: We can transform 4321 → 3421 → 3241 → 2341 → 1234 using exactly 4 swaps to get the minimum possible result.

example_2.py — Limited swaps

$ Input: num = "100", k = 1

› Output: "010"

💡 Note: With only 1 swap allowed, we can swap the first two digits: 100 → 010. This gives us the lexicographically smallest result.

example_3.py — Already optimal

$ Input: num = "1234", k = 4

› Output: "1234"

💡 Note: The string is already in its optimal form, so no swaps are needed even though k=4 swaps are available.

Constraints

1 ≤ num.length ≤ 3 × 10⁴
num consists of only digits and does not have leading zeros
0 ≤ k ≤ 10⁹
k can be larger than the number of swaps needed

Visualization

Tap to expand

Understanding the Visualization

Identify Target

For each position, find the smallest digit reachable with remaining swaps

Calculate Cost

Determine how many swaps needed to move target digit to current position

Execute Swaps

Perform adjacent swaps to bubble the digit forward

Update State

Decrease swap budget and move to next position

Key Takeaway

🎯 Key Insight: Greedy approach works because placing smaller digits at earlier positions always leads to a lexicographically smaller result, and we should use our swap budget optimally by prioritizing the most impactful moves first.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 28 f Meta 22

This problem requires a greedy approach where we iteratively place the smallest possible digit at each position from left to right. The key insight is that we should always try to move smaller digits forward when possible within our swap budget. The optimal solution uses O(n²) time to scan and bubble digits, making it efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O((n-1)^k * n)	O(n * (n-1)^k)	Try every possible sequence of k swaps and return the lexicographically smallest result
Greedy with Segment Tree (Optimal)	O(n² log n)	O(n)	Greedily place smallest digits forward using efficient data structure to track positions

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible combinations of adjacent swaps (up to k)
For each combination, apply the swaps to get a result string
Track the lexicographically smallest string found
Return the minimum result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the original string

Generate Swaps

For each position, try swapping with adjacent position

Recursive Exploration

Recursively explore all possible swap sequences

Track Minimum

Keep track of the lexicographically smallest result found

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char minResult[1000];

void backtrack(char* s, int swapsLeft) {
    if (strcmp(s, minResult) < 0) {
        strcpy(minResult, s);
    }
    
    if (swapsLeft == 0) return;
    
    int len = strlen(s);
    for (int i = 0; i < len - 1; i++) {
        char temp = s[i];
        s[i] = s[i + 1];
        s[i + 1] = temp;
        
        backtrack(s, swapsLeft - 1);
        
        s[i + 1] = s[i];
        s[i] = temp;
    }
}

char* minimumInteger(char* num, int k) {
    strcpy(minResult, num);
    backtrack(num, k);
    return minResult;
}

int main() {
    char num[1000];
    int k;
    fgets(num, sizeof(num), stdin);
    num[strlen(num)-1] = '\0'; // Remove newline
    // Remove quotes
    memmove(num, num+1, strlen(num));
    num[strlen(num)-1] = '\0';
    scanf("%d", &k);
    printf("\"%s\"\n", minimumInteger(num, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((n-1)^k * n)

For each position, we have (n-1) possible swaps, and we can make k swaps, then O(n) to process each string

✓ Linear Growth

Space Complexity

O(n * (n-1)^k)

Need to store all possible combinations of swaps and resulting strings

⚡ Linearithmic Space

52.0K Views

Medium-High Frequency

~25 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler