Lexicographically smallest string possible by using given operations
Last Updated :
06 Feb, 2023
Given a string S consisting of digits from 0 to 9 inclusive, the task is to form the lexicographically smallest string by performing an operation any number of times. In one operation you can choose any position i and delete the digit d at s[i] and insert min(d+1, 9) on any position (at the beginning, at the end, or in between any two adjacent digits).
Examples:
Input: s = “04829”
Output: “02599”
Explanation: Delete 8 and insert 9 at the end of the string, the resulting string is 04299 then delete 4 and insert 5 in the 2nd position of the string. The resulting string is 02599.
Input: s = “07”
Output: “07”
Explanation: Nothing needs to be done here. It is already the lexicographically smallest string we can get.
Approach: To solve the problem follow the below idea:
The idea is to place the smallest digit just before the greater digit in order to form the lexicographically Smallest string. This can be done by iterating from second last digit and if any digit d is found to be greater than its next digit, delete it and insert min (d+1, 9) to the position such that it is smaller than its next digit and greater than its previous digit i.e., string remains in increasing order. We can use priority queue to place the digit to its correct position.
Follow the steps mentioned below to implement the idea:
- Declare the min heap which stores the digit at its correct position.
- Iterate from the second last digit in the reverse direction and if the current digit is found greater than the digit at its next index, delete it
- Insert min (d+1, 9) in the priority queue (min-heap)
- Declare the new string ans to store the resultant string.
- Pop out the top digit from the priority queue until the queue becomes empty and insert it into the resultant string.
- Return the resultant string formed.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
string smallest_string(string& s, int n)
{
priority_queue<int, vector<int>, greater<int> > pq;
int last_digit = s[n - 1] - '0';
pq.push(last_digit);
for (int i = n - 2; i >= 0; i--) {
int value = s[i] - '0';
if (value > last_digit) {
int mini = min(value + 1, 9);
pq.push(mini);
}
else {
last_digit = value;
pq.push(value);
}
}
string ans = "";
while (!pq.empty()) {
string temp = to_string(pq.top());
ans += temp;
pq.pop();
}
return ans;
}
int main()
{
string s = "04829";
int n = s.length();
cout << smallest_string(s, n) << endl;
s = "07";
n = s.length();
cout << smallest_string(s, n) << endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
import java.util.PriorityQueue;
public class Gfg {
public static String smallestString(String s, int n)
{
PriorityQueue<Integer> pq = new PriorityQueue<>();
int lastDigit = s.charAt(n - 1) - '0';
pq.offer(lastDigit);
for (int i = n - 2; i >= 0; i--) {
int value = s.charAt(i) - '0';
if (value > lastDigit) {
int mini = Math.min(value + 1, 9);
pq.offer(mini);
}
else {
lastDigit = value;
pq.offer(value);
}
}
StringBuilder ans = new StringBuilder();
while (!pq.isEmpty()) {
ans.append(pq.poll());
}
return ans.toString();
}
public static void main(String[] args)
{
String s = "04829";
int n = s.length();
System.out.println(smallestString(s, n));
s = "07";
n = s.length();
System.out.println(smallestString(s, n));
}
}
|
Python3
import heapq
def smallest_string(s: str, n: int) -> str:
pq = []
last_digit = int(s[n - 1])
heapq.heappush(pq, last_digit)
for i in range(n - 2, -1, -1):
value = int(s[i])
if value > last_digit:
mini = min(value + 1, 9)
heapq.heappush(pq, mini)
else:
last_digit = value
heapq.heappush(pq, value)
ans = ""
while pq:
ans += str(heapq.heappop(pq))
return ans
if __name__ == "__main__":
s = "04829"
n = len(s)
print(smallest_string(s, n))
s = "07"
n = len(s)
print(smallest_string(s, n))
|
C#
using System;
using System.Linq;
using System.Collections.Generic;
public class GFG {
static string smallest_string(string s, int n)
{
SortedSet<int> pq = new SortedSet<int>();
int last_digit = s[n - 1] - '0';
pq.Add(last_digit);
for (int i = n - 2; i >= 0; i--) {
int value = s[i] - '0';
if (value > last_digit) {
int mini = Math.Min(value + 1, 9);
pq.Add(mini);
}
else {
last_digit = value;
pq.Add(value);
}
}
string ans = "";
foreach(int item in pq) { ans += item; }
if (ans.Length < n) {
for (int i = ans.Length; i < n; i++) {
ans += "9";
}
}
return ans;
}
static public void Main()
{
string s = "04829";
int n = s.Length;
Console.WriteLine(smallest_string(s, n));
s = "07";
n = s.Length;
Console.WriteLine(smallest_string(s, n));
}
}
|
Javascript
function smallest_string(s, n) {
let pq = new PriorityQueue({
comparator: (a, b) => a - b
});
let last_digit = s[n - 1] - '0';
pq.enqueue(last_digit);
for (let i = n - 2; i >= 0; i--)
{
let value = s[i] - '0';
if (value > last_digit) {
let mini = Math.min(value + 1, 9);
pq.enqueue(mini);
} else {
last_digit = value;
pq.enqueue(value);
}
}
let ans = "";
while (!pq.isEmpty()) {
let temp = String(pq.dequeue());
ans += temp;
}
return ans;
}
let s = "04829";
let n = s.length;
console.log(smallest_string(s, n));
s = "07";
n = s.length;
console.log(smallest_string(s, n));
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Related Articles:
Share your thoughts in the comments
Please Login to comment...