/**
 * Given some iterable object that provides strings, find the longest
 * string in the collection that can be reached from the empty string
 * by adding one character at a time such that every intermediate step
 * is also in the collection.
 *
 
 * For example, if the collection is {@code {@literal {}a,
 * at, cat, chat, chart, cart, car{@literal }}},
 * then the longst word is {@code chart}, and it's derivation is:
 * {@code a => at => cat => cart => chart}.  If there are multiple
 * longest words, then only one is detected.
 *
 
 * Note that if single letters are not in the collection, then no words
 * can be derived, and only the empty derivation is returned.
 *
 * @param strings    An iterable providing the strings.
 * @return    The derivation of the longest, from the shortest word to the
 *             longest.  If there is no longest word, then the empty
 *             derivation is returned.
 */
public List search(Iterable strings) {
    if (strings == null) {
        throw new NullPointerException("The string iterator is null.");
    }
 
    // Read each string from the iterable.  The strings assumed to be
    // single words, and the words are not assumed to occur in any
    // particular order.  We put the words we read into a heap, ordered
    // by length.  Our "heap" is a sorted map.
    //
    // Every entry in the map has an associated integer value, which
    // tells us the position of the last inserted character.  This can
    // be used to "unwind" the derivation of the word.  If there is not
    // (yet) any way to reach the word, then the word is mapped to -1.
    TreeMap heap =
        new TreeMap(new Comparator() {
            public int compare(String first, String second) {
                // Okay, we sort first by length, and then alphabetically.
                // This is necessary because of the way TreeMap tests
                // equality; it uses the comparator.  Thus we must only
                // return zero if the two are actually equal.  So, we
                // first order by length, and then for items of the same
                // length, we order using the natural comparator for
                // strings.
                int order = first.length() - second.length();
                if (order == 0) {
                    order = first.compareToIgnoreCase(second);
                }
                return order;
            }
        });
    for (String str : strings) {
        heap.put(str,-1);
    } // Add all strings to the heap.
 
    // Prime the pump by adding the empty string as "reachable."
    String longest = "";
    int length = 0;
    heap.put("", 0);
 
    // At this point the heap is constructed.  We now iterate over the
    // heap looking for connected words.  If we find one, we mark it.
    for (String str : heap.keySet()) {
        // Watch for a case where we skip a length.  If we do, we're done.
        if (str.length() > length+1) {
            break;
        }
        length = str.length();
 
        // Now we have a string, we need to find out if the string is
        // reachable from a previously-reached string.  We drop each
        // character, and then check if the resulting string is
        // present in the heap and is marked.
        for (int index = 0; index < str.length(); index++) {
            // Omit the character at position index.
            String test = str.substring(0,index) + str.substring(index+1);
            // See if the resulting test string is in the heap.
            Integer pos = heap.get(test);
 
            // Now there are three cases:
            // (1) The test string is not in the heap.
            // (2) The test string is in the heap, but not reachable.
            if (pos == null || pos < 0) {
                continue;
            }
            // (3) The test string is in the heap, and is reachable.
            // In this last case we know we can reach the current string
            // from the test string by adding the character at position
            // index, so put this in the heap.
            heap.put(str, index);
            // Note that whenever this happens, we might have just found
            // (one of) the longest words, so save it.
            longest = str;
            // We don't need to test any other positions.
            break;
        } // Construct new words by omitting each character.
    } // Search the heap for words.
 
    // Now we have (hopefully) found a long word.  We need to generate
    // the derivation and return it.
    List derivation = new LinkedList();
    while (longest.length() > 0) {
        // Get the insertion position from the heap.
        int pos = heap.get(longest);
        // Add the word to the derivation.
        derivation.add(0, longest);
        // Generate the prior string in the derivation.
        longest = longest.substring(0, pos) + longest.substring(pos+1);
    } // Build the derivation.
 
    // Done!  Return the derivation.
    return derivation;
}