Sum of Remoteness of All Cells - Practice Coding Problems

Sum of Remoteness of All Cells - Problem

Array Hash Table Depth-First Search Breadth-First Search Union Find Matrix Medium

You're given an n × n grid where each cell contains either a positive integer or -1 (representing a blocked cell). Your task is to calculate the "remoteness" of every cell and return their sum.

What is Remoteness?
For any non-blocked cell (i, j), its remoteness R[i][j] is the sum of all values in cells that are unreachable from (i, j) through valid moves. You can only move between adjacent non-blocked cells (up, down, left, right).

For blocked cells, R[i][j] = 0.

Goal: Return the sum of remoteness values for all cells in the grid.

Think of it like islands in an ocean - cells on different islands can't reach each other, so they contribute to each other's remoteness!

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: grid = [[1, -1, 3], [5, 6, -1], [-1, 2, 4]]

› Output: 32

💡 Note: Component 1: {1} with sum=1, remoteness=14 each. Component 2: {5,6} with sum=11, remoteness=4 each. Component 3: {3} with sum=3, remoteness=12 each. Component 4: {2,4} with sum=6, remoteness=9 each. Total: 1×14 + 2×4 + 1×12 + 2×9 = 32

example_2.py — All Connected

$ Input: grid = [[1, 2], [3, 4]]

› Output: 0

💡 Note: All cells are connected in one component. Each cell can reach all others, so remoteness is 0 for each cell. Total sum = 0.

example_3.py — Single Cell

$ Input: grid = [[5]]

› Output: 0

💡 Note: Only one cell exists. It has no unreachable cells, so remoteness = 0. Total sum = 0.

Constraints

1 ≤ n ≤ 1000
grid[i][j] is either -1 or in the range [1, 10⁶]
There is at least one non-blocked cell in the grid

Visualization

Tap to expand

Understanding the Visualization

Map the Islands

Identify separate landmasses (connected components) using Union-Find or BFS

Calculate Island Populations

Sum up the population (cell values) for each island

Compute Remoteness

For each community, remoteness = populations of all other islands

Sum All Remoteness Values

Add up remoteness values from all communities across all islands

Key Takeaway

🎯 Key Insight: Group cells into connected components first, then use mathematical relationships to avoid redundant traversals - this transforms an O(n⁴) problem into O(n²)!

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal approach uses Union-Find to group cells into connected components efficiently. Instead of running BFS from each cell, we identify all connected components once, calculate their sums, then compute each cell's remoteness as total_sum - component_sum. This reduces time complexity from O(n⁴) to O(n² α(n²)) where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Connected Components (Union-Find)	O(n² α(n²))	O(n²)	Group cells into connected components first, then calculate remoteness efficiently
Brute Force (BFS for Each Cell)	O(n⁴)	O(n²)	For each cell, run BFS to find reachable cells, then sum unreachable ones

Connected Components (Union-Find) — Algorithm Steps

Initialize Union-Find data structure for all non-blocked cells
Union adjacent non-blocked cells to form connected components
Calculate sum of values for each connected component
For each cell, remoteness = total sum - sum of its component
Sum up remoteness values for all cells

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Union-Find

Each cell starts as its own component

Union adjacent cells

Connect neighboring non-blocked cells

Calculate component sums

Sum values within each connected component

Compute remoteness

For each cell: remoteness = total - component_sum

Code -

solution.c — C

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

#define MAX_COMPONENTS 10000

typedef struct {
    int id;
    long long sum;
    int count;
} Component;

int componentId[1000][1000];
Component components[MAX_COMPONENTS];
int numComponents = 0;

void dfs(int** grid, int n, int i, int j, int compId) {
    if (i < 0 || i >= n || j < 0 || j >= n || grid[i][j] == -1 || componentId[i][j] != -1) {
        return;
    }
    
    componentId[i][j] = compId;
    components[compId].sum += grid[i][j];
    components[compId].count++;
    
    dfs(grid, n, i+1, j, compId);
    dfs(grid, n, i-1, j, compId);
    dfs(grid, n, i, j+1, compId);
    dfs(grid, n, i, j-1, compId);
}

long long sumRemoteness(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    numComponents = 0;
    
    // Initialize
    memset(componentId, -1, sizeof(componentId));
    memset(components, 0, sizeof(components));
    
    // Find connected components
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] != -1 && componentId[i][j] == -1) {
                components[numComponents].id = numComponents;
                dfs(grid, n, i, j, numComponents);
                numComponents++;
            }
        }
    }
    
    // Calculate total sum
    long long totalSum = 0;
    for (int i = 0; i < numComponents; i++) {
        totalSum += components[i].sum;
    }
    
    // Calculate result
    long long result = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] != -1) {
                int compId = componentId[i][j];
                result += totalSum - components[compId].sum;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² α(n²))

Union-Find operations with nearly constant amortized time per operation

⚠ Quadratic Growth

Space Complexity

O(n²)

Union-Find parent and rank arrays, plus component sum storage

⚠ Quadratic Space

21.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Connected Components (Union-Find) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler