# Word Search Leetcode Solution

In this post, we are going to solve the Word Search Leetcode SolutionÂ problem of Leetcode. This Leetcode problem is done in many programming languages like C++, Java, and Python.

## Problem

Given anÂ `m x n`Â grid of charactersÂ `board`Â and a stringÂ `word`, returnÂ `true`Â ifÂ `word`Â exists in the grid.

The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.

Example 1:

```Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
Output: true
```

Example 2:

```Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
Output: true
```

Example 3:

```Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
Output: false
```

Constraints:

• `m == board.length`
• `n = board[i].length`
• `1 <= m, n <= 6`
• `1 <= word.length <= 15`
• `board`Â andÂ `word`Â consists of only lowercase and uppercase English letters.

Follow up:Â Could you use search pruning to make your solution faster with a largerÂ `board`?

Now, letâ€™s see the leetcode solution ofÂ Word Search Leetcode Solution.

### Word SearchLeetcode Solution in Python

```class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
m = len(board)
n = len(board[0])

def dfs(i: int, j: int, s: int) -> bool:
if i < 0 or i == m or j < 0 or j == n:
return False
if board[i][j] != word[s] or board[i][j] == '*':
return False
if s == len(word) - 1:
return True

cache = board[i][j]
board[i][j] = '*'
isExist = \
dfs(i + 1, j, s + 1) or \
dfs(i - 1, j, s + 1) or \
dfs(i, j + 1, s + 1) or \
dfs(i, j - 1, s + 1)
board[i][j] = cache

return isExist

return any(dfs(i, j, 0) for i in range(m) for j in range(n))
```

### Word SearchLeetcode Solutionin CPP

```class Solution {
public:
bool exist(vector<vector<char>>& board, string word) {
for (int i = 0; i < board.size(); ++i)
for (int j = 0; j < board[0].size(); ++j)
if (dfs(board, word, i, j, 0))
return true;
return false;
}

private:
bool dfs(vector<vector<char>>& board, const string& word, int i, int j,
int s) {
if (i < 0 || i == board.size() || j < 0 || j == board[0].size())
return false;
if (board[i][j] != word[s] || board[i][j] == '*')
return false;
if (s == word.length() - 1)
return true;

const char cache = board[i][j];
board[i][j] = '*';
const bool isExist = dfs(board, word, i + 1, j, s + 1) ||
dfs(board, word, i - 1, j, s + 1) ||
dfs(board, word, i, j + 1, s + 1) ||
dfs(board, word, i, j - 1, s + 1);
board[i][j] = cache;

return isExist;
}
};
```

### Word SearchLeetcode Solution in Java

```class Solution {
public boolean exist(char[][] board, String word) {
for (int i = 0; i < board.length; ++i)
for (int j = 0; j < board[0].length; ++j)
if (dfs(board, word, i, j, 0))
return true;
return false;
}

private boolean dfs(char[][] board, String word, int i, int j, int s) {
if (i < 0 || i == board.length || j < 0 || j == board[0].length)
return false;
if (board[i][j] != word.charAt(s) || board[i][j] == '*')
return false;
if (s == word.length() - 1)
return true;

final char cache = board[i][j];
board[i][j] = '*';
final boolean isExist = dfs(board, word, i + 1, j, s + 1) ||
dfs(board, word, i - 1, j, s + 1) ||
dfs(board, word, i, j + 1, s + 1) ||
dfs(board, word, i, j - 1, s + 1);
board[i][j] = cache;

return isExist;
}
}
```

Note:Â This problemÂ Word Search is generated byÂ LeetcodeÂ but the solution is provided byÂ Chase2learn This tutorial is only forÂ EducationalÂ andÂ LearningÂ purposes.

Sharing Is Caring