Skip to main content

Minimum Adjacent Swaps to Reach the Kth Smallest Number - Video Solutions

MediumTwo PointersStringGreedy

Minimum Adjacent Swaps to Reach the Kth Smallest Number | LeetCode 1850 | Coders Camp

Coders Camp
13:323,024 views
10 video solutions available

Minimum Adjacent Swaps to Reach the Kth Smallest Number - Video Solution

Watch 10 video solutions for Minimum Adjacent Swaps to Reach the Kth Smallest Number, a medium level problem involving Two Pointers, String, Greedy. This walkthrough by Coders Camp has 3,024 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.

Problem Statement

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.

 

Example 1:

Input: num = "5489355142", k = 4
Output: 2
Explanation: The 4th smallest wonderful number is "5489355421". To get this number:
- Swap index 7 with index 8: "5489355142" -> "5489355412"
- Swap index 8 with index 9: "5489355412" -> "5489355421"

Example 2:

Input: num = "11112", k = 4
Output: 4
Explanation: The 4th smallest wonderful number is "21111". To get this number:
- Swap index 3 with index 4: "11112" -> "11121"
- Swap index 2 with index 3: "11121" -> "11211"
- Swap index 1 with index 2: "11211" -> "12111"
- Swap index 0 with index 1: "12111" -> "21111"

Example 3:

Input: num = "00123", k = 1
Output: 1
Explanation: The 1st smallest wonderful number is "00132". To get this number:
- Swap index 3 with index 4: "00123" -> "00132"

 

Constraints:

  • 2 <= num.length <= 1000
  • 1 <= k <= 1000
  • num only consists of digits.
Read full problem with examples

Approach Overview

Problem Overview: Given a numeric string num and an integer k, find the minimum number of adjacent swaps required to transform num into its kth next lexicographically smallest permutation. You first determine what the kth permutation looks like, then compute how many adjacent swaps are needed to reach it.

Approach 1: Using Next Permutation (O(k·n + n²) time, O(n) space)

Generate the target number by applying the next_permutation operation k times on the original string. This algorithm scans from right to left to find the first decreasing pair, swaps with the next larger digit, then reverses the suffix. Once the kth permutation is obtained, compute the minimum adjacent swaps needed to convert the original string into this target. Iterate through each position; when digits differ, search forward in the target and repeatedly swap left until the correct digit reaches the position. This simulates the minimum adjacent swaps required. The approach relies on string manipulation and a greedy bubble-style swap process.

Approach 2: Optimized Swap Calculation (O(k·n + n²) time, O(1) extra space)

After generating the kth permutation, compute swaps more efficiently using a greedy shifting strategy. Traverse both strings from left to right. If characters match, move forward. When they differ, locate the matching digit in the target suffix, then shift it left using adjacent swaps while counting operations. Each shift reduces the distance between the digit's current index and its desired position. This guarantees the minimal number of swaps because adjacent swaps preserve relative ordering. The logic combines ideas from greedy algorithms with pointer scanning similar to two pointers.

Recommended for interviews: Interviewers typically expect the next permutation approach combined with a greedy adjacent swap count. Showing the next_permutation logic demonstrates understanding of permutation generation, while the swap simulation shows how to compute minimal adjacent operations. The optimized swap counting variant is cleaner in implementation and easier to reason about during interviews.

Complexity Analysis

ApproachTimeSpaceWhen to Use
Next Permutation + Swap SimulationO(k·n + n²)O(n)Most common solution; easy to implement and explain in interviews
Optimized Greedy Swap CalculationO(k·n + n²)O(1)When minimizing extra memory and implementing cleaner swap counting