NEUOJ 719 (字典树 字典序)

题目链接:点击这里

Problem: 树上单词问题

Time limit: 1s Mem limit: 64 MB AC/Submission: 14/24 Discuss
Problem Description
现在有一颗N个节点的树（根节点为1），每条边上有一个单词。那么对于每个节点x，从根到该节点的所有单词连接起来可以组成一个长的字符串定义为str[x]。现在问题来了：对于一个询问，u和v，请问u和v的，请比较str[u]和str[v]的字典序。

Input
T<=10代表数据组数，
对于每组数据：
第一行两个正整数n<=100000,m<=100000代表节点个数和询问次数
下面n-1行：
每行两个正整数1<=a<=n,1<=b<=n，和一个字符串s(len(s)<=5,且只有小写字母)，代表a到b有一条边，以及对应的单词。
接下来的m行，代表询问：
询问的每行，两个正整数1<=u<=n,1<=v<=n，代表询问的两个节点

Output
对于每组询问，
如果str[u]的字典序比str[v]小，输出”small”
如果str[u]的字典序比str[v]大，输出”big”
如果srt[u]的字典序和str[v]一样，输出”equal”

Sample Input
1
7 5
1 2 a
1 3 aba
2 4 a
2 5 b
5 6 a
5 7 ab
3 7
6 3
2 3
4 3
6 7

Sample Output
small
equal
small
small
small

题意:给定一棵树,权值为长度小于等于5的字符串,求根节点到u的字符串和根节点到v的字符串的字典序关系.

对原树dfs建字典树,记录下每个原树节点在字典树上的节点编号,然后对字典树按照按照类似于先序遍历的方式dfs一遍记录下每一个节点的dfs序,最后比较两个节点的字典序关系只需要判断dfs序的相对关系就好了.

#include <bits/stdc++.h>
using namespace std;
#define maxn 111111
#define mod 1000000007

int root;
struct E {
    int v, next;
    char s[11];
}edge[maxn<<2];
int head[maxn], cnt;
int n, m;

void add_edge (int u, int v, char *a) {
    edge[cnt].v = v, edge[cnt].next = head[u];
    for (int i = 0; ; i++) {
        edge[cnt].s[i] = a[i];
        if (a[i] == 0)
            break;
    }
    head[u] = cnt++;
}

struct node {
    int next[33];
}tree[maxn*11];
int tot;

int new_node () {
    ++tot;
    memset (tree[tot].next, -1, sizeof tree[tot].next);
    return tot;
}

int f[maxn];

void insert (int root, char *s, int u) {
    int len = strlen (s);
    int p = root;
    for (int i = 0; i < len; i++) {
        int id = s[i]-'a';
        if (tree[p].next[id] == -1) {
            tree[p].next[id] = new_node ();
        }
        p = tree[p].next[id];
    }
    f[u] = p;
}

void dfs (int u, int fa) {
    for (int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if (v == fa)
            continue;
        insert (f[u], edge[i].s, v);
        dfs (v, u);
    }
}

int dfn[maxn*11], dfs_clock;

void dfs2 (int u) {
    dfn[u] = dfs_clock++;
    for (int i = 0; i < 26; i++) {
        if (tree[u].next[i] != -1) {
            dfs2 (tree[u].next[i]);
        }
    }
}

int main () {
    //freopen ("in", "r", stdin);
    int t;
    scanf ("%d", &t);
    while (t--) {
        tot = 0;
        root = new_node ();
        f[1] = 1;
        memset (head, -1, sizeof head);
        cnt = 0;
        scanf ("%d%d", &n, &m);
        for (int i = 1; i < n; i++) {
            int u, v;
            char s[11];
            scanf ("%d%d%s", &u, &v, s);
            add_edge (u, v, s);
            add_edge (v, u, s);
        }
        dfs (1, 0);
        dfs_clock = 0;
        dfs2 (1);
        while (m--) {
            int u, v;
            scanf ("%d%d", &u, &v);
            if (dfn[f[u]] == dfn[f[v]]) {
                printf ("equal\n");
            }
            else if (dfn[f[u]] > dfn[f[v]]) {
                printf ("big\n");
            }
            else {
                printf ("small\n");
            }
        }
    }
    return 0;
}