字典树模板

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;
}