Count of permutations such that sum of K numbers from given range is even - GeeksforGeeks

29 Jun, 2021
Given a range [low, high], both inclusive, and an integer K, the task is to select K numbers from the range(a number can be chosen multiple times) such that the sum of those K numbers is even. Print the number of all such permutations.
Examples:
Input: low = 4, high = 5, k = 3 Output: 4 Explanation: There are 4 valid permutation. They are {4, 4, 4}, {4, 5, 5}, {5, 4, 5} and {5, 5, 4} which sum up to an even number.
Input: low = 1, high = 10, k = 2 Output: 50 Explanation: There are 50 valid permutations. They are {1, 1}, {1, 3}, .. {1, 9} {2, 2}, {2, 4}, ..., {2, 10}, ..., {10, 2}, {10, 4}, ... {10, 10}. These 50 permutations, each sum up to an even number.
Naive Approach: The idea is to find all subset of size K such that the sum of the subset is even and also calculate permutation for each required subset. Time Complexity: O(K * (2K)) Auxiliary Space: O(K)
Efficient Approach: The idea is to use the fact that the sum of two even and odd numbers is always even. Follow the steps below to solve the problem:  
Find the total count of even and odd numbers in the given range [low, high].Initialize variable even_sum = 1 and odd_sum = 0 to store way to get even sum and odd sum respectively.Iterate a loop K times and store the previous even sum as prev_even = even_sum and the previous odd sum as prev_odd = odd_sum where even_sum = (prev_even*even_count) + (prev_odd*odd_count) and odd_sum = (prev_even*odd_count) + (prev_odd*even_count).Print the even_sum at the end as there is a count for the odd sum because the previous odd_sum will contribute to the next even_sum.
Find the total count of even and odd numbers in the given range [low, high].
Initialize variable even_sum = 1 and odd_sum = 0 to store way to get even sum and odd sum respectively.
Iterate a loop K times and store the previous even sum as prev_even = even_sum and the previous odd sum as prev_odd = odd_sum where even_sum = (prev_even*even_count) + (prev_odd*odd_count) and odd_sum = (prev_even*odd_count) + (prev_odd*even_count).
Print the even_sum at the end as there is a count for the odd sum because the previous odd_sum will contribute to the next even_sum.
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include<bits/stdc++.h>using namespace std; // Function to return the number// of all permutations such that// sum of K numbers in range is evenint countEvenSum(int low, int high, int k){         // Find total count of even and    // odd number in given range    int even_count = high / 2 - (low - 1) / 2;    int odd_count = (high + 1) / 2 - low / 2;     long even_sum = 1;    long odd_sum = 0;     // Iterate loop k times and update    // even_sum & odd_sum using    // previous values    for(int i = 0; i < k; i++)    {                 // Update the prev_even and        // odd_sum        long prev_even = even_sum;        long prev_odd = odd_sum;         // Even sum        even_sum = (prev_even * even_count) +                    (prev_odd * odd_count);         // Odd sum        odd_sum = (prev_even * odd_count) +                   (prev_odd * even_count);    }     // Return even_sum    cout << (even_sum);} // Driver Codeint main(){         // Given ranges    int low = 4;    int high = 5;     // Length of permutation    int K = 3;         // Function call    countEvenSum(low, high, K);} // This code is contributed by Stream_Cipher
// Java program for the above approachimport java.util.*; class GFG {     // Function to return the number    // of all permutations such that    // sum of K numbers in range is even    public static void    countEvenSum(int low, int high,                 int k)    {        // Find total count of even and        // odd number in given range        int even_count = high / 2 - (low - 1) / 2;        int odd_count = (high + 1) / 2 - low / 2;         long even_sum = 1;        long odd_sum = 0;         // Iterate loop k times and update        // even_sum & odd_sum using        // previous values        for (int i = 0; i < k; i++) {             // Update the prev_even and            // odd_sum            long prev_even = even_sum;            long prev_odd = odd_sum;             // Even sum            even_sum = (prev_even * even_count)                       + (prev_odd * odd_count);             // Odd sum            odd_sum = (prev_even * odd_count)                      + (prev_odd * even_count);        }         // Return even_sum        System.out.println(even_sum);    }     // Driver Code    public static void main(String[] args)    {        // Given ranges        int low = 4;        int high = 5;         // Length of permutation        int K = 3;         // Function call        countEvenSum(low, high, K);    }}
# Python3 program for the above approach # Function to return the number# of all permutations such that# sum of K numbers in range is evendef countEvenSum(low, high, k):     # Find total count of even and    # odd number in given range    even_count = high / 2 - (low - 1) / 2    odd_count = (high + 1) / 2 - low / 2     even_sum = 1    odd_sum = 0     # Iterate loop k times and update    # even_sum & odd_sum using    # previous values    for i in range(0, k):                 # Update the prev_even and        # odd_sum        prev_even = even_sum        prev_odd = odd_sum         # Even sum        even_sum = ((prev_even * even_count) +                     (prev_odd * odd_count))         # Odd sum        odd_sum = ((prev_even * odd_count) +                    (prev_odd * even_count))     # Return even_sum    print(int(even_sum)) # Driver Code # Given rangeslow = 4;high = 5; # Length of permutationK = 3; # Function callcountEvenSum(low, high, K); # This code is contributed by Stream_Cipher
// C# program for the above approachusing System; class GFG{ // Function to return the number// of all permutations such that// sum of K numbers in range is evenpublic static void countEvenSum(int low,                                int high, int k){         // Find total count of even and    // odd number in given range    int even_count = high / 2 - (low - 1) / 2;    int odd_count = (high + 1) / 2 - low / 2;     long even_sum = 1;    long odd_sum = 0;     // Iterate loop k times and update    // even_sum & odd_sum using    // previous values    for(int i = 0; i < k; i++)    {                 // Update the prev_even and        // odd_sum        long prev_even = even_sum;        long prev_odd = odd_sum;         // Even sum        even_sum = (prev_even * even_count) +                    (prev_odd * odd_count);         // Odd sum        odd_sum = (prev_even * odd_count) +                   (prev_odd * even_count);    }     // Return even_sum    Console.WriteLine(even_sum);} // Driver Codepublic static void Main(String[] args){         // Given ranges    int low = 4;    int high = 5;     // Length of permutation    int K = 3;     // Function call    countEvenSum(low, high, K);}} // This code is contributed by amal kumar choubey
<script> // JavaScript program for the above approach     // Function to return the number    // of all permutations such that    // sum of K numbers in range is even    function    countEvenSum(low, high, k)    {        // Find total count of even and        // odd number in given range        let even_count = high / 2 - (low - 1) / 2;        let odd_count = (high + 1) / 2 - low / 2;           let even_sum = 1;        let odd_sum = 0;           // Iterate loop k times and update        // even_sum & odd_sum using        // previous values        for (let i = 0; i < k; i++) {               // Update the prev_even and            // odd_sum            let prev_even = even_sum;            let prev_odd = odd_sum;               // Even sum            even_sum = (prev_even * even_count)                       + (prev_odd * odd_count);               // Odd sum            odd_sum = (prev_even * odd_count)                      + (prev_odd * even_count);        }           // Return even_sum        document.write(even_sum);    }  // Driver Code      // Given ranges        let low = 4;        let high = 5;           // Length of permutation        let K = 3;           // Function call        countEvenSum(low, high, K);      </script>
4
 
Time Complexity: O(K)Auxiliary Space: O(1)
Amal Kumar Choubey
Stream_Cipher
susmitakundugoaldanga
saurabh1990aror
Adobe
array-range-queries
permutation
Permutation and Combination
Arrays
Dynamic Programming
Greedy
Mathematical
Adobe
Arrays
Dynamic Programming
Greedy
Mathematical
permutation
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Introduction to Arrays
Multidimensional Arrays in Java
Linear Search
Linked List vs Array
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Longest Common Subsequence | DP-4
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16