text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int ch[100005][26], ed[100005], fail[100005], output[100005];
int rt = 1, tot = 1;
void insert(string &T, int id) {
int t = T.length();
int n = rt;
for (int i = (0); i <= (t - 1); i += (1)) {
int x = T[i] - 'a';
if (!ch[n][x]) ch[n][x] = ++tot;
n = ch[n][x];
}
ed[n] = id;
}
queue<int> bfs;
void Aho_Corasick() {
bfs.push(rt);
for (int i = (0); i <= (25); i += (1)) {
if (ch[rt][i]) fail[ch[rt][i]] = rt;
}
while (!bfs.empty()) {
int u = bfs.front();
bfs.pop();
for (int i = (0); i <= (25); i += (1)) {
int v = ch[u][i];
if (!v) continue;
int f = fail[u];
while (f && !ch[f][i]) f = fail[f];
if (!f)
f = rt;
else
f = ch[f][i];
fail[v] = f;
if (ed[f])
output[v] = f;
else
output[v] = output[f];
bfs.push(v);
}
}
}
int occ[100005], len[100005];
queue<int> pos[100005];
int ans[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string S;
int n;
cin >> S >> n;
int s = S.length();
for (int i = (1); i <= (n); i += (1)) {
string T;
int k;
cin >> k >> T;
occ[i] = k;
len[i] = T.length();
insert(T, i);
}
Aho_Corasick();
for (int i = (1); i <= (n); i += (1)) ans[i] = 1000000000;
int j = 1;
for (int i = (0); i <= (s - 1); i += (1)) {
int x = S[i] - 'a';
while (j && !ch[j][x]) j = fail[j];
if (!j)
j = rt;
else
j = ch[j][x];
int tj = j;
while (tj) {
if (ed[tj]) {
int id = ed[tj];
pos[id].push(i);
while (pos[id].size() > occ[id]) pos[id].pop();
if (pos[id].size() == occ[id]) {
ans[id] = min(ans[id], i - pos[id].front() + len[id]);
}
}
tj = output[tj];
}
}
for (int i = (1); i <= (n); i += (1)) {
printf("%d\n", (ans[i] == 1000000000) ? -1 : ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const unsigned long long base = 233;
const int maxn = 100005;
unsigned long long Pow[maxn], Hs[maxn];
char s[maxn], qr[maxn];
int n, q, k[maxn], l[maxn], len[maxn], cnt;
unordered_map<unsigned long long, int> id[maxn];
vector<int> pos[maxn];
inline unsigned long long SegHs(int l, int r) {
return Hs[r] - Hs[l - 1] * Pow[r - l + 1];
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
Pow[0] = 1;
for (int i = 1; i <= n; ++i)
Pow[i] = Pow[i - 1] * base, Hs[i] = Hs[i - 1] * base + s[i];
read(q);
for (int i = 1; i <= q; ++i) {
read(k[i]), scanf("%s", qr + 1);
unsigned long long Nhs = 0;
l[i] = strlen(qr + 1);
for (int j = 1; j <= l[i]; ++j) Nhs = Nhs * base + qr[j];
id[l[i]][Nhs] = i;
len[++cnt] = l[i];
}
sort(len + 1, len + cnt + 1);
cnt = unique(len + 1, len + cnt + 1) - len - 1;
for (int i = 1; i <= cnt; ++i) {
int nowl = len[i];
for (int ql = 1, qr = nowl; qr <= n; ql++, qr++) {
unsigned long long tmp = SegHs(ql, qr);
if (id[nowl].count(tmp)) pos[id[nowl][tmp]].push_back(ql);
}
}
for (int i = 1; i <= q; ++i) {
int ans = 1e9;
for (int ql = 0, qr = k[i] - 1; qr < pos[i].size(); ++ql, ++qr)
ans = min(ans, (pos[i][qr] + l[i] - 1) - pos[i][ql] + 1);
printf("%d\n", ans == 1e9 ? -1 : ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char S[N], T[N];
const int BLOCK = 100;
int BIG(int k) {
string s(S), t(T);
s = t + "#" + s;
int n = s.size(), m = t.size();
vector<int> p(n);
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 and s[i] != s[j]) {
j = p[j - 1];
}
if (s[i] == s[j]) j++;
p[i] = j;
}
vector<int> v;
for (int i = m + m; i < n; i++) {
if (p[i] == m) v.emplace_back(i);
}
if (v.size() < k) return -1;
int ans = 1e9;
for (int i = k - 1; i < v.size(); i++) {
ans = min(ans, v[i] - v[i - k + 1]);
}
return ans + m;
}
int ans[N];
struct state {
int to[26];
int depth;
int suffLink;
int par;
int parLet;
int nxt[26];
} states[N];
int totNodes = 1;
int add(char *str) {
int cur = 1;
int len = strlen(str);
for (int i = 0; i < len; i++) {
char c = str[i];
if (!states[cur].to[c - 'a']) {
states[cur].to[c - 'a'] = ++totNodes;
states[totNodes].par = cur;
states[totNodes].depth = states[cur].depth + 1;
states[totNodes].parLet = c - 'a';
}
cur = states[cur].to[c - 'a'];
}
return cur;
}
int who[N];
int kk[N];
vector<int> g[N];
void pushLinks() {
queue<int> Q;
Q.push(1);
while (!Q.empty()) {
int node = Q.front();
Q.pop();
if (states[node].depth <= 1) {
states[node].suffLink = 1;
} else {
int cur = states[states[node].par].suffLink;
int parLet = states[node].parLet;
while (cur > 1 and !states[cur].to[parLet]) {
cur = states[cur].suffLink;
}
if (states[cur].to[parLet]) {
cur = states[cur].to[parLet];
}
states[node].suffLink = cur;
}
if (node != 1) g[states[node].suffLink].push_back(node);
for (int i = 0; i < 26; i++) {
if (states[node].to[i]) {
Q.push(states[node].to[i]);
}
}
}
}
vector<int> idx[N];
vector<int> nodes;
vector<int> pos[N];
void dfs(int u, int p) {
if (who[u]) {
nodes.push_back(who[u]);
}
for (auto id : idx[u]) {
for (auto v : nodes) {
pos[v].emplace_back(id);
}
}
for (auto v : g[u]) {
if (v == p) continue;
dfs(v, u);
}
if (who[u]) {
nodes.pop_back();
}
}
int sz[N];
int main() {
scanf("%s", S);
int Q;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
int k;
scanf("%d %s", &k, &T);
int m = strlen(T);
if (m > BLOCK) {
ans[i] = BIG(k);
} else {
who[add(T)] = i;
kk[i] = k;
sz[i] = m;
}
}
pushLinks();
int len = strlen(S);
int cur = 1;
for (int i = 0; i < len; i++) {
int c = S[i] - 'a';
while (cur > 1 and !states[cur].to[c]) {
cur = states[cur].suffLink;
}
if (states[cur].to[c]) {
cur = states[cur].to[c];
}
idx[cur].push_back(i);
}
dfs(1, -1);
for (int i = 1; i <= Q; i++) {
if (!kk[i]) continue;
int k = kk[i];
if (pos[i].size() < k) {
ans[i] = -1;
continue;
}
sort(pos[i].begin(), pos[i].end());
ans[i] = 1e9;
for (int j = k - 1; j < pos[i].size(); j++) {
ans[i] = min(ans[i], pos[i][j] - pos[i][j - k + 1]);
}
ans[i] += sz[i];
}
for (int i = 1; i <= Q; i++) {
printf("%d ", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int A = 179;
int B = 1e9 + 7;
int n = s.size();
vector<long long> h = {1 + ((char)s[0] - 'a')}, p = {1};
for (int i = 1; i < n; ++i) {
h.push_back((h[i - 1] * A + 1 + ((char)s[i] - 'a')) % B);
p.push_back((p[i - 1] * A) % B);
}
p.push_back((p[n - 1] * A) % B);
int m;
cin >> m;
vector<vector<pair<int, int> > > str(n + 1);
vector<bool> len(n + 1);
vector<int> X(m);
for (int i = 0; i < m; ++i) {
int t;
string st;
cin >> t >> st;
X[i] = t;
len[st.size()] = true;
long long sst = 1 + ((char)(st[0]) - 'a');
for (int j = 1; j < st.size(); ++j) {
sst = (sst * A + ((char)st[j] - 'a') + 1) % B;
}
str[st.size()].push_back({i, sst});
}
vector<int> anz(m);
for (int l = 0; l < n + 1; ++l) {
if (len[l]) {
int cnt = 1;
unordered_map<int, int> mp;
vector<vector<int> > c(1);
for (int j = 0; j < str[l].size(); ++j) {
int now = str[l][j].second;
if (!mp.count(now)) {
mp[now] = cnt;
cnt += 1;
c.push_back({});
}
}
for (int i = 0; i + l - 1 < n; ++i) {
long long now = h[i + l - 1];
int left = i - 1;
if (left >= 0) {
now = (now - p[l] * h[left] + B) % B;
now = (now + B) % B;
}
if (mp.count(now)) {
c[mp[now]].push_back(i);
}
}
for (int j = 0; j < str[l].size(); ++j) {
int now = str[l][j].second;
vector<int> a = c[mp[now]];
int ind = str[l][j].first;
int x = X[ind];
if (a.size() < x) {
anz[ind] = -1;
} else {
int ans = l + a[x - 1] - a[0];
for (int i = x; i < a.size(); ++i) {
ans = min(ans, l + a[i] - a[i - x + 1]);
}
anz[ind] = ans;
}
}
}
}
for (int q = 0; q < m; ++q) {
cout << anz[q] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000005;
const long long INFLL = 1000000000000000002ll;
const long long MOD = 1000000009;
inline long long min(long long a, long long b, long long c) {
return min(min(a, b), c);
}
inline long long min(long long a, long long b, long long c, long long d) {
return min(min(min(a, b), c), d);
}
inline long long max(long long a, long long b, long long c) {
return max(max(a, b), c);
}
inline long long max(long long a, long long b, long long c, long long d) {
return max(max(max(a, b), c), d);
}
int Ans[100005], K[100005], L[100005], Q;
string S;
vector<int> Pos[100005];
struct AhoCorasick {
struct Node {
bool dictionary_fail;
int word;
Node *next[26];
Node *parent;
Node *fail;
Node() {
for (int i = (0); i <= (25); i++) next[i] = NULL;
dictionary_fail = false;
word = 0;
}
};
Node *root;
AhoCorasick() { root = new Node(); }
void add(string s, int id) {
Node *n = root;
for (int i = (0); i <= (((int)s.size()) - 1); i++) {
int l = s[i] - 'a';
if (n->next[l] == NULL) {
n->next[l] = new Node();
n->next[l]->parent = n;
}
n = n->next[l];
}
n->word = id;
}
string getWord(Node *n) {
string ret;
while (n != root) {
Node *p = n->parent;
for (int l = (0); l <= (25); l++)
if (p->next[l] == n) ret += (char)(l + 'a');
n = n->parent;
}
reverse(ret.begin(), ret.end());
return ret;
}
void printWords() {
queue<Node *> q;
q.push(root);
while (!q.empty()) {
Node *n = q.front();
q.pop();
if (n->word) cout << getWord(n) << "\n";
for (int l = (0); l <= (25); l++)
if (n->next[l] != NULL) q.push(n->next[l]);
}
}
void makeFail() {
queue<Node *> q;
root->fail = root;
q.push(root);
while (!q.empty()) {
Node *n = q.front();
q.pop();
for (int l = (0); l <= (25); l++)
if (n->next[l] != NULL) {
Node *child = n->next[l];
Node *suf = n->fail;
while (suf->next[l] == NULL) {
if (suf == root) break;
suf = suf->fail;
}
if (suf->next[l] != NULL && suf->next[l] != child)
child->fail = suf->next[l];
else
child->fail = suf;
child->dictionary_fail =
child->fail->word | child->fail->dictionary_fail;
q.push(n->next[l]);
}
}
}
void match(string t) {
Node *n = root;
for (int i = (0); i <= (((int)t.size()) - 1); i++) {
int l = t[i] - 'a';
while (n->next[l] == NULL) {
if (n == root) break;
n = n->fail;
}
if (n->next[l] != NULL) n = n->next[l];
Node *suf = n;
while (suf->word || suf->dictionary_fail) {
if (suf->word) Pos[suf->word].push_back(i);
suf = suf->fail;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
AhoCorasick aho;
cin >> S >> Q;
for (int q = (1); q <= (Q); q++) {
string t;
cin >> K[q] >> t;
L[q] = ((int)t.size());
aho.add(t, q);
}
aho.makeFail();
aho.match(S);
for (int q = (1); q <= (Q); q++) {
if (((int)Pos[q].size()) < K[q]) {
cout << "-1\n";
continue;
}
int ans = INF;
for (int i = (K[q] - 1); i <= (((int)Pos[q].size()) - 1); i++)
ans = min(ans, Pos[q][i] - Pos[q][i - K[q] + 1]);
cout << ans + L[q] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
string S, M[100001];
int N, K[100001];
struct Node {
int child[26];
int link;
vector<int> tokens;
Node() {
for (int i = 0; i < 26; i++) child[i] = 0;
link = 0;
}
};
vector<struct Node> trie;
int getchild(int node, int target) {
if (trie[node].child[target] == 0) {
trie[node].child[target] = trie.size();
trie.emplace_back();
}
return trie[node].child[target];
}
void insert(string s, int ind) {
int cur = 0;
for (int i = 0; i < (int)s.length(); i++)
cur = getchild(cur, (int)(s[i] - 'a'));
trie[cur].tokens.push_back(ind);
}
vector<int> ind[100001];
int store[100001][26];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> S >> N;
trie.emplace_back();
for (int i = 0; i < N; i++) {
cin >> K[i] >> M[i];
insert(M[i], i);
}
queue<int> q;
q.push(0);
vector<int> v;
while (!q.empty()) {
int X = q.front();
q.pop();
if (X != 0) v.push_back(X);
for (int i = 0; i < 26; i++)
if (trie[X].child[i] != 0) q.push(trie[X].child[i]);
}
for (int i = 0; i <= 100000; i++)
for (int j = 0; j < 26; j++) store[i][j] = -1;
for (int i : v) {
for (int j = 0; j < 26; j++) {
int cur = trie[i].link;
while (trie[cur].child[j] == 0 && cur != 0) {
if (store[cur][j] != -1) {
cur = store[cur][j];
break;
}
cur = trie[cur].link;
}
int temp = trie[i].link;
while (trie[temp].child[j] == 0 && temp != 0) {
if (store[temp][j] != -1) break;
store[temp][j] = cur;
temp = trie[temp].link;
}
cur = trie[cur].child[j];
if (trie[i].child[j] == 0)
trie[i].child[j] = cur;
else
trie[trie[i].child[j]].link = cur;
}
}
for (int i = 0; i < (int)v.size(); i++)
trie[v[i]].tokens.insert(trie[v[i]].tokens.end(),
trie[trie[v[i]].link].tokens.begin(),
trie[trie[v[i]].link].tokens.end());
int cur = 0;
for (int i = 0; i < (int)S.length(); i++) {
cur = trie[cur].child[(int)S[i] - 'a'];
for (int j : trie[cur].tokens) ind[j].push_back(i);
}
for (int i = 0; i < N; i++) {
if ((int)ind[i].size() < K[i]) {
cout << -1 << endl;
continue;
}
int ans = 2001001001;
for (int j = 0; j + K[i] - 1 < (int)ind[i].size(); j++)
ans = min(ans, ind[i][j + K[i] - 1] - ind[i][j]);
cout << ans + (int)M[i].length() << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int ms = int(1e5) + 10;
vector<int> occur[ms];
int ans[ms], cnt[ms];
string m[ms];
template <const int ALPHA = 26, class T = std::string, const int off = 'a'>
struct Aho {
struct Node {
int to[ALPHA];
int size;
int fail, pfail;
int present;
Node() {
for (int i = 0; i < ALPHA; i++) {
to[i] = 0;
}
size = 0;
pfail = fail = 0;
present = 0;
}
};
Aho() { nodes.push_back(Node()); }
int addString(const T &str, int idx) {
int on = 0;
for (auto ch : str) {
if (nodes[on].to[ch - off] == 0) {
nodes[on].to[ch - off] = (int)nodes.size();
nodes.push_back(Node());
nodes.back().size = 1 + nodes[on].size;
}
on = nodes[on].to[ch - off];
}
nodes[on].present = idx;
return on;
}
void build() {
std::queue<int> que;
que.push(0);
while (!que.empty()) {
int on = que.front();
que.pop();
nodes[on].pfail = nodes[nodes[on].fail].present
? nodes[on].fail
: nodes[nodes[on].fail].pfail;
for (int i = 0; i < ALPHA; i++) {
int &to = nodes[on].to[i];
if (to) {
nodes[to].fail = on == 0 ? 0 : nodes[nodes[on].fail].to[i];
que.push(to);
} else {
to = nodes[nodes[on].fail].to[i];
}
}
}
}
void search(string &s) {
int at = 0, n = s.size();
for (int i = 0; i < n; i++) {
at = nodes[at].to[s[i] - off];
int temp = at;
if (!nodes[temp].present) temp = nodes[temp].pfail;
while (temp != 0) {
int idx = nodes[temp].present;
occur[idx].push_back(i - m[idx].size() + 1);
if (occur[idx].size() >= cnt[idx]) {
ans[idx] =
min(ans[idx], i - occur[idx][occur[idx].size() - cnt[idx]] + 1);
}
temp = nodes[temp].pfail;
}
}
}
std::vector<Node> nodes;
};
int main() {
ios::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
int t;
cin >> t;
Aho<> aut;
for (int i = 1; i <= t; i++) {
cin >> cnt[i] >> m[i];
aut.addString(m[i], i);
}
aut.build();
memset(ans, 0x3f, sizeof ans);
aut.search(s);
for (int i = 1; i <= t; i++) cout << (ans[i] > 1e9 ? -1 : ans[i]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = N * 2;
const int S = 28;
char s[N], t[N];
int n, k[N], len[N], lent;
bool used[N];
vector<int> pos[N];
int cnt = 0;
struct node {
int son[S];
int fail, id;
inline void rootclear(int root) {
fail = root;
id = 0;
memset(son, 0, sizeof(son));
}
} AC[M];
void insert(char *s, int id) {
int now = len[id], root = len[id];
for (int i = 0; i < len[id]; i++) {
int c = s[i] - 'a' + 1;
if (AC[now].son[c] == 0) {
AC[now].son[c] = ++cnt;
AC[cnt].rootclear(root);
}
now = AC[now].son[c];
}
AC[now].id = id;
}
queue<int> team;
void BuildAC(int root) {
for (int i = 1; i <= 26; i++)
if (AC[root].son[i]) {
AC[AC[root].son[i]].fail = root;
team.push(AC[root].son[i]);
} else
AC[root].son[i] = root;
while (!team.empty()) {
int now = team.front();
team.pop();
int fail = AC[now].fail;
for (int i = 1; i <= 26; i++) {
int tmp = AC[now].son[i];
if (tmp) {
AC[tmp].fail = AC[fail].son[i];
team.push(tmp);
} else
AC[now].son[i] = AC[fail].son[i];
}
}
}
void match(int root, char *s, int len) {
int now = root;
for (int i = 0; i < len; i++) {
int c = s[i] - 'a' + 1;
now = AC[now].son[c];
if (AC[now].id) pos[AC[now].id].push_back(i);
}
}
int main() {
scanf("%s", t);
scanf("%d", &n);
lent = strlen(t);
for (int i = 1; i <= lent; i++) {
cnt++;
AC[cnt].rootclear(cnt);
}
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++) {
scanf("%d", &k[i]);
scanf("%s", s);
len[i] = strlen(s);
insert(s, i);
used[len[i]] = 1;
}
for (int i = 1; i <= lent; i++)
if (used[i]) {
BuildAC(i);
match(i, t, lent);
}
for (int i = 1; i <= n; i++) {
if (pos[i].size() < k[i])
printf("%d\n", -1);
else {
int ans = lent;
for (int j = 0; j <= pos[i].size() - k[i]; j++)
ans = min(ans, pos[i][j + k[i] - 1] - pos[i][j] + len[i]);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 1e9 + 7, INF = 1e6;
int t, n, k[N], sz[N], ind[N], q, ans[N], pos[N];
vector<int> V[N];
vector<pair<int, int> > a;
vector<pair<pair<int, int>, int> > p;
string second;
void search1(string t, int ind) {
int l = 1, r = n, L = n + 1, R = 0;
while (l <= r) {
int mid = (l + r) / 2;
string subs = "";
for (int i = pos[mid]; i < second.size(); i++) {
subs += second[i];
if (subs.size() == t.size()) break;
}
if (subs < t) {
l = mid + 1;
} else {
L = mid;
r = mid - 1;
}
}
l = 1;
r = n;
while (l <= r) {
int mid = (l + r) / 2;
string subs = "";
for (int i = pos[mid]; i < second.size(); i++) {
subs += second[i];
if (subs.size() == t.size()) break;
}
if (subs <= t) {
l = mid + 1;
R = mid;
} else
r = mid - 1;
}
if (L <= R) {
for (int i = L; i <= R; i++) {
V[pos[i]].push_back(ind);
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> second;
n = second.size();
second = '#' + second;
int Lg = log2(n) + 1;
for (int i = 1; i <= n; i++) {
a.push_back({second[i] - 'a', i});
}
sort(a.begin(), a.end());
int cur = 0;
for (int i = 0; i < n; i++) {
if (!i || a[i].first != a[i - 1].first) cur++;
ind[a[i].second] = cur;
}
for (int i = 1; i <= Lg; i++) {
p.clear();
for (int j = 1; j <= n; j++) {
p.push_back({{ind[j], ind[j + (1 << (i - 1))]}, j});
}
sort(p.begin(), p.end());
cur = 0;
for (int j = 0; j < n; j++) {
if (!j || p[j].first.first != p[j - 1].first.first ||
p[j].first.second != p[j - 1].first.second)
cur++;
ind[p[j].second] = cur;
pos[cur] = p[j].second;
}
}
cin >> q;
vector<int> a[q + 5];
for (int i = 1; i <= q; i++) {
string m;
ans[i] = INF;
cin >> k[i] >> m;
sz[i] = m.size();
search1(m, i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < V[i].size(); j++) {
if ((int)a[V[i][j]].size() >= k[V[i][j]] - 1) {
if (k[V[i][j]] == 1)
ans[V[i][j]] = sz[V[i][j]];
else
ans[V[i][j]] =
min(ans[V[i][j]],
i + sz[V[i][j]] -
(int)a[V[i][j]][a[V[i][j]].size() - k[V[i][j]] + 1]);
}
a[V[i][j]].push_back(i);
}
}
for (int i = 1; i <= q; i++) {
if (ans[i] != INF)
cout << ans[i] << " ";
else
cout << -1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100050;
const int INF = 1e9;
queue<int> q[maxn];
int ch[maxn][26];
int f[maxn], val[maxn], last[maxn];
int a[maxn], len[maxn];
int ans[maxn];
char s[maxn], t[maxn];
int m, tot;
void init() {
fill(ans, ans + maxn, INF);
tot = 0;
}
void insert(char *s, int len_s, int pos) {
len[pos] = len_s;
int u = 0;
for (int i = 0; i < len_s; i++) {
int id = s[i] - 'a';
if (!ch[u][id]) ch[u][id] = ++tot;
u = ch[u][id];
}
val[u] = pos;
}
void build_ac() {
queue<int> q0;
q0.push(0);
while (!q0.empty()) {
int u = q0.front();
q0.pop();
int r = f[u];
for (int i = 0; i < 26; i++) {
int v = ch[u][i];
if (!v) {
ch[u][i] = ch[r][i];
continue;
}
q0.push(v);
f[v] = u ? ch[r][i] : 0;
last[v] = val[f[v]] ? f[v] : last[f[v]];
}
}
}
void solve() {
init();
scanf("%s", s);
int len_s = strlen(s);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d %s", &a[i], t);
insert(t, strlen(t), i);
}
build_ac();
int u = 0;
for (int i = 0; i < len_s; i++) {
int id = s[i] - 'a';
u = ch[u][id];
if (val[u] || last[u]) {
int now = val[u] ? u : last[u];
while (now) {
int pos = val[now];
q[pos].push(i);
if (q[pos].size() >= a[pos]) {
int r = q[pos].front();
q[pos].pop();
ans[pos] = min(ans[pos], (i - r) + len[pos]);
}
now = last[now];
}
}
}
for (int i = 1; i <= m; i++) {
printf("%d\n", (ans[i] == INF) ? -1 : ans[i]);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXCHAR = 26;
struct Vertex {
int next[MAXCHAR];
int leaf = -1;
int p = -1;
char pch;
int link = -1;
int leaflink = -1;
int go[MAXCHAR];
Vertex(int p = -1, char ch = '$') : p(p), pch(ch) {
fill(begin(next), end(next), -1);
fill(begin(go), end(go), -1);
}
};
vector<Vertex> trie(1);
void add_string(string const &s, int idx) {
int v = 0;
for (char ch : s) {
int c = ch - 'a';
if (trie[v].next[c] == -1) {
trie[v].next[c] = trie.size();
trie.emplace_back(v, ch);
}
v = trie[v].next[c];
}
trie[v].leaf = idx;
}
int go(int v, char ch);
int get_link(int v) {
if (trie[v].link == -1) {
if (v == 0 || trie[v].p == 0)
trie[v].link = 0;
else
trie[v].link = go(get_link(trie[v].p), trie[v].pch);
}
return trie[v].link;
}
int go(int v, char ch) {
int c = ch - 'a';
if (trie[v].go[c] == -1) {
if (trie[v].next[c] != -1)
trie[v].go[c] = trie[v].next[c];
else
trie[v].go[c] = v == 0 ? 0 : go(get_link(v), ch);
}
return trie[v].go[c];
}
int getleaf(int i) {
if (trie[i].leaflink != -1) {
return trie[i].leaflink;
}
int nxt = get_link(i);
if (nxt > 0) {
if (trie[nxt].leaf != -1) {
trie[i].leaflink = nxt;
} else {
trie[i].leaflink = getleaf(nxt);
}
return trie[i].leaflink;
}
return 0;
}
string S;
int N;
int K[MAXN];
string M[MAXN];
vector<int> results[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> S;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> K[i];
cin >> M[i];
add_string(M[i], i);
}
int v = 0;
for (int i = 0; i < S.size(); i++) {
v = go(v, S[i]);
int cur = v;
while (getleaf(cur) > 0) {
cur = getleaf(cur);
results[trie[cur].leaf].push_back(i);
}
if (trie[v].leaf != -1) {
results[trie[v].leaf].push_back(i);
}
}
for (int i = 0; i < N; i++) {
int minLength = 1 << 30;
for (int j = K[i]; j <= results[i].size(); j++) {
minLength = min(minLength, results[i][j - 1] - results[i][j - K[i]]);
}
if (minLength == 1 << 30) {
cout << -1 << endl;
} else {
cout << minLength + M[i].size() << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, q, ans[maxn];
char S[maxn], T[maxn];
queue<int> mat[maxn];
struct Querys {
int pos, len, tid, x;
} Q[maxn];
const int P1 = 1e9 + 7, P2 = 1e9 + 9, B1 = 2333, B2 = 51111;
int pw1[maxn], pw2[maxn];
struct Hnode {
int v1, v2;
Hnode() {}
Hnode(int x, int y) : v1(x), v2(y) {}
Hnode app(int c) {
return Hnode((1ll * B1 * v1 + c) % P1, (1ll * B2 * v2 + c) % P2);
}
long long get() { return 1ll * v1 * P2 + v2; }
} dat[maxn], A[maxn];
Hnode query(Hnode* S, int l, int r) {
return Hnode((S[r].v1 + 1ll * (P1 - S[l - 1].v1) * pw1[r - l + 1]) % P1,
(S[r].v2 + 1ll * (P2 - S[l - 1].v2) * pw2[r - l + 1]) % P2);
}
const int P = 1e5 + 3;
int h[P], nxt[maxn];
long long key[maxn];
int find(long long x) {
for (int i = h[x % P]; i; i = nxt[i])
if (key[i] == x) return i;
return -1;
}
void ins(long long x, int id) {
int& H = h[x % P];
nxt[id] = H, key[id] = x, H = id;
}
int main() {
scanf("%s%d", S + 1, &q), n = strlen(S + 1);
for (int i = (1), iend = (q); i <= iend; ++i) {
Q[i].pos = Q[i - 1].pos + Q[i - 1].len + 1, ans[i] = 1e9,
scanf("%d%s", &Q[i].x, T + Q[i].pos), Q[i].tid = i,
Q[i].len = strlen(T + Q[i].pos);
}
pw1[0] = pw2[0] = 1;
for (int i = (1), iend = (n); i <= iend; ++i) A[i] = A[i - 1].app(S[i]);
for (int i = (1), iend = (maxn - 1); i <= iend; ++i)
pw1[i] = 1ll * B1 * pw1[i - 1] % P1, pw2[i] = 1ll * B2 * pw2[i - 1] % P2,
dat[i] = dat[i - 1].app(T[i]);
sort(Q + 1, Q + q + 1, [](Querys X, Querys Y) { return X.len < Y.len; });
for (int l = (1), lend = (q); l <= lend; ++l) {
int r = l, len = Q[l].len;
while (r < q && Q[r + 1].len == len) r++;
memset(h, 0, sizeof h);
for (int i = (l), iend = (r); i <= iend; ++i) {
ins(query(dat, Q[i].pos, Q[i].pos + len - 1).get(), i);
}
for (int i = (1), iend = (n - len + 1); i <= iend; ++i) {
int id = find(query(A, i, i + len - 1).get());
if (id == -1) continue;
auto& V = mat[id];
V.push(i);
if ((int)V.size() > Q[id].x) V.pop();
if ((int)V.size() == Q[id].x)
ans[Q[id].tid] = min(ans[Q[id].tid], i - V.front() + len);
}
l = r;
}
for (int i = (1), iend = (q); i <= iend; ++i)
printf("%d\n", ans[i] > n ? -1 : ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 3;
const int alpha = 128;
int trie[N][alpha], ndcnt, ids[N], F[N], szs[N], nxtId[N];
char children[N][alpha];
int addnode() {
memset(trie[ndcnt], -1, sizeof(trie[ndcnt]));
ids[ndcnt] = -1;
szs[ndcnt] = 0;
return ndcnt++;
}
int getNext(int f, char c) {
while (trie[f][c] == -1) f = F[f];
f = trie[f][c];
return f;
}
void buildFail() {
queue<int> q;
for (int i = 0; i < alpha; i++) {
int &r = trie[0][i];
if (~r) {
nxtId[r] = F[r] = 0;
q.push(r);
} else
r = 0;
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = 0; i < szs[cur]; i++) {
char c = children[cur][i];
int f = F[cur];
int &nxt = trie[cur][c];
nxtId[nxt] = F[nxt] = getNext(f, c);
q.push(nxt);
}
}
}
void init() {
ndcnt = 0;
addnode();
}
int insert(const char *str, int id) {
int cur;
for (cur = 0; *str; str++) {
int &nxt = trie[cur][*str];
if (nxt == -1) {
nxt = addnode();
children[cur][szs[cur]++] = *str;
}
cur = nxt;
}
if (ids[cur] == -1) ids[cur] = id;
return ids[cur];
}
int getNxtId(int cur) {
if (cur == 0) return 0;
int &next = nxtId[cur];
if (ids[next] != -1) {
return next;
}
return next = getNxtId(next);
}
int ans[N];
int k[N];
void match(char *str, int cnt) {
vector<deque<int> > v(cnt);
for (int cur = 0, i = 0; str[i]; i++) {
cur = getNext(cur, str[i]);
for (int j = cur; j; j = getNxtId(j)) {
int x = ids[j];
if (x != -1) {
v[x].push_back(i);
while (v[x].size() > k[x]) {
v[x].pop_front();
}
if (v[x].size() == k[x]) {
ans[x] = (ans[x] < i - v[x].front() ? ans[x] : i - v[x].front());
}
}
}
}
}
char str[N];
int n;
char pat[N];
int sz[N];
int l;
int main() {
scanf("%s", str);
l = strlen(str);
scanf("%d", &n);
init();
for (int i = 0; i < n; i++) {
scanf("%d %s", &k[i], pat);
ans[i] = l + 2;
int id = insert(pat, i);
sz[i] = strlen(pat);
}
buildFail();
match(str, n);
for (int i = 0; i < n; i++) {
if (ans[i] <= l) {
cout << ans[i] + sz[i] << endl;
} else {
puts("-1");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long key = 31;
int n, m;
string s;
unsigned long long p[100008];
unsigned long long h[100008];
vector<int> v[100005];
vector<int> vv[100005];
int a[100005];
map<unsigned long long, int> pos;
string b[100005];
inline void build(int len) {
unsigned long long cur = 0;
for (int i = 0; i < v[len].size(); ++i) {
cur = 0;
for (int j = 0; j < len; ++j)
cur = (cur + (b[v[len][i]][j] - 'a' + 1) * p[j + 1]);
cur = (cur * p[100004]);
pos[cur] = v[len][i];
}
for (int i = 1; i <= n - len + 1; ++i) {
cur = h[i + len - 1] - h[i - 1];
cur *= p[100005 - i];
if (pos.count(cur)) vv[pos[cur]].push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
p[0] = 1;
for (int i = 1; i <= 100005; ++i) p[i] = p[i - 1] * key;
for (int i = 1; i <= n; ++i) h[i] = h[i - 1] + (s[i - 1] - 'a' + 1) * p[i];
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> a[i];
cin >> b[i];
v[b[i].size()].push_back(i);
}
for (int i = 1; i <= n; ++i)
if (v[i].size() > 0) {
build(i);
}
for (int i = 1; i <= m; ++i) {
if (vv[i].size() < a[i]) {
cout << -1 << '\n';
continue;
}
int cur = n;
int z;
for (int j = a[i]; j <= vv[i].size(); ++j) {
z = vv[i][j - 1] - vv[i][j - a[i]] + b[i].size();
if (z < cur) cur = z;
}
cout << cur << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9 + 7;
struct AhoCorasick {
enum { alpha = 26, first = 'a' };
struct Node {
int back, next[alpha], start = -1, end = -1, nmatches = 0;
Node(int v) { memset(next, v, sizeof(next)); }
};
vector<Node> N;
vector<int> backp;
void insert(string& s, int j) {
assert(!s.empty());
int n = 0;
for (char c : s) {
int& m = N[n].next[c - first];
if (m == -1) {
n = m = (int)(N).size();
N.emplace_back(-1);
} else
n = m;
}
if (N[n].end == -1) N[n].start = j;
backp.push_back(N[n].end);
N[n].end = j;
N[n].nmatches++;
}
AhoCorasick(vector<string>& pat) : N(1, -1) {
for (int i = 0; i < ((int)(pat).size()); ++i) insert(pat[i], i);
N[0].back = (int)(N).size();
N.emplace_back(0);
queue<int> q;
for (q.push(0); !q.empty(); q.pop()) {
int n = q.front(), prev = N[n].back;
for (int i = 0; i < (alpha); ++i) {
int &ed = N[n].next[i], y = N[prev].next[i];
if (ed == -1)
ed = y;
else {
N[ed].back = y;
(N[ed].end == -1 ? N[ed].end : backp[N[ed].start]) = N[y].end;
N[ed].nmatches += N[y].nmatches;
q.push(ed);
}
}
}
}
vector<int> find(string word) {
int n = 0;
vector<int> res;
for (char c : word) {
n = N[n].next[c - first];
res.push_back(N[n].end);
}
return res;
}
vector<vector<int> > findAll(vector<string>& pat, string word) {
vector<int> r = find(word);
vector<vector<int> > res((int)(word).size());
for (int i = 0; i < ((int)(word).size()); ++i) {
int ind = r[i];
while (ind != -1) {
res[i - (int)(pat[ind]).size() + 1].push_back(ind);
ind = backp[ind];
}
}
return res;
}
};
int main() {
string text;
cin >> text;
int n;
cin >> n;
vector<string> pattern(n);
vector<int> k(n);
for (int i = 0; i < n; ++i) {
cin >> k[i] >> pattern[i];
}
AhoCorasick aut(pattern);
vector<vector<int> > occ = aut.findAll(pattern, text);
vector<vector<int> > pos(n, vector<int>());
for (int i = 0; i < text.size(); ++i) {
for (int x : occ[i]) pos[x].push_back(i);
}
for (int i = 0; i < n; ++i) {
if (pos[i].size() < k[i]) {
puts("-1");
} else {
int ans = oo;
for (int j = 0; j <= pos[i].size() - k[i]; ++j) {
int len = pos[i][j + k[i] - 1] - pos[i][j] + pattern[i].size();
ans = min(ans, len);
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int MAXL = 100005;
int n, m;
char str[MAXL], tmp[MAXL];
int cnt[MAXL], lens[MAXL];
vector<int> res[MAXL];
struct Node {
int c, id;
bool ie;
Node *f, *o, *nxt[26];
Node() : c{-1}, id{-1}, ie{false}, f{nullptr}, o{nullptr} {
for (int i = 0; i < 26; ++i) nxt[i] = nullptr;
}
} * root;
void add_pattern(int order) {
scanf("%s", tmp + 1);
int len = strlen(tmp + 1);
lens[order] = len;
Node *cur = root;
for (int i = 1; i <= len; ++i) {
int ch = tmp[i] - 'a';
if (!cur->nxt[ch]) {
cur->nxt[ch] = new Node();
cur->nxt[ch]->c = ch;
}
cur = cur->nxt[ch];
}
cur->ie = true;
cur->id = order;
}
void make_fail() {
queue<Node *> que;
for (int i = 0; i < 26; ++i)
if (root->nxt[i]) {
root->nxt[i]->f = root;
que.push(root->nxt[i]);
}
while (que.size()) {
Node *cur = que.front();
que.pop();
if (cur->ie)
cur->o = cur;
else
cur->o = cur->f->o;
for (int i = 0; i < 26; ++i)
if (cur->nxt[i]) {
Node *next = cur->nxt[i], *t = cur->f;
while (t != root && !t->nxt[i]) t = t->f;
if (t->nxt[i]) t = t->nxt[i];
next->f = t;
que.push(next);
}
}
}
int main() {
scanf("%s", str + 1);
int slen = strlen(str + 1);
root = new Node();
root->f = root;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", cnt + i);
add_pattern(i);
}
make_fail();
Node *cur = root;
for (int i = 1; i <= slen; ++i) {
int key = str[i] - 'a';
while (cur != root && !cur->nxt[key]) cur = cur->f;
if (cur->nxt[key]) cur = cur->nxt[key];
if (cur->o) res[cur->o->id].push_back(i);
}
vector<Node *> order;
queue<Node *> que;
que.push(root);
while (!que.empty()) {
Node *cur = que.front();
que.pop();
order.push_back(cur);
for (int i = 0; i < 26; i++)
if (cur->nxt[i]) que.push(cur->nxt[i]);
}
reverse(order.begin(), order.end());
for (Node *tmp : order)
if (tmp->ie and tmp->f->o) {
int u = tmp->f->o->id;
res[u].insert(res[u].end(), res[tmp->id].begin(), res[tmp->id].end());
}
int ans = INF;
for (int i = 1; i <= n; ++i) {
ans = INF;
if (res[i].size() < cnt[i])
puts("-1");
else {
sort(res[i].begin(), res[i].end());
for (int j = cnt[i] - 1; j < res[i].size(); ++j) {
ans = min(ans, res[i][j] - res[i][j - cnt[i] + 1] + lens[i]);
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAX = 2e5 + 41;
int const INF = 1e9 + 41;
int const MAGIC = 150;
string s;
int q;
int k[MAX];
string vs[MAX];
int n;
int ans[MAX];
int pref[MAX];
string str;
vector<int> pos;
void build(string s1) {
str = s1;
str += "#";
str += s;
pref[0] = 0;
for (int i = 1; i <= (int)str.size() - 1; i++) {
pref[i] = pref[i - 1];
while (pref[i] > 0 && str[pref[i]] != str[i]) {
pref[i] = pref[pref[i] - 1];
}
if (str[i] == str[pref[i]]) pref[i]++;
}
pos.clear();
for (int i = (int)s1.size(); i <= (int)str.size() - 1; i++) {
if (pref[i] >= (int)s1.size()) pos.push_back(i);
}
}
int solvelarge(string s1, int k) {
build(s1);
int res = INF;
if ((int)pos.size() < k) return res;
for (int i = k - 1; i <= (int)pos.size() - 1; i++) {
int x = pos[i];
int y = pos[i - k + 1] - (int)s1.size() + 1;
res = min(res, x - y + 1);
}
return res;
}
int const P1 = 41;
int const MOD1 = 1000003241;
int const P2 = 541;
int const MOD2 = 1000004119;
int add(int a, int b, int MOD) {
a += b;
while (a >= MOD) a -= MOD;
while (a < 0) a += MOD;
return a;
}
int mult(int a, int b, int MOD) { return (long long)a * b % MOD; }
unsigned long long gethash(string &s) {
int res1 = 0;
int res2 = 0;
for (int i = 0; i <= (int)s.size() - 1; i++) {
res1 = mult(res1, P1, MOD1);
res1 = add(res1, s[i] - 'a' + 1, MOD1);
res2 = mult(res2, P2, MOD2);
res2 = add(res2, s[i] - 'a' + 1, MOD2);
}
return (unsigned long long)res1 * MOD2 + res2;
}
unordered_map<unsigned long long, int> hh;
vector<int> poses[MAX];
void solvesmall() {
for (int i = 0; i <= (int)s.size() - 1; i++) {
int cur1 = 0;
int cur2 = 0;
for (int j = 0; j <= MAGIC - 1; j++) {
if (i + j >= (int)s.size()) break;
cur1 = mult(cur1, P1, MOD1);
cur1 = add(cur1, s[i + j] - 'a' + 1, MOD1);
cur2 = mult(cur2, P2, MOD2);
cur2 = add(cur2, s[i + j] - 'a' + 1, MOD2);
unsigned long long cur = (unsigned long long)cur1 * MOD2 + cur2;
if (hh.find(cur) != hh.end()) {
poses[hh[cur]].push_back(i + j);
}
}
}
for (int i = 1; i <= q; i++) {
if ((int)poses[i].size() >= k[i]) {
for (int j = k[i] - 1; j <= (int)poses[i].size() - 1; j++) {
int x = poses[i][j];
int y = poses[i][j - k[i] + 1] - (int)vs[i].size() + 1;
ans[i] = min(ans[i], x - y + 1);
}
}
}
}
void solve() {
for (int i = 1; i <= q; i++) {
ans[i] = INF;
}
for (int i = 1; i <= q; i++) {
if ((int)vs[i].size() <= MAGIC) {
unsigned long long h = gethash(vs[i]);
hh[h] = i;
} else {
ans[i] = solvelarge(vs[i], k[i]);
}
}
solvesmall();
for (int i = 1; i <= q; i++) {
if (ans[i] == INF) ans[i] = -1;
printf("%d\n", ans[i]);
}
}
int main() {
cin >> s;
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> k[i] >> vs[i];
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using ll = long long;
using ld = long double;
using ull = uint64_t;
using namespace std;
const int MAXN = 200228;
const ll HV = 193297;
ull pw[MAXN];
ull h[MAXN];
int k[MAXN];
vector<int> an[MAXN];
vector<pair<ull, int>> v[MAXN];
int ln[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
string s;
cin >> s;
int n = s.length();
pw[0] = 1;
for (int i = 1; i < MAXN; ++i) {
pw[i] = pw[i - 1] * HV;
}
h[0] = 0;
for (int i = 0; i < n; ++i) {
h[i + 1] = h[i] + pw[i] * s[i];
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
string t;
cin >> k[i] >> t;
ull ch = 0;
for (int i = 0; i < t.length(); ++i) {
ch += pw[i] * t[i];
}
ch *= pw[n];
ln[i] = t.length();
v[t.length()].emplace_back(ch, i);
}
for (int len = 1; len <= n; ++len) {
if (v[len].empty()) {
continue;
}
sort(v[len].begin(), v[len].end());
for (int i = 0; i + len <= n; ++i) {
ull ch = h[i + len] - h[i];
ch *= pw[n - i];
auto it =
lower_bound(v[len].begin(), v[len].end() - 1, pair<ull, int>{ch, 0});
if (it->first == ch) {
an[it->second].push_back(i);
}
}
}
for (int i = 0; i < q; ++i) {
--k[i];
if (an[i].size() <= k[i]) {
cout << "-1\n";
} else {
int ans = MAXN;
for (int j = 0; j + k[i] < an[i].size(); ++j) {
ans = min(ans, an[i][j + k[i]] - an[i][j]);
}
cout << ans + ln[i] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 26;
const int maxn = 1e5 + 5;
vector<vector<int>> a;
string oris[maxn];
int cnt[maxn];
class Automata_ac {
int ch[maxn][maxm];
int f[maxn];
int val[maxn];
int last[maxn];
int sz = 0;
int id(char ch) { return ch - 'a'; }
public:
string t;
void insert(string t, int v) {
int u = 0;
for (auto it : t) {
int c = id(it);
if (!ch[u][c]) ch[u][c] = ++sz;
u = ch[u][c];
}
val[u] = v;
}
void getfail() {
queue<int> q;
f[0] = 0;
for (int i = 0; i < maxm; ++i) {
int u = ch[0][i];
if (u) {
f[u] = 0;
q.push(u);
last[u] = 0;
}
}
while (!q.empty()) {
int r = q.front();
q.pop();
for (int i = 0; i < maxm; ++i) {
int u = ch[r][i];
if (!u) {
ch[r][i] = ch[f[r]][i];
continue;
}
q.push(u);
int v = f[r];
f[u] = ch[v][i];
last[u] = val[f[u]] ? f[u] : last[f[u]];
}
}
}
void print(int j, int pos) {
if (j) {
a[val[j] - 1].push_back(pos);
print(last[j], pos);
}
}
void acfind() {
int j = 0;
for (int i = 0; i < t.size(); ++i) {
int c = id(t[i]);
while (j && !ch[j][c]) j = f[j];
j = ch[j][c];
if (val[j])
print(j, i);
else if (last[j])
print(last[j], i);
}
}
} ac;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> ac.t;
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> cnt[i] >> oris[i];
ac.insert(oris[i], i + 1);
}
ac.getfail();
ac.acfind();
for (int i = 0; i < n; ++i) {
if (a[i].size() < cnt[i])
cout << -1 << endl;
else {
int ans = 0x3f3f3f3f;
auto &it = a[i];
for (int j = cnt[i] - 1; j < it.size(); ++j) {
int fr = j - cnt[i] + 1;
int len = it[j] - it[fr] + oris[i].size();
ans = min(ans, len);
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct aho {
struct Vertex {
vector<int> next;
int par, link, ans, leaf;
Vertex() {
next.resize(26);
fill(next.begin(), next.end(), -1);
ans = -1;
leaf = -1;
}
};
vector<Vertex> sh;
vector<vector<int>> sol;
aho(int x) {
sh.emplace_back();
sol.resize(x);
}
void add(char s[], int k, int n) {
int v = 0;
for (int i = 0; i < n; i++) {
int c = s[i] - 'a';
if (sh[v].next[c] == -1) {
sh[v].next[c] = sh.size();
sh.emplace_back();
}
v = sh[v].next[c];
}
sh[v].leaf = k;
}
void find(char s[], int n) {
int u, v = 0;
for (int j = 0; j < n; j++) {
int c = s[j] - 'a';
while (v && sh[v].next[c] == -1) {
v = sh[v].link;
}
if (~sh[v].next[c])
v = sh[v].next[c];
else
v = 0;
u = v;
while (u) {
if (~sh[u].leaf) sol[sh[u].leaf].push_back(j);
u = sh[u].ans;
}
}
return;
}
int transition(int x, int y) {
if (~sh[x].next[y]) return sh[x].next[y];
if (!x) return 0;
return sh[x].next[y] = transition(sh[x].link, y);
}
int cnt(int x) {
if (~sh[x].ans) return sh[x].ans;
if (~sh[sh[x].link].leaf) return sh[x].link;
return sh[x].ans = cnt(sh[x].link);
}
void init() {
queue<int> q;
q.push(0);
sh[0].par = 0;
sh[0].link = 0;
sh[0].ans = 0;
int u, v;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
if (sh[u].next[i] == -1) continue;
v = sh[u].next[i];
sh[v].par = u;
if (u)
sh[v].link = transition(sh[u].link, i);
else
sh[v].link = 0;
sh[v].ans = cnt(v);
q.push(v);
}
}
}
void check(int n, int k[], int nb[]) {
int i;
for (i = 0; i < n; i++) {
int ans = 100000000;
for (int j = 0; j + k[i] - 1 < sol[i].size(); j++) {
ans = min((sol[i][j + k[i] - 1] - sol[i][j]), ans);
}
if (ans >= 10000000)
cout << -1 << endl;
else
cout << ans + nb[i] << endl;
}
}
};
char s[200005], t[200005];
int k[200005], nb[200005];
int main() {
int i, j, l, m, n, x, y;
scanf("%s", s);
scanf("%d", &n);
aho sh(n);
for (i = 0; i < n; i++) {
scanf("%d", &k[i]);
getchar();
scanf("%s", &t);
nb[i] = strlen(t);
sh.add(t, i, nb[i]);
}
sh.init();
sh.find(s, strlen(s));
sh.check(n, k, nb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
const int MAXLEN = (int)2e5 + 5;
char s[MAXLEN];
int SA[MAXLEN], cnt[MAXLEN], ary1[MAXLEN], ary2[MAXLEN];
int *Rank, *Height;
inline bool cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void make_suffix_array(int MSIZE, int len) {
int p, *x, *y, *tmp, i, j, k;
x = ary1;
y = ary2;
memset(cnt, 0, sizeof(int) * MSIZE);
for (i = 0; i < len; i++) cnt[x[i] = s[i]]++;
for (i = 1; i < MSIZE; i++) cnt[i] += cnt[i - 1];
for (i = len - 1; i >= 0; i--) SA[--cnt[x[i]]] = i;
for (j = p = 1; p < len; j <<= 1, MSIZE = p) {
for (p = 0, i = len - j; i < len; i++) y[p++] = i;
for (i = 0; i < len; i++) {
if (SA[i] >= j) y[p++] = SA[i] - j;
}
memset(cnt, 0, sizeof(int) * MSIZE);
for (i = 0; i < len; i++) cnt[x[y[i]]]++;
for (i = 1; i < MSIZE; i++) cnt[i] += cnt[i - 1];
for (i = len - 1; i >= 0; i--) SA[--cnt[x[y[i]]]] = y[i];
tmp = x;
x = y;
y = tmp;
x[SA[0]] = 0;
for (i = p = 1; i < len; i++) {
x[SA[i]] = cmp(y, SA[i - 1], SA[i], j) ? p - 1 : p++;
}
}
Rank = x;
Height = y;
for (i = k = 0; i < len - 1; i++) {
if (k > 0) k--;
j = SA[Rank[i] - 1];
while (s[i + k] == s[j + k]) k++;
Height[Rank[i]] = k;
}
}
int get(int lv, int ll, int rr, char c) {
rr++;
while (ll < rr) {
int mm = (ll + rr) / 2;
if (s[lv + SA[mm]] >= c)
rr = mm;
else
ll = mm + 1;
}
return ll;
}
int N;
char qs[SIZE];
map<int, int> dp[SIZE];
int gg[SIZE], gn;
int f(int lv, int ll, int rr) {
if (ll == rr) {
return (N - SA[ll] - lv) % 2;
}
if (dp[ll].count(lv)) return dp[ll][lv];
int &res = dp[ll][lv];
int now = ll;
if (s[SA[now] + lv] == 0) now++;
vector<int> tmp;
while (now <= rr) {
int nxt = get(lv, now, rr, s[SA[now] + lv] + 1);
tmp.push_back(f(lv + 1, now, nxt - 1));
now = nxt;
}
res = 0;
gn++;
for (int x : tmp) gg[x] = gn;
while (gg[res] == gn) res++;
return res;
}
int tmp[SIZE];
int main() {
while (scanf("%s", s) != EOF) {
N = strlen(s);
make_suffix_array(128, N + 1);
for (int i = (1); i <= (N); ++i) dp[i].clear();
int Q;
R(Q);
while (Q--) {
int kk;
R(kk);
scanf("%s", (qs));
int sn = strlen(qs);
int ll = 1, rr = N;
int i;
for (i = 0; i < sn && ll <= rr; i++) {
int nxt_ll = get(i, ll, rr, qs[i]);
int nxt_rr = get(i, ll, rr, qs[i] + 1) - 1;
ll = nxt_ll, rr = nxt_rr;
}
if (rr - ll + 1 < kk) {
W(-1);
continue;
}
int tn = rr - ll + 1;
for (int j = (ll); j <= (rr); ++j) tmp[j - ll] = SA[j];
sort(tmp, tmp + tn);
int an = tmp[kk - 1] - tmp[0];
for (int j = (kk); j < (tn); ++j) an = min(an, tmp[j] - tmp[j - kk + 1]);
W(an + sn);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
const int LOG = 20;
const int NN = 1 << LOG;
const int MAXN = (int)60000 + 5;
const int INF = 1 << 29;
const long long MAX = (long long)1e18 + 5;
const int MOD = 1000;
long long mul(long long x, long long y) { return (1LL * x * y) % MOD; }
long long add(long long x, long long y) {
long long res = x;
res += y;
return (res % MOD + MOD) % MOD;
}
int two(int x) { return 1 << x; }
bool contain(int mask, int bit) { return (mask & two(bit)) > 0; }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int bit_count(int x) { return x == 0 ? 0 : (x & 1) + bit_count(x >> 1); }
vector<string> word;
vector<vector<int> > occ;
struct TrieNode {
TrieNode* fail;
TrieNode* dict;
int idx;
vector<TrieNode*> children;
TrieNode() {
this->children.clear();
this->children.resize('z' - 'a' + 1, nullptr);
this->fail = nullptr;
this->dict = nullptr;
this->idx = -1;
}
};
struct AhoCorasick {
int trie_size;
TrieNode* root;
AhoCorasick() {
this->root = new TrieNode();
this->trie_size = 1;
}
void insert(string s, int idx) {
TrieNode* node = root;
for (int i = 0; i < (int)s.size(); i++) {
int c = s[i] - 'a';
if (node->children[c] == nullptr) {
node->children[c] = new TrieNode();
this->trie_size++;
}
node = node->children[c];
}
node->idx = idx;
node->dict = node;
}
void set_links() {
TrieNode** q = (TrieNode**)malloc(this->trie_size * sizeof(TrieNode));
int beg = 0, fin = 0;
q[fin++] = root;
while (beg < fin) {
TrieNode* parent = q[beg++];
for (int i = 0; i < (int)parent->children.size(); i++) {
TrieNode*& child = parent->children[i];
if (child != nullptr) {
q[fin++] = child;
TrieNode* f = parent->fail;
while (f != nullptr && f->children[i] == nullptr) f = f->fail;
if (f == nullptr) {
child->fail = this->root;
} else {
child->fail = f->children[i];
if (child->dict == nullptr) child->dict = child->fail->dict;
}
}
}
}
}
TrieNode* process(TrieNode* node, int idx_s, int ch) {
while (node != nullptr && node->children[ch] == nullptr) node = node->fail;
if (node == nullptr)
node = this->root;
else
node = node->children[ch];
TrieNode* cur = node->dict;
while (cur != nullptr) {
occ[cur->idx].push_back(idx_s - (int)word[cur->idx].size() + 1);
cur = cur->fail == nullptr ? nullptr : cur->fail->dict;
}
return node;
}
};
int main() {
ios_base::sync_with_stdio(false);
AhoCorasick aho = AhoCorasick();
string s;
cin >> s;
int q;
cin >> q;
occ.clear();
occ.resize(q);
word.clear();
word.resize(q);
vector<int> k(q);
for (int i = 0; i < q; i++) {
cin >> k[i] >> word[i];
aho.insert(word[i], i);
}
aho.set_links();
TrieNode* node = aho.root;
for (int i = 0; i < (int)s.size(); i++) {
node = aho.process(node, i, s[i] - 'a');
}
for (int i = 0; i < q; i++) {
int best = -1;
for (int j = k[i] - 1; j < (int)occ[i].size(); j++) {
int len = occ[i][j] - occ[i][j - k[i] + 1] + (int)word[i].size();
if (best == -1 || len < best) best = len;
}
printf("%d\n", best);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const int inf = INT_MAX;
template <char f = 'a', size_t K = 26>
class AhoCorasick {
public:
struct Node {
bool leaf;
char pch;
int idx, p, link, exitLink;
array<int, K> next;
Node(int p, char pch)
: leaf(false), idx(-1), p(p), pch(pch), link(-1), exitLink(-1) {
next.fill(-1);
}
};
vector<Node> t;
AhoCorasick() : t(1, Node(-1, ' ')) {}
AhoCorasick(const vector<string>& s) : t(1, Node(-1, ' ')) {
for (const string& ss : s) {
insert(ss);
}
}
void insert(const string& s, int idx) {
int cur = 0;
for (char ch : s) {
if (t[cur].next[ch - f] == -1) {
t[cur].next[ch - f] = (int)t.size();
t.emplace_back(cur, ch);
}
cur = t[cur].next[ch - f];
}
t[cur].idx = idx;
t[cur].leaf = true;
}
bool search(const string& s) {
int cur = 0;
for (char ch : s) {
if (t[cur].next[ch - f] == -1) {
return false;
}
cur = t[cur].next[ch - f];
}
return t[cur].leaf;
}
void process() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
if (x == 0 or t[x].p == 0) {
t[x].link = 0;
} else {
t[x].link = t[t[t[x].p].link].next[t[x].pch - f];
t[x].exitLink = t[t[x].link].leaf ? t[x].link : t[t[x].link].exitLink;
}
for (int i = 0; i < K; i++) {
if (t[x].next[i] == -1) {
t[x].next[i] = x == 0 ? 0 : t[t[x].link].next[i];
} else {
q.push(t[x].next[i]);
}
}
}
}
Node& operator[](int i) { return t[i]; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = s.length();
AhoCorasick<> t;
int m;
cin >> m;
vector<pair<int, string>> queries(m);
for (int i = 0; i < m; i++) {
cin >> queries[i].first >> queries[i].second;
t.insert(queries[i].second, i);
}
t.process();
vector<int> ans(m, n + 1);
vector<queue<int>> q(m);
for (int i = 0, cur = 0; i < n; i++) {
cur = t[cur].next[s[i] - 'a'];
int curr = cur;
while (curr != -1) {
if (t[curr].idx != -1) {
int j = t[curr].idx;
if (q[j].size() == queries[j].first) {
q[j].pop();
q[j].push(i);
} else {
q[j].push(i);
}
if (q[j].size() == queries[j].first) {
ans[j] = min(ans[j], q[j].back() - q[j].front() +
(int)queries[j].second.length());
}
}
curr = t[curr].exitLink;
}
}
for (int i = 0; i < m; i++) {
cout << (ans[i] < n + 1 ? ans[i] : -1) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 g1(chrono::steady_clock::now().time_since_epoch().count());
string s, t;
int N;
const long long MOD = 1e9 + 7;
long long hsh[2][100005];
long long pows[2][100005];
long long sd[2] = {31, 131};
int fre[100005];
pair<long long, long long> h[100005];
vector<int> pos[100005];
vector<int> lst[100005];
int ans[100005];
int sz[100005];
set<int> st;
map<int, int> qu;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
uniform_int_distribution<int> distribution(MOD / 2, MOD - 2);
sd[0] = distribution(g1);
sd[1] = distribution(g1);
pows[0][0] = pows[1][0] = 1;
for (int i = 1; i <= s.size(); i++) {
pows[0][i] = pows[0][i - 1] * sd[0];
pows[1][i] = pows[1][i - 1] * sd[1];
pows[0][i] %= MOD, pows[1][i] %= MOD;
hsh[0][i] = (hsh[0][i - 1] * sd[0] + s[i - 1] - 'a' + 1) % MOD;
hsh[1][i] = (hsh[1][i - 1] * sd[1] + s[i - 1] - 'a' + 1) % MOD;
}
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> fre[i] >> t;
sz[i] = t.size();
pos[sz[i]].push_back(i);
st.insert(sz[i]);
for (char c : t) {
h[i].first = (h[i].first * sd[0] + c - 'a' + 1) % MOD;
h[i].second = (h[i].second * sd[1] + c - 'a' + 1) % MOD;
}
}
for (int l : st) {
for (int n : pos[l]) {
qu.insert({(h[n].first * h[n].second), n});
}
for (int i = l; i <= s.size(); i++) {
long long h1 = (hsh[0][i] - hsh[0][i - l] * pows[0][l] % MOD + MOD) % MOD;
long long h2 = (hsh[1][i] - hsh[1][i - l] * pows[1][l] % MOD + MOD) % MOD;
if (qu.count((h1 * h2))) {
lst[qu[(h1 * h2)]].push_back(i);
}
}
for (int n : pos[l]) {
ans[n] = INT_MAX;
for (int k = fre[n] - 1; k < lst[n].size(); k++) {
ans[n] = min(ans[n], lst[n][k] - lst[n][k - fre[n] + 1]);
}
ans[n] = (ans[n] == INT_MAX ? -1 : ans[n] + sz[n]);
}
qu.clear();
}
for (int i = 1; i <= N; i++) {
cout << ans[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
int readIn() {
int a = 0;
bool positive = true;
char ch = getchar();
while (!(ch == '-' || std::isdigit(ch))) ch = getchar();
if (ch == '-') {
positive = false;
ch = getchar();
}
while (std::isdigit(ch)) {
a = a * 10 - (ch - '0');
ch = getchar();
}
return positive ? -a : a;
}
void printOut(int x) {
char buffer[20];
int length = 0;
if (x < 0)
putchar('-');
else
x = -x;
do buffer[length++] = -(x % 10) + '0';
while (x /= 10);
do putchar(buffer[--length]);
while (length);
putchar('\n');
}
struct Pool {
static const std::size_t threshold = int(6e4) * 232;
unsigned long long pool;
unsigned long long cnt;
unsigned long long end;
Pool() : pool(), cnt(), end() {}
void* operator()(std::size_t size) {
if (cnt + size >= end || !pool) {
pool = (unsigned long long)new unsigned char[threshold];
cnt = pool;
end = pool + threshold;
}
unsigned long long ret = cnt;
cnt += size;
return (void*)ret;
}
} allocator;
struct ACAutomaton {
static const int alphabet = 26;
static inline int code(char ch) { return ch - 'a'; }
struct Node {
void* operator new(std::size_t size) { return allocator(size); }
void operator delete(void*) {}
int cnt;
Node* fail;
Node* suffix;
Node* ch[alphabet];
Node() : cnt(), fail(), suffix(), ch() {}
};
Node* root;
ACAutomaton() { root = new Node; }
void insert(char* s, int idx) {
Node* cnt = root;
for (; *s; s++) {
int x = code(*s);
if (!cnt->ch[x]) cnt->ch[x] = new Node;
cnt = cnt->ch[x];
}
cnt->cnt = idx;
}
void build() {
std::queue<Node*> q;
q.push(root);
while (!q.empty()) {
Node* cnt = q.front();
q.pop();
for (int i = 0; i < alphabet; i++) {
Node*& to = cnt->ch[i];
Node* t = cnt == root ? root : cnt->fail->ch[i];
if (!to)
to = t;
else {
to->fail = t;
to->suffix = to->fail->cnt ? to->fail : to->fail->suffix;
q.push(to);
}
}
}
}
void match(char* s, const std::function<void(int pos, int idx)> callback) {
Node* cnt = root;
for (int pos = 0; *s; s++, pos++) {
int x = code(*s);
cnt = cnt->ch[x];
for (Node* t = cnt; t; t = t->suffix) {
if (t->cnt) {
callback(pos, t->cnt);
}
}
}
}
} ac;
const int maxn = int(1e5) + 5;
char str[maxn];
int n;
int k[maxn];
int len[maxn];
char buffer[maxn];
std::vector<std::vector<int> > pos;
void callback(int p, int idx) { pos[idx].push_back(p); }
void run() {
scanf("%s", str);
n = readIn();
for (int i = 1; i <= n; i++) {
k[i] = readIn();
scanf("%s", buffer);
len[i] = strlen(buffer);
ac.insert(buffer, i);
}
ac.build();
pos.resize(n + 1);
ac.match(str, callback);
for (int i = 1; i <= n; i++) {
const std::vector<int>& vec = pos[i];
if (vec.size() < k[i])
printOut(-1);
else {
int ans = maxn;
for (int j = 0, r = k[i] - 1; r < vec.size(); j++, r++)
ans = std::min(ans, len[i] + vec[r] - vec[j]);
printOut(ans);
}
}
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long key = 31;
const int MB = 1e5 + 5;
int n, m;
string s;
unsigned long long p[100008];
unsigned long long h[100008];
vector<int> v[100005];
vector<int> vv[100005];
int a[100005];
map<unsigned long long, int> pos;
string b[100005];
inline void build(int len) {
unsigned long long cur = 0;
for (int i = 0; i < v[len].size(); ++i) {
cur = 0;
for (int j = 0; j < len; ++j)
cur = (cur + (b[v[len][i]][j] - 'a' + 1) * p[j + 1]);
cur = (cur * p[MB - 1]);
pos[cur] = v[len][i];
}
for (int i = 1; i <= n - len + 1; ++i) {
cur = h[i + len - 1] - h[i - 1];
cur *= p[MB - i];
if (pos.count(cur)) vv[pos[cur]].push_back(i);
}
pos.clear();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
p[0] = 1;
for (int i = 1; i <= MB; ++i) p[i] = p[i - 1] * key;
for (int i = 1; i <= n; ++i) h[i] = h[i - 1] + (s[i - 1] - 'a' + 1) * p[i];
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> a[i];
cin >> b[i];
v[b[i].size()].push_back(i);
}
for (int i = 1; i <= n; ++i)
if (v[i].size() > 0) {
build(i);
}
for (int i = 1; i <= m; ++i) {
if (vv[i].size() < a[i]) {
cout << -1 << '\n';
continue;
}
int cur = n;
int z;
for (int j = a[i]; j <= vv[i].size(); ++j) {
z = vv[i][j - 1] - vv[i][j - a[i]] + b[i].size();
if (z < cur) cur = z;
}
cout << cur << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 101;
int pot[200005];
struct hstring {
const string *src;
vector<int> h;
hstring() : src(nullptr), h(1) {}
hstring(const string &str) : src(&str), h(str.size() + 1) {
for (int i = (int)(0); i < (int)(str.size()); ++i)
h[i + 1] = h[i] * P + str[i];
}
int size() const { return (int)src->size(); }
char operator[](int first) const { return (*src)[first]; }
int operator()(int first) const { return h[first]; }
};
struct hstring2 {
const hstring *src;
int shift;
hstring2(hstring &_src, int _shift = 0) : src(&_src), shift(_shift) {}
int size() const { return src->size() - shift; }
char operator[](int first) const { return (*src)[first + shift]; }
int operator()(int first) const {
return (*src)(first + shift) - (*src)(shift)*pot[first];
}
};
int lcp(const hstring2 &a, const hstring2 &b) {
int lo = 0, hi = min(a.size(), b.size()), mid;
while (lo != hi) {
mid = (lo + hi + 1) / 2;
if (a(mid) != b(mid))
hi = mid - 1;
else
lo = mid;
}
return lo;
}
bool operator<(const hstring2 &a, const hstring2 &b) {
int tmp = lcp(a, b);
if (tmp == a.size()) return b.size() != tmp;
if (tmp == b.size()) return false;
return a[tmp] < b[tmp];
}
string s;
int n;
int main() {
ios_base::sync_with_stdio(false);
pot[0] = 1;
for (int i = (int)(0); i < (int)(2e5); ++i) pot[i + 1] = P * pot[i];
cin >> s;
hstring hs(s);
vector<hstring2> suffix;
for (int i = (int)(0); i < (int)(s.size()); ++i) suffix.emplace_back(hs, i);
sort(suffix.begin(), suffix.end());
cin >> n;
for (int blatruc = (int)(0); blatruc < (int)(n); ++blatruc) {
int k;
cin >> k;
string m;
cin >> m;
hstring hm(m);
hstring2 hm2(hm);
int sz = (int)m.size();
vector<int> loc;
for (auto it = lower_bound(suffix.begin(), suffix.end(), hm2);
it != suffix.end() && it->size() >= sz && (*it)(sz) == hm(sz); ++it)
loc.push_back(it->shift);
if ((int)loc.size() < k) {
cout << -1 << endl;
continue;
}
sort(loc.begin(), loc.end());
int sol = 1e9;
for (int i = (int)(0); i < (int)(loc.size() - k + 1); ++i)
sol = min(sol, loc[i + k - 1] - loc[i]);
cout << sol + sz << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename T1, typename T2>
inline bool chkmin(T1& x, const T2& y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool chkmax(T1& x, const T2& y) {
if (x < y) {
x = y;
return 1;
}
return 0;
}
using namespace std;
const int maxn = 2e5 + 20;
ostream& operator<<(ostream& out, vector<int>& v) {
for (auto& x : v) out << x << ' ';
return out;
}
ostream& operator<<(ostream& out, pair<int, int>& v) {
out << v.first << ", " << v.second;
return out;
}
istream& operator>>(istream& in, pair<int, int>& a) {
in >> a.first >> a.second;
return in;
}
const long long inf = (long long)2e9;
const long double pi = asin(1) * 2;
const long double eps = 1e-8;
const long long mod = (long long)1e9 + 7;
const long long ns = 97;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
struct tree {
map<char, tree*> t;
tree* p;
tree* suf;
tree* ssuf;
int term, j;
char last;
tree() {
p = suf = ssuf = nullptr;
term = 0;
last = '#';
j = -1;
}
tree(tree* x, char r) {
last = r;
p = x;
suf = ssuf = nullptr;
term = 0;
j = -1;
}
};
void add(tree* root, string& s, int j, int i = 0) {
if (i == (int)s.size()) {
++root->term;
root->j = j;
return;
}
if (!root->t.count(s[i])) root->t[s[i]] = new tree(root, s[i]);
add(root->t[s[i]], s, j, i + 1);
}
tree* root = nullptr;
void bfs() {
queue<tree*> a;
a.push(root);
root->p = root->ssuf = root;
while (!a.empty()) {
auto v = a.front();
auto c = v->last;
a.pop();
auto u = v->p->ssuf;
while (1) {
if (u->t.count(c) && u->t[c] != v) {
v->ssuf = u->t[c];
break;
}
if (u == root) {
v->ssuf = u;
break;
}
u = u->ssuf;
}
for (auto& u : v->t) {
a.push(u.second);
}
}
a.push(root);
while (!a.empty()) {
auto v = a.front();
a.pop();
auto u = v->ssuf;
while (1) {
if (u == root || u->term) {
v->suf = u;
break;
}
u = u->suf;
}
for (auto& u : v->t) {
a.push(u.second);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
root = new tree();
string s;
cin >> s;
int q;
cin >> q;
vector<pair<int, string>> kek(q);
for (int i = 0; i < q; ++i) {
int x;
string t;
cin >> x >> t;
kek[i] = {x, t};
add(root, t, i);
}
bfs();
tree* r = root;
vector<vector<int>> lol(q);
for (int i = 0; i < (int)s.size(); ++i) {
char c = s[i];
while (1) {
if (r->t.count(c)) {
r = r->t[c];
break;
}
if (r == root) break;
r = r->ssuf;
}
auto t = r;
if (t->j == -1) t = t->suf;
while (t->j != -1) {
;
;
lol[t->j].push_back(i);
t = t->suf;
}
}
vector<int> ans(q);
for (int i = 0; i < q; ++i) {
int k = kek[i].first;
auto& v = lol[i];
if ((int)v.size() < k) {
ans[i] = -1;
continue;
}
int b = k - 1;
int res = inf;
while (b < (int)v.size()) {
chkmin(res, v[b] - v[b - k + 1]);
++b;
}
res += (int)kek[i].second.size();
ans[i] = res;
}
for (auto& x : ans) cout << x << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int base = 29;
int n, len;
long long Val[101010], Hash[101010], POW[101010], p[101010];
string s, m[101010];
vector<int> contains[101010], appear[101010];
int res[101010], k[101010];
long long getHash(int i, int j) {
return (Hash[j] - Hash[i - 1] * POW[j - i + 1] + MOD * MOD) % MOD;
}
void GoHome() {
cin >> s >> n;
len = s.size();
s = '~' + s;
Hash[0] = 0;
POW[0] = 1;
for (int i = (1); i <= (len); ++i) {
POW[i] = POW[i - 1] * base % MOD;
Hash[i] = (Hash[i - 1] * base + (s[i] - 'a')) % MOD;
}
for (int i = (1); i <= (n); ++i) {
cin >> k[i] >> m[i];
Val[i] = 0;
int sz = m[i].size();
for (int j = 0; j < (sz); ++j)
Val[i] = (Val[i] * base + (m[i][j] - 'a')) % MOD;
contains[sz].push_back(i);
res[i] = len + 1;
}
for (int i = (1); i <= (len); ++i)
if (contains[i].size()) {
sort(contains[i].begin(), contains[i].end(),
[](int x, int y) { return Val[x] < Val[y]; });
int sz = contains[i].size();
for (int j = 0; j < (sz); ++j) {
appear[j].clear();
p[j] = Val[contains[i][j]];
}
for (int j = (1); j <= (len - i + 1); ++j) {
long long val = getHash(j, j + i - 1);
int pos = lower_bound(p, p + sz, val) - p;
if (pos < sz && p[pos] == val) {
appear[pos].push_back(j);
}
}
for (int j = 0; j < (sz); ++j) {
int id = contains[i][j];
for (int t = (k[id]); t <= ((int)appear[j].size()); ++t) {
res[id] = min(res[id], appear[j][t - 1] + i - appear[j][t - k[id]]);
}
}
}
for (int id = (1); id <= (n); ++id) {
if (res[id] == len + 1) res[id] = -1;
cout << res[id] << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
GoHome();
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000005;
const long long INFLL = 1000000000000000002ll;
const long long MOD = 1000000009;
inline long long min(long long a, long long b, long long c) {
return min(min(a, b), c);
}
inline long long min(long long a, long long b, long long c, long long d) {
return min(min(min(a, b), c), d);
}
inline long long max(long long a, long long b, long long c) {
return max(max(a, b), c);
}
inline long long max(long long a, long long b, long long c, long long d) {
return max(max(max(a, b), c), d);
}
int Ans[100005], K[100005], L[100005], Q;
string S;
vector<int> Pos[100005];
struct AhoCorasick {
struct Node {
bool dictionary_fail;
vector<int> words;
Node *next[26];
Node *parent;
Node *fail;
Node() {
for (int i = (0); i <= (25); i++) next[i] = NULL;
dictionary_fail = false;
}
};
Node *root;
AhoCorasick() { root = new Node(); }
void add(string s, int id) {
Node *n = root;
for (int i = (0); i <= (((int)s.size()) - 1); i++) {
int l = s[i] - 'a';
if (n->next[l] == NULL) {
n->next[l] = new Node();
n->next[l]->parent = n;
}
n = n->next[l];
}
n->words.push_back(id);
}
string getWord(Node *n) {
string ret;
while (n != root) {
Node *p = n->parent;
for (int l = (0); l <= (25); l++)
if (p->next[l] == n) ret += (char)(l + 'a');
n = n->parent;
}
reverse(ret.begin(), ret.end());
return ret;
}
void printWords() {
queue<Node *> q;
q.push(root);
while (!q.empty()) {
Node *n = q.front();
q.pop();
if (!n->words.empty()) cout << getWord(n) << "\n";
for (int l = (0); l <= (25); l++)
if (n->next[l] != NULL) q.push(n->next[l]);
}
}
void makeFail() {
queue<Node *> q;
root->fail = root;
q.push(root);
while (!q.empty()) {
Node *n = q.front();
q.pop();
for (int l = (0); l <= (25); l++)
if (n->next[l] != NULL) {
Node *child = n->next[l];
Node *suf = n->fail;
while (suf->next[l] == NULL) {
if (suf == root) break;
suf = suf->fail;
}
if (suf->next[l] != NULL && suf->next[l] != child)
child->fail = suf->next[l];
else
child->fail = suf;
child->dictionary_fail =
(!child->fail->words.empty()) | child->fail->dictionary_fail;
q.push(n->next[l]);
}
}
}
vector<pair<int, int>> match(string t) {
Node *n = root;
vector<pair<int, int>> ret;
for (int i = (0); i <= (((int)t.size()) - 1); i++) {
int l = t[i] - 'a';
while (n->next[l] == NULL) {
if (n == root) break;
n = n->fail;
}
if (n->next[l] != NULL) n = n->next[l];
Node *suf = n;
while (!suf->words.empty() || suf->dictionary_fail) {
for (int id : suf->words) Pos[id].push_back(i);
suf = suf->fail;
}
}
return ret;
}
};
int main() {
ios_base::sync_with_stdio(false);
AhoCorasick aho;
cin >> S >> Q;
for (int q = (1); q <= (Q); q++) {
string t;
cin >> K[q] >> t;
L[q] = ((int)t.size());
aho.add(t, q);
}
aho.makeFail();
aho.match(S);
for (int q = (1); q <= (Q); q++) {
if (((int)Pos[q].size()) < K[q]) {
cout << "-1\n";
continue;
}
int ans = INF;
for (int i = (K[q] - 1); i <= (((int)Pos[q].size()) - 1); i++)
ans = min(ans, Pos[q][i] - Pos[q][i - K[q] + 1]);
cout << ans + L[q] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int po[100005];
char s[100005];
char m[100005];
int hs[100005];
int occ[100005];
int res[100005];
int k_rec[100005];
int hsval(int l, int r) {
return (hs[r] - (1LL * hs[l - 1] * po[r - l + 1]) % 1000000009 + 1000000009) %
1000000009;
}
int min(int a, int b) { return a < b ? a : b; }
map<int, int> mp[330 + 5];
int main() {
scanf("%s", &s[1]);
int n;
for (n = 1; s[n]; n++)
;
n--;
for (int i = 1; i <= n; i++)
hs[i] = (1LL * hs[i - 1] * 26 + s[i] - 'a') % 1000000009;
po[0] = 1;
for (int i = 1; i <= n; i++) po[i] = (1LL * po[i - 1] * 26) % 1000000009;
int q;
scanf("%d", &q);
for (int qr = 1; qr <= q; qr++) {
int k;
scanf("%d", &k);
scanf("%s", &m[1]);
int len;
for (len = 1; m[len]; len++)
;
len--;
int val = 0;
for (int i = 1; i <= len; i++)
val = (1LL * val * 26 + m[i] - 'a') % 1000000009;
res[qr] = 1e9;
if (len > 330) {
int found = 0;
for (int i = len; i <= n; i++) {
if (hsval(i - len + 1, i) == val) {
occ[++found] = i;
if (found >= k) res[qr] = min(res[qr], i - occ[found - k + 1] + len);
}
}
} else {
mp[len][val] = qr;
k_rec[qr] = k;
}
}
for (int len = 1; len <= 330; len++) {
map<int, vector<int>> occ;
for (int i = len; i <= n; i++) {
int x = hsval(i - len + 1, i);
if (mp[len].find(x) != mp[len].end()) {
int qr = mp[len][x];
occ[x].push_back(i);
int k = k_rec[qr];
int sz = (int)occ[x].size();
if (sz >= k) {
res[qr] = min(res[qr], i - occ[x][sz - k] + len);
}
}
}
}
for (int i = 1; i <= q; i++) {
if (res[i] > n)
printf("-1\n");
else
printf("%d\n", res[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct vec {
int to;
int fro;
};
int fa[200010], son[200010][26], mx[200010];
int rt, lst, tot;
int n, m;
char s[200010];
vec mp[200010];
int tai[200010], cnt;
int P[200010];
int ans[200010];
vector<int> qs[200010];
int av[200010];
int len[200010];
int Rt[200010], Son[4000010][2];
int TOT;
inline void be(int x, int y) {
mp[++cnt].to = y;
mp[cnt].fro = tai[x];
tai[x] = cnt;
}
int merge(int x, int y) {
if (!x || !y) {
return x + y;
}
Son[x][0] = merge(Son[x][0], Son[y][0]);
Son[x][1] = merge(Son[x][1], Son[y][1]);
return x;
}
void change(int &x, int y, int z, int p) {
if (!x) {
x = ++TOT;
}
if (y == z) {
return;
}
int mid = y + z >> 1;
if (p <= mid) {
change(Son[x][0], y, mid, p);
} else {
change(Son[x][1], mid + 1, z, p);
}
}
void ins(int x) {
int np = ++tot, p = lst;
mx[np] = mx[p] + 1;
while (p && !son[p][x]) {
son[p][x] = np;
p = fa[p];
}
if (!p) {
fa[np] = rt;
} else {
int q = son[p][x];
if (mx[q] == mx[p] + 1) {
fa[np] = q;
} else {
int nq = ++tot;
mx[nq] = mx[p] + 1;
memcpy(son[nq], son[q], sizeof(son[q]));
fa[nq] = fa[q];
fa[np] = fa[q] = nq;
while (p && son[p][x] == q) {
son[p][x] = nq;
p = fa[p];
}
}
}
lst = np;
}
int L;
int t[200010];
void DFS(int x, int y, int z) {
if (y == z) {
t[++L] = y;
return;
}
int mid = y + z >> 1;
if (Son[x][0]) {
DFS(Son[x][0], y, mid);
}
if (Son[x][1]) {
DFS(Son[x][1], mid + 1, z);
}
}
void dfs(int x) {
int i, y;
for (i = tai[x]; i; i = mp[i].fro) {
y = mp[i].to;
dfs(y);
}
for (i = tai[x]; i; i = mp[i].fro) {
y = mp[i].to;
Rt[x] = merge(Rt[x], Rt[y]);
}
L = 0;
if (qs[x].size()) {
L = 0;
DFS(Rt[x], 1, n);
for (i = 0; i < qs[x].size(); i++) {
int wzh = 1;
int ti = qs[x][i];
int tav = av[qs[x][i]];
if (L < tav) {
ans[ti] = -1;
} else {
ans[ti] = 1000000000;
for (int j = tav; j <= L; j++) {
ans[ti] = min(ans[ti], t[j] - t[j - tav + 1] + len[ti]);
}
}
}
}
}
int main() {
int i, x;
lst = rt = tot = 1;
scanf("%s", s + 1);
n = strlen(s + 1);
int p = rt;
for (i = 1; i <= n; i++) {
ins(s[i] - 'a');
p = son[p][s[i] - 'a'];
P[i] = p;
change(Rt[p], 1, n, i);
}
for (i = 2; i <= tot; i++) {
be(fa[i], i);
}
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d%s", &av[i], s + 1);
int p = rt;
for (int j = 1; s[j]; j++) {
p = son[p][s[j] - 'a'];
}
len[i] = strlen(s + 1);
if (!p) {
ans[i] = -1;
} else {
qs[p].push_back(i);
}
}
dfs(1);
for (i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct node {
int ptr[26];
int nxt[26];
int leaf, link, exlink, p, ch;
node(int _p = -1, int _ch = -1) {
p = _p;
ch = _ch;
link = exlink = leaf = -1;
memset(ptr, -1, sizeof(ptr));
memset(nxt, -1, sizeof(nxt));
}
};
vector<node> trie(1);
vector<int> pos[N];
string t[N];
string s;
int k[N];
int n;
void add(string s, int val) {
int cur = 0;
for (char c : s) {
if (trie[cur].ptr[c - 'a'] < 0) {
trie[cur].ptr[c - 'a'] = trie.size();
trie.push_back(node(cur, c - 'a'));
}
cur = trie[cur].ptr[c - 'a'];
}
trie[cur].leaf = val;
}
int getlink(int u);
int getnext(int u, int ch) {
int &res = trie[u].nxt[ch];
if (res == -1) {
if (trie[u].ptr[ch] != -1)
res = trie[u].ptr[ch];
else if (u == 0)
res = 0;
else
res = getnext(getlink(u), ch);
}
return res;
}
int getlink(int u) {
int &res = trie[u].link;
int ch = trie[u].ch;
if (res == -1) {
if (u == 0 || trie[u].p == 0) return res = 0;
res = getnext(getlink(trie[u].p), ch);
}
return res;
}
int getexlink(int u) {
int &res = trie[u].exlink;
if (res == -1) {
if (u == 0)
return res = 0;
else if (trie[getlink(u)].leaf >= 0)
res = getlink(u);
else
res = getexlink(getlink(u));
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s >> n;
for (int i = 1; i <= n; i++) {
cin >> k[i] >> t[i];
add(t[i], i);
}
int cur = 0;
for (int i = 0; i < (int)s.size(); i++) {
cur = getnext(cur, s[i] - 'a');
int tmp = cur;
while (tmp) {
if (trie[tmp].leaf) pos[trie[tmp].leaf].push_back(i);
tmp = getexlink(tmp);
}
}
for (int i = 1; i <= n; i++) {
if (pos[i].size() < k[i]) {
cout << "-1\n";
continue;
}
int res = 1e9;
for (int j = 0; j + k[i] <= (int)pos[i].size(); j++)
res = min(res, pos[i][j + k[i] - 1] - pos[i][j] + (int)t[i].size());
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct AhoCorasick {
struct vert {
int nxt[26], suffix, exit, character, parent;
vector<int> patterns;
vert(int c, int p) : suffix(-1), exit(-1), character(c), parent(p) {
memset(nxt, -1, sizeof(nxt));
}
};
vector<vert> aho;
AhoCorasick() { aho.push_back(vert(-1, 0)); }
void addString(string &s, int patternIdx) {
int v = 0;
for (char c : s) {
int idx = c - 'a';
if (aho[v].nxt[idx] == -1) {
aho[v].nxt[idx] = aho.size();
aho.emplace_back(idx, v);
}
v = aho[v].nxt[idx];
}
aho[v].patterns.push_back(patternIdx);
}
int getSuffix(int v) {
if (aho[v].suffix == -1) {
if (v == 0 || aho[v].parent == 0)
aho[v].suffix = 0;
else
aho[v].suffix = go(getSuffix(aho[v].parent), aho[v].character);
}
return aho[v].suffix;
}
int getExit(int v) {
if (aho[v].exit == -1) {
int suffix = getSuffix(v);
if (v == 0)
aho[v].exit = 0;
else {
if (aho[suffix].patterns.empty())
aho[v].exit = getExit(suffix);
else
aho[v].exit = suffix;
}
}
return aho[v].exit;
}
int go(int v, int c) {
if (aho[v].nxt[c] != -1)
return aho[v].nxt[c];
else
return v == 0 ? 0 : go(getSuffix(v), c);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
AhoCorasick aho;
int n;
cin >> n;
vector<int> k(n), len(n);
for (int i = 0; i < n; i++) {
string m;
cin >> k[i] >> m;
aho.addString(m, i);
len[i] = m.size();
}
vector<int> res(n, s.size() + 1);
vector<deque<int>> matches(n);
int v = 0;
for (int i = 0; i < (int)s.size(); i++) {
int idx = s[i] - 'a';
v = aho.go(v, idx);
int w = v;
do {
for (int p : aho.aho[w].patterns) {
matches[p].push_back(i - len[p] + 1);
while ((int)matches[p].size() > k[p]) matches[p].pop_front();
if ((int)matches[p].size() == k[p])
res[p] = min(res[p], i - matches[p][0] + 1);
}
w = aho.getExit(w);
} while (w != 0);
}
for (int r : res) {
if (r == (int)s.size() + 1)
cout << "-1" << endl;
else
cout << r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) { return n | (1LL << i); }
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) {
normal(a);
return modPow(a, 1000000007 - 2);
}
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
string t, str[100005];
int n, k[100005], last[100005], lagbe[100005], ans[100005];
int term[100005], len[100005], to[100005][26], link[100005], sz = 1,
dokhol[100005];
vector<int> lvl[100005], vt[100005];
int add_str(string &s) {
int cur = 0, siz = s.size();
for (int i = 0; i < siz; i++) {
char c = s[i];
if (!to[cur][c - 'a']) {
to[cur][c - 'a'] = sz++;
len[to[cur][c - 'a']] = len[cur] + 1;
}
cur = to[cur][c - 'a'];
}
term[cur] = cur;
lvl[len[cur]].push_back(cur);
return cur;
}
void push_links() {
int que[sz];
int st = 0, fi = 1;
que[0] = 0;
while (st < fi) {
int V = que[st++];
int U = link[V];
if (!term[V]) term[V] = term[U];
for (int c = 0; c < 26; c++)
if (to[V][c]) {
link[to[V][c]] = V ? to[U][c] : 0;
que[fi++] = to[V][c];
} else {
to[V][c] = to[U][c];
}
}
}
int result(int node) {
int res = 1e9;
if (vt[node].size() < lagbe[node]) res = -1;
sort(vt[node].begin(), vt[node].end());
int siz = str[dokhol[node]].size() - 1;
for (int i = 0; res != -1 && i <= vt[node].size() - lagbe[node]; i++) {
int tmp = vt[node][i + lagbe[node] - 1] - (vt[node][i] - siz) + 1;
res = min(res, tmp);
}
if (term[link[node]]) {
for (int i = 0; i < vt[node].size(); i++) {
vt[term[link[node]]].push_back(vt[node][i]);
}
}
return res;
}
void berkoro() {
int now = 0, siz = t.size();
for (int i = 0; i < siz; i++) {
now = to[now][t[i] - 'a'];
if (term[now]) vt[term[now]].push_back(i);
}
for (int i = 100005 - 1; i >= 1; i--) {
for (int j = 0, V; j < lvl[i].size(); j++) {
V = lvl[i][j];
ans[dokhol[V]] = result(V);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> t;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> k[i] >> str[i];
last[i] = add_str(str[i]);
dokhol[last[i]] = i;
lagbe[last[i]] = k[i];
}
push_links();
berkoro();
for (int i = 1; i <= n; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k[100010], N, M, len[100010];
char S[300005], buf[300005];
vector<int> v[100010];
struct NODE {
NODE() : is_end(0), count(0), f(0), o(0), num(0) {
for (int i = 0; i < 26; i++) nxt[i] = 0;
}
bool is_end;
int count, num;
NODE *nxt[26], *f, *o;
} * root;
NODE *my_end_node[100005];
int main() {
int j;
scanf("%s%d", S + 1, &M);
N = strlen(S + 1);
root = new NODE();
for (int i = 1; i <= M; i++) {
scanf("%d", &k[i]);
scanf("%s", buf + 1);
int n = strlen(buf + 1);
len[i] = n;
NODE *now = root;
for (int j = 1; j <= n; j++) {
int c = buf[j] - 'a';
if (!now->nxt[c]) now->nxt[c] = new NODE();
now = now->nxt[c];
}
now->is_end = 1;
now->num = i;
my_end_node[i] = now;
}
queue<NODE *> que;
for (int i = 0; i < 26; i++)
if (root->nxt[i]) {
root->nxt[i]->f = root;
que.push(root->nxt[i]);
}
while (!que.empty()) {
NODE *q = que.front();
que.pop();
if (q->is_end)
q->o = q;
else
q->o = q->f->o;
for (int i = 0; i < 26; i++)
if (q->nxt[i]) {
NODE *t = q->nxt[i];
t->f = q->f;
while (t->f != root && !t->f->nxt[i]) t->f = t->f->f;
if (t->f->nxt[i]) t->f = t->f->nxt[i];
que.push(t);
}
}
NODE *now = root;
NODE *now2 = root;
for (int i = 1; i <= N; i++) {
int c = S[i] - 'a';
while (now != root && !now->nxt[c]) now = now->f;
if (now->nxt[c]) now = now->nxt[c];
if (now->o) {
now2 = now->o;
while (now2 && now2->o) {
v[now2->o->num].push_back(i);
if (now2->o->num == 40) {
j = 1;
}
if (now2->o == now2) {
now2 = now2->f->o;
} else
now2 = now2->o;
}
now->o->count++;
}
}
for (int i = 1; i <= M; i++) {
int mini = 2147483647;
for (j = k[i] - 1; j < v[i].size(); j++) {
if (mini > v[i][j] - v[i][j - k[i] + 1] + len[i])
mini = v[i][j] - v[i][j - k[i] + 1] + len[i];
}
if (mini == 2147483647)
printf("-1\n");
else
printf("%d\n", mini);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using pii = pair<int, int>;
struct info {
bool query;
int cnt;
char ch;
info *fth, *link;
info *fewiuf[26];
bool isNext[26];
vector<int> pos;
info(info *_fth, char _ch) {
query = false;
cnt = 0;
ch = _ch - 'a';
fth = _fth;
link = nullptr;
memset(fewiuf, 0, sizeof fewiuf);
memset(isNext, 0, sizeof(isNext));
}
};
int k[100010], len[100010];
string s, m;
info *queryIdx[100010], *q[100010];
info *add(info *node, string s) {
for (auto ch : s) {
if (!node->fewiuf[ch - 'a']) {
node->fewiuf[ch - 'a'] = new info(node, ch);
node->isNext[ch - 'a'] = true;
}
node = node->fewiuf[ch - 'a'];
}
node->query = true;
return node;
}
info *getLink(info *node);
info *go(info *node, char ch);
void bfs(info *root);
int main() {
int i, n;
info *root, *node;
root = new info(nullptr, 0);
cin >> s >> n;
for (i = 0; i < n; ++i) {
cin >> k[i] >> m;
len[i] = m.size();
queryIdx[i] = add(root, m);
}
for (node = root, i = 0; i < s.length(); ++i) {
node = go(node, s[i] - 'a');
node->pos.push_back(i);
}
bfs(root);
for (i = 0; i < n; ++i) {
node = queryIdx[i];
if (node->pos.size() < k[i])
cout << -1 << '\n';
else {
sort(node->pos.begin(), node->pos.end());
int j, ans = 2000000010;
for (j = 0; j + k[i] - 1 < node->pos.size(); ++j)
ans = min(ans, node->pos[j + k[i] - 1] - node->pos[j] + len[i]);
cout << ans << '\n';
}
}
return 0;
}
info *getLink(info *node) {
if (node->link) return node->link;
if (!node->fth) return node->link = node;
if (!node->fth->fth) return node->link = node->fth;
return node->link = go(getLink(node->fth), node->ch);
}
info *go(info *node, char ch) {
if (node->fewiuf[ch]) return node->fewiuf[ch] = node->fewiuf[ch];
if (!node->fth) return node->fewiuf[ch] = node;
return node->fewiuf[ch] = go(getLink(node), ch);
}
void bfs(info *root) {
int i, l, r;
for (q[0] = root, l = r = 0; l <= r; ++l) {
q[l]->query |= getLink(q[l])->query;
for (i = 0; i < 26; ++i)
if (q[l]->isNext[i]) q[++r] = q[l]->fewiuf[i];
}
for (i = r; i > 0; --i) {
if (!q[i]->query) continue;
for (auto p : q[i]->pos) getLink(q[i])->pos.push_back(p);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int val, lev;
char ch;
node *next[26], *fail, *pa;
vector<int> output;
node() {
lev = val = 0;
pa = fail = NULL;
for (int i = 0; i <= 25; i++) next[i] = NULL;
}
};
node *Root;
int ID(char ch) { return (ch - 'a'); }
void in(string str, int p) {
node *s = Root;
int n = str.size();
for (int i = 0; i <= n - 1; i++) {
int x = ID(str[i]);
if (s->next[x] == NULL) {
s->next[x] = new node();
s->next[x]->ch = str[i];
s->next[x]->pa = s;
}
s = s->next[x];
}
s->output.push_back(p);
s->val = s->val + 1;
return;
}
queue<node *> que;
void outputLink(node *go, node *p) {
for (int i = 0; i <= (int)go->output.size() - 1; i++) {
int oto = go->output[i];
p->output.push_back(oto);
}
}
void bfs(node *p) {
que.push(p);
while (!que.empty()) {
p = que.front();
que.pop();
int C = ID(p->ch);
if (p->pa == Root) {
p->fail = Root;
} else {
node *s = p->pa->fail;
while (true) {
if (s->next[C] != NULL) {
p->fail = s->next[C];
outputLink(s->next[C], p);
break;
} else if (Root == s) {
p->fail = s;
break;
}
s = s->fail;
}
}
for (int i = 0; i <= 25; i++) {
if (p->next[i] != NULL) {
p->next[i]->lev = p->lev + 1;
que.push(p->next[i]);
}
}
}
}
string pattern[100010], text;
int col[100010], doo[100010], cnt[100010];
vector<int> aho[100010];
long long po[100010];
map<long long, int> mopa;
void readText() {
int p = 0, n = text.size(), x;
node *s = Root;
while (p < n) {
int x = ID(text[p]);
if (s->next[x] != NULL) {
s = s->next[x];
for (int i = 0; i <= (int)s->output.size() - 1; i++) {
int go = s->output[i];
col[go]++;
aho[go].push_back(p);
}
p++;
} else if (s == Root)
p++;
else
s = s->fail;
}
}
void info() {
long long x = 1;
for (int i = 0; i <= 100010 - 1; i++) {
po[i] = x;
x *= 29;
}
}
long long hasho(string str) {
long long n = str.size(), a, x = 0;
for (int i = 0; i <= n - 1; i++) {
a = str[i] - 'a';
a++;
x += (po[i] * a);
}
return x;
}
int main() {
ios::sync_with_stdio(false);
Root = new node();
Root->fail = Root;
Root->pa = Root;
int n;
long long v;
cin >> text;
cin >> n;
for (int i = 0; i <= n - 1; i++) {
cin >> cnt[i] >> pattern[i];
{ in(pattern[i], i); }
doo[i] = i;
}
bfs(Root);
readText();
for (int i = 0; i <= n - 1; i++) {
int k = -1, go = doo[i];
for (int j = cnt[i] - 1; j <= (int)aho[go].size() - 1; j++) {
int lp = j - cnt[i] + 1;
lp = (aho[go][lp] - (int)pattern[i].size()) + 1;
int mp = aho[go][j];
if (k == -1)
k = (mp - lp) + 1;
else
k = min(k, (mp - lp) + 1);
}
cout << k << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const long long int prime = 193297;
long long int st[N], h[N];
int l[N], sz[N];
vector<pair<long long int, int> > w[N];
vector<int> an[N];
int main() {
ios_base::sync_with_stdio(0);
string second;
cin >> second;
int n = (int)second.size();
st[0] = 1;
for (int i = 1; i <= n; ++i) {
st[i] = st[i - 1] * prime;
h[i] = h[i - 1] + st[i - 1] * second[i - 1];
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
string t;
cin >> l[i] >> t;
long long int hash = 0;
for (int i = 0; i < (int)t.size(); ++i) hash += t[i] * st[i];
hash *= st[n];
sz[i] = (int)t.size();
w[(int)t.size()].push_back(make_pair(hash, i));
}
for (int i = 1; i <= n; ++i) {
if (w[i].empty()) continue;
sort(w[i].begin(), w[i].end());
for (int j = i; j <= n; ++j) {
long long int hash = h[j] - h[j - i];
hash *= st[n - (j - i)];
auto it = lower_bound(w[i].begin(), w[i].end() - 1,
pair<long long int, int>{hash, 0});
if (it->first == hash) an[it->second].push_back(j);
}
}
for (int i = 0; i < m; ++i) {
if ((int)an[i].size() < l[i]) {
cout << "-1\n";
continue;
}
int ans = n;
for (int j = 0; j + l[i] - 1 < (int)an[i].size(); ++j)
ans = min(ans, an[i][j + l[i] - 1] - an[i][j]);
cout << ans + sz[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1 << 17, Sq = 1 << 5, B = 313,
Mod = 1000 * 1000 * 1000 + 7;
long long P[maxN], H[maxN];
inline long long getHash(long long l, long long r) {
return (H[r] - H[l] * P[r - l] % Mod + Mod) % Mod;
}
unordered_map<long long, vector<long long>> Li[Sq];
int32_t main() {
string S;
cin >> S;
long long n = S.size();
P[0] = 1;
for (long long i = 0; i < n; i++) {
H[i + 1] = (H[i] * B + S[i]) % Mod;
P[i + 1] = (P[i] * B) % Mod;
}
for (long long l = 1; l < Sq; l++)
for (long long i = 0; i + l <= n; i++)
Li[l][getHash(i, i + l)].push_back(i);
long long q;
cin >> q;
while (q--) {
long long k, THash = 0;
cin >> k;
string T;
cin >> T;
for (long long i = 0; i < T.size(); i++) THash = (THash * B + T[i]) % Mod;
vector<long long> St;
if (T.size() < Sq)
St = Li[T.size()][THash];
else
for (long long i = 0; i + T.size() <= n; i++)
if (getHash(i, i + T.size()) == THash) St.push_back(i);
long long a = n + 1;
for (long long i = k - 1; i < St.size(); i++)
a = min(a, St[i] - St[i - k + 1] + (long long)(T.size()));
if (a == n + 1) a = -1;
cout << a << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k[100005], Next[100005][27], cnt, out[100005], link[100005];
vector<int> id[100005], res[100005];
string s, t[100005];
void Add(string s, int x) {
int u = 0;
for (int i = 0; s[i]; i++) {
int v = s[i] - 'a';
if (!Next[u][v]) Next[u][v] = ++cnt;
u = Next[u][v];
}
out[u]++;
id[u].push_back(x);
}
int get_next(int u, int k) {
while (u != -1) {
if (Next[u][k]) return Next[u][k];
u = link[u];
}
return 0;
}
void Bfs() {
queue<int> q;
q.push(0);
link[0] = -1;
while (q.size()) {
int u = q.front();
q.pop();
for (int p = (0); p <= (25); p++) {
if (Next[u][p]) {
int v = Next[u][p];
link[v] = get_next(link[u], p);
q.push(v);
out[v] += out[link[v]];
copy(id[link[v]].begin(), id[link[v]].end(), back_inserter(id[v]));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> k[i] >> t[i];
Add(t[i], i);
}
Bfs();
int p = 0;
for (int i = 0; s[i]; i++) {
p = get_next(p, s[i] - 'a');
for (int u : id[p]) res[u].push_back(i);
}
for (int i = (1); i <= (n); i++) {
if (res[i].size() < k[i]) {
cout << -1 << '\n';
continue;
}
int low = 1e9;
for (int j = (k[i] - 1); j <= (res[i].size() - 1); j++) {
low = min(low, res[i][j] - res[i][j - k[i] + 1]);
}
cout << low + t[i].size() << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
static const int maxn = 5e5 + 5;
int Next[27][maxn], End[maxn], sz, Num[maxn], backPoint[maxn];
bool created[maxn];
vector<int> out[maxn], patternIndices[maxn], occur[maxn];
string text, pattern[maxn];
int numPat, k[maxn];
void init() {
sz = 0;
memset(Next, 0, sizeof Next);
memset(End, 0, sizeof End);
memset(created, 0, sizeof created);
memset(Num, 0, sizeof Num);
for (int i = 0; i < maxn; i++) {
out[i].clear();
patternIndices[i].clear();
}
}
void insertPattern(const string &pat, const int id) {
int v = 0;
for (char ch : pat) {
int val = ch - 'a';
if (!created[Next[val][v]]) {
++sz;
Next[val][v] = sz;
created[sz] = 1;
}
v = Next[val][v];
}
End[v]++;
patternIndices[v].emplace_back(id);
}
void findBackPointer() {
queue<int> PQ;
int v = 0;
for (int i = 0; i < 26; i++) {
if (Next[i][v]) {
PQ.emplace(Next[i][v]);
backPoint[Next[i][v]] = v;
out[v].emplace_back(Next[i][v]);
}
}
while (!PQ.empty()) {
int u = PQ.front();
PQ.pop();
for (int i = 0; i < 26; i++) {
int v = Next[i][u];
if (!v) continue;
int w = backPoint[u];
while (w && Next[i][w] == 0) w = backPoint[w];
backPoint[v] = Next[i][w];
out[Next[i][w]].push_back(v);
for (int p : patternIndices[Next[i][w]]) patternIndices[v].push_back(p);
PQ.emplace(v);
}
}
}
void insertText(const string &text) {
int v = 0;
for (int i = 0; i < text.size(); i++) {
int val = text[i] - 'a';
while (v && Next[val][v] == 0) v = backPoint[v];
v = Next[val][v];
for (int p : patternIndices[v]) occur[p].push_back(i);
}
}
int query(int id) {
int len = pattern[id].size();
int occ = occur[id].size();
if (occ < k[id]) return -1;
int mini = 1e7;
for (int i = 0, j = k[id] - 1; j < occ; i++, j++)
mini = min(mini, occur[id][j] - occur[id][i]);
return mini + len;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(3);
init();
cin >> text >> numPat;
for (int i = 1; i <= numPat; i++) {
cin >> k[i] >> pattern[i];
insertPattern(pattern[i], i);
}
findBackPointer();
insertText(text);
for (int i = 1; i <= numPat; i++) cout << query(i) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const int inf = INT_MAX;
template <char f = 'a', size_t K = 26>
class AhoCorasick {
public:
struct Node {
bool leaf;
char pch;
int idx, p, link, exitLink;
array<int, K> next;
Node(int p, char pch)
: leaf(false), pch(pch), idx(-1), p(p), link(-1), exitLink(-1) {
next.fill(-1);
}
};
vector<Node> t;
AhoCorasick() : t(1, Node(-1, ' ')) {}
AhoCorasick(const vector<string>& s) : t(1, Node(-1, ' ')) {
for (const string& ss : s) {
insert(ss);
}
}
void insert(const string& s, int idx) {
int cur = 0;
for (char ch : s) {
if (t[cur].next[ch - f] == -1) {
t[cur].next[ch - f] = (int)t.size();
t.emplace_back(cur, ch);
}
cur = t[cur].next[ch - f];
}
t[cur].idx = idx;
t[cur].leaf = true;
}
int getLink(int cur) {
if (t[cur].link == -1) {
if (cur == 0 || t[cur].p == 0) {
t[cur].link = 0;
} else {
t[cur].link = next(getLink(t[cur].p), t[cur].pch);
getLink(t[cur].link);
if (t[t[cur].link].leaf) {
t[cur].exitLink = t[cur].link;
} else {
t[cur].exitLink = t[t[cur].link].exitLink;
}
}
}
return t[cur].link;
}
int next(int cur, char ch) {
if (t[cur].next[ch - f] == -1) {
if (cur == 0) {
t[cur].next[ch - f] = 0;
} else {
t[cur].next[ch - f] = next(getLink(cur), ch);
}
}
return t[cur].next[ch - f];
}
Node& operator[](int i) { return t[i]; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = s.length();
AhoCorasick<> t;
int m;
cin >> m;
vector<pair<int, string>> queries(m);
for (int i = 0; i < m; i++) {
cin >> queries[i].first >> queries[i].second;
t.insert(queries[i].second, i);
}
vector<int> ans(m, n + 1);
vector<queue<int>> q(m);
for (int i = 0, cur = 0; i < n; i++) {
cur = t.next(cur, s[i]);
int curr = cur;
while (curr != -1) {
if (t[curr].idx != -1) {
int j = t[curr].idx;
if (q[j].size() == queries[j].first) {
q[j].pop();
q[j].push(i);
} else {
q[j].push(i);
}
if (q[j].size() == queries[j].first) {
ans[j] = min(ans[j], q[j].back() - q[j].front() +
(int)queries[j].second.length());
}
}
t.getLink(curr);
curr = t[curr].exitLink;
}
}
for (int i = 0; i < m; i++) {
cout << (ans[i] < n + 1 ? ans[i] : -1) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const ALPHA = 26;
struct Node {
int to[ALPHA];
bool leaf;
int link;
int ext;
int lvl;
int idx;
Node() {
leaf = link = ext = lvl = 0;
idx = -1;
for (int i = 0; i < ALPHA; i++) to[i] = 0;
}
};
vector<Node> t(1);
void add(string &s, int id) {
int v = 0;
for (auto ch : s) {
if (!t[v].to[ch - 'a']) {
t[v].to[ch - 'a'] = t.size();
t.push_back(Node());
}
v = t[v].to[ch - 'a'];
}
t[v].leaf = 1;
t[v].idx = id;
}
void build_aho() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int p = q.front();
q.pop();
for (int ch = 0; ch < ALPHA; ch++) {
int v = t[p].to[ch];
if (v) {
t[v].link = (p == 0) ? 0 : t[t[p].link].to[ch];
if (t[t[v].link].leaf) {
t[v].ext = t[v].link;
} else {
t[v].ext = t[t[v].link].ext;
}
t[v].lvl = t[p].lvl + 1;
q.push(v);
} else {
t[p].to[ch] = t[t[p].link].to[ch];
}
}
}
}
vector<int> g[100010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n;
cin >> n;
vector<pair<int, string>> q(n);
for (int i = 0; i < n; i++) {
cin >> q[i].first >> q[i].second;
add(q[i].second, i);
}
build_aho();
int cur = 0;
for (int i = 0; i < s.size(); i++) {
cur = t[cur].to[s[i] - 'a'];
int temp = cur;
while (temp != 0) {
if (t[temp].leaf) g[t[temp].idx].push_back(i);
temp = t[temp].ext;
}
}
for (int i = 0; i < n; i++) {
if (g[i].size() < q[i].first)
cout << -1 << "\n";
else {
sort(g[i].begin(), g[i].end());
int mn = 1e8;
for (int j = q[i].first - 1; j < g[i].size(); j++) {
mn = min(
mn, (int)(g[i][j] - g[i][j - q[i].first + 1] + q[i].second.size()));
}
cout << mn << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long aa;
bool bb;
char ch;
long long scan() {
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
ch == '-' ? (bb = 1, aa = 0) : (bb = 0, aa = ch - 48);
while (ch = getchar(), (ch >= '0' && ch <= '9')) aa = aa * 10 + ch - 48;
return (bb ? (-aa) : (aa));
}
inline int Min(int u, int v) { return u < v ? u : v; }
const int INF = 2147483647;
int len_str;
char s[100000], str[100000];
int len[100000];
int pos[100000];
int g[100000][30] = {};
int fail[100000] = {}, sz = 0;
int K[100000], Q;
int n;
int ans[100000];
int set_num = 0, num[100000];
set<int> Set[100000];
queue<int> q;
struct E {
int to, next;
} e[100000];
int last[100000] = {}, tot = 0;
void add(int u, int v) {
e[++tot].next = last[u];
last[u] = tot;
e[tot].to = v;
}
void ins(int p) {
int i, u;
u = 0;
for (i = 0; i < len[p]; ++i) {
s[i] = s[i] - 'a';
if (!g[u][s[i]]) {
g[u][s[i]] = ++sz;
}
u = g[u][s[i]];
}
pos[u] = p;
}
void build_ac() {
int i, u, v;
for (i = 0; i < 26; ++i)
if (g[0][i]) q.push(g[0][i]);
while (!q.empty()) {
u = q.front();
q.pop();
for (i = 0; i < 26; ++i) {
if (g[u][i]) {
v = g[u][i];
q.push(v);
fail[v] = g[fail[u]][i];
} else if (u)
g[u][i] = g[fail[u]][i];
}
}
}
void build_tree() {
for (int i = 1; i <= sz; ++i) add(fail[i], i);
}
void dfs(int u) {
int max_node = u;
for (int i = last[u]; i; i = e[i].next) {
dfs(e[i].to);
if (Set[num[e[i].to]].size() > Set[num[max_node]].size())
max_node = e[i].to;
}
set<int>::iterator j;
for (int i = last[u]; i; i = e[i].next) {
if (e[i].to == max_node) continue;
for (j = Set[num[e[i].to]].begin(); j != Set[num[e[i].to]].end(); j++)
Set[num[max_node]].insert(*j);
}
if (max_node != u) {
for (j = Set[num[u]].begin(); j != Set[num[u]].end(); j++)
Set[num[max_node]].insert(*j);
num[u] = num[max_node];
}
if (pos[u]) {
vector<int> p;
for (j = Set[num[u]].begin(); j != Set[num[u]].end(); j++) p.push_back(*j);
int tmp = INF;
for (int k = K[pos[u]], h = k - 1; h < p.size(); ++h)
tmp = Min(tmp, p[h] - p[h - k + 1]);
if (tmp == INF)
ans[pos[u]] = -1;
else
ans[pos[u]] = tmp + len[pos[u]];
}
}
int main() {
scanf("%s", str);
len_str = strlen(str);
scanf("%d", &Q);
for (int i = 1; i <= Q; ++i) {
scanf("%d", &K[i]);
scanf("%s", s);
len[i] = strlen(s);
ins(i);
}
build_ac();
build_tree();
int u = 0;
for (int i = 0; i < len_str; ++i) {
u = g[u][str[i] - 'a'];
if (!num[u]) num[u] = ++set_num;
Set[num[u]].insert(i);
}
dfs(0);
for (int i = 1; i <= Q; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100, INF = 0x3f3f3f3f;
char ax[maxn], bx[maxn];
int id[maxn], ans[maxn], bel[maxn], temp[maxn], val[maxn], L[maxn];
vector<int> ac[maxn];
set<int> ss[maxn];
struct AC_hod {
int Size = 1;
struct node {
int Next[26];
int fail, cnt, nn, len;
} Tree[maxn];
void init() {
build_newnode(0);
Size = 1;
}
void build_newnode(int now) {
for (int i = 0; i < 26; i++) Tree[now].Next[i] = 0;
Tree[now].fail = 0, Tree[now].cnt = 0;
Tree[now].nn = 0;
}
int Insert(char* s, int c) {
int now = 0, cnt1 = strlen(s);
for (int i = 0; i < cnt1; i++) {
if (!Tree[now].Next[s[i] - 'a']) {
Tree[now].Next[s[i] - 'a'] = Size++;
build_newnode(Size - 1);
}
now = Tree[now].Next[s[i] - 'a'];
}
Tree[now].cnt = c, Tree[now].len = cnt1;
return now;
}
void build() {
int now = 0;
Tree[now].fail = 0;
queue<int> Q;
Q.push(now);
while (!Q.empty()) {
now = Q.front();
Q.pop();
for (int i = 0; i < 26; i++) {
int temp = Tree[now].Next[i];
if (temp) {
if (now == 0)
Tree[temp].fail = 0;
else
Tree[temp].fail = Tree[Tree[now].fail].Next[i];
Q.push(temp);
} else {
if (!now)
Tree[now].Next[i] = 0;
else
Tree[now].Next[i] = Tree[Tree[now].fail].Next[i];
}
}
}
}
void buildTree() {
for (int i = 1; i <= Size; i++) ac[Tree[i].fail].push_back(i);
}
void make(char* s) {
int len = strlen(s), now = 0, l = 0;
memset(bel, 0, sizeof(bel));
for (int i = 0; i < len; i++) {
int c = s[i] - 'a';
now = Tree[now].Next[c];
if (!bel[now]) bel[now] = ++l;
ss[bel[now]].insert(i);
}
}
void calc(int x) {
int now = x;
for (int i = 0; i < ac[x].size(); i++) {
int v = ac[x][i];
calc(v);
if (ss[bel[v]].size() > ss[bel[now]].size()) now = v;
}
for (int i = 0; i < ac[x].size(); i++) {
int v = ac[x][i];
if (v == now) continue;
for (auto j = ss[bel[v]].begin(); j != ss[bel[v]].end(); j++) {
ss[bel[now]].insert(*j);
}
}
if (x != now) {
for (auto j = ss[bel[x]].begin(); j != ss[bel[x]].end(); j++)
ss[bel[now]].insert(*j);
bel[x] = bel[now];
}
if (temp[x]) {
int k = temp[x];
vector<int> bc;
for (auto j = ss[bel[now]].begin(); j != ss[bel[now]].end(); j++)
bc.push_back(*j);
for (int z = val[k] - 1; z < bc.size(); z++)
ans[k] = min(ans[k], bc[z] - bc[z - val[k] + 1]);
if (ans[k] != INF) ans[k] += L[k];
}
}
} AC;
int main() {
scanf("%s", &ax);
int n;
scanf("%d", &n);
memset(ans, INF, sizeof(ans));
for (int i = 1; i <= n; i++) {
scanf("%d%s", &val[i], &bx);
id[i] = AC.Insert(bx, val[i]);
temp[id[i]] = i;
L[i] = strlen(bx);
}
AC.build();
AC.buildTree();
AC.make(ax);
AC.calc(0);
for (int i = 1; i <= n; i++) {
if (ans[i] == INF)
printf("%d\n", -1);
else
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 26;
struct node {
int pre = 0, sl = 0, id = 0;
int go[M];
node() {
for (int i = 0; i < M; i++) go[i] = 0;
}
};
node ah[2 * N];
int nxt = 1;
int k[N], ans[N], sz[N];
void trie(string s, int id) {
int n = 0;
for (char c : s) {
if (!ah[n].go[c - 'a']) ah[n].go[c - 'a'] = nxt++;
n = ah[n].go[c - 'a'];
}
ah[n].id = id;
}
void build_ah() {
int n = 0, u, v;
queue<int> q;
q.push(0);
while (!q.empty()) {
n = q.front();
q.pop();
for (int i = 0; i < M; i++) {
if (!ah[n].go[i]) continue;
u = ah[n].sl;
v = ah[n].go[i];
while (u && !ah[u].go[i]) u = ah[u].sl;
u = ah[u].go[i];
if (u != v) {
ah[v].sl = u;
ah[v].pre = ah[u].id ? u : ah[u].pre;
}
q.push(v);
}
}
}
void find(string s) {
int n = 0, i = 0, id;
vector<deque<int> > found(N);
for (char c : s) {
while (n && !ah[n].go[c - 'a']) n = ah[n].sl;
n = ah[n].go[c - 'a'];
for (int m = n; m > 0; m = ah[m].pre) {
id = ah[m].id;
if (!id) continue;
deque<int> &dq = found[id];
dq.push_back(i);
while (dq.size() > k[id]) dq.pop_front();
if (dq.size() == k[id])
ans[id] = min(ans[id], dq.back() - dq.front() + sz[id]);
}
i++;
}
}
int main() {
string s, x;
cin >> s;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> k[i] >> x;
sz[i] = x.size();
trie(x, i);
ans[i] = 2 * N;
}
build_ah();
find(s);
for (int i = 1; i <= n; i++) {
if (ans[i] != 2 * N)
cout << ans[i] << "\n";
else
cout << "-1\n";
}
return 0;
}
|
#include <bits/stdc++.h>
std::mt19937_64 rng(
std::chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int R) {
long long int val = rng() % R;
assert(val >= 0);
return val;
}
const long double PI = atan(1.0) * 4;
const int32_t INF32 = 2e9 + 7;
const int64_t INF64 = 3e18;
const int32_t LOG = 21;
const int32_t MOD = 1e9 + 7;
using namespace std;
void my_debugger(string second, long long int LINE_NUM) { cerr << '\n'; }
template <typename start, typename... end>
void my_debugger(string second, long long int LINE_NUM, start x, end... y) {
if (second.back() != ',') {
second += ',';
cerr << "LINE(" << LINE_NUM << "): ";
}
long long int i = second.find(',');
cerr << second.substr(0, i) << " = " << x;
second = second.substr(i + 1);
if (!second.empty()) cerr << ", ";
my_debugger(second, LINE_NUM, y...);
}
struct aho_corasick {
struct node {
long long int nxt[26];
long long int go[26];
bool leaf;
long long int p;
long long int pch;
long long int link;
long long int good_link;
long long int val;
node() {
fill(begin(nxt), end(nxt), -1);
fill(begin(go), end(go), -1);
leaf = false;
p = pch = -1;
link = good_link = -1;
val = -1;
}
};
vector<node> nodes;
aho_corasick() { nodes = vector<node>(1, node()); }
long long int add(const string& second) {
long long int cur = 0;
for (auto it : second) {
long long int ch = it - 'a';
if (nodes[cur].nxt[ch] == -1) {
nodes[cur].nxt[ch] = nodes.size();
nodes.emplace_back(node());
nodes.back().p = cur;
nodes.back().pch = ch;
}
cur = nodes[cur].nxt[ch];
}
nodes[cur].leaf = true;
return cur;
}
long long int suf_link(long long int v) {
if (nodes[v].link == -1) {
if (v == 0 || nodes[v].p == 0)
nodes[v].link = 0;
else
nodes[v].link = go(suf_link(nodes[v].p), nodes[v].pch);
}
return nodes[v].link;
}
long long int go(long long int v, long long int ch) {
if (nodes[v].go[ch] == -1) {
if (nodes[v].nxt[ch] != -1)
nodes[v].go[ch] = nodes[v].nxt[ch];
else
nodes[v].go[ch] = (v == 0) ? 0 : go(suf_link(v), ch);
}
return nodes[v].go[ch];
}
};
vector<tuple<long long int, string, long long int>> queries[100005];
vector<long long int> v[100005];
long long int ans[100005];
long long int need[100005];
long long int slen[100005];
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
long long int tests = 1;
for (long long int ii = 0; ii < (long long int)tests; ii++) {
string second;
cin >> second;
long long int q;
cin >> q;
for (long long int i = 0; i < (long long int)q; i++) {
ans[i] = -1;
long long int k;
string s1;
cin >> k >> s1;
need[i] = k;
slen[i] = s1.size();
long long int siz = s1.size();
queries[siz].push_back({k, s1, i});
}
long long int len = second.size();
for (long long int i = 0; i < (long long int)len + 1; i++) {
if (queries[i].empty()) continue;
vector<long long int> indices;
aho_corasick aho;
for (auto& it : queries[i]) {
long long int ind;
string s1;
tie(ignore, s1, ind) = it;
indices.push_back(ind);
long long int v = aho.add(s1);
aho.nodes[v].val = ind;
}
long long int cur = 0;
long long int j = 0;
for (auto& it : second) {
long long int ch = it - 'a';
cur = aho.go(cur, ch);
if (aho.nodes[cur].leaf) {
long long int ind = aho.nodes[cur].val;
long long int siz = slen[ind];
v[ind].push_back(j - siz + 1);
}
j++;
}
for (auto& ind : indices) {
long long int siz = v[ind].size();
for (long long int j = 0; j < siz; j++) {
if (j + need[ind] - 1 >= siz) break;
long long int l = v[ind][j];
long long int r = v[ind][j + need[ind] - 1];
r = r + slen[ind] - 1;
if (ans[ind] == -1 || ans[ind] > r - l + 1) ans[ind] = r - l + 1;
}
}
}
for (long long int i = 0; i < (long long int)q; i++) cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int chr = 26;
struct node {
int nxt[chr];
node() { memset(nxt, -1, sizeof(nxt)); }
};
node T[250005];
int suffix[250005], indx, len, path[250005];
int val[250005], ed[250005], E[250005], sf[250005];
vector<int> v[250005];
struct Aho_Corasick {
void init() {
len = indx = 0;
memset(E, 0, sizeof(E));
memset(T, 0, sizeof(T));
memset(suffix, 0, sizeof(suffix));
memset(val, 0, sizeof(val));
T[indx] = node();
}
void insert(string s, int p) {
int now = 0;
for (int i = 0; i < s.size(); i++) {
int id = s[i] - 'a';
if (T[now].nxt[id] == -1) {
T[now].nxt[id] = ++indx;
T[indx] = node();
}
now = T[now].nxt[id];
}
ed[p] = now;
E[now] = p;
}
void reverse_link() {
queue<int> q;
for (int i = 0; i < chr; i++) {
if (T[0].nxt[i] != -1) {
q.push(T[0].nxt[i]);
} else
T[0].nxt[i] = 0;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < chr; i++) {
int v = T[u].nxt[i];
if (v == -1) {
T[u].nxt[i] = T[suffix[u]].nxt[i];
continue;
}
suffix[v] = T[suffix[u]].nxt[i];
if (E[suffix[v]])
sf[v] = suffix[v];
else
sf[v] = sf[suffix[v]];
q.push(v);
path[len++] = v;
}
}
}
void search(string s) {
int now = 0;
for (int i = 0; i < s.size(); i++) {
int id = s[i] - 'a';
now = T[now].nxt[id];
val[now]++;
int nd = now;
while (nd > 0) {
if (E[nd]) v[E[nd]].push_back(i + 1);
nd = sf[nd];
}
}
for (int i = len - 1; i >= 0; i--) {
val[suffix[path[i]]] += val[path[i]];
}
}
} AC;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
string T;
cin >> T >> n;
vector<pair<int, string> > vc;
for (int i = 1; i <= n; i++) {
string s;
cin >> k >> s;
vc.push_back({k, s});
AC.insert(s, i);
}
AC.reverse_link();
AC.search(T);
for (int i = 1; i <= n; i++) {
if (val[ed[i]] < vc[i - 1].first)
cout << "-1\n";
else {
int mn = 250005;
int sz = vc[i - 1].second.size();
k = vc[i - 1].first;
for (int j = k - 1; j < v[i].size(); j++) {
mn = min(mn, v[i][j] - v[i][j - k + 1] + sz);
}
cout << mn << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
char s[100010], m[100010];
int len, n;
std::set<int> A[100010];
int ch[100010][26], tot, fail[100010], p[100010], Q[100010], k[100010],
l[100010], Ans[100010];
void Add(char *s, int pos) {
int now = 0;
for (int i = 1; s[i]; ++i) {
int t = s[i] - 'a';
if (!ch[now][t]) ch[now][t] = ++tot;
now = ch[now][t];
}
p[now] = pos;
}
void Build() {
int head = 0, tail = 0;
for (int i = 0; i < 26; ++i)
if (ch[0][i]) Q[++tail] = ch[0][i];
do {
int u = Q[++head];
for (int i = 0; i < 26; ++i)
if (ch[u][i]) {
fail[Q[++tail] = ch[u][i]] = ch[fail[u]][i];
} else
ch[u][i] = ch[fail[u]][i];
} while (head < tail);
}
int Point[100010], Next[100010], To[100010], q;
void Add_Edge(int u, int v) {
Next[++q] = Point[u];
Point[u] = q;
To[q] = v;
}
void dfs(int u) {
for (int j = Point[u]; j; j = Next[j]) {
dfs(To[j]);
if (A[u].size() < A[To[j]].size()) std::swap(A[u], A[To[j]]);
for (std::set<int>::iterator i = A[To[j]].begin(); i != A[To[j]].end(); ++i)
A[u].insert(*i);
}
if (p[u]) {
tot = 0;
for (std::set<int>::iterator i = A[u].begin(); i != A[u].end(); ++i)
Q[++tot] = *i;
int K = k[p[u]];
if (A[u].size() < K) {
Ans[p[u]] = -1;
return;
}
Ans[p[u]] = 2147483647;
for (int i = 1, lim = A[u].size(); i <= tot - K + 1; ++i)
Ans[p[u]] =
(Ans[p[u]] < Q[i + K - 1] - Q[i] ? Ans[p[u]] : Q[i + K - 1] - Q[i]);
Ans[p[u]] += l[p[u]];
}
}
int main() {
scanf("%s %d", s + 1, &n);
len = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
scanf("%d %s", &k[i], m + 1);
l[i] = strlen(m + 1);
Add(m, i);
}
Build();
int now = 0;
for (int i = 1; i <= len; ++i) {
int t = s[i] - 'a';
now = ch[now][t];
A[now].insert(i);
}
for (int i = 1; i <= tot; ++i) Add_Edge(fail[i], i);
dfs(0);
for (int i = 1; i <= n; ++i) printf("%d\n", Ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100010], ss[100100];
int ll, x[100100], l2;
int pp[100100];
vector<int> vv[200100];
set<int> sss[200100];
int n, ans[100100];
int lll[100100];
namespace SAM {
int mem, np, root;
int len[200100], par[200100];
int trans[200100][26];
int posl[200100], posr[200100];
void append(int ch) {
int p = np;
np = ++mem;
len[np] = len[p] + 1;
for (; p && !trans[p][ch]; p = par[p]) trans[p][ch] = np;
if (!p)
par[np] = root;
else {
int q = trans[p][ch];
if (len[q] == len[p] + 1)
par[np] = q;
else {
int nq = ++mem;
par[nq] = par[q];
par[q] = par[np] = nq;
memcpy(trans[nq], trans[q], sizeof(trans[nq]));
len[nq] = len[p] + 1;
posl[nq] = posl[q];
posr[nq] = posl[q] - (len[nq] - len[par[nq]]) + 1;
posl[q] = posr[nq] - 1;
for (; p && trans[p][ch] == q; p = par[p]) trans[p][ch] = nq;
}
}
}
void build() {
np = root = ++mem;
int i, now;
for (i = 1; i <= ll; i++) {
append(s[i] - 'a'), sss[np].insert(i);
for (now = np; now != root && !posr[now] && !posl[now]; now = par[now]) {
posl[now] = i - len[par[now]];
posr[now] = i - len[now] + 1;
}
}
}
} // namespace SAM
namespace ST {
int ch[200100][26];
using SAM::par;
void build() {
int i;
for (i = 1; i <= SAM::mem; i++) {
if (par[i]) {
ch[par[i]][s[SAM::posl[i]] - 'a'] = i;
}
}
}
} // namespace ST
void work(int tt) {
using SAM::root, SAM::posl, SAM::posr, ST::ch;
int i, now = root, j, k;
for (i = l2; i >= 1;) {
now = ch[now][ss[i] - 'a'];
if (!now) return;
for (j = i, k = posl[now]; j >= 1 && k >= posr[now]; j--, k--)
if (ss[j] != s[k]) return;
i -= posl[now] - posr[now] + 1;
}
vv[now].push_back(tt);
}
queue<int> q;
int in[200100];
void work2() {
using SAM::mem, SAM::par;
int i, j, t;
vector<int> tmp;
for (i = 1; i <= mem; i++)
if (par[i]) in[par[i]]++;
for (i = 1; i <= mem; i++)
if (!in[i]) q.push(i);
while (!q.empty()) {
t = q.front();
q.pop();
if (vv[t].size()) {
tmp.clear();
for (auto k : sss[t]) tmp.push_back(k);
}
for (auto p : vv[t]) {
for (i = 0, j = x[p] - 1; j < tmp.size(); i++, j++) {
ans[p] = min(ans[p], tmp[j] - tmp[i] + lll[p]);
}
}
if (par[t]) {
if (sss[par[t]].size() < sss[t].size()) swap(sss[par[t]], sss[t]);
for (auto k : sss[t]) sss[par[t]].insert(k);
sss[t].clear();
in[par[t]]--;
if (!in[par[t]]) q.push(par[t]);
}
}
}
int main() {
int i;
scanf("%s", s + 1);
ll = strlen(s + 1);
SAM::build();
ST::build();
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%s", &x[i], ss + 1);
l2 = lll[i] = strlen(ss + 1);
work(i);
}
memset(ans, 0x3f, sizeof(ans));
work2();
for (i = 1; i <= n; i++) printf("%d\n", ans[i] == 0x3f3f3f3f ? -1 : ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long n1, long long n2) {
if (!n1) return n2;
if (!n2) return n1;
if (n1 % n2 == 0) return n2;
return gcd(n2, n1 % n2);
}
long long powmod(long long base, long long exponent) {
base %= 1000000007;
long long ans = 1;
while (exponent) {
if (exponent & 1) ans = (ans * base) % 1000000007;
base = (base * base) % 1000000007;
exponent /= 2;
}
ans %= 1000000007;
return ans;
}
int trie[200100 + 1][26];
int memo[200100 + 1][26];
int node_cnt;
int parent[200100 + 1];
int which_char[200100 + 1];
int suffix_link[200100 + 1];
int immediate_leaf[200100 + 1];
int ind[200100 + 1];
vector<int> occurences[200100 + 1];
string arr[200100 + 1];
int ki[200100 + 1];
void insert(int j) {
int node = 1;
for (int i = 0; i < arr[j].size(); i++) {
int temp = arr[j][i] - 'a';
if (!trie[node][temp]) trie[node][temp] = (++node_cnt);
parent[trie[node][temp]] = node;
which_char[trie[node][temp]] = temp;
node = trie[node][temp];
}
ind[node] = j;
}
int get_suffix_link(int node) {
if (parent[node] == 1) return 1;
if (suffix_link[node]) return suffix_link[node];
int temp = parent[node];
while (true) {
temp = get_suffix_link(temp);
if (trie[temp][which_char[node]]) {
suffix_link[node] = trie[temp][which_char[node]];
break;
}
if (temp == 1) break;
}
if (!suffix_link[node]) suffix_link[node] = 1;
return suffix_link[node];
}
void generate_suffix_links() {
for (int i = 1; i <= node_cnt; i++) {
suffix_link[i] = get_suffix_link(i);
}
}
int go(int v, char c) {
int temp = c - 'a';
if (v == 1) {
if (trie[v][temp]) return trie[v][temp];
return v;
}
if (!memo[v][temp]) {
if (!trie[v][temp])
memo[v][temp] = go(suffix_link[v], c);
else
memo[v][temp] = trie[v][temp];
}
return memo[v][temp];
}
int next_leaf(int node) {
if (node == 1) return node;
if (immediate_leaf[node]) return immediate_leaf[node];
int ret;
if (ind[node])
ret = node;
else
ret = next_leaf(suffix_link[node]);
immediate_leaf[node] = ret;
return ret;
}
void update(int node, int i) {
if (node == 1) return;
if (ind[node]) occurences[ind[node]].push_back(i);
update(next_leaf(suffix_link[node]), i);
}
void aho_corasick(string& s, int n) {
memset(trie, 0, sizeof(trie));
memset(memo, 0, sizeof(memo));
memset(parent, 0, sizeof(parent));
memset(suffix_link, 0, sizeof(suffix_link));
memset(ind, 0, sizeof(ind));
int i, j, k;
for (i = 1; i <= n; i++) occurences[i].clear();
node_cnt = 1;
parent[1] = 1;
for (i = 1; i <= n; i++) insert(i);
generate_suffix_links();
int curr = 1;
for (i = 0; i < s.size(); i++) {
curr = go(curr, s[i]);
update(curr, i);
}
}
int main() {
clock_t begin = clock();
;
string s;
cin >> s;
int i, j, k, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &ki[i]);
cin >> arr[i];
}
aho_corasick(s, n);
for (i = 1; i <= n; i++) {
if ((int)occurences[i].size() < ki[i])
printf("%d\n", -1);
else {
int answer = 1000000100;
for (j = ki[i] - 1; j < occurences[i].size(); j++) {
int rgt = occurences[i][j];
int lft = occurences[i][j - ki[i] + 1] - ((int)arr[i].size());
answer = min(answer, rgt - lft);
}
printf("%d\n", answer);
}
}
clock_t end = clock();
double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
fprintf(stderr, "\nTime elapsed : %.3f seconds\n", elapsed_secs);
return 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int L = 1e5;
const int N = 1e5;
const int S = 'z' + 1 - 'a';
class Trie;
queue<Trie*> q;
class Trie {
public:
Trie* v[S];
Trie* dict;
Trie* fail;
int print;
bool root;
Trie(bool f) {
for (int i = 0; i < S; i++) {
v[i] = NULL;
}
dict = NULL;
fail = NULL;
print = -1;
root = f;
}
void add(int where, char s[], int p) {
if (s[p] == NULL) {
print = where;
return;
}
int c = s[p] - 'a';
if (v[c] == NULL) {
v[c] = new Trie(false);
}
v[c]->add(where, s, p + 1);
}
};
void bfs(Trie* trie) {
q.push(trie);
while (!q.empty()) {
Trie* node = q.front();
q.pop();
for (int i = 0; i < S; i++) {
Trie* son = node->v[i];
if (son != NULL) {
q.push(son);
if (node->root) {
son->fail = node;
continue;
}
Trie* curr = node->fail;
while (!curr->root && curr->v[i] == NULL) {
curr = curr->fail;
}
if (curr->v[i] != NULL) {
son->fail = curr->v[i];
} else {
son->fail = curr;
}
if (son->fail->print >= 0) {
son->dict = son->fail;
} else {
son->dict = son->fail->dict;
}
}
}
}
}
Trie* T = new Trie(true);
int k[N];
char text[L + 1];
int sz[N];
vector<int> pos[N];
char s[L + 1];
int n;
void update(Trie* node, int p) {
if (node->print < 0) {
node = node->dict;
}
while (node != NULL) {
pos[node->print].push_back(p);
node = node->dict;
}
}
void solve() {
Trie* curr = T;
for (int i = 0; text[i]; i++) {
int c = text[i] - 'a';
while (!curr->root && curr->v[c] == NULL) {
curr = curr->fail;
}
if (curr->v[c] != NULL) {
curr = curr->v[c];
update(curr, i);
}
}
}
void init() { freopen("std.in", "r", stdin); }
int main() {
gets(text);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d ", &k[i]);
gets(s);
sz[i] = strlen(s);
T->add(i, s, 0);
}
bfs(T);
solve();
for (int i = 0; i < n; i++) {
int minn = INF;
for (unsigned int j = 0; j + k[i] <= pos[i].size(); j++) {
minn = min(minn, pos[i][j + k[i] - 1] - pos[i][j]);
}
if (pos[i].size() >= k[i]) {
cout << minn + sz[i] << '\n';
} else {
cout << "-1" << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 1e5;
const int INF = 0x7fffffff;
const int mod = 1e9 + 7;
const double eps = 1e-7;
const double Pi = acos(-1.0);
inline int read_int() {
char c;
int ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
inline long long read_ll() {
char c;
long long ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
struct node {
int child[26], fail, cnt, next;
} arr[maxn + 5];
int tot = 0;
inline void insert(char* s, int id) {
int now = 0;
for (int i = 0; s[i]; ++i) {
int id = s[i] - 'a';
if (!arr[now].child[id]) arr[now].child[id] = ++tot;
now = arr[now].child[id];
}
arr[now].cnt = id;
}
inline void build() {
queue<int> q;
for (int i = 0; i < 26; ++i)
if (arr[0].child[i]) arr[arr[0].child[i]].fail = 0, q.push(arr[0].child[i]);
while (!q.empty()) {
int u = q.front();
q.pop();
if (arr[arr[u].fail].cnt)
arr[u].next = arr[u].fail;
else
arr[u].next = arr[arr[u].fail].next;
for (int i = 0; i < 26; ++i) {
if (arr[u].child[i])
arr[arr[u].child[i]].fail = arr[arr[u].fail].child[i],
q.push(arr[u].child[i]);
else
arr[u].child[i] = arr[arr[u].fail].child[i];
}
}
}
int cnt[maxn + 5], num[maxn + 5], len[maxn + 5], n;
char s[maxn + 5], p[maxn + 5];
vector<int> v[maxn + 5];
inline void solve(char* s) {
int now = 0;
for (int i = 0; s[i]; ++i) {
int id = s[i] - 'a';
now = arr[now].child[id];
for (int j = now; j; j = arr[j].next) {
if (arr[j].cnt) {
cnt[arr[j].cnt]++;
v[arr[j].cnt].push_back(i);
}
}
}
}
inline int get_res(int x) {
if (v[x].size() < num[x]) return -1;
int res = INF;
for (int i = 0; i + num[x] - 1 < v[x].size(); ++i)
res = min(res, v[x][i + num[x] - 1] - v[x][i] + len[x]);
return res;
}
int main() {
scanf("%s", s);
n = read_int();
for (int i = 1; i <= n; ++i) {
num[i] = read_int();
scanf("%s", p);
len[i] = strlen(p);
insert(p, i);
}
build();
solve(s);
for (int i = 1; i <= n; ++i) printf("%d\n", get_res(i));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, N;
char S[300007], p[300007];
int End[300007], ans[300007], length[300007], num[300007];
vector<int> Spot[300007];
set<int> mch[300007];
queue<int> q;
struct State {
int next[26];
int fail, cnt;
} Tree[300007];
struct Aho {
int Size;
void init() {
Size = 1;
while (!q.empty()) q.pop();
memset(End, 0, sizeof(End));
for (int i = 0; i < 300007; i++) ans[i] = 1e9;
for (int i = 0; i < 300007; i++) {
memset(Tree[i].next, 0, sizeof(Tree[i].next));
Tree[i].fail = Tree[i].cnt = 0;
}
}
void Add_string(char *S, int id, int tot) {
int L = strlen(S);
length[id] = L;
int now = 0;
for (int i = 0; i < L; i++) {
char c = S[i];
if (!Tree[now].next[c - 'a']) Tree[now].next[c - 'a'] = Size++;
now = Tree[now].next[c - 'a'];
}
Tree[now].cnt++;
End[now] = id;
num[id] = tot;
}
void GetFail() {
int now = 0;
Tree[now].fail = -1;
q.push(now);
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < 26; i++) {
int to = Tree[now].next[i];
if (to) {
if (Tree[to].cnt) mch[to].insert(to);
if (now == 0)
Tree[to].fail = 0;
else {
int pos = Tree[now].fail;
while (pos != -1) {
if (Tree[pos].next[i]) {
Tree[to].fail = Tree[pos].next[i];
for (set<int>::iterator it = mch[Tree[to].fail].begin();
it != mch[Tree[to].fail].end(); it++) {
mch[to].insert(*it);
}
break;
}
pos = Tree[pos].fail;
}
if (pos == -1) Tree[to].fail = 0;
}
q.push(to);
}
}
}
}
void match(char *S) {
int L = strlen(S);
int now = 0;
for (int i = 0; i < L; i++) {
char c = S[i];
if (Tree[now].next[c - 'a'])
now = Tree[now].next[c - 'a'];
else {
int pos = Tree[now].fail;
while (pos != -1 && Tree[pos].next[c - 'a'] == 0) pos = Tree[pos].fail;
if (pos == -1)
now = 0;
else
now = Tree[pos].next[c - 'a'];
}
int temp = now;
for (set<int>::iterator it = mch[now].begin(); it != mch[now].end();
it++) {
int id = End[*it];
Spot[id].push_back(i);
if (Spot[id].size() >= num[id] && num[id] > 0) {
int last = Spot[id].size() - 1;
ans[id] = min(ans[id], Spot[id][last] - Spot[id][last - num[id] + 1] +
length[id]);
}
}
}
for (int i = 1; i <= N; i++) {
if (ans[i] == 1e9)
cout << -1 << endl;
else
cout << ans[i] << endl;
}
}
} aho;
int main() {
std::ios::sync_with_stdio(false);
T = 1;
while (T--) {
aho.init();
cin >> S;
cin >> N;
for (int i = 0; i < N; i++) {
int num;
cin >> num;
cin >> p;
aho.Add_string(p, i + 1, num);
}
aho.GetFail();
aho.match(S);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, l, tot, node_cnt, j, L, k, p[100005], x, fail[100005], ans[100005],
len[100005], U[100005], u, to[100005][26], v1[100005], v2[100005];
char t[100005], s[100005];
queue<int> q;
vector<int> gg[100005];
vector<int> ps[100005];
int cal() {
int i = 2, j = 0, ret = 1e9;
for (; i <= l; ++i) {
while (j && t[i] != t[j + 1]) j = p[j];
if (t[i] == t[j + 1]) ++j;
p[i] = j;
}
tot = j = 0;
for (i = 1; i <= L; ++i) {
while (j && s[i] != t[j + 1]) j = p[j];
if (s[i] == t[j + 1]) ++j;
if (j == l) j = p[j], U[++tot] = i;
}
if (tot < k) return -1;
for (i = k; i <= tot; ++i) {
ret = min(ret, U[i] - U[i - k + 1] + l);
}
return ret;
}
void ins(int pos) {
u = 0;
for (int i = 1; i <= l; ++i) {
t[i] -= 'a';
if (!to[u][t[i]]) to[u][t[i]] = ++node_cnt;
u = to[u][t[i]];
}
v1[u] = pos;
}
int main() {
scanf("%s%d", s + 1, &n);
L = strlen(s + 1);
for (i = 1; i <= n; ++i) {
scanf("%d%s", &k, t + 1);
l = strlen(t + 1);
if (l >= 200) {
ans[i] = cal();
} else {
ins(i);
v2[i] = k;
len[i] = l;
}
}
for (i = 0; i < 26; ++i) {
if (to[0][i]) q.push(to[0][i]);
}
while (q.size()) {
x = q.front();
q.pop();
for (i = 0; i < 26; ++i) {
if (to[x][i])
fail[to[x][i]] = to[fail[x]][i], q.push(to[x][i]);
else
to[x][i] = to[fail[x]][i];
}
}
u = 0;
for (i = 1; i <= L; ++i) {
u = to[u][s[i] - 'a'];
x = u;
while (x) {
if (v1[x]) ps[v1[x]].push_back(i);
x = fail[x];
}
}
for (i = 1; i <= n; ++i) {
if (!ans[i]) {
if (ps[i].size() < v2[i])
ans[i] = -1;
else {
ans[i] = 1e9;
for (j = v2[i] - 1; j < ps[i].size(); ++j) {
ans[i] = min(ans[i], ps[i][j] - ps[i][j - v2[i] + 1] + len[i]);
}
}
}
}
for (i = 1; i <= n; ++i) cout << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
const int maxn = 100000 + 10;
int go[maxn][26], fail[maxn];
int I[maxn], F[maxn], S[maxn], FIN[maxn];
int total;
void push(string &s, int index, int freq) {
int u = 0;
for (auto c : s) {
int x = c - 'a';
if (!go[u][x]) go[u][x] = total++;
u = go[u][x];
}
I[u] = index, F[u] = freq, S[u] = s.length(), FIN[u] = u;
}
void build() {
queue<pair<int, int> > q;
for (int i = 0; i < 26; ++i) {
if (go[0][i]) q.push({go[0][i], 0});
}
while (!q.empty()) {
auto x = q.front();
q.pop();
int u = x.first, f = x.second;
fail[u] = f;
if (!FIN[u]) FIN[u] = FIN[f];
for (int i = 0; i < 26; ++i) {
if (go[u][i])
q.push({go[u][i], go[f][i]});
else
go[u][i] = go[f][i];
}
}
}
int ANSWER[maxn];
queue<int> deq[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
total = 1;
string s;
cin >> s;
int q;
cin >> q;
for (int i = 1; i <= q; ++i) {
int f;
string t;
cin >> f >> t;
push(t, i, f);
}
build();
memset(ANSWER, 0x3f, sizeof ANSWER);
for (int i = 0, u = 0; i < (int)s.length(); ++i) {
u = go[u][s[i] - 'a'];
int v = FIN[u];
while (v) {
int idx = I[v];
deq[idx].push(i);
if (deq[idx].size() > F[v]) deq[idx].pop();
if (deq[idx].size() == F[v]) {
int beg = deq[idx].front();
ANSWER[idx] = min(ANSWER[idx], i - beg + S[v]);
}
v = FIN[fail[v]];
}
}
for (int i = 1; i <= q; ++i) {
if (ANSWER[i] == oo)
cout << -1 << '\n';
else
cout << ANSWER[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long K = 26;
struct Vertex {
long long next[K];
bool terminal = false;
long long terminal_idx = -1, p = -1;
char pch;
long long depth = 0, link = 0;
long long next_terminal = 0;
long long go[K];
Vertex(long long p = -1, char ch = '$', long long depth = 0)
: p(p), pch(ch), depth(depth) {
fill(begin(next), end(next), 0);
fill(begin(go), end(go), 0);
}
};
vector<Vertex> t(1);
void add_string(const string &s, long long idx) {
long long v = 0;
for (char ch : s) {
long long c = ch - 'a';
if (!t[v].next[c]) {
t[v].next[c] = (long long)t.size();
t.emplace_back(v, ch, t[v].depth + 1);
}
v = t[v].next[c];
}
t[v].terminal = true;
t[v].terminal_idx = idx;
}
void push_links() {
queue<long long> q;
q.push(0);
while (!q.empty()) {
long long v = q.front();
q.pop();
auto &cur = t[v];
auto &link = t[cur.link];
cur.next_terminal = link.terminal ? cur.link : link.next_terminal;
for (long long c = 0; c < K; ++c) {
if (cur.next[c]) {
t[cur.next[c]].link = v ? link.next[c] : 0;
q.push(cur.next[c]);
} else {
cur.next[c] = link.next[c];
}
}
}
}
long long transition(long long idx, char c) { return t[idx].next[c - 'a']; }
Vertex const &getInfo(long long idx) { return t[idx]; }
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string s;
cin >> s;
long long n;
cin >> n;
vector<pair<long long, string> > queries(n);
for (long long i = 0; i < n; ++i) {
long long m;
cin >> m;
string si;
cin >> si;
queries[i] = {m, si};
add_string(si, i);
}
push_links();
vector<vector<long long> > occ(n);
long long cur = 0;
for (long long i = 0; i < (long long)s.size(); ++i) {
cur = transition(cur, s[i]);
long long tmp = cur;
while (tmp) {
auto &x = getInfo(tmp);
if (x.terminal) {
occ[x.terminal_idx].push_back(i);
}
tmp = x.next_terminal;
}
}
for (long long i = 0; i < n; ++i) {
auto &[m, si] = queries[i];
auto &o = occ[i];
if (m > (long long)o.size()) {
cout << -1 << '\n';
continue;
}
long long ans = (long long)s.size();
for (long long j = 0; j + m - 1 < (long long)o.size(); ++j) {
ans = min(ans, o[j + m - 1] - o[j] + (long long)si.size());
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxxt;
} e[200006];
struct node {
int k, wh, len;
} b[200006];
char ch[200006], s[200006];
int len[200006], fl[200006], cz[200006][26], js, la, n, Q, head[200006],
cnt = 1, ans[200006], ls[200006 * 18], rs[200006 * 18], he[200006 * 18],
rt[200006], tot;
int oc[200006], tt;
bool vis[200006];
vector<int> v[200006];
inline void ins(int u, int v) {
e[cnt].to = v;
e[cnt].nxxt = head[u];
head[u] = cnt++;
}
inline void ada(char c) {
int p = la, cur = ++js;
len[cur] = len[p] + 1;
vis[cur] = 1;
while ((~p) && !cz[p][c - 'a']) cz[p][c - 'a'] = cur, p = fl[p];
if (p != -1) {
int q = cz[p][c - 'a'];
if (len[q] == len[p] + 1)
fl[cur] = q;
else {
int cl = ++js;
len[cl] = len[p] + 1;
fl[cl] = fl[q];
for (int i = 0; i < 26; i++) cz[cl][i] = cz[q][i];
while ((~p) && cz[p][c - 'a'] == q) cz[p][c - 'a'] = cl, p = fl[p];
fl[cur] = fl[q] = cl;
}
}
la = cur;
}
int cmp(int x, int y) { return b[x].k < b[y].k; }
void chng(int &o, int l, int r, int x) {
if (!o) o = ++tot;
he[o]++;
if (l == r) return;
int mid = (l + r) >> 1;
if (x <= mid)
chng(ls[o], l, mid, x);
else
chng(rs[o], mid + 1, r, x);
}
void merge(int &o, int u, int v) {
if ((!u) || (!v)) {
o = u | v;
return;
}
o = u;
he[o] += he[v];
merge(ls[o], ls[u], ls[v]);
merge(rs[o], rs[u], rs[v]);
}
void loc(int ind, int l, int r) {
if (l == r) {
oc[++tt] = l;
return;
}
int mid = (l + r) >> 1;
if (he[ls[ind]]) loc(ls[ind], l, mid);
if (he[rs[ind]]) loc(rs[ind], mid + 1, r);
}
void dfs(int te) {
if (te && vis[te]) chng(rt[te], 1, n, len[te]);
for (int i = head[te]; i; i = e[i].nxxt) {
int j = e[i].to;
dfs(j);
merge(rt[te], rt[te], rt[j]);
}
if (v[te].size()) {
tt = 0;
loc(rt[te], 1, n);
for (int i = 0; i < v[te].size(); i++) {
int x = v[te][i];
if (b[x].k > tt)
ans[b[x].wh] = -1;
else {
ans[b[x].wh] = 1e9;
for (int j = b[x].k; j <= tt; j++)
ans[b[x].wh] =
min(ans[b[x].wh], oc[j] - oc[j - b[x].k + 1] + b[x].len);
}
}
}
}
int main() {
scanf("%s", ch + 1);
fl[0] = -1;
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) ada(ch[i]);
for (int i = 1; i <= js; i++) ins(fl[i], i);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d%s", &b[i].k, s + 1);
b[i].wh = i;
int tle = strlen(s + 1), pos = 0;
bool flag = true;
b[i].len = tle;
for (int j = 1; j <= tle; j++) {
if (!cz[pos][s[j] - 'a']) {
flag = false;
break;
}
pos = cz[pos][s[j] - 'a'];
}
if (!flag) {
ans[i] = -1;
continue;
}
v[pos].push_back(i);
}
for (int i = 1; i <= js; i++) sort(v[i].begin(), v[i].end(), cmp);
dfs(0);
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int ms = int(1e5) + 10;
vector<int> occur[ms];
int ans[ms], cnt[ms];
string m[ms];
template <const int ALPHA = 26, class T = std::string, const int off = 'a'>
struct Aho {
struct Node {
int to[ALPHA];
int size;
int fail, pfail;
int present;
Node() {
for (int i = 0; i < ALPHA; i++) {
to[i] = 0;
}
size = 0;
pfail = fail = 0;
present = 0;
}
};
Aho() { nodes.push_back(Node()); }
int addString(const T &str, int idx) {
int on = 0;
for (auto ch : str) {
if (nodes[on].to[ch - off] == 0) {
nodes[on].to[ch - off] = (int)nodes.size();
nodes.push_back(Node());
nodes.back().size = 1 + nodes[on].size;
}
on = nodes[on].to[ch - off];
}
nodes[on].present = idx;
return on;
}
void build() {
std::queue<int> que;
que.push(0);
while (!que.empty()) {
int on = que.front();
que.pop();
nodes[on].pfail = nodes[nodes[on].fail].present
? nodes[on].fail
: nodes[nodes[on].fail].pfail;
for (int i = 0; i < ALPHA; i++) {
int &to = nodes[on].to[i];
if (to) {
nodes[to].fail = on == 0 ? 0 : nodes[nodes[on].fail].to[i];
que.push(to);
} else {
to = nodes[nodes[on].fail].to[i];
}
}
}
}
void search(string &s) {
int at = 0, n = s.size();
for (int i = 0; i < n; i++) {
if (nodes[at].to[s[i] - off] == 0) {
at = nodes[at].fail;
} else {
at = nodes[at].to[s[i] - off];
}
int temp = at;
if (!nodes[temp].present) temp = nodes[temp].pfail;
while (temp != 0) {
int idx = nodes[temp].present;
occur[idx].push_back(i - m[idx].size() + 1);
if (occur[idx].size() >= cnt[idx]) {
ans[idx] =
min(ans[idx], i - occur[idx][occur[idx].size() - cnt[idx]] + 1);
}
temp = nodes[temp].pfail;
}
}
}
std::vector<Node> nodes;
};
int main() {
ios::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
int t;
cin >> t;
Aho<> aut;
for (int i = 1; i <= t; i++) {
cin >> cnt[i] >> m[i];
aut.addString(m[i], i);
}
aut.build();
memset(ans, 0x3f, sizeof ans);
aut.search(s);
for (int i = 1; i <= t; i++) cout << (ans[i] > 1e9 ? -1 : ans[i]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k[100010], m, ans[100010], l[100010];
int kmp[100010], pos[100010];
int ch[100010][26], cn = 1, id[100010], fail[100010];
queue<int> q;
vector<int> g[100010];
char s[100010], c[100010];
void build() {
for (int i = 0; i < 26; i++)
if (!ch[1][i])
ch[1][i] = 1;
else
fail[ch[1][i]] = 1, q.push(ch[1][i]);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 26; i++)
if (!ch[u][i])
ch[u][i] = ch[fail[u]][i];
else
fail[ch[u][i]] = ch[fail[u]][i], q.push(ch[u][i]);
}
}
int main() {
scanf("%s%d", s + 1, &n);
m = strlen(s + 1);
for (int p = 1; p <= n; p++) {
ans[p] = 1e9 + 7;
scanf("%d%s", &k[p], c + 1);
l[p] = strlen(c + 1);
if (l[p] > 340) {
kmp[1] = 0;
for (int i = 2, j = 0; i <= l[p]; i++) {
while (j && c[j + 1] != c[i]) j = kmp[j];
if (c[j + 1] == c[i]) j++;
kmp[i] = j;
}
int ss = 0;
for (int i = 1, j = 0; i <= m; i++) {
while (j && c[j + 1] != s[i]) j = kmp[j];
if (c[j + 1] == s[i]) j++;
if (j == l[p]) {
pos[++ss] = i;
if (ss >= k[p])
ans[p] = min(ans[p], pos[ss] - pos[ss - k[p] + 1] + l[p]);
j = kmp[j];
}
}
} else {
int u = 1;
for (int i = 1; i <= l[p]; i++) {
if (!ch[u][c[i] - 'a']) ch[u][c[i] - 'a'] = ++cn;
u = ch[u][c[i] - 'a'];
}
id[u] = p;
}
}
build();
int u = 1;
for (int i = 1; i <= m; i++) {
u = ch[u][s[i] - 'a'];
int er = u;
while (er != 1) {
if (id[er]) g[id[er]].push_back(i);
er = fail[er];
}
}
for (int i = 1; i <= n; i++) {
int sz = g[i].size();
for (int j = 0; j < sz; j++)
if (j >= k[i] - 1)
ans[i] = min(g[i][j] - g[i][j - k[i] + 1] + l[i], ans[i]);
}
for (int i = 1; i <= n; i++) printf("%d\n", (ans[i] > 1e9) ? -1 : ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = N << 1;
const int S = 28;
char s[N], t[N];
int n, k[N], len[N], lent;
bool used[N];
vector<int> pos[N];
int cnt = 0;
struct node {
int son[S];
int fail, id;
inline void rootclear(int root) {
fail = root;
id = 0;
memset(son, 0, sizeof(son));
}
} AC[M];
void insert(char *s, int id) {
int now = len[id], root = len[id];
for (int i = 0; i < len[id]; i++) {
int c = s[i] - 'a' + 1;
if (AC[now].son[c] == 0) {
AC[now].son[c] = ++cnt;
AC[cnt].rootclear(root);
}
now = AC[now].son[c];
}
AC[now].id = id;
}
queue<int> team;
void BuildAC(int root) {
for (int i = 1; i <= 26; i++)
if (AC[root].son[i]) {
AC[AC[root].son[i]].fail = root;
team.push(AC[root].son[i]);
} else
AC[root].son[i] = root;
while (!team.empty()) {
int now = team.front();
team.pop();
int fail = AC[now].fail;
for (int i = 1; i <= 26; i++) {
int tmp = AC[now].son[i];
if (tmp) {
AC[tmp].fail = AC[fail].son[i];
team.push(tmp);
} else
AC[now].son[i] = AC[fail].son[i];
}
}
}
void match(int root, char *s, int len) {
int now = root;
for (int i = 0; i < len; i++) {
int c = s[i] - 'a' + 1;
now = AC[now].son[c];
if (AC[now].id) pos[AC[now].id].push_back(i);
}
}
int main() {
scanf("%s", t);
scanf("%d", &n);
lent = strlen(t);
for (int i = 1; i <= lent; i++) {
cnt++;
AC[cnt].rootclear(cnt);
}
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++) {
scanf("%d", &k[i]);
scanf("%s", s);
len[i] = strlen(s);
insert(s, i);
used[len[i]] = 1;
}
for (int i = 1; i <= lent; i++)
if (used[i]) {
BuildAC(i);
match(i, t, lent);
}
for (int i = 1; i <= n; i++) {
if (pos[i].size() < k[i])
printf("%d\n", -1);
else {
int ans = lent;
for (int j = 0; j <= pos[i].size() - k[i]; j++)
ans = min(ans, pos[i][j + k[i] - 1] - pos[i][j] + len[i]);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
putchar(' ');
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
template <typename R, typename D>
inline void Min(R &a, D b) {
if (a > b) a = b;
}
template <typename D, typename R>
inline void Max(D &a, R b) {
if (a < b) a = b;
}
const int N = 100005, C = 26;
int k, top, bot, o[N], id[N];
string t[N];
vector<int> ve[N];
struct Trie {
int last;
Trie *link;
Trie *child[C];
Trie() {
last = 0;
for (int i = 0; i < C; ++i) child[i] = NULL;
link = NULL;
}
} trie;
Trie *q[N];
void Reset() {
Trie *p = ≜
for (int i = 0; i < 26; ++i) {
p->child[i] = NULL;
}
top = bot = 1;
}
void Add(string s, int id) {
Trie *p = ≜
for (int i = 0; i < s.size(); ++i) {
int tmp = s[i] - 'a';
if (p->child[tmp] == NULL) p->child[tmp] = new Trie();
p = p->child[tmp];
}
p->last = id;
}
void Aho() {
while (bot <= top) {
Trie *u = q[bot++], *v;
for (int p = 0; p < C; ++p) {
v = u->child[p];
if (v == NULL) continue;
Trie *nl = u->link;
for (;;) {
if (nl == NULL) break;
if (nl->child[p] != NULL) {
nl = nl->child[p];
break;
}
nl = nl->link;
}
if (nl == NULL) nl = ≜
v->link = nl;
q[++top] = v;
}
}
}
void Find(string s) {
Trie *p = ≜
for (int i = 0; i < s.size(); ++i) {
int tmp = s[i] - 'a';
for (;;) {
if (p->child[tmp] != NULL) {
p = p->child[tmp];
break;
}
p = p->link;
if (p == NULL) {
p = ≜
break;
}
}
if (p->last) ve[p->last].push_back(i);
}
}
int Handle(int i) {
if (ve[i].size() < o[i]) return -1;
int res = 2e9;
for (int j = o[i] - 1; j < ve[i].size(); ++j) {
Min(res, ve[i][j] - ve[i][j - o[i] + 1]);
}
return res + t[i].size();
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
cin >> k;
for (int i = 1; i <= k; ++i) {
cin >> o[i] >> t[i];
id[i] = i;
}
sort(id + 1, id + 1 + k,
[&](int x, int y) { return t[x].size() < t[y].size(); });
q[top = 1] = ≜
int run = 1;
while (run <= k) {
int tr = t[id[run]].size();
Reset();
while (t[id[run]].size() == tr) {
Add(t[id[run]], id[run]);
++run;
}
Aho();
Find(s);
}
for (int i = 1; i <= k; ++i) {
cout << Handle(i) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxnode = 1e5 + 10, z = 26, inf = 1e9 + 10;
vector<int> ocr[maxn];
char s[maxn], t[maxn];
int n, m, ted[maxn], sz[maxn], ans[maxn];
struct Trie {
int to[maxnode][z], last = 1, val[maxnode], f[maxnode], Q[maxnode],
par[maxnode];
void add(int ii, char s[maxn], int size) {
int id = 0;
for (int i = 0; i < size; i++) {
if (to[id][s[i] - 'a'] == 0) {
to[id][s[i] - 'a'] = last++;
}
id = to[id][s[i] - 'a'];
}
val[id] = ii + 1;
}
void bfs() {
int l = 0, r = 0;
Q[r++] = 0;
while (l < r) {
int a = Q[l++];
if (val[a] > 0) {
if (val[f[a]] == 0) {
par[a] = 0;
} else {
par[a] = f[a];
}
} else {
val[a] = val[f[a]];
par[a] = par[f[a]];
}
for (int i = 0; i < z; i++) {
if (to[a][i] == 0) {
to[a][i] = to[f[a]][i];
} else {
f[to[a][i]] = (a > 0) ? to[f[a]][i] : 0;
Q[r++] = to[a][i];
}
}
}
}
void solve() {
int id = 0;
for (int i = 0; i < m; i++) {
id = to[id][s[i] - 'a'];
int ii = id;
while (val[ii] > 0) {
ocr[val[ii] - 1].push_back(i);
ii = par[ii];
}
}
for (int i = 0; i < n; i++) {
for (int j = ted[i] - 1; j < int(ocr[i].size()); j++) {
if (ans[i] == -1 ||
ans[i] > ocr[i][j] - ocr[i][j - ted[i] + 1] + sz[i]) {
ans[i] = ocr[i][j] - ocr[i][j - ted[i] + 1] + sz[i];
}
}
}
}
} trie;
int32_t main() {
memset(ans, -1, sizeof ans);
scanf("%s%d", s, &n);
m = strlen(s);
for (int i = 0; i < n; i++) {
scanf("%d%s", ted + i, t);
sz[i] = strlen(t);
trie.add(i, t, sz[i]);
}
trie.bfs();
trie.solve();
for (int i = 0; i < n; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
node* nxt[26];
int terminal = 0;
int terminal_idx = -1;
node* link = NULL;
node* nxt_terminal = NULL;
node* p;
char p_ch;
node(node* pr, char ch) : p(pr), p_ch(ch) {
for (int i = 0; i < 26; i++) nxt[i] = NULL;
}
};
node* root;
void add_word(vector<string> words) {
for (int i = 0; i < words.size(); i++) {
string word = words[i];
node* cur = root;
for (auto ch : word) {
if (cur->nxt[ch - 'a'] == NULL) cur->nxt[ch - 'a'] = new node(cur, ch);
cur = cur->nxt[ch - 'a'];
}
cur->terminal = 1;
cur->terminal_idx = i;
}
}
void push_links() {
queue<node*> q;
node* c = (root);
q.push(c);
while (!q.empty()) {
node* cur = q.front();
node* slink = cur->link;
assert(cur->link == slink);
q.pop();
if (slink->terminal) {
cur->nxt_terminal = slink;
} else
cur->nxt_terminal = slink->nxt_terminal;
for (int c = 0; c < 26; c++) {
if (cur->nxt[c]) {
if (cur != root) {
(cur->nxt[c])->link = (cur->link)->nxt[c];
} else
(cur->nxt[c])->link = root;
q.push(cur->nxt[c]);
} else {
if (cur != root)
cur->nxt[c] = (cur->link)->nxt[c];
else
cur->nxt[c] = root;
}
}
}
}
int main() {
root = new node(NULL, '$');
root->link = root;
string s;
cin >> s;
int n;
cin >> n;
vector<string> vec(n);
vector<int> k(n);
vector<vector<int>> ans(n);
for (int i = 0; i < n; i++) {
cin >> k[i] >> vec[i];
}
add_word(vec);
push_links();
node* cur = root;
for (int i = 0; i < s.length(); i++) {
cur = cur->nxt[s[i] - 'a'];
if (cur->terminal) {
ans[cur->terminal_idx].push_back(i);
}
node* c = cur;
while (c->nxt_terminal) {
c = c->nxt_terminal;
ans[c->terminal_idx].push_back(i);
}
}
for (int i = 0; i < n; i++) {
int mi = 1e6;
for (int j = 0; j + k[i] - 1 < ans[i].size(); j++) {
mi = min(mi, ans[i][j + k[i] - 1] - ans[i][j] + (int)vec[i].length());
}
if (mi == 1e6)
cout << "-1\n";
else
cout << mi << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100002, C = 28;
int n, m, k[N], nodeId;
char str[N], temp[N];
string a[N];
int getVal(char ch) { return ch - 'a'; }
struct node {
node* fail;
node* childs[C];
vector<int> patIds;
vector<char> chars;
long long id;
node() {
id = ++nodeId;
memset(childs, 0, sizeof childs);
}
void insert(const char* str, int id) {
if (!(*str)) {
patIds.push_back(id);
return;
}
if (!childs[getVal(*str)])
childs[getVal(*str)] = new node(), chars.push_back(*str);
childs[getVal(*str)]->insert(str + 1, id);
}
};
void fail(node*& k, char ch) {
while (!k->childs[getVal(ch)]) k = k->fail;
k = k->childs[getVal(ch)];
}
node* buildAhoTree(string pat[], int n) {
node* root = new node();
for (int(i) = (1); (i) <= (int)(n); (i)++) root->insert(pat[i].c_str(), i);
queue<node*> Q;
for (int(i) = (0); (i) <= (int)(C - 1); (i)++)
if (root->childs[i])
Q.push(root->childs[i]), root->childs[i]->fail = root;
else
root->childs[i] = root;
while (!Q.empty()) {
node* cur = Q.front();
Q.pop();
for (char ch : cur->chars) {
Q.push(cur->childs[getVal(ch)]);
node* k = cur->fail;
fail(k, ch);
cur->childs[getVal(ch)]->fail = k;
cur->childs[getVal(ch)]->patIds.insert(
cur->childs[getVal(ch)]->patIds.end(), k->patIds.begin(),
k->patIds.end());
}
}
return root;
}
vector<int> idx[N];
void match(char* str, node* root) {
node* k = root;
for (int i = 0; str[i]; i++) {
fail(k, str[i]);
for (int j : k->patIds) idx[j].push_back(i);
}
}
int main() {
scanf("%s%d", str, &m);
n = (int)strlen(str);
for (int(i) = (1); (i) <= (int)(m); (i)++)
scanf("%d%s", &k[i], temp), a[i] = string(temp);
node* root = buildAhoTree(a, m);
match(str, root);
for (int(i) = (1); (i) <= (int)(m); (i)++) {
if (k[i] > (int)(idx[i]).size())
printf("-1\n");
else {
int ans = n;
for (int(j) = (k[i] - 1); (j) <= (int)((int)(idx[i]).size() - 1); (j)++)
ans = min(ans, idx[i][j] - idx[i][j - k[i] + 1] + (int)(a[i]).size());
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool leq(int a1, int a2, int b1, int b2) {
return a1 < b1 || (a1 == b1 && a2 <= b2);
}
inline bool leq(int a1, int a2, int a3, int b1, int b2, int b3) {
return a1 < b1 || (a1 == b1 && leq(a2, a3, b2, b3));
}
inline void radixPass(int* a, int* b, int* r, int n, int K) {
int* c = new int[K + 1];
for (int i = 0; i <= K; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[r[a[i]]]++;
for (int i = 0, sum = 0; i <= K; i++) {
int t = c[i];
c[i] = sum;
sum += t;
}
for (int i = 0; i < n; i++) b[c[r[a[i]]]++] = a[i];
delete[] c;
}
void suffixArray(int* T, int* SA, int n, int K) {
int n0 = (n + 2) / 3, n1 = (n + 1) / 3, n2 = n / 3, n02 = n0 + n2;
int* R = new int[n02 + 3];
R[n02] = R[n02 + 1] = R[n02 + 2] = 0;
int* SA12 = new int[n02 + 3];
SA12[n02] = SA12[n02 + 1] = SA12[n02 + 2] = 0;
int* R0 = new int[n0];
int* SA0 = new int[n0];
for (int i = 0, j = 0; i < n + (n0 - n1); i++)
if (i % 3 != 0) R[j++] = i;
radixPass(R, SA12, T + 2, n02, K);
radixPass(SA12, R, T + 1, n02, K);
radixPass(R, SA12, T, n02, K);
int name = 0, c0 = -1, c1 = -1, c2 = -1;
for (int i = 0; i < n02; i++) {
if (T[SA12[i]] != c0 || T[SA12[i] + 1] != c1 || T[SA12[i] + 2] != c2) {
name++;
c0 = T[SA12[i]];
c1 = T[SA12[i] + 1];
c2 = T[SA12[i] + 2];
}
if (SA12[i] % 3 == 1)
R[SA12[i] / 3] = name;
else
R[SA12[i] / 3 + n0] = name;
}
if (name < n02) {
suffixArray(R, SA12, n02, name);
for (int i = 0; i < n02; i++) R[SA12[i]] = i + 1;
} else {
for (int i = 0; i < n02; i++) SA12[R[i] - 1] = i;
}
for (int i = 0, j = 0; i < n02; i++)
if (SA12[i] < n0) R0[j++] = 3 * SA12[i];
radixPass(R0, SA0, T, n0, K);
for (int p = 0, t = n0 - n1, k = 0; k < n; k++) {
int i = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
int j = SA0[p];
if (SA12[t] < n0 ? leq(T[i], R[SA12[t] + n0], T[j], R[j / 3])
: leq(T[i], T[i + 1], R[SA12[t] - n0 + 1], T[j], T[j + 1],
R[j / 3 + n0])) {
SA[k] = i;
t++;
if (t == n02) {
for (k++; p < n0; p++, k++) SA[k] = SA0[p];
}
} else {
SA[k] = j;
p++;
if (p == n0) {
for (k++; t < n02; t++, k++)
SA[k] = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
}
}
}
delete[] R;
delete[] SA12;
delete[] SA0;
delete[] R0;
}
const int MOD1 = 1000000007;
const int MOD2 = 1000000009;
const int BASE = 447;
int n, m;
int str[100005];
int sa[100005];
pair<int, int> hs[100005];
pair<int, int> hq[100005];
pair<int, int> pw[100005];
int tmp[100005];
string s, q;
pair<int, int> hes(int l, int r, pair<int, int>* h) {
int h0 = h[r].first - h[l].first * 1ll * pw[r - l].first % MOD1;
int h1 = h[r].second - h[l].second * 1ll * pw[r - l].second % MOD2;
if (h0 < 0) h0 += MOD1;
if (h1 < 0) h1 += MOD2;
return {h0, h1};
}
int lcp(pair<int, int>* h1, pair<int, int>* h2, int hi) {
int l = 1, r = hi, o = 0;
while (l <= r) {
int m = (l + r) >> 1;
if (hes(0, m, h1) == hes(0, m, h2)) {
o = m;
l = m + 1;
} else {
r = m - 1;
}
}
return o;
}
bool cmp(int x, int y) {
if (y == -1) {
x = max(x, y);
int l = lcp(hq, hs + x, min(m, n - x));
if (l == m)
return false;
else
return q[l] > s[x + l];
} else {
x = max(x, y);
int l = lcp(hq, hs + x, min(m, n - x));
if (l == m)
return false;
else
return q[l] < s[x + l];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
pw[0] = {1, 1};
for (int i = 1; i < 100005; i++) {
pw[i].first = pw[i - 1].first * 1ll * BASE % MOD1;
pw[i].second = pw[i - 1].second * 1ll * BASE % MOD2;
}
cin >> s;
n = s.size();
s += '.';
for (int i = 0; i < n; i++) {
str[i] = s[i] - 'a' + 1;
hs[i + 1] = {(hs[i].first * 1ll * BASE + s[i]) % MOD1,
(hs[i].second * 1ll * BASE + s[i]) % MOD2};
}
suffixArray(str, sa, n, 29);
int qq;
cin >> qq;
while (qq--) {
int k;
cin >> k >> q;
k--;
m = q.size();
for (int j = 0; j < m; j++) {
hq[j + 1] = {(hq[j].first * 1ll * BASE + q[j]) % MOD1,
(hq[j].second * 1ll * BASE + q[j]) % MOD2};
}
int lo = lower_bound(sa, sa + n, -1, cmp) - sa;
int hi = upper_bound(sa, sa + n, -1, cmp) - sa;
int z = hi - lo;
copy(sa + lo, sa + hi, tmp);
sort(tmp, tmp + z);
int sol = 1123123123;
for (int i = k; i < z; i++) {
sol = min(sol, tmp[i] - tmp[i - k] + m);
}
if (sol == 1123123123) sol = -1;
cout << sol << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct tn {
tn *c[26], *f, *s;
unsigned long long l, id;
};
template <size_t S>
struct pool_t {
tn* p;
unsigned long long s;
pool_t() {
p = (tn*)malloc(S * sizeof(tn));
s = 0;
}
tn* get(const tn& w) {
tn* np = p + (s++);
*np = w;
return np;
}
~pool_t() { free(p); }
};
pool_t<100000> pool;
struct aca_t {
tn* r;
aca_t() : r(0) {}
tn* get() { return pool.get({{0}, r, 0, 0, 0}); }
void build(const vector<string>& sv) {
r = get();
for (int i = 0; i != sv.size(); ++i) {
tn* p = r;
for (const char& ch : sv[i]) {
int o = ch - 'a';
if (!p->c[o]) p->c[o] = get();
p = p->c[o];
}
p->id = i + 1;
}
queue<tn*> q;
q.push(r);
while (q.size()) {
tn* u = q.front();
q.pop();
for (int o = 0; o != 26; ++o) {
tn *&v = u->c[o], *f = u == r ? r : u->f->c[o];
if (v) {
v->f = f;
v->s = v->f->id ? v->f : v->f->s;
q.push(v);
} else
v = f;
}
}
}
void match(string t, vector<vector<int>>& res) {
tn* p = r;
for (int i = 0; i != t.size(); ++i) {
p = p->c[t[i] - 'a'];
for (tn* w = p; w; w = w->s)
if (w->id) res[w->id - 1].push_back(i);
}
}
};
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
aca_t aca;
string t;
cin >> t;
int n;
cin >> n;
vector<vector<int>> res;
res.resize(n);
vector<int> kv;
vector<string> sv;
for (int i = 0; i != n; ++i) {
int k;
string s;
cin >> k >> s;
kv.push_back(k);
sv.push_back(s);
}
aca.build(sv);
aca.match(t, res);
vector<int> ans;
for (int i = 0; i != n; ++i) {
int k = kv[i];
if (res[i].size() < k)
ans.push_back(-1);
else {
int d = ~(1 << 31);
for (int j = 0; j != res[i].size(); ++j)
if (j >= k - 1) d = min(d, res[i][j] - res[i][j - k + 1]);
ans.push_back(d + sv[i].size());
}
}
for (int d : ans) cout << d << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1000000;
using namespace std;
string s;
int n;
struct node {
int l, r, par, link;
map<char, int> next;
node(int l = 0, int r = 0, int par = -1) : l(l), r(r), par(par), link(-1) {}
int len() { return r - l; }
int& get(char c) {
if (!next.count(c)) next[c] = -1;
return next[c];
}
};
node t[MAXN];
int sz;
struct state {
int v, pos;
state(int v, int pos) : v(v), pos(pos) {}
};
state ptr(0, 0);
state go(state st, int l, int r) {
while (l < r)
if (st.pos == t[st.v].len()) {
st = state(t[st.v].get(s[l]), 0);
if (st.v == -1) return st;
} else {
if (s[t[st.v].l + st.pos] != s[l]) return state(-1, -1);
if (r - l < t[st.v].len() - st.pos) return state(st.v, st.pos + r - l);
l += t[st.v].len() - st.pos;
st.pos = t[st.v].len();
}
return st;
}
int split(state st) {
if (st.pos == t[st.v].len()) return st.v;
if (st.pos == 0) return t[st.v].par;
node v = t[st.v];
int id = sz++;
t[id] = node(v.l, v.l + st.pos, v.par);
t[v.par].get(s[v.l]) = id;
t[id].get(s[v.l + st.pos]) = st.v;
t[st.v].par = id;
t[st.v].l += st.pos;
return id;
}
int get_link(int v) {
if (t[v].link != -1) return t[v].link;
if (t[v].par == -1) return 0;
int to = get_link(t[v].par);
return t[v].link = split(
go(state(to, t[to].len()), t[v].l + (t[v].par == 0), t[v].r));
}
void tree_extend(int pos) {
for (;;) {
state nptr = go(ptr, pos, pos + 1);
if (nptr.v != -1) {
ptr = nptr;
return;
}
int mid = split(ptr);
int leaf = sz++;
t[leaf] = node(pos, n, mid);
t[mid].get(s[pos]) = leaf;
ptr.v = get_link(mid);
ptr.pos = t[ptr.v].len();
if (!mid) break;
}
}
void build_tree() {
sz = 1;
for (int i = 0; i < n; ++i) tree_extend(i);
}
struct LeavesInfo {
size_t start_index;
size_t finish_index;
size_t depth;
};
void UpdateLeavesInfoRecursive(std::vector<int>& leaves,
std::vector<LeavesInfo>& leaves_info,
const int current_node, const size_t depth) {
if (t[current_node].next.size() == 0) {
leaves.push_back(current_node);
leaves_info[current_node] = {leaves.size() - 1, leaves.size(), depth};
return;
}
size_t start_index = std::numeric_limits<size_t>::max();
size_t finish_index = 0;
for (auto& letter_and_child : t[current_node].next) {
auto child = letter_and_child.second;
UpdateLeavesInfoRecursive(leaves, leaves_info, child,
depth + t[child].r - t[child].l);
start_index = std::min(start_index, leaves_info[child].start_index);
finish_index = std::max(finish_index, leaves_info[child].finish_index);
}
leaves_info[current_node] = {start_index, finish_index, depth};
}
std::tuple<std::vector<int>, std::vector<LeavesInfo>>
GetVectorOfLeavesAndInfos() {
std::vector<int> leaves;
std::vector<LeavesInfo> leaves_info(sz);
UpdateLeavesInfoRecursive(leaves, leaves_info, 0, 0);
return {leaves, leaves_info};
}
int main() {
std::ios::sync_with_stdio(false);
std::cin >> s;
s += '$';
n = static_cast<int>(s.size());
build_tree();
std::vector<LeavesInfo> leaves_info;
std::vector<int> leaves;
std::tie(leaves, leaves_info) = GetVectorOfLeavesAndInfos();
int count_of_operations;
std::cin >> count_of_operations;
for (int operation = 0; operation < count_of_operations; ++operation) {
int number;
std::string substring;
std::cin >> number >> substring;
int current_node = 0;
size_t scanned = 0;
while (scanned < substring.size()) {
char next_symbol = substring[scanned];
if (t[current_node].next.count(next_symbol) == 0) {
break;
} else {
current_node = t[current_node].next[next_symbol];
bool went_wrong = false;
for (int i = t[current_node].l;
i < t[current_node].r && scanned < substring.size(); ++i) {
if (s[i] == substring[scanned]) {
++scanned;
} else {
went_wrong = true;
break;
}
}
if (went_wrong) {
break;
}
}
}
if (scanned == substring.size()) {
auto& cur_leaves_info = leaves_info[current_node];
std::vector<int> depths;
for (size_t i = cur_leaves_info.start_index;
i < cur_leaves_info.finish_index; ++i) {
depths.push_back(leaves_info[leaves[i]].depth);
}
std::sort(depths.begin(), depths.end());
auto last = std::unique(depths.begin(), depths.end());
depths.erase(last, depths.end());
if (depths.size() < static_cast<size_t>(number)) {
std::cout << -1 << std::endl;
} else {
auto first_it = depths.begin();
auto second_it = depths.begin();
int min_distance = std::numeric_limits<int>::max();
for (int i = 0; i + 1 < number; ++i) {
++second_it;
}
while (second_it != depths.end()) {
min_distance =
std::min(min_distance, *second_it++ - *first_it++ +
static_cast<int>(substring.size()));
}
std::cout << min_distance << std::endl;
}
} else {
std::cout << -1 << std::endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct vertex {
map<char, int> next, go;
int p, link, leafLink;
char pch;
vector<int> leaf;
vertex(int p = -1, char pch = -1) : p(p), pch(pch), link(-1), leafLink(-1) {}
};
vector<vertex> t;
void aho_init() {
t.clear();
t.push_back(vertex());
}
void add_string(string s, int id) {
int v = 0;
for (char c : s) {
if (!t[v].next.count(c)) {
t[v].next[c] = t.size();
t.push_back(vertex(v, c));
}
v = t[v].next[c];
}
t[v].leaf.push_back(id);
}
int go(int v, char c);
int get_link(int v) {
if (t[v].link < 0)
if (!v || !t[v].p)
t[v].link = 0;
else
t[v].link = go(get_link(t[v].p), t[v].pch);
return t[v].link;
}
int get_leafLink(int v) {
if (t[v].leafLink < 0) {
if (!v || !t[v].p) {
t[v].leafLink = 0;
} else {
if (t[get_link(v)].leaf.size() > 0) {
t[v].leafLink = get_link(v);
} else {
t[v].leafLink = get_leafLink(get_link(v));
}
}
}
return t[v].leafLink;
}
int go(int v, char c) {
if (!t[v].go.count(c))
if (t[v].next.count(c))
t[v].go[c] = t[v].next[c];
else
t[v].go[c] = v == 0 ? 0 : go(get_link(v), c);
return t[v].go[c];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n;
cin >> n;
vector<pair<int, int> > queries;
aho_init();
for (int i = 0, colchin = n; i < colchin; ++i) {
string m;
int k;
cin >> k >> m;
queries.push_back(pair<int, int>(k, m.size()));
add_string(m, i);
}
int curr = 0;
vector<int> positions[n + 5];
for (int i = 0, colchin = s.size(); i < colchin; ++i) {
curr = go(curr, s[i]);
int currLeaf = curr;
while (currLeaf != 0) {
for (int id : t[currLeaf].leaf) {
positions[id].push_back(i);
}
currLeaf = get_leafLink(currLeaf);
}
}
for (int i = 0, colchin = n; i < colchin; ++i) {
if (positions[i].size() >= queries[i].first) {
int k = queries[i].first;
int minimum = 1e9;
for (int j = 0, colchin = positions[i].size() - k + 1; j < colchin; ++j) {
minimum = min(minimum, positions[i][j + k - 1] - positions[i][j]);
}
cout << minimum + queries[i].second << "\n";
} else {
cout << "-1\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
const int LEN = 200005;
vector<int> g[LEN];
int in[LEN], out[LEN];
int arr[LEN];
struct SA {
struct state {
int len, link;
map<char, int> next;
};
state st[LEN];
int sz, last;
int cnt[LEN];
bitset<LEN> vis;
void SA_make() {
sz = 0;
st[0].len = 0, st[0].link = -1;
++sz;
last = 0;
}
SA() { SA_make(); }
void add(char c) {
int new_n = sz++;
st[new_n].len = st[last].len + 1;
int pt = last;
while (pt != -1 && !st[pt].next.count(c)) {
st[pt].next[c] = new_n;
pt = st[pt].link;
}
if (pt == -1) {
st[new_n].link = 0;
} else {
int q_st = st[pt].next[c];
if (st[q_st].len == st[pt].len + 1)
st[new_n].link = q_st;
else {
int clone = sz++;
st[clone] = st[q_st];
st[clone].len = st[pt].len + 1;
st[q_st].link = st[new_n].link = clone;
while (pt != -1 && st[pt].next[c] == q_st) {
st[pt].next[c] = clone;
pt = st[pt].link;
}
}
}
last = new_n;
}
int minlen(int u) {
if (u == 0) return 0;
return st[st[u].link].len + 1;
}
void build(string &s) {
int id = 1;
for (char c : s) {
add(c);
cnt[last] = id++;
}
}
int cur = 1;
void dfs(int u = 0) {
in[u] = cur++;
arr[in[u]] = u;
for (auto j : g[u]) dfs(j);
out[u] = cur - 1;
}
void buildTree() {
for (int i = 1; i < sz; ++i) g[st[i].link].push_back(i);
dfs();
}
int get(string &t) {
int cur = 0;
for (auto j : t) {
if (st[cur].next.count(j))
cur = st[cur].next[j];
else
return -1;
}
return cur;
}
} sa;
int _runtimeTerror_() {
string s;
cin >> s;
sa.build(s);
sa.buildTree();
int Q;
cin >> Q;
for (int i = 1; i <= Q; ++i) {
int k;
string t;
cin >> k >> t;
int u = sa.get(t);
if (u == -1) {
cout << "-1\n";
continue;
}
vector<int> v;
for (int j = in[u]; j <= out[u]; ++j) {
if (sa.cnt[arr[j]]) v.push_back(sa.cnt[arr[j]]);
}
if ((long long)v.size() < k) {
cout << "-1\n";
continue;
}
sort(v.begin(), v.end());
int sz = (long long)v.size() - k;
int ans = 2e9;
for (int i = 0; i <= sz; ++i) amin(ans, v[i + k - 1] - v[i]);
cout << ans + (long long)t.size() << "\n";
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, rt = 1, cnt = 1;
char s[N], t[N];
queue<int> que[N];
int lim[N], ed[N], ch[N][26], fail[N], Fail[N], len[N], Ans[N];
inline void insert(int k) {
int x = rt;
for (int i = 1; t[i]; ++i) {
if (!ch[x][t[i] - 'a']) ch[x][t[i] - 'a'] = ++cnt;
x = ch[x][t[i] - 'a'];
}
ed[x] = k;
}
inline void build() {
static int que[N];
int head = 1, tail = 0;
for (int i = 0; i < 26; ++i)
if (ch[rt][i])
fail[ch[rt][i]] = rt, que[++tail] = ch[rt][i];
else
ch[rt][i] = rt;
while (head <= tail) {
int x = que[head++];
Fail[x] = ed[fail[x]] ? fail[x] : Fail[fail[x]];
for (int i = 0; i < 26; ++i)
if (ch[x][i])
fail[ch[x][i]] = ch[fail[x]][i], que[++tail] = ch[x][i];
else
ch[x][i] = ch[fail[x]][i];
}
}
int main() {
scanf("%s%d", s + 1, &n);
for (int i = 1; i <= n; ++i)
scanf("%d%s", &lim[i], t + 1), len[i] = strlen(t + 1), Ans[i] = N,
insert(i);
int x = rt;
build();
for (int i = 1; s[i]; ++i) {
x = ch[x][s[i] - 'a'];
for (int y = ed[x] ? x : Fail[x], k; y; y = Fail[y]) {
que[k = ed[y]].push(i);
if (que[k].size() > lim[k]) que[k].pop();
if (que[k].size() == lim[k])
Ans[k] = min(Ans[k], i - que[k].front() + len[k]);
}
}
for (int i = 1; i <= n; ++i) printf("%d\n", Ans[i] >= N ? -1 : Ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 100001, k = 26;
int n, m;
string second, t;
int a[mxn], sz[mxn], lk[mxn], q[mxn];
int tr[mxn][k];
vector<int> v[mxn], first[mxn];
int ql, qr, it = 1;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> second >> m;
n = second.size();
for (int i = 0; i < m; i++) {
cin >> a[i] >> t;
sz[i] = t.size();
int l = 0;
for (char c : t) {
int j = c - 'a';
if (!tr[l][j]) tr[l][j] = it++;
l = tr[l][j];
}
v[l].push_back(i);
}
lk[qr++] = -1;
while (ql < qr) {
int c = q[ql++];
if (~lk[c])
for (int i : v[lk[c]]) v[c].push_back(i);
for (int i = 0; i < k; i++) {
int j = lk[c], l = tr[c][i];
if (l) {
lk[l] = ~j ? tr[j][i] : 0;
q[qr++] = l;
} else {
tr[c][i] = tr[j][i];
}
}
}
for (int i = 0, j = 0; i < n; i++) {
int c = second[i] - 'a';
j = tr[j][c];
for (int l : v[j]) first[l].push_back(i);
}
for (int i = 0; i < m; i++) {
if (first[i].size() < a[i]) {
cout << -1 << '\n';
} else {
int ret = n;
for (int j = a[i] - 1; j < first[i].size(); j++) {
ret = min(ret, first[i][j] - first[i][j - a[i] + 1]);
}
ret += sz[i];
cout << ret << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct node {
int ptr[26];
int leaf, link, exlink, p, ch;
node(int _p = -1, int _ch = -1) {
p = _p;
ch = _ch;
link = exlink = leaf = -1;
memset(ptr, -1, sizeof(ptr));
}
};
vector<node> trie(1);
vector<int> pos[N];
string t[N];
string s;
int k[N];
int n;
void add(string s, int val) {
int cur = 0;
for (char c : s) {
if (trie[cur].ptr[c - 'a'] < 0) {
trie[cur].ptr[c - 'a'] = trie.size();
trie.push_back(node(cur, c - 'a'));
}
cur = trie[cur].ptr[c - 'a'];
}
trie[cur].leaf = val;
}
int getlink(int u);
int getptr(int u, int ch) {
int &res = trie[u].ptr[ch];
if (res == -1) {
if (u == 0)
res = 0;
else
res = getptr(getlink(u), ch);
}
return res;
}
int getlink(int u) {
int &res = trie[u].link;
int ch = trie[u].ch;
if (res == -1) {
if (u == 0 || trie[u].p == 0) return res = 0;
res = getptr(getlink(trie[u].p), ch);
}
return res;
}
int getexlink(int u) {
int &res = trie[u].exlink;
if (res == -1) {
if (u == 0)
return res = 0;
else if (trie[getlink(u)].leaf >= 0)
res = getlink(u);
else
res = getexlink(getlink(u));
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s >> n;
for (int i = 1; i <= n; i++) {
cin >> k[i] >> t[i];
add(t[i], i);
}
int cur = 0;
for (int i = 0; i < (int)s.size(); i++) {
cur = getptr(cur, s[i] - 'a');
int tmp = cur;
while (tmp) {
if (trie[tmp].leaf) pos[trie[tmp].leaf].push_back(i);
tmp = getexlink(tmp);
}
}
for (int i = 1; i <= n; i++) {
if (pos[i].size() < k[i]) {
cout << "-1\n";
continue;
}
int res = 1e9;
for (int j = 0; j + k[i] <= (int)pos[i].size(); j++)
res = min(res, pos[i][j + k[i] - 1] - pos[i][j] + (int)t[i].size());
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
vector<int> g[maxn];
struct AC {
int N, P;
vector<vector<int>> next;
vector<int> link, out_link;
vector<vector<int>> out;
AC() : N(0), P(0) { node(); }
int node() {
next.emplace_back(26, 0);
link.emplace_back(0);
out_link.emplace_back(0);
out.emplace_back(0);
return N++;
}
int add_pattern(const string T) {
int u = 0;
for (auto c : T) {
if (!next[u][c - 'a']) next[u][c - 'a'] = node();
u = next[u][c - 'a'];
}
out[u].push_back(P);
return P++;
}
void compute() {
queue<int> q;
for (q.push(0); !q.empty();) {
int u = q.front();
q.pop();
for (int c = 0; c < 26; ++c) {
int v = next[u][c];
if (!v)
next[u][c] = next[link[u]][c];
else {
link[v] = u ? next[link[u]][c] : 0;
out_link[v] = out[link[v]].empty() ? out_link[link[v]] : link[v];
q.push(v);
}
}
}
}
int advance(int u, char c) {
while (u && !next[u][c - 'a']) u = link[u];
u = next[u][c - 'a'];
return u;
}
void match(const string S) {
int u = 0;
for (int i = 0; i < S.size(); ++i) {
char c = S[i];
u = advance(u, c);
for (int v = u; v; v = out_link[v]) {
for (auto p : out[v]) {
g[p].push_back(i);
}
}
}
}
} aho;
string pat[maxn];
string s;
int n, k[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cin >> s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k[i] >> pat[i];
aho.add_pattern(pat[i]);
}
aho.compute();
aho.match(s);
for (int i = 0; i < n; i++) {
int l = 0, r = k[i] - 1;
int ans = 1e9;
while (r < g[i].size()) {
int sz = g[i][r] - g[i][l] + pat[i].size();
ans = min(ans, sz);
r++;
l++;
}
if (ans == 1e9) ans = -1;
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 26;
char Begin = 'a';
struct node {
int next[N], go[N];
int leaf = 0, p = -1, link = -1, link2 = -1, len = -1;
char ch;
vector<int> ind;
};
vector<node> trie;
void create_root() {
node root;
for (int i = 0; i < N; ++i) root.next[i] = root.go[i] = -1;
trie.push_back(root);
}
node create(int p, char c) {
node ans;
ans.p = p;
ans.ch = c;
for (int i = 0; i < N; ++i) ans.next[i] = ans.go[i] = -1;
return ans;
}
void add_string(string s, int num) {
int curr_node = 0;
for (int i = 0; i < s.size(); ++i) {
int c = s[i] - Begin;
if (trie[curr_node].next[c] == -1) {
trie[curr_node].next[c] = trie.size();
node new_node = create(curr_node, s[i]);
trie.push_back(new_node);
}
curr_node = trie[curr_node].next[c];
}
trie[curr_node].leaf = 1;
trie[curr_node].len = s.size();
trie[curr_node].ind.push_back(num);
}
int go(int curr_node, char ch);
int get_link(int curr_node) {
if (trie[curr_node].link == -1) {
if (curr_node == 0 || trie[curr_node].p == 0)
trie[curr_node].link = 0;
else
trie[curr_node].link =
go(get_link(trie[curr_node].p), trie[curr_node].ch);
}
return trie[curr_node].link;
}
int go(int curr_node, char ch) {
int c = ch - Begin;
if (trie[curr_node].go[c] == -1) {
if (trie[curr_node].next[c] != -1)
trie[curr_node].go[c] = trie[curr_node].next[c];
else {
if (curr_node == 0)
trie[curr_node].go[c] = 0;
else
trie[curr_node].go[c] = go(get_link(curr_node), ch);
}
}
return trie[curr_node].go[c];
}
int walk(int now) {
if (trie[now].link2 == -1) {
int nxt = get_link(now);
if (now == 0 || nxt == 0)
trie[now].link2 = 0;
else if (trie[nxt].leaf)
trie[now].link2 = nxt;
else
trie[now].link2 = walk(nxt);
}
return trie[now].link2;
}
vector<int> cnt;
vector<vector<int> > pos;
vector<int> Data;
vector<int> fre;
int main() {
string s, a;
cin >> s;
int n, i, j;
scanf("%d", &n);
create_root();
for (i = 0; i < n; ++i) {
scanf("%d", &j);
fre.push_back(j);
cin >> a;
Data.push_back(a.size());
add_string(a, i);
}
pos.assign(n, vector<int>());
int now = 0;
for (i = 0; i < s.size(); ++i) {
now = go(now, s[i]);
int tmp = now;
while (tmp > 0) {
if (trie[tmp].leaf) {
for (j = 0; j < trie[tmp].ind.size(); ++j) {
pos[trie[tmp].ind[j]].push_back(i - trie[tmp].len + 1);
}
}
tmp = walk(tmp);
}
}
for (int i = 0; i < n; ++i) {
if (pos[i].size() < fre[i])
cout << -1 << endl;
else {
int ans = 1000000;
for (j = 0; j + fre[i] - 1 < pos[i].size(); ++j) {
ans = min(ans, pos[i][j + fre[i] - 1] - pos[i][j] + Data[i]);
}
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 11;
const int sqr = 400;
const long long base = 727;
const long long mod = 1e9 + 11;
const int oo = 1e9;
int nxt[maxn][26], k[maxn], ind[maxn], siz, n;
long long h[maxn], po[maxn], qh[maxn];
string s, t[maxn];
vector<int> found[maxn];
void add(string &s, int i) {
int cur = 0;
for (auto x : s) {
if (!nxt[cur][x - 'a']) nxt[cur][x - 'a'] = ++siz;
cur = nxt[cur][x - 'a'];
}
ind[cur] = i;
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
memset(ind, -1, sizeof ind);
cin >> s >> n;
po[0] = 1LL;
h[0] = s[0] - 'a' + 1;
for (int i = 1; i < (int)(s).size(); i++) {
h[i] = (h[i - 1] * base + (s[i] - 'a' + 1)) % mod;
po[i] = po[i - 1] * base % mod;
}
vector<int> big;
for (int i = 0; i < n; i++) {
cin >> k[i] >> t[i];
if ((int)(t[i]).size() > sqr) {
big.push_back(i);
} else {
add(t[i], i);
}
for (auto x : t[i]) {
qh[i] = (qh[i] * base + (x - 'a' + 1)) % mod;
}
}
auto gethash = [&](int l, int r) {
long long ret = h[r];
if (l) {
ret -= po[r - l + 1] * h[l - 1];
assert(r - l + 1 < (int)(s).size());
}
ret %= mod;
while (ret < 0) ret += mod;
return ret;
};
for (int i = 0; i < (int)(s).size(); i++) {
int cur = 0;
for (int r = i;
r < (int)(s).size() && r - i + 1 <= sqr && nxt[cur][s[r] - 'a']; r++) {
cur = nxt[cur][s[r] - 'a'];
if (ind[cur] >= 0) {
found[ind[cur]].push_back(i);
}
}
for (int b : big) {
if (i + (int)(t[b]).size() <= (int)(s).size() &&
gethash(i, i + (int)(t[b]).size() - 1) == qh[b])
found[b].push_back(i);
}
}
for (int i = 0; i < n; i++) {
if ((int)(found[i]).size() < k[i] || (int)(t[i]).size() > (int)(s).size())
cout << -1 << endl;
else {
int ans = 1e9;
for (int j = 0; j + k[i] - 1 < (int)(found[i]).size(); j++) {
ans =
min(ans, found[i][j + k[i] - 1] + (int)(t[i]).size() - found[i][j]);
}
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void readi(T &x) {
T input = 0;
bool negative = false;
char c = ' ';
while (c < '-') {
c = getchar();
}
if (c == '-') {
negative = true;
c = getchar();
}
while (c >= '0') {
input = input * 10 + (c - '0');
c = getchar();
}
if (negative) {
input = -input;
}
x = input;
}
template <class T>
void printi(T output) {
if (output == 0) {
putchar('0');
return;
}
if (output < 0) {
putchar('-');
output = -output;
}
int aout[20];
int ilen = 0;
while (output) {
aout[ilen] = ((output % 10));
output /= 10;
ilen++;
}
for (int i = ilen - 1; i >= 0; i--) {
putchar(aout[i] + '0');
}
return;
}
template <class T>
void ckmin(T &a, T b) {
a = min(a, b);
}
template <class T>
void ckmax(T &a, T b) {
a = max(a, b);
}
long long randomize(long long mod) {
return ((1ll << 30) * rand() + (1ll << 15) * rand() + rand()) % mod;
}
const long double PI = 4.0 * atan(1.0);
const long double EPS = 1e-20;
long long normalize(long long x, long long mod = 1000000007) {
return (((x % mod) + mod) % mod);
}
string temps;
int N, Q, M;
long long s[100013], t[100013];
vector<int> hashes;
int best;
int sval[30][100013];
int suf[100013], srank[100013], lcp[100013];
vector<int> sfi[100013], sse[100013];
pair<long long, long long> shash[100013];
pair<long long, long long> thash[100013];
pair<long long, long long> pw[100013];
int ans[100013];
int arr[100013];
vector<pair<pair<int, int>, pair<int, int> > > queries;
pair<long long, long long> srange(int L, int R) {
pair<long long, long long> res;
res.first = normalize(
shash[R + 1].first - shash[L].first * pw[R - L + 1].first, 1000000007);
res.second = normalize(
shash[R + 1].second - shash[L].second * pw[R - L + 1].second, 1000000009);
return res;
}
pair<long long, long long> trange(int L, int R) {
pair<long long, long long> res;
res.first = normalize(
thash[R + 1].first - thash[L].first * pw[R - L + 1].first, 1000000007);
res.second = normalize(
thash[R + 1].second - thash[L].second * pw[R - L + 1].second, 1000000009);
return res;
}
void getsuf() {
for (int i = 0; i < N; i++) {
sval[0][i] = s[i];
}
for (int i = 0; i < 20; i++) {
int Z = max((int)N, 256);
for (int j = 0; j <= Z; j++) {
sse[j].clear();
sfi[j].clear();
}
for (int j = 0; j < N; j++) {
sse[sval[i][j + (1 << i)]].push_back(j);
}
for (int j = 0; j <= Z; j++) {
for (int k = 0; k < sse[j].size(); k++) {
int idx = sse[j][k];
sfi[sval[i][idx]].push_back(idx);
}
}
int cnt = 0;
pair<int, int> was = make_pair(-1, -1);
for (int j = 0; j <= Z; j++) {
for (int k = 0; k < sfi[j].size(); k++) {
int idx = sfi[j][k];
pair<int, int> curp = make_pair(sval[i][idx], sval[i][idx + (1 << i)]);
if (curp != was) {
cnt++;
was = curp;
}
sval[i + 1][idx] = cnt;
}
}
}
for (int i = 0; i < N; i++) {
srank[i] = sval[20][i] - 1;
suf[srank[i]] = i;
}
}
int stoverlap(int a, int b) {
int lo = 0, hi = min(N - a, M - b);
while (hi > lo) {
int mid = (hi + lo + 1) / 2;
if (srange(a, a + mid - 1) == trange(b, b + mid - 1)) {
lo = mid;
} else {
hi = mid - 1;
}
}
return lo;
}
int32_t main() {
ios_base::sync_with_stdio(0);
srand(time(0));
if (fopen("cf963d.in", "r")) {
freopen("cf963d.in", "r", stdin);
freopen("cf963d.out", "w", stdout);
}
cin >> temps;
N = temps.length();
for (int i = 0; i < N; i++) {
s[i] = temps[i] - 'a' + 1;
}
for (int i = 0; i < N; i++) {
shash[i + 1].first = shash[i].first * 1000007 + s[i];
shash[i + 1].first %= 1000000007;
shash[i + 1].second = shash[i].second * 1000007 + s[i];
shash[i + 1].second %= 1000000009;
}
pw[0] = make_pair(1, 1);
for (int i = 0; i < N; i++) {
pw[i + 1].first = pw[i].first * 1000007;
pw[i + 1].first %= 1000000007;
pw[i + 1].second = pw[i].second * 1000007;
pw[i + 1].second %= 1000000009;
}
getsuf();
for (int i = 0; i < N; i++) {
arr[i] = suf[i];
}
cin >> Q;
for (int q = 0; q < Q; q++) {
int k;
cin >> k >> temps;
M = temps.length();
if (M > N) {
ans[q] = -1;
continue;
}
for (int i = 0; i < M; i++) {
t[i] = temps[i] - 'a' + 1;
}
for (int i = 0; i < M; i++) {
thash[i + 1].first = thash[i].first * 1000007 + t[i];
thash[i + 1].first %= 1000000007;
thash[i + 1].second = thash[i].second * 1000007 + t[i];
thash[i + 1].second %= 1000000009;
}
int lt, rt;
int lo = 0, hi = N - 1;
while (hi > lo) {
int mid = (hi + lo + 1) / 2;
int pos = suf[mid];
int overlap = stoverlap(pos, 0);
if (overlap >= M || s[pos + overlap] <= t[overlap]) {
lo = mid;
} else {
hi = mid - 1;
}
}
rt = lo;
lo = 0;
hi = N - 1;
while (hi > lo) {
int mid = (hi + lo) / 2;
int pos = suf[mid];
int overlap = stoverlap(pos, 0);
if ((overlap >= M) || s[pos + overlap] > t[overlap]) {
hi = mid;
} else {
lo = mid + 1;
}
}
lt = lo;
if (lt + k - 1 > rt) {
ans[q] = -1;
continue;
}
sort(arr + lt, arr + rt + 1);
ans[q] = 1000000007;
for (int i = lt; i + k - 1 <= rt; i++) {
ckmin(ans[q], arr[i + k - 1] - arr[i]);
}
ans[q] += M;
for (int i = lt; i <= rt; i++) {
arr[i] = suf[i];
}
}
for (int i = 0; i < Q; i++) {
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long MOD = 1e9 + 9;
unsigned long long Hash[100011];
unsigned long long P = 29;
unsigned long long p_pow[100011];
const int MAXN = 1e5 + 5;
int n;
int q;
string s;
vector<int> poses[100001];
int k[100001];
string strs[100001];
vector<int> queries[100001];
map<unsigned long long, int> have;
inline void solve(int x) {
for (int i = 0; i < queries[x].size(); i++) {
unsigned long long _Hash = 0;
string cur = strs[queries[x][i]];
for (int j = 1; j <= x; j++) {
_Hash += (unsigned long long)(cur[j - 1] - 'a' + 1) * p_pow[j] % MOD;
_Hash %= MOD;
}
_Hash *= p_pow[MAXN - x];
_Hash %= MOD;
have[_Hash] = queries[x][i];
}
for (int i = 1; i <= n - x + 1; i++) {
unsigned long long tmp = (MOD + Hash[i + x - 1] - Hash[i - 1]) % MOD;
tmp *= p_pow[MAXN - (i + x - 1)];
tmp %= MOD;
if (have.count(tmp)) poses[have[tmp]].push_back(i);
}
have.clear();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.length();
p_pow[0] = 1;
for (int i = 1; i <= MAXN; i++) p_pow[i] = p_pow[i - 1] * P % MOD;
for (int i = 1; i <= n; i++) {
Hash[i] = Hash[i - 1] + (unsigned long long)(s[i - 1] - 'a' + 1) * p_pow[i];
Hash[i] %= MOD;
}
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> k[i];
cin >> strs[i];
queries[strs[i].length()].push_back(i);
}
for (int i = 1; i <= n; i++)
if (queries[i].size() > 0) {
solve(i);
}
for (int i = 1; i <= q; i++) {
if (poses[i].size() < k[i]) {
cout << -1 << '\n';
continue;
}
int len = 2e9;
int cur;
for (int j = k[i] - 1; j < poses[i].size(); j++) {
cur = poses[i][j] + (int)strs[i].size() - poses[i][j - k[i] + 1];
if (cur < len) len = cur;
}
cout << len << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxnode = 1e5 + 10, z = 26, inf = 1e9 + 10;
vector<int> ocr[maxn];
char s[maxn], t[maxn];
int n, m, ted[maxn], sz[maxn], ans[maxn];
struct Trie {
int to[maxnode][z], last = 1, val[maxnode], f[maxnode], Q[maxnode],
par[maxnode];
void add(int ii, char s[maxn], int size) {
int id = 0;
for (int i = 0; i < size; i++) {
if (to[id][s[i] - 'a'] == 0) {
to[id][s[i] - 'a'] = last++;
}
id = to[id][s[i] - 'a'];
}
val[id] = ii + 1;
}
void bfs() {
int l = 0, r = 0;
Q[r++] = 0;
while (l < r) {
int a = Q[l++];
if (val[a] > 0) {
if (val[f[a]] == 0) {
par[a] = 0;
} else {
par[a] = f[a];
}
} else {
val[a] = val[f[a]];
par[a] = par[f[a]];
}
for (int i = 0; i < z; i++) {
if (to[a][i] == 0) {
to[a][i] = to[f[a]][i];
} else {
f[to[a][i]] = (a > 0) ? to[f[a]][i] : 0;
Q[r++] = to[a][i];
}
}
}
}
void solve() {
int id = 0;
for (int i = 0; i < m; i++) {
id = to[id][s[i] - 'a'];
int ii = id, vl = -1, cnt = 0;
while (val[ii] > 0) {
cnt++;
if (cnt > 500) {
assert(0);
}
if (vl != val[ii]) {
ocr[val[ii] - 1].push_back(i);
}
vl = val[ii];
ii = par[ii];
}
}
for (int i = 0; i < n; i++) {
for (int j = ted[i] - 1; j < int(ocr[i].size()); j++) {
if (ans[i] == -1 ||
ans[i] > ocr[i][j] - ocr[i][j - ted[i] + 1] + sz[i]) {
ans[i] = ocr[i][j] - ocr[i][j - ted[i] + 1] + sz[i];
}
}
}
}
} trie;
int32_t main() {
memset(ans, -1, sizeof ans);
scanf("%s%d", s, &n);
m = strlen(s);
for (int i = 0; i < n; i++) {
scanf("%d%s", ted + i, t);
sz[i] = strlen(t);
trie.add(i, t, sz[i]);
}
trie.bfs();
trie.solve();
for (int i = 0; i < n; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 10000020;
const int INF = 0x3f3f3f3f;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
unordered_map<unsigned long long, int> mp;
char s[100003];
unsigned long long h[100003], pw[100003];
struct query {
int k, l, id;
unsigned long long hsh;
vector<int> v;
bool operator<(const query& rhs) const { return l < rhs.l; }
} q[100003];
int ans[100003];
int n;
void work(int l) {
for (int i = 1; i <= n - l + 1; i++) {
unsigned long long qwq = h[i + l - 1] - h[i - 1] * pw[l];
unordered_map<unsigned long long, int>::iterator it = mp.find(qwq);
if (it != mp.end()) q[it->second].v.push_back(i);
}
}
int main() {
init();
n = readstr(s + 1);
for (int i = 1; i <= n; i++) h[i] = h[i - 1] * 233 + s[i] - 'a' + 1;
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = pw[i - 1] * 233;
int m = readint();
for (int i = 1; i <= m; i++) {
q[i].k = readint();
q[i].l = readstr(s + 1);
q[i].id = i;
for (int j = 1; j <= q[i].l; j++) {
q[i].hsh = q[i].hsh * 233 + s[j] - 'a' + 1;
}
}
sort(q + 1, q + m + 1);
for (int i = 1; i <= m; i++) {
mp[q[i].hsh] = i;
if (q[i].l != q[i + 1].l) work(q[i].l);
}
for (int i = 1; i <= m; i++) {
ans[q[i].id] = INF;
for (int j = q[i].k - 1; j < q[i].v.size(); j++)
ans[q[i].id] =
min(ans[q[i].id], q[i].v[j] - q[i].v[j - q[i].k + 1] + q[i].l);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i] == INF ? -1 : ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100010], ss[100100];
int ll, x[100100], l2;
int pp[100100];
vector<int> vv[200100];
set<int> sss[200100];
int n, ans[100100];
int lll[100100];
namespace SAM {
int mem, np, root;
int len[200100], par[200100];
int trans[200100][26];
void append(int ch) {
int p = np;
np = ++mem;
len[np] = len[p] + 1;
for (; p && !trans[p][ch]; p = par[p]) trans[p][ch] = np;
if (!p)
par[np] = root;
else {
int q = trans[p][ch];
if (len[q] == len[p] + 1)
par[np] = q;
else {
int nq = ++mem;
par[nq] = par[q];
par[q] = par[np] = nq;
memcpy(trans[nq], trans[q], sizeof(trans[nq]));
len[nq] = len[p] + 1;
for (; p && trans[p][ch] == q; p = par[p]) trans[p][ch] = nq;
}
}
}
void build() {
np = root = ++mem;
int i;
for (i = 1; i <= ll; i++) {
append(s[i] - 'a'), sss[np].insert(i);
}
}
} // namespace SAM
void work(int tt) {
using SAM::trans;
int i, now = SAM::root;
for (i = 1; i <= l2; i++) {
now = trans[now][ss[i] - 'a'];
}
vv[now].push_back(tt);
}
queue<int> q;
int in[200100];
void work2() {
using SAM::mem;
using SAM::par;
int i, j, t;
vector<int> tmp;
for (i = 1; i <= mem; i++)
if (par[i]) in[par[i]]++;
for (i = 1; i <= mem; i++)
if (!in[i]) q.push(i);
while (!q.empty()) {
t = q.front();
q.pop();
if (vv[t].size()) {
tmp.clear();
for (auto k : sss[t]) tmp.push_back(k);
}
for (auto p : vv[t]) {
for (i = 0, j = x[p] - 1; j < tmp.size(); i++, j++) {
ans[p] = min(ans[p], tmp[j] - tmp[i] + lll[p]);
}
}
if (par[t]) {
if (sss[par[t]].size() < sss[t].size()) swap(sss[par[t]], sss[t]);
for (auto k : sss[t]) sss[par[t]].insert(k);
sss[t].clear();
in[par[t]]--;
if (!in[par[t]]) q.push(par[t]);
}
}
}
int main() {
int i;
scanf("%s", s + 1);
ll = strlen(s + 1);
SAM::build();
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%s", &x[i], ss + 1);
l2 = lll[i] = strlen(ss + 1);
work(i);
}
int aefsaf;
memset(ans, 0x3f, sizeof(ans));
work2();
for (i = 1; i <= n; i++) printf("%d\n", ans[i] == 0x3f3f3f3f ? -1 : ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
bool is_down(char x) { return ('a' <= x && x <= 'z'); }
bool is_upper(char x) { return ('A' <= x && x <= 'Z'); }
bool is_digit(char x) { return ('0' <= x && x <= '9'); }
const double pi = 3.141592653589793238462643383279;
const double log23 = 1.58496250072115618145373894394781;
const double eps = 1e-10;
const long long INF = 1e18 + 239;
const long long prost = 239;
const int two = 2;
const int th = 3;
const long long MOD = 1e9 + 9;
const long long MOD2 = MOD * MOD;
const int BIG = 1e9 + 239;
const int alf = 26;
const int M = 1e5 + 239;
const int N = 2 * 1e3 + 239;
const int L = 20;
const int T = (1 << 18);
const int B = trunc(sqrt(M)) + 1;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dig = 10;
const string str_alf = "abcdefghijklmnopqrstuvwxyz";
const string str_alf_big = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int digarr[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int bt = 31;
vector<int> z_function(string s) {
int n = s.length();
vector<int> z;
z.resize(n);
z[0] = 0;
int l = 0;
int r = 0;
for (int i = 1; i < n; i++) {
z[i] = min(z[i - l], r - i);
if (z[i] < 0) z[i] = 0;
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] > r) {
l = i;
r = i + z[i];
}
}
return z;
}
string s;
int q, k[M];
string t[M];
vector<vector<int> > pos(M), v(M);
int ans[M];
struct Node {
Node *a[alf];
int id;
Node() {
for (int x = 0; x < alf; x++) a[x] = NULL;
id = -1;
}
};
Node *root;
void add(string z, int id) {
Node *cur = root;
for (char x : z) {
if (cur->a[x - 'a'] != NULL)
cur = cur->a[x - 'a'];
else {
Node *d = new Node();
cur->a[x - 'a'] = d;
cur = d;
}
}
cur->id = id;
}
const int MG = 200;
int main() {
cin.sync_with_stdio(0);
root = new Node();
cin >> s >> q;
for (int i = 0; i < q; i++) cin >> k[i] >> t[i];
for (int i = 0; i < q; i++) {
if (t[i].size() >= MG) {
string w = t[i];
w += "&";
w += s;
vector<int> z = z_function(w);
for (int x = 0; x < s.size(); x++)
if (z[x + t[i].size() + 1] >= t[i].size()) pos[x].push_back(i);
continue;
}
add(t[i], i);
}
int n = s.size();
for (int i = 0; i < n; i++) {
Node *cur = root;
for (int x = i; x < n; x++) {
if (cur->a[s[x] - 'a'] == NULL) break;
cur = cur->a[s[x] - 'a'];
if (cur->id != -1) pos[i].push_back(cur->id);
}
}
for (int i = 0; i < q; i++) ans[i] = BIG;
for (int i = 0; i < n; i++) {
for (int x : pos[i]) {
v[x].push_back(i);
if (v[x].size() >= k[x])
ans[x] = min(ans[x], v[x].back() - v[x][(int)v[x].size() - k[x]]);
}
}
for (int i = 0; i < q; i++) {
if (ans[i] == BIG)
cout << "-1\n";
else
cout << ans[i] + t[i].size() << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
namespace SA {
const int MN = 100010;
int n, k, rsa[MN], tmp[MN];
bool cmp(int i, int j) {
if (rsa[i] != rsa[j]) return rsa[i] < rsa[j];
int ri = (i + k <= n) ? rsa[i + k] : -1;
int rj = (j + k <= n) ? rsa[j + k] : -1;
return ri < rj;
}
template <class S>
vector<int> build(const S &s) {
n = int(s.size());
vector<int> sa(n + 1);
for (int i = 0; i <= n; i++) {
sa[i] = i;
rsa[i] = i < n ? s[i] : -1;
}
for (k = 1; k <= n; k *= 2) {
sort(sa.begin(), sa.end(), cmp);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + int(cmp(sa[i - 1], sa[i]));
}
copy(tmp, tmp + n + 1, rsa);
}
return sa;
}
} // namespace SA
template <class S>
pair<int, int> match(const S &s, const S &t, const vector<int> &sa) {
int n = int(s.size()), m = int(t.size());
pair<int, int> ans;
int lw, hi;
lw = 0;
hi = n + 1;
while (hi - lw > 1) {
int mi = (lw + hi) / 2;
if (s.compare(sa[mi], m, t) < 0) {
lw = mi;
} else {
hi = mi;
}
}
ans.first = hi;
lw = 0;
hi = n + 1;
while (hi - lw > 1) {
int mi = (lw + hi) / 2;
if (s.compare(sa[mi], m, t) <= 0) {
lw = mi;
} else {
hi = mi;
}
}
ans.second = hi;
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
vector<int> sa = SA::build(s);
int q;
cin >> q;
for (int ph = 0; ph < q; ph++) {
int k;
string m;
cin >> k >> m;
pair<int, int> u = match(s, m, sa);
vector<int> v;
for (int i = u.first; i < u.second; i++) {
v.push_back(sa[i]);
}
sort(v.begin(), v.end());
int n = int(v.size());
if (n < k) {
cout << -1 << '\n';
continue;
}
int ans = INF;
for (int i = 0; i <= n - k; i++) {
ans = min(ans, v[i + k - 1] - v[i] + int(m.size()));
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct SuffixArray {
vector<int> SA;
string s;
void Build_SA(const string &str) {
s = str;
SA.resize(s.size());
iota(begin(SA), end(SA), 0);
sort(begin(SA), end(SA), [&](const int &a, const int &b) {
if (s[a] == s[b]) return (a > b);
return (s[a] < s[b]);
});
vector<int> classes(s.size()), c(s.size()), cnt(s.size());
for (int i = 0; i < s.size(); i++) {
c[i] = s[i];
}
for (int len = 1; len < s.size(); len <<= 1) {
for (int i = 0; i < s.size(); i++) {
if (i > 0 && c[SA[i - 1]] == c[SA[i]] && SA[i - 1] + len < s.size() &&
c[SA[i - 1] + len / 2] == c[SA[i] + len / 2]) {
classes[SA[i]] = classes[SA[i - 1]];
} else {
classes[SA[i]] = i;
}
}
iota(begin(cnt), end(cnt), 0);
copy(begin(SA), end(SA), begin(c));
for (int i = 0; i < s.size(); i++) {
int s1 = c[i] - len;
if (s1 >= 0) SA[cnt[classes[s1]]++] = s1;
}
classes.swap(c);
}
}
int operator[](int k) const { return (SA[k]); }
int size() const { return (s.size()); }
bool lt_substr(string &t, int si = 0, int ti = 0) {
int sn = s.size(), tn = t.size();
while (si < sn && ti < tn) {
if (s[si] < t[ti]) return (true);
if (s[si] > t[ti]) return (false);
++si, ++ti;
}
return (si >= sn && ti < tn);
}
int lower_bound(string &t) {
int low = -1, high = SA.size();
while (high - low > 1) {
int mid = (low + high) >> 1;
if (lt_substr(t, SA[mid]))
low = mid;
else
high = mid;
}
return (high);
}
pair<int, int> lower_upper_bound(string &t) {
int idx = lower_bound(t);
int low = idx - 1, high = SA.size();
t.back()++;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (lt_substr(t, SA[mid]))
low = mid;
else
high = mid;
}
t.back()--;
return (make_pair(idx, high));
}
void output() {
for (int i = 0; i < size(); i++) {
cout << i << ": " << s.substr(SA[i]) << endl;
}
}
};
const int INF = 1 << 30;
int main() {
string S;
cin >> S;
SuffixArray sa;
sa.Build_SA(S);
int N;
cin >> N;
while (N--) {
int k;
string T;
cin >> k >> T;
auto p = sa.lower_upper_bound(T);
if (p.second - p.first < k) {
cout << -1 << endl;
continue;
}
vector<int> vs;
vs.reserve(p.second - p.first);
for (int i = p.first; i < p.second; i++) {
vs.push_back(sa.SA[i]);
}
sort(vs.begin(), vs.end());
int ret = INF;
for (int i = k - 1; i < vs.size(); i++) {
ret = min(ret, vs[i] - vs[i - k + 1]);
}
cout << ret + T.size() << endl;
}
}
|
#include <bits/stdc++.h>
const int maxn = 1e5 + 7;
const int inf = 0x3f3f3f3f;
using namespace std;
char s[maxn], s1[maxn];
int m, k, cnt;
int ans[maxn];
queue<int> q;
struct node {
int fail, next, ans, k, num, len;
int son[26];
vector<int> a;
} t[maxn];
void ins(char *S, int d, int k) {
int len = strlen(S + 1), now = 0;
for (int i = 1; i <= len; i++) {
int c = S[i] - 'a';
if (!t[now].son[c]) t[now].son[c] = ++cnt;
t[t[now].son[c]].len = t[now].len + 1;
now = t[now].son[c];
}
t[now].k = k, t[now].num = d, t[now].ans = inf;
}
void getfail() {
for (int i = 0; i < 26; i++) {
if (t[0].son[i]) {
t[i].fail = 0;
q.push(t[0].son[i]);
}
}
while (!q.empty()) {
int now = q.front();
q.pop();
if (t[t[now].fail].num)
t[now].next = t[now].fail;
else
t[now].next = t[t[now].fail].next;
for (int i = 0; i < 26; i++) {
if (t[now].son[i]) {
t[t[now].son[i]].fail = t[t[now].fail].son[i];
q.push(t[now].son[i]);
} else {
t[now].son[i] = t[t[now].fail].son[i];
}
}
}
}
void find(char *S) {
int len = strlen(S + 1), now = 0;
for (int i = 1; i <= len; i++) {
int c = S[i] - 'a';
now = t[now].son[c];
for (int p = now; p; p = t[p].next) {
if (t[p].num) {
t[p].a.push_back(i);
if (t[p].a.size() >= t[p].k) {
int sz = t[p].a.size();
t[p].ans = min(t[p].ans, i - (t[p].a[sz - t[p].k] - t[p].len));
}
}
}
}
}
int main() {
scanf("%s", s + 1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &k);
scanf("%s", s1 + 1);
ins(s1, i, k);
}
getfail();
find(s);
for (int p = 1; p <= cnt; p++) {
if (t[p].num) {
if (t[p].ans != inf)
ans[t[p].num] = t[p].ans;
else
ans[t[p].num] = -1;
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct SuffixArray {
const int L;
string s;
vector<vector<int> > P;
vector<pair<pair<int, int>, int> > M;
SuffixArray(const string &s)
: L(s.length()), s(s), P(1, vector<int>(L, 0)), M(L) {
for (int i = 0; i < L; i++) P[0][i] = int(s[i]);
for (int skip = 1, level = 1; skip < L; skip *= 2, level++) {
P.push_back(vector<int>(L, 0));
for (int i = 0; i < L; i++)
M[i] =
make_pair(make_pair(P[level - 1][i],
i + skip < L ? P[level - 1][i + skip] : -1000),
i);
sort(M.begin(), M.end());
for (int i = 0; i < L; i++)
P[level][M[i].second] = (i > 0 && M[i].first == M[i - 1].first)
? P[level][M[i - 1].second]
: i;
}
}
vector<int> GetSuffixArray() { return P.back(); }
int LongestCommonPrefix(int i, int j) {
int len = 0;
if (i == j) return L - i;
for (int k = P.size() - 1; k >= 0 && i < L && j < L; k--) {
if (P[k][i] == P[k][j]) {
i += 1 << k;
j += 1 << k;
len += 1 << k;
}
}
return len;
}
};
char s[100005], t[100005];
int rk[100005];
int main() {
scanf("%s", s);
int n = strlen(s);
SuffixArray suffix(s);
vector<int> v = suffix.GetSuffixArray();
for (int i = 0; i < v.size(); i++) rk[v[i]] = i;
int q;
scanf("%d", &q);
while (q--) {
int k;
scanf("%d", &k);
scanf("%s", t);
int m = strlen(t);
int lo = 0, hi = n - 1, l = -1, r = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
int res = strncmp(t, s + rk[mid], m);
if (res == 0)
l = mid, hi = mid - 1;
else if (res < 0)
hi = mid - 1;
else
lo = mid + 1;
}
lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
int res = strncmp(t, s + rk[mid], m);
if (res == 0)
r = mid, lo = mid + 1;
else if (res < 0)
hi = mid - 1;
else
lo = mid + 1;
}
if (l == -1 || r == -1)
printf("-1\n");
else {
vector<int> v;
for (int i = l; i <= r; i++) {
v.push_back(rk[i]);
}
sort(v.begin(), v.end());
l = 0, r = 0;
int ans = 2e9;
while (l < v.size()) {
while (r < v.size() && r - l + 1 < k) r++;
if (r - l + 1 == k && r < v.size()) ans = min(ans, v[r] - v[l] + m);
l++;
}
if (ans == 2e9) ans = -1;
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, bzmax = 20;
typedef class Pair3 {
public:
int x, y, id;
Pair3(int x = 0, int y = 0, int id = 0) : x(x), y(y), id(id) {}
} Pair3;
int n, q;
char str[N << 1];
int sa[N], rk[N], cnt[N];
Pair3 xs[N], ys[N];
char buf[N];
inline void init() {
scanf("%s", str + 1);
n = strlen(str + 1);
scanf("%d", &q);
}
void radix_sort(Pair3* xs) {
int m = max(n, 256);
memset(cnt, 0, sizeof(int) * (m + 1));
for (int i = 1; i <= n; i++) cnt[xs[i].y]++;
for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (int i = 1; i <= n; i++) ys[cnt[xs[i].y]--] = xs[i];
memset(cnt, 0, sizeof(int) * (m + 1));
for (int i = 1; i <= n; i++) cnt[ys[i].x]++;
for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (int i = n; i; i--) xs[cnt[ys[i].x]--] = ys[i];
}
void build_sa() {
for (int i = 1; i <= n; i++) rk[i] = str[i];
for (int k = 0, dif; k < bzmax; k++) {
for (int i = 1; i + (1 << k) <= n; i++)
xs[i] = Pair3(rk[i], rk[i + (1 << k)], i);
for (int i = n - (1 << k) + 1; i <= n; i++) xs[i] = Pair3(rk[i], 0, i);
radix_sort(xs);
rk[xs[1].id] = dif = 1;
for (int i = 2; i <= n; i++)
rk[xs[i].id] =
((xs[i].x != xs[i - 1].x || xs[i].y != xs[i - 1].y) ? (++dif)
: (dif));
if (dif == n) break;
}
for (int i = 1; i <= n; i++) sa[rk[i]] = i;
}
int cnt1[256];
int ar[N], br[N];
void radix_sort(int* ar, int len) {
const int temp = 255;
int *x = ar, *y = br;
for (int t = 0; t < 3; t++) {
int bit = t * 8;
memset(cnt1, 0, sizeof(cnt1));
for (int i = 0; i < len; i++) cnt1[(x[i] >> bit) & temp]++;
for (int i = 1; i <= temp; i++) cnt1[i] += cnt1[i - 1];
for (int i = len - 1; ~i; i--) y[--cnt1[(x[i] >> bit) & temp]] = x[i];
swap(x, y);
}
for (int i = 0; i < len; i++) ar[i] = x[i];
}
inline void solve() {
int K, len;
while (q--) {
scanf("%d%s", &K, buf + 1);
len = strlen(buf + 1);
int L = 1, R = n, l, r;
for (int i = 1; i <= len && L <= R; i++) {
l = L, r = R;
while (l <= r) {
int mid = (l + r) >> 1;
if (str[sa[mid] + i - 1] >= buf[i])
r = mid - 1;
else
l = mid + 1;
}
L = r + 1;
if (L > R) break;
l = L, r = R;
while (l <= r) {
int mid = (l + r) >> 1;
if (str[sa[mid] + i - 1] <= buf[i])
l = mid + 1;
else
r = mid - 1;
}
R = l - 1;
}
if (R - L + 1 < K)
puts("-1");
else {
int res = 211985, lc = R - L + 1;
for (int i = L; i <= R; i++) ar[i - L] = sa[i];
radix_sort(ar, lc);
for (int i = K - 1; i < lc; i++) res = min(ar[i] - ar[i - K + 1], res);
printf("%d\n", res + len);
}
}
}
int main() {
init();
build_sa();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 14, sq = 200, z = 26;
int q, k[maxn], m[maxn], po[maxn], h[maxn], len[maxn], sz = 1, nxt[maxn][z];
int to[maxn];
vector<int> where[maxn];
string s, p[maxn];
int f[maxn];
int insert(string &s) {
int v = 0;
for (int i = 0; i < s.size(); i++) {
if (!nxt[v][s[i] - 'a']) nxt[v][s[i] - 'a'] = sz++;
v = nxt[v][s[i] - 'a'];
}
return v;
}
vector<int> kmp(string &s, string &p) {
vector<int> ret;
int k = 0;
for (int i = 1; i < p.size(); i++) {
while (k && p[k] != p[i]) k = f[k];
if (p[k] == p[i]) k++;
f[i + 1] = k;
}
k = 0;
for (int i = 0; i < s.size(); i++) {
while (k && p[k] != s[i]) k = f[k];
if (p[k] == s[i]) k++;
if (k == p.size()) {
ret.push_back(i);
k = f[k];
}
}
return ret;
}
int solve(const vector<int> &v, int k, int len) {
if (v.size() < k) return -1;
int ans = s.size();
for (int j = k - 1; j < v.size(); j++)
ans = min(ans, v[j] - v[j - k + 1] + len);
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
memset(to, -1, sizeof to);
cin >> s;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> k[i] >> p[i];
if (p[i].size() < sq) to[insert(p[i])] = i;
}
for (int i = 0; i < s.size(); i++) {
int p = 0;
for (int j = i; j < min<int>(s.size(), i + sq); j++) {
if (!nxt[p][s[j] - 'a']) break;
p = nxt[p][s[j] - 'a'];
if (to[p] != -1) where[to[p]].push_back(i);
}
}
for (int i = 0; i < q; i++)
cout << solve(p[i].size() < sq ? where[i] : kmp(s, p[i]), k[i], p[i].size())
<< '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, cnt, ans[N];
struct AC {
int c[26], k, id, ans, suiv, fail, len;
vector<int> u;
} a[N];
inline void insert(char* s, int k, int id) {
int p = 0;
for (int i = 0; s[i]; i++) {
if (!a[p].c[s[i] - 'a']) a[p].c[s[i] - 'a'] = ++cnt;
a[a[p].c[s[i] - 'a']].len = a[p].len + 1;
p = a[p].c[s[i] - 'a'];
}
a[p].k = k;
a[p].id = id;
a[p].ans = 0x3f3f3f3f;
}
inline void build() {
queue<int> q;
for (int i = 0; i < 26; i++)
if (a[0].c[i]) a[a[0].c[i]].fail = 0, q.push(a[0].c[i]);
while (q.size()) {
int x = q.front();
q.pop();
if (a[a[x].fail].id)
a[x].suiv = a[x].fail;
else
a[x].suiv = a[a[x].fail].suiv;
for (int i = 0; i < 26; i++)
if (a[x].c[i])
a[a[x].c[i]].fail = a[a[x].fail].c[i], q.push(a[x].c[i]);
else
a[x].c[i] = a[a[x].fail].c[i];
}
}
inline void find(char* s) {
int p = 0;
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
p = a[p].c[s[i] - 'a'];
for (int j = p; j; j = a[j].suiv) {
if (!a[j].id) continue;
a[j].u.push_back(i);
if (a[j].u.size() >= a[j].k)
a[j].ans =
min(a[j].ans, i - (a[j].u[a[j].u.size() - a[j].k] - a[j].len));
}
}
}
int main() {
static char s[N], t[N];
scanf("%s%d", t + 1, &n);
for (int i = 1, k; i <= n; i++) scanf("%d%s", &k, s), insert(s, k, i);
build();
find(t);
for (int i = 0; i <= cnt; i++)
if (a[i].id) ans[a[i].id] = (a[i].ans == 0x3f3f3f3f) ? -1 : a[i].ans;
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int ch[26], f, d;
} t[100010];
vector<int> has[100010], to[100010];
int pre[100010];
int tot = 1;
inline void ins(char *s, const int p) {
int L = strlen(s + 1), x = 1;
for (int i = 1; i <= L; i++) {
const int in = s[i] - 'a';
if (!t[x].ch[in]) t[x].ch[in] = ++tot, t[tot].d = i;
x = t[x].ch[in];
}
has[x].push_back(p);
}
int que[100010];
inline void build(int l = 1, int r = 0) {
for (int i = 0; i < 26; i++)
if (t[1].ch[i]) {
t[t[1].ch[i]].f = 1;
que[++r] = t[1].ch[i];
} else
t[1].ch[i] = 1;
while (l <= r) {
const int x = que[l++];
for (int i = 0; i < 26; i++)
if (t[x].ch[i]) {
t[t[x].ch[i]].f = t[t[x].f].ch[i];
pre[t[x].ch[i]] = has[t[t[x].ch[i]].f].size() ? t[t[x].ch[i]].f
: pre[t[t[x].ch[i]].f];
que[++r] = t[x].ch[i];
} else
t[x].ch[i] = t[t[x].f].ch[i];
}
}
vector<int> edp[100010];
inline void match(char *s) {
int L = strlen(s + 1), x = 1;
for (int i = 1; i <= L; i++) {
x = t[x].ch[s[i] - 'a'];
int y = x;
while (y) {
if (has[y].size()) edp[y].push_back(i);
y = pre[y];
}
}
}
char s[100010], T[100010];
int k[100010], ans[100010];
int main() {
scanf("%s", s + 1);
const int l = strlen(s + 1);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%s", &k[i], T + 1);
ins(T, i);
}
build();
match(s);
memset(ans, 0x3f, sizeof ans);
for (int i = 1; i <= tot; i++)
if (has[i].size())
for (int j : has[i])
for (int p = 0; p < edp[i].size(); p++)
if (p >= k[j] - 1)
ans[j] = min(ans[j], edp[i][p] - edp[i][p - k[j] + 1] + t[i].d);
for (int i = 1; i <= n; i++) printf("%d\n", ans[i] == ans[0] ? -1 : ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct aho_corasick {
static const int alpha = 26;
vector<array<int, alpha>> go;
vector<int> fail;
vector<vector<int>> endpos;
aho_corasick() { add_node(); }
int add_string(const string &str, int ind) {
int e = 0;
for (char c : str) {
if (!go[e][c - 'a']) {
int nn = add_node();
go[e][c - 'a'] = nn;
}
e = go[e][c - 'a'];
}
endpos[e].push_back(ind);
return e;
}
void build() {
queue<int> que;
for (int c = 0; c < alpha; ++c)
if (go[0][c]) que.push(go[0][c]);
for (; !que.empty(); que.pop()) {
int e = que.front();
int f = fail[e];
for (int c = 0; c < alpha; ++c)
if (!go[e][c])
go[e][c] = go[f][c];
else {
fail[go[e][c]] = go[f][c];
for (auto &i : endpos[go[f][c]]) endpos[go[e][c]].push_back(i);
que.push(go[e][c]);
}
}
}
private:
int add_node() {
int pos = go.size();
go.emplace_back(array<int, alpha>());
fail.emplace_back(0);
endpos.emplace_back(vector<int>());
return pos;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
aho_corasick aho;
string s;
cin >> s;
int n;
cin >> n;
vector<int> cant(n);
vector<string> w(n);
for (int i = 0; i < n; i++) {
cin >> cant[i] >> w[i];
aho.add_string(w[i], i);
}
aho.build();
vector<vector<int>> entries(n);
int cur = 0;
for (int i = 0; i < s.size(); i++) {
cur = aho.go[cur][s[i] - 'a'];
for (auto &j : aho.endpos[cur]) entries[j].push_back(i);
}
for (int i = 0; i < n; i++) {
int k = cant[i];
int ans = 1000000;
for (int j = 0; j + k - 1 < entries[i].size(); j++)
ans = min(ans, entries[i][j + k - 1] - entries[i][j] + (int)w[i].size());
if (ans == 1000000) ans = -1;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const long double PI = acos(-1.0);
const long double EPS = 1e-6;
const long long INF = 1e9;
const long long LINF = 1e18;
const long long mod = 1000000009;
const long long MAX = 5e3 + 47;
int magic = 50;
string s;
int cnt = 0;
pair<long long, int> hashes[10000000];
long long pow29[100001];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
int n = s.size();
magic = min(magic, n);
for (int i = 0; i < s.size(); i++) s[i] -= 'a', s[i]++;
pow29[0] = 1;
for (int i = 1; i <= n; i++) pow29[i] = pow29[i - 1] * 37;
for (int i = 1; i <= magic; i++) {
long long hash = 0;
for (int j = 0; j < i; j++) {
hash *= 37;
hash += s[j];
}
hashes[cnt++] = {hash, 0};
for (int j = 0; j < n - i; j++) {
hash -= pow29[i - 1] * s[j];
hash *= 37;
hash += s[j + i];
hashes[cnt++] = {hash, j + 1};
}
}
sort(hashes, hashes + cnt);
int q;
cin >> q;
while (q--) {
int num = 0;
string query;
cin >> num >> query;
if (query.size() > n) {
cout << -1 << endl;
continue;
}
long long Hash1 = 0;
for (int i = 0; i < query.size(); i++) {
query[i] -= 'a';
query[i]++;
Hash1 *= 37;
Hash1 += query[i];
}
if (query.size() <= magic) {
int ans = INF;
auto it = lower_bound(hashes, hashes + cnt, make_pair(Hash1, 0));
if (it == hashes + cnt) {
cout << -1 << endl;
continue;
}
int pos = it - hashes;
for (int i = pos;
i < cnt - num + 1 && hashes[i + num - 1].first == Hash1 &&
hashes[i].first == Hash1;
i++) {
ans = min(ans, hashes[i + num - 1].second - hashes[i].second);
}
if (ans == INF)
cout << -1 << endl;
else
cout << ans + query.size() << endl;
} else {
vector<int> hashes;
int magic = query.size();
long long hash = 0;
for (int j = 0; j < magic; j++) {
hash *= 37;
hash += s[j];
}
if (Hash1 == hash) hashes.push_back(0);
for (int j = 0; j < n - magic; j++) {
hash -= pow29[magic - 1] * s[j];
hash *= 37;
hash += s[j + magic];
if (Hash1 == hash) hashes.push_back(j + 1);
}
int bestAns = INF;
for (int i = 0; i < (int)hashes.size() - num + 1; i++) {
bestAns = min(bestAns, hashes[i + num - 1] - hashes[i]);
}
if (bestAns == INF)
cout << -1 << endl;
else
cout << bestAns + query.size() << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
const int mod = 67867967;
const int md = 32452843;
const int inf = 1e9;
int n, m, k[maxn], ans[maxn];
long long h[maxn], hs[maxn], p[maxn];
string s, st[maxn];
vector<int> g[maxn], vec[maxn];
int mp[mod];
int get(int l, int r) {
int x = h[r] - (h[l] * p[r - l] % mod);
if (x < 0) x += mod;
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
p[0] = 1;
for (int i = 1; i < maxn; i++) {
p[i] = (p[i - 1] * 31) % mod;
}
cin >> s;
n = s.size();
s = ' ' + s;
for (int i = 1; i <= n; i++) {
h[i] = (h[i - 1] * 31 + (s[i] - 'a')) % mod;
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> k[i] >> st[i];
ans[i] = inf;
vec[i].reserve(10);
if ((int)st[i].size() + k[i] - 1 <= n) g[(int)st[i].size()].push_back(i);
for (int j = 0; j < (int)st[i].size(); j++) {
hs[i] = (hs[i] * 31 + (st[i][j] - 'a')) % mod;
}
}
for (int i = 1; i <= n; i++) {
if (g[i].empty()) continue;
for (int j = 0; j < (int)g[i].size(); j++) {
mp[hs[g[i][j]]] = g[i][j];
}
for (int j = 1; j + i - 1 <= n; j++) {
int x = mp[get(j - 1, j + i - 1)];
if (x) vec[x].push_back(j);
}
for (int o : g[i]) {
for (int j = 0; j + k[o] - 1 < (int)vec[o].size(); j++) {
ans[o] =
min(ans[o], vec[o][j + k[o] - 1] - vec[o][j] + (int)st[o].size());
}
vec[o].clear();
vec[o].resize(0);
vec[o].shrink_to_fit();
}
for (int j = 0; j < (int)g[i].size(); j++) {
mp[hs[g[i][j]]] = 0;
}
}
for (int i = 1; i <= m; i++) {
if (ans[i] == inf) ans[i] = -1;
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Trie {
static const int C = 26;
struct Node {
Node* ch[C];
T val;
Node() {
val = -1;
fill(ch, ch + C, nullptr);
}
};
Node* root;
char start;
Trie(char start = 'a') : start(start) { root = new Node(); }
void update(Node* node, T v) { node->val = max(node->val, v); }
void add(Node* node, int d, const string& S, T v) {
if (S.size() == d) {
update(node, v);
} else {
int c = S[d] - start;
if (!node->ch[c]) node->ch[c] = new Node();
add(node->ch[c], d + 1, S, v);
}
}
void add(const string& S, T v) { add(root, 0, S, v); }
T get(Node* node, int d, const string& S) {
if (S.size() == d) {
return node->val;
} else {
int c = S[d] - start;
return (node->ch[c] ? get(node->ch[c], d + 1, S) : -1);
}
}
T get(const string& S) { return get(root, 0, S); }
void getall(Node* node, int d, const string& S, vector<T>& ret) {
ret[d] = node->val;
if (d < S.size()) {
int c = S[d] - start;
if (node->ch[c]) getall(node->ch[c], d + 1, S, ret);
}
}
vector<T> getall(const string& S) {
vector<T> ret(S.size() + 1, -1);
getall(root, 0, S, ret);
return ret;
}
};
vector<int> z_algorithm(const vector<int>& S) {
int N = S.size(), c = 0;
vector<int> ret(N, 0);
for (int i = 1; i < N; i++) {
if (i + ret[i - c] < c + ret[c]) {
ret[i] = ret[i - c];
} else {
int j = max(0, c + ret[c] - i);
while (i + j < N && S[j] == S[i + j]) j++;
ret[i] = j;
c = i;
}
}
ret[0] = N;
return ret;
}
vector<int> z_algorithm(const string& S) {
int N = S.size();
vector<int> s(N);
for (int i = 0; i < N; i++) s[i] = S[i];
return z_algorithm(s);
}
vector<int> z_algorithm(string& A, string& B) {
string S = A + '!' + B;
auto z = z_algorithm(S);
vector<int> ret(B.size());
for (int i = 0; i < B.size(); i++) {
ret[i] = z[i + A.size() + 1];
}
return ret;
}
int main() {
string S;
cin >> S;
int L = S.size();
int N;
cin >> N;
vector<int> M(N);
vector<vector<int>> occur(N);
vector<string> K(N);
Trie<int> trie;
const int B = 300;
for (int i = 0; i < N; i++) {
cin >> M[i] >> K[i];
int sz = K[i].size();
if (sz >= B) {
auto z = z_algorithm(K[i], S);
for (int j = 0; j < L; j++)
if (z[j] == sz) occur[i].push_back(j);
} else {
trie.add(K[i], i);
}
}
for (int i = 0; i < L; i++) {
auto t = trie.getall(S.substr(i, B - 1));
for (int j : t)
if (j != -1) occur[j].push_back(i);
}
for (int i = 0; i < N; i++) {
int sz = occur[i].size(), ans;
if (sz < M[i]) {
ans = -1;
} else {
ans = 1e9;
for (int j = M[i] - 1; j < sz; j++)
ans = min(ans, occur[i][j] - occur[i][j - M[i] + 1] + (int)K[i].size());
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
struct Aho {
static const int ALPHABET = 26;
struct Node {
int suff = -1, dict = -1, depth = 0;
int word_index = -1;
int word_count = 0;
int link[ALPHABET];
Node() { fill(link, link + ALPHABET, -1); }
int& operator[](char c) { return link[c - 'a']; }
};
vector<Node> nodes;
int W;
vector<int> word_location;
vector<int> word_indices_by_depth;
vector<int> defer;
Aho(const vector<string>& words = {}) {
if (!words.empty()) build(words);
}
vector<vector<int>> build_suffix_adj() const {
vector<vector<int>> adj(nodes.size());
for (int i = 1; i < (int)nodes.size(); i++) adj[nodes[i].suff].push_back(i);
return adj;
}
int get_or_add_child(int current, char c) {
if (nodes[current][c] >= 0) return nodes[current][c];
int index = nodes.size();
nodes[current][c] = index;
nodes.emplace_back();
nodes.back().depth = nodes[current].depth + 1;
return index;
}
int add_word(const string& word, int word_index) {
assert(!nodes.empty());
int curr = 0;
for (char c : word) curr = get_or_add_child(curr, c);
if (nodes[curr].word_index < 0) nodes[curr].word_index = word_index;
nodes[curr].word_count++;
return curr;
}
int get_suffix_link(int location, char c) const {
if (location >= 0) location = nodes[location].link[c - 'a'];
return max(location, 0);
}
void build(const vector<string>& words) {
nodes = {Node()};
W = words.size();
word_location.resize(W);
defer.resize(W);
int max_depth = 0;
for (int i = 0; i < W; i++) {
word_location[i] = add_word(words[i], i);
max_depth = max(max_depth, int(words[i].size()));
defer[i] = nodes[word_location[i]].word_index;
}
word_indices_by_depth.resize(W);
vector<int> depth_freq(max_depth + 1, 0);
for (int i = 0; i < W; i++) depth_freq[words[i].size()]++;
for (int i = max_depth - 1; i >= 0; i--) depth_freq[i] += depth_freq[i + 1];
for (int i = 0; i < W; i++)
word_indices_by_depth[--depth_freq[words[i].size()]] = i;
vector<int> q = {0};
for (int i = 0; i < (int)q.size(); i++) {
int curr = q[i];
for (char c = 'a'; c < 'a' + ALPHABET; c++) {
int& index = nodes[curr][c];
if (index >= 0) {
int suffix_parent = get_suffix_link(nodes[curr].suff, c);
nodes[index].suff = suffix_parent;
nodes[index].word_count += nodes[suffix_parent].word_count;
nodes[index].dict = nodes[suffix_parent].word_index < 0
? nodes[suffix_parent].dict
: suffix_parent;
q.push_back(index);
} else
index = get_suffix_link(nodes[curr].suff, c);
}
}
}
vector<int> count_matches(const string& text) const {
vector<int> matches(W, 0);
int curr = 0;
for (char c : text) {
curr = get_suffix_link(curr, c);
int dict_node = nodes[curr].word_index < 0 ? nodes[curr].dict : curr;
if (dict_node >= 0) matches[nodes[dict_node].word_index]++;
}
for (int word_index : word_indices_by_depth) {
int location = word_location[word_index];
int dict_node = nodes[location].dict;
if (dict_node >= 0)
matches[nodes[dict_node].word_index] += matches[word_index];
}
for (int i = 0; i < W; i++) matches[i] = matches[defer[i]];
return matches;
}
vector<int> count_matches_by_position(const string& text) const {
vector<int> matches(text.size());
int curr = 0;
for (int i = 0; i < text.size(); i++) {
curr = get_suffix_link(curr, text[i]);
matches[i] = nodes[curr].word_count;
}
return matches;
}
int64_t count_total_matches(const string& text) const {
int64_t matches = 0;
int curr = 0;
for (char c : text) {
curr = get_suffix_link(curr, c);
matches += nodes[curr].word_count;
}
return matches;
}
vector<vector<int>> match_positions(const string& text) const {
vector<vector<int>> match_pos(W);
int curr = 0;
for (int i = 0; i < text.size(); i++) {
curr = get_suffix_link(curr, text[i]);
if (nodes[curr].word_index != -1)
match_pos[nodes[curr].word_index].push_back(i);
int dict_node = nodes[curr].dict;
while (dict_node > 0) {
match_pos[nodes[dict_node].word_index].push_back(i);
dict_node = nodes[dict_node].dict;
}
}
for (int i = 0; i < W; i++) match_pos[i] = match_pos[defer[i]];
return match_pos;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string S;
cin >> S;
int N;
cin >> N;
vector<int> k(N);
vector<string> m(N);
for (int i = 0; i < N; i++) cin >> k[i] >> m[i];
Aho aho(m);
vector<vector<int>> positions = aho.match_positions(S);
for (int i = 0; i < N; i++) {
int ans = 1e9;
for (int j = 0; j + k[i] - 1 < (int)positions[i].size(); j++)
ans = min(
ans, positions[i][j + k[i] - 1] + (int)m[i].size() - positions[i][j]);
if (ans == 1e9) ans = -1;
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using std ::lower_bound;
using std ::sort;
using std ::unique;
using std ::vector;
template <typename T>
T max(T x, T y) {
return (x > y) ? x : y;
}
template <typename T>
T min(T x, T y) {
return (x < y) ? x : y;
}
template <typename T>
bool chkmax(T &x, T y) {
return (x >= y) ? 0 : (x = y, 1);
}
template <typename T>
bool chkmin(T &x, T y) {
return (x <= y) ? 0 : (x = y, 1);
}
template <typename T>
T read(T &in) {
in = 0;
char ch;
T f = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
while (isdigit(ch)) in = in * 10 + ch - '0', ch = getchar();
return in *= f;
}
static const int max1 = 100000 + 11;
int q;
int k[max1], qlen[max1];
int dlen[max1], dl;
char InS[max1], S[max1], *T[max1];
vector<int> SolveAt[max1];
int ch[max1][26], fail[max1], At[max1], q_fail[max1], nd;
vector<int> App[max1];
void Insert(int id) {
int p = 0;
for (int i = (0), ir = (qlen[id] - 1); i <= (ir); ++i) {
int c = T[id][i] - 'a';
if (!ch[p][c]) ch[p][c] = ++nd;
p = ch[p][c];
}
At[p] = id;
}
void BuildFail() {
static int que[max1], *front, *back;
front = back = que;
for (int i = (0), ir = (25); i <= (ir); ++i)
if (ch[0][i]) *(++back) = ch[0][i], fail[ch[0][i]] = 0;
while (front != back) {
int x = *(++front);
q_fail[x] = At[fail[x]] ? fail[x] : q_fail[fail[x]];
for (int i = (0), ir = (25); i <= (ir); ++i)
if (ch[x][i]) {
int np = ch[x][i];
fail[np] = ch[fail[x]][i];
*(++back) = np;
} else
ch[x][i] = ch[fail[x]][i];
}
}
void solve() {
for (int i = (1), ir = (q); i <= (ir); ++i) Insert(i);
BuildFail();
static int n = strlen(S);
int p = 0;
for (int i = (0), ir = (n - 1); i <= (ir); ++i) {
p = ch[p][S[i] - 'a'];
for (int j = p; j; j = q_fail[j])
if (At[j]) App[At[j]].push_back(i);
}
}
int GetAns(int id) {
int k = ::k[id];
if ((int)App[id].size() < k) return -1;
int Ans = INT_MAX;
for (int i = (k - 1), ir = ((int)App[id].size() - 1); i <= (ir); ++i)
chkmin(Ans, App[id][i] - App[id][i - k + 1]);
return Ans + qlen[id];
}
int main() {
scanf("%s", S);
read(q);
for (int i = (1), ir = (q); i <= (ir); ++i) {
read(k[i]), scanf("%s", InS);
qlen[i] = strlen(InS);
T[i] = new char[qlen[i]];
memcpy(T[i], InS, sizeof(char) * qlen[i]);
dlen[++dl] = qlen[i];
}
solve();
for (int i = (1), ir = (q); i <= (ir); ++i) printf("%d\n", GetAns(i));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXL = 1e5 + 100;
char second[MAXL];
const int sizz = MAXL + 100;
int nx[sizz][26], spt = 1;
int fl[sizz], efl[sizz], ed[sizz];
int newnode(int len_ = 0) {
for (int i = 0; i < 26; i++) nx[spt][i] = 0;
ed[spt] = 0;
return spt++;
}
int add(char *s, int p, int id) {
int l = 1;
for (int i = 0; s[i]; i++) {
int a = s[i] - 'a';
(void)0;
if (nx[p][a] == 0) nx[p][a] = newnode(l);
p = nx[p][a];
l++;
}
ed[p] = id;
return p;
}
int q[sizz], qs, qe;
void make_fl(int root) {
fl[root] = efl[root] = 0;
qs = qe = 0;
q[qe++] = root;
for (; qs != qe;) {
int p = q[qs++];
for (int i = 0; i < 26; i++) {
int t = nx[p][i];
if (t == 0) continue;
int tmp = fl[p];
for (; tmp && nx[tmp][i] == 0;) tmp = fl[tmp];
fl[t] = tmp ? nx[tmp][i] : root;
efl[t] = ed[fl[t]] ? fl[t] : efl[fl[t]];
q[qe++] = t;
}
}
}
vector<int> at[MAXL];
void match(int root) {
int p = root;
for (int i = 1; second[i]; i++) {
int a = second[i] - 'a';
(void)0;
for (; p && nx[p][a] == 0; p = fl[p])
;
p = p ? nx[p][a] : root;
for (int t = p; t; t = efl[t]) {
if (!ed[t]) continue;
at[ed[t]].push_back(i);
}
}
}
int K[MAXL], length[MAXL];
char tmp[MAXL];
int main() {
scanf("%s", second + 1);
int N;
scanf("%d", &N);
int root = newnode();
for (int i = 1; i <= N; i++) {
scanf("%d", &K[i]);
scanf("%s", tmp);
int len = strlen(tmp);
length[i] = len;
add(tmp, root, i);
}
make_fl(root);
match(root);
for (int i = 1; i <= N; i++) {
(void)0;
if (((int)(at[i]).size()) < K[i]) {
puts("-1");
continue;
}
int ans = at[i][K[i] - 1] - at[i][0];
for (int j = K[i]; j < ((int)(at[i]).size()); j++)
ans = min(ans, at[i][j] - at[i][j - (K[i] - 1)]);
printf("%d\n", ans + length[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
const int INF = 1 << 30;
int q;
int req[N], len[N], ans[N];
string s;
vector<int> occ[N];
struct TAhoCorasick {
struct TNode {
int id = -1;
int p, link = -1;
int pch;
int a[26];
int go[26];
int jmp = -1;
int& operator[](int ch) { return a[ch]; }
TNode() {
fill(a, a + 26, 0);
fill(go, go + 26, -1);
}
};
vector<TNode> a;
void Insert(const string& s, int id) {
int cur = 0;
for (char ch : s) {
ch -= 'a';
if (!a[cur][ch]) {
a[cur][ch] = a.size();
a.push_back(TNode());
a.back().p = cur;
a.back().pch = ch;
}
cur = a[cur][ch];
}
a[cur].id = id;
}
int GetLink(int u) {
if (a[u].link == -1)
a[u].link = (u == 0 || a[u].p == 0 ? 0 : Go(GetLink(a[u].p), a[u].pch));
return a[u].link;
}
int Go(int u, int ch) {
if (a[u].go[ch] == -1)
if (a[u][ch])
a[u].go[ch] = a[u][ch];
else
a[u].go[ch] = (u == 0 ? 0 : Go(GetLink(u), ch));
return a[u].go[ch];
}
int GetOcc(int u) {
if (u == 0) return 0;
if (a[u].jmp == -1) a[u].jmp = (a[u].id == -1 ? GetOcc(GetLink(u)) : u);
return a[u].jmp;
}
TAhoCorasick() { a.assign(1, TNode()); }
} fsm;
int main() {
cin >> s >> q;
fill(ans + 1, ans + 1 + q, INF);
for (int i = 1; i <= q; ++i) {
string mi;
cin >> req[i] >> mi;
fsm.Insert(mi, i);
len[i] = mi.size();
}
int state = 0;
for (int i = 0; i < s.size(); ++i) {
state = fsm.Go(state, s[i] - 'a');
int tmp = fsm.GetOcc(state);
while (tmp > 0) {
int id = fsm.a[tmp].id;
occ[id].push_back(i);
if (occ[id].size() >= req[id])
ans[id] = min(ans[id], i - occ[id][occ[id].size() - req[id]] + len[id]);
tmp = fsm.GetOcc(fsm.GetLink(tmp));
}
}
for (int i = 1; i <= q; ++i) cout << (ans[i] == INF ? -1 : ans[i]) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template <class T, class T2>
inline bool chkmax(T &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class T2>
inline bool chkmin(T &x, const T2 &y) {
return x > y ? x = y, 1 : 0;
}
template <class T>
inline void sortl(T &a) {
sort(a.begin(), a.end());
}
template <class T>
inline void sortg(T &a) {
sort(a.begin(), a.end(), greater<int>());
}
template <class T, class T2>
inline istream &operator>>(istream &is, pair<T, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <class T, class T2>
inline ostream &operator<<(ostream &os, const pair<T, T2> &p) {
os << p.first << ' ' << p.second;
return os;
}
template <class T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &curr : v) is >> curr;
return is;
}
template <class T>
inline ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto curr : v) os << curr << ' ';
return os;
}
template <class T, class T2>
inline ostream &operator<<(ostream &os, const map<T, T2> &m) {
auto id = m.begin();
while (id != m.end()) os << (*id).first << ' ' << (*(id++)).second;
return os;
}
template <class T, class T2>
inline ostream &operator<<(ostream &os, const unordered_map<T, T2> &um) {
auto id = um.begin();
while (id != um.end()) os << (*id).first << ' ' << (*(id++)).second;
return os;
}
template <class T>
inline ostream &operator<<(ostream &os, const list<T> &l) {
auto id = l.begin();
while (id != l.end()) os << *(id++) << ' ';
return os;
}
template <class T>
inline ostream &operator<<(ostream &os, const set<T> &second) {
auto id = second.begin();
while (id != second.end()) os << *(id++) << ' ';
return os;
}
template <class T>
inline ostream &operator<<(ostream &os, const unordered_set<T> &us) {
auto id = us.begin();
while (id != us.end()) os << *(id++) << ' ';
return os;
}
template <class T>
inline ostream &operator<<(ostream &os, const multiset<T> &ms) {
auto id = ms.begin();
while (id != ms.end()) os << *(id++) << ' ';
return os;
}
template <class T>
inline ostream &operator<<(ostream &os, const unordered_multiset<T> &mus) {
auto id = mus.begin();
while (id != mus.end()) os << *(id++) << ' ';
return os;
}
template <class T>
inline void inArray(T a[], const int &n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <class T>
inline void outArray(T a[], const int &n) {
for (int i = 0; i < n; i++) cout << a[i] << ' ';
}
const bool hasTests = 0;
struct node {
int par, link;
int key;
vector<int> ch, go;
vector<int> eow;
node(int par, int key) : par(par), key(key) {
link = 0;
ch.resize(26, 0);
};
};
vector<node> tr;
vector<queue<int>> app;
vector<int> need, sz;
vector<int> ans;
string second;
int n;
void addString(string &second, int k) {
int curr = 0;
for (char ch : second) {
int c = ch - 'a';
if (!tr[curr].ch[c]) {
tr[curr].ch[c] = ((int)tr.size());
tr[curr].go.push_back(((int)tr.size()));
tr.emplace_back(curr, c);
}
curr = tr[curr].ch[c];
}
tr[curr].eow.push_back(k);
}
void input() {
cin >> second >> n;
app.resize(n);
need.resize(n);
sz.resize(n);
ans.resize(n, ((int)second.size()) + 1);
tr.emplace_back(0, -1);
string temps;
for (int i = 0; i < n; i++) {
cin >> need[i] >> temps;
sz[i] = ((int)temps.size());
addString(temps, i);
}
}
void output() {
for (int i = 0; i < n; i++) {
if (ans[i] == ((int)second.size()) + 1) {
cout << "-1\n";
} else {
cout << ans[i] + sz[i] << '\n';
}
}
}
void findLink(int u) {
if (tr[u].par == 0) {
return;
}
int p = tr[tr[u].par].link;
int c = tr[u].key;
while (p && !tr[p].ch[c]) {
p = tr[p].link;
}
tr[u].link = tr[p].ch[c];
}
void findEndingWords(int u) {
int v = tr[u].link;
for (auto w : tr[v].eow) {
tr[u].eow.push_back(w);
}
}
void pushLinks() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
findLink(u);
findEndingWords(u);
for (auto v : tr[u].go) {
q.push(v);
}
}
}
void endingIn(int w, int pos) {
app[w].push(pos);
if (app[w].size() > need[w]) {
app[w].pop();
}
if (app[w].size() == need[w]) {
chkmin(ans[w], pos - app[w].front());
}
}
void solve() {
pushLinks();
int p = 0;
for (int i = 0; i < ((int)second.size()); i++) {
int c = second[i] - 'a';
while (p && !tr[p].ch[c]) {
p = tr[p].link;
}
p = tr[p].ch[c];
for (auto w : tr[p].eow) {
endingIn(w, i);
}
}
}
void start() {
int t = 1;
if (hasTests) cin >> t;
for (int i = 1; i <= t; i++) {
input();
solve();
output();
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
start();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.