Problem 168: Search a word in a grid

Author: mandliya

README.md

@@ -6,7 +6,7 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 167 |
+| Total Problems | 168 |
 
 </center>
 
@@ -197,12 +197,13 @@ Include contains single header implementation of data structures and some algori
 | Calculate total weight of Minimum Spanning Tree of a given graph ( sum of weights of edges which forms MST) using Prim's algorithm | [primsMST.cpp](graph_problems/primsMST.cpp)|
 | Print Minimum Spanning Tree( MST ) of a given graph using Kruskal's algorithm.| [kruskalMST.cpp](graph_problems/kruskalMST.cpp)|
 | Create a program to generate a Huffman encoding for each character as a table.|[huffman_encoding.cpp](greedy_problems/huffman_encoding.cpp)|
+| Search a given word in a 2D board containing letters. The word can be constructed by sequentially traversing adjacent horizontal or vertical cells. In a sequence to form word, letter on same position can not be used more than once. (Check top of file for examples.)|[grid_word_search.cpp](graph_problems/grid_word_search.cpp)|
 
 ### Greedy Problems
 | Problem | Solution |
 | :------------ | :----------: |
 | Given two integer arrays, A and B, each containing N integers. You are free to permute the order of the elements in the arrays. Is there an permutation A', B' possible of A and B, such that, A'<sub>i</sub>+B'<sub>i</sub> ≥ K for all i, where A'<sub>i</sub> denotes the i<sup>th</sup> element in the array A' and B'<sub>i</sub> denotes i<sup>th</sup> element in the array B'.| [two_arrays.cpp](greedy_problems/two_arrays.cpp)|
-|John is taking orders. The i<sup>th</sup> order is placed by the i<sup>th</sup> customer at t<sub>i</sub> time and it takes d<sub>i</sub> time to procees. What is the order in which the customers will get their orders? (see more details in solutions's comments)|[orders_order.cpp](greedy_problems/orders_order.cpp)|
+| John is taking orders. The i<sup>th</sup> order is placed by the i<sup>th</sup> customer at t<sub>i</sub> time and it takes d<sub>i</sub> time to procees. What is the order in which the customers will get their orders? (see more details in solutions's comments)|[orders_order.cpp](greedy_problems/orders_order.cpp)|
 
 
 ### Leet code Problems

graph_problems/grid_word_search.cpp

@@ -0,0 +1,140 @@
+/*
+ * Search a given word in a 2D board containing letters. 
+ * The word can be constructed by sequentially traversing adjacent 
+ * horizontal or vertical cells. In a sequence to form word,
+ * letter on same position can not be used more than once.
+ * 
+ * Example:
+ * Input:
+ * 
+ * ['H' 'E' 'Y' 'A']
+ * ['O' 'L' 'A' 'Y']
+ * ['I' 'L' 'O' 'V']
+ * 
+ * Word: HELLO
+ * Output: Yes/true
+ * 
+ * Word: YELL
+ * Output: Yes/true
+ * 
+ * Word: LOVE
+ * Output: No/false
+ * 
+ * Assumption: grid or word does not contain '$' char
+ * 
+ * Approach: We can use Depth First Search with backtracking to solve this.
+ * We can search the grid to match the grid the first letter of search word
+ * in the grid, and then apply depth first search on the grid.
+ * Finding appropriate next characters in the search word at each depth while
+ * searching sequentially in the four directions.
+ * 
+ * We need some way to mark a position in grid as already visited. I will use
+ * '$' to mark the position as visited, and we will reset the letter at the
+ * position back to original letter at the end of backtracking.
+ * 
+ */
+
+#include <iostream>
+#include <vector>
+#include <iomanip>
+
+bool depth_first_search(std::vector<std::vector<char>>& grid, const std::string& word,
+    int r, int c, int index)
+{
+    if (index == word.size()) {
+        return true;
+    }
+    int rows = grid.size();
+    int cols = grid[0].size();
+    if (r < 0 || r >= rows || c < 0 || c >= cols) {
+        return false;
+    }
+
+    if (word[index] != grid[r][c]) {
+        return false;
+    }
+
+    char cur = grid[r][c];
+    grid[r][c] = '$';
+    bool result = false;
+
+    result = depth_first_search(grid, word, r - 1, c, index + 1) ||
+        depth_first_search(grid, word, r + 1, c, index + 1) ||
+        depth_first_search(grid, word, r, c - 1, index + 1) ||
+        depth_first_search(grid, word, r, c + 1, index + 1);
+
+    grid[r][c] = cur;
+    return result;
+}
+
+
+
+bool grid_search(std::vector<std::vector<char>>& grid, const std::string& word)
+{
+    int rows = grid.size();
+    int cols = grid[0].size();
+    for (int i = 0; i < rows; ++i) {
+        for (int j = 0; j < cols; ++j) {
+           if (word[0] == grid[i][j]) {
+               if (depth_first_search(grid, word, i, j, 0)) {
+                   return true;
+               }
+           }
+        }
+    }
+    return false;
+}
+
+void print_grid(const std::vector<std::vector<char>>& grid)
+{
+    for (auto vec : grid) {
+        std::cout << "{ ";
+        for (auto c : vec) {
+            std::cout << c << " ";
+        }
+        std::cout << "}" << std::endl;
+    }
+}
+
+int main()
+{
+    std::vector<std::vector<char>> grid{
+        {'H', 'E', 'Y', 'A'},
+        {'O', 'L', 'A', 'Y'},
+        {'I', 'L', 'O', 'V'}
+    };
+    print_grid(grid);
+    std::cout << std::boolalpha;
+    std::cout << "Does word 'HELLO' exist in grid? ";
+    bool result = grid_search(grid, "HELLO");
+    std::cout << result << std::endl;
+
+    std::cout << "Does word 'HELL' exist in grid? ";
+    result = grid_search(grid, "HELL");
+    std::cout << result << std::endl;
+
+    std::cout << "Does word 'LOVE' exist in grid? ";
+    result = grid_search(grid, "LOVE");
+    std::cout << result << std::endl;
+
+    std::vector<std::vector<char>> grid2 {
+        {'A','B','C','E'},
+        {'S','F','C','S'},
+        {'A','D','E','E'}
+    };
+
+    print_grid(grid2);
+    std::cout << "Does word 'SEE' exist in grid? ";
+    result = grid_search(grid2, "SEE");
+    std::cout << result << std::endl;
+
+    std::cout << "Does word 'ABCCSE' exist in grid? ";
+    result = grid_search(grid2, "ABCCSE");
+    std::cout << result << std::endl;
+
+    std::cout << "Does word 'ABDE' exist in grid? ";
+    result = grid_search(grid2, "ABDE");
+    std::cout << result << std::endl;
+
+    return 0;
+}