Lexicographically Smallest String After Applying Operations

Lexicographically Smallest String After Applying Operations - Problem

You are given a string s of even length consisting of digits from 0 to 9, and two integers a and b.

You can apply either of the following two operations any number of times and in any order on s:

Operation 1: Add a to all odd indices of s (0-indexed). Digits post 9 are cycled back to 0. For example, if s = "3456" and a = 5, s becomes "3951".
Operation 2: Rotate s to the right by b positions. For example, if s = "3456" and b = 1, s becomes "6345".

Return the lexicographically smallest string you can obtain by applying the above operations any number of times on s.

A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, string a has a letter that appears earlier in the alphabet than the corresponding letter in b.

Input & Output

Example 1 — Basic Case

$ Input: s = "5014", a = 9, b = 2

› Output: "0145"

💡 Note: Apply operation 2 to rotate right by 2: "5014" → "1450". Then apply operation 2 again: "1450" → "0145". This gives the lexicographically smallest result.

Example 2 — Only Operation 1 Needed

$ Input: s = "74", a = 5, b = 1

› Output: "24"

💡 Note: Apply operation 1 to add 5 to odd indices: "74" → "72" (7+5=12→2). Continue: "72" → "70" → "78" → "76" → "74" → "72"... Then try rotations to get "24".

Example 3 — No Operations Needed

$ Input: s = "0000", a = 1, b = 1

› Output: "0000"

💡 Note: The string is already lexicographically smallest possible (all zeros), so no operations improve it.

Constraints

2 ≤ s.length ≤ 100
s.length is even
s consists of digits from 0 to 9
1 ≤ a ≤ 9
1 ≤ b ≤ s.length - 1

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that this is a graph search problem where each string state can transition to new states via two operations. The BFS approach systematically explores all reachable states while using a visited set to avoid cycles. Best approach uses BFS with state tracking: Time: O(10^n), Space: O(10^n) where n is string length.

Common Approaches

✓ Divide And Conquer

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

BFS with State Tracking

⏱️ Time: O(n × 10^n) Space: O(10^n)

Apply BFS to explore all possible string states by applying operations level by level. Use a visited set to avoid revisiting states and track the lexicographically smallest string encountered.

Brute Force with Recursion

⏱️ Time: O(2^d) Space: O(d)

Apply both operations recursively up to a maximum depth and track the minimum string found. This approach explores the solution space without optimization.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char visited[1000][21];  // Store visited states
int visited_count = 0;

void apply_op1(char* string, int a, char* result) {
    int len = strlen(string);
    strcpy(result, string);
    for (int i = 1; i < len; i += 2) {
        int digit = string[i] - '0';
        result[i] = '0' + ((digit + a) % 10);
    }
}

void apply_op2(char* string, int b, char* result) {
    int n = strlen(string);
    b = b % n;
    if (b > 0) {
        // string[-b:] + string[:-b]
        strcpy(result, string + n - b);
        strncat(result, string, n - b);
    } else {
        strcpy(result, string);
    }
}

int is_visited(char* s) {
    for (int i = 0; i < visited_count; i++) {
        if (strcmp(visited[i], s) == 0) {
            return 1;
        }
    }
    return 0;
}

void add_visited(char* s) {
    if (visited_count < 1000) {
        strcpy(visited[visited_count], s);
        visited_count++;
    }
}

void dfs(char* curr, int depth, char* min_result) {
    if (depth > 20 || is_visited(curr)) {  // Limit depth and avoid cycles
        return;
    }
    
    add_visited(curr);
    
    if (strcmp(curr, min_result) < 0) {
        strcpy(min_result, curr);
    }
    
    char op1_result[21], op2_result[21];
    
    apply_op1(curr, ((int*)curr)[-1], op1_result);  // Use global a
    apply_op2(curr, ((int*)curr)[-2], op2_result);  // Use global b
    
    dfs(op1_result, depth + 1, min_result);
    dfs(op2_result, depth + 1, min_result);
}

static int global_a, global_b;

void apply_op1_global(char* string, char* result) {
    int len = strlen(string);
    strcpy(result, string);
    for (int i = 1; i < len; i += 2) {
        int digit = string[i] - '0';
        result[i] = '0' + ((digit + global_a) % 10);
    }
}

void apply_op2_global(char* string, char* result) {
    int n = strlen(string);
    int b = global_b % n;
    if (b > 0) {
        strcpy(result, string + n - b);
        strncat(result, string, n - b);
        result[n] = '\0';
    } else {
        strcpy(result, string);
    }
}

void dfs_global(char* curr, int depth, char* min_result) {
    if (depth > 20 || is_visited(curr)) {
        return;
    }
    
    add_visited(curr);
    
    if (strcmp(curr, min_result) < 0) {
        strcpy(min_result, curr);
    }
    
    char op1_result[21], op2_result[21];
    
    apply_op1_global(curr, op1_result);
    apply_op2_global(curr, op2_result);
    
    dfs_global(op1_result, depth + 1, min_result);
    dfs_global(op2_result, depth + 1, min_result);
}

char* solution(char* s, int a, int b) {
    global_a = a;
    global_b = b;
    visited_count = 0;
    
    char* result = malloc(21);
    strcpy(result, s);
    
    dfs_global(s, 0, result);
    
    return result;
}

int main() {
    char s[21];
    int a, b;
    
    if (scanf("%s", s) != 1) {
        return 1;
    }
    if (scanf("%d", &a) != 1) {
        return 1;
    }
    if (scanf("%d", &b) != 1) {
        return 1;
    }
    
    char* result = solution(s, a, b);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

24.0K Views

Medium Frequency

~25 min Avg. Time

890 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