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 = 26;//最大长度

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

Node::Node()
{
    for (int i = 0; i < LetterCount; i++)
    {
        next[i] = NULL;
    }
    count = 1;
    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 = 0; i < LetterCount; i++)
        {
            root->next[i] = NULL;
        }
    }
}

void Trie::Distroy(const Node* root)
{
    if (!root)
    {
        return;
    }
    for (int i = 0; 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 = 0; i < length; i++)
    {
        int index = word[i] - 'A';
        if (!(p->next[index]))//当前没有那个字母
        {
            Node* q = new Node();
            q->end = false;
            for (int j = 0; 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 = 1;
    }
    return p->count;
}

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

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

void Trie::Travel(int* arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        arr[i] = 0;
    }
    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 + 1];
    memset(count, 0, sizeof(int) * (n + 1));
}

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

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

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

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

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