Find Polygon With the Largest Perimeter

Find Polygon With the Largest Perimeter - Problem

You are given an array of positive integers nums of length n.

A polygon is a closed plane figure that has at least 3 sides. The longest side of a polygon is smaller than the sum of its other sides.

Conversely, if you have k (k ≥ 3) positive real numbers a₁, a₂, a₃, ..., aₖ where a₁ ≤ a₂ ≤ a₃ ≤ ... ≤ aₖ and a₁ + a₂ + a₃ + ... + aₖ₋₁ > aₖ, then there always exists a polygon with k sides whose lengths are a₁, a₂, a₃, ..., aₖ.

The perimeter of a polygon is the sum of lengths of its sides.

Return the largest possible perimeter of a polygon whose sides can be formed from nums, or -1 if it is not possible to create a polygon.

Input & Output

Example 1 — Basic Valid Polygon

$ Input: nums = [5,5,5,2,10,15]

› Output: 42

💡 Note: After sorting: [2,5,5,5,10,15]. All elements form a valid polygon because 15 < 2+5+5+5+10 = 27. Total perimeter = 42.

Example 2 — No Valid Polygon

$ Input: nums = [1,12,1,2,5,50,3]

› Output: -1

💡 Note: After sorting: [1,1,2,3,5,12,50]. No subset can form a valid polygon because any combination with 50 fails (50 ≥ sum of others), and without 50, 12 ≥ sum of remaining elements.

Example 3 — Minimum Size Triangle

$ Input: nums = [3,3,5]

› Output: 11

💡 Note: After sorting: [3,3,5]. Forms valid triangle since 5 < 3+3 = 6. Perimeter = 3+3+5 = 11.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 18 f Facebook 12 M Microsoft 8

The key insight is that for a valid polygon, the longest side must be smaller than the sum of all other sides. The optimal approach sorts the array and uses prefix sums to efficiently check polygon validity in O(1) time per combination. Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Try All Subsets

⏱️ Time: O(2ⁿ × n log n) Space: O(n)

For each subset of size 3 or more, sort the elements and check if the largest element is less than the sum of all others. Track the maximum valid perimeter found.

Optimal: Sort + Prefix Sum

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

Sort the array, compute prefix sums for efficient range sum queries, then iterate from the largest possible combination downward. For each combination, use prefix sums to quickly check if the polygon condition is satisfied.

Sort and Check Greedily

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

Sort the array in ascending order, then starting from the largest elements, try to form the largest valid polygon by checking if the largest side is smaller than the sum of all others.

Brute Force - Try All Subsets — Algorithm Steps

Generate all subsets of size ≥ 3
For each subset, sort elements
Check if max < sum of others
Track maximum valid perimeter

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all combinations of 3+ elements

Check Validity

For each subset, verify polygon condition

Track Maximum

Keep the largest valid perimeter found

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

long long solution(int* nums, int n) {
    qsort(nums, n, sizeof(int), compare);
    
    // Try greedily from the full array down
    for (int k = n; k >= 3; k--) {
        // Take the k largest elements (last k elements in sorted array)
        long long largest = nums[n - 1];
        long long sumOthers = 0;
        for (int i = n - k; i < n - 1; i++) {
            sumOthers += nums[i];
        }
        
        if (largest < sumOthers) {
            return largest + sumOthers;
        }
    }
    
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char *ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char *token = strtok(ptr, ",]");
        while (token && n < 1000) {
            nums[n++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    long long result = solution(nums, n);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n log n)

2^n subsets, each requiring O(n log n) sorting

⚡ Linearithmic

Space Complexity

O(n)

Space for storing current subset and sorting

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

485 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

Brute Force - Try All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler