# 2852. Sum of Remoteness of All Cells

## Problem Description

In this problem, we are given an `n x n` matrix called `grid`, where the value at each cell in the grid represents either a positive integer or `-1` indicating a blocked cell. The aim is to calculate the sum of "remoteness" for each cell in the grid. For a non-blocked cell `(i, j)`, the remoteness `R[i][j]` is defined as the sum of values of all non-blocked cells `(x, y)` from which there is no path to cell `(i, j)`. For blocked cells (where the value is `-1`), the remoteness is `0`.

To visualize how to move within the grid, one can move horizontally or vertically but not diagonally to any adjacent non-blocked cell. The overall goal is to determine the sum of remoteness for all cells in the matrix and return this sum.

## Intuition

To approach this problem, we have to understand that the remoteness of a non-blocked cell depends on the inaccessibility of other cells to this particular cell. Hence, if we know all the sets of cells that cannot reach a particular cell, we can calculate that cell's remoteness by summing up the values of those inaccessible cells.

The intuition behind the solution uses Depth-First Search (DFS) to group cells into connected components. For a non-blocked cell, we perform DFS to find all other reachable non-blocked cells. During each DFS, we keep track of:

1. The sum `s` of the values of the cells visited in the current DFS.
2. The total count `t` of cells visited in the current DFS.

Each time we visit a cell, we mark it as part of a connected component by setting its value to `0` to avoid revisiting it. Once the DFS is complete for a connected component, we know that:

• Any cell not visited during this DFS cannot reach any cell in the connected component, and their values should contribute to the remoteness of the component.
• The sum `s` represents the sum of values within the connected component.
• The count `t` represents the total number of cells in the connected component.

The remoteness for each non-blocked cell within the same connected component is the same. Hence, the remoteness (`R[i][j]`) for any non-blocked cell `(i, j)` is the product of the difference between the total count of non-blocked cells and the size of the connected component `t` (i.e., `(cnt - t)`) and the sum `s` of the connected component.

The final answer is the sum over the remoteness of all cells. By iterating over each cell and performing the above steps for each cell if it's a non-blocked cell that hasn't been visited, we can find the sum of remoteness for all cells in the grid.

## Solution Approach

The solution implements Depth-First Search (DFS) to walk through the grid and find connected components of non-blocked cells. Here's a step-by-step explanation of the implementation:

1. Define the `dfs` function that takes the current indices `i`, `j` as parameters. This function returns a tuple `(s, t)`, where `s` is the sum of the values of the cells within the current connected component and `t` is the number of cells in this connected component.

2. The `dfs` function first initializes `s` with the current cell's value and `t` with 1 (since the current cell is being counted). It then marks the current cell as part of a connected component by setting `grid[i][j]` to `0`, preventing the algorithm from revisiting this cell in the future.

3. The function proceeds to iterate over all adjacent cellsโin the up, down, left, and right directionsโchecking if any of them are non-blocked (where `grid[x][y] > 0`). For each non-blocked adjacent cell, it recursively calls `dfs` to visit it.

4. The results of the recursive calls (`s1`, `t1`) are aggregated to the current DFS call, updating the `s` and `t` for the entire connected component.

5. The solution records the total count of non-blocked cells in the `cnt` variable before starting the DFS processes. This count is needed to compute the remoteness for the cells.

6. The solution iterates over all the cells using nested loops. If a cell has a value greater than `0` (non-blocked and not yet visited), it calls the `dfs` function on it.

7. For each DFS completed, it has the sum `s` and total `t` for the connected component. The algorithm computes the remoteness for the cells in this component as `(cnt - t) * s` and adds it to the answer `ans`. This calculation is based on the count of cells not in the connected component (`cnt - t`) and the sum of the values of cells within the component.

8. Finally, after traversing all cells, the `ans` variable holds the sum of the remoteness of all cells which the function returns.

The implementation makes use of basic Python constructs like list comprehensions to calculate the count of non-blocked cells and for-loop along with tuple unpacking for iteration. The `dfs` function facilitates the use of recursion as a primary strategy to search through the grid, exhibiting the DFS pattern.

In summary, the algorithm complexity is driven by the DFS pattern, which ensures that each cell is explored only once. The data structures used are simple: the matrix `grid` itself, to mark visited cells, and a couple of variables to keep track of the summation. By leveraging these data structures and algorithm patterns, the implementation efficiently solves the problem.

๐ช
Level Up Your
Algo Skills

### Example Walkthrough

#### Initial setup:

Let's consider a small `3 x 3` grid as our example:

``````1grid = [
2    [1, 2, -1],
3    [-1, 3, 4],
4    [5, -1, 6]
5]``````

In this case, we have blocked cells at positions `(0,2)`, `(1,0)`, and `(2,1)`.

#### Step-by-step DFS analysis:

1. Start at cell `(0,0)` with a value of `1`. Initialize `s` to `1` and `t` to `1`. We perform a DFS from this cell, marking it as visited by setting its value to `0`.
• No valid adjacent cells to the right (blocked) or down (blocked).
• DFS ends for this cell with `s=1`, `t=1`.
1. Move to cell `(0,1)` with a value of `2`. This cell starts a new DFS as it is not visited yet.
• It can move down to `(1,1)` with a value of `3`, where `s = 2+3=5`, `t=1+1=2`.
• From `(1,1)`, it moves right to `(1,2)` with a value of `4`, where `s = 5+4=9`, `t = 2+1=3`.
• All adjacent cells are visited/blocked, so DFS ends with `s=9`, `t=3`.
1. Skipping to cell `(2,0)` with a value of `5`. This cell is not visited yet.
• No valid adjacent cells to move to.
• DFS ends for this cell with `s=5`, `t=1`.
1. Checking the last cell `(2,2)` with a value of `6`.
• No valid adjacent cells to move to.
• DFS ends for this cell with `s=6`, `t=1`.

#### Calculating remoteness:

The total count of non-blocked cells `cnt` is `6`.

For cell `(0,0)`, with `s=1`, `t=1`:

• Remoteness `R` for this connected component is `(cnt - t) * s = (6 - 1) * 1 = 5`.

For cells `(0,1)`, `(1,1)`, and `(1,2)`, with `s=9`, `t=3`:

• Remoteness `R` for this connected component is `(cnt - t) * s = (6 - 3) * 9 = 27`.

For cell `(2,0)`, with `s=5`, `t=1`:

• Remoteness `R` for this connected component is `(cnt - t) * s = (6 - 1) * 5 = 25`.

For cell `(2,2)`, with `s=6`, `t=1`:

• Remoteness `R` for this connected component is `(cnt - t) * s = (6 - 1) * 6 = 30`.

#### Final remoteness sum:

Adding the remoteness of all cells: `5 + 27 + 25 + 30 = 87`.

So, the sum of remoteness for this `3 x 3` grid example is `87`.

## Python Solution

``````1from typing import List, Tuple
2
3class Solution:
4    def sum_remoteness(self, grid: List[List[int]]) -> int:
5        # Helper function to perform depth-first search
6        def dfs(i: int, j: int) -> Tuple[int, int]:
7            subtree_sum, tree_size = grid[i][j], 1  # Initialize the sum and size for the current tree
8            grid[i][j] = 0  # Mark the current cell as visited by setting it to zero
9
10            # Iterate over the possible directions (up, right, down, left)
11            for a, b in pairwise(directions):
12                x, y = i + a, j + b  # Calculate the new coordinates
13
14                # Check if the new coordinates are within the grid and the cell is not visited
15                if 0 <= x < n and 0 <= y < n and grid[x][y] > 0:
16                    # Recursively call dfs to get subtree sum and size for the cell in the new coordinate
18                    # Sum up the results from the adjacent cells to the current cell
21
22            # Return sum and size of the subtree rooted at (i, j)
23            return subtree_sum, tree_size
24
25        # Calculate the grid size
26        n = len(grid)
27        # Define directions as a tuple, which represents up, right, down, and left moves
28        directions = (-1, 0, 1, 0, -1)
29        # Find the count of non-zero cells in the grid
30        total_positive_numbers = sum(x > 0 for row in grid for x in row)
31        # Initialize the variable to store the answer
32        total_remoteness = 0
33
34        # Iterate over each cell in the grid
35        for i, row in enumerate(grid):
36            for j, value in enumerate(row):
37                # If the cell has a positive value, it is the root of a tree
38                if value > 0:
39                    # Perform depth-first search from the root cell to get the sum and size of its tree
40                    sum_tree, size_tree = dfs(i, j)
41                    # Calculate the remoteness for the current tree and add it to the total
42                    total_remoteness += (total_positive_numbers - size_tree) * sum_tree
43
44        # Return the total remoteness for the grid
46
47# Helper function to generate pairs of directions for use in the DFS iteration
48def pairwise(iterable):
49    a, b = tee(iterable)
50    next(b, None)
51    return zip(a, b)
52
53# This part might require correction as the tee function is not imported in the original code, and the pairwise function should return overlapping pairs from directions.
54# Assumption is that itertools.tee and itertools.zip were intended to be used.
55
56from itertools import tee
57
58# example usage
59solution_instance = Solution()
60result = solution_instance.sum_remoteness([[1,2,3],[4,5,6],[7,8,9]])
61print(result)  # This line of code will print the result of the sum_remoteness function
62``````

## Java Solution

``````1class Solution {
2    private int size; // Grid size
3    private int[][] grid; // Grid declaration
4    private final int[] directions = {-1, 0, 1, 0, -1}; // Array to help navigate up, right, down, and left
5
6    // Method to calculate the sum of remoteness.
7    public long sumRemoteness(int[][] grid) {
8        this.size = grid.length;
9        this.grid = grid;
10        int count = 0; // Count of positive numbers in the grid
11
12        // Iterate over the grid to count the number of positive numbers
13        for (int[] row : grid) {
14            for (int cellValue : row) {
15                if (cellValue > 0) {
16                    ++count;
17                }
18            }
19        }
20
21        long totalSum = 0; // Initialize sum of remoteness
22
23        // Iterate over the grid to perform DFS and calculate remoteness
24        for (int i = 0; i < this.size; ++i) {
25            for (int j = 0; j < this.size; ++j) {
26                // Conditional to only start DFS from a positive cell value
27                if (this.grid[i][j] > 0) {
28                    long[] dfsResult = dfs(i, j);
29                    // Increase total sum by the remote value times the number of remaining positive numbers
30                    totalSum += (count - dfsResult[1]) * dfsResult[0];
31                }
32            }
33        }
35    }
36
37    // Depth-First Search (DFS) to explore grid cells recursively.
38    private long[] dfs(int row, int col) {
39        long[] result = new long[2];
40        result[0] = this.grid[row][col]; // The remoteness value
41        result[1] = 1; // Counts the current cell
42        this.grid[row][col] = 0; // Marks cell as visited
43
44        // Traverses the grid using the directions array.
45        for (int k = 0; k < 4; ++k) {
46            int newX = row + directions[k];
47            int newY = col + directions[k + 1];
48            // Check bounds and whether the new cell is positive before recursive call
49            if (newX >= 0 && newX < this.size && newY >= 0 && newY < this.size && this.grid[newX][newY] > 0) {
50                long[] temp = dfs(newX, newY);
51                result[0] += temp[0]; // Accumulate remoteness values from connected cells
52                result[1] += temp[1]; // Accumulate the number of connected positive cells
53            }
54        }
55        return result;
56    }
57}
58``````

## C++ Solution

``````1class Solution {
2public:
3    long long sumRemoteness(vector<vector<int>>& grid) {
4        using PairLongInt = pair<long long, int>; // Pair type for sum and count
5        int gridSize = grid.size(); // Size of the grid
6        int positiveCount = 0; // Count of positive values in grid
7        // Calculate the count of positive values
8        for (const auto& row : grid) {
9            for (int value : row) {
10                positiveCount += value > 0;
11            }
12        }
13        // Directions for adjacent cells (up, right, down, left)
14        int directions[5] = {-1, 0, 1, 0, -1};
15
16        // Depth-First Search to explore connected components
17        function<PairLongInt(int, int)> dfs = [&](int i, int j) {
18            long long sum = grid[i][j];
19            int count = 1;
20            grid[i][j] = 0; // Mark cell as visited
21            // Explore all 4 directions
22            for (int k = 0; k < 4; ++k) {
23                int newX = i + directions[k], newY = j + directions[k + 1];
24                // Check if the new position is valid and the cell has positive value
25                if (newX >= 0 && newX < gridSize && newY >= 0 && newY < gridSize && grid[newX][newY] > 0) {
26                    auto [subSum, subCount] = dfs(newX, newY); // Recur for the connected cell
27                    sum += subSum; // Increment sum by returned sum
28                    count += subCount; // Increment count by returned count
29                }
30            }
31            return PairLongInt(sum, count); // Return the total sum and count of connected component
32        };
33
34        long long answer = 0; // Variable to store the final answer
35        // Iterate through each cell in the grid
36        for (int i = 0; i < gridSize; ++i) {
37            for (int j = 0; j < gridSize; ++j) {
38                // If the cell has a positive value, it is part of an unvisited component
39                if (grid[i][j] > 0) {
40                    auto [componentSum, componentCount] = dfs(i, j); // DFS to get sum and count of the component
41                    // Update answer by adding the product of (cnt - count) and sum
42                    answer += (positiveCount - componentCount) * componentSum;
43                }
44            }
45        }
46        return answer; // Return the computed remoteness sum
47    }
48};
49``````

## Typescript Solution

``````1function sumRemoteness(grid: number[][]): number {
2    const gridSize = grid.length; // The size (width/height) of the grid
3    let countPositive = 0; // This will hold the number of positive values in the grid
4
5    // Calculate the total number of positive values in the grid
6    for (const row of grid) {
7        for (const cellValue of row) {
8            if (cellValue > 0) {
9                countPositive++;
10            }
11        }
12    }
13
14    // Define the possible directions (up, right, down, left) to explore in the grid
15    const directions = [-1, 0, 1, 0, -1];
16
17    // Depth-First Search function for exploring the grid
18    const depthFirstSearch = (rowIndex: number, colIndex: number): [number, number] => {
19        let sum = grid[rowIndex][colIndex]; // Current cell's value
20        let total = 1; // Initial total to 1 to represent the current cell
21        grid[rowIndex][colIndex] = 0; // Mark the current cell as visited
22
23        // Explore all adjacent cells in all four directions
24        for (let k = 0; k < 4; ++k) {
25            const newRow = rowIndex + directions[k];
26            const newCol = colIndex + directions[k + 1];
27
28            // Check if the new cell is within bounds and contains a positive value
29            if (newRow >= 0 && newRow < gridSize && newCol >= 0 && newCol < gridSize && grid[newRow][newCol] > 0) {
30                const [neighborSum, neighborTotal] = depthFirstSearch(newRow, newCol);
31                sum += neighborSum; // Add values from neighboring positive cells
32                total += neighborTotal; // Increment total number of positive cells encountered
33            }
34        }
35
36        // Return total values of the connected cells and the number of cells
37        return [sum, total];
38    };
39
40    let result = 0; // This will hold the final answer
41
42    // Process every cell in the grid
43    for (let rowIndex = 0; rowIndex < gridSize; rowIndex++) {
44        for (let colIndex = 0; colIndex < gridSize; colIndex++) {
45            // If the current cell has a positive value
46            if (grid[rowIndex][colIndex] > 0) {
47                // Perform a DFS from this cell
48                const [sumOfValues, totalValues] = depthFirstSearch(rowIndex, colIndex);
49                // Add to the result the product of the sum of values times the number of other cells
50                result += (countPositive - totalValues) * sumOfValues;
51            }
52        }
53    }
54
55    // Return the final calculated result
56    return result;
57}
58``````

## Time and Space Complexity

### Time Complexity

The given Python code performs a depth-first search (DFS) to compute the "sum of remoteness" on a 2D grid. To analyze the time complexity, we consider the following points:

• There is a nested for-loop that iterates through each element of the `n x n` grid, which gives a time complexity of `O(n^2)` for this part.
• Within the loop, the code executes a DFS (the `dfs` function) whenever a positive grid value is encountered. In the worst case, DFS may visit each cell once.
• The time complexity of DFS in a grid is proportional to the number of cells in the grid, which is `O(n^2)` for an `n x n` grid.
• Since DFS is called once per positive number in the grid and ensures that each cell is visited only once (by marking visited cells with `0`), the entire grid is processed only once. Thus, the combined complexity of processing the grid with DFS is still `O(n^2)`.

Given these considerations, the overall time complexity of the function is `O(n^2)`.

### Space Complexity

For the space complexity:

• The space is dominated by the recursion stack of DFS since we don't use any additional data structures that are dependent on `n`.
• In the worst case, when the grid is filled completely with positive numbers, the DFS could go as deep as `O(n^2)` since in the worst case it might have to visit all cells before backtracking (for example, in a scenario where you have a snake-like pattern).
• Apart from the recursion stack, the `dfs` function contains variable declarations which use only constant extra space.

Hence, the space complexity of the function is `O(n^2)`.

๐
Become an
Algo Monster

Got a question?ย Ask the Teaching Assistantย anything you don't understand.

Still not clear? Ask in the Forum, ย Discordย orย Submitย the part you don't understand to our editors.

โ
โTA ๐จโ๐ซ