# Maximum sum of a path in a Right Number Triangle

• Difficulty Level : Easy
• Last Updated : 23 Apr, 2021

Given a right triangle of numbers, find the largest of the sum of numbers that appear on the paths starting from the top towards the base, so that on each path the next number is located directly below or below-and-one-place-to-the-right.
Examples :

```Input : 1
1 2
4 1 2
2 3 1 1
Output : 9
Explanation : 1 + 1 + 4 + 3

Input : 2
4 1
1 2 7
Output : 10
Explanation : 2 + 1 + 7```

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

The idea is to find the largest sum ending at every cell of the last row and return a maximum of these sums. We can recursively compute these sums by recursively considering the above two cells. Since there are overlapping subproblems, we use dynamic programming to find the maximum sum ending at a particular cell of the last row.
Below is the implementation of the above idea.

## C++

 `// C++ program to print maximum sum``// in a right triangle of numbers``#include``using` `namespace` `std;` `// function to find maximum sum path``int` `maxSum(``int` `tri[], ``int` `n)``{``    ``// Adding the element of row 1 to both the``    ``// elements of row 2 to reduce a step from``    ``// the loop``    ``if` `(n > 1)``        ``tri = tri + tri;``        ``tri = tri + tri;` `    ``// Traverse remaining rows``    ``for``(``int` `i = 2; i < n; i++) {``        ``tri[i] = tri[i] + tri[i-1];``        ``tri[i][i] = tri[i][i] + tri[i-1][i-1];` `        ``//Loop to traverse columns``        ``for` `(``int` `j = 1; j < i; j++){` `            ``// Checking the two conditions,``            ``// directly below and below right.``            ``// Considering the greater one``            ` `            ``// tri[i] would store the possible``            ``// combinations of sum of the paths``            ``if` `(tri[i][j] + tri[i-1][j-1] >=``                            ``tri[i][j] + tri[i-1][j])``                ` `                ``tri[i][j] = tri[i][j] + tri[i-1][j-1];``            ``else``                ``tri[i][j] = tri[i][j]+tri[i-1][j];``        ``}``    ``}``    ` `    ``// array at n-1 index (tri[i]) stores``    ``// all possible adding combination, finding``    ``// the maximum one out of them``    ``int` `max=tri[n-1];``    ` `    ``for``(``int` `i=1;i

## Java

 `// Java program to print maximum sum``// in a right triangle of numbers``class` `GFG``{``    ` `    ``// function to find maximum sum path``    ``static` `int` `maxSum(``int` `tri[][], ``int` `n)``    ``{``        ` `        ``// Adding the element of row 1 to both the``        ``// elements of row 2 to reduce a step from``        ``// the loop``        ``if` `(n > ``1``)``            ``tri[``1``][``1``] = tri[``1``][``1``] + tri[``0``][``0``];``            ``tri[``1``][``0``] = tri[``1``][``0``] + tri[``0``][``0``];``    ` `        ``// Traverse remaining rows``        ``for``(``int` `i = ``2``; i < n; i++) {``            ``tri[i][``0``] = tri[i][``0``] + tri[i-``1``][``0``];``            ``tri[i][i] = tri[i][i] + tri[i-``1``][i-``1``];``    ` `            ``//Loop to traverse columns``            ``for` `(``int` `j = ``1``; j < i; j++){``    ` `                ``// Checking the two conditions,``                ``// directly below and below right.``                ``// Considering the greater one``                ` `                ``// tri[i] would store the possible``                ``// combinations of sum of the paths``                ``if` `(tri[i][j] + tri[i-``1``][j-``1``] >=``                           ``tri[i][j] + tri[i-``1``][j])``                    ` `                    ``tri[i][j] = tri[i][j]``                                  ``+ tri[i-``1``][j-``1``];``                    ` `                ``else``                    ``tri[i][j] = tri[i][j]``                                    ``+ tri[i-``1``][j];``            ``}``        ``}``        ` `        ``// array at n-1 index (tri[i]) stores``        ``// all possible adding combination,``        ``// finding the maximum one out of them``        ``int` `max = tri[n-``1``][``0``];``        ` `        ``for``(``int` `i = ``1``; i < n; i++)``        ``{``            ``if``(max < tri[n-``1``][i])``                ``max = tri[n-``1``][i];``        ``}``        ` `        ``return` `max;``    ``}``        ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `tri[][] = {{``1``}, {``2``,``1``}, {``3``,``3``,``2``}};``        ` `        ``System.out.println(maxSum(tri, ``3``));``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python

 `# Python program to print maximum sum``# in a right triangle of numbers.` `# tri[][] is a 2D array that stores the``# triangle, n is number of lines or rows.``def` `maxSum(tri, n):` `    ``# Adding the element of row 1 to both the``    ``# elements of row 2 to reduce a step from``    ``# the loop``    ``if` `n > ``1``:``        ``tri[``1``][``1``] ``=` `tri[``1``][``1``]``+``tri[``0``][``0``]``        ``tri[``1``][``0``] ``=` `tri[``1``][``0``]``+``tri[``0``][``0``]` `    ``# Traverse remaining rows``    ``for` `i ``in` `range``(``2``, n):``        ``tri[i][``0``] ``=` `tri[i][``0``] ``+` `tri[i``-``1``][``0``]``        ``tri[i][i] ``=` `tri[i][i] ``+` `tri[i``-``1``][i``-``1``]` `        ``# Loop to traverse columns``        ``for` `j ``in` `range``(``1``, i):` `            ``# Checking the two conditions, directly below``            ``# and below right. Considering the greater one` `            ``# tri[i] would store the possible combinations``            ``# of sum of the paths``            ``if` `tri[i][j]``+``tri[i``-``1``][j``-``1``] >``=` `tri[i][j]``+``tri[i``-``1``][j]:``                ``tri[i][j] ``=` `tri[i][j] ``+` `tri[i``-``1``][j``-``1``]``            ``else``:``                ``tri[i][j] ``=` `tri[i][j]``+``tri[i``-``1``][j]` `    ``# array at n-1 index (tri[i]) stores all possible``    ``# adding combination, finding the maximum one``    ``# out of them``    ``print` `max``(tri[n``-``1``])` `# driver program``tri ``=` `[[``1``], [``2``,``1``], [``3``,``3``,``2``]]``maxSum(tri, ``3``)`

## C#

 `// C# program to print``// maximum sum in a right``// triangle of numbers``using` `System;` `class` `GFG``{``    ` `    ``// function to find``    ``// maximum sum path``    ``static` `int` `maxSum(``int` `[,]tri,``                      ``int` `n)``    ``{``        ` `        ``// Adding the element of row 1``        ``// to both the elements of row 2``        ``// to reduce a step from the loop``        ``if` `(n > 1)``            ``tri[1, 1] = tri[1, 1] +``                        ``tri[0, 0];``            ``tri[1, 0] = tri[1, 0] +``                        ``tri[0, 0];``    ` `        ``// Traverse remaining rows``        ``for``(``int` `i = 2; i < n; i++)``        ``{``            ``tri[i, 0] = tri[i, 0] +``                        ``tri[i - 1, 0];``            ``tri[i, i] = tri[i, i] +``                        ``tri[i - 1, i - 1];``     ` `            ``//Loop to traverse columns``            ``for` `(``int` `j = 1; j < i; j++)``            ``{``    ` `                ``// Checking the two conditions,``                ``// directly below and below right.``                ``// Considering the greater one``                ` `                ``// tri[i] would store the possible``                ``// combinations of sum of the paths``                ``if` `(tri[i, j] + tri[i - 1, j - 1] >=``                    ``tri[i, j] + tri[i - 1, j])``                ` `                    ``tri[i, j] = tri[i, j] +``                                ``tri[i - 1, j - 1];``                    ` `                ``else``                    ``tri[i, j] = tri[i, j] +``                                ``tri[i - 1, j];``            ``}``        ``}``        ` `        ``// array at n-1 index (tri[i])``        ``// stores all possible adding``        ``// combination, finding the``        ``// maximum one out of them``        ``int` `max = tri[n - 1, 0];``        ` `        ``for``(``int` `i = 1; i < n; i++)``        ``{``            ``if``(max < tri[n - 1, i])``                ``max = tri[n - 1, i];``        ``}``        ` `        ``return` `max;``    ``}``        ` `// Driver Code``public` `static` `void` `Main ()``{``    ` `        ``int` `[,]tri = {{1,0,0},``                      ``{2,1,0},``                      ``{3,3,2}};``        ` `        ``Console.Write(maxSum(tri, 3));``}``}` `// This code is contributed by ajit.`

## PHP

 ` 1)``        ``\$tri`` = ``\$tri`` + ``\$tri``;``        ``\$tri`` = ``\$tri`` + ``\$tri``;` `    ``// Traverse remaining rows``    ``for``(``\$i` `= 2; ``\$i` `< ``\$n``; ``\$i``++)``    ``{``        ``\$tri``[``\$i``] = ``\$tri``[``\$i``] +``                      ``\$tri``[``\$i` `- 1];``        ``\$tri``[``\$i``][``\$i``] = ``\$tri``[``\$i``][``\$i``] +``                       ``\$tri``[``\$i` `- 1][``\$i` `- 1];` `        ``//Loop to traverse columns``        ``for` `(``\$j` `= 1; ``\$j` `< ``\$i``; ``\$j``++)``        ``{` `            ``// Checking the two conditions,``            ``// directly below and below right.``            ``// Considering the greater one``            ` `            ``// tri[i] would store the possible``            ``// combinations of sum of the paths``            ``if` `(``\$tri``[``\$i``][``\$j``] + ``\$tri``[``\$i` `- 1][``\$j` `- 1] >=``                 ``\$tri``[``\$i``][``\$j``] + ``\$tri``[``\$i` `- 1][``\$j``])``                ` `                ``\$tri``[``\$i``][``\$j``] = ``\$tri``[``\$i``][``\$j``] +``                               ``\$tri``[``\$i` `- 1][``\$j` `- 1];``            ``else``                ``\$tri``[``\$i``][``\$j``] = ``\$tri``[``\$i``][``\$j``] +``                               ``\$tri``[``\$i` `- 1][``\$j``];``        ``}``    ``}``    ` `    ``// array at n-1 index (tri[i])``    ``// stores all possible adding``    ``// combination, finding the``    ``// maximum one out of them``    ` `    ``\$max` `= ``\$tri``[``\$n` `- 1];``    ` `    ``for``(``\$i` `= 1; ``\$i` `< ``\$n``; ``\$i``++)``    ``{``        ``if``(``\$max` `< ``\$tri``[``\$n` `- 1][``\$i``])``            ``\$max` `= ``\$tri``[``\$n` `- 1][``\$i``];``    ``}``    ` `    ``return` `\$max``;``}` `// Driver Code``\$tri` `= ``array``(``array``(1),``             ``array``(2,1),``             ``array``(3,3,2));` `echo` `maxSum(``\$tri``, 3);` `// This code is contributed by ajit``?>`

## Javascript

 ``

Output :

`6`

This article is contributed by Harshit Agrawal. 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.