Lexicographically Smallest String After Operations With Constraint

Lexicographically Smallest String After Operations With Constraint - Problem

String Greedy Medium

You are given a string s and an integer k, and need to transform s into the lexicographically smallest possible string while staying within a transformation budget.

The Challenge: Letters are arranged in a cyclic order from 'a' to 'z', meaning the distance between 'a' and 'z' is just 1 (wrapping around the circle). The distance function calculates the minimum cyclic distance between corresponding characters in two strings.

For example:

distance("ab", "cd") = 4 (a→c costs 2, b→d costs 2)
distance("a", "z") = 1 (wrap around: a→z or z→a)

Goal: Return the lexicographically smallest string t you can create such that distance(s, t) ≤ k.

Input & Output

example_1.py — Basic Transformation

$ Input: s = "zab", k = 2

› Output: "aab"

💡 Note: We can change 'z' to 'a' with cost 1 (cyclic distance), resulting in "aab". Total distance = 1, which is ≤ 2.

example_2.py — Limited Budget

$ Input: s = "xyzab", k = 1

› Output: "xyzaa"

💡 Note: With budget k=1, we can only make one unit change. The best strategy is to change 'b' to 'a' at the end, giving us "xyzaa".

example_3.py — Cyclic Wrapping

$ Input: s = "ba", k = 1

› Output: "aa"

💡 Note: We can change 'b' to 'a' with cost 1. The cyclic property doesn't matter here since both are close in the alphabet.

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ k ≤ 26 × s.length
s consists only of lowercase English letters
Cyclic distance: min(|c1 - c2|, 26 - |c1 - c2|)

Visualization

Tap to expand

Understanding the Visualization

Analyze Current Character

Look at each position and consider what letters we could change it to

Calculate Cyclic Costs

Compute the minimum rotation needed for each possible target letter

Budget Planning

Ensure we reserve enough budget for optimizing remaining positions

Greedy Selection

Choose the lexicographically smallest affordable option

Key Takeaway

🎯 Key Insight: Use a greedy left-to-right approach where each position is set to the lexicographically smallest possible letter while ensuring the remaining budget can handle the worst-case scenario for future positions.

Asked in

G Google 23 f Meta 15 a Amazon 12 ⊞ Microsoft 8

The optimal solution uses a greedy approach that processes each character from left to right, trying to set it to the lexicographically smallest possible letter while ensuring the remaining budget can handle the rest of the string. This achieves O(n) time complexity by making locally optimal choices that lead to the globally optimal result.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Greedily try to make each character as small as possible while preserving budget
Brute Force (Try All Combinations)	O(26^n)	O(26^n)	Generate all possible strings and find the lexicographically smallest within budget

Greedy Approach (Optimal) — Algorithm Steps

For each position i, try letters 'a' to 'z' in order
Calculate the cost to change s[i] to the candidate letter
Check if remaining budget can handle worst-case costs for remaining positions
Choose the lexicographically smallest feasible letter

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Position i

Try letters 'a' through 'z' in order

Calculate Cost

Compute cyclic distance to candidate letter

Check Budget

Ensure remaining budget handles future positions

Select Best

Choose first feasible letter (lexicographically smallest)

Code -

solution.c — C

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

int cyclicDistance(char c1, char c2) {
    int diff = abs(c1 - c2);
    return (diff < 26 - diff) ? diff : 26 - diff;
}

char* lexicographicallySmallestString(char* s, int k) {
    int n = strlen(s);
    char* result = malloc(n + 1);
    strcpy(result, s);
    
    for (int i = 0; i < n; i++) {
        for (char target = 'a'; target <= 'z'; target++) {
            int cost = cyclicDistance(s[i], target);
            
            int worstCaseRemaining = 0;
            for (int j = i + 1; j < n; j++) {
                worstCaseRemaining += cyclicDistance(result[j], 'a');
            }
            
            if (k - cost >= worstCaseRemaining) {
                result[i] = target;
                k -= cost;
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    memmove(s, s + 1, strlen(s));
    s[strlen(s) - 1] = '\0';
    scanf("%d", &k);
    
    char* result = lexicographicallySmallestString(s, k);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, with constant work per position

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for tracking, modifying string in place

✓ Linear Space

23.6K Views

Medium Frequency

~18 min Avg. Time

847 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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler