 Open in App
Not now

# Minimize deletions to reduce String to size 1 wherein ith deletion, N/2^i occurrences of (X+i-1)th character can be deleted

• Last Updated : 20 Jan, 2022

Given string str of length N and a character X, where N is always of the form 2k, the task is to find the minimum replacement operations required to reduce the size of the string to 1 wherein ith deletion, N/2i occurrences of (X + i – 1)th character can be deleted either from the front or the back of the string.

Example:

Input: str = “CDAAAABB”, X = ‘A’
Output: 4
Explanation: Replacement operations on the given string can be done as:

1. Replace ‘C’ at 1st index with ‘A’.
2. Replace ‘D’ at 2nd index with ‘A’.
3. Replace ‘A’ at 5th index with ‘D’.
4. Replace ‘A’ at 6th index with ‘C’.

Therefore, the string becomes str = “AAAADCBB”. During the 1st deletion (8/21) occurrences of (A+1-1)th character can be removed from the front of the string. Therefore, the string becomes str = “DCBB”. Similarly, during the 2nd deletion (8/22) occurrences of (A+2-1)th  i.e, ‘B’ character can be removed from the back of the string. Therefore, the string becomes str = “DC”. Similarly, after the 3rd deletion, the string becomes str = “D” having length as 1. Therefore, the number of required replacement operations are 4 which is the minimum possible.

Input: str = “QRQP”, X = ‘P’
Output: 1

Approach: The given problem can be solved by using Recursion having a similar structure as that of the Binary Search. During each deletion, it can be observed that there are 2 possible choices. They are as follows:

1. Replace all the characters of the first half of the given string by ‘X’ and recursively call for the remaining half for X = X + 1.
2. Or, replace all the characters of the second half of the given string by ‘X’ and recursively call for the remaining half for X = X + 1.

Therefore, using the above observations create a recursive function that takes the minimum moves out of the two possibilities by calculating the number of indices that need to be replaced to X in the first half of the string and recursively calling for the remaining half and vice versa.

Below is the implementation of the above approach:

## C++

 `// C++ implementation for the above approach``#include ``using` `namespace` `std;` `// Recursive function to find minimum``// replacements required to reduce the``// size of the given string to 1``int` `minReplacment(string s, ``char` `x)``{``    ``// Base Case``    ``if` `(s.size() == 1) {``        ``return` `s != x;``    ``}` `    ``// Stores the middle index``    ``int` `mid = s.size() / 2;` `    ``// Recursive call for left half``    ``int` `cntl = minReplacment(``        ``string(s.begin(), s.begin() + mid), x + 1);``    ``cntl += s.size() / 2``            ``- count(s.begin() + mid, s.end(), x);` `    ``// Recursive call for right half``    ``int` `cntr = minReplacment(``        ``string(s.begin() + mid, s.end()), x + 1);``    ``cntr += s.size() / 2``            ``- count(s.begin(), s.begin() + mid, x);` `    ``// Return Answer``    ``return` `min(cntl, cntr);``}` `// Driver Code``int` `main()``{``    ``int` `N = 8;``    ``string str = ``"CDAAAABB"``;``    ``char` `X = ``'A'``;` `    ``cout << minReplacment(str, X);` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``// Java code for the above approach``import` `java.util.*;` `class` `GFG {``    ``public` `static` `int` `count(String str, ``char` `c)``    ``{``        ``int` `ct = ``0``;` `        ``for` `(``int` `i = ``0``; i < str.length(); i++) {``            ``char` `currChar = str.charAt(i);``            ``if` `(currChar == c)``                ``ct += ``1``;``        ``}` `        ``return` `ct;``    ``}` `    ``// Recursive function to find minimum``    ``// replacements required to reduce the``    ``// size of the given string to 1``    ``static` `int` `minReplacment(String s, ``char` `x)``    ``{``        ``// Base Case``        ``if` `(s.length() == ``1``) {``            ``if` `(s.charAt(``0``) == x)``                ``return` `1``;``            ``return` `0``;``        ``}` `        ``// Stores the middle index``        ``int` `mid = s.length() / ``2``;` `        ``// Recursive call for left half``        ``char` `p = (``char``)(x + ``1``);``        ``int` `cntl = minReplacment(s.substring(``0``, mid), p);``        ``cntl = cntl + s.length() / ``2``               ``- count(s.substring(mid, s.length()), x);` `        ``// Recursive call for right half``        ``char` `t = (``char``)(x + ``1``);``        ``int` `cntr = minReplacment(``            ``s.substring(mid, s.length()), t);``        ``cntr = cntr + s.length() / ``2``               ``- count(s.substring(``0``, mid), x);` `        ``// Return Answer``        ``return` `Math.min(cntl + ``1``, cntr);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `N = ``8``;``        ``String str = ``"CDAAAABB"``;``        ``char` `X = ``'A'``;``        ``System.out.println(minReplacment(str, X));``    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# Python 3 implementation for the above approach` `# Recursive function to find minimum``# replacements required to reduce the``# size of the given string to 1``def` `minReplacment(s,  x):` `    ``# Base Case``    ``if` `(``len``(s) ``=``=` `1``):``        ``return` `s[``0``] !``=` `x` `    ``# Stores the middle index``    ``mid ``=` `len``(s) ``/``/` `2` `    ``# Recursive call for left half``    ``cntl ``=` `minReplacment(``        ``s[:mid], ``chr``(``ord``(x) ``+` `1``))``    ``cntl ``+``=` `len``(s) ``/``/` `2` `-` `s[mid:].count(x)` `    ``# Recursive call for right half``    ``cntr ``=` `minReplacment(``        ``s[mid:], ``chr``(``ord``(x) ``+` `1``))``    ``cntr ``+``=` `len``(s) ``/``/` `2` `-` `s[:mid].count(x)` `    ``# Return Answer``    ``return` `min``(cntl, cntr)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `8``    ``st ``=` `"CDAAAABB"``    ``X ``=` `'A'` `    ``print``(minReplacment(st, X))` `    ``# This code is contributed by ukasp.`

## C#

 `/*package whatever //do not write package name here */``// C# code for the above approach``using` `System;` `public` `class` `GFG {``    ``public` `static` `int` `count(String str, ``char` `c)``    ``{``        ``int` `ct = 0;` `        ``for` `(``int` `i = 0; i < str.Length; i++) {``            ``char` `currChar = str[i];``            ``if` `(currChar == c)``                ``ct += 1;``        ``}` `        ``return` `ct;``    ``}` `    ``// Recursive function to find minimum``    ``// replacements required to reduce the``    ``// size of the given string to 1``    ``static` `int` `minReplacment(String s, ``char` `x)``    ``{``        ``// Base Case``        ``if` `(s.Length == 1) {``            ``if` `(s == x)``                ``return` `1;``            ``return` `0;``        ``}` `        ``// Stores the middle index``        ``int` `mid = s.Length / 2;` `        ``// Recursive call for left half``        ``char` `p = (``char``)(x + 1);``        ``int` `cntl = minReplacment(s.Substring(0, mid), p);``        ``cntl = cntl + s.Length / 2``               ``- count(s.Substring(mid, s.Length-mid), x);` `        ``// Recursive call for right half``        ``char` `t = (``char``)(x + 1);``        ``int` `cntr = minReplacment(``            ``s.Substring(mid, s.Length-mid), t);``        ``cntr = cntr + s.Length / 2``               ``- count(s.Substring(0, mid), x);` `        ``// Return Answer``        ``return` `Math.Min(cntl + 1, cntr);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String str = ``"CDAAAABB"``;``        ``char` `X = ``'A'``;``        ``Console.WriteLine(minReplacment(str, X));``    ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output

`4`

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up