Minimum Adjacent Swaps to Reach the Kth Smallest Number - Problem

You are given a string num, representing a large integer, and an integer k.

We call some integer wonderful if it is a permutation of the digits in num and is greater in value than num. There can be many wonderful integers. However, we only care about the smallest-valued ones.

For example, when num = "5489355142":

The 1st smallest wonderful integer is "5489355214".
The 2nd smallest wonderful integer is "5489355241".
The 3rd smallest wonderful integer is "5489355412".
The 4th smallest wonderful integer is "5489355421".

Return the minimum number of adjacent digit swaps that needs to be applied to num to reach the kth smallest wonderful integer.

The tests are generated in such a way that kth smallest wonderful integer exists.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: The 4th smallest wonderful number is "5489355421". We need 2 adjacent swaps to transform "5489355142" to "5489355421": swap positions 7-8 (4↔2) then swap positions 8-9 (4↔1).

Example 2 — Small Input

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

› Output: 4

💡 Note: The 1st smallest wonderful number is "11121". We need 4 adjacent swaps to move the '2' from position 4 to position 3: swap 4 times to get "11121".

Example 3 — Multiple Steps

$ Input: num = "123", k = 2

› Output: 2

💡 Note: The permutations greater than "123" are ["132", "213", "231", "312", "321"]. The 2nd smallest is "213". From "123" to "213" requires 2 adjacent swaps: first swap positions 0-1 to get "213" directly (swap '1' and '2'), then the string is correct.

Constraints

1 ≤ num.length ≤ 1000
1 ≤ k ≤ 1000
num consists of digits only

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is to use the next permutation algorithm repeatedly to find the k-th wonderful number, then calculate adjacent swaps needed. The greedy approach applies next permutation k times with O(k × n²) time complexity, which is much better than generating all permutations.

Common Approaches

✓ Generate All Permutations

⏱️ Time: O(n! × n) Space: O(n! × n)

Generate all possible permutations of the digits, sort them to find permutations greater than original, pick the k-th one, then calculate minimum adjacent swaps needed.

Next Permutation Algorithm

⏱️ Time: O(k × n²) Space: O(1)

Apply the next permutation algorithm k times to find the k-th wonderful number directly. For each step, count the adjacent swaps needed to transform current permutation to next one.

Generate All Permutations — Algorithm Steps

Generate all permutations of digits
Filter permutations greater than original
Sort and pick k-th permutation
Calculate adjacent swaps needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible permutations of digits

Filter & Sort

Keep only permutations greater than original

Count Swaps

Calculate adjacent swaps needed for k-th permutation

Code -

solution.c — C

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

bool nextPermutation(char* arr, int len) {
    // Find the largest index i such that arr[i] < arr[i + 1]
    int i = len - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) {
        i--;
    }
    
    if (i == -1) {
        return false;  // No next permutation
    }
    
    // Find the largest index j such that arr[i] < arr[j]
    int j = len - 1;
    while (arr[j] <= arr[i]) {
        j--;
    }
    
    // Swap arr[i] and arr[j]
    char temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    
    // Reverse the suffix starting at arr[i + 1]
    int left = i + 1;
    int right = len - 1;
    while (left < right) {
        temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
    return true;
}

int countSwaps(char* s1, char* s2) {
    int len = strlen(s1);
    char* arr = malloc((len + 1) * sizeof(char));
    strcpy(arr, s1);
    int swaps = 0;
    
    for (int i = 0; i < len; i++) {
        char targetChar = s2[i];
        if (arr[i] != targetChar) {
            // Find where target_char is in arr[i:]
            int j = i + 1;
            while (j < len && arr[j] != targetChar) {
                j++;
            }
            // Bubble it to position i
            while (j > i) {
                char temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
                swaps++;
                j--;
            }
        }
    }
    free(arr);
    return swaps;
}

int solution(char* num, int k) {
    int len = strlen(num);
    char* current = malloc((len + 1) * sizeof(char));
    strcpy(current, num);
    
    // Generate k next permutations
    for (int i = 0; i < k; i++) {
        if (!nextPermutation(current, len)) {
            free(current);
            return -1;
        }
    }
    
    int result = countSwaps(num, current);
    free(current);
    return result;
}

int main() {
    char num[20];
    int k;
    fgets(num, sizeof(num), stdin);
    num[strcspn(num, "\n")] = 0;
    scanf("%d", &k);
    printf("%d\n", solution(num, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) time to process

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Store all n! permutations, each of length n

⚠ Quadratic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

485 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

Minimum Adjacent Swaps to Reach the Kth Smallest Number - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler