Two axis-aligned rectangles share positive area exactly when they overlap on the x-axis AND on the y-axis separately, so the whole thing collapses to four comparisons on the corner coordinates. A rectangle is a box; a box is the product of two intervals; two boxes intersect iff both interval pairs intersect. That factoring is the entire solution. My first instinct was to reason about corners — is `rec2`'s bottom-left inside `rec1`, or a corner of `rec1` inside `rec2`, and so on. That path is a minefield: one rectangle can straddle another without any corner sitting inside it (a tall thin box crossing a wide flat one), so corner-containment misses cases and you end up patching it forever. Projecting onto each axis sidesteps all of that. For each axis I want the two intervals to overlap with positive length. Interval `[a1, a2]` and `[b1, b2]` overlap with positive length iff `a1 < b2` and `b1 < a2`. Strict `<`, not `<=`: rectangles that merely touch along an edge or a point have zero overlap area and must return false. Do that on x with `rec1[0] < rec2[2] && rec2[0] < rec1[2]`, on y with `rec1[1] < rec2[3] && rec2[1] < rec1[3]`, and AND the two together. ### Worked example Take `rec1 = [0,0,2,2]` and `rec2 = [1,1,3,3]`. X-axis: `rec1[0]=0 < rec2[2]=3` true, and `rec2[0]=1 < rec1[2]=2` true, so the x-projections `[0,2]` and `[1,3]` overlap. Y-axis: `rec1[1]=0 < rec2[3]=3` true, and `rec2[1]=1 < rec1[3]=2` true. Both axes overlap, so the answer is true — the shared region is the unit square `[1,2] x [1,2]`. Now nudge `rec2` to `[2,2,4,4]`: x-check `rec2[0]=2 < rec1[2]=2` is false, they only kiss at the corner `(2,2)`, and the strict `<` correctly returns false. ### Complexity - Time O(1) — four integer comparisons, no loops. - Space O(1) — nothing allocated beyond the inputs. ### Code (C++) ```cpp class Solution { public: bool isRectangleOverlap(vector& rec1, vector& rec2) { // Two axis-aligned rectangles overlap with positive area iff their // projections onto BOTH the x-axis and the y-axis overlap with // positive length. rec = [x1, y1, x2, y2] (bottom-left, top-right). return rec1[0] < rec2[2] && rec2[0] < rec1[2] && rec1[1] < rec2[3] && rec2[1] < rec1[3]; } }; ``` ### One note The one thing to get right is the strictness of the comparison. Using `<=` anywhere would count edge-touching or corner-touching rectangles as overlapping, and the problem defines overlap as positive area — so `<` is load-bearing, not a stylistic choice. The transferable idea is the separating-axis shortcut for axis-aligned boxes: to test box intersection, test the 1-D interval intersection on each axis independently and AND the results. It scales straight to 3-D (six comparisons for two cuboids) and it's the fast broad-phase check behind a lot of collision detection.