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)

If(n == 1) maxWeight(str[0..n-1]) = 1Else Ifstr[0] != str[1] // 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<bits/stdc++.h> ` `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; ` `} ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

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

## Recommended Posts:

- Maximum sum such that no two elements are adjacent
- Maximum size square sub-matrix with all 1s
- Maximum Sum Increasing Subsequence | DP-14
- Maximum Length Chain of Pairs | DP-20
- Maximum sum rectangle in a 2D matrix | DP-27
- Maximum Subarray Sum using Divide and Conquer algorithm
- Find if a string is interleaved of two other strings | DP-33
- Maximum Product Cutting | DP-36
- Find all distinct palindromic sub-strings of a given string
- How to print maximum number of A's using given four keys
- Maximum profit by buying and selling a share at most twice
- Collect maximum points in a grid using two traversals
- Collect maximum coins before hitting a dead end
- Maximum profit by buying and selling a share at most k times
- Find maximum length Snake sequence