Maximum weight transformation of a given string

Given a string consisting of only A’s and B’s. We can transform the given string to another string by toggling any character. Thus many transformations of the given string are possible. The task is to find Weight of the maximum weight transformation.

Weight of a sting is calculated using below formula.

Weight of string = Weight of total pairs +
weight of single characters -
Total number of toggles.

Two consecutive characters are considered as pair only if they
are different.
Weight of a single pair (both character are different) = 4
Weight of a single character = 1

Examples :

Input: str = "AA"
Output: 3
Transformations of given string are "AA", "AB", "BA" and "BB".
Maximum weight transformation is "AB" or "BA".  And weight
is "One Pair - One Toggle" = 4-1 = 3.

Input: str = "ABB"
Output: 5
Transformations are "ABB", "ABA", "AAB", "AAA", "BBB",
"BBA", "BAB" and "BAA"
Maximum weight is of original string 4+1 (One Pair + 1
character)

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

If (n == 1)
maxWeight(str[0..n-1]) = 1

Else If str != str
// Max of two cases: First character considered separately
//                   First pair considered separately
maxWeight(str[0..n-1]) = Max (1 + maxWeight(str[1..n-1]),
4 + getMaxRec(str[2..n-1])
Else
// Max of two cases: First character considered separately
//                   First pair considered separately
// Since first two characters are same and a toggle is
// required to form a pair, 3 is added for pair instead
// of 4
maxWeight(str[0..n-1]) = Max (1 + maxWeight(str[1..n-1]),
3 + getMaxRec(str[2..n-1])

If we draw the complete recursion tree, we can observer that many subproblems are solved again and again. Since same suproblems are called again, this problem has Overlapping Subprolems property. So min square sum problem has both properties (see this and this) of a dynamic programming problem. Like other typical Dynamic Programming(DP) problems.

Below is a memoization based solution. A lookup table is used to see if a problem is already computed.

C++

 // C++ program to find maximum weight  // transformation of a given string #include using namespace std;    // Returns weight of the maximum  // weight transformation int getMaxRec(string &str, int i, int n,                             int lookup[]) {     // Base case     if (i >= n) return 0;        //If this subproblem is already solved     if (lookup[i] != -1) return lookup[i];        // Don't make pair, so      // weight gained is 1     int ans = 1 + getMaxRec(str, i + 1, n,                                    lookup);        // If we can make pair     if (i + 1 < n)     {     // If elements are dissmilar,     // weight gained is 4     if (str[i] != str[i+1])         ans = max(4 + getMaxRec(str, i + 2,                                  n, lookup), ans);        // if elements are similar so for      // making a pair we toggle any of them.     // Since toggle cost is 1 so      // overall weight gain becomes 3     else ans = max(3 + getMaxRec(str, i + 2,                                   n, lookup), ans);     }        // save and return maximum     // of above cases     return lookup[i] = ans; }    // Initializes lookup table  // and calls getMaxRec() int getMaxWeight(string str) {     int n = str.length();        // Create and initialize lookup table     int lookup[n];     memset(lookup, -1, sizeof lookup);        // Call recursive function     return getMaxRec(str, 0, str.length(),                                   lookup); }    // Driver Code int main() {     string str = "AAAAABB";     cout << "Maximum weight of a transformation of "           << str << " is " << getMaxWeight(str);     return 0; }

Java

 // Java program to find maximum  // weight transformation of a // given string class GFG {            // Returns wieght of the maximum      // weight transformation     static int getMaxRec(String str, int i,             int n, int[] lookup)      {         // Base case         if (i >= n)          {             return 0;         }            // If this subproblem is already solved         if (lookup[i] != -1)          {             return lookup[i];         }            // Don't make pair, so          // weight gained is 1         int ans = 1 + getMaxRec(str, i + 1,                             n, lookup);            // If we can make pair         if (i + 1 < n)         {                            // If elements are dissmilar,              // weight gained is 4             if (str.charAt(i) != str.charAt(i + 1))             {                 ans = Math.max(4 + getMaxRec(str, i + 2,                                 n, lookup), ans);             }                             // if elements are similar so for              // making a pair we toggle any of              // them. Since toggle cost is             // 1 so overall weight gain becomes 3             else              {                 ans = Math.max(3 + getMaxRec(str, i + 2,                                 n, lookup), ans);             }         }            // save and return maximum         // of above cases         return lookup[i] = ans;     }        // Initializes lookup table     // and calls getMaxRec()     static int getMaxWeight(String str)      {         int n = str.length();            // Create and initialize lookup table         int[] lookup = new int[n];         for (int i = 0; i < n; i++)         {             lookup[i] = -1;         }            // Call recursive function         return getMaxRec(str, 0, str.length(),                             lookup);     }        // Driver Code     public static void main(String[] args)     {            String str = "AAAAABB";         System.out.println("Maximum weight of a"                         + " transformation of "                         + str + " is "                         + getMaxWeight(str));     } }    // This code is contributed by 29AjayKumar

Python3

 # Python3 program to find maximum weight # transformation of a given string    # Returns weight of the maximum # weight transformation  def getMaxRec(string, i, n, lookup):            # Base Case     if i >= n:         return 0        # If this subproblem is already solved     if lookup[i] != -1:         return lookup[i]        # Don't make pair, so     # weight gained is 1     ans = 1 + getMaxRec(string, i + 1, n,                         lookup)        # If we can make pair     if i + 1 < n:                    # If elements are dissimilar         if string[i] != string[i + 1]:             ans = max(4 + getMaxRec(string, i + 2,                                     n, lookup), ans)         # if elements are similar so for         # making a pair we toggle any of them.         # Since toggle cost is 1 so         # overall weight gain becomes 3         else:             ans = max(3 + getMaxRec(string, i + 2,                                     n, lookup), ans)     # save and return maximum     # of above cases     lookup[i] = ans     return ans    # Initializes lookup table # and calls getMaxRec()  def getMaxWeight(string):        n = len(string)        # Create and initialize lookup table     lookup = [-1] * (n)        # Call recursive function     return getMaxRec(string, 0,                      len(string), lookup)    # Driver Code if __name__ == "__main__":     string = "AAAAABB"     print("Maximum weight of a transformation of",            string, "is", getMaxWeight(string))    # This code is contributed by vibhu4agarwal

C#

 // C# program to find maximum  // weight transformation of a // given string using System;    class GFG { // Returns wieght of the maximum  // weight transformation static int getMaxRec(string str, int i,                       int n, int []lookup) {     // Base case     if (i >= n) return 0;        //If this subproblem is already solved     if (lookup[i] != -1) return lookup[i];        // Don't make pair, so      // weight gained is 1     int ans = 1 + getMaxRec(str, i + 1,                              n, lookup);        // If we can make pair     if (i + 1 < n)     {     // If elements are dissmilar,      // weight gained is 4     if (str[i] != str[i + 1])         ans = Math.Max(4 + getMaxRec(str, i + 2,                                       n, lookup), ans);        // if elements are similar so for      // making a pair we toggle any of      // them. Since toggle cost is     // 1 so overall weight gain becomes 3     else ans = Math.Max(3 + getMaxRec(str, i + 2,                                        n, lookup), ans);     }        // save and return maximum     // of above cases     return lookup[i] = ans; }    // Initializes lookup table // and calls getMaxRec() static int getMaxWeight(string str) {     int n = str.Length;        // Create and initialize lookup table     int[] lookup = new int[n];     for(int i = 0 ; i < n ; i++)     lookup[i] = -1;        // Call recursive function     return getMaxRec(str, 0, str.Length,                                   lookup); }    // Driver Code public static void Main() {     string str = "AAAAABB";     Console.Write("Maximum weight of a" +                    " transformation of " +                            str + " is " +                        getMaxWeight(str)); } }    // This code is contributed by Sumit Sudhakar

Output:

Maximum weight of a transformation of AAAAABB is 11

Thanks to Gaurav Ahirwar for providing above solution.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.