Ways to form an array having integers in given range such that total sum is divisible by 2

Given three positive integers N, L and R. The task is to find the number of ways to form an array of size N where each element lies in the range [L, R] such that the total sum of all the elements of the array is divisible by 2.

Examples:

Input: N = 2, L = 1, R = 3
Output: 5
Possible arrays having sum of all elements divisible by 2 are
[1, 1], [2, 2], [1, 3], [3, 1] and [3, 3]

Input: N = 3, L = 2, R = 2
Output: 1



Approach: The idea is to find the count of numbers having remainder 0 and 1 modulo 2 separately lying between L and R. This count can be calculated as follows:

We need to count numbers between range having remainder 1 modulo 2
F = First number in range of required type
L = Last number in range of required type
Count = (L – F) / 2
cnt0, and cnt1 represents Count of numbers between range of each type.

Then, using dynamic programming we can solve this problem. Let dp[i][j] denotes the number of ways where the sum of first i numbers modulo 2 is equal to j. Suppose we need to calculate dp[i][0], then it will have the following recurrence relation: dp[i][0] = (cnt0 * dp[i – 1][0] + cnt1 * dp[i – 1][1]). First term represents the number of ways upto (i – 1) having sum remainder as 0, so we can place cnt0 numbers in ith position such that sum remainder still remains 0. Second term represents the number of ways upto (i – 1) having sum remainder as 1, so we can place cnt1 numbers in ith position to such that sum remainder becomes 0. Similarly, we can calculate for dp[i][1].
Final answer will be denoted by dp[N][0].

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the number of ways to
// form an array of size n such that sum of
// all elements is divisible by 2
int countWays(int n, int l, int r)
{
    int tL = l, tR = r;
  
    // Represents first and last numbers
    // of each type (modulo 0 and 1)
    int L[2] = { 0 }, R[2] = { 0 };
    L[l % 2] = l, R[r % 2] = r;
  
    l++, r--;
  
    if (l <= tR && r >= tL)
        L[l % 2] = l, R[r % 2] = r;
  
    // Count of numbers of each type between range
    int cnt0 = 0, cnt1 = 0;
    if (R[0] && L[0])
        cnt0 = (R[0] - L[0]) / 2 + 1;
    if (R[1] && L[1])
        cnt1 = (R[1] - L[1]) / 2 + 1;
  
    int dp[n][2];
  
    // Base Cases
    dp[1][0] = cnt0;
    dp[1][1] = cnt1;
    for (int i = 2; i <= n; i++) {
  
        // Ways to form array whose sum upto
        // i numbers modulo 2 is 0
        dp[i][0] = (cnt0 * dp[i - 1][0]
                    + cnt1 * dp[i - 1][1]);
  
        // Ways to form array whose sum upto
        // i numbers modulo 2 is 1
        dp[i][1] = (cnt0 * dp[i - 1][1]
                    + cnt1 * dp[i - 1][0]);
    }
  
    // Return the required count of ways
    return dp[n][0];
}
  
// Driver Code
int main()
{
    int n = 2, l = 1, r = 3;
    cout << countWays(n, l, r);
  
    return 0;
}

chevron_right


Python3

# Python3 implementation of the approach

# Function to return the number of ways to
# form an array of size n such that sum of
# all elements is divisible by 2
def countWays(n, l, r):

tL, tR = l, r

# Represents first and last numbers
# of each type (modulo 0 and 1)
L = [0 for i in range(2)]
R = [0 for i in range(2)]

L[l % 2] = l
R[r % 2] = r

l += 1
r -= 1

if (l <= tR and r >= tL):
L[l % 2], R[r % 2] = l, r

# Count of numbers of each type
# between range
cnt0, cnt1 = 0, 0
if (R[0] and L[0]):
cnt0 = (R[0] – L[0]) // 2 + 1
if (R[1] and L[1]):
cnt1 = (R[1] – L[1]) // 2 + 1

dp = [[0 for i in range(2)]
for i in range(n + 1)]

# Base Cases
dp[1][0] = cnt0
dp[1][1] = cnt1
for i in range(2, n + 1):

# Ways to form array whose sum
# upto i numbers modulo 2 is 0
dp[i][0] = (cnt0 * dp[i – 1][0] +
cnt1 * dp[i – 1][1])

# Ways to form array whose sum upto
# i numbers modulo 2 is 1
dp[i][1] = (cnt0 * dp[i – 1][1] +
cnt1 * dp[i – 1][0])

# Return the required count of ways
return dp[n][0]

# Driver Code
n, l, r = 2, 1, 3
print(countWays(n, l, r))

# This code is contributed
# by Mohit Kumar

Output:

5


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : mohit kumar 29