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. Define a function distance(s1, s2) between two strings s1 and s2 of the same length n as:

The sum of the minimum distance between s1[i] and s2[i] when the characters from 'a' to 'z' are placed in a cyclic order, for all i in the range [0, n - 1].

For example, distance("ab", "cd") == 4, and distance("a", "z") == 1.

You can change any letter of s to any other lowercase English letter, any number of times.

Return a string denoting the lexicographically smallest string t you can get after some changes, such that distance(s, t) <= k.

Input & Output

Example 1 — Basic Transformation

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

› Output: "aaa"

💡 Note: Change 'z' to 'a' (cost 1), 'a' stays 'a' (cost 0), change 'b' to 'a' (cost 1). Total cost = 2 ≤ k.

Example 2 — Limited Budget

$ Input: s = "xkcd", k = 4

› Output: "akcd"

💡 Note: Change 'x' to 'a' (cost 3), remaining budget is 1. 'k' to 'a' costs 10 > 1, so 'k' stays. 'c' and 'd' also stay due to insufficient budget.

Example 3 — Insufficient Budget

$ Input: s = "abc", k = 0

› Output: "abc"

💡 Note: No budget available, string remains unchanged.

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ k ≤ 2 × 10⁵
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to use a greedy approach, processing characters from left to right and always trying to use 'a' first for lexicographically smallest result. The optimal approach is greedy transformation with Time: O(n), Space: O(1).

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Optimal

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(26ⁿ × n) Space: O(n)

This approach generates all possible strings of the same length and checks each one to see if its distance from the original string is within k. Among valid candidates, we return the lexicographically smallest.

Greedy Approach

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

For lexicographically smallest result, we process characters from left to right. For each position, we try to use the smallest character ('a') if we have enough budget remaining, otherwise use the smallest character we can afford.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

void solution(char* s, int k, char* result) {
    int n = strlen(s);
    strcpy(result, s);
    int budget = k;
    
    for (int i = 0; i < n; i++) {
        // Try to use 'a' first (lexicographically smallest)
        int costToA = getDistance(s[i], 'a');
        if (costToA <= budget) {
            result[i] = 'a';
            budget -= costToA;
        } else {
            // Find the smallest character we can afford
            char bestChar = s[i];
            for (char c = 'a'; c <= 'z'; c++) {
                int cost = getDistance(s[i], c);
                if (cost <= budget && c < bestChar) {
                    bestChar = c;
                }
            }
            
            int cost = getDistance(s[i], bestChar);
            result[i] = bestChar;
            budget -= cost;
        }
    }
}

int main() {
    char s[1001];
    int k;
    char result[1001];
    
    fgets(s, sizeof(s), stdin);
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    scanf("%d", &k);
    
    solution(s, k, result);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

856 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