第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 B-跳一跳，很简单的（字符串哈希）

思路:

$\ \ \ \ \ $首先知道一个节点的值经过$26$秒之后肯定是到回原来的值去了，那就可以建立$26$棵树， 每棵树对应每个时间的状态，然后对每一棵树进行处理，因为比较从$u$到根节点和从$v$到根节点的字典序只需要从左往右找到第一个不同的位置进行比较就行了，可以让每个结点$x$到根节点的路径字符串哈希一下，深度更大的结点对应所在字符串更左的位置，现在对比$u$, $v$的时候，比较前缀时候哈希值相同的就跳过，不同的就留着下次比较，计算固定长度前缀的哈希值可以用倍增法，预处理后时间$O(\log n)$所以总的时间复杂度是$O(26n+n\log n+Q\log n)$
$\ $

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e5 + 10;
const ll mod = 1e9 + 7;
using namespace std;

int T, n, m, kase = 1, p, q;
vector<int> G[maxn];
char s[maxn];
int val[26][maxn], fac_val[maxn], st[maxn];
int dep[maxn], anc[maxn][20], pre[maxn];
ll hs[26][maxn], pw[maxn], inv[maxn];

ll qmod(ll x, ll n) {
    ll ans = 1;
    while(n) {
        if(n & 1) ans = ans * x % mod;
        x = x * x % mod;
        n >>= 1;
    }
    return ans;
}

void preprocess() {
    pw[0] = 1; inv[0] = 1;
    memset(anc, -1, sizeof anc);
    memset(dep, 0, sizeof dep);
    for(int i = 1; i <= n; i++) {
        anc[i][0] = pre[i];
        pw[i] = pw[i - 1] * 26 % mod;
        inv[i] = qmod(pw[i], mod - 2);
    }
    for(int j = 1; (1 << j) <= n; j++) {
        for(int i = 1; i <= n; i++) {
            int t = anc[i][j - 1];
            if(~t && ~anc[t][j - 1]) anc[i][j] = anc[t][j - 1];
        }
    }
}

ll find_hash(int x, int fa, int id) {
    ll hs1 = hs[id][x], hs2 = hs[id][fa];
    hs1 -= hs2; if(hs1 < 0) hs1 += mod;
    ll iv = inv[dep[fa]];
    return iv * hs1 % mod;
}

void dfs_hash(int x, int now, ll now_hash, int d) {
    dep[x] = d;
    if(x != 1) val[now][x] = (fac_val[x] + st[x] * now) % 26;
    hs[now][x] = (now_hash + val[now][x] * pw[dep[x] - 1]) % mod;
    if(hs[now][x] < 0) hs[now][x] += mod;
    for(int i = 0; i < G[x].size(); i++) {
        int v = G[x][i];
        dfs_hash(v, now, hs[now][x], d + 1);
    }
}

int cmp(int u, int v, int id) {
    int k = min(dep[u], dep[v]) - 1;
    int lg = 0, tot = 0;
    while((1 << lg) <= k) lg++; lg--;
    for( ; lg >= 0; lg--) {
        if((1 << lg) > k) continue;
        int fu = anc[u][lg], fv = anc[v][lg];
        ll hu = find_hash(u, fu, id);
        ll hv = find_hash(v, fv, id);
        if(hu != hv) { k -= (k - (1 << lg)); }
        else { u = fu; v = fv; k -= (1 << lg); }
    }
    if(val[id][u] == val[id][v]) return 0;
    else if(val[id][u] > val[id][v]) return 1;
    else return -1;
}


int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        memset(fac_val, -1, sizeof fac_val);
        for(int i = 0; i < maxn; i++) G[i].clear();
        for(int i = 2; i <= n; i++) {
            scanf("%d %s %d", &p, s, &st[i]);
            G[p].push_back(i); pre[i] = p;
            fac_val[i] = s[0] - 'a';
        }
        pre[1] = -1; preprocess();
        for(int i = 0; i < 26; i++) {
            val[i][1] = fac_val[1] = -1;
            dfs_hash(1, i, 0, 1);
        }
        scanf("%d", &q);
        while(q--) {
            int u, v, t;
            scanf("%d %d %d", &u, &v, &t);
            int ans = cmp(u, v, t % 26);
            if(ans == 0) cout << "=" << endl;
            else if(ans == 1) cout << ">" << endl;
            else cout << "<" << endl;
        }
    }
    return 0;
}