String lexicográficamente más pequeña después de operaciones M

Dada una string S y un entero M . La tarea es realizar exactamente M operaciones para obtener la string lexicográfica más pequeña.

• En cada operación, seleccione un carácter de manera óptima de la string y actualícelo con el siguiente carácter inmediato ( aaa -> aab ), de modo que la string permanezca lexicográficamente más pequeña.
• Se permiten múltiples operaciones sobre un solo carácter de la string.

Nota: Considere el siguiente de ‘z’ como ‘a’.
Ejemplos:

Entrada: S = “aazzx”, M = 6 
Salida: aaaab 
Explicación: 
Intentamos formar la string lexicográfica más pequeña para cada operación. 
Para m = 1: actualice “aazzx” a “aaazx” 
para m = 2: actualice “aaazx” a “aaaax” 
para m = 3: actualice “aaaax” a “aaaay” 
para m = 4: actualice “aaaay” a “ aaaaz” 
para m = 5: actualice “aaaaz” a “aaaaa” 
para m = 6: actualice “aaaaa” a “aaaab”, que es lexicográficamente más pequeño que “aaaba”, “aabaa”, “abaaa”, “baaaa”. 
String final después de 6 operaciones: “aaaab”.
Entrada: S = “z”, M = 27 
Salida: a 
Explicación: 
Intente formar la string lexicográfica más pequeña para cada operación, ya que solo hay un carácter, por lo que las 27 operaciones deben realizarse sobre él. La string final después de la operación 27 es «a».

Enfoque: la idea es implementar un enfoque codicioso simple , para iterar la string desde el comienzo de la string y, mientras se itera, centrarse en el elemento actual de la string para hacerlo lo más pequeño posible.

• Supongamos que el elemento actual es r , para hacer que r sea el más pequeño, es decir , a , se requieren 9 operaciones, llamemos al valor como distancia .
• Ahora, verifique si M es mayor que igual a la distancia , luego actualice el carácter actual a ‘a’ y disminuya el valor de M por distancia . De lo contrario, continúe con la siguiente iteración.
• Como el siguiente de z es a , se forma un ciclo de 26. Entonces, el último carácter de la string se puede actualizar con el último carácter + (M % 26) .

A continuación se muestra la implementación del enfoque anterior:

// C++ implementation to find the
// lexicographical smallest string
// after performing M operations
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the
// lexicographical smallest string
// after performing M operations
void smallest_string(string s, int m)
{
 
    // Size of the given string
    int n = s.size();
 
    // Declare an array a
    int a[n];
 
    // For each i, a[i] contain number
    // of operations to update s[i] to 'a'
    for (int i = 0; i < n; i++) {
        int distance = s[i] - 'a';
        if (distance == 0)
            a[i] = 0;
 
        else
            a[i] = 26 - distance;
    }
 
    for (int i = 0; i < n; i++) {
        // Check if m >= ar[i],
        // then update s[i] to 'a'
        // decrement k by a[i]
        if (m >= a[i]) {
            s[i] = 'a';
            m = m - a[i];
        }
    }
 
    // Form a cycle of 26
    m = m % 26;
 
    // update last element of
    // string with the value
    // s[i] + (k % 26)
    s[n - 1] = s[n - 1] + m;
 
    // Return the answer
    cout << s;
}
 
// Driver code
int main()
{
    string str = "aazzx";
    int m = 6;
    smallest_string(str, m);
    return 0;
}

// Java implementation to find the
// lexicographical smallest String
// after performing M operations
class GFG{
 
// Function to find the
// lexicographical smallest String
// after performing M operations
static void smallest_String(char []s, int m)
{
 
    // Size of the given String
    int n = s.length;
 
    // Declare an array a
    int []a = new int[n];
 
    // For each i, a[i] contain number
    // of operations to update s[i] to 'a'
    for (int i = 0; i < n; i++)
    {
        int distance = s[i] - 'a';
        if (distance == 0)
            a[i] = 0;
 
        else
            a[i] = 26 - distance;
    }
 
    for (int i = 0; i < n; i++)
    {
        // Check if m >= ar[i],
        // then update s[i] to 'a'
        // decrement k by a[i]
        if (m >= a[i])
        {
            s[i] = 'a';
            m = m - a[i];
        }
    }
 
    // Form a cycle of 26
    m = m % 26;
 
    // update last element of
    // String with the value
    // s[i] + (k % 26)
    s[n - 1] = (char) (s[n - 1] + m);
 
    // Return the answer
    System.out.print(String.valueOf(s));
}
 
// Driver code
public static void main(String[] args)
{
    String str = "aazzx";
    int m = 6;
    smallest_String(str.toCharArray(), m);
}
}
 
// This code is contributed by Princi Singh

# Python3 implementation to find the
# lexicographical smallest string
# after performing M operations
 
# Function to find the
# lexicographical smallest string
# after performing M operations
def smallest_string(s, m):
     
    # Size of the given string
    n = len(s);
     
    l = list(s)
 
    # Declare an array a
    a = [0] * n;
 
    # For each i, a[i] contain number
    # of operations to update s[i] to 'a'
    for i in range(n):
        distance = ord(s[i]) - ord('a');
         
        if (distance == 0):
            a[i] = 0;
        else:
            a[i] = 26 - distance;
     
    for i in range(n):
         
        # Check if m >= ar[i],
        # then update s[i] to 'a'
        # decrement k by a[i]
        if (m >= a[i]):
            l[i] = 'a';
            m = m - a[i];
         
    # Form a cycle of 26
    m = m % 26;
 
    # update last element of
    # with the value
    # s[i] + (k % 26)
     
    # Return the answer
    for i in range(len(l) - 1):
        print(l[i], end = "")
     
    print(chr(ord(l[n - 1]) + m))
 
# Driver code
str = "aazzx";
m = 6;
 
smallest_string(str, m);
 
# This code is contributed by grand_master

// C# implementation to find the
// lexicographical smallest String
// after performing M operations
using System;
 
class GFG{
 
// Function to find the
// lexicographical smallest String
// after performing M operations
static void smallest_String(char []s, int m)
{
     
    // Size of the given String
    int n = s.Length;
 
    // Declare an array a
    int []a = new int[n];
 
    // For each i, a[i] contain number
    // of operations to update s[i] to 'a'
    for(int i = 0; i < n; i++)
    {
        int distance = s[i] - 'a';
        if (distance == 0)
            a[i] = 0;
        else
            a[i] = 26 - distance;
    }
 
    for(int i = 0; i < n; i++)
    {
         
        // Check if m >= ar[i],
        // then update s[i] to 'a'
        // decrement k by a[i]
        if (m >= a[i])
        {
            s[i] = 'a';
            m = m - a[i];
        }
    }
 
    // Form a cycle of 26
    m = m % 26;
 
    // Update last element of
    // String with the value
    // s[i] + (k % 26)
    s[n - 1] = (char)(s[n - 1] + m);
 
    // Return the answer
    Console.Write(String.Join("", s));
}
 
// Driver code
public static void Main(String[] args)
{
    String str = "aazzx";
    int m = 6;
     
    smallest_String(str.ToCharArray(), m);
}
}
 
// This code is contributed by Princi Singh

<script>
 
// JavaScript implementation to find the
// lexicographical smallest string
// after performing M operations
 
 
// Function to find the
// lexicographical smallest string
// after performing M operations
function smallest_string(s,m)
{
 
    // Size of the given string
    let n = s.length;
 
    // Declare an array a
    let a = new Array(n).fill(0);
 
    // For each i, a[i] contain number
    // of operations to update s[i] to 'a'
    for (let i = 0; i < n; i++) {
        let distance = s.charCodeAt(i) - 'a'.charCodeAt(0);
        if (distance == 0)
            a[i] = 0;
 
        else
            a[i] = 26 - distance;
    }
 
    for (let i = 0; i <br n; i++) {
        // Check if m >= ar[i],
        // then update s[i] to 'a'
        // decrement k by a[i]
        if (m >= a[i]) {
            s = s.replace(s[i],'a');
            m = m - a[i];
        }
    }
 
    // Form a cycle of 26
    m = m % 26;
 
    // update last element of
    // string with the value
    // s[i] + (k % 26)
 
    s = s.substring(0,n-1)  + String.fromCharCode(s.charCodeAt(n - 1) + m);
 
    // Return the answer
    document.write(s,"</br>");
}
 
// Driver code
 
let str = "aazzx";
let m = 6;
smallest_string(str, m)
 
// This code is contributed by shinjanpatra
 
</script>

aaaab

Complejidad de tiempo: O(N), donde N es la longitud de la string dada 
Espacio auxiliar: O(N), donde N es la longitud de la string dada