Trie(字典树）解析及其在编程竞赛中的典型应用举例

摘要：

　　本文主要讲解了Trie的基本思想和原理，实现了几种常见的Trie构造方法，着重讲解Trie在编程竞赛中的一些典型应用。

1. 什么是Trie?
2. 如何构建一个Trie？
3. Trie在编程竞赛中的典型应用有些？
4. 例题解析

---

 

什么是Trie?

　　术语取自retrieval中（检索，收回，挽回）的trie，读作“try”，也叫做前缀树或者字典树，是一种有序的树形数据结构。我们常用字典树来保存字符串集合(但不仅限于字符串），如下图就是一个字典树。

　　　　　　　　　　　　　　　　

　　它保存的字符集合是{to,te,tea,ted,ten,a,i,in,inn}，可以看出从根结点到单词结点所经过的路径上的所有字母所组成的字符串就是该单词结点对应的字符串。从图中我们可以验证字典树的三条性质：

　　1.根结点不包含字符，除根结点外，其他结点都只包含一个字符；

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

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

　　类比查英文字典的过程就是在字典树上查单词的过程，它的核心思想就是利用字符串的公共前缀来减少查询时间，最大限度地减少无谓字字符比较，从而提高效率。

　　Trie的典型应用是用于统计、排序和保存大量的字符串（不限于字符串），所以经常被用于搜索引擎的文本词频统计，关键词检索。

如何构建一个Trie?

　 常用的有三种构建方法，分别是转移矩阵法、链表法和左儿子-右兄弟表示法。

　 转移矩阵法的基本思想和实现　　　　

　　矩阵转移法的思想是将根结点标号为0，其余结点标号为从1开始的正整数，然后用一个二维数组来保存每个结点的所有子节点，用数组下标进行直接存取。具体来说就是用ch[i][j]来表示结点i编号为j的那个子结点（其中编号为j意为该字符在字符集中的编号，比如a在所有的小写字母集合中的编号为0），可以构建如下图所示的转移矩阵（原谅我这不讲究的画图）。

　　　　　　　　              　

 　　将初始化、插入和查询封装到一个结构体里代码如下：

const int maxn = 1001;//模板数
const int sigma_size = 26;
 
struct Trie {
    int ch[maxn][sigma_size];
    int val[maxn];//规定非单词结点的附加价值为0 
    int sz;//结点总数 
    void init() {//初始化，只有一个根结点并且没有子结点 
        sz = 1;
        memset(ch[0], 0, sizeof(ch[0]));
    } 
    int idx(char c) {
        return c - 'a';
    }
    void insert(char *s, int v) {
        int n = strlen(s);
        int u = 0;
        for(int i = 0; i < n; i++) {//遍历模板串的每一个字母 
            int c = idx(s[i]);//得到该字母的编号 
            if(!ch[u][c]){//该结点不存在 
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;//中间结点的附加信息为0 
                ch[u][c] = sz++;//将结点u编号为j的子结点编号为sz 
            }
            u = ch[u][c];//往下走 
        }
        val[u] = v; 
    } 
    bool query(char *t) {
        int m = strlen(t);
        int u = 0;
        for(int i = 0; i < m; i++) {
            int c = idx(t[i]);
            if(!ch[u][c])//结点u编号为j的子结点为空表示不存在该串 
                return false;
            u = ch[u][c];
        }
        return true;
    } 
};

　　上述代码中值得注意的是每遇到一个结点才重置二维数组中的一行，看似麻烦，其实可以起到优化内存，防止内存超限的作用，因为如果按照题目要求一次性置零，判题机会直接检测到内存超限，按照上述的方法，有多少单词就用多少内存，只要不是字符集特别大（一般是小写字母集合，如果真的很大采用后面的第三种方法），并不会直接判内存超限。

　　来看一个具体的问题，输入单词数n和n个单词，查询m个单词是否在之前的单词表中，存在输出Yes，否则输出No。直接套用模板代码如下：

#include <cstdio>
#include <cstring> 
const int maxn = 1001;//模板数
const int sigma_size = 26;
 
struct Trie {
    int ch[maxn][sigma_size];
    int val[maxn];//规定非单词结点的附加价值为0 
    int sz;//结点总数 
    void init() {//初始化，只有一个根结点并且没有子结点 
        sz = 1;
        memset(ch[0], 0, sizeof(ch[0]));
    } 
    int idx(char c) {
        return c - 'a';
    }
    void insert(char *s, int v) {
        int n = strlen(s);
        int u = 0;
        for(int i = 0; i < n; i++) {//遍历模板串的每一个字母 
            int c = idx(s[i]);//得到该字母的编号 
            if(!ch[u][c]){//该结点不存在 
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;//中间结点的附加信息为0 
                ch[u][c] = sz++;//将结点u编号为j的子结点编号为sz 
            }
            u = ch[u][c];//往下走 
        }
        val[u] = v; 
    } 
    bool query(char *t) {
        int m = strlen(t);
        int u = 0;
        for(int i = 0; i < m; i++) {
            int c = idx(t[i]);
            if(!ch[u][c])//结点u编号为j的子结点为空表示不存在该串 
                return false;
            u = ch[u][c];
        }
        return true;
    } 
};

Trie trie;//直接使用封装好的结构体  
int main()
{
    int n;
    char word[maxn];
    trie.init();
    printf("输入单词表的个数和单词表:\n");
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        scanf("%s", word);
        trie.insert(word, 1);
    } 
    printf("输入欲查询单词的个数和单词：\n");
    int m; 
    scanf("%d", &m);
    for(int i = 0; i < m; i++) {
        scanf("%s", word);
        if(trie.query(word))
            printf("Yes\n");
        else
            printf("No\n");
    }
    getchar();
    return 0;
}

/*测试样例 
10
asd
zxc
qwe
asdf
zxcv
qwer
asdfgh
rewq
fdsa
vcxz
5
asdf
ghjk
zxcv
qwer
rewq
*/ 

测试样例结果:

                    

　 链表法的基本思想和实现

　　链表法和转移矩阵法的基本思想是一致的，每个结点都存储有下一个结点的信息，不同的是二维数组使用数组下标方式的方式直接存取，而链表法采用指针指向的方式存取。同样封装到一个结构体中代码如下：

struct Node {
    int cnt;//以当前结点为前缀的单词个数
    Node* chi[26];//字符集的大小的结点指针数组 
};
struct Trie {
    Node* root;
    void init() {//初始化 
        root = create();
    }
    Node* create() {//新建一个结点 
        Node* tmp = new Node;
        tmp->cnt = 0;
        memset(tmp->chi, 0, sizeof(tmp->chi));
        return tmp;
    }
    void insert(char *s) {
        Node* u = root;
        int len = strlen(s);
        for(int i = 0; i < len; i++) {
            int c = s[i] - 'a';
            if(u->chi[c] == NULL)
                u->chi[c] = create();
                
            u = u->chi[c];
            u->cnt ++;//以当前结点为前缀的单词个数++ 
        }
    }
    int query(char *t) {//查询 
        int len = strlen(t);
        Node* u = root;
        for(int i = 0; i < len; i++) {
            int c = t[i] - 'a';
            if(u->chi[c] == NULL)
                return 0;//走到字典树的叶子节点该单词还没结束，以该串为前缀的单词数为0 
                
            u = u->chi[c];
        }
        return u->cnt;
    }
    void freeTrie(Node* u) {//递归释放内存 
        if(u == NULL)
            return;
        for(int i = 0; i < 26; i ++) {
            if(u->chi[i] != NULL)
                freeTrie(u->chi[i]);
        }
        free(u);
    }
};

　　可以看出，前两种方法的基本思想是一致的，只是存取方式略有差异。它们除了都存在稀疏现象严重，空间利用率低的问题之外，当碰上字符集很大题目，比如UVa 11732 “strcmp()” Anyone?，字符集是10个数字和大小写字母，想要遍历整个Trie的时候必须依次枚举字符集各个位置是否为空才行，所以还存在遍历时间开销较大的问题。（需要遍历Trie的问题很多比如计算多个模板的最长公共前缀问题）而第三种构建方式左儿子-右兄弟表示法可以很好的解决时间和空间上的问题。

　 左儿子-右兄弟表示法的基本思想和实现

　　左儿子-右兄弟表示法的精髓在于将之前的字典树的多叉树结构转化为了二叉树结构。这里借鉴《算法入门经典 训练指南》中的数组表示法。主要使用了两个数组，一个是head数组表示第i个结点的左儿子编号和next数组表示第i个结点的右兄弟编号。同样封装在一个结构体中代码如下：

const int maxw = 1000010; //单词的最大个数 
const int maxwl = 101;//单词的最大长度
const int maxnode = maxw * maxwl + 10;
 
struct Trie {
    int head[maxnode]; //head[i]表示第i个结点的左儿子的编号
    int next[maxnode]; //next[i]表示第i个结点的右兄弟的编号
    int val[maxnode];  //以该结点为前缀的单词的个数 
    char ch[maxnode];  //ch[i]表示第i个结点的字符 
    int sz;            //结点总数
    
    void init() {
        sz = 1;
        head[0] = next[0] = val[0] = 0; 
    } 
    void insert(char *s) {
        int u = 0, len = strlen(s), v;
        for(int i = 0; i < len; i ++) {
            //在当前u的所有儿子中找s[i] 
            bool found = false;
            for(v = head[u]; v != 0; v = next[v]) {//遍历当前u的所有儿子 
                if(ch[v] == s[i]) {
                    found = true;//找到 
                    break;
                } 
            }
            if(!found) {//没有找到则新建一个结点作为当前结点的儿子 
                v = sz++;
                ch[v] = s[i];
                val[v] = 0;
                
                next[v] = head[u]; //该结点的右兄弟是head[u](当前结点的左儿子)
                head[u] = v;       //v是当前结点u的左儿子
                head[v] = 0;       //v没有左儿子(叶子结点) 
            } 
            
            u = v;//继续往下走 
            val[u]++; //以当前结点为前缀为单词个数++ 
        }
    } 
    int query(char *t) {
        int u = 0, len = strlen(t), v;
        for(int i = 0; i < len; i++) {
            bool found = false;
            for(v = head[u]; v != 0; v = next[v]) {
                if(ch[v] == t[i]) {
                    found = true;
                    break;
                }
            }
            if(!found)
                return 0;
            u = v;
        }
        return val[u];
    }
};

　　为了比较三种写法的优劣，以HDU 1251 统计难题为例，统计以某串为前缀的单词个数，三种写法如下：

转移矩阵表示法：

/*
关于转移矩阵的使用注意事项，由于二维矩阵存在较大的空间资源浪费，可以利用C语言的特性，变量声明时不申请空间，只有在赋值
的时候申请，所以置零可以分成需要的时候再置。 
*/ 
#include <cstdio>
#include <cstring> 
const int maxw = 1000010;
const int sigm_size = 26;

struct Trie {
    int ch[maxw][sigm_size];
    int val[maxw];
    int sz;
    
    void init() {
        sz = 1;
        memset(ch[0], 0, sizeof(ch[0])); 
    }
    void insert(char *s) {
        int u = 0, len = strlen(s);
        for(int i = 0; i < len; i++) {//遍历模板串的每一个字母 
            int c = s[i] - 'a';//得到该字母的编号 
            if(!ch[u][c]) {//该结点不存在
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;//中间结点的附加信息为0
                ch[u][c] = sz++;//将结点u编号为j的子结点编号为sz 
            } 

            u = ch[u][c];//往下走
            val[u]++;//以该结点为前缀的单词++ 
        }
    } 
    int query(char *t) {
        int len = strlen(t);
        int u = 0;
        for(int i = 0; i < len; i++) {
            int c = t[i] - 'a';
            if(!ch[u][c])//结点u编号为j的子结点为空表示不存在该串 
                return 0;
            u = ch[u][c];
        }
        return val[u];
    } 
};

Trie trie;
int main()
{
    char word[11];
    trie.init();
    while(gets(word) != NULL) {
        int len = strlen(word);
        if(len == 0) break;
        trie.insert(word);
    } 
    while(gets(word) != NULL) {
        printf("%d\n", trie.query(word));
    }
    return 0;
}

左儿子-右兄弟表示法：

#include <cstdio>
#include <cstring>
const int maxw = 1000010; //单词的最大个数 
const int maxwl = 101;//单词的最大长度
const int maxnode = maxw * maxwl + 10;
 
struct Trie {
    int head[maxnode]; //head[i]表示第i个结点的左儿子的编号
    int next[maxnode]; //next[i]表示第i个结点的右兄弟的编号
    int val[maxnode];  //以该结点为前缀的单词的个数 
    char ch[maxnode];  //ch[i]表示第i个结点的字符 
    int sz;            //结点总数
    
    void init() {
        sz = 1;
        head[0] = next[0] = val[0] = 0; 
    } 
    void insert(char *s) {
        int u = 0, len = strlen(s), v;
        for(int i = 0; i < len; i ++) {
            //在当前u的所有儿子中找s[i] 
            bool found = false;
            for(v = head[u]; v != 0; v = next[v]) {//遍历当前u的所有儿子 
                if(ch[v] == s[i]) {
                    found = true;//找到 
                    break;
                } 
            }
            if(!found) {//没有找到则新建一个结点作为当前结点的儿子 
                v = sz++;
                ch[v] = s[i];
                val[v] = 0;
                
                next[v] = head[u]; //该结点的右兄弟是head[u](当前结点的左儿子)
                head[u] = v;       //v是当前结点u的左儿子
                head[v] = 0;       //v没有左儿子(叶子结点) 
            } 
            
            u = v;//继续往下走 
            val[u]++; //以当前结点为前缀为单词个数++ 
        }
    } 
    int query(char *t) {
        int u = 0, len = strlen(t), v;
        for(int i = 0; i < len; i++) {
            bool found = false;
            for(v = head[u]; v != 0; v = next[v]) {
                if(ch[v] == t[i]) {
                    found = true;
                    break;
                }
            }
            if(!found)
                return 0;
            u = v;
        }
        return val[u];
    }
};

Trie trie; 
int main()
{
    char word[maxwl]; 
    trie.init();//记得初始化 
    while(gets(word) != NULL) {
        int len = strlen(word);
        if(len == 0)    break;
        trie.insert(word);
    }
    while(gets(word) != NULL) {
        printf("%d\n", trie.query(word));
    }
    return 0;
} 

链表法：

//c++ AC G++MLE 
#include <cstdio>
#include <cstring>
#include <cstdlib>
struct Node {
    int cnt;//以当前结点为前缀的单词个数
    Node* chi[26];//字符集的大小的结点指针数组 
};
struct Trie {
    Node* root;
    void init() {//初始化 
        root = create();
    }
    Node* create() {//新建一个结点 
        Node* tmp = new Node;
        tmp->cnt = 0;
        memset(tmp->chi, 0, sizeof(tmp->chi));
        return tmp;
    }
    void insert(char *s) {
        Node* u = root;
        int len = strlen(s);
        for(int i = 0; i < len; i++) {
            int c = s[i] - 'a';
            if(u->chi[c] == NULL)
                u->chi[c] = create();
                
            u = u->chi[c];
            u->cnt ++;//以当前结点为前缀的单词个数++ 
        }
    }
    int query(char *t) {//查询 
        int len = strlen(t);
        Node* u = root;
        for(int i = 0; i < len; i++) {
            int c = t[i] - 'a';
            if(u->chi[c] == NULL)
                return 0;//走到字典树的叶子节点该单词还没结束，以该串为前缀的单词数为0 
                
            u = u->chi[c];
        }
        return u->cnt;
    }
    void freeTrie(Node* u) {//递归释放内存 
        if(u == NULL)
            return;
        for(int i = 0; i < 26; i ++) {
            if(u->chi[i] != NULL)
                freeTrie(u->chi[i]);
        }
        free(u);
    }
};

Trie trie;
int main()
{
    char word[11];
    trie.init();
    while(gets(word) != NULL) {
        int len = strlen(word);
        if(len == 0) break;
        trie.insert(word);
    }
    while(gets(word) != NULL) {
        printf("%d\n", trie.query(word));
    }
    trie.freeTrie(trie.root);
    return 0;
}

对应运行结果如下图所示：

可以看到，运行结果时间最长，内存占用最大的是链表法，转移矩阵法虽然占用内存大，但是在时间上表现优异，而左儿子-右兄弟表示法完美的解决了前两种的结构存在的问题，占用内存小、效率高。

Trie在编程竞赛中有哪些典型的应用呢？

　　1、前缀统计

　　给出单词表后问一个串是多少个单词的前缀。例题HDU 1251 统计难题。

　　2、串的快速检索

　　给出单词表，问一个单词是否存在在之前的单词表里。例题 HDU 1277 全文检索。当然对于单词检索问题，也可以用STL中的map集合求解，但有时不光是解决存在问题，还需要解决其他问题,比如和前缀有关的问题和效率问题，就应该考虑Trie。

　　3、串的排序问题

　　给出许多单词，将其按字典序输出。当然对于字符串排序，使用STL中sort一下也可，但是对于单词量巨大的时候，Trie有其独有的优势:占用空间少，效率又高。

　　4、计算最长公共前缀。

　　给出几个字符串，问它们的最长公共前缀是多少。或者像UVa11732 strcmp() Anyone?求解两两串的公共前缀。

　　5、作为其他算法的数据结构，比如AC自动机。

例题解析

　　围绕上述Trie在编程竞赛中的典型应用，例题有：

　   HDU 1251 统计难题（前缀统计），上面给出了三种写法，大致思想都是用单词表构建字典树的时候，每走过一个结点都标记一下，最后以查询串的最后一单词为结点的值就是以该串为前缀的单词的数量。

　　HDU 1277 全文检索（串的快速检索问题），题意描述是给出一段数字串，再给出关键词，问哪些关键词在上面的数字串里。题意很明显，先根据关键词构建个位数字集合的字典树，然后分割数字文本串，查找到最长前缀就输出，有些同学可能会想，以某个开头的关键词不止一个怎么办，题中说了前四个数字不同，意味着没有前缀相同的关键词，所以就不用考虑了。其实这道题是AC自动机的模板问题，只不过这里使用了复杂度较高的方法。代码如下：

#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;

const int maxl = 60010;
char txt[maxl];
const int maxk = 10010;
char key[maxk/100];//每个关键词的长度 
const int maxnode = maxk * 60 + 10;//最大化结点个数 

struct Trie {
    int ch[maxnode][10];
    int val[maxnode];
    int sz;
    
    void init() {
        sz = 1;
        memset(ch[sz], 0, sizeof(ch[sz]));
    }
    void insert(char *s, int v) {//将每个关键词的序号作为附加信息 
        int u = 0, len = strlen(s);
        for(int i = 0; i < len; i++) {
            int c = s[i] - '0';//注意字符集的使用 
            if(!ch[u][c]) {
                val[sz] = 0;
                memset(ch[sz], 0, sizeof(ch[sz]));
                
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] = v; 
    }
    int query(char *t) {
        int u = 0, len = strlen(t);
        for(int i = 0; i < len; i++) {
            int c = t[i] - '0';
            if(!ch[u][c])
                break;
            u = ch[u][c];
        }
        return val[u];
    }
};

Trie trie;
int main() 
{
    int n,m;
    while(scanf("%d%d", &n, &m) != EOF) {
        trie.init();
        int len = 0;
        for(int i = 0; i < n; i++) {
            scanf("%s", txt+len);
            len = strlen(txt);
        }    
        for(int i = 1; i <= m; i++) {
            int v;
            scanf("%*s%*s%d%*c%s", &v, key);
            trie.insert(key, i);
        }
        
        vector<int> p;//保存存在的关键词的编号 
        for(int i = 0; i < len; i++) {
            int num = trie.query(txt+i);
            if(num)    p.push_back(num);
        }
        if(!p.empty()) {
            printf("Found key:");
            for(int i = 0; i < p.size(); i++) 
                printf(" [Key No. %d]", p[i]);
            puts("");
        }
        else
            puts("No key can be found !\n");
    }
    return 0;
}

　　LA 3942 Remember the word（与DP结合的前缀串查询问题），题意描述是给出一个字符串和单词数n和n个单词，问可以重复使用n个单词，组成该字符串的方法有几种？例如有4个单词a、b、cd、ab，组成abcd有两种方法：a+b+cd和ab+cd。

　　直觉告诉我们这是一个DP题，关键是定义状态，找到转移方程，我们可以这样定义d[i]为第i个字符开始的字符串（即后缀s[i..L]）的分解方法。如果单词x是s[i...L]的前缀的话，那么d[i] = 1*d[i + len(x)]，单词x个数1和之后的组合方案书相乘，不要忘了，这道题没有说前几个单词前缀不同，也就是存在多个单词x，那么d[i] = sum{d[i + len(x)]}就可以了。现在问题变成了怎么寻找是串s[i..L]的前缀的单词，一个一个枚举显然不是什么好办法，可以使用Trie，每次枚举s[i..L并]记录它有哪些前缀单词，直接一遍就可以找出全部的前缀单词。代码如下：

#include <cstring>
#include <vector>
using namespace std;

const int maxn = 4010 * 100 + 10;
struct Trie {
    int ch[maxn][26];
    int val[maxn];
    int sz;
    
    void clear() { 
        sz = 1; 
        memset(ch[0], 0, sizeof(ch[0])); 
    }
    void insert(char *s, int v) {
        int u = 0;
        int n = strlen(s);
        for(int i = 0; i < n; i++) {
            int c = s[i] - 'a';
            if(!ch[u][c]){
                memset(ch[sz], 0, sizeof(ch[sz]));
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] = v;
    }
    //查询长度不超过len的前缀单词并记录序号到p中 
    void query(char *t, int len, vector<int>& p) {
        int u = 0;
        for(int i = 0; i < len; i++) {
            if(t[i] == '\0')
                break;
            int c = t[i] - 'a';
            if(!ch[u][c])
                break;
            
            u = ch[u][c];
            if(val[u] != 0)
                p.push_back(val[u]);
        } 
    }
}trie;

#include <cstdio>
const int maxwl = 100 + 10;
const int maxl = 300010;
const int MOD =  20071027;
const int maxw = 4000 + 10;

char txt[maxl];
char word[maxwl];
int len[maxw];
int d[maxl];

int main()
{
    int n;
    int kase = 0;
    while(scanf("%s", txt) != EOF) {
        scanf("%d", &n);
        trie.clear();//多样例，记得初始化 
        for(int i = 1; i <= n; i++) {
            scanf("%s", word);
            trie.insert(word, i);
            len[i] = strlen(word);;
        }
        
        int L = strlen(txt);
        memset(d, 0, sizeof(d));
        d[L] = 1;
        for(int i = L - 1; i >= 0; i --) {
            vector<int> p;
            trie.query(txt+i, L - i, p);
            for(int j = 0; j < p.size(); j++) 
                d[i] = (d[i] + d[i + len[p[j]]]) % MOD;
        }
        printf("Case %d: %d\n", ++kase, d[0]);
    }    
    return 0;
}

　　串的排序问题，就是字符串的排序，就不找题了，关键是使用字典树进行排序，也不能说是用字典树排序，应该是构造字典树，前序遍历输出的问题。关于前序遍历，主要是递归遍历，需要记录进入子树之前的字符串，用于回溯的时候恢复状态。代码如下：

#include <cstdio>
#include <cstring>
#include <vector>
#include <iostream>
using namespace std;

struct Node {
    bool f;//单词结点标志位 
    Node* chl[26]; 
};
struct Trie {
    Node* root;
    string p;//保存单词便于输出 
    void init() {//初始化只有一个结点和清空单词字符串 
        root = cret();
        memset(root->chl, 0, sizeof(root->chl));
        p.clear();
    }
    Node* cret() {
        Node* tmp = new Node;
        tmp->f = false;
        memset(tmp->chl, 0, sizeof(tmp->chl));
        return tmp;
    }
    void insert(char *s) {
        int len = strlen(s);
        Node* u = root;
        for(int i = 0; i < len; i++) {
            int c = s[i] - 'a';
            if(u->chl[c] == NULL)
                u->chl[c] = cret();
                
            u = u->chl[c];//往下走 
        }
        u->f = true;//标记该结点为单词结点 
    }
    void print(Node* u) {
        if(u->f)//如果是单词结点就输出当前单词字符串 
            cout<<p<<endl;
        
        for(int i = 0; i < 26; i++) {
            if(u->chl[i]) {
                string tmp = p;
                char tmpch = ('a' + i); 
                p = p + tmpch;//字符串+时不能直接+('a' + i) 
                print(u->chl[i]);
                
                p = tmp;//恢复成进入子树之前的状态 
            }
        }
    }
}trie;
 
int main() 
{
    int n;
    char word[111];
    //printf("输入待排序单词的个数:\n");
    scanf("%d", &n);
    trie.init();
    while(n--) {
        scanf("%s", word);
        trie.insert(word);
    }
    puts(""); 
    trie.print(trie.root);
    return 0;
}

/*测试样例 
5
banana
band
bee
absolute
acm 
*/ 

样例结果如下：

　　UVa 11732 "strcmp()" Anyone? 计算公共前缀问题，给出n个单词，问这些单词两两调用strcmp函数共比较了多少次？C/C++中的strcmp函数源码如下：

1 int strcmp(char *s, char *t)
2 {
3     int i;
4     for (i = 0; s[i] == t[i]; i++)
5         if(s[i] == '\0')
6             return 0;
7     return s[i] - t[i];
8 }

       比如aaa和aaa比较，两者相等s[i] == t[i]  和  s[i] == '\0'各用了四次，共比较了8词，再比如题中所给的than 和that最后一次比较是s[i] == t[i]失败，之前相同的各两次，所以共比较7次，由此可以发现比较次数和公共前缀有关，那就有了字典树的用武之地，建立字典树，采用深度优先搜索，计算每个结点之前的比较次数，按失败的计算，最后遍历到叶结点时，根据相同个数再加上最后一次比较即可。代码如下：

#include <cstdio>
#include <cstring>

const int maxw = 4010;
const int maxwl = 1100;
const int maxnode = maxw * maxwl + 10; 

struct Trie {
    int head[maxnode];//第i个结点的儿子 
    int next[maxnode];//第i个结点兄弟 
    char ch[maxnode];//第i个结点的字符 
    int tot[maxnode];//以该结点为根结点的子树的数目，跟前缀相同的单词数一样 
    int sz;
    long long ans;
    
    void init() {
        sz = 1;
        head[0] = next[0] = tot[0] = 0;
    }
    void insert(const char *s) {
        int u = 0, len = strlen(s), v;
        tot[0]++;
        
        for(int i = 0; i <= len; i++) {//是 <= 为了表示出相同字符串的数目，注意将'\0'也加入 
            bool found = false;
            for(v = head[u]; v != 0; v = next[v]) {
                if(ch[v] == s[i]) {
                    found = true;
                    break;
                }
            }
            if(!found) {
                v = sz++;
                ch[v] = s[i];
                tot[v] = 0;
                
                next[v] = head[u];
                head[u] = v;
                head[v] = 0;
            }
            u = v;
            tot[u]++;
        }
    }
    //统计最长公共前缀为u的所有串的比较次数 
    void dfs(int depth, int u) {
        if(head[u] == 0) //叶结点，如果该叶结点没有相同的串，tot[u] == 1对答案没有影响，如果有那么 
            ans += tot[u] * (tot[u] - 1) * depth;
        else { 
            int sum = 0;
            for(int v = head[u]; v != 0; v = next[v])//统计当前结点之前的比较次数 
                sum += tot[v] * (tot[u] - tot[v]);//子树v中选择一个，其他子树中选一个
            //除以2因为统计了两次,所有串的比较次数乘以当前的深度等于总的比较次数
            //乘以2倍的深度加1是都先按不相等处理，最后到叶子结点再加 
            ans += sum / 2 * (2 * depth + 1);
            for(int v = head[u]; v != 0; v = next[v])//统计当前结点的所有子节点的比较次数
                dfs(depth+1, v); 
        } 
    }
    long long count(){
        ans = 0;
        dfs(0, 0);
        return ans;
    }
}trie;

int main() 
{
    int n, kase = 0;
    char word[maxwl];
    while(scanf("%d", &n) == 1 && n) {
        trie.init();
        for(int i = 0; i < n; i++) {
            scanf("%s", word);
            trie.insert(word);
        }
        printf("Case %d: %lld\n",++kase, trie.count());
    }
    return 0;
}

　　Trie做为AC自动机的数据结构的应用就在AC自动机中具体解释。

　　到此，有关Trie的解析就结束了，本文主要讲述了Trie在编程竞赛中的一些典型应用，想掌握它并不难，关键是配合一些具体的应用和例题帮助自己更具实践性的掌握，可以根据具体的提示和问题，自己实现以下相关的程序，达到活学活用的效果。（原创不易，转载请注明出处哦）