We are given a number n, we need to find the maximum sum possible with the help of following function:
F(n) = max( (F(n/2) + F(n/3) + F(n/4) + F(n/5)), n). To calculate F(n, ) we may either have n as our result or we can further break n into four part as in given function definition. This can be done as much time as we can. Find the maximum possible sum you can get from a given N. Note : 1 can not be break further so F(1) = 1 as a base case.
Examples :
Input : n = 10 Output : MaxSum = 12 Explanation: f(10) = f(10/2) + f(10/3) + f(10/4) + f(10/5) = f(5) + f(3) + f(2) + f(2) = 12 5, 3 and 2 cannot be further divided. Input : n = 2 Output : MaxSum = 2
Approach : This problem can be solve with recursive approach but that will cost us a high complexity because of its overlapping sub problems. So we apply dynamic programming concept to solve this question in bottom up manner as:
// CPP program for maximize result when // we have choice to divide or consider // as it is. #include <bits/stdc++.h> using namespace std;
// function for calculating max possible result int maxDP( int n)
{ int res[n + 1];
res[0] = 0;
res[1] = 1;
// Compute remaining values in bottom
// up manner.
for ( int i = 2; i <= n; i++)
res[i] = max(i, (res[i / 2]
+ res[i / 3]
+ res[i / 4]
+ res[i / 5]));
return res[n];
} // Driver Code int main()
{ int n = 60;
cout << "MaxSum =" << maxDP(n);
return 0;
} |
// Java program for maximize result when // we have choice to divide or consider // as it is. import java.io.*;
class GFG {
// function for calculating max
// possible result
static int maxDP( int n)
{
int res[] = new int [n + 1 ];
res[ 0 ] = 0 ;
res[ 1 ] = 1 ;
// Compute remaining values in
// bottom up manner.
for ( int i = 2 ; i <= n; i++)
res[i]
= Math.max(i, (res[i / 2 ]
+ res[i / 3 ]
+ res[i / 4 ]
+ res[i / 5 ]));
return res[n];
}
// Driver Code
public static void main(String[] args)
{
int n = 60 ;
System.out.println( "MaxSum = " + maxDP(n));
}
} // This code is contributed by vt_m |
# Python3 code to maximize result when # we have choice to divide or consider # as it is. # function for calculating max # possible result def maxDP (n):
res = list ()
res.append( 0 )
res.append( 1 )
# Compute remaining values in
# bottom up manner.
i = 2
while i<n + 1 :
res.append( max (i, (res[ int (i / 2 )]
+ res[ int (i / 3 )] +
res[ int (i / 4 )]
+ res[ int (i / 5 )])))
i = i + 1
return res[n]
# driver code n = 60
print ( "MaxSum =" , maxDP(n))
# This code is contributed by "Sharad_Bhardwaj". |
// C# program for maximize result when // we have choice to divide or consider // as it is. using System;
class GFG {
// function for calculating max
// possible result
static int maxDP( int n)
{
int [] res = new int [n + 1];
res[0] = 0;
res[1] = 1;
// Compute remaining values in
// bottom up manner.
for ( int i = 2; i <= n; i++)
res[i] = Math.Max(i, (res[i / 2]
+ res[i / 3]
+ res[i / 4]
+ res[i / 5]));
return res[n];
}
// Driver code
public static void Main()
{
int n = 60;
Console.WriteLine( "MaxSum = " + maxDP(n));
}
} // This code is contributed by vt_m |
<?php // PHP program to maximize // result when we have choice // to divide or consider as it is. // function for calculating // max possible result function maxDP ( $n )
{ $res [0] = 0;
$res [1] = 1;
// Compute remaining values
// in bottom up manner.
for ( $i = 2; $i <= $n ; $i ++)
$res [ $i ] = max( $i , ( $res [ $i / 2] +
$res [ $i / 3] +
$res [ $i / 4] +
$res [ $i / 5]));
return $res [ $n ];
} // Driver Code $n = 60;
echo "MaxSum =" , maxDP ( $n );
// This code is contributed by aj_36 ?> |
<script> // javascript program for maximize result when // we have choice to divide or consider // as it is. // function for calculating max
// possible result
function maxDP(n)
{
let res = [];
res[0] = 0;
res[1] = 1;
// Compute remaining values in
// bottom up manner.
for (let i = 2; i <= n; i++){
res[i]
= Math.max(i, (res[(Math.floor(i / 2))]
+ res[(Math.floor(i / 3))]
+ res[(Math.floor(i / 4))]
+ res[(Math.floor(i / 5))]));
}
return res[n];
}
// Driver code let n = 60;
document.write( "MaxSum = " + maxDP(n));
</script> |
MaxSum =106
Time Complexity: O(N)
Auxiliary Space: O(N)