Given a number N and for any number K for a series formed as K, K + 1, K + 2, K + 3, K + 4, ......., K + N. The task is to find the number of unique sums that can be obtained by adding two or more integers from the series of N + 1 integers.
Examples:
Input: N = 3
Output: 10
Explanation:
The possible unique combinations are:
(K) + (K + 1) = 2*K + 1
(K) + (K + 2) = 2*K + 2
(K) + (K + 3) = 2*K + 3
(K + 1) + (K + 3) = 2*K + 4
(K + 2) + (K + 3) = 2*K + 5
(K) + (K + 1) + (K + 2) = 3*K + 3
(K) + (K + 1) + (K + 3) = 3*K + 4
(K) + (K + 2) + (K + 3) = 3*K + 5
(K + 1) + (K + 2) + (K + 3) = 3*K + 6
(K) + (K + 1) + (K + 2) + (K + 3) = 4*K + 6
So in total, there are 10 unique ways.
Input: N = 4
Output: 20
Explanation:
The possible unique combinations are 20 in number.
Approach: The following observations are to be made:
- Since K is number the only significance it has is that two subsets with different sizes cannot have the same sum.
- A unique sum can be obtained from the minimum possible sum of the subset to the maximum possible sum of subset having size as X where (2 ? X ? (N + 1)).
For Example:N = 4
The Series is = {K, K + 1, K + 2, K + 3, K + 4}
For K = 2, minimum_sum = (K, K + 1) = 2*K + 1
and maximum_sum = (K + 3, K + 4) = 2*K + 7
The maximum distinct sums possible with K = 2 are (maximum_sum – minimum_sum + 1) = (7 - 1 + 1) = 7.
Follow the steps below to solve the problem:
- Initialize two arrays array fsum[] and rsum[] each of size N + 1 to 0.
- For each element of both the arrays fsum[] and rsum[], update fsum[i] with ar[i] + fsum[i - 1] and rsum[i] with ar[i] + fsum[i + 1].
- Initialize a variable ans to 1 that stores the count of different possible sums of the given series.
- For each possible subset size X, where (2 ? X ? (N + 1)), add the value 1 + rsum[n + 1 - k] + fsum[k] to ans.
- The value of ans is the required answer hence return it.
Below is the implementation of the above approach:
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to count the unique sum
int count_unique_sum(int n)
{
int i, ar[n + 1], fsum[n + 1];
int rsum[n + 1], ans = 1;
// Initialize array fsum[] with 0
memset(fsum, 0, sizeof fsum);
// Initialize array rsum[] with 0
memset(rsum, 0, sizeof rsum);
for (i = 0; i <= n; i++) {
ar[i] = i;
}
// Set fsum[0] as ar[0]
fsum[0] = ar[0];
// Set rsum[0] as ar[n]
rsum[n] = ar[n];
// For each i update fsum[i] with
// ar[i] + fsum[i - 1]
for (i = 1; i <= n; i++) {
fsum[i] = ar[i] + fsum[i - 1];
}
// For each i from n-1, update
// rsum[i] with ar[i] + fsum[i + 1]
for (i = n - 1; i >= 0; i--) {
rsum[i] = ar[i] + rsum[i + 1];
}
// K represent size of subset as
// explained above
for (int k = 2; k <= n; k++) {
// Using above relation
ans += 1 + rsum[n + 1 - k]
- fsum[k - 1];
}
// Return the result
return ans;
}
// Driver Code
int main()
{
// Given a number N
int N = 4;
// Function Call
cout << count_unique_sum(N);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG{
// Function to count the unique sum
static int count_unique_sum(int n)
{
int i;
int ar[] = new int[n + 1];
int fsum[] = new int[n + 1];
int rsum[] = new int[n + 1];
int ans = 1;
// Initialize array fsum[] with 0
Arrays.fill(fsum, 0);
// Initialize array rsum[] with 0
Arrays.fill(rsum, 0);
for (i = 0; i <= n; i++)
{
ar[i] = i;
}
// Set fsum[0] as ar[0]
fsum[0] = ar[0];
// Set rsum[0] as ar[n]
rsum[n] = ar[n];
// For each i update fsum[i] with
// ar[i] + fsum[i - 1]
for (i = 1; i <= n; i++)
{
fsum[i] = ar[i] + fsum[i - 1];
}
// For each i from n-1, update
// rsum[i] with ar[i] + fsum[i + 1]
for (i = n - 1; i >= 0; i--)
{
rsum[i] = ar[i] + rsum[i + 1];
}
// K represent size of subset as
// explained above
for (int k = 2; k <= n; k++)
{
// Using above relation
ans += 1 + rsum[n + 1 - k] -
fsum[k - 1];
}
// Return the result
return ans;
}
// Driver Code
public static void main(String[] args)
{
// Given a number N
int N = 4;
// Function Call
System.out.print(count_unique_sum(N));
}
}
// This code is contributed by rock__cool
# Python3 program for the above approach
# Function to count the unique sum
def count_unique_sum(n):
ar = [0] * (n + 1)
fsum = [0] * (n + 1)
rsum = [0] * (n + 1)
ans = 1
for i in range(0, n + 1):
ar[i] = i
# Set fsum[0] as ar[0]
fsum[0] = ar[0]
# Set rsum[0] as ar[n]
rsum[n] = ar[n]
# For each i update fsum[i] with
# ar[i] + fsum[i - 1]
for i in range(1, n + 1):
fsum[i] = ar[i] + fsum[i - 1]
# For each i from n-1, update
# rsum[i] with ar[i] + fsum[i + 1]
for i in range(n - 1, -1, -1):
rsum[i] = ar[i] + rsum[i + 1]
# K represent size of subset as
# explained above
for k in range(2, n + 1):
# Using above relation
ans += (1 + rsum[n + 1 - k] -
fsum[k - 1])
# Return the result
return ans
# Driver Code
# Given a number N
N = 4
# Function call
print(count_unique_sum(N))
# This code is contributed by sanjoy_62
// C# program for the above approach
using System;
class GFG{
// Function to count the unique sum
static int count_unique_sum(int n)
{
int i;
int []ar = new int[n + 1];
int []fsum = new int[n + 1];
int []rsum = new int[n + 1];
int ans = 1;
for (i = 0; i <= n; i++)
{
ar[i] = i;
}
// Set fsum[0] as ar[0]
fsum[0] = ar[0];
// Set rsum[0] as ar[n]
rsum[n] = ar[n];
// For each i update fsum[i] with
// ar[i] + fsum[i - 1]
for (i = 1; i <= n; i++)
{
fsum[i] = ar[i] + fsum[i - 1];
}
// For each i from n-1, update
// rsum[i] with ar[i] + fsum[i + 1]
for (i = n - 1; i >= 0; i--)
{
rsum[i] = ar[i] + rsum[i + 1];
}
// K represent size of subset as
// explained above
for (int k = 2; k <= n; k++)
{
// Using above relation
ans += 1 + rsum[n + 1 - k] -
fsum[k - 1];
}
// Return the result
return ans;
}
// Driver Code
public static void Main(String[] args)
{
// Given a number N
int N = 4;
// Function Call
Console.Write(count_unique_sum(N));
}
}
// This code is contributed by PrinciRaj1992
<script>
// Javascript program for the above approach
// Function to count the unique sum
function count_unique_sum(n)
{
let i;
let ans = 1;
let ar = new Array(n + 1);
let fsum = new Array(n + 1);
let rsum = new Array(n + 1);
// Initialize array fsum[] with 0
fsum.fill(0);
// Initialize array rsum[] with 0
rsum.fill(0);
for (i = 0; i <= n; i++) {
ar[i] = i;
}
// Set fsum[0] as ar[0]
fsum[0] = ar[0];
// Set rsum[0] as ar[n]
rsum[n] = ar[n];
// For each i update fsum[i] with
// ar[i] + fsum[i - 1]
for (i = 1; i <= n; i++) {
fsum[i] = ar[i] + fsum[i - 1];
}
// For each i from n-1, update
// rsum[i] with ar[i] + fsum[i + 1]
for (i = n - 1; i >= 0; i--) {
rsum[i] = ar[i] + rsum[i + 1];
}
// K represent size of subset as
// explained above
for (let k = 2; k <= n; k++) {
// Using above relation
ans += 1 + rsum[n + 1 - k]
- fsum[k - 1];
}
// Return the result
return ans;
}
// Given a number N
let N = 4;
// Function Call
document.write(count_unique_sum(N));
//This code is contributed by suresh07.
</script>
Output
20
Time Complexity: O(N)
Auxiliary Space: O(N), since N extra space has been taken.
