Maximize cost of removing all occurrences of substrings "ab" and "ba"

// Java program for the above approach:

import java.util.*;

class GFG {

    // Function to find the maximum cost of
    // removing substrings "ab" and "ba" from S
    public static int MaxCollection(
        String S, int P, int Q)
    {
        // MaxStr is the substring char
        // array with larger cost
        char maxstr[]
            = (P >= Q ? "ab" : "ba").toCharArray();

        // MinStr is the substring char
        // array with smaller cost;
        char minstr[]
            = (P >= Q ? "ba" : "ab").toCharArray();

        // Denotes larger point
        int maxp = Math.max(P, Q);

        // Denotes smaller point
        int minp = Math.min(P, Q);

        // Stores cost scored
        int cost = 0;

        // Removing all occurrences of
        // maxstr from the S

        // Stack to keep track of characters
        Stack<Character> stack1 = new Stack<>();
        char[] s = S.toCharArray();

        // Traverse the string
        for (char ch : s) {

            // If the substring is maxstr

            if (!stack1.isEmpty()
                && (stack1.peek() == maxstr[0]
                    && ch == maxstr[1])) {

                // Pop from the stack
                stack1.pop();

                // Add maxp to cost
                cost += maxp;
            }

            // Push the character to the stack
            else {

                stack1.push(ch);
            }
        }

        // Remaining string after removing maxstr
        StringBuilder sb = new StringBuilder();

        // Find remaining string
        while (!stack1.isEmpty())
            sb.append(stack1.pop());

        // Reversing the string
        // retrieved from the stack
        sb = sb.reverse();
        String remstr = sb.toString();

        // Removing all occurrences of minstr
        for (char ch : remstr.toCharArray()) {

            // If the substring is minstr
            if (!stack1.isEmpty()
                && (stack1.peek() == minstr[0]
                    && ch == minstr[1])) {

                // Pop from the stack
                stack1.pop();

                // Add minp to the cost
                cost += minp;
            }

            // Otherwise
            else {
                stack1.push(ch);
            }
        }

        // Return the maximum cost
        return cost;
    }

    // Driver Code
    public static void main(String[] args)
    {

        // Input String
        String S = "cbbaabbaab";

        // Costs
        int P = 6;
        int Q = 4;

        System.out.println(MaxCollection(S, P, Q));
    }
}