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:

## C++

`// 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;` `}` |

*chevron_right*

*filter_none*

## Java

`// 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` |

*chevron_right*

*filter_none*

## Python3

`# 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".` |

*chevron_right*

*filter_none*

## C#

`// 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` |

*chevron_right*

*filter_none*

## PHP

`<?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` `?>` |

*chevron_right*

*filter_none*

**Output**

MaxSum =106

**Time Complexity: **O(N)**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Maximize a number considering permutations with values smaller than limit
- Choice of Area
- Maximum sum after repeatedly dividing N by a divisor
- Largest number dividing maximum number of elements in the array
- Minimum value of X to make all array elements equal by either decreasing or increasing by X
- Maximum length subsequence with difference between adjacent elements as either 0 or 1
- Count number of digits after decimal on dividing a number
- Count of divisors having more set bits than quotient on dividing N
- Longest dividing subsequence
- Ways of dividing a group into two halves such that two elements are in different groups
- Minimum integer such that it leaves a remainder 1 on dividing with any element from the range [2, N]
- Minimize sum by dividing all elements of a subarray by K
- Smallest number dividing minimum number of elements in the array | Set 2
- Smallest number dividing minimum number of elements in the Array
- Puzzle | Dividing a Square into N smaller squares
- Print all Longest dividing subsequence in an Array
- Smallest number to make Array sum at most K by dividing each element
- Length of longest increasing index dividing subsequence
- Min operations to reduce N to 1 by multiplying by A or dividing by B
- Count subarrays such that remainder after dividing sum of elements by K gives count of elements

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.