Find maximum distance given a grid of nodes and a set of source nodes - graph-algorithm

Question

Given a set of nodes arranged as an m by n grid (note: diagonal nodes are not connected), and a set of nodes marked as source nodes, find the maximum distance between nodes and the source nodes.
For example, for a 4 by 4 grid and a source node at (1, 0):
0 0 0 0
1 0 0 0
0 0 0 0
0 0 0 0
Computing the distance from each node to its closest source would produce:
1 2 3 4
0 1 2 3
1 2 3 4
2 3 4 5
And the maximum distance is therefore 5.
For a grid with more than 1 source, for example 3 source nodes:
0 0 1 0
1 0 0 0
0 0 0 0
0 0 0 1
Computing the distance from each node to its closest source would produce:
1 1 0 1
0 1 1 2
1 2 2 1
2 2 1 0
And the maximum distance is therefore 2.
I wrote up an algorithm that solves this, but it looks like the worst case scenario makes it run in O(n^4) (assume m == n):
// MaximumDistances.java
public class MaximumDistances {
public static void main(String[] args) {
int[][] sourceNodes = new int[][] {
{0, 0, 1, 0},
{1, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 1}
};
int maximumDistance = computeMaximumDistance(sourceNodes);
System.out.println(String.format(
"The maximum distance in this grid is %d.",
maximumDistance));
}
private static int computeMaximumDistance(int[][] sourceNodes) {
int m = sourceNodes.length;
int n = sourceNodes[0].length;
// Initializes the distance grid. Since none of the sites have been
// visited yet, the distance to any grid cell with be
// `Integer.MAX_VALUE`.
int[][] distanceGrid = new int[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
distanceGrid[i][j] = Integer.MAX_VALUE;
}
}
// If we're at a source site, we mark its distance to each grid cell.
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (sourceNodes[i][j] == 1) {
markDistancesFromSourceSite(i, j, distanceGrid);
}
}
}
// The maximum value in the distance grid will be the maximum distance.
int maximumDistance = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (distanceGrid[i][j] > maximumDistance) {
maximumDistance = distanceGrid[i][j];
}
}
}
return maximumDistance;
}
private static void markDistancesFromSourceSite(int x, int y, int[][] distanceGrid) {
int m = distanceGrid.length;
int n = distanceGrid[0].length;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int distanceToSource = Math.abs(x - i) + Math.abs(y - j);
if (distanceGrid[i][j] > distanceToSource) {
distanceGrid[i][j] = distanceToSource;
}
}
}
}
}
Is there a faster algorithm that solves this?

Answer 1

Yes You can solve this problem using a concept called multisource BFS . The concept of multisource BFS is just like BFS but here is the minor difference .
In normal BFS we just push 1 node in the queue initially while in multisource BFS we push all the source nodes .
So after pushing all the source nodes we can just do the normal BFS operation to solve the problem .
The time complexity will be O(n*m) .
import java.util.*;
class Pair{
int x , y , dist;
Pair(int first , int second){
this.x = first;
this.y = second;
this.dist = 0;
}
Pair(int first , int second , int dist){
this.x = first;
this.y = second;
this.dist = dist;
}
}
public class MultisourceBFS {
public static void main(String[] args) {
int[][] sourceNodes = new int[][] {
{0, 0, 1, 0},
{1, 0, 0, 0},
{0, 0, 0, 0},
{0, 0, 0, 1}
};
int maximumDistance = computeMaximumDistance(sourceNodes);
System.out.println(String.format(
"The maximum distance in this grid is %d.",
maximumDistance));
}
private static int computeMaximumDistance(int[][] sourceNodes) {
int m = sourceNodes.length;
int n = sourceNodes[0].length;
int maximumDistance = 0;
int xx[] = {0 , 0 , 1 , -1}; // Normal array to go to up , down , left , right;
int yy[] = {1 , -1 , 0 , 0}; // Normal array to go to up ,down , left , right
Queue<Pair> q = new LinkedList<Pair>();
boolean isVisited[][] = new boolean[m][n]; // An array to check if a cell is visited or not .
// I am adding all the source nodes to the queue
for(int i = 0 ; i < m ; ++i)
for(int j = 0 ; j < n ; ++j)
if(sourceNodes[i][j]==1){
q.add(new Pair(i , j));
isVisited[i][j] = true;
}
// Now it is going to be normal BFS
while(!q.isEmpty()){
Pair node = q.remove();
for(int k = 0 ; k < 4 ; ++k){
int new_i = node.x + xx[k];
int new_j = node.y + yy[k];
if(new_i >= 0 && new_i < m && new_j >= 0 && new_j < n && isVisited[new_i][new_j]==false){
maximumDistance = Math.max(node.dist + 1 , maximumDistance);
isVisited[new_i][new_j] = true;
q.add(new Pair(new_i , new_j , node.dist + 1));
}
}
}
return maximumDistance;
}
}