Check if a word exists in a grid or not

Given a 2D grid of characters and a word, the task is to check if that word exists in the grid or not. A word can be matched in 4 directions at any point.

The 4 directions are, Horizontally Left and Right, Vertically Up and Down.
Examples:

Input:  grid[][] = {"axmy",
                    "bgdf",
                    "xeet",
                    "raks"};
Output: Yes

a x m y
b g d f
x e e t
r a k s

Input: grid[][] = {"axmy",
                   "brdf",
                   "xeet",
                   "rass"};
Output : No

Source: Microsoft Interview



Approach: The idea used here is described in the steps below:

  • Check every cell, if the cell has first character, then recur one by one and try all 4 directions from that cell for a match.
  • Mark the position in the grid as visited and recur in the 4 possible directions.
  • After recurring, again mark the position as unvisited.
  • Once all the letters in the word is matched, return true.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to check if the word
// exists in the grid or not
#include <bits/stdc++.h>
using namespace std;
#define r 4
#define c 5
  
// Function to check if a word exists in a grid
// starting from the first match in the grid
// level: index till which pattern is matched
// x, y: current position in 2D array
bool findmatch(char mat[r], string pat, int x, int y,
               int nrow, int ncol, int level)
{
    int l = pat.length();
  
    // Pattern matched
    if (level == l)
        return true;
  
    // Out of Boundary
    if (x < 0 || y < 0 || x >= nrow || y >= ncol)
        return false;
  
    // If grid matches with a letter while
    // recursion
    if (mat[x][y] == pat[level]) {
  
        // Marking this cell as visited
        char temp = mat[x][y];
        mat[x][y] = '#';
  
        // finding subpattern in 4 directions
        bool res = findmatch(mat, pat, x - 1, y, nrow, ncol, level + 1) | 
                   findmatch(mat, pat, x + 1, y, nrow, ncol, level + 1) | 
                   findmatch(mat, pat, x, y - 1, nrow, ncol, level + 1) | 
                   findmatch(mat, pat, x, y + 1, nrow, ncol, level + 1);
  
        // marking this cell
        // as unvisited again
        mat[x][y] = temp;
        return res;
    }
    else // Not matching then false
        return false;
}
  
// Function to check if the word exists in the grid or not
bool checkMatch(char mat[r], string pat, int nrow, int ncol)
{
  
    int l = pat.length();
  
    // if total characters in matrix is
    // less then pattern lenghth
    if (l > nrow * ncol)
        return false;
  
    // Traverse in the grid
    for (int i = 0; i < nrow; i++) {
        for (int j = 0; j < ncol; j++) {
  
            // If first letter matches, then recur and check
            if (mat[i][j] == pat[0])
                if (findmatch(mat, pat, i, j, nrow, ncol, 0))
                    return true;
        }
    }
    return false;
}
  
// Driver Code
int main()
{
    char grid[r] = { "axmy",
                        "bgdf",
                        "xeet",
                        "raks" };
  
    // Function to check if word exists or not
    if (checkMatch(grid, "geeks", r, c))
        cout << "Yes";
    else
        cout << "No";
  
 return 0;
  
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to check if the word 
# exists in the grid or not 
  
r = 4
c = 4
  
# Function to check if a word exists 
# in a grid starting from the first 
# match in the grid level: index till  
# which pattern is matched x, y: current 
# position in 2D array 
def findmatch(mat, pat, x, y, 
              nrow, ncol, level) :
  
    l = len(pat) 
  
    # Pattern matched 
    if (level == l) :
        return True
  
    # Out of Boundary 
    if (x < 0 or y < 0 or 
        x >= nrow or y >= ncol) :
        return False
  
    # If grid matches with a letter 
    # while recursion 
    if (mat[x][y] == pat[level]) :
  
        # Marking this cell as visited 
        temp = mat[x][y]
        mat[x].replace(mat[x][y], "#")
  
        # finding subpattern in 4 directions 
        res = (findmatch(mat, pat, x - 1, y, nrow, ncol, level + 1) | 
               findmatch(mat, pat, x + 1, y, nrow, ncol, level + 1) | 
               findmatch(mat, pat, x, y - 1, nrow, ncol, level + 1) |
               findmatch(mat, pat, x, y + 1, nrow, ncol, level + 1)) 
  
        # marking this cell as unvisited again 
        mat[x].replace(mat[x][y], temp)
        return res
      
    else : # Not matching then false 
        return False
  
# Function to check if the word
# exists in the grid or not 
def checkMatch(mat, pat, nrow, ncol) :
  
    l = len(pat)
  
    # if total characters in matrix is 
    # less then pattern lenghth 
    if (l > nrow * ncol) :
        return False
  
    # Traverse in the grid 
    for i in range(nrow) :
        for j in range(ncol) :
  
            # If first letter matches, then 
            # recur and check 
            if (mat[i][j] == pat[0]) :
                if (findmatch(mat, pat, i, j, 
                              nrow, ncol, 0)) :
                    return True
    return False
  
# Driver Code 
if __name__ == "__main__" :
  
    grid = ["axmy", "bgdf"
            "xeet", "raks"]
  
    # Function to check if word 
    # exists or not 
    if (checkMatch(grid, "geeks", r, c)) :
        print("Yes")
    else :
        print("No"
  
# This code is contributed by Ryuga

chevron_right


Output:

Yes


My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : AnkitRai01