字典树模板

struct Trie  //字典树结构
{
    Trie *child[26];
    int num;   //子节点数
    bool end;  //判断该字母是否为某个单词的结束字母
    Trie() //构造函数
    {
        num=0;
        end=0;
        memset(child,0,sizeof(child));
    }
};
Trie *root,*s,*lrelia;
void Create(char *str)  //插入单词
{
    s=root;
    int i=0;
    while(str[i])
    {
        int id=str[i]-'a';
        if(s->child[id]==0) //如果该字母还没有出现在字典中
        {
        s->child[id]=new Trie;
        s->num++; //子节点数+1
        s=s->child[id];
        }
        else
        {
            s=s->child[id];
        }
        i++;
    }
    s->end=1;//标记单词的最后一个字母
}
double Search(char *str)
{
    s=root;
    double len=1; //因为第一个字母必须得敲击，所以len赋值1，
    int o=strlen(str);
    /*
     既然前一个字母的子节点数决定下一个字母是否要敲击,
     我们只需要遍历第1个到len-1个字母就可以了。
    */
    for(int i=0;i<o-1;++i)
    {
        int id=str[i]-'a';
        s=s->child[id];
        if(s->num>1||s->end==1) len++;
    }
    return len;
}

 上面的模板是动态的，优点：节约空间，代码简洁，缺点：太慢了，比如POJ3630 Phone list，动态模板和静态模板相差了10倍！

静态模板：

#define mod 20071027
#define MAXN 400005
int dp[5555],num,re,p;
char a[300005];
struct Trie
{
    int child[26];
    bool end;
    Trie()
    {
      end=0;
      memset(child,0,sizeof(child));
    }
    void set()
    {
        end=0;
        memset(child,0,sizeof(child));
    }
}t[MAXN];
void Create(char *s)
{
    int root=0,i=0,id;
    while(s[i])
    {
        id=s[i]-'a';
        if(t[root].child[id]==0)
            t[root].child[id]=p++;
        root=t[root].child[id];
        i++;
    }
    t[root].end=1;
}
void Search(char *s)
{
    int root=0,i=0,id,len=strlen(s);
    for(i=0;i<len;++i)
    {
        id=s[i]-'a';
        if(t[root].child[id])
        {
            root=t[root].child[id];
            if(t[root].end)
            {
                num+=dp[re+i+1];
            }
        }
        else break;
    }
}

 更高效的静态模板：

#define mod 20071027
#define MAXN 300005
int dp[MAXN];
char a[MAXN];
struct Trie
{
    int ch[MAXN][26];
    bool val[MAXN];
    int sz;
    void clear()
    {
        sz=1;
        memset(ch[0],0,sizeof(ch[0]));
    }
    void Create(char *s)
    {
        int u=0,n=strlen(s); //u相当于根节点
        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]=1;
    }
    void Search(char *s,int pos)
    {
        int i=0,u=0;
        while(s[i]!=0&&ch[u][s[i]-'a'])
        {
            u=ch[u][s[i]-'a'];
            if(val[u])
            {
                dp[pos]=dp[pos+i+1]?dp[pos]+dp[pos+i+1]:dp[pos];
                if(dp[pos]>=mod)
                    dp[pos]-=mod;
            }
            ++i;

        }
    }
}tr;

 o(︶︿︶)o GO DIE，居然还有前向星式的模板，一维的

前向星式图解：

/*
题意: 给出n个字符串, 计算两两比较的次数. 每次比较都需要比较(str1[i] == str2[i])和 (str1[i] == '\0'各一次).
点评：
将N个字符串插入前缀树，‘\0’也插入，这样就能区分字符串的终结点
S1与S2的共同前缀S，则比较次数为len(S)*2+1
但S1与S2相同，则比较次数为 (len(S1)+1)*2 （注意：这时连'\0’都算进去了噢~，因为适用性，所以模板最好是用一维的前向星式的
*/
#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
#define MAX 1005
const int maxnode = 4001*1000+5;
const int sigma_size = 26;
typedef long long ll;
struct Trie
{
    int first[maxnode], next[maxnode]; //前向星式子建图还记得么，亲？
    int total[maxnode], ch[maxnode]; //total[i]记录每个节点被遍历的的次数，ch[i]记录字符串的值的
    int sz;  //记录ch的坐标的
    void clear()
    {
        sz = 1;
        total[0] = first[0] = next[0] = 0;
    }
   
    void insert(const char *s)
    {
        int u = 0, v, n = strlen(s);
        total[u]++;
        for(int i = 0; i <= n; ++i)
        {
            bool flag = false;
            for(v = first[u]; v != 0; v = next[v]) //前向星式遍历
            {
                if(ch[v] == s[i])
                {
                    flag = true;
                    break;
                }
            }
            if( !flag )
            {
                v = sz++; 
                total[v] = 0; //初始化
                ch[v] = s[i];
                next[v] = first[u];
                first[u] = v;
                first[v] = 0;
            }
            u = v;
            total[u]++;
        }
    }
   
    void dfs(int depth, int u, ll &ans)
    {
        if( first[u] == 0 ) ans += total[u]*(total[u]-1)*depth; //如果下面没有节点了，那么ans*=total[u]*(total[u]-1)*depth
        else
        {
            int sum = 0;
            for(int v = first[u]; v != 0; v = next[v])
                sum += total[v]*(total[u]-total[v]);  //否则计算比较次数，当前节点-相同的分支的节点的数量
            ans += (sum/2*(2*depth+1)); 
            for(int v = first[u]; v != 0; v = next[v])
                dfs(depth+1, v, ans);
        }
    }
};
int n;
char str[MAX];
Trie tr;
int main()
{
    int t = 1;
    while(~scanf("%d", &n))
    {
        if(n == 0) break;
       
        tr.clear();
        for(int i = 0; i < n; ++i)
        {
            scanf("%s", str);
            tr.insert(str);
        }
       
        ll ans = 0;
        tr.dfs(0, 0, ans);
        printf("Case %d: %lld\n", t++, ans);
    }
   
    return 0;
}