Maximum sum of a path in a Right Number Triangle

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



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

Below is the implementation of above idea.

C++

// C++ program to print maximum sum
// in a right triangle of numbers
#include<bits/stdc++.h>
using namespace std;
  
// function to find maximum sum path
int maxSum(int tri[][3], 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 program
int main(){
      
    int tri[3][3] = {{1}, {2,1}, {3,3,2}};
  
    cout<<maxSum(tri, 3);
      
    return 0;
}

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

<?php
// PHP program to print maximum sum
// in a right triangle of numbers
  
// function to find maximum sum path
function 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 = 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 ($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][0];
      
    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
?>


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.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up


Improved By : jit_t

Article Tags :
Practice Tags :



Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.