Longest String Chain

Given a list of words, each word consists of English lowercase letters.

Let's say word1 is a predecessor of word2 if and only if we can add exactly one letter anywhere in word1 to make it equal to word2.  For example, "abc" is a predecessor of "abac".

A word chain is a sequence of words [word_1, word_2, ..., word_k] with k >= 1, where word_1 is a predecessor of word_2, word_2 is a predecessor of word_3, and so on.

Return the longest possible length of a word chain with words chosen from the given list of words.

Example 1:

Input: ["a","b","ba","bca","bda","bdca"]
Output: 4
Explanation: one of the longest word chain is "a","ba","bda","bdca".

Note:

1. 1 <= words.length <= 1000
2. 1 <= words[i].length <= 16
3. words[i] only consists of English lowercase letters.

思路：dp的思想，建立hashmap<String, Integer> 表示：<单词，前面能够跟单词连接起来的最长的长度>

按照长度从小到大排序之后，对于每个单词，遍历减去一个char的所有可能性，看前面是否出现过此单词，如果出现当前单词长度+1.全局变量记录最大值；记录前面的单词结果，避免重复计算；

class Solution {
    public int longestStrChain(String[] words) {
        Arrays.sort(words, (a, b) ->(a.length() - b.length()));
        HashMap<String, Integer> hashmap = new HashMap<>();
        int maxlen = 0;
        for(int i = 0; i < words.length; i++) {
            String word = words[i];
            int localbest = 1;
            for(int j = 0; j < word.length(); j++) {
                String temp = word.substring(0, j) + word.substring(j + 1);
                if(hashmap.containsKey(temp)) {
                    localbest = Math.max(localbest, 1 + hashmap.get(temp));
                }
            }
            hashmap.put(word, localbest);
            maxlen = Math.max(maxlen, localbest);
        }
        return maxlen;
    }
}