Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Move from brute-force thinking to an efficient approach using array strategy.
There exist n rectangles in a 2D plane with edges parallel to the x and y axis. You are given two 2D integer arrays bottomLeft and topRight where bottomLeft[i] = [a_i, b_i] and topRight[i] = [c_i, d_i] represent the bottom-left and top-right coordinates of the ith rectangle, respectively.
You need to find the maximum area of a square that can fit inside the intersecting region of at least two rectangles. Return 0 if such a square does not exist.
Example 1:
Input: bottomLeft = [[1,1],[2,2],[3,1]], topRight = [[3,3],[4,4],[6,6]]
Output: 1
Explanation:
A square with side length 1 can fit inside either the intersecting region of rectangles 0 and 1 or the intersecting region of rectangles 1 and 2. Hence the maximum area is 1. It can be shown that a square with a greater side length can not fit inside any intersecting region of two rectangles.
Example 2:
Input: bottomLeft = [[1,1],[1,3],[1,5]], topRight = [[5,5],[5,7],[5,9]]
Output: 4
Explanation:
A square with side length 2 can fit inside either the intersecting region of rectangles 0 and 1 or the intersecting region of rectangles 1 and 2. Hence the maximum area is 2 * 2 = 4. It can be shown that a square with a greater side length can not fit inside any intersecting region of two rectangles.
Example 3:
Input: bottomLeft = [[1,1],[2,2],[1,2]], topRight = [[3,3],[4,4],[3,4]]
Output: 1
Explanation:
A square with side length 1 can fit inside the intersecting region of any two rectangles. Also, no larger square can, so the maximum area is 1. Note that the region can be formed by the intersection of more than 2 rectangles.
Example 4:
Input: bottomLeft = [[1,1],[3,3],[3,1]], topRight = [[2,2],[4,4],[4,2]]
Output: 0
Explanation:
No pair of rectangles intersect, hence, the answer is 0.
Constraints:
n == bottomLeft.length == topRight.length2 <= n <= 103bottomLeft[i].length == topRight[i].length == 21 <= bottomLeft[i][0], bottomLeft[i][1] <= 1071 <= topRight[i][0], topRight[i][1] <= 107bottomLeft[i][0] < topRight[i][0]bottomLeft[i][1] < topRight[i][1]Problem summary: There exist n rectangles in a 2D plane with edges parallel to the x and y axis. You are given two 2D integer arrays bottomLeft and topRight where bottomLeft[i] = [a_i, b_i] and topRight[i] = [c_i, d_i] represent the bottom-left and top-right coordinates of the ith rectangle, respectively. You need to find the maximum area of a square that can fit inside the intersecting region of at least two rectangles. Return 0 if such a square does not exist.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array · Math
[[1,1],[2,2],[3,1]] [[3,3],[4,4],[6,6]]
[[1,1],[1,3],[1,5]] [[5,5],[5,7],[5,9]]
[[1,1],[2,2],[1,2]] [[3,3],[4,4],[3,4]]
rectangle-area)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #3047: Find the Largest Area of Square Inside Two Rectangles
class Solution {
public long largestSquareArea(int[][] bottomLeft, int[][] topRight) {
long ans = 0;
for (int i = 0; i < bottomLeft.length; ++i) {
int x1 = bottomLeft[i][0], y1 = bottomLeft[i][1];
int x2 = topRight[i][0], y2 = topRight[i][1];
for (int j = i + 1; j < bottomLeft.length; ++j) {
int x3 = bottomLeft[j][0], y3 = bottomLeft[j][1];
int x4 = topRight[j][0], y4 = topRight[j][1];
int w = Math.min(x2, x4) - Math.max(x1, x3);
int h = Math.min(y2, y4) - Math.max(y1, y3);
int e = Math.min(w, h);
if (e > 0) {
ans = Math.max(ans, 1L * e * e);
}
}
}
return ans;
}
}
// Accepted solution for LeetCode #3047: Find the Largest Area of Square Inside Two Rectangles
func largestSquareArea(bottomLeft [][]int, topRight [][]int) (ans int64) {
for i, b1 := range bottomLeft {
t1 := topRight[i]
x1, y1 := b1[0], b1[1]
x2, y2 := t1[0], t1[1]
for j := i + 1; j < len(bottomLeft); j++ {
x3, y3 := bottomLeft[j][0], bottomLeft[j][1]
x4, y4 := topRight[j][0], topRight[j][1]
w := min(x2, x4) - max(x1, x3)
h := min(y2, y4) - max(y1, y3)
e := min(w, h)
if e > 0 {
ans = max(ans, int64(e)*int64(e))
}
}
}
return
}
# Accepted solution for LeetCode #3047: Find the Largest Area of Square Inside Two Rectangles
class Solution:
def largestSquareArea(
self, bottomLeft: List[List[int]], topRight: List[List[int]]
) -> int:
ans = 0
for ((x1, y1), (x2, y2)), ((x3, y3), (x4, y4)) in combinations(
zip(bottomLeft, topRight), 2
):
w = min(x2, x4) - max(x1, x3)
h = min(y2, y4) - max(y1, y3)
e = min(w, h)
if e > 0:
ans = max(ans, e * e)
return ans
// Accepted solution for LeetCode #3047: Find the Largest Area of Square Inside Two Rectangles
impl Solution {
pub fn largest_square_area(bottom_left: Vec<Vec<i32>>, top_right: Vec<Vec<i32>>) -> i64 {
let mut ans: i64 = 0;
let n = bottom_left.len();
for i in 0..n {
let x1 = bottom_left[i][0];
let y1 = bottom_left[i][1];
let x2 = top_right[i][0];
let y2 = top_right[i][1];
for j in (i + 1)..n {
let x3 = bottom_left[j][0];
let y3 = bottom_left[j][1];
let x4 = top_right[j][0];
let y4 = top_right[j][1];
let w = (x2.min(x4) - x1.max(x3)) as i64;
let h = (y2.min(y4) - y1.max(y3)) as i64;
let e = w.min(h);
if e > 0 {
ans = ans.max(e * e);
}
}
}
ans
}
}
// Accepted solution for LeetCode #3047: Find the Largest Area of Square Inside Two Rectangles
function largestSquareArea(bottomLeft: number[][], topRight: number[][]): number {
let ans = 0;
for (let i = 0; i < bottomLeft.length; ++i) {
const [x1, y1] = bottomLeft[i];
const [x2, y2] = topRight[i];
for (let j = i + 1; j < bottomLeft.length; ++j) {
const [x3, y3] = bottomLeft[j];
const [x4, y4] = topRight[j];
const w = Math.min(x2, x4) - Math.max(x1, x3);
const h = Math.min(y2, y4) - Math.max(y1, y3);
const e = Math.min(w, h);
if (e > 0) {
ans = Math.max(ans, e * e);
}
}
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair or subarray. The outer loop fixes a starting point, the inner loop extends or searches. For n elements this gives up to n²/2 operations. No extra space, but the quadratic time is prohibitive for large inputs.
Most array problems have an O(n²) brute force (nested loops) and an O(n) optimal (single pass with clever state tracking). The key is identifying what information to maintain as you scan: a running max, a prefix sum, a hash map of seen values, or two pointers.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Wrong move: Temporary multiplications exceed integer bounds.
Usually fails on: Large inputs wrap around unexpectedly.
Fix: Use wider types, modular arithmetic, or rearranged operations.