统计难题（hdu1251，字典树）

字典树（Trie树）的题目

Problem Description

Ignatius最近遇到一个难题,老师交给他很多单词(只有小写字母组成,不会有重复的单词出现),现在老师要他统计出以某个字符串为前缀的单词数量( 单词本身也是自己的前缀)

Input
输入数据的第一部分是一张单词表,每行一个单词,单词的长度不超过10,它们代表的是老师交给Ignatius统计的单词,一个空行代表单词表的结束.第二部分是一连串的提问,每行一个提问,每个提问都是一个字符串
注意:本题只有一组测试数据,处理到文件结束
 
Output
对于每个提问,给出以该字符串为前缀的单词的数量
 
Sample Input
banana
band
bee
absolute
acm

ba
b
band
abc
 
Sample Output
2
3
1

0

本题是字典树的典型，关于字典树的介绍，可以查看这篇文章。

本题想法：

正如上面说的那样，每个节点由 记录前缀数量的n 和 26个代表字母的指针组成

1.构建字典树

直接来个例子：输入“aed”和“ag”

■首先存入“aed”字符串

①先从root开始。发现root->p[0]（“a”-“a”）并未分配内存，因此先分配内存，后将root->p[0]指向该内存

②接着判断root->p[0]->p[4]（“e”-“a”）是否分配内存，发现未分配后开辟内存，并将root->p[0]->p[4]指向该内存

③最后判断root->p[0]->p[4]->p[3]（“d”-“a”）是否分配内存，未分配则先分配内存，后将root->p[0]->p[4]->p[3]指向该内存

到此，“aed”序列已存入字典树中

■接着“ag”存入

①先从root开始，发现root->p[0]已分配内存，则其只需将root->p[0]的n自增1次

②接着判断root->p[0]->p[6]（“g”-“a”）是否分配内存，未分配则先分配内存，后将root->p[0]->p[6]指向该内存

2.查找字符串

■比如要查找“a”为前缀

先从root开始，发现root->p[0]已分配内存，则直接输出root->p[0]的n即可

■再比如要查找“aef“为前缀的

①先从root开始，发现root->p[0]已分配内存。则查找root->p[0]->p[4]（“e”-“a”），发现其也分配内存了。到此说明”ae“前缀在这棵树中是存在的

②接着查找root->p[0]->p[4]->p[5]（“f”-“a”），发现其未分配内存，这表明我们所要查找的以”aef“为前缀的字符串并不存在

代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

struct tire
{
    int n; 
    struct tire *next[26];                                    //树形结构（1个节点有26个分支指针。如果存在该字母，才会为其开辟内存）
}*root;                                                       //定义根节点

void insert(char *p)
{
    int i,j,len;
    struct tire *now,*cur=root;
    len=strlen(p);                                            //字符串的长度

    for(i=0;i<len;i++)
    {
        if(cur->next[p[i]-'a']==NULL)                         //如果该节点的p[i]分支还没构建（未分配内存）
        {
            now=(struct tire *)malloc(sizeof(struct tire));   //开辟一个节点的空间
            now->n=1;                                         //前缀相同的初始为1个
            for(j=0;j<26;j++)                                 //新构建节点的所有分支全初始化为NULL（即不存在）
            {
                now->next[j]=NULL;
            }
            cur->next[p[i]-'a']=now;                          //将p[i]分支指向新分配的内存
            cur=cur->next[p[i]-'a'];                          //更新cur
        }
        else                                                  //该节点的p[i]分支已经构建了
        {
            cur=cur->next[p[i]-'a'];                          //更新cur
            cur->n++;                                         //前缀相同,自增一次
        }
    }
}

int find(char *p)
{
    int i,len;
    struct tire *cur=root;
    len=strlen(p);
    for(i=0;i<len;i++)
    {
        if(cur->next[p[i]-'a']==NULL)
        {
            return 0;
        }
        else
        {
            cur=cur->next[p[i]-'a'];                         //更新cur，向后一个字符
        }
    }
    return cur->n;                                           //已找到该前缀，返回该前缀的个数
}

int main()
{
    //freopen("in.txt","r",stdin);
    //字典树（前缀树）
    int i,n;
    char p[15];
    root=(struct tire *)malloc(sizeof(struct tire));        //为根节点开辟内存
    for(i=0;i<26;i++)                                       //根节点的26个分支的指针（代表26个字母）初始为空
    {
        root->next[i]=NULL;
    }

    root->n=0;   
    while(gets(p))                                          //构建字典树
    {
        if(strlen(p)==0)
        {
            break;
        }
        insert(p);
    }

    while(~scanf("%s",p))                                   //寻找单词
    {
        n=find(p);
        printf("%d\n",n);
    }
    return 0;
}