Coordinate With Maximum Network Quality

Coordinate With Maximum Network Quality - Problem

Array Enumeration Medium

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.

Input & Output

Example 1 — Basic Case

$ Input: towers = [[1,2,5],[2,1,7],[3,1,9]], radius = 2

› Output: [2,1]

💡 Note: At coordinate (2,1): Tower1 distance=√2≈1.41, quality=⌊5/(1+1.41)⌋=2. Tower2 distance=0, quality=⌊7/(1+0)⌋=7. Tower3 distance=1, quality=⌊9/(1+1)⌋=4. Total=2+7+4=13, which is maximum.

Example 2 — Multiple Optimal Points

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

› Output: [23,11]

💡 Note: Only one tower, so the coordinate at the tower location (23,11) gives maximum quality: ⌊21/(1+0)⌋=21.

Example 3 — No Signal Case

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

› Output: [1,2]

💡 Note: With radius=0, only coordinates exactly at tower locations get signal. Tower at (1,2) has highest quality 13, so return [1,2].

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 🍎 Apple 6

The key insight is to systematically check coordinates that can receive signals from towers. The brute force approach checks all coordinates in a bounded area, while the optimized approach only checks coordinates within the radius of at least one tower. Best approach: Optimized with Time: O(T×R² + C×T), Space: O(C).

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Brute Force - Check All Coordinates

⏱️ Time: O(R² × T) Space: O(1)

Calculate the network quality at every integral coordinate within a bounded area around the towers. For each coordinate, sum up the signal qualities from all towers within the given radius.

Optimized Search - Focus on Tower Vicinity

⏱️ Time: O(T × R² + C × T) Space: O(C)

Instead of checking all coordinates in a large bound, focus only on coordinates that are within the radius of at least one tower, as these are the only coordinates that can have non-zero quality.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

static int towers[1000][3];
static int towerCount = 0;

void parseTowers(char* line) {
    towerCount = 0;
    char* p = line;
    
    // Find first '['
    while (*p && *p != '[') p++;
    if (!*p) return;
    p++; // skip first '['
    
    while (*p && towerCount < 1000) {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n') p++;
        
        if (*p == '[') {
            p++; // skip '['
            // Parse x
            towers[towerCount][0] = (int)strtol(p, &p, 10);
            while (*p == ' ' || *p == ',') p++;
            // Parse y  
            towers[towerCount][1] = (int)strtol(p, &p, 10);
            while (*p == ' ' || *p == ',') p++;
            // Parse quality
            towers[towerCount][2] = (int)strtol(p, &p, 10);
            while (*p == ' ') p++;
            if (*p == ']') p++;
            towerCount++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
}

double distance(int x1, int y1, int x2, int y2) {
    long long dx = (long long)(x1 - x2);
    long long dy = (long long)(y1 - y2);
    return sqrt((double)(dx * dx + dy * dy));
}

long long calculateNetworkQuality(int x, int y, int radius) {
    long long totalQuality = 0;
    
    for (int i = 0; i < towerCount; i++) {
        double d = distance(x, y, towers[i][0], towers[i][1]);
        if (d <= radius) {
            long long quality = (long long)(towers[i][2] / (1.0 + d));
            totalQuality += quality;
        }
    }
    
    return totalQuality;
}

void findBestCoordinate(int radius, int* bestX, int* bestY) {
    if (towerCount == 0) {
        *bestX = 0;
        *bestY = 0;
        return;
    }
    
    // Find coordinate bounds
    int minX = towers[0][0], maxX = towers[0][0];
    int minY = towers[0][1], maxY = towers[0][1];
    
    for (int i = 1; i < towerCount; i++) {
        if (towers[i][0] < minX) minX = towers[i][0];
        if (towers[i][0] > maxX) maxX = towers[i][0];
        if (towers[i][1] < minY) minY = towers[i][1];
        if (towers[i][1] > maxY) maxY = towers[i][1];
    }
    
    // Expand search area by radius
    minX -= radius; maxX += radius;
    minY -= radius; maxY += radius;
    
    // Ensure non-negative coordinates
    if (minX < 0) minX = 0;
    if (minY < 0) minY = 0;
    
    long long maxQuality = -1;
    *bestX = 0;
    *bestY = 0;
    
    for (int x = minX; x <= maxX; x++) {
        for (int y = minY; y <= maxY; y++) {
            long long quality = calculateNetworkQuality(x, y, radius);
            
            if (quality > maxQuality || 
                (quality == maxQuality && (x < *bestX || (x == *bestX && y < *bestY)))) {
                maxQuality = quality;
                *bestX = x;
                *bestY = y;
            }
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    parseTowers(line);
    
    int radius;
    scanf("%d", &radius);
    
    int bestX, bestY;
    findBestCoordinate(radius, &bestX, &bestY);
    
    printf("[%d,%d]\n", bestX, bestY);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.9K Views

Medium Frequency

~25 min Avg. Time

245 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen