A recursive backtracking problem

import java.math.BigInteger;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class SO3206795 {

    private static long ct;
    private static long time    = System.currentTimeMillis();

    private static List<String[]> allPossibleWords(final Set<String> words, final String[] chain) {
        final List<String> usedWords = Arrays.asList(chain);
        final int offset = usedWords.lastIndexOf(null);
        List<String[]> wordsList;
        if (offset < 0) {
            wordsList = Collections.singletonList(chain);
            logCreated();
        } else {
            wordsList = new ArrayList<String[]>();
            for (final String word : words) {
                if (!usedWords.contains(word)&&(offset==chain.length-1||isLegalNeighbor(word,usedWords.get(offset+1)))) {
                    final String[] copy = Arrays.copyOf(chain, chain.length);
                    copy[offset] = word;
                    wordsList.addAll(allPossibleWords(words, copy));
                }
            }
        }
        return wordsList;
    }
    private static List<String[]> getChains(final Set<String> words, final int length) {
        final List<String[]> tmpChain = new ArrayList<String[]>();
        final String[] chain = new String[length];
        tmpChain.addAll(allPossibleWords(words, chain));
        return tmpChain;
    }

    private static Set<String> getWords(final int numberOfWords, final int wordLength) {
        final Set<String> set=new TreeSet<String>();
        final Random r = new Random();
        while(set.size()<numberOfWords){
            final char[] ch = new char[wordLength];
            for (int i = 0; i < ch.length; i++) {
                ch[i]=(char) (65+r.nextInt(26));
            }
            set.add(new String(ch));
        }
        return set;
    }

    private static boolean isLegalNeighbor(final String left, final String right) {
        return left.charAt(left.length()-1)==right.charAt(0);
    }


    private static void logCreated() {
        if (++ct % 10000 == 0) {
            final long oldTime = time;
            time = System.currentTimeMillis();
            System.out.println("Created " + ct + " chains, duration: " + (time - oldTime));
        }
    }

    public static void main(final String[] args) {
        String[] usedArgs = args;
        if (args.length == 1 && args[0].matches(".*\\D.*")) {
            usedArgs = args[0].split("\\D+");
        }
        ;
        final int[] values = { 10, 3, 5 };
        for (int i = 0; i < usedArgs.length && i < values.length; i++) {
            values[i] = Integer.parseInt(usedArgs[i]);
        }
        final SO3206795 thing = new SO3206795(values[0], values[1], values[2]);
        for (final String[] chain : thing.chains) {
            System.out.println(Arrays.toString(chain));
        }
    }

    private static void printInfo(final int numberOfWords, final int wordLength, final int chainLength) {
        BigInteger words = BigInteger.valueOf(numberOfWords);
        for (int i = 1; i < chainLength; i++) {
            words = words.multiply(BigInteger.valueOf(numberOfWords - i));
        }

        System.out
        .println(MessageFormat
            .format(
                "Creating {0} words of length {1}.\nCreating all possible chains of {2} words.\nThat''s {3} chains in total",
                numberOfWords, wordLength, chainLength, words.toString()));
    }

    Set<String>     words;

    List<String[]>  chains;
    public SO3206795(final int numberOfWords, final int wordLength, final int chainLength) {

        printInfo(numberOfWords, wordLength, chainLength);
        this.words = getWords(numberOfWords, wordLength);
        this.chains = getChains(this.words, chainLength);
    }

}