Maximum Area of Longest Diagonal Rectangle

Maximum Area of Longest Diagonal Rectangle - Problem

Array Easy

You're tasked with finding the largest area among rectangles that have the longest diagonal. Imagine you have a collection of rectangular frames, and you want to pick the one with the greatest diagonal length - but if multiple frames tie for the longest diagonal, you'll choose the one with the biggest area instead.

Given a 2D array dimensions where dimensions[i] = [length, width] represents the dimensions of rectangle i, your goal is to:

Calculate the diagonal length for each rectangle using the Pythagorean theorem: √(length² + width²)
Find all rectangles with the maximum diagonal length
Among those rectangles, return the area of the one with the largest area

Example: If you have rectangles [[9,3], [8,6]], the first has diagonal √(81+9) = √90 ≈ 9.49 and the second has diagonal √(64+36) = 10. Since 10 > 9.49, return the area of the second rectangle: 8 × 6 = 48.

Input & Output

example_1.py — Basic Case

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

› Output: 48

💡 Note: Rectangle [9,3] has diagonal √(81+9) = √90 ≈ 9.49 and area 27. Rectangle [8,6] has diagonal √(64+36) = 10 and area 48. Since 10 > 9.49, we return 48.

example_2.py — Tie in Diagonal

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

› Output: 12

💡 Note: All rectangles have diagonal √(9+16) = 5 and area 12. Since they all tie for longest diagonal, we return the maximum area among them, which is 12.

example_3.py — Single Rectangle

$ Input: dimensions = [[5,12]]

› Output: 60

💡 Note: Only one rectangle with diagonal √(25+144) = 13 and area 60. Return 60.

Constraints

1 ≤ dimensions.length ≤ 100
dimensions[i].length == 2
1 ≤ dimensions[i][0], dimensions[i][1] ≤ 100
No two rectangles have the same dimensions

Visualization

Tap to expand

Understanding the Visualization

Measure Each Frame

Use Pythagorean theorem to calculate diagonal: √(length² + width²)

Track the Champion

Keep track of the current longest diagonal and the largest area among frames with that diagonal

Update When Better Found

When you find a longer diagonal, that frame becomes the new champion. If diagonal ties, pick the one with bigger area

Return Final Champion

After checking all frames, return the area of the champion frame

Key Takeaway

🎯 Key Insight: We only need to track the current maximum diagonal and the maximum area among rectangles with that diagonal - no need to store all calculations!

Asked in

A Amazon 15 ⊞ Microsoft 8 G Google 6 Apple 4

The optimal solution uses a single pass through all rectangles, tracking the maximum diagonal length and maximum area among rectangles with that diagonal. When a longer diagonal is found, we reset the area tracking. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Two-Pass Solution)	O(n)	O(n)	Calculate all diagonals first, then find maximum area among longest diagonals
One-Pass Optimal Solution	O(n)	O(1)	Track maximum diagonal and corresponding maximum area in a single pass

Brute Force (Two-Pass Solution) — Algorithm Steps

Calculate diagonal length for each rectangle using √(length² + width²)
Find the maximum diagonal length among all rectangles
Iterate through rectangles again to find maximum area among those with maximum diagonal
Return the maximum area found

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Calculate Diagonals

Calculate diagonal for each rectangle and track maximum

Second Pass - Find Maximum Area

Among rectangles with maximum diagonal, find the one with largest area

Code -

solution.c — C

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

int areaOfMaxDiagonalRectangle(int** dimensions, int dimensionsSize) {
    // First pass: calculate all diagonals and find maximum
    double* diagonals = (double*)malloc(dimensionsSize * sizeof(double));
    double maxDiagonal = 0;
    
    for (int i = 0; i < dimensionsSize; i++) {
        double diagonal = sqrt(dimensions[i][0] * dimensions[i][0] + 
                              dimensions[i][1] * dimensions[i][1]);
        diagonals[i] = diagonal;
        if (diagonal > maxDiagonal) {
            maxDiagonal = diagonal;
        }
    }
    
    // Second pass: find maximum area among rectangles with max diagonal
    int maxArea = 0;
    for (int i = 0; i < dimensionsSize; i++) {
        if (fabs(diagonals[i] - maxDiagonal) < 1e-9) {
            int area = dimensions[i][0] * dimensions[i][1];
            if (area > maxArea) {
                maxArea = area;
            }
        }
    }
    
    free(diagonals);
    return maxArea;
}

int main() {
    // Input parsing and function call would be implemented here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through n rectangles: O(n) + O(n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

Need to store diagonal length for each rectangle

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~12 min Avg. Time

892 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 (Two-Pass Solution) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler