Prob: 167 Count number of islands

Author: mandliya

README.md

@@ -6,7 +6,7 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 166 |
+| Total Problems | 167 |
 
 </center>
 
@@ -236,5 +236,5 @@ Include contains single header implementation of data structures and some algori
 | Given a string, sort it in decreasing order based on the frequency of characters.For example: <ul><li>Input: cccbbbbaa Output: bbbcccaa</li></ul>| [sortCharByFrequency.cpp](leet_code_problems/sortCharByFrequency.cpp)|
 |Product of Array Except Self. Given an array of n integers where n > 1, nums, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i].| [product_except_self.cpp](leet_code_problems/product_except_self.cpp)|
 |Given a sorted array, remove duplicates in place and return the new length. It doesn't matter what is in array beyond the unique elements size. Expected O(1) space and O(n) time complexity.| [remove_duplicates.cpp](leet_code_problems/remove_duplicates.cpp) |
-
+| Count the number of islands in a grid. Given a grid representing 1 as land body, and 0 as water body, determine the number of islands (more details in problem comments)|[count_islands.cpp](leet_code_problems/count_islands.cpp)|
 

leet_code_problems/count_islands.cpp

@@ -0,0 +1,98 @@
+/*
+ * In a given 2D grid, 1 represents land and 0 represents water body.
+ * We need to count number of islands.
+ * An island is surrounded by connecting neighbouring lands vertically
+ * or horizontally.
+ * Assume: That everything around the grid is water.
+ * 
+ * Approach: We can solve this problem with Depth/Breadth first search.
+ * 
+ * With Depth first search:
+ * Consider a land body, and start a depth first search, and mark all the
+ * connected land bodies to it as water bodies (i.e. mark all connected 1's 
+ * as 0 to mark them visited)
+ * In this case, number of islands for which DFS was started is the total
+ * count of islands.
+ * Similar idea could be used for BFS.
+ * 
+ * Example:
+ * 
+ * 1 1 0 0
+ * 1 0 1 0
+ * 1 0 0 1
+ * 
+ * There are 3 islands in above grid.
+ */
+
+#include <iostream>
+#include <vector>
+
+bool is_in_grid(const std::vector<std::vector<int> >& grid, int i, int j)
+{
+    int m = grid.size();
+    int n = grid[0].size();
+    return (i >= 0 && i < m && j >= 0 && j < n);
+}
+
+void depth_first_search(std::vector<std::vector<int> >& grid, int i, int j)
+{
+    int m = grid.size();
+    int n = grid[0].size();
+
+    if (i < 0 || i >= m || j < 0 || j >= n) {
+        return;
+    }
+    grid[i][j] = 0;
+    if (i + 1 < m && grid[i + 1][j] == 1) {
+        depth_first_search(grid, i + 1, j);
+    }
+    if (i - 1 >= 0 && grid[i - 1][j] == 1) {
+        depth_first_search(grid, i - 1, j);
+    }
+    if (j + 1 < n &&  grid[i][j + 1] == 1) {
+        depth_first_search(grid, i, j + 1);
+    }
+    if (j - 1 >= 0 && grid[i][j - 1] == 1) {
+        depth_first_search(grid, i, j - 1);
+    }
+}
+
+int number_of_islands(std::vector<std::vector<int>>& grid)
+{
+    int m = grid.size();
+    if (m == 0) {
+        return 0;
+    }
+    int n = grid[0].size();
+    int total_islands = 0;
+    for ( int i = 0; i < m; ++i) {
+        for ( int j = 0; j < n; ++j) {
+            if (grid[i][j] == 1) {
+                ++total_islands;
+                depth_first_search(grid, i, j);
+            }
+        }
+    }
+    return total_islands;
+}
+
+
+int main()
+{
+    std::vector<std::vector<int>> grid = {
+        {1, 1, 0, 0, 0},
+        {1, 1, 0, 0, 0},
+        {0, 0, 1, 0, 0},
+        {0, 0, 0, 1, 1}
+    };
+
+    for (int i = 0; i < grid.size(); ++i) {
+        for (int j = 0; j < grid[0].size(); ++j) {
+            std::cout << grid[i][j] << " ";
+        }
+        std::cout << std::endl;
+    }
+    std::cout << "Total number of islands in the grid is :"
+    << number_of_islands(grid) << std::endl;
+    return 0;
+}

sort_search_problems/closestPairSorted.cpp

@@ -20,8 +20,8 @@
 #include <cmath>
 
 std::pair<int,int> closestPair( std::vector<int> & vec1, std::vector<int> & vec2, int x ) {
-	size_t left = 0;
-	size_t right = vec2.size() - 1;
+	int left = 0;
+	int right = vec2.size() - 1;
 	int minDiff = std::numeric_limits<int>::max();
 	int leftRes, rightRes;
 	while (left < vec1.size() && right >= 0 ) {