Maximum weight transformation of a given string

04 Aug, 2021
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 string 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)
maxWeight(str[0..n-1]) = 1
Else If str[0] != str[1]// Max of two cases: First character considered separately// First pair considered separatelymaxWeight(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 4maxWeight(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 subproblems are called again, this problem has Overlapping Subproblems 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++
Java
Python3
C#
Javascript
// C++ program to find maximum weight// transformation of a given string#include<bits/stdc++.h>using namespace std; // Returns weight of the maximum// weight transformationint 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 dissimilar,    // 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 Codeint main(){    string str = "AAAAABB";    cout << "Maximum weight of a transformation of "          << str << " is " << getMaxWeight(str);    return 0;}
// Java program to find maximum// weight transformation of a// given stringclass GFG {         // Returns weight 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 dissimilar,            // 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 program to find maximum weight# transformation of a given string # Returns weight of the maximum# weight transformationdef 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 Codeif __name__ == "__main__":    string = "AAAAABB"    print("Maximum weight of a transformation of",           string, "is", getMaxWeight(string)) # This code is contributed by vibhu4agarwal
// C# program to find maximum// weight transformation of a// given stringusing System; class GFG{// Returns weight of the maximum// weight transformationstatic 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 dissimilar,    // 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 Codepublic 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
<script>    // Javascript program to find maximum    // weight transformation of a    // given string         // Returns weight of the maximum    // weight transformation    function getMaxRec(str, 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        let ans = 1 + getMaxRec(str, i + 1, n, lookup);           // If we can make pair        if (i + 1 < n)        {                           // If elements are dissimilar,            // 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()    function getMaxWeight(str)    {        let n = str.length;           // Create and initialize lookup table        let lookup = new Array(n);        lookup.fill(0);        for (let i = 0; i < n; i++)        {            lookup[i] = -1;        }           // Call recursive function        return getMaxRec(str, 0, str.length, lookup);    }         let str = "AAAAABB";    document.write("Maximum weight of a"                       + " transformation of "                       + str + " is "                       + getMaxWeight(str));     // This code is contributed by decode2207.</script>
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 
Sam007
29AjayKumar
vibhu4agarwal
decode2207
ruhelaa48
anikakapoor
simranarora5sos
Dynamic Programming
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.