返回介绍

solution / 1600-1699 / 1620.Coordinate With Maximum Network Quality / README_EN

发布于 2024-06-17 01:03:16 字数 6251 浏览 0 评论 0 收藏 0

1620. Coordinate With Maximum Network Quality

中文文档

Description

You are given an array of network towers towers, where towers[i] = [xi, yi, qi] denotes the ith network tower with location (xi, yi) and quality factor qi. All the coordinates are integral coordinates on the X-Y plane, and the distance between the two coordinates is the Euclidean distance.

You are also given an integer radius where a 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 array _[cx, cy]_ representing the integral coordinate _(cx, cy)_ where the network quality is maximum. If there are multiple coordinates with the same network quality, return the lexicographically minimum non-negative 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 a higher network quality.

Example 2:

Input: towers = [[23,11,21]], radius = 9
Output: [23,11]
Explanation: Since there is only one tower, the network quality is highest right at the tower's location.

Example 3:

Input: towers = [[1,2,13],[2,1,7],[0,1,9]], radius = 2
Output: [1,2]
Explanation: Coordinate (1, 2) has the highest network quality.

 

Constraints:

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

Solutions

Solution 1

class Solution:
  def bestCoordinate(self, towers: List[List[int]], radius: int) -> List[int]:
    mx = 0
    ans = [0, 0]
    for i in range(51):
      for j in range(51):
        t = 0
        for x, y, q in towers:
          d = ((x - i) ** 2 + (y - j) ** 2) ** 0.5
          if d <= radius:
            t += floor(q / (1 + d))
        if t > mx:
          mx = t
          ans = [i, j]
    return ans
class Solution {
  public int[] bestCoordinate(int[][] towers, int radius) {
    int mx = 0;
    int[] ans = new int[] {0, 0};
    for (int i = 0; i < 51; ++i) {
      for (int j = 0; j < 51; ++j) {
        int t = 0;
        for (var e : towers) {
          double d = Math.sqrt((i - e[0]) * (i - e[0]) + (j - e[1]) * (j - e[1]));
          if (d <= radius) {
            t += Math.floor(e[2] / (1 + d));
          }
        }
        if (mx < t) {
          mx = t;
          ans = new int[] {i, j};
        }
      }
    }
    return ans;
  }
}
class Solution {
public:
  vector<int> bestCoordinate(vector<vector<int>>& towers, int radius) {
    int mx = 0;
    vector<int> ans = {0, 0};
    for (int i = 0; i < 51; ++i) {
      for (int j = 0; j < 51; ++j) {
        int t = 0;
        for (auto& e : towers) {
          double d = sqrt((i - e[0]) * (i - e[0]) + (j - e[1]) * (j - e[1]));
          if (d <= radius) {
            t += floor(e[2] / (1 + d));
          }
        }
        if (mx < t) {
          mx = t;
          ans = {i, j};
        }
      }
    }
    return ans;
  }
};
func bestCoordinate(towers [][]int, radius int) []int {
  ans := []int{0, 0}
  mx := 0
  for i := 0; i < 51; i++ {
    for j := 0; j < 51; j++ {
      t := 0
      for _, e := range towers {
        d := math.Sqrt(float64((i-e[0])*(i-e[0]) + (j-e[1])*(j-e[1])))
        if d <= float64(radius) {
          t += int(float64(e[2]) / (1 + d))
        }
      }
      if mx < t {
        mx = t
        ans = []int{i, j}
      }
    }
  }
  return ans
}

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。
列表为空,暂无数据
    我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
    原文