Question

Ok, the real problem is slightly more complicated because it uses some classes that I’ve written instead of Strings, but it can be imagined like this: If you have a list of 700ish 3-letter words, how can I find every combination that can be formed by linking 5 of these words together by their first and last letters, i.e., CAT TOW WAR RAD DOG would be a success but so would CAT TOW WAR RAG GOD, and so on.

So far I have something like this:

for(int i = 0; i < list.size(); i++){
    String temp = chainMaker(list.get(i), list, used, temp);
}

public String chainMaker(String toAdd, ArrayList<String> unused,
    ArrayList<String> used, String result){

    if(result.size() >= 15)
        return result;
    else{
        if(result.canAdd(toAdd))
            result.add(toAdd);
        used.add(toAdd);

        return chainMaker(unused.remove(0), unused, used, result);
    }

    return result;
}

But this just keeps adding the producing rubbish. I’m terrible at recursive backtracking and I think that if I can just make this example work, I’ll finally understand this concept.
Please help me smart people!

Answer 1

Here’s a C++ implementation, but I think the logic is obvious. Just ask if you don’t understand something.

void letterChain(string stack[5], int k, const vector<string> &words)
{
    if ( k == 5 ) // have 5 words, print solution
    {
        for ( int i = 0; i < 5; ++i )
            cout << stack[i] << " ";
        cout << endl;

        return;
    }

    for ( int i = 0; i < words.size(); ++i ) // try to put a word at the current level of the stack
    {
        // if words[i] is already used, we cant use it again (if we can, just remove this part)
        bool used = false;
        for ( int j = 0; j < k; ++j )
            if ( stack[j] == words[i] )
                used = true;

        if ( !used ) // remove this if you can use a word multiple times
        {
            if ( k == 0 || words[i][0] == stack[k - 1][2] ) // if the letters match
            {
                stack[k] = words[i]; // add it to the stack
                letterChain(stack, k + 1, words); // recursive call
            }
        }
    }
}

int main()
{
    vector<string> words;
    words.push_back("CAT");
    words.push_back("TOW");
    words.push_back("WAR");
    words.push_back("RAD");
    words.push_back("DOG");
    words.push_back("GOD");
    words.push_back("RAG");
    words.push_back("RAR");

    string stack[5];

    letterChain(stack, 0, words);
}

CAT TOW WAR RAD DOG
CAT TOW WAR RAG GOD
CAT TOW WAR RAR RAD
CAT TOW WAR RAR RAG
TOW WAR RAD DOG GOD
TOW WAR RAG GOD DOG
TOW WAR RAR RAD DOG
TOW WAR RAR RAG GOD
WAR RAR RAD DOG GOD
WAR RAR RAG GOD DOG

If you can only use a word as many times as it appears in the list, then just use a counting vector subtract the count of that word every time you use it.