Compsci 201 Recitation 10

Professor Peck
Jimmy Wei
3/28/2014

In this Recitation
Boggle warmup!
Intro
Tries
Recursion
Submit via form: http://goo.gl/4kBYqY
Boggle Intro
What is Boggle?
You will be writing recursive code to find all
words on a Boggle Board which looks like this:
Boggle Intro
Whats in Boggle?
BoggleBoard: represents a 2D grid of board
values
BoardCell: represents a single cell on the board
does NOT hold cell value, only its coordinates
LexStatus: enumeration representing if a String is
a WORD, PREFIX, or NOT_WORD
Boggle intro
ILexicon: represents a lexicon, i.e. all valid
words; think of it as our dictionary
We will work with the TrieLexicon implementation
today
IWordOnBoardFinder: searches for all valid
words on a given board; used by computer after
player completes turn
We will work with the GoodWordOnBoardFinder
implementation today
Other classes not needed for this recitation but
important for the actual assignment

Boggle Intro
Two questions we will address:
How can we represent our lexicon, i.e. the list of
all valid words?
How can we recursively search the board to find
all valid words on the board?
Boggle Tries
First question: How to represent the lexicon?
Consider a trie, utilized in TrieLexicon.java:
This trie represents:
Dog
Dot
Doting
Drag
Drastic
Top
Torn
Trap

Boggle Tries
This trie supports queries
(add, contains, delete) in
O(w) time for words of
length w.
Each node in a trie has
one subtrie for every
following letter
How would you add
Duke to the trie?
Red dots indicate nodes
holding the final letter of
a word

Boggle Trie Add
boolean add(String s) {
Node t = myRoot;
for (int k=0; k<s.length(); k++) {
char ch = s.charAt(k);
Node child = t.children.get(ch);
if (child == null) {
child = new Node(ch, t);
t.children.put(ch, child);
}
t = child;
}
if (!t.isWord) {
t.isWord = true; // mark as word
mySize++;
return true;
}
return false; //word already in trie
}

Boggle Trie WordStatus
LexStatus wordStatus(String s) {
Node t = myRoot;
for (int k=0; k<s.length(); k++) {
char ch = s.charAt(k);
t = t.children.get(ch);
if (t == null) {
return
LexStatus.NOT_WORD;
}
}
if (t.isWord) {
return LexStatus.WORD;
} else {
return LexStatus.PREFIX;
}
}

Boggle Tries Answer #1
LexStatus wordStatus(String s) {
Node t = myRoot;
for (int k=0; k<s.length(); k++) {
char ch = s.charAt(k);
t = t.children.get(ch);
if (t == null) {
return
LexStatus.NOT_WORD;
}
}
if (t.isWord) {
return LexStatus.WORD;
} else {
return LexStatus.PREFIX;
}
}

boolean add(String s) {
Node t = myRoot;
for (int k=0; k<s.length(); k++) {
char ch = s.charAt(k);
Node child = t.children.get(ch);
if (child == null) {
child = new Node(ch, t);
t.children.put(ch, child);
}
t = child;
}
if (!t.isWord) {
t.isWord = true; // mark as word
mySize++;
return true;
}
return false; //word already in trie
}
Boggle Tries Answer #2
public class Node {
String info;
boolean isWord;
Map<Character,Node> children;
Node parent;

Node(char ch, Node p) {
info = +ch;
isWord = false;
children = new TreeMap<Character,Node>();
parent = p;
}
}

Boggle Tries Answer #3
private Node copyTrie(Node root) {
if (root == null) {
return null;
}
Node copy = new Node(root.info.charAt(0), null);
copy.isWord = root.isWord;

// more code to copy rest of trie

return copy;
}

Boggle Tries Answer #4
private int wordCount(Node root) {
if (root == null) {
return 0;
}

// more code to count words in trie
// use the isWord field to check each Node

}

Boggle Tries Answer #5
Look at the
compressed trie to
the right:
We have combined
chains of single
pointers into single
Nodes
We want to figure
out how to perform
this compression


Boggle Recursion
Second question: How to recurse over board?
Look at the following code for implementing
GoodWordOnBoardFinder.java:
List<BoardCell> cellsForWord(BoggleBoard board, String word)
{
ArrayList<BoardCell> list = new ArrayList<BoardCell>();
for (int r=0; r<board.size(); r++) {
for (int c=0; c<board.size(); c++) {
if (findHelper(word, 0, r, c, board, list)) {
return list;
}
}
}
list.clear();
return list;
}
Boggle Recursion
Here is the header for the helper method:
/**
* Returns true if and only if the substring of word starting at index can be
* formed starting at (row, col) on the board provided without using any cells
* stored in list --- and extending list to include all cells on which substring is
* found when true is returned.
* @param word is searched for word (e.g. entered by user)
* @param index is where in word substring starts, e.g. all chars before index
* have been found and cells are in list
* @param row is starting point for search
* @param col is starting point for search
* @param board is board on which word is searched
* @param list is cells on board where word is found
* @return true if substring found on board without reusing board cells in list
*/
private boolean findHelper(String word, int index, int row, int col,
BoggleBoard board, List<BoardCell> list);
Boggle Recursion
An example:
Say we are searching for PEST
String word = PEST
Int index = 3
Int row = 2
Int col = 1
BoggleBoard board = [NIEF, PTTO, ESWE,
MRNO]
This String array is held as an instance variable of a
BoggleBoard object
List<BoardCell> list = [(1,0); (2,0); (2,1)]
Each item in this list is actually a BoardCell object with two
instance variables, int row and int col

Boggle Recursion Answer #6-
11
// Returns true if and only if the substring of word starting at index can be formed
// starting at (row, col) on the board provided without using any cells stored in list
// Must extend list to include all cells on which substring is found when true
// @param word is searched for word (e.g. entered by user)
// @param index is where substring starts
// @param row is starting point for search
// @param col is starting point for search
// @param board is board on which word is searched
// @param list is cells on board where word is found
// @return true if substring found on board without reusing board cells in list
private boolean findHelper(String word, int index, int row, int col,
BoggleBoard board, List<BoardCell> list);
List<BoardCell> cellsForWord(BoggleBoard board, String word) {
ArrayList<BoardCell> list = new ArrayList<>();
for (int r=0; r<board.size(); r++)
for (int c=0; c<board.size(); c++)
if (findHelper(word, 0, r, c, board, list)) { return list; }
list.clear();
return list;
}
Have a good weekend!
Dont forget to submit!