Triangle

Triangle - Problem

Given a triangle array, return the minimum path sum from top to bottom.

For each step, you may move to an adjacent number of the row below. More formally, if you are on index i on the current row, you may move to either index i or index i + 1 on the next row.

Input & Output

Example 1 — Basic Triangle

$ Input: triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]

› Output: 11

💡 Note: The minimum path is 2 → 3 → 5 → 1 with sum = 2 + 3 + 5 + 1 = 11

Example 2 — Small Triangle

$ Input: triangle = [[-10]]

› Output: -10

💡 Note: Single element triangle, minimum path sum is the element itself

Example 3 — Two Rows

$ Input: triangle = [[1],[2,3]]

› Output: 3

💡 Note: Two possible paths: 1→2 (sum=3) and 1→3 (sum=4). Minimum is 3

Constraints

1 ≤ triangle.length ≤ 200
triangle[0].length == 1
triangle[i].length == triangle[i - 1].length + 1
-10⁴ ≤ triangle[i][j] ≤ 10⁴

Visualization

Tap to expand

Asked in

a Amazon 15 🍎 Apple 8 M Microsoft 6 G Google 4

The key insight is that each position's minimum path sum depends only on the two adjacent positions below it. The optimal approach uses space-optimized dynamic programming by modifying the triangle in-place from bottom to top. Time: O(n²), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Memoization (Top-Down DP)	O(n²)	O(n²)	Cache recursive results to avoid recalculating same subproblems
Space-Optimized DP (In-Place)	O(n²)	O(1)	Optimize space by modifying triangle in-place or using 1D array
Brute Force Recursion	O(2ⁿ)	O(n)	Try every possible path from top to bottom using recursion
Bottom-Up Dynamic Programming	O(n²)	O(n²)	Build solution from bottom row upward using 2D DP table

Memoization (Top-Down DP) — Algorithm Steps

Create memo table to cache results
Start recursion from top with memoization
For each position, check memo first before calculating
Store result in memo before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Memo

Initialize cache table for storing results

Check Cache

Before calculating, check if result already exists

Store Result

Cache the calculated result for future use

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define MAX_SIZE 100
int memo[MAX_SIZE][MAX_SIZE];
int visited[MAX_SIZE][MAX_SIZE];

int dfs(int** triangle, int* triangleSizes, int numRows, int row, int col) {
    if (row == numRows) {
        return 0;
    }
    
    if (visited[row][col]) {
        return memo[row][col];
    }
    
    int left = dfs(triangle, triangleSizes, numRows, row + 1, col);
    int right = dfs(triangle, triangleSizes, numRows, row + 1, col + 1);
    
    memo[row][col] = triangle[row][col] + (left < right ? left : right);
    visited[row][col] = 1;
    return memo[row][col];
}

int solution(int** triangle, int* triangleSizes, int numRows) {
    memset(visited, 0, sizeof(visited));
    return dfs(triangle, triangleSizes, numRows, 0, 0);
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int** triangle = malloc(4 * sizeof(int*));
    int triangleSizes[] = {1, 2, 3, 4};
    
    triangle[0] = malloc(1 * sizeof(int));
    triangle[0][0] = 2;
    
    triangle[1] = malloc(2 * sizeof(int));
    triangle[1][0] = 3; triangle[1][1] = 4;
    
    triangle[2] = malloc(3 * sizeof(int));
    triangle[2][0] = 6; triangle[2][1] = 5; triangle[2][2] = 7;
    
    triangle[3] = malloc(4 * sizeof(int));
    triangle[3][0] = 4; triangle[3][1] = 1; triangle[3][2] = 8; triangle[3][3] = 3;
    
    int result = solution(triangle, triangleSizes, 4);
    printf("%d\n", result);
    
    for (int i = 0; i < 4; i++) {
        free(triangle[i]);
    }
    free(triangle);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each of the n²/2 positions calculated exactly once

⚠ Quadratic Growth

Space Complexity

O(n²)

Memo table stores result for each position plus recursion stack

⚠ Quadratic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Memoization (Top-Down DP) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler