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