Trie的C++实现及HDU1251,hdu1671

最新推荐文章于 2017-04-04 22:52:01 发布
最新推荐文章于 2017-04-04 22:52:01 发布
阅读量707 收藏
点赞数
分类专栏： 基本 字符串 HDU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dengyaolongacmblog/article/details/23854717
版权
基本 同时被 3 个专栏收录
36 篇文章 0 订阅
订阅专栏
HDU
35 篇文章 0 订阅
订阅专栏
字符串
13 篇文章 0 订阅
订阅专栏 
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
using namespace std;
template<int Size>
struct trie_node{

  bool terminable; //表示节点为字符串的结尾
  int node;       //子节点的个数
  trie_node *child[Size]; //儿子节点
  trie_node():terminable(false), node(0){
      memset(child,0,sizeof(child)); //初始化节点
  }

};
template<int Size,typename Index>
class trie{
    public:
        //定义类名
        typedef trie_node<Size> node_type;
        typedef trie_node<Size> *link_type;

        //构造函数
        trie(Index i=Index()):index(i){ }

        //清空函数，用于析构
        void clear(){
          clear_node(root);
          for(int i=0;i<Size;i++)
              root.child[i]=0;
        }
        //插入
        template<typename Iterator>
        void insert(Iterator begin,Iterator end){
           link_type cur= &root;//当前插入结点为根
           while(begin!=end){
              if(!cur->child[index[*begin]]){//没有插入过
                cur->child[index[*begin]]=new node_type;
                cur->node++; //插入后，父亲多了一个儿子
              }
              cur=cur->child[index[*begin]]; //向下走
               begin++; //迭代器往前走！
           }
           cur->terminable=true;
        
        }

        //重载c风格插入
        void insert(const char * str){
           insert(str,str+strlen(str));
        }

        //查找
        template <typename Iterator>
        bool find(Iterator begin,Iterator end){
             link_type cur=&root;
             while(begin!=end){
             
                 if(!cur->child[index[*begin]]) //没有节点啊！！！
                     return false;
                 cur=cur->child[index[*begin]];

                begin++;
             
             }        
             return cur->terminable; //是否为字符串
        }

        //重载c风格
        bool find(const char *str){
        
           return find(str,str+strlen(str));
        }

        //删除字符串
       template<typename Iterator>
       bool earse (Iterator begin,Iterator end){
          bool result;
          earse_node(begin,end,root,result);
          return result;    
           
          
       }

       //c语言风格
       bool erase(char *str){
         return earse(str,str+strlen(str));
       
       }

       template<typename Functor>
           void traverse(Functor &execute =Functor()){
             visit_node(root,execute);
           
           }
    private:
       //访问结点
       template<typename Functor>
        void visit_node(node_type cur,Functor &execute){
            execute(cur);
            for(int i=0;i<Size;i++){//dfs
              if(cur.child[i]==0) continue;
              visit_node(*cur.child[i],execute);
            
            }
        }

       //清空
       void clear_node(node_type cur){
          for(int i=0;i<Size;i++){
             if(cur.child[i]==0)continue; //不存在
             clear_node(*cur.child[i]);
             delete cur.childe[i];
             cur.child[i]=0;
             if(--cur.node==0) break; //没有节点了
          
          }
      
       }

       //一边搜索一边删除
       template<typename Iterator>
       bool earse_node(Iterator begin ,Iterator end,node_type &cur,bool &result){
            if(begin==end){
                 result=cur.terminable;
                 cur.terminalbe=false;
                 return cur.node==0;
            
            }                 
           //当孩子不存在,结果假，返回假
            if(cur.child[index[*begin ]]==0) return !(result=false);
            else if(earse_node(begin+1,end,*(cur.child[index[*begin]]),result)){
               delete cur.child[index[*begin]];
               cur.child[index[*begin]]=0;
               if(--cur.node==0&&cur.terminable==false ) return true;
            
            }
            return false;
                     
       
       }
       //根
       node_type root;
       //字符转索引，类似hash
       Index index;

};

class IndexClass{
    public:
        int operator[](const char key){
            return key%26; //一个映射
        
        }

};


int main(){
    trie<26,IndexClass> t;
    t.insert("tree");
    t.insert("tea");
    t.insert("act");
    t.insert("adv");
    t.insert("ate");
    if(t.find("tree")){
      cout<<"find!";
    }
    char  str[50];
    while(scanf("%s",str)!=EOF){
        if(t.find(str)==1){
          cout<<"find"<<endl;
        }
      
    }
    return 0;


}

大部分参考http://blog.csdn.net/luxiaoxun/article/details/7937589

后来用1251裸题测试了一下。

Ac果断高兴啊！

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
using namespace std;
template<int Size>
struct trie_node{

  bool terminable; //表示节点为字符串的结尾
  int node;       //子节点的个数
  trie_node *child[Size]; //儿子节点
  trie_node():terminable(false), node(0){
      memset(child,0,sizeof(child)); //初始化节点
  }

};
template<int Size,typename Index>
class trie{
    public:
        //定义类名
        typedef trie_node<Size> node_type;
        typedef trie_node<Size> *link_type;

        //构造函数
        trie(Index i=Index()):index(i){ }

        //清空函数，用于析构
        void clear(){
          clear_node(root);
          for(int i=0;i<Size;i++)
              root.child[i]=0;
        }
        //插入
        template<typename Iterator>
        void insert(Iterator begin,Iterator end){
           link_type cur= &root;//当前插入结点为根
           while(begin!=end){
              if(cur->child[index[*begin]]){//插入过
                 cur=cur->child[index[*begin]];
                 ++(cur->node);

              }else{
                  cur->child[index[*begin]]=new node_type;
                ++(cur->child[index[*begin]]->node);
                cur=cur->child[index[*begin]];

              }




               begin++; //迭代器往前走！
           }
           cur->terminable=true;

        }

        //重载c风格插入
        void insert(const char * str){
           insert(str,str+strlen(str));
        }

        //查找
        template <typename Iterator>
        bool find(Iterator begin,Iterator end){
             link_type cur=&root;
             while(begin!=end){

                 if(!cur->child[index[*begin]]) //没有节点啊！！！
                     return false;
                 cur=cur->child[index[*begin]];

                begin++;

             }
             return cur->terminable; //是否为字符串
        }
        template <typename Iterator>
        int findNum(Iterator begin,Iterator end){
             link_type cur=&root;
             while(begin!=end){

                 if(!cur->child[index[*begin]]) //没有节点啊！！！
                     return 0;
                 cur=cur->child[index[*begin]];

                begin++;

             }

             return cur->node; //是否为字符串
        }
        //重载c风格
        int findNum(const char *str){

           return findNum(str,str+strlen(str));
        }

        //重载c风格
        bool find(const char *str){

           return find(str,str+strlen(str));
        }

        //删除字符串
       template<typename Iterator>
       bool earse (Iterator begin,Iterator end){
          bool result;
          earse_node(begin,end,root,result);
          return result;


       }

       //c语言风格
       bool erase(char *str){
         return earse(str,str+strlen(str));

       }

       template<typename Functor>
           void traverse(Functor &execute =Functor()){
             visit_node(root,execute);

           }
    private:
       //访问结点
       template<typename Functor>
        void visit_node(node_type cur,Functor &execute){
            execute(cur);
            for(int i=0;i<Size;i++){//dfs
              if(cur.child[i]==0) continue;
              visit_node(*cur.child[i],execute);

            }
        }

       //清空
       void clear_node(node_type cur){
          for(int i=0;i<Size;i++){
             if(cur.child[i]==0)continue; //不存在
             clear_node(*cur.child[i]);
             delete cur.childe[i];
             cur.child[i]=0;
             if(--cur.node==0) break; //没有节点了

          }

       }

       //一边搜索一边删除
       template<typename Iterator>
       bool earse_node(Iterator begin ,Iterator end,node_type &cur,bool &result){
            if(begin==end){
                 result=cur.terminable;
                 cur.terminalbe=false;
                 return cur.node==0;

            }
           //当孩子不存在,结果假，返回假
            if(cur.child[index[*begin ]]==0) return !(result=false);
            else if(earse_node(begin+1,end,*(cur.child[index[*begin]]),result)){
               delete cur.child[index[*begin]];
               cur.child[index[*begin]]=0;
               if(--cur.node==0&&cur.terminable==false ) return true;

            }
            return false;


       }
       //根
       node_type root;
       //字符转索引，类似hash
       Index index;

};

class IndexClass{
    public:
        int operator[](const char key){
            return key%26; //一个映射

        }

};


int main(){
    trie<26,IndexClass> t;
   char s[11];
    //freopen("in.txt","r",stdin);

    while(gets(s) && s[0])
    {
        t.insert( s);
    }

    while(gets(s))
    {
        printf("%d\n", t.findNum(s));
    }


    return 0;


}


HDU1671

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
#include<vector>
using namespace std;
#define MAXN 10
template<int Size>
struct trie_node
{

    bool terminable; //表示节点为字符串的结尾
    int node;       //子节点的个数
    trie_node *child[Size]; //儿子节点
    trie_node():terminable(false), node(0)
    {
        memset(child,0,sizeof(child)); //初始化节点
    }

};
template<int Size,typename Index>
class trie
{
public:
    //定义类名
    typedef trie_node<Size> node_type;
    typedef trie_node<Size> *link_type;

    //构造函数
    trie(Index i=Index()):index(i) { }

    //清空函数，用于析构
    void clear()
    {
        clear_node(root);
        for(int i=0; i<Size; i++)
            root.child[i]=0;
    }
    //插入
    template<typename Iterator>
    void insert(Iterator begin,Iterator end)
    {
        link_type cur= &root;//当前插入结点为根
        while(begin!=end)
        {
            if(cur->child[index[*begin]]) //插入过
            {
                cur=cur->child[index[*begin]];
                cur->node++;

            }
            else
            {
                cur->child[index[*begin]]=new node_type;
                cur->child[index[*begin]]->node++;
                cur=cur->child[index[*begin]];

            }
            begin++; //迭代器往前走！
        }
        cur->terminable=true;

    }

    //重载c风格插入
    void insert(const char * str)
    {
        insert(str,str+strlen(str));
    }
    
    //插入与判断
    template<typename Iterator>
    bool insert2(Iterator begin,Iterator end)
    {
        link_type cur= &root;//当前插入结点为根

         bool flag=0;
        while(begin!=end)
        {
            if(cur->child[index[*begin]]) //插入过
            {
                if(cur->child[index[*begin]]->terminable==true){


                    flag=1;
                }
                cur=cur->child[index[*begin]];
                cur->node++;

            }
            else
            {
                cur->child[index[*begin]]=new node_type;
                cur->child[index[*begin]]->node++;
                cur=cur->child[index[*begin]];

            }
            begin++; //迭代器往前走！
        }
        cur->terminable=true;
        return flag;

    }

    //重载c风格插入
    bool insert2(const char * str)
    {
        return insert2(str,str+strlen(str));
    }

    //查找
    template <typename Iterator>
    bool find(Iterator begin,Iterator end)
    {
        link_type cur=&root;
        while(begin!=end)
        {

            if(!cur->child[index[*begin]]) //没有节点啊！！！
                return false;
            cur=cur->child[index[*begin]];

            begin++;

        }
        return cur->terminable; //是否为字符串
    }
    //重载c风格
    bool find(const char *str)
    {

        return find(str,str+strlen(str));
    }

    //查找节点数目
    template <typename Iterator>
    int findNum(Iterator begin,Iterator end)
    {
        link_type cur=&root;
        while(begin!=end)
        {

            if(!cur->child[index[*begin]]) //没有节点啊！！！
                return 0;
            cur=cur->child[index[*begin]];

            begin++;

        }

        return cur->node; //是否为字符串
    }
    //重载c风格
    int findNum(const char *str)
    {

        return findNum(str,str+strlen(str));
    }



    //查找前缀
     template <typename Iterator>
    bool findPre(Iterator begin,Iterator end)
    {
        link_type cur=&root;
        while(begin!=end)
        {

            if(!cur->child[index[*begin]]) //没有节点啊！！！
                return false;

            if(cur->terminable) break;
            cur=cur->child[index[*begin]];

            begin++;

        }
        return begin!=end; //是否为字符串
    }

    bool findPre(const char *str){
        return findPre(str,str+strlen(str));

    }

    //删除字符串
    template<typename Iterator>
    bool earse (Iterator begin,Iterator end)
    {
        bool result;
        earse_node(begin,end,root,result);
        return result;


    }

    //c语言风格
    bool erase(char *str)
    {
        return earse(str,str+strlen(str));

    }

    template<typename Functor>
    void traverse(Functor &execute =Functor())
    {
        visit_node(root,execute);

    }
private:
    //访问结点
    template<typename Functor>
    void visit_node(node_type cur,Functor &execute)
    {
        execute(cur);
        for(int i=0; i<Size; i++) //dfs
        {
            if(cur.child[i]==0) continue;
            visit_node(*cur.child[i],execute);

        }
    }

    //清空
    void clear_node(node_type cur)
    {
        for(int i=0; i<Size; i++)
        {
            if(cur.child[i]==0)continue; //不存在
            clear_node(*cur.child[i]);
            delete cur.child[i];
            cur.child[i]=0;
            if(--cur.node==0) break; //没有节点了

        }

    }

    //一边搜索一边删除
    template<typename Iterator>
    bool earse_node(Iterator begin ,Iterator end,node_type &cur,bool &result)
    {
        if(begin==end)
        {
            result=cur.terminable;
            cur.terminalbe=false;
            return cur.node==0;

        }
        //当孩子不存在,结果假，返回假
        if(cur.child[index[*begin ]]==0) return !(result=false);
        else if(earse_node(begin+1,end,*(cur.child[index[*begin]]),result))
        {
            delete cur.child[index[*begin]];
            cur.child[index[*begin]]=0;
            if(--cur.node==0&&cur.terminable==false ) return true;

        }
        return false;


    }
    //根
    node_type root;


    //字符转索引，类似hash
    Index index;

};

class IndexClass
{
public:
    int operator[](const char key)
    {
        return key%MAXN; //一个映射

    }

};

char s[10000][11];
int main()
{
    trie<MAXN,IndexClass> t;


    int T,n,i;
  //  freopen("in.txt","r",stdin);
    scanf("%d",&T);

    while(T--)
    {
        scanf("%d",&n);


        t.clear();
        for(i=0;i<n;i++){

            scanf("%s",s[i]);


            t.insert(s[i]);


        }
        for(i=0;i<n;i++){


            if(t.findPre(s[i])){

                puts("NO");
                break;
            }
        }
        if(i==n) puts("YES");




    }


    return 0;


}


yaolongdeng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++前缀树trie的实现
12-25
C++实现的前缀树trie数据结构
【LeetCode】208. 实现 Trie (前缀树) 结题报告 (C++)
暮雨凉初透
10-28 484
原题地址：https://leetcode-cn.com/problems/implement-trie-prefix-tree/description/ 题目描述： 实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。 示例: Trie trie = new Trie(); trie.insert("apple"); trie.s...
认识trie
何成俭的博客
04-04 1154
1 Trie简介        Trie树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。         在本文中，对于输入的进行序列化，比如输入“单词查找树”，序列化为“单/词/查/找/树”，这样可以进行任何一种自
【trie树】insert和search操作
二十三小时
11-14 805
#include #include #include #include using namespace std; #define N 26 struct TrieNode { char *data; TrieNode* branch[N]; TrieNode() { data = NULL; for (int i = 0; i
Bitwise-trie:按位trie的C++实现
06-20
按位尝试基本说明我在这里实现的基本上是一个没有前缀机制的。 我使用std::bitset将数据映射到树上相应的叶节点。在std::bitset存储任何数据的详细描述std::bitset是位的容器。 我将任意数据存储到这样的容器中的...
C# TrieTree介绍及实现方法
09-05
C# TrieTree介绍及实现方法，需要的朋友可以参考一下
Trie树(字典树)的介绍及Java实现
08-31
Trie树，又称字典树或前缀树，关于它的结构就不详细介绍了。Trie树在单词统计、前缀匹配等很多方面有很大用处...下面这篇文章主要介绍了Trie树，以及Java实现如何Trie树，有需要的朋友可以参考借鉴，下面来一起看看吧。
省选训练赛第4场D题（多米诺骨牌）
u011044759的专栏
04-18 2889
题目来自FZU2163 多米诺骨牌 Time Limit: 1000 mSec    Memory Limit : 32768 KB  Problem Description Vasya很喜欢排多米诺骨牌。他已经厌倦了普通的多米诺骨牌，所以他用不同高度的多米诺骨牌。他从左边到右边，把n个多米诺骨牌沿一个轴放在桌子上。每一个多米诺骨牌垂直于该轴，使该轴穿过其底部的中心。第i个多米诺
每天一水SGU347
u011044759的专栏
04-08 2448
今天本来应该要写校题解报告的，但是CF跪了，一题都没JUDGE出来，最后比赛取消了~郁闷啊！ 后来闲的无事，就到处看看contest，随便点进去一个，看到一水题，几分钟写完，马上就WA了！~ 题目的信息含量太低了！我直接看样例。以为是字典序排序后连起来输出，没想到是使得最后连起来的字典序最小。 本来我因为mutilset轻松水过，后来……还是用mutilset水的。重载下小于就好了。 题目
坑爹CF April Fools Day Contest题解
u011044759的专栏
04-04 2116
H - A + B Strikes Back A + B is often used as an example of the easiest problem possible to show some contest platform. However, some scientists have observed that sometimes this problem is not
高校俱乐部(-3+1)题解
u011044759的专栏
04-10 1905
最近好久没做高校俱乐部了，今天杭电在比赛，又不想刷其他了，就随便看看。 看到一个三星题目，-3+1,第一个反应就是3n+1啦，之后暴力什么的涌现眼前。 来看题目 -3+1 题目详情: 有一个数列，所有的数都是非负整数，你可以进行如下方式进行一次操作（注意一次完整的操作必须先后完成如下两个步骤）： （1） 任选一个不小于3的数，把它减少3。 （2） 任选一个数把它增加1。
SCNU省选校赛第二场B题题解
u011044759的专栏
04-04 1888
今晚的校赛又告一段落啦，终于“开斋”了！ AC了两题，还算是满意的，英语还是硬伤。 来看题目吧！    B. Array time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard ou
异常的校省选赛第三场题解
u011044759的专栏
04-10 1739
SCNU校省选赛异常的第三场
校省选赛第一场A题Cinema题解
u011044759的专栏
04-02 1584
校省选赛A题题解
POJ3213(矩阵乘法)
u011044759的专栏
10-11 1399
PM3 Time Limit: 5000MS   Memory Limit: 131072K Total Submissions: 3036   Accepted: 1059 Description USTC has recently developed the Parallel Matrix Multiplication Machi
HDU1006、3037、2084、1176题解
u011044759的专栏
05-26 1360
最近就只有早起做题，做完就上课，周六日可以做些恶心点点的，平时要上课就只有做做DP，数学题什么的了。 HDU1006，十分恶心的一题，实际上我还不是很懂，看着kuangbin大神的代码基本对着拍，没有什么改进。 题目的意思就是时钟里有三条针，时分秒针，两两超过D度就开心，问一天有百分只几是开心的。 思路就是：模拟，区间交，关键，精度问题，这个针算是连续的～不是60秒动一下分针！ /**
HDU1004
u011044759的专栏
04-18 1331
相信很多人都做过这题目，你可以完全当做这是一条水题，但是最近在搞TRIE，就用TRIE来做。 首先，用map一次水掉了，不解释，当然也可以自己写一个map,如编程珠玑统计圣经单词那样做，一摸一样。 #include #include #include #include #include using namespace std; int main(){ int n,i; cha
校省选赛第一场D题TwoDecks题解
u011044759的专栏
04-03 1313
SCNU校省选赛第一场D题TwoDecks题解,出自(CF240D)。
线段树（单点更新）HDU1166、HDU1742
u011044759的专栏
04-10 1231
在上一篇博文里面，我提到了我不会线段树，现在就努力地学习啊！ 今天AC一题感觉都很累，可能是状态不佳，在做HDU1166这题目时候，RE了无数次。 原因是：我的宏定义写错了，我已经不是第一犯这种错误了！我的宏写成了 #ifndef ONLINE_JUDEGE  freopen("in.txt","r",stdin); #endif 就是这个错误我调了两个小时……教训！！！每次出现R
c语言字典trie树代码实现
最新发布
05-30
以下是一个简单的 C 语言字典 Trie 树的代码实现： ```c #include #include #include #define MAX_WORD_LEN 100 typedef struct TrieNode { char value; struct TrieNode *children[26]; int is_end; } ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值