Coordinate With Maximum Network Quality - Practice Coding Problems

Coordinate With Maximum Network Quality - Problem

Array Enumeration Medium

Network Tower Signal Optimization Problem

Imagine you're a network engineer tasked with finding the optimal location to place a monitoring station that receives the maximum combined signal quality from all nearby network towers.

You are given an array of network towers towers, where towers[i] = [xi, yi, qi] represents the i-th network tower located at coordinates (xi, yi) with a quality factor qi. Each tower broadcasts a signal that weakens with distance according to the formula: ⌊qi / (1 + d)⌋, where d is the Euclidean distance from the tower to your position.

However, there's a catch! Towers have a limited radius - if the distance exceeds this radius, the signal becomes completely garbled and unusable.

Your Goal: Find the integral coordinate [cx, cy] where the total network quality (sum of all reachable tower signals) is maximized. If multiple coordinates tie for the maximum, return the lexicographically smallest coordinate.

Think of it like finding the sweet spot where your phone gets the best combined signal from all nearby cell towers!

Input & Output

example_1.py — Basic Case

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

› Output: [2,1]

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

example_2.py — Out of Range

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

› Output: [23,11]

💡 Note: Only one tower exists, so the optimal position is exactly at the tower location (23,11) where we get maximum signal quality of ⌊21/(1+0)⌋ = 21.

example_3.py — No Reachable Towers

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

› Output: [1,2]

💡 Note: Multiple coordinates might have the same maximum quality. We return the lexicographically smallest one. At (1,2), we get quality 13 from the first tower, plus contributions from other towers within radius 2.

Visualization

Tap to expand

Understanding the Visualization

Map the Territory

Identify all tower locations and their coverage areas (circles with given radius)

Define Search Zone

Create a bounding box that encompasses all possible optimal locations

Systematic Search

Check each integral coordinate and calculate total signal quality from reachable towers

Find the Sweet Spot

Select the coordinate with maximum quality (lexicographically smallest for ties)

Key Takeaway

🎯 Key Insight: The optimal location is always within the radius of at least one tower, so we can limit our search to a bounded area around all towers rather than the infinite coordinate plane.

Time & Space Complexity

Time Complexity

⏱️

O(W × H × N)

W and H are the width and height of the search space, N is the number of towers. For each coordinate, we check all towers.

✓ Linear Growth

Space Complexity

O(1)

Only storing the current best coordinate and quality value

✓ Linear Space

Constraints

1 ≤ towers.length ≤ 50
towers[i].length == 3
0 ≤ x_i, y_i, q_i ≤ 50
1 ≤ radius ≤ 50
All coordinates are integers
Distance is calculated using Euclidean formula: √[(x₂-x₁)² + (y₂-y₁)²]

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

This problem requires finding the optimal coordinate with maximum network quality through grid search. The key insight is that we only need to search within a bounded area around all towers (within radius distance). For each coordinate, we calculate the total signal quality from all reachable towers and track the lexicographically smallest coordinate with maximum quality. The brute force approach has complexity O(W × H × N) where W,H are the search space dimensions and N is the number of towers.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Grid Search	O(W × H × N)	O(1)	Check every coordinate in a reasonable grid around all towers

Brute Force Grid Search — Algorithm Steps

Determine the bounding box around all towers (with some padding for the radius)
Iterate through every integral coordinate (x, y) in this bounding box
For each coordinate, calculate the total network quality from all reachable towers
Keep track of the maximum quality and the lexicographically smallest coordinate that achieves it

Visualization

Tap to expand

Step-by-Step Walkthrough

Define Search Space

Create bounding box around all towers with radius padding

Grid Iteration

Check each integral coordinate systematically

Signal Calculation

For each point, sum signals from reachable towers

Track Optimum

Keep the lexicographically smallest coordinate with maximum quality

Code -

solution.c — C

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

int* bestCoordinate(int** towers, int towersSize, int* towersColSize, int radius, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = result[1] = 0;
    
    if (towersSize == 0) return result;
    
    // Find bounding box
    int minX = towers[0][0], maxX = towers[0][0];
    int minY = towers[0][1], maxY = towers[0][1];
    
    for (int i = 0; i < towersSize; 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];
    }
    
    minX -= radius; maxX += radius;
    minY -= radius; maxY += radius;
    
    int maxQuality = 0;
    
    // Check every coordinate in the bounding box
    for (int x = minX; x <= maxX; x++) {
        for (int y = minY; y <= maxY; y++) {
            int quality = 0;
            
            // Calculate quality from all reachable towers
            for (int i = 0; i < towersSize; i++) {
                double distance = sqrt(pow(x - towers[i][0], 2) + pow(y - towers[i][1], 2));
                if (distance <= radius) {
                    int signal = (int)(towers[i][2] / (1 + distance));
                    quality += signal;
                }
            }
            
            // Update best coordinate
            if (quality > maxQuality || 
                (quality == maxQuality && (x < result[0] || (x == result[0] && y < result[1])))) {
                maxQuality = quality;
                result[0] = x;
                result[1] = y;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(W × H × N)

W and H are the width and height of the search space, N is the number of towers. For each coordinate, we check all towers.

✓ Linear Growth

Space Complexity

O(1)

Only storing the current best coordinate and quality value

✓ Linear Space

Constraints

1 ≤ towers.length ≤ 50
towers[i].length == 3
0 ≤ x_i, y_i, q_i ≤ 50
1 ≤ radius ≤ 50
All coordinates are integers
Distance is calculated using Euclidean formula: √[(x₂-x₁)² + (y₂-y₁)²]

28.5K Views

Medium Frequency

~18 min Avg. Time

742 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Grid Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler