leetcode 223. Rectangular area - 850. Rectangular area II - coordinate projection - segment coverage - effective interval calculation - pow index calculation

223. Rectangular area

Give you two rectangles composed of straight lines on the two-dimensional plane. Please calculate and return the total area covered by the two rectangles.

Each rectangle is represented by its lower left vertex and upper right vertex coordinates:

The first rectangle is defined by its lower left vertex (ax1, ay1) and upper right vertex (ax2, ay2).
The second rectangle is defined by its lower left vertex (bx1, by1) and upper right vertex (bx2, by2).

Input: ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2
Output: 45

Source: LeetCode
Link: https://leetcode-cn.com/problems/rectangle-area

Problem solution

Subtract the coverage area from the sum of the two rectangular areas

The coverage area is calculated through the coordinate interval of the coverage

class Solution:
    def computeArea(self, ax1: int, ay1: int, ax2: int, ay2: int, bx1: int, by1: int, bx2: int, by2: int) -> int:
        s = (ax1-ax2)*(ay1-ay2)+(bx1-bx2)*(by1-by2)
        if ax2<=bx1 or ax1>=bx2 or ay1>=by2 or ay2<=by1: return s

        xs = [ax1,ax2,bx1,bx2]
        ys = [ay1,ay2,by1,by2]

        return s-((xs[1]-xs[2])*(ys[1]-ys[2]))

850. Rectangular area II

We give a (axis aligned) list of rectangles. For rectangle[i] = [x1, y1, x2, y2], where (x1, y1) is the coordinate of the lower left corner of rectangle I and (x2, y2) is the coordinate of the upper right corner of the rectangle.

Find the total area covered by all rectangles in the plane. Since the answer may be too large, please return its modulus of 10 ^ 9 + 7.

Example 1:

Input: [[0,0,2,2], [1,0,2,3], [1,0,3,1]]
Output: 6
Explanation: as shown in the figure

Source: LeetCode
Link: https://leetcode-cn.com/problems/rectangle-area-ii


  • Take all the x's and arrange them in order, corresponding to the coordinate axis
  • Find the effective interval coverage of y-axis corresponding to each x, as shown in the debugging code below
    • We pack the ordinates Y1 and Y2 of a rectangle into a list and put them into the [x1,x2) interval
    • If the [x1,x2) interval has three coordinates x1, X3 and x4, use these three coordinates as keys to store the y interval they cover
    • Then x1:[y1,y2],x3:[y1,y2],x4:[y1,y2]
    • Calculate the interval covered by all rectangles
    • The key corresponding intervals are fused to find the sum of the effective interval length

Three coordinates are keys to store the y interval they cover

Problem solving - coordinate projection - line segment coverage - effective interval calculation

class Solution:
    def rectangleArea(self, rectangles) -> int:
        ans = 0
        Mapped rectangular x Coordinate to axis
        for x1, y1, x2, y2 in rectangles:
        xs = list(set(xs))
        look for x Corresponding y section
        cy = {}
        for x1, y1, x2, y2 in rectangles:
            for i in range(len(xs)-1):
                if i not in cy: cy[i] = []
                if x1<=xs[i]:
                    if x2>xs[i]:
        Find the effective interval length
        def mergeqj(xs):
            if len(xs) == 0:return 0
            ys = 0
            l,r = xs[0]
            for ll,rr in xs[1:]:
                if ll > r:
                    l = ll
                    r = rr
                    r = max(r,rr)
            ys += r-l
            return ys
        Find area
        for i in range(0,len(xs)-1):
            y = mergeqj(cy[i])
            ans += (xs[i+1]-xs[i])*y
        return int(ans%(10**9+7))

pow index calculation fails in a wide range

from math import pow
int(ans%(pow(10,9)+7)) and int(ans%(10**9+7)) get different answers, and the former answer is wrong

Expected results

In a small range, pow is efficient
On a large scale, pow is wrong

Tags: Python Algorithm leetcode

Posted on Fri, 19 Nov 2021 00:10:20 -0500 by nomad9