# Boggle (find all possible words in a board of characters)

## Introduction

Boggle, a classic word game invented by Allan Turoff in 1972, has captivated generations with its simple yet addictive gameplay. The objective is to find as many words as possible within a grid of letters before time runs out. Although Boggle can be enjoyed as a social activity or a pastime, it also serves as an excellent mental exercise that sharpens vocabulary, enhances pattern recognition skills, and challenges one's ability to think quickly.

## Understanding the Boggle Game:

Before we proceed with the implementation, let's establish a clear understanding of the rules and mechanics of the Boggle game:

• The game is played on a square grid board, usually 4x4 or 5x5, consisting of lettered dice.
• Players must form words by connecting adjacent letters horizontally, vertically, or diagonally.
• Each letter can be used only once within a single word.
• Words must be at least three letters long.
• Valid words are those that exist in a standard English dictionary.
• Players earn points based on the length of the words they find.

Suppose we have words in a Dictionary "ABC", "ABCD", "DEF", "DEFGH", "JKLM", "MNOP".

From this above Boggle Board, when we connect adjacent letter then we find words only "ABC", "ABCD" and "MNOP". Other words we can't find from the above Boggle Board.

## Finding All Possible Words

The allure of Boggle lies in discovering all the possible words hidden within the grid. While it may seem like an overwhelming task at first, various strategies can be employed to systematically uncover the vocabulary treasure.

• Exhaustive Search: The brute force method involves checking every possible combination of letters on the board against a dictionary. Although this approach guarantees finding all valid words, it is computationally expensive and not feasible for larger grids.
• Depth-First Search (DFS): This algorithm traverses the grid by exploring all possible paths from a starting point until no more words can be formed. It uses a recursive approach to efficiently search for words, backtracking when necessary. DFS can be optimized by incorporating data structures like tries or prefix trees to eliminate unnecessary exploration.
• Breadth-First Search (BFS): Similar to DFS, BFS explores the grid in a systematic manner, but it examines all possible paths at a given level before moving to the next level. BFS is particularly useful when a breadth-first traversal is desired, such as finding words of a specific length or prioritizing shorter words over longer ones.
• Word Lookup Optimization: To expedite the word-finding process, a lookup table or a trie data structure can be employed to store valid words from a dictionary. This enables quick checks to determine if a formed word is valid, significantly reducing the time required for search algorithms.
• Pruning Techniques: Boggle boards often contain clusters of letters that form prefixes or suffixes of words. By employing pruning techniques, such as identifying and skipping paths that cannot lead to valid words, the search space can be dramatically reduced, improving the efficiency of the word-finding process.

## Algorithmic Approach

To solve Boggle, we can use a backtracking algorithm combined with a trie data structure. The algorithm traverses the board, exploring all possible paths to form words. It checks if each path matches a valid word by searching through a dictionary stored in a trie.

Here are the high-level steps of the algorithm:

1. Build a trie data structure containing all the valid words in the dictionary.
2. Iterate through each cell on the board.
3. For each cell, perform a depth-first search (DFS) to explore all possible paths.
4. During the DFS, check if the current path forms a valid word by traversing the trie.
5. Mark visited cells to avoid reusing them in the same word.
6. Continue the DFS until all possible paths are explored.
7. Output all the valid words found during the search.

### Program:

Explanation:

• The constant SIZE is defined as 4, assuming a 4x4 grid for the Boggle board.
• Next, a structure called TrieNode is defined. It represents a node in the trie data structure. It contains an array of 26 TrieNode pointers, children, representing each letter of the alphabet, and a boolean flag, isWord, to indicate whether the node represents the end of a valid word.
• The insertWord function is defined to insert a word into the trie. It takes the root of the trie and a word as parameters. The function traverses the characters of the word and inserts them into the trie, creating new nodes as necessary. It sets the isWord flag of the last node to true to mark the end of the word.
• The dfs (depth-first search) function is defined to perform the search on the Boggle board. It takes the board, a current TrieNode in the trie, row and column indices, a 2D array of visited cells, the current word being formed, and a vector to store found words as parameters.
• Inside the dfs function, the base cases are checked: if the row or column indices are out of bounds or if the current cell has already been visited, the function returns.
• The character at the current cell is obtained from the board, and an index is calculated based on the assumption of uppercase letters. If the current node's child at the calculated index is nullptr, indicating that the letter is not a valid child, the function returns.
• If the current letter is a valid child, the cell is marked as visited, and the current letter is appended to the current word.
• If the child node at the calculated index represents the end of a valid word, the word is added to the vector of found words, and the isWord flag of that node is set to false to avoid duplicate entries.
• Arrays rowOffsets and colOffsets are defined to represent the eight possible directions to explore from the current cell: up, down, left, right, and the four diagonals.
• A loop is used to recursively call the dfs function for each valid direction from the current cell. The row and column indices are adjusted by adding the corresponding offset values.
• After the loop, the last character is removed from the current word, the current cell is marked as unvisited, and the function returns.
• The findWords function is defined to iterate over all cells in the Boggle board and initiate the depth-first search from each cell. It takes the board and the root of the trie as parameters.
• The findWords function initializes a 2D vector, visited, to keep track of visited cells. It also creates an empty vector, foundWords, to store the found words.
• Two nested loops iterate over each cell of the Boggle board, and for each cell, the dfs function is called to search for words starting from that cell.
• The findWords function returns the vector of found words.
• In the main function, the root of the trie is created, and a 4x4 Boggle board is defined using a vector of vectors.
• A dictionary of words is defined as a vector of strings.
• Each word from the dictionary is inserted into the trie using the insertWord
• The findWords function is called, passing the Boggle board and the trie root, and the returned vector of found words is stored in the foundWords

Program Output:

## Conclusion:

In conclusion, the game of Boggle, which involves finding all possible words in a board of characters, relies on the effective use of various data structures.

The primary data structure used in solving Boggle is typically a trie (prefix tree), which efficiently stores a large number of words and facilitates quick word lookups. The trie allows for efficient searching and validation of potential words formed by adjacent characters on the Boggle board.

Additionally, a graph-based data structure, such as a two-dimensional array or an adjacency list, is employed to represent the Boggle board itself. This structure enables efficient traversal of neighboring cells and exploration of different paths to form words.

By utilizing techniques such as depth-first search (DFS) or breadth-first search (BFS) algorithms, it becomes possible to systematically search for valid words while considering adjacent characters and avoiding revisiting the same cell multiple times.

Overall, the effective utilization of data structures is crucial in efficiently solving the Boggle game and finding all possible words on the board.