Question

I have a 4×4 2D array of characters like this:

A B C D
U A L E
T S U G
N E Y I

Now, I would need to find all the permutations of 3 characters, 4 characters, etc till 10.

So, some words that one could “find” out of this are TEN, BALD, BLUE, GUYS.

I did search SO for this and Googled, but to no concrete help. Can you push me in the right direction in which algorithm I should learn (A* maybe?). Please be gentle as I’m no algorithms guy (aren’t we all (well, at least a majority :)), but am willing to learn just don’t know where exactly to start.

Answer 1

Ahhh, that’s the game Boggle isn’t it… You don’t want permutations, you want a graph and you want to find words in the graph.

Well, I would start by arranging the characters as graph nodes, and join them to their immediate and diagonal neighbours.

Now you just want to search the graph. For each of the 16 starting nodes, you’re going to do a recursion. As you move to a new node, you must flag it as being used so that you can’t move to it again. When you leave a node (having completely searched it) you unflag it.

I hope you see where this is going…

For each node, you will visit each of its neighbours and add that character to a string. If you have built your dictionary with this search in mind, you will immediately be able to see whether the characters you have so far are the beginning of a word. This narrows the search nicely.

The kind of dictionary I’m talking about is where you have a tree whose nodes have one child for each letter of the alphabet. The beauty of these is that you only need to store which tree node you’re currently up to in the search. If you decide you’ve found a word, you just backtrack via the parent nodes to work out which word it is.

Using this tree style along with a depth-first graph search, you can search ALL possible word lengths at the same time. That’s about the most efficient way I can think of.

---

Let me just write a pseudocodish function for your graph search:

function FindWords( graphNode, dictNode, wordsList )
    # can't use a letter twice
    if graphNode.used then return

    # don't continue if the letter not part of any word
    if not dictNode.hasChild(graphNode.letter) then return
    nextDictNode = dictNode.getChild(graphNode.letter)

    # if this dictionary node is flagged as a word, add it to our list
    nextDictNode.isWord()
        wordsList.addWord( nextDictNode .getWord() )
    end

    # Now do a recursion on all our neighbours
    graphNode.used = true
    foreach nextGraphNode in graphNode.neighbours do
        FindWords( nextGraphNode, nextDictNode, wordsList )
    end
    graphNode.used = false
end

And of course, to kick the whole thing off:

foreach graphNode in graph do
    FindWords( graphNode, dictionary, wordsList )
end

All that remains is to build the graph and the dictionary. And I just remembered what that dictionary data structure is called! It’s a Trie. If you need more space-efficient storage, you can compress into a Radix Tree or similar, but by far the easiest (and fastest) is to just use a straight Trie.