总结

P4075 [SDOI2016]模式字符串

题目描述

给出n个结点的树结构T，其中每一个结点上有一个字符，这里我们所说的字符只考虑大写字母A到Z，再给出长度为m的模式串s，其中每一位仍然是A到z的大写字母。

Alice希望知道，有多少对结点<u，v>满足T上从u到V的最短路径形成的字符串可以由模式串S重复若干次得到？

这里结点对<u，v>是有序的，也就是说<u，v>和<v，u>需要被区分。

所谓模式串的重复，是将若干个模式串S依次相接（不能重叠)。例如当S=PLUS的时候，重复两次会得到PLUSPLUS，重复三次会得到PLUSPLUSPLUS，同时要注恿，重复必须是整数次的。例如当S=XYXY时，因为必须重复整数次，所以XYXYXY不能看作是S重复若干次得到的。

输入格式

每一个数据有多组测试，

第一行输入一个整数C，表示总的测试个数。

对于每一组测试来说：

第一行输入两个整数，分别表示树T的结点个数n与模式长度m。结点被依次编号为1到n，

之后一行，依次给出了n个大写字母（以一个长度为n的字符串的形式给出），依次对应树上每一个结点上的字符（第i个字符对应了第i个结点)。

之后n-1行，每行有两个整数u和v表示树上的一条无向边，之后一行给定一个长度为m的由大写字母组成的字符串，为模式串S。

输出格式

给出C行，对应C组测试。

每一行输出一个整数，表示有多少对节点<u,v>满足从u到v的路径形成的字符串恰好是模式串的若干次重复.

输入输出样例

输入 #1

1
11 4
IODSSDSOIOI
1 2
2 3
3 4
1 5
5 6
6 7
3 8
8 9
6 10
10 11
SDOI

输出 #1

5

说明/提示

1<=C<=10，3<=∑N<=1000000，3<=∑M<=1000000

看到这题 ，弱弱的我的第一反应就是 \(n^3\) 暴力大枚举 ， 之后幸亏迷途知返，想了一个\(n^2\) 的。。。。。

就不讨论我的弱了，

正解

点分治 ， 用两个数组 \(f , g\) 分别表示前缀 ， 后缀长为 i 的点的数量 ， 之后就是按照点分治的模板 ， 改改就好了 ， 至于怎么判断是否相同，hash就行了。

我还是比较弱 ， 这种题也就算个点分治的板子 ， 以后得多练一些点分治的题。

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int N = 1010000;
typedef unsigned long long ull;
inline int read()
{
    register int x = 0; register char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0' , c = getchar();
    return x;
}
int n , m , cnt , root , all , ans;
int d[N] , head[N] , Max[N] , siz[N] , vis[N] , sf[N] , sg[N] , f[N] , g[N];
char a[N] , b[N];
ull t1[N] , t2[N] , bs[N];
struct edge{int v , nex; } e[N<<1];
inline void add(int u , int v) { e[++cnt].v = v; e[cnt].nex = head[u]; head[u] = cnt; return ; }

void getroot(int x , int fa)
{
    siz[x] = 1; Max[x] = 0;
    for(int i = head[x] , v ; i ; i = e[i].nex)
    {
        v = e[i].v; if(v == fa || vis[v]) continue;
        getroot(v , x); siz[x] += siz[v];
        Max[x] = max(Max[x] , siz[v]);
    }
    Max[x] = max(Max[x] , all - siz[x]);
    if(Max[root] > Max[x]) root = x;
    return ;
}

int getdep(int x , int fa , int dep , ull hs)
{
    hs = hs * 1331 + a[x]; int tmp = 1;
    if(hs == t1[dep]) f[(dep - 1) % m + 1]++ , ans += sg[m - (dep - 1) % m];
    if(hs == t2[dep]) g[(dep - 1) % m + 1]++ , ans += sf[m - (dep - 1) % m];
    for(int i = head[x] , v; i ; i = e[i].nex)
    {
        v = e[i].v; if(v == fa || vis[v]) continue;
        tmp = max(tmp , getdep(v , x , dep + 1 , hs) + 1);
    }
    return tmp;
}

void dfs(int x)
{
    sf[1] = sg[1] = 1; vis[x] = 1; int tmp = 0;
    for(int i = head[x] , v; i ; i = e[i].nex)
    {
        v = e[i].v; if(vis[v]) continue;
        int k = min(m , getdep(v , x , 2 , a[x]) + 1); tmp = max(tmp , k);
        for(int j = 1 ; j <= k ; ++j) sf[j] += f[j] , sg[j] += g[j] , f[j] = g[j] = 0;
    }
    for(int i = 1 ; i <= tmp ; ++i) sf[i] = sg[i] = 0;
    for(int i = head[x] ; i ; i = e[i].nex) 
    if(!vis[e[i].v])
    {
        all = siz[e[i].v]; root = 0;
        getroot(e[i].v , x); dfs(root);
    }
    return ;
}

void solve()
{
    n = read(); m = read();
    scanf("%s",a + 1);
    for(int i = 1 , u , v ; i < n ; ++i)
    {
        u = read(); v = read();
        add(u , v); add(v , u);
    }
    scanf("%s",b + 1); bs[0] = 1;
    for(int i = 1 ; i <= n ; ++i) // hash
    {
        bs[i] = bs[i-1] * 1331;
        t1[i] = t1[i-1] + bs[i-1] * b[(i-1) % m + 1];
        t2[i] = t2[i-1] + bs[i-1] * b[m - (i-1) % m];
    }
    Max[0] = 1e9; root = 0; all = n; getroot(1 , 0); dfs(root);
    printf("%d\n" , ans);
    for(int i = 1 ; i <= n ; ++i) head[i] = 0 , vis[i] = 0; cnt = 0; ans = 0;
    return ;
}

int main()
{
    // freopen("A.in" , "r" , stdin);
    // freopen("A.out" , "w" , stdout);
    int T = read(); while(T --) solve();
    fclose(stdin); fclose(stdout); return 0;
}
/*
2
11 4
IODSSDSOIOI
1 2
2 3
3 4
1 5
5 6
6 7
3 8
8 9
6 10
10 11
SDOI
11 4
IODSSDSOIOI
1 2
2 3
3 4
1 5
5 6
6 7
3 8
8 9
6 10
10 11
SDOI
*/

标签：tmp,结点,int,hs,dep,SDOI2016,字符串,P4075,重复
来源： https://www.cnblogs.com/R-Q-R-Q/p/12209889.html