[hihocoder1036]Trie图

最新推荐文章于 2018-12-03 21:22:56 发布
最新推荐文章于 2018-12-03 21:22:56 发布
阅读量330 收藏
点赞数
分类专栏： hihocoder 文章标签： hihocoder Trie
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silent56_th/article/details/53448581
版权

问题简介

给定词典，求给定文章内部是否含有词典中的单词。
具体问题请参考 hihocoder的网站。

算法简介

详细的算法思路参照 hihocoder的网站。
Trie树大致上是共前缀的树（具体参照 [hihocoder1014]Trie树），Trie图则是维护后缀前缀重叠最长的信息（这里结合了 KMP的思想，KMP可以看做是词典只有一个词的Trie树；KMP也是维护字符串前缀后缀最长重叠部分，之后加入短路）。Trie图的目的是减少比较次数，充分利用已知信息。

数据结构

1. 节点Node

1.1. 内部变量

对应于Trie图中的某个节点，这个结构存储几乎所有的Trie图中的信息，包括：
  1. 节点对应字符串的前缀（包括原串）是否有词典中的单词bool flag。
  2. 指向子节点以及如果没有子节点时所应该跳转到的节点Node* next[26]。例如当前节点对应于字符串str，新字符'b'在Trie树中不存在子节点，则next['b']对应于所有节点中对对应字符串是str+'b'的后缀且长度最长（在Trie树中深度最深）的节点。
  3. 区分指向边是否存在于Trie树中的标志，即是指向子节点还是跳转节点。bool flags[26]
  4. 所有节点中对应字符串是该节点对应字符串str的后缀且长度最长（深度最深）的节点Node *trie。
  5. 测试用的变量：父节点Node* parent，节点编码int num。

1.2. 内部函数

  1. 构造函数：就是给变量赋初值。
  2. 析构函数：空函数
  3. 复制构造函数：复制变量。
  4. 递归delete的函数clean：用于清空new的Node。
  5. 插入字符串函数insert(char *str):str指向于当前节点与父节点之间边的字符，str+1用于表面递归插入的方向。insert函数需要维护flag, next, next->parent几个变量。
  6. 设置flag的函数set_flag(): 在所有插入函数结束之后调用，用于维护flag，即该节点对应字符串的前缀中是否含有词典中的单词。注：此处是递归版本，为了加速，已弃用。
  7. 测试用print()函数：输出节点内部信息。
struct Node{
    bool flags[26],flag;
    Node *next[26],*parent,*trie;
//    int parent_index;

    int num;//for test

public:
    Node():flag(false),parent(NULL),trie(NULL),num(-1){
        for (int i = 0;i < 26;++i){
            flags[i] = false;
            next[i] = NULL;
        }
    }
    Node(const Node &n):flag(n.flag),parent(n.parent),trie(n.trie),num(n.num){
        for (int i = 0;i < 26;++i){
            flags[i] = n.flags[i];
            next[i] = n.next[i];
        }
    }
    ~Node() {}

    void clean();
    void insert(char *str);
    void set_flag(bool f);
    //for test
    void print();
};


2. Trie图 TrieGraph

2.1. 内部变量

存储根节点即可

2.2. 内部函数

  1. 构造函数：空函数
  2. 析构函数：调用Node.clean()函数
  3. 插入函数insert()：递归调用法，调用Node.insert()
  4. 设置整个图节点flag的设置set_flag()：深度优先的迭代算法
  5. 由Trie树构造Trie图的函数build_graph()：具体参照详细算法部分。
  6. 利用Trie图检测输入字符串中是否有词典中的词语test(char *str)：根据字符串，逐步前进，判断是否行进到flag=true的节点。
  7. 测试用print()函数：输出树中某些节点内部的信息。
class TrieGraph{
    Node root;
public:
    TrieGraph() {}
    ~TrieGraph() {root.clean();}

    void insert(char *str);
    void set_flag();
    void build_graph();
    bool test(char *str);
    void print();
};

算法详解

为了方便复杂度的表示，设字典中单词的个数为N，长度最长为L，文章长度为M。

1. 构建Trie树的insert(char *str)函数

使用递归算法，*str决定了插入的子节点。具体参照 [hihocoder1014]Trie树。复杂度为O(L) 
    void insert(char *str){
        if (!*str)
            flag = true;
        else {
            if (!next[*str-'a']){
                next[*str-'a'] = new Node;
                flags[*str-'a'] = true;
                next[*str-'a']->parent = this;
            }
            next[*str-'a']->insert(str+1);
        }
    }

2. 设置flag的set_flag()函数

使用迭代算法实现深度优先遍历所有节点，子节点Node的flag=Node.flag || Node.parent->flag。复杂度O(NL) 
    void set_flag(){

        stack<Node*> node_stack;
        Node *node = &root;

        node_stack.push(node);
        char str[100002] = {0};
        int depth = 0,str_char;
        bool flag = false;
        while (!node_stack.empty()){
            flag = node_stack.top()->flag;
            node = node_stack.top();
            for (str_char=(str[depth]?str[depth]+1:'a');str_char<='z' && !node->flags[str_char-'a'];++str_char);
            if (str_char == 'z'+1){
                node_stack.pop();
                str[depth--] = 0;
            }
            else {
                node_stack.push(node->next[str_char-'a']);
                flag = flag || node->next[str_char-'a']->flag;
                node->next[str_char-'a']->flag = flag;
                str[depth++] = str_char;
            }
        }
    }

3. 构建Trie图build_graph()

回顾next以及trie的定义：某个节点Node根据其与根节点的路径唯一确定一个字符串str，那么trie指向的是所有节点中是str后缀且长度最长的节点；而next[char]如果是Trie树中的边则指向其子节点，否则指向所有节点中是str+char后缀且长度最长的节点（这里的两个定义在拓展后缀定义（即包含原串）的意义下是等价的，分开定义是方便函数处理）。
根据定义，可以很容易给出一种朴素的解法，即由长到短枚举所有后缀，判断是否有对应节点。复杂度为O(N*L*L*L)
分析可知这种朴素的算法有很多重复计算，字符串的trie以及next可以利用其前缀的trie以及next信息。具体来说，设len=strlen(str)，那么str的最长存在后缀为str[0:len-1]+str[len-1]的最长存在后缀，即trie(str)=next(str[0:len-1])[str[len-1]]；而str+char的最长重复后缀对应于trie(str)+char的最长重复后缀（这里是广义定义的后缀，即包含原串），即next(str)[char]=next(trie(str))[char]。综上所述，使用广度优先遍历所有节点，既可以快速的构建Trie图。复杂度为O(N*L) 
    void build_graph(){
        queue<Node*> node_queue;
        Node *node;

        //for test
        int cnt = 0;
        root.num = cnt++;

        root.trie = &root;
        for (int i = 0;i < 26;++i){
            if (root.flags[i]){
                node_queue.push(root.next[i]);

                //for test
                root.next[i]->num = cnt++;

                root.next[i]->trie=&root;
            }
            else
                root.next[i] = &root;
        }

        while (!node_queue.empty()){
            node = node_queue.front();
            node_queue.pop();
            for (int i = 0;i < 26;++i){
                if (node->flags[i]){
                    node_queue.push(node->next[i]);

                    //for test
                    node->next[i]->num = cnt++;

                    node->next[i]->trie = node->trie->next[i];
                }
                else
                    node->next[i]=node->trie->next[i];
            }
        }
    }

4. 判断给定文章是否含有词典中词语bool test(char *str)

依次按照字符串中的字符在Trie图中移动，如果移动到flag=true的节点，则返回true；否则返回false。复杂度为O(M) 
    bool test(char *str){
        Node *node = &root;

        while (*str){

            //for test
//            cout << node->num << endl;

            node = node->next[*str-'a'];
            if (node->flag)
                return true;
            ++str;
        }
        return false;
    }

5. 主函数

构建Trie树(O(NL))-->设置flag(O(NL))-->构建Trie图(O(NL))-->判断文章是否含有词典中的词语O(M)。整体复杂度为O(NL+M)。 
int main()
{
    char str[1000002];
    int N;
    TrieGraph trieGraph;
    cin >> N;
    for (int i = 0;i < N;++i){
        cin >> str;
        trieGraph.insert(str);
    }
    trieGraph.set_flag();
    trieGraph.build_graph();

    cin >> str;
    cout << ((trieGraph.test(str))?"YES":"NO") << endl;

//    trieGraph.print();
    return 0;
}

全部代码

#include <iostream>
#include <cstring>
#include <queue>
#include <stack>

using namespace std;

struct Node{
    bool flags[26],flag;
    Node *next[26],*parent,*trie;
//    int parent_index;

    int num;//for test

public:
    Node():flag(false),parent(NULL),trie(NULL),num(-1){
        for (int i = 0;i < 26;++i){
            flags[i] = false;
            next[i] = NULL;
        }
    }
    Node(const Node &n):flag(n.flag),parent(n.parent),trie(n.trie),num(n.num){
        for (int i = 0;i < 26;++i){
            flags[i] = n.flags[i];
            next[i] = n.next[i];
        }
    }
    ~Node() {}

    void clean(){
        for (int i = 0;i < 26;++i)
        if (flags[i]){
            next[i]->clean();
            delete next[i];
        }
    }

    void insert(char *str){
        if (!*str)
            flag = true;
        else {
            if (!next[*str-'a']){
                next[*str-'a'] = new Node;
                flags[*str-'a'] = true;
                next[*str-'a']->parent = this;
//                next[*str-'a']->parent->parent_index = *str-'a';
            }
            next[*str-'a']->insert(str+1);
        }
    }

    void set_flag(bool f){
        flag = f || flag;
        for (int i = 0;i < 26;++i)
            if (flags[i])
                next[i]->set_flag(flag);
    }

    //for test
    void print(){
        cout << num << ": ";
        for (int i = 0;i < 26;++i)
            cout << next[i]->num << '/' << flags[i] << ' ';
        cout << endl;
    }
};

class TrieGraph{
    Node root;
public:
    TrieGraph() {}
    ~TrieGraph() {root.clean();}

    void insert(char *str){
        if (!*str)
            root.flag = true;
        else {
            if (!root.next[*str-'a']){
                root.next[*str-'a'] = new Node;
                root.flags[*str-'a'] = true;
                root.next[*str-'a']->parent = &root;
//                root.next[*str-'a']->parent_index = *str-'a';
            }
            root.next[*str-'a']->insert(str+1);
        }
    }

    void set_flag(){
//        root.set_flag(false);

        stack<Node*> node_stack;
        Node *node = &root;

        node_stack.push(node);
        char str[100002] = {0};
        int depth = 0,str_char;
        bool flag = false;
        while (!node_stack.empty()){
            flag = node_stack.top()->flag;
//            cout << str << endl;
            node = node_stack.top();
            for (str_char=(str[depth]?str[depth]+1:'a');str_char<='z' && !node->flags[str_char-'a'];++str_char);
            if (str_char == 'z'+1){
                node_stack.pop();
                str[depth--] = 0;
            }
            else {
                node_stack.push(node->next[str_char-'a']);
                flag = flag || node->next[str_char-'a']->flag;
                node->next[str_char-'a']->flag = flag;
                str[depth++] = str_char;
            }
        }
    }

    void build_graph(){
        queue<Node*> node_queue;
        Node *node;

        //for test
        int cnt = 0;
        root.num = cnt++;

        root.trie = &root;
        for (int i = 0;i < 26;++i){
            if (root.flags[i]){
                node_queue.push(root.next[i]);

                //for test
                root.next[i]->num = cnt++;

                root.next[i]->trie=&root;
            }
            else
                root.next[i] = &root;
        }

        while (!node_queue.empty()){
            node = node_queue.front();
            node_queue.pop();
            for (int i = 0;i < 26;++i){
                if (node->flags[i]){
                    node_queue.push(node->next[i]);

                    //for test
                    node->next[i]->num = cnt++;

                    node->next[i]->trie = node->trie->next[i];
                }
                else
                    node->next[i]=node->trie->next[i];
            }
        }
    }

    bool test(char *str){
        Node *node = &root;

        while (*str){

            //for test
//            cout << node->num << endl;

            node = node->next[*str-'a'];
            if (node->flag)
                return true;
            ++str;
        }
        return false;
    }

    void print(){
        root.print();
        root.next[0]->print();
        root.next[1]->print();
        root.next[2]->print();
        root.next[0]->next[0]->print();
    }
};

int main()
{
    char str[1000002];
    int N;
    TrieGraph trieGraph;
    cin >> N;
    for (int i = 0;i < N;++i){
        cin >> str;
        trieGraph.insert(str);
    }
    trieGraph.set_flag();
    trieGraph.build_graph();

    cin >> str;
    cout << ((trieGraph.test(str))?"YES":"NO") << endl;

//    trieGraph.print();
    return 0;
}




silent56_th
关注
专栏目录
学习笔记-Trie树整理
08-21
学习笔记-Trie树整理
Trie图——多模式串的字符串匹配（数据结构详解+模板题算法）
weixin_42420686的博客
07-17 1377
引入——多模式串的字符串匹配问题 对于字符串匹配问题，我们熟知的是KMP算法，它维护一个next数组，使模式串在失配的时候可以快速调整位置继续比较，而母串的指针不必回溯。（此处关于KMP不再介绍） 那么，对于有多个模式串的字符串匹配问题，如果想要做到在匹配的过程中母串指针不回溯，一个next数组显然是不够的。直观地，我们需要更复杂一些的数据结构来执行类似于next数组的功能。 这个数据结构就是Tr...
Trie图-hihoCoder1036
WilliamSun0122的博客
07-21 582
Trie图Trie图相当于在AC自动机上优化了一下（感觉像是AC自动机的进阶版本），使匹配的速度更快。在学Trie图之前一定要先学会AC自动机： http://blog.csdn.net/williamsun0122/article/details/75576970Trie图是跟着fail指针一起构建的，同样，我们看图理解。（以字符集为｛0，1｝为例） 首先，我们必须明确Trie图就是把AC自动
Trie图（AC自动机）阶段做题小结
Best丶Wyj的博客
12-03 390
AC自动机构建完成后，某个节点沿着Fail链向上能从长到短走到自己的所有后缀。一般的，遍历主串进行匹配，就是在Trie图上定向移动的过程。 构造（一遍 BFS） void build_AC() { int u=0; for(int i=0;i&lt;26;i++) if(ch[u][i])q[r++]=ch[u][i]; while(l&lt;r) { u=q[l++]; ...
AC自动机
chen1234com的专栏
03-20 516
AC自动机 AC自动机        算法目的：        AC自动机主要用于解决多模式串的匹配问题，是字典树(trie树)的变种，一种伪树形结构(主体是树形的，但是由于加入了失败指针，使得它变成了一个有向图)；trie图(我的理解^_^)是对AC自动机的一种改造，使得图中每个结点都有MAXC条出边(MAXC表示该图的字符集合大小), trie图上的每个结点代表一个状态，并且和AC自
Trie图（模板）
weixin_30402343的博客
09-18 167
Trie图（蒟蒻听说AC自动机能做的题Trie图都能做，而且AC自动机可能被卡，就没学过AC自动机），最近想捡一捡，好久之前做的了。 Trie图，就是一个在Trie树上建的图 大概描述一下 比如说有几个字符串： abc abcd bcd bacd jdr ac 先把它们存在Trie树中： 就像KMP那样，做出这样的逻辑判断： bacd比较到第三位bac结果没有d...
C# TrieTree介绍及实现方法
09-05
C#中的TrieTree，又称字典树，是一种高效的数据结构，尤其在自然语言处理（NLP）和文本搜索领域有着广泛的应用。它的主要功能是存储字符串集合，并允许快速查找和匹配这些字符串。TrieTree的基本思想是通过将字符串...
C++前缀树trie的实现
12-25
C++实现的前缀树trie数据结构
Python实现Trie树
06-13
用Python实现Trie树的应用，并可以对英汉词典进行导入和检索、添加和删除，最终可以将导入的英汉词典保存到本地磁盘。内附两个.py文件，分别是tree.py和d_gui.py，tree.py是类和方法,d_gui.py是图形界面；一个.txt...
trie-0.1.1.tar
04-18
Trie数据结构详解与应用 Trie，又称为前缀树或字典树，是一种用于存储字符串的树形数据结构。它的主要特点是通过关联字符来构建树的节点，从而实现快速的字符串查找、插入和删除操作。Trie在信息技术、搜索引擎优化...
Trie图 (hihocoder1036)
arz74的博客
09-09 275
题目连接：http://hihocoder.com/problemset/problem/1036 思路：题目上有题解             这道数据结构是在 Trie树 的基础上构造，所以不懂 Trie树的，先去看看 Trie树。             然后在 Trie树 的基础上，我们增加了一些边，然后树便成了图；             那么需要增加那些边呢？        
KNOW: Tree, Trie, Graph
b_end_an的专栏
08-14 819
Binary Tree A binary tree is a tree in which no node can have more than two children. The depth of an average binary tree is considerably smaller than N. For binary search tree, the average dep
hiho一下 第四周 Hihocoder #1036 : Trie图
Luke的学习笔记
08-05 2031
#1036 : Trie图 时间限制:20000ms 单点时限:1000ms 内存限制:512MB 描述 前情回顾 上回说到，小Hi和小Ho接受到了河蟹先生伟大而光荣的任务：河蟹先生将要给与他们一篇从互联网上收集来的文章，和一本厚厚的河蟹词典，而他们要做的是判断这篇文章中是否存在那些属于河蟹词典中的词语。 当时，小Hi和小Ho的水平还是十分有限，他
trie图模板
弱智就要多努力
06-06 542
题目：http://hihocoder.com/problemset/problem/1036题意：给定多个模式串，问原串中有没有包含至少一个模式串思路：trie图应用，题目上有详细讲解，hiho一下第四周的题目，可以看大佬的代码#include<iostream> #include<cstdio> #include<cstring> #include <vector> #include <queu
hiho一下 第四周 Trie图
KangRoger的专栏
07-29 2810
题目： 时间限制:20000ms 单点时限:1000ms 内存限制:512MB 描述 前情回顾 上回说到，小Hi和小Ho接受到了河蟹先生伟大而光荣的任务：河蟹先生将要给与他们一篇从互联网上收集来的文章，和一本厚厚的河蟹词典，而他们要做的是判断这篇文章中是否存在那些属于河蟹词典中的词语。 当时，小Hi和小Ho的水平还是十分有限，他们只能够想到：“枚举
从Trie树（字典树）谈到后缀树（10.28修订）
热门推荐
结构之法 算法之道
10-22 17万+
从Trie树（字典树）谈到后缀树作者：July、yansha。出处：http://blog.csdn.net/v_JULY_v 。 引言    常关注本blog的读者朋友想必看过此篇文章：从B树、B+树、B*树谈到R 树，这次，咱们来讲另外两种树：Tire树与后缀树。不过，在此之前，先来看两个问题。    第一个问题： 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，
HiHocoder 1036 : Trie图 AC自动机
weixin_30835649的博客
10-08 90
Trie图 先看一个问题：给一个很长很长的母串 长度为n，然后给m个小的模式串。求这m个模式串里边有多少个是母串的字串。 最先想到的是暴力O(n*m*len(m)) len(m)表示这m个模式串的平均长度。。。 显然时间复杂度会很高。。。 再改进一些，用kmp让每一模式串与母串进行匹配呢？时间复杂度为O((n + len(m))*m)，还算可以。 ...
AC自动机相关Fail树和Trie图相关基础知识
weixin_30443895的博客
04-27 346
装载自55242字符串AC自动机专栏 fail树 定义 把所有fail指针逆向,这样就得到了一棵树 (因为每个节点的出度都为1,所以逆向后每个节点入度为1,所以得到的是一棵树) 还账… 有了这个东西,我们可以做很多事… 对于AC自动机的构造前面的文章已经讲了,而在查询的时候,有一点感觉没有说清楚： 对于x串在y串中出现,必然是在y串某个前缀...
学习笔记：KMP/AC自动机/trie图/fail树
少主大人殿下的博客
03-15 925
前言 KMP是一个经典的字符串匹配算法。 然后AC自动机是基于KMP思想的一个多模板匹配算法。 trie图是AC自动机的一个优化。 fail树是AC自动机中fail指针构成的有特殊性质的树。 KMP算法 算法原理 设两个字符串长度为n和m。 两个模板匹配，如果暴力匹配是暴力枚举起点，最坏时间复杂度O(n * m * min(n,m) ) 利用一个叫做失配指针的东西，f[i...
trie图时间复杂度
最新发布
08-10
Trie树的构建过程需要扫描所有的字符串，时间复杂度为O(n)，其中n表示所有字符串的长度和。而对于后续的查询操作，如果要查询的字符串长度为k，只需要比对k个节点，时间复杂度为O(k)。因此，Trie树的查询操作非常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值