Minimum Number of Operations to Make String Sorted

Minimum Number of Operations to Make String Sorted - Problem

You are given a string s (0-indexed). You are asked to perform the following operation on s until you get a sorted string:

Find the largest index i such that 1 <= i < s.length and s[i] < s[i - 1].
Find the largest index j such that i <= j < s.length and s[k] < s[i - 1] for all the possible values of k in the range [i, j] inclusive.
Swap the two characters at indices i - 1 and j.
Reverse the suffix starting at index i.

Return the number of operations needed to make the string sorted. Since the answer can be too large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Small String

$ Input: s = "cba"

› Output: 5

💡 Note: The operations transform: "cba" → "cab" → "acb" → "abc". Total operations needed: 5

Example 2 — Already Sorted

$ Input: s = "aabbc"

› Output: 0

💡 Note: String is already sorted, so no operations are needed

Example 3 — Reverse Order

$ Input: s = "dcba"

› Output: 11

💡 Note: Worst case: completely reverse sorted string requires 11 operations to sort

Constraints

1 ≤ s.length ≤ 3000
s consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8 M Microsoft 5

This problem asks us to count operations to sort a string using a specific reverse next-permutation algorithm. The key insight is that instead of simulating the operations, we can use factorial number system and combinatorics to calculate the result mathematically. The optimal approach uses character frequencies and factorials to count permutations in O(n²) time with O(n) space.

Common Approaches

✓ Factorial Number System (Combinatorics)

⏱️ Time: O(n²) Space: O(n)

The operations described are essentially the reverse of next permutation. We can calculate how many permutations come before the sorted version using factorial number system and combinatorics.

Simulation Approach

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

Follow the algorithm step by step: find the largest index where s[i] < s[i-1], find the appropriate swap position, swap characters, reverse suffix, and count operations.

Factorial Number System (Combinatorics) — Algorithm Steps

Count frequency of each character
For each position, calculate how many smaller characters can be placed
Use factorial to count permutations
Sum up contributions modulo 10^9+7

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Frequencies

Count frequency of each character in the string

Position Analysis

For each position, count smaller available characters

Factorial Calculation

Use factorial formula to count permutations

Code -

solution.c — C

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

const int MOD = 1000000007;

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp /= 2;
    }
    return result;
}

int solution(char* s) {
    int n = strlen(s);
    
    // Precompute factorials
    long long fact[n + 1];
    fact[0] = 1;
    for (int i = 1; i <= n; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }
    
    // Count frequency of each character
    int freq[26] = {0};
    for (int i = 0; i < n; i++) {
        freq[s[i] - 'a']++;
    }
    
    long long result = 0;
    
    // For each position from left to right
    for (int i = 0; i < n; i++) {
        // Count how many characters smaller than s[i] are available
        int smallerCount = 0;
        for (int j = 0; j < s[i] - 'a'; j++) {
            smallerCount += freq[j];
        }
        
        // Calculate contribution: smallerCount * (remaining positions - 1)! / (frequencies!)
        int remaining = n - i - 1;
        if (remaining >= 0) {
            long long contribution = (smallerCount * fact[remaining]) % MOD;
            
            // Divide by frequencies of remaining characters (excluding current)
            long long divisor = 1;
            int tempFreq[26];
            for (int k = 0; k < 26; k++) {
                tempFreq[k] = freq[k];
            }
            tempFreq[s[i] - 'a']--;
            
            for (int k = 0; k < 26; k++) {
                if (tempFreq[k] > 0) {
                    divisor = (divisor * fact[tempFreq[k]]) % MOD;
                }
            }
            
            // Calculate modular inverse and multiply
            if (divisor > 0) {
                long long invDivisor = modPow(divisor, MOD - 2, MOD);
                contribution = (contribution * invDivisor) % MOD;
            }
            
            result = (result + contribution) % MOD;
        }
        
        // Remove current character from frequency
        freq[s[i] - 'a']--;
    }
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position, we count smaller characters which takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Arrays to store character frequencies and precomputed factorials

✓ Linear Space

12.0K Views

Medium Frequency

~45 min Avg. Time

234 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

Factorial Number System (Combinatorics) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler