Skip to content
Related Articles

Related Articles

Improve Article

Maximize cost of repeated removal of string P or its reverse from the string S

  • Difficulty Level : Hard
  • Last Updated : 24 Aug, 2021

Given two positive integers X and Y and two numeric strings S and P of length N and 2 respectively, the task is to find the maximum total cost obtained by repeatedly removing string P or the reverse of the string P from the string S at the cost of X and Y respectively.

Examples:

Input: S = “12333444”, X = 5, Y = 4, P = “34”
Output: 15
Explanation:
Below are the operations to remove substring to get the maximum cost:

  • Remove the string 34″ from the string S. Therefore, the string S modifies to “123344”. Cost = 5.
  • Remove the string 34″ from the string S. Therefore, the string S modifies to “1234”. Cost = 5.
  • Remove the string 34″ from the string S. Therefore, the string S modifies to “12”. Cost = 5.

Therefore, the total cost is 5 +  5 + 5 = 15.

Input: S = “12121221”, X = 7, Y = 10, P = “12”
Output: 37



Approach: The given problem can be solved using the Greedy Approach and Stack. Follow the steps below to solve the problem:

  • Initialize a variable, say ans as 0 to store the maximum cost of removing the given substrings.
  • Initialize a Stack that is used to decide whether the string P or the reverse of P is removed.
  • Traverse the given string S and perform the following steps:
  • Similarly, the reverse of the string P can be removed from any string by adding Y to the cost.
  • Now, If X is greater than Y, then removing P before removing the reverse of P will give a greater value. Otherwise, remove the reverse of the pattern P first.
  • After completing the above steps, print the value of ans as the total maximum cost.

Below is the implementation of the above approach:

C++




// C++ program for above approach
#include <bits/stdc++.h>
using namespace std;
 
// Initialize amount
int ans[1] = {0};
 
// Function to remove reverse of P first
void rp(string str, int x, int y, bool flag, char p, char r)
{
 
  // Initialize empty stack
  stack<char>stk;
 
  // Iterate through each char in string
  for(int i = 0; i < str.length(); i++)
  {
    // Remove reverse of P
    if (str[i]== p) {
      if (stk.size() > 0 && stk.top() == r)
      {
        ans[0] += y;
 
        // Pop the element from
        // the stack
        stk.pop();
      }
      else
      {
        stk.push(str[i]);
      }
    }
    else
    {
      stk.push(str[i]);
    }
    // Remove P, if needed
    ans[0]+=1;
    if (flag)
    {
      string s = "";
      stack<char> s1 ;
      while (s1.size() > 0) {
        s += s1.top();
        s1.pop();
      }
      pr(s, x, y, false, p, r);
    }
  }
}
 
 
// Function to remove the string P first
void pr(string str, int x, int y, bool flag, char p, char r) {
 
  // Initialize empty stack
  stack<int>stk;
 
  // Iterate through each char
  // in string
  for(int i = 0; i < str.length(); i++) {
 
    // Remove the string P
    if (str[i]== r) {
      if (stk.size() > 0 && stk.top() == p) {
        ans[0] += x;
        stk.pop();
      }
      // If no such pair exists just
      // push the chars to stack
      else {
        stk.push(str[i]);
      }
    }
    else {
      stk.push(str[i]);
    }
    ans[0] += 1;
 
    // Remove reverse of P, if needed
    if (flag) {
      string s = "";
      stack<char>s1;
      while (s1.size() > 0) {
        s = s + s1.top();
        s1.pop();
      }
      rp(s, x, y, false, p, r);
    }
  }
}
 
 
 
// Function to find the appropriate answer
int solve(string str, int x, int y, char p, char r) {
 
  // Remove P then reverse of P
  if (x > y)
    pr(str, x, y, true, p, r);
 
  // Remove reverse of P then P
  else
    rp(str, x, y, true, p, r);
 
  // Return the result
  return ans[0]-1;
}
 
// Driver Code
int main() {
 
  // Given string S
  string S = "12333444";
 
  // Given X and Y
  int x = 5;
  int y = 4;
 
  // Given P
  String P = "34";
 
  // Function Call
  cout<<solve(S, x, y, P[0], P[1]<<endl;
              return 0;
              }
              // This code is contributed by dwivediyash

Java




// Java program for the above approach
import java.util.*;
public class Main
{
   
    // Initialize amount
    static int[] ans = {0};
          
    // Function to remove the string P first
    static void pr(String str, int x, int y, boolean flag, char p, char r) {
       
        // Initialize empty stack
        Stack<Character> stack = new Stack<Character>();
          
        // Iterate through each char
        // in string
        for(int i = 0; i < str.length(); i++) {
              
            // Remove the string P
            if (str.charAt(i) == r) {
                if (stack.size() > 0 && stack.peek() == p) {
                    ans[0] += x;
                    stack.pop();
                }
                // If no such pair exists just
                // push the chars to stack
                else {
                    stack.push(str.charAt(i));
                }
            }
            else {
                stack.push(str.charAt(i));
            }
            ans[0] += 1;
           
            // Remove reverse of P, if needed
            if (flag) {
                String s = "";
                Stack<Character> s1 = stack;
                while (s1.size() > 0) {
                    s = s + s1.peek();
                    s1.pop();
                }
                rp(s, x, y, false, p, r);
            }
        }
    }
      
    // Function to remove reverse of P first
    static void rp(String str, int x, int y, boolean flag, char p, char r)
    {
        // Initialize empty stack
        Stack<Character> stack = new Stack<Character>();
      
        // Iterate through each char in string
        for(int i = 0; i < str.length(); i++)
        {
            // Remove reverse of P
            if (str.charAt(i) == p) {
                if (stack.size() > 0 && stack.peek() == r)
                {
                    ans[0] += y;
       
                    // Pop the element from
                    // the stack
                    stack.pop();
                }
                else
                {
                    stack.push(str.charAt(i));
                }
            }
            else
            {
                stack.push(str.charAt(i));
            }
            // Remove P, if needed
            ans[0]+=1;
            if (flag)
            {
                String s = "";
                Stack<Character> s1 = stack;
                while (s1.size() > 0) {
                    s = s + s1.peek();
                    s1.pop();
                }
                pr(s, x, y, false, p, r);
            }
        }
    }
      
    // Function to find the appropriate answer
    static int solve(String str, int x, int y, char p, char r) {
       
        // Remove P then reverse of P
        if (x > y)
            pr(str, x, y, true, p, r);
       
        // Remove reverse of P then P
        else
            rp(str, x, y, true, p, r);
       
        // Return the result
        return ans[0]-1;
    }
     
  // Driver code
    public static void main(String[] args)
    {
       
        // Given string S
        String S = "12333444";
           
        // Given X and Y
        int x = 5;
        int y = 4;
           
        // Given P
        String P = "34";
           
        // Function Call
        System.out.print(solve(S, x, y, P.charAt(0), P.charAt(1)));
    }
}
 
// This code is contributed by mukesh07.

Python3




# Python program for the above approach
 
# Function to remove reverse of P first
def rp(string, x, y, ans, flag, p, r):
 
    # Initialize empty stack
    stack = []
 
    # Iterate through each char in string
    for char in string:       
 
        # Remove reverse of P
        if char == p:
            if stack and stack[-1] == r:
                ans[0] += y
 
                # Pop the element from
                # the stack
                stack.pop()
            else:
                stack.append(char)
        else:
            stack.append(char)
 
    # Remove P, if needed
    if flag:
        pr("".join(stack), x, y, ans, False, p, r)
 
# Function to remove the string P first
def pr(string, x, y, ans, flag, p, r):
 
    # Initialize empty stack
    stack = []
 
    # Iterate through each char
    # in string
    for char in string:
 
      # Remove the string P
        if char == r:
             
            if stack and stack[-1] == p:
                ans[0] += x
                stack.pop()
                 
            # If no such pair exists just
            # push the chars to stack
            else:
                stack.append(char)
                 
        else:
            stack.append(char)
             
        # Remove reverse of P, if needed
        if flag:
            rp("".join(stack), x, y, ans, False, p, r)
 
# Function to find the appropriate answer
def solve(string, x, y, p, r):
 
    # Initialize amount
    ans = [0]
 
    # Remove P then reverse of P
    if x > y:
        pr(string, x, y, ans, True, p, r)
     
    # Remove reverse of P then P
    else:
        rp(string, x, y, ans, True, p, r)
     
    # Return the result
    return ans[0]
 
 
# Driver Code
 
# Given string S
S = "12333444"
 
# Given X and Y
x = 5
y = 4
 
# Given P
P = "34"
 
# Function Call
print(solve(S, x, y, P[0], P[1]))

C#




// C# program for the above approach
using System;
using System.Collections;
class GFG {
     
    // Initialize amount
    static int[] ans = {0};
         
    // Function to remove the string P first
    static void pr(string str, int x, int y, bool flag, char p, char r) {
      
        // Initialize empty stack
        Stack stack = new Stack();
         
        // Iterate through each char
        // in string
        foreach(char c in str) {
             
            // Remove the string P
            if (c == r) {
                if (stack.Count > 0 && (char)stack.Peek() == p) {
                    ans[0] += x;
                    stack.Pop();
                }
                // If no such pair exists just
                // push the chars to stack
                else {
                    stack.Push(c);
                }
            }
            else {
                stack.Push(c);
            }
            ans[0]+=1;
            // Remove reverse of P, if needed
            if (flag) {
                string s = "";
                Stack s1 = stack;
                while (s1.Count > 0) {
                    s = s + (char)s1.Peek();
                    s1.Pop();
                }
                rp(s, x, y, false, p, r);
            }
        }
    }
     
    // Function to remove reverse of P first
    static void rp(string str, int x, int y, bool flag, char p, char r)
    {
        // Initialize empty stack
        Stack stack = new Stack();
     
        // Iterate through each char in string
        foreach(char c in str)
        {
            // Remove reverse of P
            if (c == p) {
                if (stack.Count > 0 && (char)stack.Peek() == r)
                {
                    ans[0] += y;
      
                    // Pop the element from
                    // the stack
                    stack.Pop();
                }
                else
                {
                    stack.Push(c);
                }
            }
            else
            {
                stack.Push(c);
            }
            // Remove P, if needed
            ans[0]+=1;
            if (flag)
            {
                string s = "";
                Stack s1 = stack;
                while (s1.Count > 0) {
                    s = s + (char)s1.Peek();
                    s1.Pop();
                }
                pr(s, x, y, false, p, r);
            }
        }
    }
     
    // Function to find the appropriate answer
    static int solve(string str, int x, int y, char p, char r) {
      
        // Remove P then reverse of P
        if (x > y)
            pr(str, x, y, true, p, r);
      
        // Remove reverse of P then P
        else
            rp(str, x, y, true, p, r);
      
        // Return the result
        return ans[0]-1;
    }
     
    static void Main()
    {
       
        // Given string S
        string S = "12333444";
          
        // Given X and Y
        int x = 5;
        int y = 4;
          
        // Given P
        string P = "34";
          
        // Function Call
        Console.Write(solve(S, x, y, P[0], P[1]));
    }
}
 
// This code is contributed by divyesh072019.

Javascript




<script>
 
// Javascript program for the above approach
 
// Function to remove reverse of P first
function rp(string, x, y, ans, flag, p, r) {
 
    // Initialize empty stack
    let stack = []
     
 
    // Iterate through each char in string
    for (let char of string) {
 
        // Remove reverse of P
        if (char == p) {
            if (stack && stack[stack.length - 1] == r) {
                ans[0] += y
 
                // Pop the element from
                // the stack
                stack.pop()
            }
            else
                stack.push(char)
        }
        else
            stack.push(char)
        // Remove P, if needed
 
        if (flag) {
            pr(stack.join(""), x, y, ans, false, p, r)
        }
    }
}
 
// Function to remove the string P first
function pr(string, x, y, ans, flag, p, r) {
 
    // Initialize empty stack
    let stack = []
 
    // Iterate through each char
    // in string
    for (let char of string) {
 
        // Remove the string P
        if (char == r) {
 
            if (stack && stack[stack.length - 1] == p) {
                ans[0] += x
                stack.pop()
            }
            // If no such pair exists just
            // push the chars to stack
            else {
                stack.push(char)
            }
        }
        else {
            stack.push(char)
        }
 
        // Remove reverse of P, if needed
        if (flag) {
            rp(stack.join(""), x, y, ans, false, p, r)
        }
    }
}
 
 
// Function to find the appropriate answer
function solve(string, x, y, p, r) {
 
    // Initialize amount
    let ans = [0]
 
    // Remove P then reverse of P
    if (x > y)
        pr(string, x, y, ans, true, p, r)
 
    // Remove reverse of P then P
    else
        rp(string, x, y, ans, true, p, r)
 
    // Return the result
    return ans[0]
}
 
// Driver Code
 
// Given string S
let S = "12333444"
 
// Given X and Y
let x = 5
let y = 4
 
// Given P
let P = "34"
 
// Function Call
document.write(solve(S, x, y, P[0], P[1]))
 
// This code is contributed by _saurabh_jaiswal.
</script>
Output: 
15

 

Time Complexity: O(N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :