POJ2945(Find the Clones)--字典树，map

题意：给你n个规定长度的单词，问你其中出现了1次的单词，出现两次的单词...出现n次单词分别有多少个。

当然这题map也能过，但是这里介绍字典树的做法。

首相对于n个单词存入树中，当然建树过程中遇到一样的单词就把那个单词最后一个结点的计数++就行。否则为这个单词是第一次建立，计数为1。

count[i]数组用来存放出现i次的字符串出现的次数。

Travel函数用来递归统计每个单词，将不同出现次数的数字记录到arr数组中，最后打印count数组即可

 #include <iostream>
 #include <string>
 #include <cstring>
 #include <fstream>
 #include <map>
 #include <algorithm>
 #include <sstream>
 #include <cstdio>
 using namespace std;

 const int LetterCount = ;//最大长度

 struct Node
 {
     Node* next[LetterCount];//结点的下一个指针
     int count;
     bool end;//标记是否为最后一个单词
     Node();
 };

 Node::Node()
 {
     for (int i = ; i < LetterCount; i++)
     {
         next[i] = NULL;
     }
     count = ;
     end = false;
 }

 class Trie
 {
 protected:
     Node* root;
     void GreateRoot();
     void Distroy(const Node* root);
     void Travel(Node* root, int* arr);
 public:
     Trie();
     ~Trie();
     int Insert(char* word);
     int Query(char* word);
     void Travel(int* arr, int n);
 };

 Trie::Trie()
 {
     root = NULL;
     GreateRoot();
 }

 Trie::~Trie()
 {
     Distroy(root);
 }

 void Trie::GreateRoot()
 {
     if (!root)//根结点为false
     {
         root = new Node();//建根
         for (int i = ; i < LetterCount; i++)
         {
             root->next[i] = NULL;
         }
     }
 }

 void Trie::Distroy(const Node* root)
 {
     if (!root)
     {
         return;
     }
     for (int i = ; i < LetterCount; i++)
     {
         if (root->next[i] != NULL)
         {
             Distroy(root->next[i]);
         }
     }
     delete[] root;
 }

 int Trie::Insert(char* word)
 {
     Node* p = root;//根结点为root
     int length = strlen(word);//计算长度
     for (int i = ; i < length; i++)
     {
         int index = word[i] - 'A';
         if (!(p->next[index]))//当前没有那个字母
         {
             Node* q = new Node();
             q->end = false;
             for (int j = ; j < LetterCount; j++)
             {
                 q->next[j] = NULL;
             }
             p->next[index] = q;
         }
         p = p->next[index];
     }
     if (p->end)
     {
         p->count++;
     }
     else
     {
         p->end = true;
         p->count = ;
     }
     return p->count;
 }

 int Trie::Query(char* word)
 {
     Node* p = root;
     bool found = true;
     int length = strlen(word);
     for (int i = ; i < length; i++)
     {
         int index = word[i] - 'A';
         p = p->next[index];
         if (!p)//p为false
         {
             found = false;//没找到
             break;
         }
     }
     if (!found || !p->end)//没找到或已经是结束标记
     {
         return ;
     }
     return p->count;//否则返回计数
 }

 void Trie::Travel(Node* root, int* arr)
 {
     if (!root)
     {
         return;
     }
     if (root->end)//表示为最后一个词
     {
         arr[root->count]++;
         return;
     }
     for (int i = ; i < LetterCount; i++)
     {
         Travel(root->next[i], arr);//递归计算
     }
 }

 void Trie::Travel(int* arr, int n)
 {
     for (int i = ; i < n; i++)
     {
         arr[i] = ;
     }
     Travel(root, arr);
 }

 class FindTheClones
 {
 protected:
     int n;
     int* count;
     Trie tree;
 public:
     FindTheClones(int n);
     ~FindTheClones();
     void Insert(char* word);
     void Travel();
     void Output() const;
 };

 FindTheClones::FindTheClones(int n)
 {
     this->n = n;
     count = new int[n + ];
     memset(count, , sizeof(int) * (n + ));
 }

 FindTheClones::~FindTheClones()
 {
     delete[] count;
 }

 void FindTheClones::Insert(char* word)
 {
     tree.Insert(word);
 }

 void FindTheClones::Travel()
 {
     tree.Travel(count, n + );
 }

 void FindTheClones::Output() const
 {
     for (int i = ; i < n + ; i++)
     {
         printf("%d\n", count[i]);
     }
 }

 int main()
 {
     int n = , m = ;
     while (scanf("%d%d", &n, &m))
     {
         if (n <= )
         {
             break;
         }
         char str[];
         FindTheClones obj(n);
         for (int i = ; i < n; i++)
         {
             scanf("%s", str);
             obj.Insert(str);
         }
         obj.Travel();
         obj.Output();
     }
     return ;
 }