Note:

• A lattice point is a point with integer coordinates.
• Points that lie on the circumference of a circle are also considered to be inside it.

Example 1:

Input: circles = [[2,2,1]]
Output: 5
Explanation:
The figure above shows the given circle.
The lattice points present inside the circle are (1, 2), (2, 1), (2, 2), (2, 3), and (3, 2) and are shown in green.
Other points such as (1, 1) and (1, 3), which are shown in red, are not considered inside the circle.
Hence, the number of lattice points present inside at least one circle is 5.

Example 2:

Input: circles = [[2,2,2],[3,4,1]]
Output: 16
Explanation:
The figure above shows the given circles.
There are exactly 16 lattice points which are present inside at least one circle. 
Some of them are (0, 2), (2, 0), (2, 4), (3, 2), and (4, 4).

Constraints:

• 1 <= circles.length <= 200
• circles[i].length == 3
• 1 <= xi, yi <= 100
• 1 <= ri <= min(xi, yi)

Solution: Brute Force

Time complexity: O(m * m * n) = O(200 * 200 * 200)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countLatticePoints(vector<vector<int>>& circles) {
    auto isIn = [](int u, int v, int x, int y, int r) {
      return (u - x) * (u - x) + (v - y) * (v - y) <= r * r;
    };    
    int ans = 0;
    for (int u = 0; u <= 200; ++u)
      for (int v = 0; v <= 200; ++v) {
        bool found = false;
        for (const auto& c : circles)
          if (isIn(u, v, c[0], c[1], c[2])) {
            found = true;
            break;
          }
        ans += found;
      }
    return ans;
  }
};

The post 花花酱 LeetCode 2249. Count Lattice Points Inside a Circle appeared first on Huahua's Tech Road.

Example 1:

Input: coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
Output: true

Example 2:

Input: coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]
Output: false

Constraints:

• 2 <= coordinates.length <= 1000
• coordinates[i].length == 2
• -10^4 <= coordinates[i][0], coordinates[i][1] <= 10^4
• coordinates contains no duplicate point.

Solution: Slope and Hashset

This is not a easy problem, a few corner cases:

• dx == 0
• dy == 0
• dx < 0

Basically we are counting (dx / gcd(dx, dy), dy / gcd(dx, dy)). We will have only ONE entry if all the points are on the same line.

Time complexity: O(n)
Space complexity: O(1) w/ early exit.

// Author: Huahua
class Solution {
public:
  bool checkStraightLine(vector<vector<int>>& coordinates) {
    set<pair<int, int>> s;
    for (int i = 1; i < coordinates.size(); ++i) {      
      int dx = coordinates[i][0] - coordinates[0][0];
      int dy = coordinates[i][1] - coordinates[0][1];      
      if (dy == 0)
        s.emplace(1, 0);
      else if (dx == 0)
        s.emplace(0, 1);
      else {
        if (dx < 0) dx *= -1, dy *= -1;
        const int d = gcd(dx, dy);
        s.emplace(dx / d, dy / d);
      }
      if (s.size() > 1) return false;
    }
    return true;
  }
};

The post 花花酱 LeetCode 1232. Check If It Is a Straight Line appeared first on Huahua's Tech Road.

Given an m x n integer grid, return the size (i.e., the side length k) of the largest magic square that can be found within this grid.

Example 1:

Input: grid = [[7,1,4,5,6],[2,5,1,6,4],[1,5,4,3,2],[1,2,7,3,4]]
Output: 3
Explanation: The largest magic square has a size of 3.
Every row sum, column sum, and diagonal sum of this magic square is equal to 12.
- Row sums: 5+1+6 = 5+4+3 = 2+7+3 = 12
- Column sums: 5+5+2 = 1+4+7 = 6+3+3 = 12
- Diagonal sums: 5+4+3 = 6+4+2 = 12

Example 2:

Input: grid = [[5,1,3,1],[9,3,3,1],[1,3,3,8]]
Output: 2

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 50
• 1 <= grid[i][j] <= 106

Solution: Brute Force w/ Prefix Sum

Compute the prefix sum for each row and each column.

And check all possible squares.

Time complexity: O(m*n*min(m,n)²)
Space complexity: O(m*n)

// Author: Huahua
class Solution {
public:
  int largestMagicSquare(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<int>> rows(m, vector<int>(n + 1));
    vector<vector<int>> cols(n, vector<int>(m + 1));
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        rows[i][j + 1] = rows[i][j] + grid[i][j];
        cols[j][i + 1] = cols[j][i] + grid[i][j];
      }
    for (int k = min(m, n); k >= 2; --k)
      for (int i = 0; i + k <= m; ++i)
        for (int j = 0; j + k <= n; ++j) {
          vector<int> s;
          for (int r = 0; r < k; ++r) 
            s.push_back(rows[i + r][j + k] - rows[i + r][j]);
          for (int c = 0; c < k; ++c)
            s.push_back(cols[j + c][i + k] - cols[j + c][i]);
          int d1 = 0;
          int d2 = 0;
          for (int d = 0; d < k; ++d) {
            d1 += grid[i + d][j + d];
            d2 += grid[i + d][j + k - d - 1];
          }
          s.push_back(d1);
          s.push_back(d2);          
          if (count(begin(s), end(s), s[0]) == s.size()) return k;
        }
    return 1;
  }
};

The post 花花酱 LeetCode 1895. Largest Magic Square appeared first on Huahua's Tech Road.

A rhombus sum is the sum of the elements that form the border of a regular rhombus shape in grid​​​. The rhombus must have the shape of a square rotated 45 degrees with each of the corners centered in a grid cell. Below is an image of four valid rhombus shapes with the corresponding colored cells that should be included in each rhombus sum:

Note that the rhombus can have an area of 0, which is depicted by the purple rhombus in the bottom right corner.

Return the biggest three distinct rhombus sums in the grid in descending order. If there are less than three distinct values, return all of them.

Example 1:

Input: grid = [[3,4,5,1,3],[3,3,4,2,3],[20,30,200,40,10],[1,5,5,4,1],[4,3,2,2,5]]
Output: [228,216,211]
Explanation: The rhombus shapes for the three biggest distinct rhombus sums are depicted above.
- Blue: 20 + 3 + 200 + 5 = 228
- Red: 200 + 2 + 10 + 4 = 216
- Green: 5 + 200 + 4 + 2 = 211

Example 2:

Input: grid = [[1,2,3],[4,5,6],[7,8,9]]
Output: [20,9,8]
Explanation: The rhombus shapes for the three biggest distinct rhombus sums are depicted above.
- Blue: 4 + 2 + 6 + 8 = 20
- Red: 9 (area 0 rhombus in the bottom right corner)
- Green: 8 (area 0 rhombus in the bottom middle)

Example 3:

Input: grid = [[7,7,7]]
Output: [7]
Explanation: All three possible rhombus sums are the same, so return [7].

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 50
• 1 <= grid[i][j] <= 105

Solution: Brute Force

Just find all Rhombus…

Time complexity: O(mn*min(n,m)²)
Space complexity: O(mn*min(n,m)²)

// Author: Huahua
class Solution {
public:
  vector<int> getBiggestThree(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    vector<int> ans;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        ans.push_back(grid[i][j]);
    for (int a = 2; a <= min(m, n); ++a)
      for (int cy = a - 1; cy + a <= m; ++cy)
        for (int cx = a - 1; cx + a <= n; ++cx) {
          int s = grid[cy][cx - a + 1]
                + grid[cy][cx + a - 1]
                + grid[cy + a - 1][cx]
                + grid[cy - a + 1][cx];
          for (int i = 1; i < a - 1; ++i)
            s += grid[cy - i][cx - a + i + 1] 
               + grid[cy - i][cx + a - i - 1]
               + grid[cy + i][cx - a + i + 1] 
               + grid[cy + i][cx + a - i - 1];
          ans.push_back(s);          
        }
    sort(rbegin(ans), rend(ans));
    vector<int> output;
    for (int x : ans) {
      if (output.empty() || output.back() != x)
        output.push_back(x);
      if (output.size() == 3) break;
    }
    return output;
  }
};

The post 花花酱 LeetCode 1878. Get Biggest Three Rhombus Sums in a Grid appeared first on Huahua's Tech Road.

You are also given an array queries where queries[j] = [xj, yj, rj] describes a circle centered at (xj, yj) with a radius of rj.

For each query queries[j], compute the number of points inside the jth circle. Points on the border of the circle are considered inside.

Return an array answer, where answer[j] is the answer to the jth query.

Example 1:

Input: points = [[1,3],[3,3],[5,3],[2,2]], queries = [[2,3,1],[4,3,1],[1,1,2]]
Output: [3,2,2]
Explanation: The points and circles are shown above.
queries[0] is the green circle, queries[1] is the red circle, and queries[2] is the blue circle.

Example 2:

Input: points = [[1,1],[2,2],[3,3],[4,4],[5,5]], queries = [[1,2,2],[2,2,2],[4,3,2],[4,3,3]]
Output: [2,3,2,4]
Explanation: The points and circles are shown above.
queries[0] is green, queries[1] is red, queries[2] is blue, and queries[3] is purple.

Constraints:

• 1 <= points.length <= 500
• points[i].length == 2
• 0 <= x​​​​​​i, y​​​​​​i <= 500
• 1 <= queries.length <= 500
• queries[j].length == 3
• 0 <= xj, yj <= 500
• 1 <= rj <= 500
• All coordinates are integers.

Solution: Brute Force

Time complexity: O(P * Q)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> countPoints(vector<vector<int>>& points, vector<vector<int>>& queries) {
    vector<int> ans;
    ans.reserve(queries.size());
    for (const auto& q : queries) {
      const int rs = q[2] * q[2];
      int cnt = 0;      
      for (const auto& p : points)
        if ((q[0] - p[0]) * (q[0] - p[0]) + 
            (q[1] - p[1]) * (q[1] - p[1]) <= rs)
          ++cnt;
      ans.push_back(cnt);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1828. Queries on Number of Points Inside a Circle appeared first on Huahua's Tech Road.

Return the index (0-indexed) of the valid point with the smallest Manhattan distance from your current location. If there are multiple, return the valid point with the smallest index. If there are no valid points, return -1.

The Manhattan distance between two points (x1, y1) and (x2, y2) is abs(x1 - x2) + abs(y1 - y2).

Example 1:

Input: x = 3, y = 4, points = [[1,2],[3,1],[2,4],[2,3],[4,4]]
Output: 2
Explanation: Of all the points, only [3,1], [2,4] and [4,4] are valid. Of the valid points, [2,4] and [4,4] have the smallest Manhattan distance from your current location, with a distance of 1. [2,4] has the smallest index, so return 2.

Example 2:

Input: x = 3, y = 4, points = [[3,4]]
Output: 0
Explanation: The answer is allowed to be on the same location as your current location.

Example 3:

Input: x = 3, y = 4, points = [[2,3]]
Output: -1
Explanation: There are no valid points.

Constraints:

• 1 <= points.length <= 104
• points[i].length == 2
• 1 <= x, y, ai, bi <= 104

Solution: Brute Force

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int nearestValidPoint(int x, int y, vector<vector<int>>& points) {
    int min_dist = INT_MAX;
    int ans = -1;
    for (int i = 0; i < points.size(); ++i) {
      const int dx = abs(points[i][0] - x);
      const int dy = abs(points[i][1] - y);      
      if (dx * dy == 0 && dx + dy < min_dist) {
        min_dist = dx + dy;
        ans = i;
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1779. Find Nearest Point That Has the Same X or Y Coordinate appeared first on Huahua's Tech Road.

• You can place the boxes anywhere on the floor.
• If box x is placed on top of the box y, then each side of the four vertical sides of the box y must either be adjacent to another box or to a wall.

Given an integer n, return the minimum possible number of boxes touching the floor.

Example 1:

Input: n = 3
Output: 3
Explanation: The figure above is for the placement of the three boxes.
These boxes are placed in the corner of the room, where the corner is on the left side.

Example 2:

Input: n = 4
Output: 3
Explanation: The figure above is for the placement of the four boxes.
These boxes are placed in the corner of the room, where the corner is on the left side.

Example 3:

Input: n = 10
Output: 6
Explanation: The figure above is for the placement of the ten boxes.
These boxes are placed in the corner of the room, where the corner is on the back side.

Constraints:

• 1 <= n <= 109

Solution: Geometry

Step 1: Build a largest pyramid that has less then n cubes, whose base area is d*(d+1) / 2
Step 2: Build a largest triangle with cubes left, whose base area is l, l*(l + 1) / 2 >= left

Time complexity: O(n^(1/3))
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minimumBoxes(int n) {
    int d = 0;
    int l = 0;
    while (n - (d + 1) * (d + 2) / 2 > 0) {
      n -= (d + 1) * (d + 2) / 2;
      ++d;
    }
    while (n > 0) n -= ++l;
    return d * (d + 1) / 2 + l;
  }
};

The post 花花酱 LeetCode 1739. Building Boxes appeared first on Huahua's Tech Road.

You can cut the ith rectangle to form a square with a side length of k if both k <= li and k <= wi. For example, if you have a rectangle [4,6], you can cut it to get a square with a side length of at most 4.

Let maxLen be the side length of the largest square you can obtain from any of the given rectangles.

Return the number of rectangles that can make a square with a side length of maxLen.

Example 1:

Input: rectangles = [[5,8],[3,9],[5,12],[16,5]]
Output: 3
Explanation: The largest squares you can get from each rectangle are of lengths [5,3,5,5].
The largest possible square is of length 5, and you can get it out of 3 rectangles.

Example 2:

Input: rectangles = [[2,3],[3,7],[4,3],[3,7]]
Output: 3

Constraints:

• 1 <= rectangles.length <= 1000
• rectangles[i].length == 2
• 1 <= li, wi <= 109
• li != wi

Solution: Running Max of Shortest Edge

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countGoodRectangles(vector<vector<int>>& rectangles) {
    int cur = 0;
    int ans = 0;
    for (const auto& r : rectangles) {
      if (min(r[0], r[1]) > cur) {
        cur = min(r[0], r[1]);
        ans = 0;
      }
      if (min(r[0], r[1]) == cur) ++ans;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1725. Number Of Rectangles That Can Form The Largest Square appeared first on Huahua's Tech Road.

Given an array positions where positions[i] = [xi, yi] is the position of the ith customer on the map, return the minimum sum of the euclidean distances to all customers.

In other words, you need to choose the position of the service centre [xcentre, ycentre] such that the following formula is minimized:

Answers within 10^-5 of the actual value will be accepted.

Example 1:

Input: positions = [[0,1],[1,0],[1,2],[2,1]]
Output: 4.00000
Explanation: As shown, you can see that choosing [xcentre, ycentre] = [1, 1] will make the distance to each customer = 1, the sum of all distances is 4 which is the minimum possible we can achieve.

Example 2:

Input: positions = [[1,1],[3,3]]
Output: 2.82843
Explanation: The minimum possible sum of distances = sqrt(2) + sqrt(2) = 2.82843

Example 3:

Input: positions = [[1,1]]
Output: 0.00000

Example 4:

Input: positions = [[1,1],[0,0],[2,0]]
Output: 2.73205
Explanation: At the first glance, you may think that locating the centre at [1, 0] will achieve the minimum sum, but locating it at [1, 0] will make the sum of distances = 3.
Try to locate the centre at [1.0, 0.5773502711] you will see that the sum of distances is 2.73205.
Be careful with the precision!

Example 5:

Input: positions = [[0,1],[3,2],[4,5],[7,6],[8,9],[11,1],[2,12]]
Output: 32.94036
Explanation: You can use [4.3460852395, 4.9813795505] as the position of the centre.

Constraints:

• 1 <= positions.length <= 50
• positions[i].length == 2
• 0 <= positions[i][0], positions[i][1] <= 100

Solution: Weiszfeld’s algorithm

Use Weiszfeld’s algorithm to compute geometric median of the samples.

Time complexity: O(f(epsilon) * O)
Space complexity: O(1)

template<typename T1, typename T2>
double dist(const vector<T1>& a, const vector<T2>& b) {
  return sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]));
};

class Solution {
public:
  double getMinDistSum(vector<vector<int>>& positions) {    
    constexpr double kDelta = 1e-7;
    constexpr double kEpsilon = 1e-15;
    vector<double> c{-1, -1};
    double ans = 0;
    while (true) {
      ans = 0;
      double nx = 0, ny = 0;
      double denominator = 0;
      for (const auto& p : positions) {
        double d = dist(c, p) + kEpsilon;
        ans += d;
        nx += p[0] / d;
        ny += p[1] / d;
        denominator += 1.0 / d;
      }
      vector<double> t{nx / denominator, ny / denominator};      
      if (dist(c, t) < kDelta) return ans;
      c = t;
    }
    return -1;
  }
};

The post 花花酱 LeetCode 1515. Best Position for a Service Centre appeared first on Huahua's Tech Road.

A vertical area is an area of fixed-width extending infinitely along the y-axis (i.e., infinite height). The widest vertical area is the one with the maximum width.

Note that points on the edge of a vertical area are not considered included in the area.

Example 1:

​

Input: points = [[8,7],[9,9],[7,4],[9,7]]
Output: 1
Explanation: Both the red and the blue area are optimal.

Example 2:

Input: points = [[3,1],[9,0],[1,0],[1,4],[5,3],[8,8]]
Output: 3

Constraints:

• n == points.length
• 2 <= n <= 105
• points[i].length == 2
• 0 <= xi, yi <= 109

Solution: Sort by x coordinates

Time complexity: O(nlogn)
Space complexity: O(n)

class Solution {
public:
  int maxWidthOfVerticalArea(vector<vector<int>>& points) {
    sort(begin(points), end(points), [](const auto& p1, const auto& p2) {
      return p1[0] != p2[0] ? p1[0] < p2[0] : p1[1] < p2[1];
    });
    int ans = 0;
    for (int i = 1; i < points.size(); ++i)
      ans = max(ans, points[i][0] - points[i - 1][0]);
    return ans;
  }
};

The post 花花酱 LeetCode 1637. Widest Vertical Area Between Two Points Containing No Points appeared first on Huahua's Tech Road.

The integer radius denotes the maximum distance in which the tower is reachable. The tower is reachable if the distance is less than or equal to radius. Outside that distance, the signal becomes garbled, and the tower is not reachable.

The signal quality of the ith tower at a coordinate (x, y) is calculated with the formula ⌊qi / (1 + d)⌋, where d is the distance between the tower and the coordinate. The network quality at a coordinate is the sum of the signal qualities from all the reachable towers.

Return the integral coordinate where the network quality is maximum. If there are multiple coordinates with the same network quality, return the lexicographically minimum coordinate.

Note:

• A coordinate (x1, y1) is lexicographically smaller than (x2, y2) if either x1 < x2 or x1 == x2 and y1 < y2.
• ⌊val⌋ is the greatest integer less than or equal to val (the floor function).

Example 1:

Input: towers = [[1,2,5],[2,1,7],[3,1,9]], radius = 2
Output: [2,1]
Explanation: 
At coordinate (2, 1) the total quality is 13
- Quality of 7 from (2, 1) results in ⌊7 / (1 + sqrt(0)⌋ = ⌊7⌋ = 7
- Quality of 5 from (1, 2) results in ⌊5 / (1 + sqrt(2)⌋ = ⌊2.07⌋ = 2
- Quality of 9 from (3, 1) results in ⌊9 / (1 + sqrt(1)⌋ = ⌊4.5⌋ = 4
No other coordinate has higher quality.

Example 2:

Input: towers = [[23,11,21]], radius = 9
Output: [23,11]

Example 3:

Input: towers = [[1,2,13],[2,1,7],[0,1,9]], radius = 2
Output: [1,2]

Example 4:

Input: towers = [[2,1,9],[0,1,9]], radius = 2
Output: [0,1]
Explanation: Both (0, 1) and (2, 1) are optimal in terms of quality but (0, 1) is lexicograpically minimal.

Constraints:

• 1 <= towers.length <= 50
• towers[i].length == 3
• 0 <= xi, yi, qi <= 50
• 1 <= radius <= 50

Solution: Brute Force

Try all possible coordinates from (0, 0) to (50, 50).

Time complexity: O(|X|*|Y|*t)
Space complexity: O(1)

class Solution {
public:
  vector<int> bestCoordinate(vector<vector<int>>& towers, int radius) {
    constexpr int n = 50;
    vector<int> ans;
    int max_q = 0;    
    for (int x = 0; x <= n; ++x)
      for (int y = 0; y <= n; ++y) {
        int q = 0;
        for (const auto& tower : towers) {
          const int tx = tower[0], ty = tower[1];
          const float d = sqrt((x - tx) * (x - tx) + (y - ty) * (y - ty));
          if (d > radius) continue;
          q += floor(tower[2] / (1 + d));
        }
        if (q > max_q) {
          max_q = q;
          ans = {x, y};
        }
      }    
    return ans;
  }
};

The post 花花酱 LeetCode 1620. Coordinate With Maximum Network Quality appeared first on Huahua's Tech Road.

1. updateSubrectangle(int row1, int col1, int row2, int col2, int newValue)

• Updates all values with newValue in the subrectangle whose upper left coordinate is (row1,col1) and bottom right coordinate is (row2,col2).

2. getValue(int row, int col)

• Returns the current value of the coordinate (row,col) from the rectangle.

Example 1:

Input
["SubrectangleQueries","getValue","updateSubrectangle","getValue","getValue","updateSubrectangle","getValue","getValue"]
[[[[1,2,1],[4,3,4],[3,2,1],[1,1,1]]],[0,2],[0,0,3,2,5],[0,2],[3,1],[3,0,3,2,10],[3,1],[0,2]]
Output

[null,1,null,5,5,null,10,5]

Explanation SubrectangleQueries subrectangleQueries = new SubrectangleQueries([[1,2,1],[4,3,4],[3,2,1],[1,1,1]]); // The initial rectangle (4×3) looks like: // 1 2 1 // 4 3 4 // 3 2 1 // 1 1 1 subrectangleQueries.getValue(0, 2); // return 1 subrectangleQueries.updateSubrectangle(0, 0, 3, 2, 5); // After this update the rectangle looks like: // 5 5 5 // 5 5 5 // 5 5 5 // 5 5 5 subrectangleQueries.getValue(0, 2); // return 5 subrectangleQueries.getValue(3, 1); // return 5 subrectangleQueries.updateSubrectangle(3, 0, 3, 2, 10); // After this update the rectangle looks like: // 5 5 5 // 5 5 5 // 5 5 5 // 10 10 10 subrectangleQueries.getValue(3, 1); // return 10 subrectangleQueries.getValue(0, 2); // return 5

Example 2:

Input
["SubrectangleQueries","getValue","updateSubrectangle","getValue","getValue","updateSubrectangle","getValue"]
[[[[1,1,1],[2,2,2],[3,3,3]]],[0,0],[0,0,2,2,100],[0,0],[2,2],[1,1,2,2,20],[2,2]]
Output

[null,1,null,100,100,null,20]

Explanation SubrectangleQueries subrectangleQueries = new SubrectangleQueries([[1,1,1],[2,2,2],[3,3,3]]); subrectangleQueries.getValue(0, 0); // return 1 subrectangleQueries.updateSubrectangle(0, 0, 2, 2, 100); subrectangleQueries.getValue(0, 0); // return 100 subrectangleQueries.getValue(2, 2); // return 100 subrectangleQueries.updateSubrectangle(1, 1, 2, 2, 20); subrectangleQueries.getValue(2, 2); // return 20

Constraints:

• There will be at most 500 operations considering both methods: updateSubrectangle and getValue.
• 1 <= rows, cols <= 100
• rows == rectangle.length
• cols == rectangle[i].length
• 0 <= row1 <= row2 < rows
• 0 <= col1 <= col2 < cols
• 1 <= newValue, rectangle[i][j] <= 10^9
• 0 <= row < rows
• 0 <= col < cols

Solution 1: Simulation

Update the matrix values.

Time complexity:
Update: O(m*n), where m*n is the area of the sub-rectangle.
Query: O(1)

Space complexity: O(rows*cols)

// Author: Huahua
class SubrectangleQueries {
public:
  SubrectangleQueries(vector<vector<int>>& rectangle): 
    m_(rectangle) {}

  void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
    for (int i = row1; i <= row2; ++i)
      for (int j = col1; j <= col2; ++j)
        m_[i][j] = newValue;
  }

  int getValue(int row, int col) {
    return m_[row][col];
  }
private:
  vector<vector<int>> m_;
};

Solution 2: Geometry

For each update remember the region and value.

For each query, find the newest updates that covers the query point. If not found, return the original value in the matrix.

Time complexity:
Update: O(1)
Query: O(|U|), where |U| is the number of updates so far.

Space complexity: O(|U|)

// Author: Huahua
class SubrectangleQueries {
public:
  SubrectangleQueries(vector<vector<int>>& rectangle): 
    m_(rectangle) {}

  void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
    updates_.push_front({row1, col1, row2, col2, newValue});
  }

  int getValue(int row, int col) {
    for (const auto& u : updates_)
      if (row >= u[0] && row <= u[2] && col >= u[1] && col <= u[3])
        return u[4];
    return m_[row][col];
  }
private:
  const vector<vector<int>>& m_;
  deque<vector<int>> updates_;  
};

The post 花花酱 LeetCode 1476. Subrectangle Queries appeared first on Huahua's Tech Road.

Return the maximum area of a piece of cake after you cut at each horizontal and vertical position provided in the arrays horizontalCuts and verticalCuts. Since the answer can be a huge number, return this modulo 10^9 + 7.

Example 1:

Input: h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3]
Output: 4 
Explanation: The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green piece of cake has the maximum area.

Example 2:

Input: h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1]
Output: 6
Explanation: The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green and yellow pieces of cake have the maximum area.

Example 3:

Input: h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3]
Output: 9

Constraints:

• 2 <= h, w <= 10^9
• 1 <= horizontalCuts.length < min(h, 10^5)
• 1 <= verticalCuts.length < min(w, 10^5)
• 1 <= horizontalCuts[i] < h
• 1 <= verticalCuts[i] < w
• It is guaranteed that all elements in horizontalCuts are distinct.
• It is guaranteed that all elements in verticalCuts are distinct.

Solution: Geometry

Find the max gap between vertical cuts mx and max gap between horizontal cuts my. ans = mx * my

Time complexity: O(nlogn)
Space complexity: O(1) if sort in place otherweise O(n)

// Author: Huahua
class Solution {
public:
  int maxArea(int h, int w, vector<int>& horizontalCuts, vector<int>& verticalCuts) {
    constexpr int kMod = 1e9 + 7;
    sort(begin(verticalCuts), end(verticalCuts));
    sort(begin(horizontalCuts), end(horizontalCuts));
    int mx = max(verticalCuts[0], w - verticalCuts.back());
    int my = max(horizontalCuts[0], h - horizontalCuts.back());
    for (int i = 1; i < verticalCuts.size(); ++i)
      mx = max(mx, verticalCuts[i] - verticalCuts[i - 1]);
    for (int i = 1; i < horizontalCuts.size(); ++i)
      my = max(my, horizontalCuts[i] - horizontalCuts[i - 1]);               
    return static_cast<long>(mx) * my % kMod;
  }
};

The post 花花酱 LeetCode 1465. Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts appeared first on Huahua's Tech Road.

Return the maximum number of points that are within or lie on any circular dartboard of radius r.

Example 1:

Input: points = [[-2,0],[2,0],[0,2],[0,-2]], r = 2
Output: 4
Explanation: Circle dartboard with center in (0,0) and radius = 2 contain all points.

Example 2:

Input: points = [[-3,0],[3,0],[2,6],[5,4],[0,9],[7,8]], r = 5
Output: 5
Explanation: Circle dartboard with center in (0,4) and radius = 5 contain all points except the point (7,8).

Example 3:

Input: points = [[-2,0],[2,0],[0,2],[0,-2]], r = 1
Output: 1

Example 4:

Input: points = [[1,2],[3,5],[1,-1],[2,3],[4,1],[1,3]], r = 2
Output: 4

Constraints:

• 1 <= points.length <= 100
• points[i].length == 2
• -10^4 <= points[i][0], points[i][1] <= 10^4
• 1 <= r <= 5000

Solution 1: Angular Sweep

See for more details: https://www.geeksforgeeks.org/angular-sweep-maximum-points-can-enclosed-circle-given-radius/

Time complexity: O(n^2*logn)
Space complexity: O(n^2)

// Author: Huahua
// Python-Like enumerate() In C++17
// http://reedbeta.com/blog/python-like-enumerate-in-cpp17/
template <typename T,
          typename TIter = decltype(std::begin(std::declval<T>())),
          typename = decltype(std::end(std::declval<T>()))>
constexpr auto enumerate(T && iterable) {
  struct iterator {
    size_t i;
    TIter iter;
    bool operator != (const iterator & other) const { return iter != other.iter; }
    void operator ++ () { ++i; ++iter; }
    auto operator * () const { return std::tie(i, *iter); }
  };
  struct iterable_wrapper {
    T iterable;
    auto begin() { return iterator{ 0, std::begin(iterable) }; }
    auto end() { return iterator{ 0, std::end(iterable) }; }
  };
  return iterable_wrapper{ std::forward<T>(iterable) };
}

class Solution {
public:
  int numPoints(vector<vector<int>>& points, int r) {
    const int n = points.size();
    vector<vector<double>> d(n, vector<double>(n));
    
    for (const auto& [i, pi] : enumerate(points))  
      for (const auto& [j, pj] : enumerate(points))
        d[i][j] = d[j][i] = sqrt((pi[0] - pj[0]) * (pi[0] - pj[0]) 
                               + (pi[1] - pj[1]) * (pi[1] - pj[1]));
        
    int ans = 1;
    for (const auto& [i, pi] : enumerate(points)) {    
      vector<pair<double, int>> angles; // {angle, event_type}
      for (const auto& [j, pj] : enumerate(points)) {
        if (i != j && d[i][j] <= 2 * r) {
          const double a = atan2(pj[1] - pi[1], pj[0] - pi[0]);
          const double b = acos(d[i][j] / (2 * r));
          angles.emplace_back(a - b, -1); // entering
          angles.emplace_back(a + b, 1); // exiting
        }
      }
      // If angles are the same, entering points go first.
      sort(begin(angles), end(angles));
      int pts = 1;
      for (const auto& [_, event] : angles)
        ans = max(ans, pts -= event);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1453. Maximum Number of Darts Inside of a Circular Dartboard appeared first on Huahua's Tech Road.

Return True if the circle and rectangle are overlapped otherwise return False.

In other words, check if there are any point (xi, yi) such that belongs to the circle and the rectangle at the same time.

Example 1:

Input: radius = 1, x_center = 0, y_center = 0, x1 = 1, y1 = -1, x2 = 3, y2 = 1
Output: true
Explanation: Circle and rectangle share the point (1,0) 

Example 2:

Input: radius = 1, x_center = 0, y_center = 0, x1 = -1, y1 = 0, x2 = 0, y2 = 1
Output: true

Example 3:

Input: radius = 1, x_center = 1, y_center = 1, x1 = -3, y1 = -3, x2 = 3, y2 = 3
Output: true

Example 4:

Input: radius = 1, x_center = 1, y_center = 1, x1 = 1, y1 = -3, x2 = 2, y2 = -1
Output: false

Constraints:

• 1 <= radius <= 2000
• -10^4 <= x_center, y_center, x1, y1, x2, y2 <= 10^4
• x1 < x2
• y1 < y2

Solution: Geometry

Find the shortest distance from the center to the rectangle, return dist <= radius.

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool checkOverlap(int radius, int x_center, int y_center, int x1, int y1, int x2, int y2) {
    int dx = x_center - max(x1, min(x2, x_center));
    int dy = y_center - max(y1, min(y2, y_center));
    return dx * dx + dy * dy <= radius * radius;
  }
};

The post 花花酱 LeetCode 1401. Circle and Rectangle Overlapping appeared first on Huahua's Tech Road.