# Word Search Leetcode Solution In this post, you will know how to solve the Word Search Leetcode Solution problem of Leetcode. This Leetcode problem is done in many programming languages like C++, Java, and Python.

One more thing to add, don’t directly look for the solutions, first try to solve the problems of Leetcode by yourself. If you find any difficulty after trying several times, then you can look for solutions.

## 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`?

### Word SearchLeetcode Solutions in Python

```class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
m = len(board)
n = len(board)
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 Search Leetcode Solutions in 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.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.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 Solutions 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.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.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  BrokenProgrammers. This tutorial is only for Educational and Learning purposes.