HUST-1350 Trie

1350 - Trie

时间限制：1秒 内存限制：128兆

104 次提交 35 次通过

题目描述

In computer science, a trie, is an ordered tree data structure that is used to store an associative array where the keys are usually strings. Each position in the tree shows what key it is associated with and All the descendants of a node have a common prefix of the string associated with that node, have and only have one more character than its father node. the root of the trie is associated with the empty string. For example, if we put 6 words of “to”, “tea”, “ted”, “ten”, “a”, “inn” to a trie, it will be the form of figure.  In the computer science, a trie is a tree. For a tree, we define the leave node is the node without any descendants and only have an edge connect in. So in this example, the leave node is “to”, “tea”, “ted”, “ten”, “a” and “inn”. And we define the distance between two node is the minimum edge from a node to another node must pass. So the distance between “a” and “te” is 3, “to” and “inn” is 5. Finally, we define the value of a node is the sum of the node to the entire leave node’s distance. And the value of a tree is equal the value of a node which have the minimum value. Now give you a list of words. Put them into a trie, and calculate the value of this trie.

输入

The first line is T, indicate there are T cases. For each case, the first line is N, indicate there are N words. Next N lines, each line have a word only include the lower case letters and no two words are the same. (N<=50 and the length of a word less than 10)

输出

For each case output a line with the value of the trie.

样例输入

2
6
a
to
tea
ted
ten
inn
4
sa
sb
sc
sd

样例输出

Case #1: 13
Case #2: 5

/////////////////////////////////////
For the second case, if the root has only one child, it’s a special leaf and must be calculate.

提示

来源

Hong Zehua, HUST Campus 2009

/**
    题意：给几个字符串，构成一个字典树，求哪个节点到每个叶子的距离最短的，最短是多少
    做法：先建立一个字典树，然后求公共祖先（求得是所有点到叶子节点的最短的距离）
**/
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
#define maxn 100010
int tot =  ;
const int MAXN = ;
const int DEG = ;
int num[maxn];
int tot2 = ;
int tot3 = ;
int num1[maxn];
int indegree[maxn];
int mmap[maxn];
int mm = ;
struct Node
{
    int x;
    int y;
    int flag;
    Node() {};
    Node(int _x, int _y) {
        x = _x;
        y = _y;
        flag = ;
    }
} node[maxn << ];
struct Trie
{
    int next[maxn][], end[maxn];
    int root;
    int L;
    int newnode() {
        for(int i = ; i < ; i++) {
            next[L][i] = -;
        }
        end[L++] = ;
        return L - ;
    }
    void init() {
        L = ;
        root = newnode();
    }
    void insert(char buf[]) {
        int len = strlen(buf);
        int now = root;
        for(int i = ; i < len; i++) {
            if(next[now][buf[i] - 'a'] == -) {
                next[now][buf[i] - 'a'] = newnode();
                node[tot].y = next[now][buf[i] - 'a'] + ;
                node[tot].x = now + ;
                node[tot].flag = ;
                tot++;
            }
            now = next[now][buf[i] - 'a'];
        }
        node[tot - ].flag = ;
        num[tot2++] = node[tot - ].y;
        end[now]++;
    }
};
Trie ac;
struct Edge
{
    int to;
    int next;
} edge[MAXN * ];
int head[MAXN], tot1;
void addedge(int u, int v)
{
    edge[tot1].to = v;
    edge[tot1].next = head[u];
    head[u] = tot1++;
}
void init()
{
    tot1 = ;
    memset(head, -, sizeof(head));
}
int fa[MAXN << ][DEG];
int deg[MAXN << ];
void bfs(int root)
{
    queue<int>que;
    deg[root] = ;
    fa[root][] = root;
    que.push(root);
    while(!que.empty())
    {
        int tmp = que.front();
        que.pop();
        for(int i = ; i < DEG; i++) {
            fa[tmp][i] = fa[fa[tmp][i - ]][i - ];
        }
        for(int i = head[tmp]; i != -; i = edge[i].next)
        {   int v = edge[i].to;
            if(v == fa[tmp][]) {
                continue;
            }
            deg[v] = deg[tmp] + ;
            fa[v][] = tmp;
            que.push(v);
        }
    }
}
int LCA(int u, int v)
{
    if(deg[u] > deg[v]) {
        swap(u, v);
    }
    int hu = deg[u], hv = deg[v];
    int tu = u, tv = v;
    for(int det = hv - hu, i = ; det; det >>= , i++)
        if(det & ) {
            tv = fa[tv][i];
        }
    if(tu == tv) {
        return tu;
    }
    for(int i = DEG - ; i >= ; i--)
    {
        if(fa[tu][i] == fa[tv][i]) {
            continue;
        }
        tu = fa[tu][i];
        tv = fa[tv][i];
    }
    return fa[tu][];
}
bool flag[MAXN];
char buf[];
int main()
{
    //freopen("in.txt", "r", stdin);
    int Case = ;
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n;
        tot = ;    ///边的数目
        tot2 = ;   ///叶子节点的数目  如果根节点存在Case 2 中的情况也加进去
        tot3 = ;   ///不是叶子的节点的节点
        mm = ;
        memset(node, , sizeof(node));
        memset(indegree, , sizeof(indegree));
        memset(flag, , sizeof(flag));
        scanf("%d", &n);
        ac.init();
        for(int i = ; i < n; i++)
        {
            scanf("%s", buf);
            ac.insert(buf);
        }
        init();
        int yy = ;
        for(int i = ; i < tot; i++)
        {
            addedge(node[i].x, node[i].y);
            addedge(node[i].y, node[i].x);
            indegree[node[i].x] ++;
            indegree[node[i].y] ++;
            yy = max(yy, max(node[i].x, node[i].y));
        }
        for(int i = ; i < tot; i++) {
            if(indegree[node[i].x] == ) {
                mmap[mm++] = node[i].x;
            }
            else {
                num1[tot3++] = node[i].x;
            }
            if(indegree[node[i].y] == ) {
                mmap[mm++] = node[i].y;
            }
            else {
                num1[tot3++] = node[i].y;
            }
        }
        sort(mmap, mmap + mm);
        sort(num1, num1 + tot3);
        int newmm = unique(mmap, mmap + mm) - mmap;
        int newtot3 = unique(num1, num1 + tot3) - num1;
        bfs();
        int mmin = 0xfffffff;
        for(int i = ; i <= yy; i++)
        {
            int temp = ;
            for(int j = ; j < newmm; j++)
            {
                if(i != mmap[j]) {
                    int tt = LCA(i, mmap[j]);
                    int res = ;
                    res = abs(deg[i] - deg[tt]) + abs(deg[mmap[j]] - deg[tt]);
                    temp += res;
                }
            }
            mmin = min(mmin, temp);
        }
        printf("Case #%d: %d\n", Case++, mmin);
    }
    return ;
}