Minimum Score Triangulation of Polygon - Practice Coding Problems

Minimum Score Triangulation of Polygon - Problem

Polygon Triangulation Optimization Challenge

Imagine you have a convex polygon with n vertices, where each vertex has a specific integer value. Your task is to triangulate this polygon (divide it into triangles) in the most optimal way possible.

🎯 The Goal: Find the triangulation that minimizes the total score, where each triangle's score equals the product of its three vertex values.

📐 Rules:
• You can only create triangles using the polygon's original vertices
• Every triangulation of an n-sided polygon creates exactly n-2 triangles
• The vertices are given in clockwise order in the input array

Example: For a quadrilateral with values [3,7,4,5], you can triangulate it in two ways:
• Diagonal 3-4: triangles (3,7,4) and (3,4,5) → score = 84 + 60 = 144
• Diagonal 7-5: triangles (3,7,5) and (7,4,5) → score = 105 + 140 = 245

Return the minimum possible total score.

Input & Output

example_1.py — Basic Quadrilateral

$ Input: [1,2,3]

› Output: 6

💡 Note: With only 3 vertices, we have exactly one triangle (1,2,3) with score 1×2×3 = 6

example_2.py — Simple Quadrilateral

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

› Output: 144

💡 Note: Two possible triangulations: diagonal 3-4 gives triangles (3,7,4) + (3,4,5) = 84+60=144. Diagonal 7-5 gives (3,7,5) + (7,4,5) = 105+140=245. Minimum is 144.

example_3.py — Pentagon

$ Input: [1,3,1,4,1,5]

› Output: 13

💡 Note: For this hexagon, the optimal triangulation creates 4 triangles with minimum total score of 13

Constraints

n == values.length
3 ≤ n ≤ 50
1 ≤ values[i] ≤ 100
The polygon is convex

Visualization

Tap to expand

Understanding the Visualization

Identify Polygon

Start with convex polygon with labeled vertex values

Choose Diagonal

Pick a diagonal to create first triangle

Recursive Division

Recursively triangulate remaining parts

Calculate Cost

Sum up products of triangle vertices

Key Takeaway

🎯 Key Insight: This is an interval DP problem where we build optimal solutions from smaller polygon segments

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

This is a classic dynamic programming problem. The optimal approach uses interval DP where we consider all possible ways to triangulate polygon segments. For each segment from vertex i to j, we try all possible intermediate vertices k to form triangles, leading to O(n³) time complexity. The key insight is that overlapping subproblems can be memoized to avoid recomputation.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Exhaustive Search	O(4^n)	O(n)	Try all possible triangulations recursively

Recursive Exhaustive Search — Algorithm Steps

For each pair of non-adjacent vertices, try making a triangle with them
Recursively solve the left and right subpolygons
Return the minimum cost among all possibilities
Base case: when we have only 3 vertices, return their product

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Root Triangle

Pick a triangle containing vertices 0 and n-1

Recursive Split

Recursively solve left and right subpolygons

Combine Results

Add triangle cost plus subproblem costs

Code -

solution.c — C

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

int solve(int* values, int i, int j) {
    if (j - i < 2) return 0;
    
    int minCost = INT_MAX;
    for (int k = i + 1; k < j; k++) {
        int cost = values[i] * values[k] * values[j] + solve(values, i, k) + solve(values, k, j);
        if (cost < minCost) {
            minCost = cost;
        }
    }
    
    return minCost;
}

int minScoreTriangulation(int* values, int n) {
    return solve(values, 0, n - 1);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int values[100];
    int n = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        values[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", minScoreTriangulation(values, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

Each recursive call branches into multiple subproblems, leading to exponential growth

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to number of vertices

⚡ Linearithmic Space

62.0K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Recursive Exhaustive Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler