# Boggle (Find all possible words in a board of characters) | Set 1

Given a dictionary, a method to do lookup in dictionary and a M x N board where every cell has one character. Find all possible words that can be formed by a sequence of adjacent characters. Note that we can move to any of 8 adjacent characters, but a word should not have multiple instances of same cell.

Example:

Input: dictionary[] = {"GEEKS", "FOR", "QUIZ", "GO"}; boggle[][] = {{'G', 'I', 'Z'}, {'U', 'E', 'K'}, {'Q', 'S', 'E'}}; isWord(str): returns true if str is present in dictionary else false. Output: Following words of dictionary are present GEEKS QUIZ

### We strongly recommend that you click here and practice it, before moving on to the solution.

The idea is to consider every character as a starting character and find all words starting with it. All words starting from a character can be found using Depth First Traversal. We do depth first traversal starting from every cell. We keep track of visited cells to make sure that a cell is considered only once in a word.

## C++

// C++ program for Boggle game

#include

#include

using namespace std;

#define M 3

#define N 3

// Let the given dictionary be following

string dictionary[] = { “GEEKS”, “FOR”, “QUIZ”, “GO” };

int n = sizeof(dictionary) / sizeof(dictionary[0]);

// A given function to check if a given string is present in

// dictionary. The implementation is naive for simplicity. As

// per the question dictionary is given to us.

bool isWord(string& str)

{

// Linearly search all words

for (int i = 0; i < n; i++)
if (str.compare(dictionary[i]) == 0)
return true;
return false;
}
// A recursive function to print all words present on boggle
void findWordsUtil(char boggle[M][N], bool visited[M][N], int i,
int j, string& str)
{
// Mark current cell as visited and append current character
// to str
visited[i][j] = true;
str = str + boggle[i][j];
// If str is present in dictionary, then print it
if (isWord(str))
cout << str << endl;
// Traverse 8 adjacent cells of boggle[i][j]
for (int row = i - 1; row <= i + 1 && row < M; row++)
for (int col = j - 1; col <= j + 1 && col < N; col++)
if (row >= 0 && col >= 0 && !visited[row][col])

findWordsUtil(boggle, visited, row, col, str);

// Erase current character from string and mark visited

// of current cell as false

str.erase(str.length() – 1);

visited[i][j] = false;

}

// Prints all words present in dictionary.

void findWords(char boggle[M][N])

{

// Mark all characters as not visited

bool visited[M][N] = { { false } };

// Initialize current string

string str = “”;

// Consider every character and look for all words

// starting with this character

for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++)
findWordsUtil(boggle, visited, i, j, str);
}
// Driver program to test above function
int main()
{
char boggle[M][N] = { { 'G', 'I', 'Z' },
{ 'U', 'E', 'K' },
{ 'Q', 'S', 'E' } };
cout << "Following words of dictionary are present\n";
findWords(boggle);
return 0;
}
[tabby title="Java"]

`// Java program for Boggle game ` `class` `GFG { ` ` ` `// Let the given dictionary be following ` ` ` `static` `final` `String dictionary[] = { ` `"GEEKS"` `, ` `"FOR"` `, ` `"QUIZ"` `, ` `"GUQ"` `, ` `"EE"` `}; ` ` ` `static` `final` `int` `n = dictionary.length; ` ` ` `static` `final` `int` `M = ` `3` `, N = ` `3` `; ` ` ` ` ` `// A given function to check if a given string is present in ` ` ` `// dictionary. The implementation is naive for simplicity. As ` ` ` `// per the question dictionary is given to us. ` ` ` `static` `boolean` `isWord(String str) ` ` ` `{ ` ` ` `// Linearly search all words ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `if` `(str.equals(dictionary[i])) ` ` ` `return` `true` `; ` ` ` `return` `false` `; ` ` ` `} ` ` ` ` ` `// A recursive function to print all words present on boggle ` ` ` `static` `void` `findWordsUtil(` `char` `boggle[][], ` `boolean` `visited[][], ` `int` `i, ` ` ` `int` `j, String str) ` ` ` `{ ` ` ` `// Mark current cell as visited and append current character ` ` ` `// to str ` ` ` `visited[i][j] = ` `true` `; ` ` ` `str = str + boggle[i][j]; ` ` ` ` ` `// If str is present in dictionary, then print it ` ` ` `if` `(isWord(str)) ` ` ` `System.out.println(str); ` ` ` ` ` `// Traverse 8 adjacent cells of boggle[i][j] ` ` ` `for` `(` `int` `row = i - ` `1` `; row <= i + ` `1` `&& row < M; row++) ` ` ` `for` `(` `int` `col = j - ` `1` `; col <= j + ` `1` `&& col < N; col++) ` ` ` `if` `(row >= ` `0` `&& col >= ` `0` `&& !visited[row][col]) ` ` ` `findWordsUtil(boggle, visited, row, col, str); ` ` ` ` ` `// Erase current character from string and mark visited ` ` ` `// of current cell as false ` ` ` `str = ` `""` `+ str.charAt(str.length() - ` `1` `); ` ` ` `visited[i][j] = ` `false` `; ` ` ` `} ` ` ` ` ` `// Prints all words present in dictionary. ` ` ` `static` `void` `findWords(` `char` `boggle[][]) ` ` ` `{ ` ` ` `// Mark all characters as not visited ` ` ` `boolean` `visited[][] = ` `new` `boolean` `[M][N]; ` ` ` ` ` `// Initialize current string ` ` ` `String str = ` `""` `; ` ` ` ` ` `// Consider every character and look for all words ` ` ` `// starting with this character ` ` ` `for` `(` `int` `i = ` `0` `; i < M; i++) ` ` ` `for` `(` `int` `j = ` `0` `; j < N; j++) ` ` ` `findWordsUtil(boggle, visited, i, j, str); ` ` ` `} ` ` ` ` ` `// Driver program to test above function ` ` ` `public` `static` `void` `main(String args[]) ` ` ` `{ ` ` ` `char` `boggle[][] = { { ` `'G'` `, ` `'I'` `, ` `'Z'` `}, ` ` ` `{ ` `'U'` `, ` `'E'` `, ` `'K'` `}, ` ` ` `{ ` `'Q'` `, ` `'S'` `, ` `'E'` `} }; ` ` ` ` ` `System.out.println(` `"Following words of dictionary are present"` `); ` ` ` `findWords(boggle); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

Note that the above solution may print the same word multiple times. For example, if we add “SEEK” to the dictionary, it is printed multiple times. To avoid this, we can use hashing to keep track of all printed words.

In below set 2, we have discussed Trie based optimized solution:

**Boggle | Set 2 (Using Trie)**

This article is contributed by **Rishabh**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Boggle | Set 2 (Using Trie)
- Find alphabetical order such that words can be considered sorted
- Given a sorted dictionary of an alien language, find order of characters
- Count the nodes of a tree whose weighted string does not contain any duplicate characters
- Union-Find Algorithm | (Union By Rank and Find by Optimized Path Compression)
- Find the node whose xor with x gives maximum value
- Find the node whose xor with x gives minimum value
- Find the number of islands | Set 1 (Using DFS)
- Find the node whose sum with X has minimum set bits
- Find the node whose sum with X has maximum set bits
- Find the ordering of tasks from given dependencies
- Find whether it is possible to finish all tasks or not from given dependencies
- Find the maximum value permutation of a graph
- Find whether there is path between two cells in matrix
- Find k-cores of an undirected graph