Brightest Position on Street

Brightest Position on Street - Problem

A perfectly straight street is represented by a number line. The street has street lamp(s) on it and is represented by a 2D integer array lights. Each lights[i] = [position_i, range_i] indicates that there is a street lamp at position position_i that lights up the area from [position_i - range_i, position_i + range_i] (inclusive).

The brightness of a position p is defined as the number of street lamps that light up the position p.

Given lights, return the brightest position on the street. If there are multiple brightest positions, return the smallest one.

Input & Output

Example 1 — Basic Two Lamps

$ Input: lights = [[1,1],[3,2]]

› Output: 1

💡 Note: Lamp 1 at position 1 with range 1 covers [0,2]. Lamp 2 at position 3 with range 2 covers [1,5]. Position 1 and 2 both have brightness 2, but we return the smaller position 1.

Example 2 — Single Lamp

$ Input: lights = [[2,3]]

› Output: -1

💡 Note: Single lamp at position 2 with range 3 covers [-1,5]. All positions have brightness 1, so return the smallest position -1.

Example 3 — Multiple Overlaps

$ Input: lights = [[1,0],[0,1]]

› Output: 1

💡 Note: Lamp 1 at position 1 with range 0 covers [1,1]. Lamp 2 at position 0 with range 1 covers [-1,1]. Position 1 has brightness 2 (both lamps overlap), while other positions have brightness 1, so return position 1.

Constraints

1 ≤ lights.length ≤ 10⁵
lights[i].length == 2
-10⁸ ≤ position_i ≤ 10⁸
0 ≤ range_i ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use coordinate compression with a difference array to efficiently track brightness changes. Instead of checking every position, we only process critical points where brightness changes. Best approach uses line sweep technique. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Check All Positions

⏱️ Time: O(R × n) Space: O(1)

For each possible position on the street, count how many street lamps illuminate that position. Track the maximum brightness and the smallest position with that brightness.

Difference Array (Line Sweep)

⏱️ Time: O(n log n) Space: O(n)

Create events for when each lamp starts and stops contributing. Use coordinate compression and difference array to efficiently compute brightness at all relevant positions.

Brute Force - Check All Positions — Algorithm Steps

Find the range of all possible positions
For each position, count overlapping lamp ranges
Track maximum brightness and smallest position

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Range

Determine min and max possible positions

Check Each Position

Count how many lamps illuminate each position

Find Maximum

Return position with highest brightness

Code -

solution.c — C

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

struct TreeNode {
    char* val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(const char* val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = (char*)malloc(strlen(val) + 1);
    strcpy(node->val, val);
    node->left = NULL;
    node->right = NULL;
    return node;
}

int precedence(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}

struct TreeNode* expTree(char* s) {
    struct TreeNode** operands = (struct TreeNode**)malloc(1000 * sizeof(struct TreeNode*));
    char* operators = (char*)malloc(1000 * sizeof(char));
    int operandTop = -1;
    int operatorTop = -1;
    
    int i = 0;
    int len = strlen(s);
    
    while (i < len) {
        char c = s[i];
        
        if (isdigit(c)) {
            char num[100] = {0};
            int numIdx = 0;
            while (i < len && isdigit(s[i])) {
                num[numIdx++] = s[i];
                i++;
            }
            operands[++operandTop] = createNode(num);
            i--;
        } else if (c == '(') {
            operators[++operatorTop] = c;
        } else if (c == ')') {
            while (operatorTop >= 0 && operators[operatorTop] != '(') {
                char op = operators[operatorTop--];
                struct TreeNode* right = operands[operandTop--];
                struct TreeNode* left = operands[operandTop--];
                
                char opStr[2] = {op, '\0'};
                struct TreeNode* root = createNode(opStr);
                root->left = left;
                root->right = right;
                operands[++operandTop] = root;
            }
            operatorTop--; // Remove '('
        } else if (c == '+' || c == '-' || c == '*' || c == '/') {
            while (operatorTop >= 0 && operators[operatorTop] != '(' &&
                   precedence(operators[operatorTop]) >= precedence(c)) {
                char op = operators[operatorTop--];
                struct TreeNode* right = operands[operandTop--];
                struct TreeNode* left = operands[operandTop--];
                
                char opStr[2] = {op, '\0'};
                struct TreeNode* root = createNode(opStr);
                root->left = left;
                root->right = right;
                operands[++operandTop] = root;
            }
            operators[++operatorTop] = c;
        }
        i++;
    }
    
    while (operatorTop >= 0) {
        char op = operators[operatorTop--];
        struct TreeNode* right = operands[operandTop--];
        struct TreeNode* left = operands[operandTop--];
        
        char opStr[2] = {op, '\0'};
        struct TreeNode* root = createNode(opStr);
        root->left = left;
        root->right = right;
        operands[++operandTop] = root;
    }
    
    struct TreeNode* result = operandTop >= 0 ? operands[operandTop] : NULL;
    free(operands);
    free(operators);
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    struct TreeNode* result = expTree(s);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(R × n)

R is the range of positions (can be very large), n is number of lamps

⚡ Linearithmic

Space Complexity

O(1)

Only using variables to track maximum brightness and position

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler