Minimum number of Water to Land conversion to make two islands connected in a Grid

04 Apr, 2022
Given a 2D grid arr[][] of ‘W’ and ‘L’ where ‘W’ denotes water and ‘L’ denotes land, the task is to find the minimum number of water components ‘W’ that must be changed to land component ‘L’ so that two islands becomes connected. 
An island is the set of connected ‘L’s. 
Note: There can be only two disjoint islands.
Examples:  
Input: arr[][] = {{‘W’, ‘L’}, {‘L’, ‘W’}}; Output: 1 Explanation: For the given set of islands if we change arr[1][1] to ‘W’ then, set of all island are connected. Therefore, the minimum number of ‘W’ must be changed to ‘L’ is 1.
Input: arr[][] = {{‘W’, ‘L’, ‘W’}, {‘W’, ‘W’, ‘W’}, {‘W’, ‘W’, ‘L’}} Output: 2 
Approach: This problem can be solved using Floodfill algorithm. Below are the steps:  
Use Floodfill algorithm for the first set of the connected islands and make all the islands as visited and store the coordinates in a hash (say hash1).Use Floodfill algorithm for the second set of the connected islands and make all the islands as visited and store the coordinates in a second hash(say hash2).The minimum difference between coordinates stored in both the hash is the required result.
Use Floodfill algorithm for the first set of the connected islands and make all the islands as visited and store the coordinates in a hash (say hash1).
Use Floodfill algorithm for the second set of the connected islands and make all the islands as visited and store the coordinates in a second hash(say hash2).
The minimum difference between coordinates stored in both the hash is the required result.
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach #include <bits/stdc++.h>using namespace std; // Determine the distance between two// coordinatesint dist(pair<int, int>& p1,         pair<int, int>& p2){     return abs(p1.first - p2.first)           + abs(p2.second - p1.second) - 1;} // Function to implement floodfill algorithmvoid floodfill(set<pair<int, int> >& hash,               int i, int j,               vector<vector<char> >& A){     // Base Case    if (i < 0 || i >= A.size() || j < 0        || j >= A[0].size() || A[i][j] != 'L') {        return;    }     // Mark the current node visited    A[i][j] = 'V';     // Store the coordinates of in the    // hash set    hash.insert(make_pair(i, j));     // Recursively iterate for the next    // four directions    floodfill(hash, i - 1, j, A);    floodfill(hash, i + 1, j, A);    floodfill(hash, i, j - 1, A);    floodfill(hash, i, j + 1, A);} // Function to find the minimum 'W' to flippedvoid findMinimumW(vector<vector<char> >& A){     // Base Case    if (A.size() == 0)        return;     // Two sets to store the coordinates of    // connected island    set<pair<int, int> > hash1, hash2;     // Traversing the given grid[][]    for (int i = 0; i < A.size(); i++) {         for (int j = 0; j < A[0].size(); j++) {             // If an island is found            if (A[i][j] == 'L') {                 // Floodfill Algorithm for                // the first island                if (hash1.empty()) {                    floodfill(hash1, i, j, A);                }                 // Floodfill Algorithm for                // the second island                if (hash2.empty()                    && !hash1.count({ i, j })) {                    floodfill(hash2, i, j, A);                }            }        }    }     // To store the minimum count of 'W'    int ans = INT_MAX;     // Traverse both pairs of hashes    for (auto i : hash1) {        for (auto j : hash2) {            ans = min(ans, dist(i, j));        }    }     // Print the final answer    cout << ans << endl;} // Driver Codeint main(){     // Given grid of land and water    vector<vector<char> > arr;    arr = { { 'W', 'L' }, { 'L', 'W' } };     // Function Call    findMinimumW(arr);    return 0;}
// Java program for the above approachimport java.util.*; class GFG {  // Determine the distance between two  // coordinates  static int dist(Pair p1, Pair p2)  {    return Math.abs(p1.first - p2.first)      + Math.abs(p2.second - p1.second) - 1;  }   // class Pair to represent coordinates  // of elements in grid  static class Pair {    int first;    int second;    Pair(int f, int s)    {      this.first = f;      this.second = s;    }  }   // Function to implement floodfill algorithm  static void floodfill(HashSet<Pair> hash, int i, int j,                        char[][] A)  {     // Base Case    if (i < 0 || i >= A.length || j < 0        || j >= A[0].length || A[i][j] != 'L') {      return;    }     // Mark the current node visited    A[i][j] = 'V';     // Store the coordinates of in the    // hash set    hash.add(new Pair(i, j));     // Recursively iterate for the next    // four directions    floodfill(hash, i - 1, j, A);    floodfill(hash, i + 1, j, A);    floodfill(hash, i, j - 1, A);    floodfill(hash, i, j + 1, A);  }   // Function to find the minimum 'W' to flipped  static void findMinimumW(char[][] A)  {     // Base Case    if (A.length == 0)      return;     // Two sets to store the coordinates of    // connected island    HashSet<Pair> hash1 = new HashSet<>();    HashSet<Pair> hash2 = new HashSet<>();     // Traversing the given grid[][]    for (int i = 0; i < A.length; i++) {       for (int j = 0; j < A[0].length; j++) {         // If an island is found        if (A[i][j] == 'L') {           // Floodfill Algorithm for          // the first island          if (hash1.isEmpty()) {            floodfill(hash1, i, j, A);          }           // Floodfill Algorithm for          // the second island          if (hash2.isEmpty()              && !hash1.contains(                new Pair(i, j))) {            floodfill(hash2, i, j, A);          }        }      }    }     // To store the minimum count of 'W'    int ans = Integer.MAX_VALUE;     // Traverse both pairs of hashes    for (Pair i : hash1) {      for (Pair j : hash2) {        ans = Math.min(ans, dist(i, j));      }    }     // Print the final answer    System.out.println(ans);  }   // Driver Code  public static void main(String[] args)  {    // Given grid of land and water    char[][] arr = { { 'W', 'L' }, { 'L', 'W' } };     // Function Call    findMinimumW(arr);  }} // This code is contributed by kdeepsingh2002
# Python3 program for the above approachimport sys # Determine the distance between two# coordinatesdef dist(p1, p2):         return (abs(p1[0] - p2[0]) +            abs(p2[1] - p1[1]) - 1) # Function to implement floodfill algorithmdef floodfill(hash, i, j, A):         # Base Case    if (i < 0 or i >= len(A) or j < 0 or        j >= len(A[0]) or A[i][j] != 'L'):        return hash, A             # Mark the current node visited    A[i][j] = 'V'      # Store the coordinates of in the    # hash set    hash.add((i, j))         # Recursively iterate for the next    # four directions    hash, A = floodfill(hash, i - 1, j, A)    hash, A = floodfill(hash, i + 1, j, A)    hash, A = floodfill(hash, i, j - 1, A)    hash, A = floodfill(hash, i, j + 1, A)    return hash, A # Function to find the minimum 'W' to flippeddef findMinimumW(A):         # Base Case    if (len(A) == 0):        return set(), A             # Two sets to store the coordinates of    # connected island    hash1 = set()    hash2 = set()         # Traversing the given grid[][]    for i in range(len(A)):        for j in range(len(A[0])):                         # If an island is found            if (A[i][j] == 'L'):                                 # Floodfill Algorithm for                # the first island                if (len(hash1) == 0):                    hash1, A = floodfill(hash1, i, j, A)                                     # Floodfill Algorithm for                # the second island                if (len(hash2) == 0 and                   (i, j) not in hash1):                    hash2, A = floodfill(hash2, i, j, A)                         # To store the minimum count of 'W'    ans = sys.maxsize      # Traverse both pairs of hashes    for i in hash1:        for j in hash2:            ans = min(ans, dist(i, j))                 # Print the final answer    print(ans)     # Driver Codeif __name__=='__main__':      # Given grid of land and water    arr = []    arr = [ [ 'W', 'L' ], [ 'L', 'W' ] ]      # Function Call    findMinimumW(arr) # This code is contributed by pratham76
// C# program for the above approachusing System;using System.Collections.Generic; public class GFG{   // Determine the distance between two  // coordinates  static int dist(Pair p1, Pair p2)  {    return Math.Abs(p1.first - p2.first)      + Math.Abs(p2.second - p1.second) - 1;  }   // class Pair to represent coordinates  // of elements in grid  class Pair {    public int first;    public int second;    public Pair(int f, int s)    {      this.first = f;      this.second = s;    }  }   // Function to implement floodfill algorithm  static void floodfill(HashSet<Pair> hash, int i, int j,                        char[,] A)  {     // Base Case    if (i < 0 || i >= A.GetLength(0) || j < 0        || j >= A.GetLength(1) || A[i,j] != 'L') {      return;    }     // Mark the current node visited    A[i,j] = 'V';     // Store the coordinates of in the    // hash set    hash.Add(new Pair(i, j));     // Recursively iterate for the next    // four directions    floodfill(hash, i - 1, j, A);    floodfill(hash, i + 1, j, A);    floodfill(hash, i, j - 1, A);    floodfill(hash, i, j + 1, A);  }   // Function to find the minimum 'W' to flipped  static void findMinimumW(char[,] A)  {     // Base Case    if (A.GetLength(0) == 0)      return;     // Two sets to store the coordinates of    // connected island    HashSet<Pair> hash1 = new HashSet<Pair>();    HashSet<Pair> hash2 = new HashSet<Pair>();     // Traversing the given grid[,]    for (int i = 0; i < A.GetLength(0); i++) {       for (int j = 0; j < A.GetLength(1); j++) {         // If an island is found        if (A[i,j] == 'L') {           // Floodfill Algorithm for          // the first island          if (hash1.Count==0) {            floodfill(hash1, i, j, A);          }           // Floodfill Algorithm for          // the second island          if (hash2.Count==0              && !hash1.Contains(                new Pair(i, j))) {            floodfill(hash2, i, j, A);          }        }      }    }     // To store the minimum count of 'W'    int ans = int.MaxValue;     // Traverse both pairs of hashes    foreach (Pair i in hash1) {      foreach (Pair j in hash2) {        ans = Math.Min(ans, dist(i, j));      }    }     // Print the readonly answer    Console.WriteLine(ans);  }   // Driver Code  public static void Main(String[] args)  {     // Given grid of land and water    char[,] arr = { { 'W', 'L' }, { 'L', 'W' } };     // Function Call    findMinimumW(arr);  }} // This code is contributed by shikhasingrajput
<script> // JavaScript program for the above approach  // Determine the distance between two// coordinatesfunction dist(p1,p2){     return Math.abs(p1[0] - p2[0])           + Math.abs(p2[1] - p1[1]) - 1;} // Function to implement floodfill algorithmfunction floodfill(hash,i,j, A){     // Base Case    if (i < 0 || i >= A.length || j < 0        || j >= A[0].length || A[i][j] != 'L') {        return;    }     // Mark the current node visited    A[i][j] = 'V';     // Store the coordinates of in the    // hash set    hash.add([i, j]);     // Recursively iterate for the next    // four directions    floodfill(hash, i - 1, j, A);    floodfill(hash, i + 1, j, A);    floodfill(hash, i, j - 1, A);    floodfill(hash, i, j + 1, A);} // Function to find the minimum 'W' to flippedfunction findMinimumW(A){     // Base Case    if (A.length == 0)        return;     // Two sets to store the coordinates of    // connected island    let hash1 = new Set(), hash2 = new Set();     // Traversing the given grid[][]    for (let i = 0; i < A.length; i++) {         for (let j = 0; j < A[0].length; j++) {             // If an island is found            if (A[i][j] == 'L') {                 // Floodfill Algorithm for                // the first island                if (hash1.size == 0) {                    floodfill(hash1, i, j, A);                }                 // Floodfill Algorithm for                // the second island                if (hash2.size == 0 && !hash1.has([ i, j ])) {                    floodfill(hash2, i, j, A);                }            }        }    }     // To store the minimum count of 'W'    let ans = Number.MAX_VALUE;     // Traverse both pairs of hashes    for (let i of hash1) {        for (let j of hash2) {            ans = Math.min(ans, dist(i, j));        }    }     // Print the final answer    document.write(ans,"</br>");} // Driver Code // Given grid of land and waterlet arr = [ [ 'W', 'L' ], [ 'L', 'W' ] ]; // Function CallfindMinimumW(arr); // This code is contributed by shinjanpatra </script>
1
 
Time Complexity: O(N4) Auxiliary Space: O(N2) 
pratham76
ruhelaa48
pankajsharmagfg
karandeep1234
shikhasingrajput
shinjanpatra
Algorithms
Graph
Hash
Matrix
Hash
Matrix
Graph
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.