算法题：恢复空格（题目+思路+代码+注释）

记忆法+Tire字典树

题目

面试题 17.13. 恢复空格
哦，不！你不小心把一个长篇文章中的空格、标点都删掉了，并且大写也弄成了小写。像句子"I reset the computer. It still didn’t boot!“已经变成了"iresetthecomputeritstilldidntboot”。在处理标点符号和大小写之前，你得先把它断成词语。当然了，你有一本厚厚的词典dictionary，不过，有些词没在词典里。假设文章用sentence表示，设计一个算法，把文章断开，要求未识别的字符最少，返回未识别的字符数。

注意：本题相对原题稍作改动，只需返回未识别的字符数

示例：

输入：
dictionary = [“looked”,“just”,“like”,“her”,“brother”]
sentence = “jesslookedjustliketimherbrother”
输出： 7
解释： 断句后为"jess looked just like tim her brother"，共7个未识别字符。
提示：

0 <= len(sentence) <= 1000
dictionary中总字符数不超过 150000。
你可以认为dictionary和sentence中只包含小写字母。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/re-space-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

• 将这个问题分解为两个问题，
• 一个是判断是不是单词的字符串比对问题，一个是最少未知字符计算问题
• 首先判断一个字符串是否是一个字符串数组中的某个字符串问题，将单词字母做成一个字典树查找的效率会提升很多，因此我们建立Tire字典树用来实现判定是不是单词
• 求这个字符串的最少未知字符问题根据记忆法减少运算的思路，求长度为n的字符串的最少未知字符问题可以变为可以变为求前n-1个字符串的最少未知数+1，另外如果这个字符向前能匹配到单词的话，则等于这个位置向前匹配到单词位置的最少未知数，文字形容不太贴切，直接上案例
• 我们定义第i个字符的最少未知字符数为 d[i]
• 第一种说的：
• 单词 [“hello”,“world”]
• 语句：“ihellot” 例如第7个字符位置的最少未知字符数d[7]=d[6]+1=1+1=2
• 第二种说的，向前匹配
• 例如第6个字符位置的最少未知字符数d[6]，向前匹配到5个字符的时候匹配到了单词hello，则d[6]=d[6-5]=d[1]，而d[1]等于1，则d[6]=d[1]=1
• 用这样的方式利用前面计算过的不再重复计算的方法，能够减少大量的不必要运算
• 因此我们遍历每个位置字符，算出每个位置上的最少未知字符数，则最后一个位置的最少位置字符数就是整个字符串的最少未知字符数
• 而在算这个位置的时候，可以从这个位置向前找n个字符试图去匹配成单词，不断和已有的最小值比对，取最小的，以此来找到这个位置的最少未知字符数

代码

public int respace(String[] dictionary, String sentence) {
        //特殊情况
        if (sentence.length() ==0){
            return 0;
        }
        if (dictionary.length == 0){
            return sentence.length();
        }
        //读取单词生成字典树
        Tire tree = new Tire();
        tree.addWords(dictionary);

        //开始搜索
        int len =sentence.length();
        //记录[0-第i个字母]的最少未知字符数,由于后面我们会用到   第i个位置的最少未知字符等于第i-1个位置的最少的未知字符+1，作为最差情况，那第1个就需要第0个，而第0个是0则符合循环体执行
        //比如现在在第5个字符，如果向前匹配两个字符成功了，那就是现在的最少未知数等于第 5-2也就是第3个字符位置上的最少未知字符数，这样利用前面已经做过的计算，减少计算。记忆法！！！
        int[] d = new int[len+1];
        //假设每个都是没办法识别的单词，作为初始值
        for (int i = 0,arrayLength=d.length; i< arrayLength;i++){
            d[i] = i;
        }
        //等下加入单词长度可能性限制，减少运算  1 2 3 4 5     匹配到45  i=5  j=2  d[5]最小值就等于 d[5-2] 和 d[5]的最小值
        //第一层循环是从算第多少个字符的最少未知字符数量
        for (int i = 1;i<=len;i++){
            //第二层循环是从第i个字符向前取几个字符尝试组成单词，尝试成功则当前位置最少未知字符数等于前面那个位置的数量和自己当前已经找到的最少数量的最小值
            for (int j =1; j<=i;j++){
                if (tree.hasSubString(sentence,i-j,i)){
                    d[i] = Math.min(d[i-j],d[i]);
                }else {
                    d[i] = Math.min(d[i-1]+1,d[i]);
                }
            }
        }
        return d[len];
    }

    static class Tire {
        private TireNode root = new TireNode();

        /**
         * 题中需要抽象的两个函数，一个是加入单词
         * @param strs
         */
        public void addWords(String[] strs){
            for (String s: strs){
                root.addWord(s);
            }
        }

        /**
         * 题中需要抽象的两个函数，另一个是判断这个子字符串是不是个单词，而我不想切割字符串就这样了，给下标
         * @param word
         * @param start
         * @param end
         * @return
         */
        public boolean hasSubString(String word,int start, int end){
            TireNode tmp = root;
            while (start<end){
                int j = word.charAt(start)-'a';
                if (tmp.nodes[j]==null){
                    return false;
                }
                tmp = tmp.nodes[j];
                start++;
            }
            if (tmp.isEnd()){
                return true;
            }
            return false;
        }
    }

    /**
     * tire字典树的节点
     */
    static class TireNode {
        boolean end = false;
        TireNode[] nodes = new TireNode[26];
        public void addWord(String word){
            addWord(word,word.length(),0);
        }
        private  void addWord(String word,int len,int i){
            int j = word.charAt(i)-'a';
            if (nodes[j]==null){
                nodes[j]= new TireNode();
            }
            i++;
            //最后一个单词
            if (i==len){
                nodes[j].setIsEnd();
                return;
            }
            if (i<len){
                nodes[j].addWord(word,len,i);
            }
        }
        public void setIsEnd(){
            this.end = true;
        }
        public boolean isEnd(){
            return end;
        }
    }

思考：我们每次向前尝试的时候是每次+1，而我们可以在读取字典的时候记录下单词的长度，这样尝试的时候只尝试这些长度，则可以减少运算量，另外字典树还可以根据不同长度的字符串建立不同的字典数以加速查找，我的测试中，这样可以减少运算量，加快速度，不采用这种方式的时候180ms，采用这个优化之后111ms。