Count sequences of given length having non-negative prefix sums that can be generated by given values

Given two integers M and X, the task is to find the number of sequences of length M that can be generated comprising X and -X such that their respective counts are equal and the prefix sum up to each index of the resulting sequence is non-negative.

Examples:

Input: M = 4, X = 5
Output: 2
Explanation:
There are only 2 possible sequences that have all possible prefix sums non-negative: 

1. {+5, +5, -5, -5}
2. {+5, -5, +5, -5}

Input: M = 6, X = 2
Output: 5
Explanation:
There are only 5 possible sequences that have all possible prefix sums non-negative:

1. {+2, +2, +2, -2, -2, -2}
2. {+2, +2, -2, -2, +2, -2}
3. {+2, -2, +2, -2, +2, -2}
4. {+2, +2, -2, +2, -2, -2}
5. {+2, -2, +2, +2, -2, -2}

Naive Approach: The simplest approach is to generate all possible arrangements of size M with the given integers +X and -X and find the prefix sum of each arrangement formed and count those sequences whose prefix sum array has only non-negative elements. Print the count of such sequence after the above steps. 

Time Complexity: O((M*(M!))/((M/2)!)²) 
Auxiliary Space: O(M)

Efficient Approach: The idea is to observe the pattern that for any sequence formed the number of positive X that has occurred at each index is always greater than or equal to the number of negative X that occurred. This is similar to the pattern of Catalan Numbers. In this case, check that at any point the number of positive X that occurred is always greater than or equal to the number of negative X that occurred which is the pattern of Catalan numbers. So the task is to find the Nth Catalan number where N = M/2.

K_{N} = \frac{\binom{2N}{N}}{N + 1}        

where, K_N is N^th the Catalan Number and \binom{2N}{N}    is the binomial coefficient. 
 

Below is the implementation of the above approach:

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the Binomial
// Coefficient C(n, r)
unsigned long int binCoff(unsigned int n,
                          unsigned int r)
{
    // Stores the value C(n, r)
    unsigned long int val = 1;
    int i;

    // Update C(n, r) = C(n, n - r)
    if (r > (n - r))
        r = (n - r);

    // Find C(n, r) iteratively
    for (i = 0; i < r; i++) {
        val *= (n - i);
        val /= (i + 1);
    }

    // Return the final value
    return val;
}

// Function to find number of sequence
// whose prefix sum at each index is
// always non-negative
void findWays(int M)
{
    // Find n
    int n = M / 2;

    unsigned long int a, b, ans;

    // Value of C(2n, n)
    a = binCoff(2 * n, n);

    // Catalan number
    b = a / (n + 1);

    // Print the answer
    cout << b;
}

// Driver Code
int main()
{
    // Given M and X
    int M = 4, X = 5;

    // Function Call
    findWays(M);

    return 0;
}

// Java program for the above approach
import java.io.*;

class GFG{

// Function to find the Binomial
// Coefficient C(n, r)
static long binCoff(long n, long r)
{
    
    // Stores the value C(n, r)
    long val = 1;
    int i;

    // Update C(n, r) = C(n, n - r)
    if (r > (n - r))
        r = (n - r);

    // Find C(n, r) iteratively
    for(i = 0; i < r; i++)
    {
        val *= (n - i);
        val /= (i + 1);
    }

    // Return the final value
    return val;
}

// Function to find number of sequence
// whose prefix sum at each index is
// always non-negative
static void findWays(int M)
{
    
    // Find n
    int n = M / 2;

    long a, b, ans;

    // Value of C(2n, n)
    a = binCoff(2 * n, n);

    // Catalan number
    b = a / (n + 1);

    // Print the answer
    System.out.print(b);
}

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

    // Given M and X
    int M = 4, X = 5;

    // Function Call
    findWays(M);
}
}

// This code is contributed by akhilsaini

# Python3 program for the above approach

# Function to find the Binomial
# Coefficient C(n, r)
def binCoff(n, r):

    # Stores the value C(n, r)
    val = 1

    # Update C(n, r) = C(n, n - r)
    if (r > (n - r)):
        r = (n - r)

    # Find C(n, r) iteratively
    for i in range(0, r):
        val *= (n - i)
        val //= (i + 1)

    # Return the final value
    return val

# Function to find number of sequence
# whose prefix sum at each index is
# always non-negative
def findWays(M):

    # Find n
    n = M // 2

    # Value of C(2n, n)
    a = binCoff(2 * n, n)

    # Catalan number
    b = a // (n + 1)

    # Print the answer
    print(b)

# Driver Code
if __name__ == '__main__':

    # Given M and X
    M = 4
    X = 5

    # Function Call
    findWays(M)

# This code is contributed by akhilsaini

// C# program for the above approach
using System;

class GFG{

// Function to find the Binomial
// Coefficient C(n, r)
static long binCoff(long n, long r)
{
    
    // Stores the value C(n, r)
    long val = 1;
    int i;

    // Update C(n, r) = C(n, n - r)
    if (r > (n - r))
        r = (n - r);

    // Find C(n, r) iteratively
    for(i = 0; i < r; i++)
    {
        val *= (n - i);
        val /= (i + 1);
    }

    // Return the final value
    return val;
}

// Function to find number of sequence
// whose prefix sum at each index is
// always non-negative
static void findWays(int M, int X)
{
    
    // Find n
    int n = M / 2;

    long a, b;

    // Value of C(2n, n)
    a = binCoff(2 * n, n);

    // Catalan number
    b = a / (n + 1);

    // Print the answer
    Console.WriteLine(b);
}

// Driver Code
public static void Main()
{
    
    // Given M and X
    int M = 4;
    int X = 5;

    // Function Call
    findWays(M, X);
}
}

// This code is contributed by akhilsaini

<script>
// Javascript program to implement
// the above approach

// Function to find the Binomial
// Coefficient C(n, r)
function binCoff(n, r)
{
      
    // Stores the value C(n, r)
    let val = 1;
    let i;
  
    // Update C(n, r) = C(n, n - r)
    if (r > (n - r))
        r = (n - r);
  
    // Find C(n, r) iteratively
    for(i = 0; i < r; i++)
    {
        val *= (n - i);
        val /= (i + 1);
    }
  
    // Return the final value
    return val;
}
  
// Function to find number of sequence
// whose prefix sum at each index is
// always non-negative
function findWays(M)
{
      
    // Find n
    let n = M / 2;
  
    let a, b, ans;
  
    // Value of C(2n, n)
    a = binCoff(2 * n, n);
  
    // Catalan number
    b = a / (n + 1);
  
    // Print the answer
    document.write(b);
}


    // Driver Code
     
    // Given M and X
    let M = 4, X = 5;
  
    // Function Call
    findWays(M);

     
</script>

2

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