Codeforces Round #337 Alphabet Permutations

E. Alphabet Permutations

time limit per test: 

1 second

memory limit per test: 

512 megabytes

input: 

standard input

output: standard output

You are given a string s of length n, consisting of first k lowercase English letters.

We define a c-repeat of some string q as a string, consisting of c copies of the string q. For example, string "acbacbacbacb" is a 4-repeat of the string "acb".

Let's say that string a contains string b as a subsequence, if string b can be obtained from a by erasing some symbols.

Let p be a string that represents some permutation of the first k lowercase English letters. We define function d(p) as the smallest integer such that a d(p)-repeat of the string p contains string s as a subsequence.

There are m operations of one of two types that can be applied to string s:

1. Replace all characters at positions from li to ri by a character ci.
2. For the given p, that is a permutation of first k lowercase English letters, find the value of function d(p).

All operations are performed sequentially, in the order they appear in the input. Your task is to determine the values of function d(p) for all operations of the second type.

Input

The first line contains three positive integers n, m and k (1 ≤ n ≤ 200 000, 1 ≤ m ≤ 20000, 1 ≤ k ≤ 10) — the length of the string s, the number of operations and the size of the alphabet respectively. The second line contains the string s itself.

Each of the following lines m contains a description of some operation:

1. Operation of the first type starts with 1 followed by a triple li, ri and ci, that denotes replacement of all characters at positions from lito ri by character ci (1 ≤ li ≤ ri ≤ n, ci is one of the first k lowercase English letters).
2. Operation of the second type starts with 2 followed by a permutation of the first k lowercase English letters.

Output

For each query of the second type the value of function d(p).

Sample test(s)

input

7 4 3
abacaba
1 3 5 b
2 abc
1 4 4 c
2 cba

output

6
5

Note

After the first operation the string s will be abbbbba.

In the second operation the answer is 6-repeat of abc: ABcaBcaBcaBcaBcAbc.

After the third operation the string s will be abbcbba.

In the fourth operation the answer is 5-repeat of cba: cbAcBacBaCBacBA.

Uppercase letters means the occurrences of symbols from the string s.

思路：容易证明答案等于1+字符串中相邻字符对不可成为置换串（模式串）子串的对数。

本题关键是如何充分利用题目信息降低计算复杂度。由于操作1和操作2有2e4次，显然不能每次遍历文本串。

注意到串是定长的，因此字符对数固定，而字符相邻关系可以用k * k矩阵表示。

考虑问题的反面，只需计数文本串中所有相邻字符对满足可成为模式串子串的对数。

k*k矩阵记录当前串中字符i与字符j相邻的相邻字符对对数。这样记录的目的是为了应对模式串的改变。

用线段树储存字符串子串相邻字符对出现次数的信息，这样同时标记端点字符即可进行子串的合并。

代码：

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define lson (u << 1)
 #define rson (u << 1 | 1)
 using namespace std;
 const int maxn = 2e5 + ;
 char T[maxn], P[];
 int n, m, k;
 struct Seg{
     int l, r;
     char left, right;
     int lazy;
     int mt[][];
 }seg[maxn << ];

 void push_up(int u){
     memset(seg[u].mt, , sizeof seg[u].mt);
     for(int i = ; i < k; i++) for(int j = ; j < k; j++) seg[u].mt[i][j] += seg[lson].mt[i][j] + seg[rson].mt[i][j];
     seg[u].left = seg[lson].left, seg[u].right = seg[rson].right;
     seg[u].mt[seg[lson].right - 'a'][seg[rson].left - 'a']++;
 }

 void build(int u, int l, int r){
     seg[u].l = l, seg[u].r = r;
     seg[u].left = T[l], seg[u].right = T[r - ];
     seg[u].lazy = ;
     memset(seg[u].mt, , sizeof seg[u].mt);
     if(r - l < ) return;
     int mid = (l + r) >> ;
     build(lson, l, mid), build(rson, mid, r);
     push_up(u);
 }

 void push_down(int u){
     if(!seg[u].lazy) return;
     memset(seg[lson].mt, , sizeof seg[lson].mt);
     memset(seg[rson].mt, , sizeof seg[rson].mt);
     seg[lson].mt[seg[u].left - 'a'][seg[u].left - 'a'] = seg[lson].r - seg[lson].l - ;
     seg[rson].mt[seg[u].left - 'a'][seg[u].left - 'a'] = seg[rson].r - seg[rson].l - ;
     seg[u].lazy = ;
     seg[lson].lazy = seg[rson].lazy = ;
     seg[lson].left = seg[rson].left = seg[lson].right = seg[rson].right = seg[u].left;
 }

 void cover(int u, int l, int r, int L, int R, char ch){
     if(l == L && r == R){
         memset(seg[u].mt, , sizeof seg[u].mt);
         seg[u].left = seg[u].right = ch;
         seg[u].lazy = ;
         seg[u].mt[ch - 'a'][ch - 'a'] = r - l - ;
         return;
     }
     push_down(u);
     int mid = (l + r) >> ;
     if(R <= mid) cover(lson, l, mid, L, R, ch);
     else if(L >= mid) cover(rson, mid, r, L, R, ch);
     else{
         cover(lson, l, mid, L, mid, ch);
         cover(rson, mid, r, mid, R, ch);
     }
     push_up(u);
 }

 int getAns(){
     int ans = ;
     for(int i = ; i < k; i++) for(int j = i + ; j < k; j++){
         ans += seg[].mt[P[i] - 'a'][P[j] - 'a'];
     }
     ans = n - ans;
     return ans;
 }

 int main(){
     //freopen("in.txt", "r", stdin);
     while(~scanf("%d%d%d", &n, &m, &k)){
         scanf("%s", T + );
         build(, , n + );
         char ch;
         for(int i = , op, l, r; i < m; i++){
             scanf("%d", &op);
             if(op == ){
                 scanf("%d%d %c", &l, &r, &ch);
                 cover(, , n + , l, r + , ch);
             }else{
                 scanf("%s", P);
                 int ans = getAns();
                 printf("%d\n", ans);
             }
         }
     }
     return ;
 }