力扣刷题-面试题 17.13. 恢复空格、字典树、前缀树的应用

基本概念

  1. Trie 树

    又称单词查找树、前缀树,是一种树形结构。典型应用是用于统计、排序和保存大量的字符串(但不仅限于字符串)。它的优点是:利用字符串的公共前缀来减少查询时间,最大限度地减少无谓的字符串比较,比哈希表更快。

  2. 基本性质

    ①.根节点不包含字符,除根节点外每个节点都只包含一个字符

    ②.从根节点到某一节点,路径上经过的字符连接起来,为该节点对应的字符串

    ③.每个节点的所有子节点包含的字符都不相同

  3. 基本操作

    ①.插入:把一个单词插入到字典树

    ②.查询前缀:判断某个单词是否为一个单词的前缀

    ③.查询单词:判断某个单词是否已经存在

基本原理

  1. 字典树的本质

    Trie 树的本质,就是利用字符串之间的公共前缀,将重复的前缀合并在一起。

  2. 构建原理

    Trie 树的插入操作就是将单词的每个字母逐一插入Trie树。插入前先判断字母对应的节点是否存在,存在则移动到下一层继续插入,不存在则创建对应的节点。

实现方法

// TrieNode 节点类,由 a-z 小写字母构成的字典树
class TrieNode
{
private:
    int count;//包含子节点数量,可以用于判断是否叶子节点
    bool isEnd;//标记是否单词结尾
    vector children;//存储子节点指针
public:
    // 构造
    TrieNode():count(0),isEnd(false),children(26,NULL) {}
    // 析构
    ~TrieNode()
    {
        for(int i = 0;i < 26;i++ )
        {
            if( children[i] ) delete children[i];
        }
    }
    // 对外系列接口
    int size() { return count ;} // 返回子节点数量
    TrieNode* insertNode(char c) // 插入一个子节点,并返回其指针
    {
        if( c  <  'a' || c > 'z' ) return NULL;
        if( children[c - 'a'] == NULL)
        {
            children[c - 'a'] = new TrieNode();
            count++;
        }
        return children[c - 'a'] ;
    }
    TrieNode* getNode( char c )//返回指定子节点
    {
        if( c  <  'a' || c > 'z' ) return NULL;
        return children[c - 'a'] ;
    }
    bool idWordEnd(){ return isEnd;}//返回是否单词结尾
    void setEnd() { isEnd = true ;}//标记本节点为单词结尾
};
// Trie 类,封装操作接口
class Trie {
private:
    TrieNode * root;//根节点
public:
    // 构造
    Trie() : root( new TrieNode() ){}
    // 析构
    ~Trie()
    {
        delete root;
    }
    // 插入一个单词
    void insert(string word) {
        TrieNode * p = root;
        for(int i = 0;i < word.size();i++ )
        {
            p = p->insertNode(word[i]);
        }
        p->setEnd() ;
    }
    //逆序插入一个单词
    void insertReverse(string word) {
        TrieNode * p = root;
        for(int i = word.size() -1;i >-1;i-- )
        {
            p = p->insertNode(word[i]);
        }
        p->setEnd() ;
    }
    //根据单词返回节点
    TrieNode *getNode(string word)
    {
        TrieNode * p = root;
        for(int i = 0;i < word.size();i++ )
        {
            p = p->getNode(word[i]) ;
            if( p == NULL ) return NULL;
        }
        return p;
    }
    // 判断指定单词是否存在
    bool search(string word) {
        TrieNode * p = getNode(word);
        if( p )
        	return  p->idWordEnd();
        return false;
    }
    //判断指定前缀是否存在
    bool startsWith(string prefix) {
        TrieNode * p = getNode(prefix);
        return p != NULL;
    }
};

字典树应用

你不小心把一个长篇文章中的空格、标点都删掉了,并且大写也弄成了小写。像句子"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个未识别字符。

来源:力扣(LeetCode)

  1. 题目分析

    ①.动态规划

    定义 dp[i] 表示考虑截止到位置 i 时最少的未识别的字符数量。

    为方便初始化,在字符串开头增加一个不可识别字符 “#”,则dp[0] = 1。

    若存在一个位置 j 把前 i 个字符构成的子串 [0,i] 分为两部分,并且子串 [j,i] 是字典里的单词,如下图所示:

    力扣刷题-面试题 17.13. 恢复空格、字典树、前缀树的应用_第1张图片

    dp[i] 可以转换成 dp[j-1],遍历找到所有的 j ,然后dp[i] 取所有 j 位置的最小值即可,所以状态转移方程为dp[i] = min(dp[i],dp[j-1]);

    若不存在一个位置 j,则 dp[i] = dp[i-1] + 1。

    ②.字典树

    用 j 在范围 [0,i] 遍历所有子串 [j,i] 时,每次都从头到尾截取子串,存在大量的重复判断,可以使用字典树进行优化:
    从 j = i 开始倒叙遍历,若 [j,i] 不是字典是中的前缀,则直接中断循环即可,若 [j,i] 是字典是中的前缀,再判断是否是字典中的单词。

  2. 代码示例

    class TrieNode
    {
    private:
        int count;//包含子节点数量,可以用于判断是否叶子节点
        bool isEnd;//标记是否单词结尾
        vector children;//存储子节点指针
    public:
        // 构造
        TrieNode():count(0),isEnd(false),children(26,NULL) {}
        // 析构
        ~TrieNode()
        {
            for(int i = 0;i < 26;i++ )
            {
                if( children[i] ) delete children[i];
            }
        }
        // 对外系列接口
        int size() { return count ;} // 返回子节点数量
        TrieNode* insertNode(char c) // 插入一个子节点,并返回其指针
        {
            if( c  <  'a' || c > 'z' ) return NULL;
            if( children[c - 'a'] == NULL)
            {
                children[c - 'a'] = new TrieNode();
                count++;
            }
            return children[c - 'a'] ;
        }
        TrieNode* getNode( char c )//返回指定子节点
        {
            if( c  <  'a' || c > 'z' ) return NULL;
            return children[c - 'a'] ;
        }
        bool idWordEnd(){ return isEnd;}//返回是否单词结尾
        void setEnd() { isEnd = true ;}//标记本节点为单词结尾
    };
    // Trie 类,封装操作接口
    class Trie {
    private:
        TrieNode * root;//根节点
    public:
        // 构造
        Trie() : root( new TrieNode() ){}
        // 析构
        ~Trie()
        {
            delete root;
        }
        // 插入一个单词
        void insert(string word) {
            TrieNode * p = root;
            for(int i = 0;i < word.size();i++ )
            {
                p = p->insertNode(word[i]);
            }
            p->setEnd() ;
        }
        //逆序插入一个单词
        void insertReverse(string word) {
            TrieNode * p = root;
            for(int i = word.size() -1;i >-1;i-- )
            {
                p = p->insertNode(word[i]);
            }
            p->setEnd() ;
        }
        //根据单词返回节点
        TrieNode *getNode(string word)
        {
            TrieNode * p = root;
            for(int i = 0;i < word.size();i++ )
            {
                p = p->getNode(word[i]) ;
                if( p == NULL ) return NULL;
            }
            return p;
        }
        // 判断指定单词是否存在
        bool search(string word) {
            TrieNode * p = getNode(word);
            if( p )
            	return  p->idWordEnd();
            return false;
        }
        //判断指定前缀是否存在
        bool startsWith(string prefix) {
            TrieNode * p = getNode(prefix);
            return p != NULL;
        }
        //
    };
    class Solution {
    public:
        int respace(vector& dictionary, string sentence) {
            Trie * trie = new Trie();
            for(int i = 0;i < dictionary.size();i++ )
            {
                string word = dictionary[i];
                trie->insertReverse(word);
            }
            sentence = '#'+sentence;
            vector dp(sentence.size(),0);
            dp[0] = 1;
            for( int i = 1;i < sentence.size();i++)
            {
                dp[i] = dp[i-1]+1;
                string temp = "";
                for(int j = i;j > -1;j--)
                {
                    temp += sentence[j] ;
                    TrieNode * p = trie->getNode(temp);
                    if( p  ) //是后缀
                    {
                        if( p->idWordEnd() )
                            dp[i] = min(dp[i],dp[j-1]);
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return dp[sentence.size()-1] -1 ;
        }
    };
    

你可能感兴趣的:(算法与数据结构,力扣刷题,#,字典树,leetcode,C++,字典树,算法)