Given a sorted array A of n integers. The task is to find the sum of the minimum of all possible subsequences of A.
Note: Considering there will be no overflow of numbers.
Examples:
Input: A = [1, 2, 4, 5]
Output: 29
Subsequences are [1], [2], [4], [5], [1, 2], [1, 4], [1, 5], [2, 4], [2, 5], [4, 5] [1, 2, 4], [1, 2, 5], [1, 4, 5], [2, 4, 5], [1, 2, 4, 5]
Minimums are 1, 2, 4, 5, 1, 1, 1, 2, 2, 4, 1, 1, 1, 2, 1.
Sum is 29
Input: A = [1, 2, 3]
Output: 11
Approach: The Naive approach is to generate all possible subsequences, find their minimum and add them to the result.
Efficient Approach: It is given that the array is sorted, so observe that the minimum element occurs 2n-1 times, the second minimum occurs 2n-2 times, and so on… Let’s take an example:
arr[] = {1, 2, 3}
Subsequences are {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}
Minimum of each subsequence: {1}, {2}, {3}, {1}, {1}, {2}, {1}.
where
1 occurs 4 times i.e. 2 n-1 where n = 3.
2 occurs 2 times i.e. 2n-2 where n = 3.
3 occurs 1 times i.e. 2n-3 where n = 3.
So, traverse the array and add current element i.e. arr[i]* pow(2, n-1-i) to the sum.
Below is the implementation of the above approach:
// C++ implementation of the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the sum // of minimum of all subsequence int findMinSum( int arr[], int n)
{ int occ = n - 1, sum = 0;
for ( int i = 0; i < n; i++) {
sum += arr[i] * pow (2, occ);
occ--;
}
return sum;
} // Driver code int main()
{ int arr[] = { 1, 2, 4, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << findMinSum(arr, n);
return 0;
} |
// Java implementation of the above approach class GfG
{ // Function to find the sum // of minimum of all subsequence static int findMinSum( int arr[], int n)
{ int occ = n - 1 , sum = 0 ;
for ( int i = 0 ; i < n; i++)
{
sum += arr[i] * ( int )Math.pow( 2 , occ);
occ--;
}
return sum;
} // Driver code public static void main(String[] args)
{ int arr[] = { 1 , 2 , 4 , 5 };
int n = arr.length;
System.out.println(findMinSum(arr, n));
} } // This code is contributed by Prerna Saini |
# Python3 implementation of the # above approach # Function to find the sum # of minimum of all subsequence def findMinSum(arr, n):
occ = n - 1
Sum = 0
for i in range (n):
Sum + = arr[i] * pow ( 2 , occ)
occ - = 1
return Sum
# Driver code arr = [ 1 , 2 , 4 , 5 ]
n = len (arr)
print (findMinSum(arr, n))
# This code is contributed # by mohit kumar |
// C# implementation of the above approach using System;
class GFG
{ // Function to find the sum // of minimum of all subsequence static int findMinSum( int []arr, int n)
{ int occ = n - 1, sum = 0;
for ( int i = 0; i < n; i++)
{
sum += arr[i] *( int ) Math.Pow(2, occ);
occ--;
}
return sum;
} // Driver code public static void Main(String []args)
{ int []arr = { 1, 2, 4, 5 };
int n = arr.Length;
Console.WriteLine( findMinSum(arr, n));
} } // This code is contributed by Arnab Kundu |
<?php // PHP implementation of the // above approach // Function to find the sum // of minimum of all subsequence function findMinSum( $arr , $n )
{ $occ1 = ( $n );
$occ = $occ1 - 1;
$Sum = 0;
for ( $i = 0; $i < $n ; $i ++)
{
$Sum += $arr [ $i ] * pow(2, $occ );
$occ -= 1;
}
return $Sum ;
} // Driver code $arr = array (1, 2, 4, 5);
$n = count ( $arr );
echo findMinSum( $arr , $n );
// This code is contributed // by Srathore ?> |
<script> // Javascript implementation of the above approach // Function to find the sum // of minimum of all subsequence function findMinSum(arr, n)
{ var occ = n - 1, sum = 0;
for ( var i = 0; i < n; i++) {
sum += arr[i] * Math.pow(2, occ);
occ--;
}
return sum;
} // Driver code var arr = [ 1, 2, 4, 5 ];
var n = arr.length;
document.write( findMinSum(arr, n)); </script> |
29
Time Complexity: O(nlogn)
Auxiliary Space: O(1)
Note: To find the Sum of maximum element of all subsequences in a sorted array, just traverse the array in reverse order and apply the same formula for Sum.