Maximum Area of Longest Diagonal Rectangle

Maximum Area of Longest Diagonal Rectangle - Problem

Array Easy

You are given a 2D 0-indexed integer array dimensions. For all indices i, 0 <= i < dimensions.length, dimensions[i][0] represents the length and dimensions[i][1] represents the width of the rectangle i.

Return the area of the rectangle having the longest diagonal. If there are multiple rectangles with the longest diagonal, return the area of the rectangle having the maximum area.

Input & Output

Example 1 — Basic Case

$ Input: dimensions = [[9,5],[4,6]]

› Output: 45

💡 Note: Rectangle 1: diagonal = √(9² + 5²) = √106 ≈ 10.3, area = 45. Rectangle 2: diagonal = √(4² + 6²) = √52 ≈ 7.2, area = 24. Rectangle 1 has the longest diagonal, so return its area 45.

Example 2 — Tie in Diagonal

$ Input: dimensions = [[3,4],[4,3],[5,0]]

› Output: 12

💡 Note: Rectangle 1: diagonal = √(3² + 4²) = 5, area = 12. Rectangle 2: diagonal = √(4² + 3²) = 5, area = 12. Rectangle 3: diagonal = √(5² + 0²) = 5, area = 0. All have same diagonal (5), so return maximum area which is 12.

Example 3 — Single Rectangle

$ Input: dimensions = [[6,8]]

› Output: 48

💡 Note: Only one rectangle with diagonal = √(6² + 8²) = 10 and area = 48. Return 48.

Constraints

1 ≤ dimensions.length ≤ 100
dimensions[i].length == 2
1 ≤ dimensions[i][0], dimensions[i][1] ≤ 100

Visualization

Tap to expand

Asked in

M Microsoft 15 🍎 Apple 12

The key insight is to use the Pythagorean theorem to calculate each rectangle's diagonal, then prioritize by longest diagonal first, maximum area second. Best approach is the single pass optimization which tracks the best rectangle as we iterate. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Comparison	O(n²)	O(1)	Calculate diagonal and area for each rectangle, compare all pairs to find the best one
Single Pass Optimization	O(n)	O(1)	Calculate diagonal and area in one pass, tracking the best rectangle as we go

Brute Force Comparison — Algorithm Steps

Calculate diagonal and area for each rectangle
Compare all rectangles to find the best one
Return the area of the rectangle with longest diagonal (or max area if tied)

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate

Find diagonal and area for each rectangle

Compare

Check all rectangles to find longest diagonal

Result

Return area of best rectangle

Code -

solution.c — C

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

int solution(int dimensions[][2], int n) {
    double maxDiagonal = -1;
    int maxArea = -1;
    
    // Calculate diagonal and area for each rectangle
    double rectangles[n][2];
    for (int i = 0; i < n; i++) {
        int length = dimensions[i][0];
        int width = dimensions[i][1];
        double diagonal = sqrt(length * length + width * width);
        int area = length * width;
        rectangles[i][0] = diagonal;
        rectangles[i][1] = (double)area;
    }
    
    // Find the best rectangle by comparing all
    for (int i = 0; i < n; i++) {
        double diagonal = rectangles[i][0];
        int area = (int)rectangles[i][1];
        int isBetter = 0;
        
        if (diagonal > maxDiagonal) {
            isBetter = 1;
        } else if (fabs(diagonal - maxDiagonal) < 1e-9 && area > maxArea) {
            isBetter = 1;
        }
        
        if (isBetter) {
            maxDiagonal = diagonal;
            maxArea = area;
        }
    }
    
    return maxArea;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[a,b],[c,d],...] format
    int dimensions[100][2];
    int count = 0;
    char *ptr = line + 1; // Skip first [
    
    while (*ptr && count < 100) {
        if (*ptr == '[') {
            ptr++;
            dimensions[count][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            dimensions[count][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            count++;
        }
        ptr++;
    }
    
    int result = solution(dimensions, count);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Calculate diagonal for each rectangle O(n), then compare all pairs O(n²)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for tracking best rectangle

✓ Linear Space

12.0K Views

Medium Frequency

~8 min Avg. Time

450 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 Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler