Leetcode面试题 17.13. 恢复空格——综合题：字典树+dp+倒序思想

引入

今天终于把面试题 17.13. 恢复空格这道放着好久没做的题给做了，确实做这样一道题要拐很多弯，需要一定量的积累。

题目就暂时不放出来了，拿到这道题的第一反应，我也确实想到了字典树（ps：刚才去翻了翻博客日志，居然没有写过字典树相关的介绍，一会在下文我会写上）。

使用字典树只是题解里面的一个步骤，看到挨个判断字符串的每个字符是否在字典里的时候，我又想到了回溯算法，也就是遍历的时候，对于每一个字符，去判断是否能从这个字符开始，单独形成一个单词。
简单的说，就比如"abcd"，字典[“ab”,“bc”]，在判断第二个字符b的时候，需要去考虑“ab”的情况和“bc”的情况，如果使用递归，就要单独弄出一个新的递归函数来判断“bc”的情况。

使用递归，估计复杂度过不了，应该还要使用一个剪枝。剪枝却十分麻烦，我有一个比较麻烦的思路，在此不做赘述了。另外，回溯需要传入的参数也是比较多的，不做推荐。

所以，这道题使用回溯，算是比较麻烦的情况。

俗话说的好，凡是能用回溯的地方，都能用dp，这道题dp很好假设：
dp[i]表示：前i个字符最多有dp[i]个字符没有被识别出来。
初始化条件也很简单，dp[0]=0就行了。

不过在考虑dp的时候，怎么去做状态转移方程呢？
一种方法是从j=0开始，判断j到i的字典有没有在字典树里，但是这种方法和使用Set没什么区别。
另一种很好的做法是，字典树倒序，从最后一个字符往前判断。这样只要有不匹配的情况，前面的肯定也是不匹配的了。

接下来就介绍下题解。

字典树

首先说说字典树，字典树其实就是树，含有26个字母的树。
树的节点如下：

	class Node {
        //字典树
        Node[] dict = new Node[26];
        boolean isEnd;

        public Node() {
            this.isEnd = false;
        }
    }

可以看出，其实就是个多叉树，其中加入了个isEnd的判断，用于表示一个单词是否到了结尾。

字典树的初始化方式如下：

        //初始化字典树
        Node dummy = new Node();
        for (String word : dictionary) {
            Node point = dummy;
            for (int i = word.length() - 1; i >= 0; i--) {//将单词倒序放入字典树
                int pos = word.charAt(i) - 'a';
                if (point.dict[pos] == null) point.dict[pos] = new Node();
                point = point.dict[pos];
                //如果是单词最后一个字符，那么单词结束
                if (i == 0) point.isEnd = true;
            }
        }

题解

使用倒序+字典树的方式会好很多，可以关注一下i和j是如何走的。
代码如下：

import java.util.*;

public class Solution {
    class Node {
        //字典树
        Node[] dict = new Node[26];
        boolean isEnd;

        public Node() {
            this.isEnd = false;
        }
    }

    public int respace(String[] dictionary, String sentence) {
        //初始化字典树
        Node dummy = new Node();
        for (String word : dictionary) {
            Node point = dummy;
            for (int i = word.length() - 1; i >= 0; i--) {//将单词倒序放入字典树
                int pos = word.charAt(i) - 'a';
                if (point.dict[pos] == null) point.dict[pos] = new Node();
                point = point.dict[pos];
                if (i == 0) point.isEnd = true;
            }
        }
        //使用动态规划，dp[i]表示前i个字母，未被识别的有dp[i]个。
        int LEN = sentence.length();
        int[] dp = new int[LEN + 1];
        //初始化dp[0]=0;
        for (int i = 0; i < sentence.length(); i++) {
            dp[i + 1] = dp[i] + 1;//首先默认在该位置没有匹配
            Node point = dummy;
            for (int j = i; j >= 0; j--) {
                int pos = sentence.charAt(j) - 'a';
                if (point.dict[pos] != null) {
                    point = point.dict[pos];
                    if (point.isEnd) {
                        //如果查找到一个单词
                        dp[i + 1] = Math.min(dp[j], dp[i + 1]);
                    } else {
                        //没有查找到单词，继续向前找
                        dp[i + 1] = Math.min(dp[j+1] + (i - j), dp[i + 1]);
                    }
                } else {
                    //说明查找不到单词了
                    dp[i + 1] = Math.min(dp[j+1] + (i - j), dp[i + 1]);
                    break;
                }
            }
        }
        return dp[LEN];
    }
}