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.

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.

You are given an array points, an integer angle, and your location, where location = [posx, posy] and points[i] = [xi, yi] both denote integral coordinates on the X-Y plane.

Initially, you are facing directly east from your position. You cannot move from your position, but you can rotate. In other words, posx and posy cannot be changed. Your field of view in degrees is represented by angle, determining how wide you can see from any given view direction. Let d be the amount in degrees that you rotate counterclockwise. Then, your field of view is the inclusive range of angles [d - angle/2, d + angle/2].

You can see some set of points if, for each point, the angle formed by the point, your position, and the immediate east direction from your position is in your field of view.

There can be multiple points at one coordinate. There may be points at your location, and you can always see these points regardless of your rotation. Points do not obstruct your vision to other points.

Return the maximum number of points you can see.

Example 1:

Input: points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]
Output: 3
Explanation: The shaded region represents your field of view. All points can be made visible in your field of view, including [3,3] even though [2,2] is in front and in the same line of sight.

Example 2:

Input: points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1]
Output: 4
Explanation: All points can be made visible in your field of view, including the one at your location.

Example 3:

Input: points = [[1,0],[2,1]], angle = 13, location = [1,1]
Output: 1
Explanation: You can only see one of the two points, as shown above.

Constraints:

• 1 <= points.length <= 105
• points[i].length == 2
• location.length == 2
• 0 <= angle < 360
• 0 <= posx, posy, xi, yi <= 109

Solution: Sliding window

Sort all the points by angle, duplicate the points with angle + 2*PI to deal with turn around case.

maintain a window [l, r] such that angle[r] – angle[l] <= fov

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

// Author: Huahua
class Solution {
public:
  int visiblePoints(vector<vector<int>>& points, int angle, vector<int>& o) {    
    int at_origin = 0;
    vector<double> ps;
    for (const auto& p : points)
      if (p[0] == o[0] && p[1] == o[1])
        ++at_origin;
      else
        ps.push_back(atan2(p[1] - o[1], p[0] - o[0]));
    sort(begin(ps), end(ps));
    const int n = ps.size();
    for (int i = 0; i < n; ++i)
      ps.push_back(ps[i] + 2.0 * M_PI); // duplicate the array +2PI
    int l = 0;
    int ans = 0;
    double fov = angle * M_PI / 180.0;
    for (int r = 0; r < ps.size(); ++r) {
      while (ps[r] - ps[l] > fov) ++l;
      ans = max(ans, r - l + 1);
    }
    return ans + at_origin;
  }
};

The post 花花酱 LeetCode 1610. Maximum Number of Visible Points 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.