Minimum Score Triangulation of Polygon

Minimum Score Triangulation of Polygon - Problem

You have a convex n-sided polygon where each vertex has an integer value. You are given an integer array values where values[i] is the value of the i-th vertex in clockwise order.

Polygon triangulation is a process where you divide a polygon into a set of triangles and the vertices of each triangle must also be vertices of the original polygon. Note that no other shapes other than triangles are allowed in the division. This process will result in n - 2 triangles.

For each triangle, the weight of that triangle is the product of the values at its vertices. The total score of the triangulation is the sum of these weights over all n - 2 triangles.

Return the minimum possible score that you can achieve with some triangulation of the polygon.

Input & Output

Example 1 — Basic Quadrilateral

$ Input: values = [1,2,3,4]

› Output: 18

💡 Note: We can triangulate as (0,1,2) and (0,2,3): cost = 1×2×3 + 1×3×4 = 6 + 12 = 18. Or as (0,1,3) and (1,2,3): cost = 1×2×4 + 2×3×4 = 8 + 24 = 32. The minimum is 18.

Example 2 — Triangle

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

› Output: 6

💡 Note: With only 3 vertices, there's only one triangle possible: (0,1,2) with cost 2×1×3 = 6.

Example 3 — Pentagon

$ Input: values = [3,7,4,5]

› Output: 144

💡 Note: For a quadrilateral with values [3,7,4,5], we can triangulate in different ways. One optimal way gives cost 144.

Constraints

n == values.length
3 ≤ n ≤ 50
1 ≤ values[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is that this is a classic interval dynamic programming problem. Any triangulation of an n-sided polygon creates exactly n-2 triangles. We need to find the triangulation that minimizes the sum of triangle weights. The optimal approach uses bottom-up DP with a 2D table where dp[i][j] represents the minimum cost to triangulate the polygon segment from vertex i to vertex j. Time: O(n³), Space: O(n²)

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n³) Space: O(n²)

Use a 2D DP table where dp[i][j] represents the minimum cost to triangulate the polygon from vertex i to vertex j. Fill the table bottom-up by considering all possible intermediate vertices.

Recursion with Memoization

⏱️ Time: O(n³) Space: O(n²)

Same recursive approach but store results of subproblems in a memoization table. When the same subproblem is encountered again, return the cached result instead of recalculating.

Recursive Brute Force

⏱️ Time: O(4ⁿ) Space: O(n)

For each possible triangle that can be formed with two adjacent vertices, recursively solve the remaining polygon parts. This explores all possible triangulations but recalculates the same subproblems multiple times.

Bottom-Up Dynamic Programming — Algorithm Steps

Create 2D DP table for all subpolygons
Fill table for increasing subproblem sizes
For each range, try all possible intermediate vertices
Return result for the entire polygon

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create DP table for all polygon segments

Fill Table

Process increasing segment lengths

Result

Final answer is in dp[0][n-1]

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int* values, int n) {
    if (n < 3) return 0;
    
    // dp[i][j] = minimum cost to triangulate polygon from i to j
    int dp[50][50];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dp[i][j] = 0;
        }
    }
    
    // Fill DP table for increasing lengths
    for (int length = 3; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            dp[i][j] = INT_MAX;
            
            // Try all possible intermediate vertices k
            for (int k = i + 1; k < j; k++) {
                int cost = values[i] * values[k] * values[j];
                cost += dp[i][k] + dp[k][j];
                dp[i][j] = min(dp[i][j], cost);
            }
        }
    }
    
    return dp[0][n - 1];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int values[50];
    int n = 0;
    char* ptr = line + 1;
    while (*ptr != ']') {
        values[n++] = atoi(ptr);
        while (*ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    int result = solution(values, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: outer two for range endpoints, inner for intermediate vertex

✓ Linear Growth

Space Complexity

O(n²)

2D DP table stores results for all possible polygon segments

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler