When we display a string on a LED screen, there may be different energy consumptions for displaying different characters. Given a string S with length n consisting of lowercase English letters and the energy consumption of each letter. Assume that the energy consumption of a string is the sum of the energy consumptions of all its characters. Please find the k-th smallest energy consumption of all the different substrings of S. Note that a substring of a string S is a contiguous subsequence of S. We say two strings S and T are different if the lengths of them are different or there exists at least one position i satisfying S[i] ̸= T[i].
Input
The first line of the input contains an integer T (1 ≤ T ≤ 2 × 103 ) — the number of test cases. The first line of each test case contains two integers n (1 ≤ n ≤ 105 ) and k (1 ≤ k ≤ n(n+1) 2 ). The second line of each test case contains a string S with length n consisting of lowercase English letters. The third line of each test case contains 26 integers ca, cb, . . . , cz (1 ≤ cα ≤ 100) — the energy consumption of each letter. It is guaranteed that the sum of n among all test cases does not exceed 8 × 105 .
Output
For each test case, output a single integer in a separate line — the k-th smallest energy consumption, or −1 if there is no answer.
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 9;
char s[N];
int n, c[26];
long long k;
template <int N, int sigma> struct Suffix_Automaton {
int tot, last, nxt[N * 2][sigma], len[N * 2], link[N * 2];
int sum[N], pos[N * 2];
vector<int> ch[N * 2];
void init(int n) {
tot = last = 0; link[0] = -1;
memset(nxt, 0, (n * 2 + 5) * sigma * sizeof(int));
memset(pos, 0, (n * 2 + 5) * sizeof(int));
for (int i = 0; i < n * 2 + 5; ++i) ch[i].clear();
}
void add_char(int c) {
int p = last, cur = last = ++tot; len[cur] = len[p] + 1;
while (~p && !nxt[p][c]) { nxt[p][c] = cur; p = link[p]; }
if (p == -1) { link[cur] = 0; return; }
int q = nxt[p][c];
if (len[q] == len[p] + 1) { link[cur] = q; return; }
int _q = ++tot; len[_q] = len[p] + 1;
memcpy(nxt[_q], nxt[q], sigma * sizeof(int));
link[_q] = link[q]; link[q] = link[cur] = _q;
while (~p && nxt[p][c] == q) { nxt[p][c] = _q; p = link[p]; }
}
void dfs(int u) {
for (int v : ch[u]) dfs(v);
if (!pos[u]) pos[u] = pos[ch[u][0]];
}
void add_string(const char s[], int n) {
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + c[s[i] - 'a'];
add_char(s[i] - 'a');
pos[last] = i;
}
for (int i = 1; i <= tot; ++i) {
ch[link[i]].push_back(i);
}
dfs(0);
}
bool check(int C) {
long long cnt = 0;
for (int i = 1; i <= tot; ++i) {
int P = pos[i], L = P - len[i] + 1, R = P - len[link[i]];
while (L < R) {
int M = (L + R) >> 1;
if (sum[P] - sum[M - 1] <= C) R = M;
else L = M + 1;
}
if (sum[P] - sum[L - 1] <= C) cnt += P - len[link[i]] - L + 1;
}
return cnt >= k;
}
};
Suffix_Automaton<N, 26> sam;
void solve() {
scanf("%d %lld", &n, &k);
scanf("%s", s + 1);
for (int i = 0; i < 26; ++i) {
scanf("%d", c + i);
}
sam.init(n);
sam.add_string(s, n);
int L = 1, R = sam.sum[n];
while (L < R) {
int M = (L + R) >> 1;
if (sam.check(M)) R = M;
else L = M + 1;
}
if (sam.check(L)) printf("%d\n", L);
else printf("-1\n");
}
int main() {
int T; scanf("%d", &T);
while (T--) solve();
return 0;
}