 GeeksforGeeks App
Open App Browser
Continue

# Maximize cost obtained by removal of substrings “pr” or “rp” from a given String

Given a string str and two integers X and Y, the task is to find the maximum cost required to remove all the substrings “pr” and “rp” from the given string, where removal of substrings “rp” and “pr” costs X and Y respectively.

Examples:

Input: str = “abppprrr”, X = 5, Y = 4
Output: 15
Explanation:
Following operations are performed:
“abppprrr” -> “abpprr”, cost = 5
“abpprr” -> “abpr”, cost = 10
“abpr” -> “ab”, cost = 15
Therefore, the maximized cost is 15

Input: str = “prprprrp”, X = 7, Y = 10
Output: 37

Approach: The problem can be solved using the Greedy Approach. The idea here is to remove “pr” if X is greater than Y or remove “rp” otherwise. Follow the steps below to solve the problem.

1. If X < Y: Swap the value of X and Y and replace the character ‘p’ to ‘r’ and vice versa in the given string.
2. Initialize two variables countP and countR to store the count of ‘p’ and ‘r’ in the string respectively.
3. Iterate over the array arr[] and perform the steps below:
• If str[i] = ‘p’: Increment the countP by 1.
• If str[i] = ‘r’: Check the value of countP. If countP > 0, then increment the result by X and decrement the value of countP by 1. Otherwise, increment the value of countR by 1.
• If str[i] != ‘p’ and str[i]!=’r’: Increment the result by min(countP, countR) * Y.
4. Increment the result by min(countP, countR) * Y.
5. Finally, after the removal of all the required substrings, print the result obtained.

## C++

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to maintain the case, X>=Y``bool` `swapXandY(string& str, ``int` `X, ``int` `Y)``{` `    ``int` `N = str.length();` `    ``// To maintain X>=Y``    ``swap(X, Y);` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Replace 'p' to 'r'``        ``if` `(str[i] == ``'p'``) {``            ``str[i] = ``'r'``;``        ``}` `        ``// Replace 'r' to 'p'.``        ``else` `if` `(str[i] == ``'r'``) {``            ``str[i] = ``'p'``;``        ``}``    ``}``}` `// Function to return the maximum cost``int` `maxCost(string str, ``int` `X, ``int` `Y)``{``    ``// Stores the length of the string``    ``int` `N = str.length();` `    ``// To maintain X>=Y.``    ``if` `(Y > X) {``        ``swapXandY(str, X, Y);``    ``}` `    ``// Stores the maximum cost``    ``int` `res = 0;` `    ``// Stores the count of 'p'``    ``// after removal of all "pr"``    ``// substrings up to str[i]``    ``int` `countP = 0;` `    ``// Stores the count of 'r'``    ``// after removal of all "pr"``    ``// substrings up to str[i]``    ``int` `countR = 0;` `    ``// Stack to maintain the order of``    ``// characters after removal of``    ``// substrings``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(str[i] == ``'p'``) {``            ``countP++;``        ``}``        ``else` `if` `(str[i] == ``'r'``) {` `            ``// If substring "pr"``            ``// is removed``            ``if` `(countP > 0) {``                ``countP--;` `                ``// Increase cost by X``                ``res += X;``            ``}``            ``else``                ``countR++;``        ``}``        ``else` `{` `            ``// If any substring "rp"``            ``// left in the Stack``            ``res += min(countP, countR) * Y;``            ``countP = 0;``            ``countR = 0;``        ``}``    ``}` `    ``// If any substring "rp"``    ``// left in the Stack``    ``res += min(countP, countR) * Y;``    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``string str = ``"abppprrr"``;``    ``int` `X = 5, Y = 4;``    ``cout << maxCost(str, X, Y);``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `// Function to maintain the case, X>=Y``static` `boolean` `swapXandY(``char` `[]str, ``int` `X, ``int` `Y)``{``    ``int` `N = str.length;` `    ``// To maintain X>=Y``    ``X = X + Y;``    ``Y = X - Y;``    ``X = X - Y;` `    ``for``(``int` `i = ``0``; i < N; i++)``    ``{` `        ``// Replace 'p' to 'r'``        ``if` `(str[i] == ``'p'``)``        ``{``            ``str[i] = ``'r'``;``        ``}` `        ``// Replace 'r' to 'p'.``        ``else` `if` `(str[i] == ``'r'``)``        ``{``            ``str[i] = ``'p'``;``        ``}``    ``}``    ``return` `true``;``}` `// Function to return the maximum cost``static` `int` `maxCost(String str, ``int` `X, ``int` `Y)``{``    ` `    ``// Stores the length of the String``    ``int` `N = str.length();` `    ``// To maintain X>=Y.``    ``if` `(Y > X)``    ``{``        ``swapXandY(str.toCharArray(), X, Y);``    ``}` `    ``// Stores the maximum cost``    ``int` `res = ``0``;` `    ``// Stores the count of 'p'``    ``// after removal of all "pr"``    ``// subStrings up to str[i]``    ``int` `countP = ``0``;` `    ``// Stores the count of 'r'``    ``// after removal of all "pr"``    ``// subStrings up to str[i]``    ``int` `countR = ``0``;` `    ``// Stack to maintain the order of``    ``// characters after removal of``    ``// subStrings``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``if` `(str.charAt(i) == ``'p'``)``        ``{``            ``countP++;``        ``}``        ``else` `if` `(str.charAt(i) == ``'r'``)``        ``{``            ` `            ``// If subString "pr"``            ``// is removed``            ``if` `(countP > ``0``)``            ``{``                ``countP--;` `                ``// Increase cost by X``                ``res += X;``            ``}``            ``else``                ``countR++;``        ``}``        ``else``        ``{` `            ``// If any subString "rp"``            ``// left in the Stack``            ``res += Math.min(countP, countR) * Y;``            ``countP = ``0``;``            ``countR = ``0``;``        ``}``    ``}` `    ``// If any subString "rp"``    ``// left in the Stack``    ``res += Math.min(countP, countR) * Y;``    ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String str = ``"abppprrr"``;``    ``int` `X = ``5``, Y = ``4``;``    ` `    ``System.out.print(maxCost(str, X, Y));``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to maintain the case, X>=Y``def` `swapXandY(``str``, X, Y):` `    ``N ``=` `len``(``str``)` `    ``# To maintain X>=Y``    ``X, Y ``=` `Y, X` `    ``for` `i ``in` `range``(N):` `        ``# Replace 'p' to 'r'``        ``if``(``str``[i] ``=``=` `'p'``):``            ``str``[i] ``=` `'r'` `        ``# Replace 'r' to 'p'.``        ``elif``(``str``[i] ``=``=` `'r'``):``            ``str``[i] ``=` `'p'` `# Function to return the maximum cost``def` `maxCost(``str``, X, Y):` `    ``# Stores the length of the string``    ``N ``=` `len``(``str``)` `    ``# To maintain X>=Y.``    ``if``(Y > X):``        ``swapXandY(``str``, X, Y)` `    ``# Stores the maximum cost``    ``res ``=` `0` `    ``# Stores the count of 'p'``    ``# after removal of all "pr"``    ``# substrings up to str[i]``    ``countP ``=` `0` `    ``# Stores the count of 'r'``    ``# after removal of all "pr"``    ``# substrings up to str[i]``    ``countR ``=` `0` `    ``# Stack to maintain the order of``    ``# characters after removal of``    ``# substrings``    ``for` `i ``in` `range``(N):``        ``if``(``str``[i] ``=``=` `'p'``):``            ``countP ``+``=` `1` `        ``elif``(``str``[i] ``=``=` `'r'``):` `            ``# If substring "pr"``            ``# is removed``            ``if``(countP > ``0``):``                ``countP ``-``=` `1` `                ``# Increase cost by X``                ``res ``+``=` `X` `            ``else``:``                ``countR ``+``=` `1` `        ``else``:``            ` `            ``# If any substring "rp"``            ``# left in the Stack``            ``res ``+``=` `min``(countP, countR) ``*` `Y``            ``countP ``=` `0``            ``countR ``=` `0` `    ``# If any substring "rp"``    ``# left in the Stack``    ``res ``+``=` `min``(countP, countR) ``*` `Y` `    ``return` `res` `# Driver Code``str` `=` `"abppprrr"``X ``=` `5``Y ``=` `4` `# Function call``print``(maxCost(``str``, X, Y))` `# This code is contributed by Shivam Singh`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG{` `// Function to maintain the case, X>=Y``static` `bool` `swapXandY(``char` `[]str,``                      ``int` `X, ``int` `Y)``{``    ``int` `N = str.Length;` `    ``// To maintain X>=Y``    ``X = X + Y;``    ``Y = X - Y;``    ``X = X - Y;` `    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``// Replace 'p' to 'r'``        ``if` `(str[i] == ``'p'``)``        ``{``            ``str[i] = ``'r'``;``        ``}` `        ``// Replace 'r' to 'p'.``        ``else` `if` `(str[i] == ``'r'``)``        ``{``            ``str[i] = ``'p'``;``        ``}``    ``}``    ``return` `true``;``}` `// Function to return the``// maximum cost``static` `int` `maxCost(String str,``                   ``int` `X, ``int` `Y)``{   ``    ``// Stores the length of the String``    ``int` `N = str.Length;` `    ``// To maintain X>=Y.``    ``if` `(Y > X)``    ``{``        ``swapXandY(str.ToCharArray(),``                  ``X, Y);``    ``}` `    ``// Stores the maximum cost``    ``int` `res = 0;` `    ``// Stores the count of 'p'``    ``// after removal of all "pr"``    ``// subStrings up to str[i]``    ``int` `countP = 0;` `    ``// Stores the count of 'r'``    ``// after removal of all "pr"``    ``// subStrings up to str[i]``    ``int` `countR = 0;` `    ``// Stack to maintain the order of``    ``// characters after removal of``    ``// subStrings``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(str[i] == ``'p'``)``        ``{``            ``countP++;``        ``}``        ``else` `if` `(str[i] == ``'r'``)``        ``{           ``            ``// If subString "pr"``            ``// is removed``            ``if` `(countP > 0)``            ``{``                ``countP--;` `                ``// Increase cost by X``                ``res += X;``            ``}``            ``else``                ``countR++;``        ``}``        ``else``        ``{``            ``// If any subString "rp"``            ``// left in the Stack``            ``res += Math.Min(countP,``                            ``countR) * Y;``            ``countP = 0;``            ``countR = 0;``        ``}``    ``}` `    ``// If any subString "rp"``    ``// left in the Stack``    ``res += Math.Min(countP,``                    ``countR) * Y;``    ``return` `res;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``String str = ``"abppprrr"``;``    ``int` `X = 5, Y = 4;   ``    ``Console.Write(maxCost(str, X, Y));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`15`

Time Complexity:O(N), where N denotes the length of the string
Auxiliary Space:O(1)

### Another Approach:

1. First, we check either X is greater than Y or not if X > Y then removing “pr” will give us greater value and if Y > X then “rp” gives more.
2. We should greedily remove “pr” or “rp” depending upon whether X is greater or Y is greater.
3. We will be using a stack to keep the order same after removal of substrings.
4. After removing all possible “pr” we will check in rest of the string if any “rp” present and we will remove them and vice versa.

## C++

 `//{ Driver Code Starts``// Initial Template for C++``#include ``using` `namespace` `std;` `// } Driver Code Ends``// User function Template for C++``class` `Solution {``public``:``    ``void` `rp(string s, ``int` `x, ``int` `y, ``long` `long``& ans,``            ``bool` `flag)``    ``{``        ``// Create an empty str to keep track of the``        ``// characters that have not been processed yet``        ``string str;``        ``// Iterate through each character in the string``        ``for` `(``char` `c : s) {``            ``// If the character is a 'p'``            ``if` `(c == ``'p'``) {``                ``// Check if there is an 'r' on top of the``                ``// str``                ``if` `(!str.empty() && str.back() == ``'r'``) {``                    ``// If there is, remove the 'r' from the``                    ``// str and add y to the answer``                    ``ans += y;``                    ``str.pop_back();``                ``}``                ``else` `{``                    ``// Otherwise, add the 'p' to the str``                    ``str.push_back(c);``                ``}``            ``}``            ``else` `{``                ``// If the character is not a 'p', add it to``                ``// the str``                ``str.push_back(c);``            ``}``        ``}``        ``// If the flag is true, call the other function to``        ``// process the remaining characters``        ``if` `(flag) {``            ``pr(str, x, y, ans, ``false``);``        ``}``    ``}` `    ``void` `pr(string s, ``int` `x, ``int` `y, ``long` `long``& ans,``            ``bool` `flag)``    ``{``        ``// Create an empty str to keep track of the``        ``// characters that have not been processed yet``        ``string str;``        ``// Iterate through each character in the string``        ``for` `(``char` `c : s) {``            ``// If the character is an 'r'``            ``if` `(c == ``'r'``) {``                ``// Check if there is a 'p' on top of the str``                ``if` `(!str.empty() && str.back() == ``'p'``) {``                    ``// If there is, remove the 'p' from the``                    ``// str and add x to the answer``                    ``ans += x;``                    ``str.pop_back();``                ``}``                ``else` `{``                    ``// Otherwise, add the 'r' to the str``                    ``str.push_back(c);``                ``}``            ``}``            ``else` `{``                ``// If the character is not an 'r', add it to``                ``// the str``                ``str.push_back(c);``            ``}``        ``}``        ``// If the flag is true, call the other function to``        ``// process the remaining characters``        ``if` `(flag) {``            ``rp(str, x, y, ans, ``false``);``        ``}``    ``}` `    ``long` `long` `solve(``int` `x, ``int` `y, string s)``    ``{``        ``long` `long` `ans = 0;``        ``// Call the appropriate function depending on the``        ``// value of x and y``        ``if` `(x > y) {``            ``pr(s, x, y, ans, ``true``);``        ``}``        ``else` `{``            ``rp(s, x, y, ans, ``true``);``        ``}``        ``return` `ans;``    ``}``};` `//{ Driver Code Starts.``signed` `main()``{``    ``string s = ``"abppprrr"``;``    ``int` `x = 5, y = 4;``    ``Solution obj;``    ``long` `long` `answer = obj.solve(x, y, s);``    ``cout << ``"Maximize cost obtained by removal of substrings “pr” or “rp” : "``<< answer << endl;``}` `//Ravi Singh`

Output

```Maximize cost obtained by removal of substrings “pr” or “rp” : 15
```

Time Complexity: O(N), where N denotes the length of the string
Auxiliary Space:O(N)

My Personal Notes arrow_drop_up