GFG App
Open App
Browser
Continue

# Count of sum of “10” subsequences for each 1 in string with A 1s, B 10s and C 0s

Given an A “1″s, B “10”s, and C “0”s, the task is to count of sum of “10” subsequences for each 1s in the string with A 1s, B 10s and C 0s

Examples:

Input: A = 1, B = 2, C = 3
Output: 14
Explanation: A = 1 means one times “1” string, B = 2 means two times “10” strings, and C = 3 means three times”0″ strings.
After Concatenation, the string formed is “11010000”
So for 1st “1”, five “10” subsequences are possible,
for 2nd “1” five “10” subsequences are possible, and
for 3rd “1” four “10” subsequences are possible.
Hence total 5 + 5 + 4 = 14 subsequences are possible.

Input: A = 0, B = 0, C = 1
Output: 0
Explanation: A = 0 means no “1” string, B = 0 means no “10” string, and C = 1 means one times “0” string.
So, final string is “0”
Hence no “10” subsequence is possible and therefore output is 0.

Naive Approach: The most simple solution for this problem is to generate the string, and then for each 1, find the count of “10” subsequences possible. Return the sum of count of all such subsequences at the end.

Time Complexity: O(N*countOf1s)
Auxiliary Space: O(1)

Efficient Approach: The idea to solve the problem efficiently using some basic concepts of mathematics and combinatorials.

• To get maximum subsequence, append all “1” at the start of final string and “0” at the end of final string.
• Declare ans variable and store count of possible “10” subsequence form by A times “1” and B times “10” by multiplying (A*B)+((B*(B+1))/2).
• Add ans with count of possible “10” subsequence form by C times “0” and A & B time “1” by multiplying (A*B)*C.

Below is the implementation of the above approach.

## C++

 // C++ Code for the above approach:   #include using namespace std; int maxsubsequence(int A, int B, int C) {       // As the answer may be very large,     // Find it modulo 109 + 7     long long mod = 1e9 + 7;       // Count possible subsequence by     // A times"1" and B times"10"     long long ans         = (A * 1l * B) % mod           + ((B * 1l * (B + 1)) / 2) % mod;     if (ans >= mod) {         ans -= mod;     }       // Count possible subsequence     // By C times "0" and A & B time  "1"     ans += ((A + B) * 1l * C) % mod;     if (ans >= mod) {         ans -= mod;     }     return ans; }   // Driver code int main() {     int A = 1, B = 2, C = 3;     cout << maxsubsequence(A, B, C) << endl;     return 0; }

## Java

 // JAVA Code for the above approach:   import java.util.*; class GFG {   public static int maxsubsequence(int A, int B, int C)   {       // As the answer may be very large,     // Find it modulo 109 + 7     long mod = (long)(1e9 + 7);       // Count possible subsequence by     // A times"1" and B times"10"     long ans = (long)(A * B) % mod       + ((B * (B + 1)) / 2) % mod;     if (ans >= mod) {       ans -= mod;     }       // Count possible subsequence     // By C times "0" and A & B time  "1"     ans += ((A + B) * C) % mod;     if (ans >= mod) {       ans -= mod;     }     return (int)ans;   }     // Driver code   public static void main(String[] args)   {     int A = 1, B = 2, C = 3;     System.out.println(maxsubsequence(A, B, C));   } }   // This code is contributed by Taranpreet

## Python3

 # python3 Code for the above approach: def maxsubsequence(A, B, C):       # As the answer may be very large,     # Find it modulo 109 + 7     mod = int(1e9 + 7)       # Count possible subsequence by     # A times"1" and B times"10"     ans = (A * 1 * B) % mod + ((B * 1 * (B + 1)) // 2) % mod     if (ans >= mod):         ans -= mod       # Count possible subsequence     # By C times "0" and A & B time "1"     ans += ((A + B) * 1 * C) % mod     if (ans >= mod):         ans -= mod       return ans   # Driver code if __name__ == "__main__":       A, B, C = 1, 2, 3     print(maxsubsequence(A, B, C))   # This code is contributed by rakeshsahni

## C#

 // C# Code for the above approach: using System; class GFG{     static int maxsubsequence(int A, int B, int C)   {       // As the answer may be very large,     // Find it modulo 109 + 7     long mod = (long)(1e9 + 7);       // Count possible subsequence by     // A times"1" and B times"10"     long ans = (long)(A * B) % mod       + ((B * (B + 1)) / 2) % mod;     if (ans >= mod) {       ans -= mod;     }       // Count possible subsequence     // By C times "0" and A & B time  "1"     ans += ((A + B) * C) % mod;     if (ans >= mod) {       ans -= mod;     }     return (int)ans;   }     // Driver code   static public void Main (){       int A = 1, B = 2, C = 3;     Console.Write(maxsubsequence(A, B, C));   } }   // This code is contributed by hrithikgarg03188.

## Javascript



Output

14

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

My Personal Notes arrow_drop_up