text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n;
string a;
string b, revb;
int dp[4307];
pair<int, int> prv[4307];
pair<int, int> cur;
int PI[4307];
int f(int st, int id) {
string c;
c.clear();
int i;
for (i = st; i < n; i++) {
c += a[i];
}
c += '#';
int sz = b.size();
for (i = 0; i < sz; i++) {
if (id == 0) {
c += b[i];
} else {
c += revb[i];
}
}
sz = c.size();
PI[0] = PI[1] = 0;
int l = 0;
int mx = 0;
for (i = 2; i <= sz; i++) {
while (c[l] != c[i - 1] && l != 0) {
l = PI[l];
}
if (c[l] == c[i - 1]) {
l++;
}
PI[i] = l;
if (i >= n - st + 2 && mx < PI[i]) {
mx = PI[i];
int fr = (i - PI[i] + 1) - (n - st) - 2;
int en = i - (n - st) - 2;
if (id == 1) {
fr = b.size() - fr - 1;
en = b.size() - en - 1;
}
cur = make_pair(fr, en);
}
}
return (st + mx);
}
void input() {
cin >> b;
int sz = b.size();
int i;
for (i = sz - 1; i >= 0; i--) {
revb += b[i];
}
cin >> a;
n = a.size();
}
void solve() {
int i;
for (i = 1; i <= n; i++) {
dp[i] = 2 * 4307;
}
dp[0] = 0;
for (i = 0; i < n; i++) {
if (dp[i] == 4307) {
continue;
}
int id;
id = f(i, 0);
if (dp[id] > dp[i] + 1) {
dp[id] = dp[i] + 1;
prv[id] = cur;
}
id = f(i, 1);
if (dp[id] > dp[i] + 1) {
dp[id] = dp[i] + 1;
prv[id] = cur;
}
}
if (dp[n] > n) {
cout << "-1\n";
} else {
cout << dp[n] << "\n";
vector<pair<int, int> > v;
int where = n;
while (where != 0) {
v.push_back(prv[where]);
where = where - (abs(prv[where].second - prv[where].first) + 1);
}
for (i = dp[n] - 1; i >= 0; i--) {
cout << v[i].first + 1 << " " << v[i].second + 1 << "\n";
}
}
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long MOD = 1e9 + 7;
const long long M = 1e18;
long long qpow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
int ct[26];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) {
string ss, t;
cin >> ss >> t;
string s1 = ss;
reverse(s1.begin(), s1.end());
for (int i = 0; i < ss.length(); i++) ct[ss[i] - 'a']++;
for (int i = 0; i < t.length(); i++) {
if (ct[t[i] - 'a'] == 0) {
cout << -1;
return 0;
}
}
int m = t.length(), n = ss.length();
vector<pair<int, int> > v;
int j, idx, mx_len, cur_len;
bool ok = true;
int lcp[m + 1][n + 1], lcp1[m + 1][n + 1];
for (int i = 0; i <= m; i++)
for (int j = 0; j <= n; j++) lcp[i][j] = 0, lcp1[i][j] = 0;
for (int i = m - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--)
if (ss[j] == t[i]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
for (int i = m - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--)
if (s1[j] == t[i]) lcp1[i][j] = lcp1[i + 1][j + 1] + 1;
}
for (int i = 0; i < m;) {
int i1 = i;
j = 0;
mx_len = 0;
cur_len = 0;
ok = true;
for (int l = 0; l < n; l++) {
if (lcp[i][l] > mx_len) {
mx_len = lcp[i][l];
idx = l;
}
}
for (int l = 0; l < s1.length(); l++) {
if (lcp1[i][l] > mx_len) {
mx_len = lcp1[i][l];
idx = l;
ok = false;
}
}
if (ok) {
v.push_back({idx + 1, idx + mx_len});
} else {
v.push_back({n - idx, n - (idx + mx_len - 1)});
}
i += mx_len;
}
cout << v.size() << "\n";
for (pair<int, int> p : v) cout << p.first << " " << p.second << "\n";
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string S;
string G;
void Input() { cin >> S >> G; }
bool Check() {
set<char> s;
for (char c : S) s.insert(c);
for (char c : G)
if (!s.count(c)) return false;
return true;
}
struct TrieNode {
TrieNode* childs[26];
TrieNode() {
for (int i = 0; i < 26; i++) {
childs[i] = nullptr;
}
}
};
int Index(const string& s, int k) { return s[k] - 'a'; }
TrieNode* Child(TrieNode* node, const string& s, int k) {
return node->childs[Index(s, k)];
}
TrieNode* InsertTrie(TrieNode* node, int k, int n, const string& s) {
if (node == nullptr) {
node = new TrieNode();
}
if (k == n) return node;
int index = Index(s, k);
node->childs[index] = InsertTrie(node->childs[index], k + 1, n, s);
return node;
}
int MaxLength(TrieNode* node, int a, bool inorder) {
if (inorder) {
int length = 0;
for (int i = a; i < G.size(); i++) {
TrieNode* next = node->childs[Index(G, i)];
if (!next) {
return length;
} else {
length++;
node = next;
}
}
return length;
} else {
int length = 0;
for (int i = a; i >= 0; i--) {
TrieNode* next = node->childs[Index(G, i)];
if (!next) {
return length;
} else {
length++;
node = next;
}
}
return length;
}
}
void Solve() {
int N = G.size();
if (!Check()) {
cout << -1 << endl;
return;
}
TrieNode* root = new TrieNode();
for (int i = 0; i < S.size(); i++) {
string prefix = S.substr(0, i);
string suffix = S.substr(i);
if (prefix.size() > 0) {
InsertTrie(root, 0, prefix.size(), prefix);
reverse(prefix.begin(), prefix.end());
InsertTrie(root, 0, prefix.size(), prefix);
}
if (suffix.size() > 0) {
InsertTrie(root, 0, suffix.size(), suffix);
reverse(suffix.begin(), suffix.end());
InsertTrie(root, 0, suffix.size(), suffix);
}
}
int res = 0;
int cur = 0;
vector<string> V;
while (cur < N) {
int len = MaxLength(root, cur, true);
V.push_back(G.substr(cur, len));
cur += len;
res++;
}
cout << res << endl;
for (string& v : V) {
auto p = S.find(v);
if (p != string::npos) {
cout << p + 1 << " " << p + v.size() << endl;
continue;
}
reverse(v.begin(), v.end());
p = S.find(v);
if (p != string::npos) {
cout << p + v.size() << " " << p + 1 << endl;
continue;
}
}
}
int main() {
Input();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pcnt[27], tcnt[27], lps[2111];
string pat, text, rtext;
pair<int, int> kmpsearch(string txt) {
int M = pat.length();
int N = txt.length();
int mx = 0;
int j = 0, pos;
int i = 0;
while (i < N) {
if (pat[j] == txt[i]) {
j++;
i++;
}
if (j > mx) {
mx = j;
pos = i - 1;
}
if (j == M) {
break;
} else if (i < N && pat[j] != txt[i]) {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
}
return {pos, mx};
}
void countLPS(string pat) {
int len = 0;
int i;
int M = pat.length();
lps[0] = 0;
i = 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
int main() {
cin >> text >> pat;
rtext = text;
reverse(rtext.begin(), rtext.end());
for (int i = 0; i < text.length(); i++) tcnt[text[i] - 'a']++;
for (int i = 0; i < pat.length(); i++) pcnt[pat[i] - 'a']++;
for (int i = 0; i < 26; i++) {
if (pcnt[i] > 0 && tcnt[i] == 0) {
cout << "-1" << endl;
return 0;
}
}
int hlen = pat.length();
pair<int, int> data;
vector<pair<int, int> > range;
while (hlen > 0) {
countLPS(pat);
data = kmpsearch(text);
int nlen = data.second;
int np = data.first;
data = kmpsearch(rtext);
int rlen = data.second;
int rp = data.first;
if (nlen >= rlen) {
hlen -= nlen;
range.push_back({np - nlen + 1, np});
if (pat.length() > 0) pat = pat.substr(nlen);
} else {
hlen -= rlen;
int sp = rp - rlen + 1;
sp = text.length() - sp - 1;
int ep = rp;
ep = text.length() - ep - 1;
range.push_back({sp, ep});
if (pat.length() > 0) pat = pat.substr(rlen);
}
}
cout << range.size() << endl;
for (auto i : range) {
cout << i.first + 1 << " " << i.second + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const long long int mod = 1e9 + 7;
const long long int inf = 1e16;
int fail[N], x[N], ind[N];
bool mark[N];
vector<pair<int, int>> ans;
inline void KMP(string &second, string &p, int l, bool bol) {
int match = 0, n = second.size(), m = p.size();
for (int i = 1; i < m; i++) {
while (match > 0 && p[match] != p[i]) match = fail[match];
match += (p[match] == p[i]);
fail[i + 1] = match;
if (match == m) match = fail[match];
}
match = 0;
for (int i = 0; i < n; i++) {
while (match > 0 && p[match] != second[i]) match = fail[match];
match += (p[match] == second[i]);
if (x[i] < match) {
x[i] = match;
ind[i] = l;
mark[i] = bol;
}
if (match == m) match = fail[match];
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string second, t;
cin >> second >> t;
int n = second.size(), m = t.size();
for (int i = 0; i < n; i++) {
string p;
for (int j = i; j < n; j++) p += second[j];
KMP(t, p, i, 1);
}
reverse(second.begin(), second.end());
for (int i = 0; i < n; i++) {
string p;
for (int j = i; j < n; j++) p += second[j];
KMP(t, p, n - i - 1, 0);
}
for (int i = 0; i < m; i++) {
if (x[i] == 0) {
cout << -1 << endl;
return 0;
}
}
int k = m - 1;
while (k >= 0) {
int l = ind[k];
if (mark[k])
ans.push_back({l + 1, l + x[k]});
else
ans.push_back({l + 1, l - x[k] + 2});
k = k - x[k];
}
cout << ans.size() << endl;
reverse(ans.begin(), ans.end());
for (auto it : ans) cout << it.first << ' ' << it.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int longest_substr_prefix(string s, string pat) {
string t = s + "#" + pat;
int n = t.size();
vector<int> z(n, 0);
int zl = 0, zr = 0;
for (int i = 1; i < n; i++) {
if (zr <= i)
z[i] = 0;
else
z[i] = min(z[i - zl], zr - i);
while (i + z[i] < n && t[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] > zr) {
zl = i;
zr = i + z[i];
}
}
int ans = 0;
for (int i = s.size(); i < n; i++) ans = max(ans, z[i]);
return ans;
}
pair<int, int> exact_match(string s, string t) {
for (int i = 0; (size_t)i + s.size() <= t.size(); i++)
if (t.substr(i, s.size()) == s) return make_pair(i + 1, i + s.size());
return make_pair(-1, -1);
}
int main() {
string s, t;
cin >> s >> t;
int n = t.size();
vector<int> dp(n + 1, 0);
string rs = s, rt = t;
reverse(rs.begin(), rs.end());
reverse(rt.begin(), rt.end());
vector<int> last(n + 1, 0);
vector<bool> last_dir(n + 1, false);
for (int i = 1; i < n + 1; i++) {
dp[i] = 1791791791;
int flp = longest_substr_prefix(rt.substr(n - i, i), s);
int slp = longest_substr_prefix(rt.substr(n - i, i), rs);
int lp = max(flp, slp);
for (int j = i - lp; j < i; j++) {
if (dp[i] > dp[j] + 1) {
last[i] = j;
last_dir[i] = flp > slp;
}
dp[i] = min(dp[i], dp[j] + 1);
}
}
if (dp[n] > n) {
cout << -1 << endl;
return 0;
}
cout << dp[n] << endl;
vector<pair<int, int> > answ;
int cur = n;
while (cur > 0) {
int i = cur;
if (last_dir[cur]) {
auto p = exact_match(t.substr(last[i], i - last[i]), rs);
answ.push_back(
make_pair(s.size() - p.first + 1, s.size() - p.second + 1));
} else {
answ.push_back(exact_match(t.substr(last[i], i - last[i]), s));
}
cur = last[i];
}
reverse(answ.begin(), answ.end());
for (auto p : answ) cout << p.first << " " << p.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[3001], c[3001];
int f1[3001][3001], f2[3001][3001];
char t1[3001], t2[3001];
int r1[3001], r2[3001], tot = 0;
inline void init() {
scanf("%s%s", &t1, &t2);
n = strlen(t1);
m = strlen(t2);
for (int i = 1; i <= n; i++) a[i] = t1[i - 1] - '0';
for (int i = 1; i <= m; i++) c[i] = t2[i - 1] - '0';
for (int i = m; i >= 1; i--)
for (int j = n; j >= 1; j--)
if (a[j] == c[i]) f1[i][j] = f1[i + 1][j + 1] + 1;
for (int i = m; i >= 1; i--)
for (int j = n; j >= 1; j--)
if (a[j] == c[i]) f2[i][j] = f2[i + 1][j - 1] + 1;
for (int i = 1, s, t, ans; i <= m;) {
s = 1;
t = 1;
for (int j = 1; j <= n; j++)
if (f1[i][j] > f1[i][s]) s = j;
for (int j = 1; j <= n; j++)
if (f2[i][j] > f2[i][t]) t = j;
ans = max(f1[i][s], f2[i][t]);
if (ans == 0) {
cout << "-1";
return;
}
if (f1[i][s] > f2[i][t]) {
r1[++tot] = s;
r2[tot] = s + f1[i][s] - 1;
} else {
r1[++tot] = t;
r2[tot] = t - f2[i][t] + 1;
}
i += ans;
}
cout << tot << endl;
for (int i = 1; i <= tot; i++) cout << r1[i] << " " << r2[i] << endl;
}
int main() {
init();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
char a[2102], b[2102];
int ans1[2102], ans2[2102], cnt, s, e, flag = 0;
scanf("%s%s", a, b);
int len1, len2, i, j, len;
len1 = strlen(a);
len2 = strlen(b);
memset(ans1, 0, sizeof(ans1));
memset(ans2, 0, sizeof(ans2));
cnt = 0;
for (i = 0; i < len2; i++) {
len = 0;
flag = 0;
for (j = 0; j < len1; j++) {
if (b[i] == a[j]) {
flag = 1;
s = j;
e = j;
for (int k = 1; j + k < len1 && i + k < len2; k++) {
if (a[j + k] == b[i + k])
e++;
else
break;
}
if (e - s + 1 > len) {
len = e - s + 1;
ans1[cnt] = s + 1;
ans2[cnt] = e + 1;
}
s = j;
e = j;
for (int k = 1; j - k >= 0 && i + k < len2; k++) {
if (a[j - k] == b[i + k])
e--;
else
break;
}
if (s - e + 1 > len) {
len = s - e + 1;
ans1[cnt] = s + 1;
ans2[cnt] = e + 1;
}
}
}
if (!flag) break;
cnt++;
i += len - 1;
}
if (!flag)
printf("-1\n");
else {
printf("%d\n", cnt);
for (int m = 0; m < cnt; m++) printf("%d %d\n", ans1[m], ans2[m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> z_function(string s) {
int n = (int)s.size();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int main() {
string have, need;
cin >> have >> need;
vector<pair<int, int> > ans;
bool cant = false;
while (need.size()) {
int best = 0, start, end;
bool is_reversed = false;
string aux = have;
reverse(aux.begin(), aux.end());
vector<int> ans1 = z_function(need + have);
vector<int> ans2 = z_function(need + aux);
for (int i = (int)need.size(); i < ans1.size(); i++) {
if (ans1[i] > best) {
start = i - need.size();
end = i + ans1[i] - need.size();
best = ans1[i];
}
}
for (int i = (int)need.size(); i < ans2.size(); i++) {
if (ans2[i] > best) {
start = i - need.size();
end = i + ans2[i] - need.size();
best = ans2[i];
is_reversed = true;
}
}
if (best == 0) {
cant = true;
break;
} else {
if (end - start >= need.size()) end = start + need.size();
best = min(best, (int)have.size());
best = min(best, (int)need.size());
need = need.substr(best);
if (!is_reversed)
ans.push_back(pair<int, int>(start + 1, end));
else
ans.push_back(
pair<int, int>(have.size() - start, have.size() - end + 1));
}
}
if (cant)
puts("-1");
else {
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct trie {
int l, r;
trie *a[26];
trie() {
for (int i = 0; i < 26; i++) a[i] = NULL;
l = r = -1;
}
};
trie *root = new trie();
int dp[22222];
pair<int, int> seg[22222];
int pre[22222];
void ins(string s, int beg, int tip) {
trie *t = root;
int n = s.size();
int e = beg, w = beg;
for (int i = 0; i < n; i++, e++, w--) {
if (t->a[s[i] - 'a'] == NULL) {
t->a[s[i] - 'a'] = new trie();
t->a[s[i] - 'a']->l = beg;
t->a[s[i] - 'a']->r = (tip ? e : w);
}
t = t->a[s[i] - 'a'];
}
}
int main() {
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
for (int i = 0; i < n; i++) {
string p = "";
for (int j = i; j < n; j++) {
p += s[j];
}
ins(p, i, 1);
}
for (int i = n - 1; i + 1; i--) {
string p = "";
for (int j = i; j + 1; j--) {
p += s[j];
}
ins(p, i, 0);
}
for (int i = 0; i < m; i++) {
dp[i] = -1;
trie *p = root;
for (int j = i; j + 1; j--) {
if (p->a[t[j] - 'a'] == NULL) break;
p = p->a[t[j] - 'a'];
if (j && dp[j - 1] == -1) continue;
int can = (j ? dp[j - 1] : 0) + 1;
if (can < dp[i] || dp[i] == -1) {
dp[i] = can;
seg[i] = make_pair(p->l, p->r);
pre[i] = j - 1;
}
}
}
int ans = dp[m - 1];
cout << ans << endl;
if (ans == -1) return 0;
vector<pair<int, int> > sol;
int x = m - 1;
while (x >= 0) {
sol.push_back(seg[x]);
x = pre[x];
}
for (int i = sol.size() - 1; i + 1; i--)
cout << sol[i].second + 1 << " " << sol[i].first + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e8;
const int MAXN = 3005;
char cad[MAXN];
int memo[MAXN];
char cad2[MAXN];
char cad3[MAXN];
int len;
int len2;
long long int h[MAXN];
long long int p[MAXN];
long long int p2[MAXN];
long long int h_[MAXN];
long long int p_[MAXN];
long long int p2_[MAXN];
long long int pot[MAXN];
long long int pot2[MAXN];
pair<long long int, long long int> H(int ini, int fin) {
if (fin + 1 == len2)
return pair<long long int, long long int>(h[ini], h_[ini]);
return pair<long long int, long long int>(
h[ini] - h[fin + 1] * pot[fin - ini + 1],
h_[ini] - h_[fin + 1] * pot2[fin - ini + 1]);
}
pair<long long int, long long int> P(int ini, int fin) {
if (fin + 1 == len)
return pair<long long int, long long int>(p[ini], p_[ini]);
return pair<long long int, long long int>(
p[ini] - p[fin + 1] * pot[fin - ini + 1],
p_[ini] - p_[fin + 1] * pot2[fin - ini + 1]);
}
pair<long long int, long long int> P2(int ini, int fin) {
if (fin + 1 == len)
return pair<long long int, long long int>(p2[ini], p2_[ini]);
return pair<long long int, long long int>(
p2[ini] - p2[fin + 1] * pot[fin - ini + 1],
p2_[ini] - p2_[fin + 1] * pot2[fin - ini + 1]);
}
int busbin(int a, int b, int a1, int b1) {
if (cad2[a1] != cad[a]) return -1;
int fin = min(b - a, b1 - a1);
int ini = 0;
while (ini < fin) {
int med = (ini + fin) / 2;
if (H(a1, a1 + med) != P(a, a + med))
fin = med - 1;
else if (med + 1 <= fin && H(a1, a1 + med + 1) != P(a, a + med + 1))
return a1 + med + 1;
else
ini = med + 1;
}
return a1 + ini + 1;
}
int busbin2(int a, int b, int a1, int b1) {
if (cad2[a1] != cad3[a]) return -1;
int fin = min(b - a, b1 - a1);
int ini = 0;
while (ini < fin) {
int med = (ini + fin) / 2;
if (H(a1, a1 + med) != P2(a, a + med))
fin = med - 1;
else if (med + 1 <= fin && H(a1, a1 + med + 1) != P2(a, a + med + 1))
return a1 + med + 1;
else
ini = med + 1;
}
return a1 + ini + 1;
}
int DP(int id) {
if (id == len2) return memo[id] = 0;
if (memo[id] != -1) return memo[id];
int res = INF;
for (int i = 0; i < len; i++) {
int a = busbin(i, len - 1, id, len2 - 1);
if (a != -1) res = min(res, DP(a) + 1);
if (a == len2) return memo[id] = res;
}
for (int i = 0; i < len; i++) {
int a = busbin2(i, len - 1, id, len2 - 1);
if (a != -1) res = min(res, DP(a) + 1);
if (a == len2) return memo[id] = res;
}
return memo[id] = res;
}
int Inversa(int a) { return len - a - 1; }
void DP2(int id) {
if (id == len2) return;
for (int i = 0; i < len; i++) {
int a = busbin(i, len - 1, id, len2 - 1);
if (a != -1 && memo[id] == memo[a] + 1) {
int len = a - id - 1;
printf("%d %d\n", i + 1, i + len + 1);
DP2(a);
return;
}
}
for (int i = 0; i < len; i++) {
int a = busbin2(i, len - 1, id, len2 - 1);
if (a != -1 && memo[id] == memo[a] + 1) {
int len = a - id - 1;
printf("%d %d\n", Inversa(i) + 1, Inversa(i + len) + 1);
DP2(a);
return;
}
}
}
int main() {
pot[0] = 1;
for (int i = 1; i < MAXN; i++) pot[i] = pot[i - 1] * 257;
pot2[0] = 1;
for (int i = 1; i < MAXN; i++) pot2[i] = pot2[i - 1] * 131;
scanf("\n%s", cad);
scanf("\n%s", cad2);
len = strlen(cad);
for (int i = len - 1; i >= 0; i--) {
cad3[i] = cad[i];
if (i == len - 1)
p[i] = cad[i];
else
p[i] = p[i + 1] * 257 + cad[i];
}
for (int i = len - 1; i >= 0; i--)
if (i == len - 1)
p_[i] = cad[i];
else
p_[i] = p_[i + 1] * 131 + cad[i];
reverse(cad3, cad3 + len);
for (int i = len - 1; i >= 0; i--)
if (i == len - 1)
p2[i] = cad3[i];
else
p2[i] = p2[i + 1] * 257 + cad3[i];
len2 = strlen(cad2);
for (int i = len2 - 1; i >= 0; i--)
if (i == len2 - 1)
h[i] = cad2[i];
else
h[i] = h[i + 1] * 257 + cad2[i];
for (int i = len - 1; i >= 0; i--)
if (i == len - 1)
p2_[i] = cad3[i];
else
p2_[i] = p2_[i + 1] * 131 + cad3[i];
for (int i = len2 - 1; i >= 0; i--)
if (i == len2 - 1)
h_[i] = cad2[i];
else
h_[i] = h_[i + 1] * 131 + cad2[i];
fill(memo, memo + len2, -1);
int res = DP(0);
if (res == INF) {
printf("-1\n");
return 0;
}
printf("%d\n", res);
DP2(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int lcp[4203][2101];
int main() {
string s1, s2, s3;
cin >> s1 >> s2;
s3 = s1;
s3.push_back('$');
reverse(s1.begin(), s1.end());
s3.append(s1);
int len1 = s3.size();
int len2 = s2.size();
int len3 = s1.size();
for (int i = len1 - 1; i >= 0; i--) {
for (int j = len2 - 1; j >= 0; j--) {
if (s3[i] == s2[j]) lcp[i][j] = 1 + lcp[i + 1][j + 1];
}
}
vector<pair<int, int>> ans;
int size = 0;
for (int idx = 0; idx < len2;) {
int maxi = 0, maxpos;
for (int i = 0; i < len1; i++) {
if (maxi < lcp[i][idx]) {
maxi = lcp[i][idx];
maxpos = i;
}
}
if (maxi == 0) {
printf("-1\n");
return 0;
}
if (maxpos < len3)
ans.push_back(make_pair(maxpos + 1, maxpos + maxi));
else
ans.push_back(make_pair(len1 - maxpos, len1 - (maxpos + maxi) + 1));
idx += maxi;
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
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);
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
using namespace std;
string s, t, rs;
bool isins[256];
bool isint[256];
vector<pair<int, int> > ans;
void solve(int u) {
if (u >= t.size()) return;
int l = u, r = t.size() - 1;
int res = 0, tt;
pair<int, int> temp;
string str;
while (l <= r) {
int m = (l + r) / 2;
str = t.substr(u, m - u + 1);
if ((tt = s.find(str)) != -1) {
temp = make_pair(tt, tt + m - u);
res = m;
l = m + 1;
} else if ((tt = rs.find(str)) != -1) {
temp = make_pair(s.size() - tt, s.size() - (tt + m - u));
res = m;
l = m + 1;
} else
r = m - 1;
}
ans.push_back(temp);
solve(res + 1);
}
int main() {
cin >> s >> t;
rs = s;
s = '0' + s;
reverse(rs.begin(), rs.end());
rs = '0' + rs;
t = '0' + t;
for (int i = 1; i < s.size(); i++) isins[s[i]] = 1;
for (int i = 1; i < t.size(); i++)
if (!isins[t[i]]) {
puts("-1");
return 0;
}
solve(1);
writeln(ans.size());
for (int i = 0; i < ans.size(); i++) {
write(ans[i].first);
putchar(' ');
writeln(ans[i].second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 5;
string s, t;
string srev;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s >> t;
srev = s;
reverse(srev.begin(), srev.end());
vector<pair<int, int>> ans;
while (t.size()) {
int n = t.size();
int i = 0;
string buf;
for (i = 1; i <= n; i++) {
string cur = t.substr(0, i);
if (s.find(cur) == string::npos && srev.find(cur) == string::npos) {
break;
} else {
buf = cur;
}
}
if (i == 1) out(-1);
if (s.find(buf) != string::npos) {
int l = s.find(buf);
int r = l + (int)buf.length() - 1;
ans.push_back({l + 1, r + 1});
} else {
int l = srev.find(buf);
int r = l + (int)buf.length() - 1;
int N = s.length();
l = N - l - 1;
r = N - r - 1;
ans.push_back({l + 1, r + 1});
}
t = t.substr(i - 1);
}
cout << ans.size() << endl;
for (auto p : ans) {
cout << p.first << " " << p.second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2500;
int dp1[N][N];
int dp2[N][N];
vector<pair<int, int> > v;
char s[N], t[N];
int main() {
scanf("%s%s", s + 1, t + 1);
int n = strlen(s + 1), m = strlen(t + 1);
int i, j;
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++) {
if (s[j] == t[i]) {
dp1[i][j] = max(dp1[i][j], dp1[i - 1][j - 1] + 1);
}
}
for (i = 1; i <= m; i++)
for (j = n; j >= 1; j--) {
if (s[j] == t[i]) dp2[i][j] = max(dp2[i][j], dp2[i - 1][j + 1] + 1);
}
int mx = 0, l, r;
for (i = m; i >= 1;) {
mx = 0;
for (j = 1; j <= n; j++) {
if (mx < dp1[i][j]) {
mx = dp1[i][j];
l = j - mx + 1;
r = j;
}
}
for (j = 1; j <= n; j++) {
if (dp2[i][j] > mx) {
mx = dp2[i][j];
l = j + mx - 1;
r = j;
}
}
if (mx == 0) {
break;
}
v.push_back(make_pair(l, r));
i -= mx;
}
if (i >= 1) {
puts("-1");
} else {
pair<int, int> p;
cout << v.size() << endl;
while (v.size()) {
p = *v.rbegin();
cout << p.first << " " << p.second << endl;
v.pop_back();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
string r = s;
reverse(r.begin(), r.end());
s = s + "#" + r;
t = t + "$";
vector<int> space;
vector<pair<int, int>> soln;
int covered = 0;
for (int j = 0, length = 0; j < t.length(); j++) {
if (space.empty()) {
for (int k = 0; k < s.length(); k++) {
space.push_back(k - 1);
}
length = 0;
}
vector<int> newspace;
for (int k : space) {
if (k + 1 < s.length() && s[k + 1] == t[j]) {
newspace.push_back(k + 1);
}
}
if (newspace.empty()) {
if (length == 0) {
break;
} else {
int x = space.back() - length + 2, y = space.back() + 1;
if (x > r.length()) {
soln.emplace_back(s.length() - x + 1, s.length() - y + 1);
} else {
soln.emplace_back(x, y);
}
covered += length;
j--;
}
} else {
length++;
}
space = newspace;
}
if (covered + 1 == t.length()) {
cout << soln.size() << endl;
for (auto p : soln) {
cout << p.first << ' ' << p.second << endl;
}
} else {
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
const double eps = 1e-10;
const long long N = 2e5 + 7;
const long long MOD = 1e9 + 7;
long long pw(long long b, long long p) {
b %= MOD;
long long res = 1;
while (p > 0) {
if (p & 1) res = res * b % MOD;
b = b * b % MOD;
p >>= 1;
}
return res;
}
long long lcp[2500][2500];
long long lcpRev[2500][2500];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
long long n = s.size(), m = t.size();
s = "!" + s + "@";
t = "#" + t + "$";
for (long long i = m; i >= 1; i--) {
for (long long j = n; j >= 1; j--) {
if (t[i] == s[j]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
}
for (long long j = 1; j < n + 1; j++) {
if (t[i] == s[j]) {
lcpRev[i][j] = lcpRev[i + 1][j - 1] + 1;
}
}
}
vector<pair<long long, long long> > ans;
for (long long i = 1; i < m + 1; i++) {
long long x = max_element(lcp[i] + 1, lcp[i] + n + 1) - lcp[i];
long long y = max_element(lcpRev[i] + 1, lcpRev[i] + n + 1) - lcpRev[i];
long long l = max(lcp[i][x], lcpRev[i][y]);
if (!l) {
cout << -1;
return 0;
}
if (l == lcp[i][x])
ans.emplace_back(x, x + l - 1);
else
ans.emplace_back(y, y - l + 1);
i += l - 1;
}
cout << ans.size() << '\n';
for (auto i : ans) cout << i.first << ' ' << i.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BM(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T MDINV(T a, T M) {
return BM(a, M - 2, M);
}
template <class T>
inline T PW(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
string NTS(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <class T>
T stringtonumber(const string &Text) {
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
template <class T>
bool ISLEFT(T a, T b, T c) {
if (((a.first - b.first) * (b.second - c.second) -
(b.first - c.first) * (a.second - b.second)) < 0.0)
return 1;
else
return 0;
}
char a[4400];
long long int z[4400];
void zalgo() {
long long int l, r;
l = r = 0;
z[0] = strlen(a);
for (long long int i = 1; i < z[0]; i++) {
if (i > r) {
l = r = i;
for (long long int j = i; j < z[0]; j++) {
if (a[j - i] != a[j])
break;
else
r = j;
}
if (a[i] != a[0])
z[i] = 0;
else
z[i] = r - l + 1;
} else {
long long int k = i - l;
if (z[k] < r - i + 1) {
z[i] = z[k];
} else {
l = i;
for (long long int j = r + 1; j < z[0]; j++) {
if (a[j - l] != a[j])
break;
else
r = j;
}
z[i] = r - l + 1;
}
}
}
}
int main() {
string s, s1;
cin >> s >> s1;
int st = 0;
vector<pair<int, int> > v;
int sz = s1.size();
int sd = s.size();
while (st < sz) {
int len = -1;
for (int i = st; i < sz; i++) a[++len] = s1[i];
int ans = len + 1;
for (int j = 0; j < sd; j++) a[++len] = s[j];
a[++len] = '\0';
zalgo();
int x = 0, y = 0, sum = 0;
for (int i = ans; i < len; i++) {
if (z[i] > ans) z[i] = ans;
if (z[i] > sum) {
sum = z[i];
x = i - ans + 1;
y = x + z[i] - 1;
}
}
len = ans - 1;
for (int j = sd - 1; j >= 0; j--) a[++len] = s[j];
a[++len] = '\0';
zalgo();
for (int i = ans; i < len; i++) {
if (z[i] > ans) z[i] = ans;
if (z[i] > sum) {
sum = z[i];
x = i - ans + 1;
y = x + z[i] - 1;
x = sd - x + 1;
y = sd - y + 1;
}
}
if (sum == 0) {
printf("%d\n", -1);
return 0;
}
v.push_back(make_pair(x, y));
st += sum;
}
printf("%d\n", (int)((int)v.size()));
for (int i = 0; i < ((int)v.size()); i++) {
printf("%d %d\n", v[i].first, v[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s, t;
int ans[2222][2], res = 0;
int main() {
cin >> s >> t;
int n = s.size(), m = t.size(), flag, l, r, k, len;
for (int i = 0; i < m; i++) {
flag = 0, len = 0;
for (int j = 0; j < n; j++) {
if (t[i] == s[j]) {
flag = 1;
l = r = j, k = i;
while (r < n && k < m) {
if (s[r] == t[k]) {
r++;
k++;
} else
break;
}
if (r - l > len) len = r - l, ans[res][0] = l, ans[res][1] = r - 1;
l = r = j, k = i;
while (l >= 0 && k < m) {
if (s[l] == t[k]) {
l--;
k++;
} else
break;
}
if (r - l > len) len = r - l, ans[res][0] = r, ans[res][1] = l + 1;
}
}
if (!flag) break;
res++;
i += len - 1;
}
if (!flag)
printf("-1\n");
else {
printf("%d\n", res);
for (int i = 0; i < res; i++)
printf("%d %d\n", ans[i][0] + 1, ans[i][1] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str1, str2, str3;
vector<int> v1, v2;
int l, r;
vector<pair<int, int> > v3;
int kmpstart(int a) {
int sz, p1, p2;
p2 = 0;
v2[0] = 0;
v2[1] = 0;
for (p1 = 2; p1 <= str2.size(); p1++) {
p2 = v2[p1 - 1];
while (1) {
if (str2[p1 - 1] == str2[p2]) {
v2[p1] = p2 + 1;
break;
} else if (p2 == 0) {
v2[p1] = 0;
break;
} else
p2 = v2[p2];
}
}
}
int kmpfinal1(int a) {
int sz, p1, p2;
p1 = 0;
p2 = 0;
sz = 0;
while (1) {
if (p1 == str1.size()) break;
if (str1[p1] == str2[p2]) {
p1++;
p2++;
if (sz < p2) {
sz = p2;
l = p1 - p2 + 1;
r = p1;
}
if (p2 == str2.size()) break;
} else if (p2 > 0)
p2 = v2[p2];
else
p1++;
}
return sz;
}
int kmpfinal2(int a) {
int sz, p1, p2;
p1 = 0;
p2 = 0;
sz = 0;
while (1) {
if (p1 == str3.size()) break;
if (str3[p1] == str2[p2]) {
p1++;
p2++;
if (sz < p2) {
sz = p2;
l = p1 - p2;
r = p1 - 1;
}
if (p2 == str2.size()) break;
} else if (p2 > 0)
p2 = v2[p2];
else
p1++;
}
return sz;
}
int main() {
int n, m, p1, p2, chng1, chng2, l1, r1;
cin >> str1 >> str2;
for (p1 = str1.size() - 1; p1 >= 0; p1--) str3.push_back(str1[p1]);
v1.resize(26, 0);
for (p1 = 0; p1 < str1.size(); p1++) v1[str1[p1] - 'a']++;
for (p1 = 0; p1 < str2.size(); p1++)
if (v1[str2[p1] - 'a'] == 0) {
cout << -1;
return 0;
}
p1 = 0;
chng1 = 0;
chng2 = 0;
while (str2.size() > 0) {
v2.clear();
v2.resize(str2.size() + 1, 0);
l = r = -1;
kmpstart(p1);
chng1 = kmpfinal1(p1);
l1 = l;
r1 = r;
chng2 = kmpfinal2(p1);
if (chng1 >= chng2) {
p1 += chng1;
l = l1;
r = r1;
str2.erase(0, chng1);
} else {
p1 += chng2;
l = str1.size() - l;
r = str1.size() - r;
str2.erase(0, chng2);
}
v3.push_back(make_pair(l, r));
}
cout << v3.size() << "\n";
for (p1 = 0; p1 < v3.size(); p1++)
cout << v3[p1].first << " " << v3[p1].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e9;
string s1, s2;
int dp1[2500][2500], dp2[2500][2500], ans[2500], dp[2500], previ[2500];
pair<int, int> m[2500];
vector<pair<int, int>> ret;
int rev(int x) { return (int)s1.size() - x - 1; }
int main() {
cin >> s1 >> s2;
int l1 = (int)s1.size();
int l2 = (int)s2.size();
for (int i = l2 - 1; i >= 0; i--)
for (int j = l1 - 1; j >= 0; j--) {
dp1[i][j] = dp1[i + 1][j + 1] + 1;
if (s2.at(i) != s1.at(j)) dp1[i][j] = 0;
}
reverse(s1.begin(), s1.end());
for (int i = l2 - 1; i >= 0; i--)
for (int j = l1 - 1; j >= 0; j--) {
dp2[i][j] = dp2[i + 1][j + 1] + 1;
if (s2.at(i) != s1.at(j)) dp2[i][j] = 0;
}
for (int i = 0; i < l2; i++)
for (int j = 0; j < l1; j++)
if (dp1[i][j] > ans[i]) {
ans[i] = dp1[i][j];
m[i] = make_pair(j, j + dp1[i][j] - 1);
}
for (int i = 0; i < l2; i++)
for (int j = 0; j < l1; j++)
if (dp2[i][j] > ans[i]) {
ans[i] = dp2[i][j];
m[i] = make_pair(rev(j), rev(j + dp2[i][j] - 1));
}
for (int i = 0; i <= l2; i++) dp[i] = maxn;
dp[0] = 0;
for (int i = 0; i < l2; i++) {
int to = i + ans[i];
if (dp[to] > dp[i] + 1) {
dp[to] = dp[i] + 1;
previ[to] = i;
}
}
if (dp[l2] == maxn) {
cout << -1 << endl;
return 0;
}
cout << dp[l2] << endl;
int i = l2;
while (i) {
int last = previ[i];
ret.push_back(m[last]);
i = last;
}
reverse(ret.begin(), ret.end());
for (int i = 0; i < ret.size(); i++)
printf("%d %d\n", ret[i].first + 1, ret[i].second + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Info {
int st, en, len;
};
string s, t, u = "";
vector<pair<int, int> > res;
Info findSubStr(string src, int start) {
int srcs = src.size(), tsize = t.size(), tmp = start, i = 0;
Info I = {0, 0, 0};
for (int i = 0; i < srcs; i++) {
int tmp = start;
Info Tmp;
if (src[i] == t[start]) {
Tmp.en = Tmp.st = i;
while (start < tsize && Tmp.en < srcs && t[start] == src[Tmp.en]) {
start++;
Tmp.en++;
}
Tmp.len = start - tmp, Tmp.st++;
if (start - tmp > I.len) {
I = Tmp;
I.len = start - tmp;
}
}
start = tmp;
}
return I;
}
int main() {
getline(cin, s);
getline(cin, t);
for (int i = s.size() - 1; i >= 0; i--) u += s[i];
int tsize = t.size();
for (int i = 0; i < tsize; i++) {
Info T = findSubStr(s, i), U = findSubStr(u, i);
if (!T.len || !U.len) {
cout << -1;
return 0;
}
if (U.len > T.len)
res.push_back(make_pair(s.size() - U.st + 1, s.size() - U.en + 1));
else
res.push_back(make_pair(T.st, T.en));
i += max(T.len, U.len) - 1;
}
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long double PI = 2 * acos(0.0);
const vector<long long int> dx = {1, -1, 0, 0};
const vector<long long int> dy = {0, 0, 1, -1};
vector<long long int> ga(long long int n, bool oneIndexed = false) {
vector<long long int> a;
if (oneIndexed) a.push_back(0ll);
for (long long int i = 0; i < n; i++) {
long long int p;
cin >> p;
a.push_back(p);
}
return move(a);
}
vector<unsigned long long int> gau(unsigned long long int n,
bool oneIndexed = false) {
vector<unsigned long long int> a;
if (oneIndexed) a.push_back(0llu);
for (unsigned long long int i = 0; i < n; i++) {
unsigned long long int p;
cin >> p;
a.push_back(p);
}
return move(a);
}
vector<string> gas(unsigned long long int n, bool oneIndexed = false) {
vector<string> a;
if (oneIndexed) a.push_back("");
for (unsigned long long int i = 0; i < n; i++) {
string p;
cin >> p;
a.push_back(p);
}
return move(a);
}
template <typename T, typename A>
void pa(vector<T, A> const &a, long long int begin = 0,
long long int end = -1) {
if (end == -1) end = (long long int)a.size() - 1;
for (long long int i = begin; i <= end; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
template <typename T, typename A>
void papair(vector<T, A> const &a, long long int begin = 0,
long long int end = -1) {
if (end == -1) end = (long long int)a.size() - 1;
for (long long int i = begin; i <= end; i++) {
cout << a[i].first << " " << a[i].second << "\n";
}
}
void yes() { cout << "YES\n"; }
void no() { cout << -1 << "\n"; }
void yesno(int f) {
if (f)
yes();
else
no();
}
pair<long long int, long long int> presentins(const string &need,
const string &p1,
const string &p2) {
for (long long int i = 0;
i <= (long long int)p1.size() - (long long int)need.size(); i++) {
if (p1.substr(i, (long long int)need.size()) == need)
return {i + 1, i + (long long int)need.size()};
if (p2.substr(i, (long long int)need.size()) == need)
return {(long long int)p1.size() - i,
(long long int)p1.size() - (i + (long long int)need.size()) + 1};
}
return {-1, -1};
}
void solve() {
string s, t;
cin >> s >> t;
string s2 = s;
reverse(s2.begin(), s2.end());
vector<pair<long long int, long long int> > ans;
for (long long int i = 0; i < (long long int)t.size();) {
long long int possibleLen = 1;
pair<long long int, long long int> check, prevcheck;
while (i + possibleLen <= (long long int)t.size()) {
const string &need = t.substr(i, possibleLen);
prevcheck = check;
check = presentins(need, s, s2);
if (check.first != -1) {
possibleLen++;
} else {
possibleLen--;
check = prevcheck;
break;
}
}
if (possibleLen == 0) {
no();
return;
};
ans.push_back(check);
i += possibleLen;
}
cout << (long long int)ans.size() << "\n";
papair(ans);
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 600000;
using namespace std;
void print(vector<int> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
int l[2102][2102], lrev[2102][2102];
string rev(string s) {
string p;
for (int i = s.size() - 1; i >= 0; i--) p.push_back(s[i]);
return p;
}
int main() {
string a, b, c;
cin >> a >> b;
int la = a.length(), lb = b.length();
c = rev(a);
memset(l, 0, sizeof l);
memset(lrev, 0, sizeof lrev);
for (int i = lb - 1; i >= 0; i--) {
for (int j = la - 1; j >= 0; j--) {
if (b[i] == a[j]) l[i][j] = l[i + 1][j + 1] + 1;
if (b[i] == c[j]) lrev[i][j] = lrev[i + 1][j + 1] + 1;
}
}
vector<pair<int, int> > v;
int cnt = 0, i;
for (i = 0; i < lb; i++) {
int k = 0, pos = 0, prev = 0;
pair<int, int> p;
for (int j = 0; j < la; j++) {
if (l[i][j] > k) {
k = l[i][j];
pos = j;
prev = 0;
}
if (lrev[i][j] > k) {
k = lrev[i][j];
pos = j;
prev = 1;
}
}
if (k == 0) {
cout << "-1\n";
break;
}
cnt++;
if (prev) {
p.second = la - 1 - (pos + k - 1);
p.first = la - 1 - pos;
} else {
p.first = pos;
p.second = pos + k - 1;
}
v.push_back(p);
i += k - 1;
}
if (i == lb) {
cout << cnt << "\n";
for (i = 0; i < v.size(); i++)
cout << v[i].first + 1 << " " << v[i].second + 1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dp1[3005][3005], dp2[3005][3005], ans1[3005], ans2[3005];
char a[3005], b[3005], c[3005];
int main() {
int i, j, p = 1, maxx, sol = 0;
cin.sync_with_stdio(0);
cin >> (a + 1) >> (c + 1);
n = strlen(a + 1);
m = strlen(c + 1);
for (i = 1; i <= n; ++i) b[n - i + 1] = a[i];
for (i = n; i; --i)
for (j = m; j; --j)
if (a[i] != c[j])
dp1[i][j] = 0;
else
dp1[i][j] = 1 + dp1[i + 1][j + 1];
for (i = n; i; --i)
for (j = m; j; --j)
if (b[i] != c[j])
dp2[i][j] = 0;
else
dp2[i][j] = 1 + dp2[i + 1][j + 1];
while (p <= m) {
++sol;
maxx = 0;
for (i = 1; i <= n; ++i) {
if (maxx < dp1[i][p]) {
maxx = dp1[i][p];
ans1[sol] = i;
ans2[sol] = i + maxx - 1;
}
if (maxx < dp2[i][p]) {
maxx = dp2[i][p];
ans1[sol] = n - i + 1;
ans2[sol] = n - (i + maxx - 1) + 1;
}
}
if (!maxx) {
cout << "-1";
return 0;
}
p += maxx;
}
cout << sol << "\n";
for (i = 1; i <= sol; ++i) cout << ans1[i] << " " << ans2[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
using Vector2D = std::vector<std::vector<T>>;
template <typename T>
using Vector3D = std::vector<Vector2D<T>>;
using PairInt = std::pair<int, int>;
using PairInt64 = std::pair<int64_t, int64_t>;
using MapInt = std::map<int, int>;
using MMapInt = std::multimap<int, int>;
using MMapInt64 = std::multimap<int64_t, int64_t>;
using UMapIntString = std::unordered_map<int, std::string>;
using SetInt = std::set<int>;
using SetPairInt64 = std::set<PairInt64>;
using VectorInt = std::vector<int>;
using VectorInt2D = Vector2D<int>;
using VectorInt64 = std::vector<int64_t>;
using VectorUInt64 = std::vector<uint64_t>;
using VectorInt642D = Vector2D<int64_t>;
using VectorChar = std::vector<char>;
using VectorChar2D = Vector2D<char>;
using VectorString = std::vector<std::string>;
using QueuePairInt = std::queue<PairInt>;
using QueueInt = std::queue<int>;
using VectorPairInt = std::vector<PairInt>;
using VectorPairInt64 = std::vector<PairInt64>;
using VectorPairInt2D = Vector2D<PairInt>;
using SetInt = std::set<int>;
using MSetInt = std::multiset<int>;
using UMapChar = std::map<char, int>;
using ListInt = std::list<int>;
using VectorListInt = std::vector<ListInt>;
using VectorDouble = std::vector<double>;
VectorInt calc_prefix_function(const std::string& str) {
const size_t str_length = str.size();
VectorInt prefix_func(str_length);
if (0 == str_length) return prefix_func;
prefix_func[0] = 0;
for (size_t current = 1; current < str_length; ++current) {
size_t matched_prefix = current - 1;
size_t candidate = prefix_func[matched_prefix];
while (candidate != 0 && str[current] != str[candidate]) {
matched_prefix = prefix_func[matched_prefix] - 1;
candidate = prefix_func[matched_prefix];
}
if (candidate == 0)
prefix_func[current] = str[current] == str[0] ? 1 : 0;
else
prefix_func[current] = candidate + 1;
}
return prefix_func;
}
int main() {
std::ios::sync_with_stdio(false);
std::string s;
std::string t;
std::string sb;
std::cin >> s >> t;
sb = s;
std::reverse(sb.begin(), sb.end());
if (t.length() == 0) {
std::cout << "0";
return 0;
} else if (s.length() == 0) {
std::cout << "-1";
return 0;
}
VectorPairInt ans = {{-1, -1}};
int sz = t.length();
for (int i = 1, j = 0; i <= sz && j < sz;) {
int len = i - j;
auto tm = t.substr(j, len) + '$';
auto prefix_f = calc_prefix_function(tm + s);
auto prefix_b = calc_prefix_function(tm + sb);
auto itf = std::find(prefix_f.begin(), prefix_f.end(), len);
auto itb = std::find(prefix_b.begin(), prefix_b.end(), len);
if (itf != prefix_f.end()) {
int idx = itf - prefix_f.begin() - len;
ans.back() = {idx - len + 1, idx};
++i;
} else if (itb != prefix_b.end()) {
int szs = s.length();
int idx = szs - ((itb - prefix_b.begin()) - len) + 1;
ans.back() = {idx + len - 1, idx};
++i;
} else if (ans.back() == PairInt(-1, -1)) {
std::cout << "-1";
return 0;
} else {
j = i - 1;
if (i <= sz && j < sz) ans.emplace_back(-1, -1);
}
}
std::cout << ans.size() << "\n";
for (auto& p : ans) {
std::cout << p.first << " " << p.second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int abs(int a) {
if (a > 0) return a;
return -a;
}
int main() {
string s, t;
cin >> s >> t;
vector<pair<int, int> > result;
vector<int> sc(26, 0);
vector<int> tc(26, 0);
for (int i = 0; i < s.size(); i++) {
sc[s[i] - 'a'] += 1;
}
for (int i = 0; i < t.size(); i++) {
tc[t[i] - 'a'] += 1;
}
int rep = 0;
int maxi = 0;
for (int i = 0; i < 26; i++) {
if (tc[i] != 0) {
if (sc[i] == 0) {
cout << "-1";
return 0;
}
}
}
map<int, vector<int> > m;
for (int i = 0; i < s.size(); i++) {
m[s[i] - 'a'].push_back(i);
}
int tt = 0;
while (tt < t.size()) {
int ll = -1, rl = -1;
int curr = 0, maxi = -1, res = 0;
for (int j = 0; j < m[t[tt] - 'a'].size(); j++) {
curr = m[t[tt] - 'a'][j];
int lr = 0, rr = 0;
int ttt1 = tt + 1, ttt2 = tt + 1;
int k1;
for (k1 = curr - 1; k1 >= 0; k1--) {
if (s[k1] == t[ttt1]) {
ttt1 += 1;
lr += 1;
} else {
break;
}
}
k1 += 1;
int k2;
for (k2 = curr + 1; k2 < s.size(); k2++) {
if (s[k2] == t[ttt2]) {
ttt2 += 1;
rr += 1;
} else {
break;
}
}
k2 -= 1;
int lll, lrl;
if (lr > rr) {
lll = curr;
lrl = k1;
} else {
lll = curr;
lrl = k2;
}
if (abs(lrl - lll) > maxi) {
maxi = abs(lrl - lll);
ll = lll;
rl = lrl;
}
}
tt += abs(rl - ll) + 1;
result.push_back(make_pair(ll, rl));
}
cout << result.size() << '\n';
for (int u = 0; u < result.size(); u++) {
cout << result[u].first + 1 << ' ' << result[u].second + 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> maxEqualPart(const string& letters, const string& s, int pos) {
int maxLen = -1;
pair<int, int> answer(-1, -1);
const int& letters_length = letters.length();
for (int i = 0; i < letters_length && letters_length - i > maxLen; ++i) {
int len = 0;
while (i + len < letters.length() && pos + len < s.length() &&
letters[i + len] == s[pos + len])
len++;
if (len > maxLen) {
maxLen = len;
answer = make_pair(i, i + len);
}
}
return answer;
}
int main() {
string s;
string t;
cin >> s;
cin >> t;
vector<pair<int, int> > segments;
string rs(s.rbegin(), s.rend());
int composedLen = 0;
while (composedLen < t.length()) {
pair<int, int> ms = maxEqualPart(s, t, composedLen);
int lenStraight = ms.second - ms.first;
if (lenStraight == 0) {
cout << -1 << endl;
return 0;
}
pair<int, int> mr = maxEqualPart(rs, t, composedLen);
int lenReverse = mr.second - mr.first;
if (lenStraight >= lenReverse) {
segments.push_back(make_pair(ms.first + 1, ms.second));
composedLen += lenStraight;
} else {
segments.push_back(
make_pair(s.length() - mr.first, s.length() - mr.second + 1));
composedLen += lenReverse;
}
}
printf("%d\n", segments.size());
for (int i = 0; i < segments.size(); ++i)
printf("%d %d\n", segments[i].first, segments[i].second);
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> match(string &s, string &t, int b) {
int max_len = 0;
int best_b = -1, best_e = -1;
for (int i = 0; i < (int)s.length(); ++i) {
int k;
for (k = 0; k + i < (int)s.length() && k + b < (int)t.length(); ++k) {
if (s[i + k] == t[b + k])
continue;
else
break;
}
if (k > max_len) {
max_len = k;
best_b = i + 1, best_e = i + k;
}
}
pair<int, int> p(best_b, best_e);
return p;
}
int main() {
string s, t;
cin >> s >> t;
int flag[26] = {0};
for (int i = 0; i < (int)s.length(); ++i) flag[s[i] - 'a'] = 1;
bool is_ok = 1;
for (int i = 0; i < (int)t.length(); ++i)
if (flag[t[i] - 'a'] == 0) {
is_ok = 0;
break;
}
if (!is_ok) {
cout << -1 << endl;
return 0;
}
vector<pair<int, int> > res;
int n = s.length();
string s2 = s;
reverse(s2.begin(), s2.end());
int b = 0;
while (b < (int)t.length()) {
pair<int, int> seg1 = match(s, t, b);
pair<int, int> seg2 = match(s2, t, b);
int len1 = abs(seg1.first - seg1.second);
int len2 = abs(seg2.first - seg2.second);
if (len1 >= len2) {
res.push_back(seg1);
b += len1 + 1;
} else {
seg2.first = n + 1 - seg2.first;
seg2.second = n + 1 - seg2.second;
res.push_back(seg2);
b += len2 + 1;
}
}
cout << res.size() << endl;
for (int i = 0; i < (int)res.size(); ++i)
cout << res[i].first << " " << res[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int C[256];
int maxlen = 0;
int lm, rm;
void build_failure_function(string pat, int F[]) {
int i, j, m;
m = (int)pat.size();
j = 0;
F[0] = 0;
F[1] = 0;
for (i = 2; i <= m; i++) {
j = F[i - 1];
while (1) {
if (pat[i - 1] == pat[j]) {
F[i] = j + 1;
break;
} else if (j == 0) {
F[i] = 0;
break;
} else
j = F[j];
}
}
}
void kmp(string txt, string pat, int F[]) {
int i, j, n, m;
n = (int)txt.size();
m = (int)pat.size();
i = j = 0;
maxlen = 0;
lm = 0;
rm = 0;
while (1) {
if (j == n) break;
if (pat[i] == txt[j]) {
i++;
j++;
if (maxlen < i) {
maxlen = i;
lm = j - i;
rm = j - 1;
}
if (i == n) break;
} else if (i > 0)
i = F[i];
else
j++;
}
}
vector<pair<int, int> > V;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t, st;
int i, j, n;
int l1, l2, r2, r1, maxlen1, maxlen2;
cin >> s >> t;
for (i = 0; i < s.size(); i++) C[s[i]]++;
for (i = 0; i < t.size(); i++)
if (!C[t[i]]) break;
n = (int)s.size();
if (i != t.size()) {
cout << -1;
return 0;
}
string srev = s;
reverse(srev.begin(), srev.end());
int F[3000];
for (i = 0; i < t.size(); i++) {
st = t.substr(i, t.size() - i);
build_failure_function(st, F);
kmp(s, st, F);
maxlen1 = maxlen;
l1 = lm;
r1 = rm;
kmp(srev, st, F);
maxlen2 = maxlen;
l2 = lm;
r2 = rm;
if (maxlen1 >= maxlen2) {
V.push_back(pair<int, int>(l1, r1));
i += maxlen1 - 1;
} else {
l2 = n - 1 - l2;
r2 = n - 1 - r2;
V.push_back(pair<int, int>(l2, r2));
i += maxlen2 - 1;
}
}
cout << V.size() << "\n";
for (auto x : V) {
cout << x.first + 1 << " " << x.second + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
} ans[2111];
char s[2111], t[2111], str[2111];
void strrev(char ch[]) {
int n = strlen(ch);
for (int i = 0; i < n / 2; i++) {
swap(ch[i], ch[n - i - 1]);
}
}
int main() {
int i, j, n, m, k = 0;
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
t[++m] = '$';
t[m + 1] = 0;
int len = 0, L, flag;
for (i = 1; i <= m;) {
len = 0;
flag = -1;
for (j = 0; j <= m - i; j++) {
str[len++] = t[i + j];
str[len] = 0;
int tmp = strstr(s + 1, str) - s;
if (tmp > 0) {
flag = 1;
L = tmp;
continue;
}
strrev(str);
tmp = strstr(s + 1, str) - s;
if (tmp > 0) {
flag = 0;
L = tmp;
strrev(str);
continue;
}
if (flag == 1) {
ans[++k].l = L;
ans[k].r = L + j - 1;
} else if (flag == 0) {
ans[++k].l = L + j - 1;
ans[k].r = L;
}
i = i + j;
break;
}
if (flag == -1) break;
}
if (i < m) {
puts("-1");
return 0;
}
printf("%d\n", k);
for (i = 1; i <= k; i++) printf("%d %d\n", ans[i].l, ans[i].r);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2505;
char a[N], b[N], c[N];
int dp1[N][N], dp2[N][N], dp[N], step[N], ans[N][2];
int main() {
scanf("%s%s", a + 1, b + 1);
int len1 = strlen(a + 1);
int len2 = strlen(b + 1);
for (int i = 1; i <= len2; i++) dp[i] = 1e8;
for (int i = 1; i <= len1; i++) c[i] = a[len1 - i + 1];
for (int i = 1; i <= len1; i++)
for (int j = 1; j <= len2; j++) {
if (a[i] == b[j]) dp1[i][j] = dp1[i - 1][j - 1] + 1;
if (b[j] == c[i]) dp2[i][j] = dp2[i - 1][j - 1] + 1;
}
for (int i = 1; i <= len2; i++)
for (int j = 1; j <= len1; j++) {
if (dp1[j][i]) {
if (dp[i] > dp[i - dp1[j][i]] + 1) {
dp[i] = dp[i - dp1[j][i]] + 1;
step[i] = i - dp1[j][i];
}
}
if (dp2[j][i]) {
if (dp[i] > dp[i - dp2[j][i]] + 1) {
dp[i] = dp[i - dp2[j][i]] + 1;
step[i] = i - dp2[j][i];
}
}
}
if (dp[len2] == 1e8) return puts("-1"), 0;
printf("%d\n", dp[len2]);
int sum = dp[len2];
int now = len2;
while (sum--) {
for (int i = 1; i <= len1; i++) {
if (dp1[i][now] == now - step[now]) {
ans[sum][0] = i - dp1[i][now] + 1, ans[sum][1] = i;
now = step[now];
break;
}
if (dp2[i][now] == now - step[now]) {
ans[sum][0] = len1 - i + dp2[i][now], ans[sum][1] = len1 - i + 1;
now = step[now];
break;
}
}
}
for (int i = 0; i < dp[len2]; i++) printf("%d %d\n", ans[i][0], ans[i][1]);
return 0;
}
|
#include <bits/stdc++.h>
int fr[2103][2103];
int br[2103][2103];
using namespace std;
int n, m;
void lps1(string a, string b) {
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (a[i] == b[j]) {
br[i][j] = 1 + br[i + 1][j + 1];
}
}
}
}
void lps2(string a, string b) {
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (a[i] == b[j]) {
fr[i][j] = 1 + fr[i + 1][j + 1];
}
}
}
}
int main() {
string a, b;
string c;
cin >> a >> b;
n = a.length();
m = b.length();
for (int i = n - 1; i >= 0; i--) {
c += a[i];
}
lps1(c, b);
lps2(a, b);
vector<pair<int, int> > ans;
int ct = 0;
for (int i = 0; i < m;) {
int inf = 0;
int inb = 0;
int bci;
int fci;
for (int j = 0; j < n; j++) {
if (inf < fr[j][i]) {
inf = fr[j][i];
fci = j;
}
}
for (int j = 0; j < n; j++) {
if (inb < br[j][i]) {
inb = br[j][i];
bci = j;
}
}
if (inf == 0 && inb == 0) {
cout << -1 << endl;
return 0;
}
if (inf > inb) {
ans.push_back(make_pair(fci, fci + inf - 1));
i += inf;
} else {
int pos1 = bci;
int pos2 = bci + inb - 1;
i += inb;
ans.push_back(make_pair(n - pos1 - 1, n - pos2 - 1));
}
ct++;
}
int l = ans.size();
cout << l << endl;
for (int i = 0; i < l; i++)
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2107;
char A[M], B[M];
int la, lb, ca[M][M], cb[M][M], cnt;
struct node {
int l, r;
} ans[M];
int main() {
scanf("%s %s", A + 1, B + 1);
la = strlen(A + 1);
lb = strlen(B + 1);
for (int i = lb; i >= 1; i--) {
for (int j = la; j >= 1; j--)
if (B[i] == A[j]) ca[i][j] = ca[i + 1][j + 1] + 1;
for (int j = la; j >= 1; j--)
if (B[i] == A[la - j + 1]) cb[i][j] = cb[i + 1][j + 1] + 1;
}
int now = 1, f = 1;
while (now <= lb) {
int x, mx = 0;
for (int i = 1; i <= la; i++)
if (ca[now][i] > mx) {
mx = ca[now][i];
x = i;
}
int y, my = 0;
for (int i = 1; i <= la; i++)
if (cb[now][i] > my) {
my = cb[now][i];
y = i;
}
int len = max(mx, my);
if (!len) {
f = 0;
break;
}
cnt++;
if (mx >= my) {
ans[cnt].l = x;
ans[cnt].r = x + len - 1;
} else {
ans[cnt].l = la - y + 1;
ans[cnt].r = la - (y + len - 1) + 1;
}
now += len;
}
if (!f)
puts("-1");
else {
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d %d\n", ans[i].l, ans[i].r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200200;
char a[MAXN];
int n;
struct SAM {
struct sam {
int len, slink, trans[26], ep;
};
sam t[MAXN];
int top = 1, las = 1, nlen = 0;
int slen[MAXN], fr[MAXN];
void add(int c) {
int tmp = ++top;
t[tmp].len = t[las].len + 1, t[tmp].ep = ++nlen;
int i, j;
for (i = las; i && !t[i].trans[c]; i = t[i].slink) t[i].trans[c] = tmp;
if (!i)
t[tmp].slink = 1;
else {
int rua = t[i].trans[c];
if (t[rua].len == t[i].len + 1)
t[tmp].slink = rua;
else {
int cl = ++top;
t[cl] = t[rua];
t[cl].len = t[i].len + 1;
for (j = i; t[j].trans[c] == rua; j = t[j].slink) t[j].trans[c] = cl;
t[tmp].slink = t[rua].slink = cl;
}
}
las = tmp;
}
void calc() {
int len = 0, now = 1, i;
for (i = 1; i <= n; i++) {
int c = a[i] - 'a';
while (now != 1 && !t[now].trans[c]) now = t[now].slink, len = t[now].len;
if (t[now].trans[c]) ++len, now = t[now].trans[c];
slen[i] = len;
fr[i] = t[now].ep - len + 1;
}
}
} s, rs;
int dp[MAXN];
struct out {
int fr, l, r;
} ans[MAXN];
char tmp[MAXN];
void prt(int x) {
if (!x) return;
prt(ans[x].fr);
printf("%d %d\n", ans[x].l, ans[x].r);
}
int main() {
scanf("%s", tmp + 1);
int i, j;
int len = strlen(tmp + 1);
for (i = 1; i <= len; i++) s.add(tmp[i] - 'a');
for (i = len; i >= 1; i--) rs.add(tmp[i] - 'a');
scanf("%s", a + 1);
n = strlen(a + 1);
s.calc();
rs.calc();
for (i = 1; i <= n; i++) {
dp[i] = 998244353;
if (dp[i - s.slen[i]] + 1 < dp[i]) {
dp[i] = dp[i - s.slen[i]] + 1;
ans[i].fr = i - s.slen[i], ans[i].l = s.fr[i],
ans[i].r = s.fr[i] + s.slen[i] - 1;
}
if (dp[i - rs.slen[i]] + 1 < dp[i]) {
dp[i] = dp[i - rs.slen[i]] + 1;
ans[i].fr = i - rs.slen[i], ans[i].l = len + 1 - rs.fr[i],
ans[i].r = len + 2 - rs.fr[i] - rs.slen[i];
}
}
if (dp[n] >= 998244353)
puts("-1");
else
printf("%d\n", dp[n]), prt(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(const T &a) {
return a * a;
}
template <class T>
inline T middle(const T &a, const T &b) {
return (a + b) / 2;
}
template <class T>
inline int len(const T &c) {
return static_cast<int>(c.size());
}
const long double EPS = 1e-9;
const long double PI = 2 * acos(0.0);
const int N = 2111;
pair<int, int> FindAppearance(const string &prefix, const string &t) {
int m = len(prefix);
string s = prefix + string("#") + t;
int n = len(s);
vector<int> p(n, 0);
pair<int, int> best{-1, -1};
int best_len = 0;
for (int i = 1; i < n; ++i) {
int j = p[i - 1];
while (j && s[i] != s[j]) {
j = p[j - 1];
}
p[i] = j;
if (s[i] == s[j]) {
++p[i];
}
if (i > m) {
if (best_len < p[i]) {
best_len = p[i];
best = {i - m - p[i], i - m - 1};
}
}
}
return best;
}
inline int Dist(pair<int, int> &x) { return abs(x.first - x.second) + 1; }
int dp[N];
pair<int, int> pd[N];
int main() {
string s, t;
getline(cin, t);
getline(cin, s);
string rt = t;
reverse(rt.begin(), rt.end());
int n = len(s);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
if (i && dp[i] < 1) {
continue;
}
int cand = dp[i] + 1;
string suf = s.substr(i);
pair<int, int> best = FindAppearance(suf, t);
pair<int, int> b2 = FindAppearance(suf, rt);
if (Dist(b2) > Dist(best)) {
best = b2;
best.first = len(rt) - 1 - best.first;
best.second = len(rt) - 1 - best.second;
}
if (best.first == -1) {
break;
}
int step = best.first <= best.second ? 1 : -1;
int leng = Dist(best);
int endpoint = best.first;
for (int j = i; j < i + leng; ++j) {
int &tg = dp[j + 1];
if (tg == 0 || tg > cand) {
tg = cand;
pd[j + 1] = {best.first, endpoint};
}
endpoint += step;
}
}
if (dp[n] == 0) {
puts("-1");
return 0;
}
printf("%d\n", dp[n]);
vector<pair<int, int> > ans;
for (int i = n; i > 0;) {
ans.push_back(pd[i]);
i -= abs(pd[i].first - pd[i].second) + 1;
}
reverse(ans.begin(), ans.end());
for (auto p : ans) {
printf("%d %d\n", p.first + 1, p.second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[2103], s2[2103];
char arr[4509];
int z[4509], sz;
vector<pair<int, int> > zz[2100], pos[2100];
const int INF = 1000000;
void ZAlgo() {
memset(z, 0, sizeof(z));
int l = 0, r = 0;
for (int i = 1; i < sz; ++i) {
if (i > r) {
l = r = i;
while (r < sz && arr[r - l] == arr[r]) ++r;
z[i] = r - l;
--r;
} else {
int k = i - l;
if (z[k] < r - i + 1)
z[i] = z[k];
else {
l = i;
while (r < sz && arr[r - l] == arr[r]) ++r;
z[i] = r - l;
--r;
}
}
}
}
int memo[2103];
int n, m;
int solve(int ind) {
if (ind == m) return 0;
int &ret = memo[ind];
if (ret != -1) return ret;
ret = INF;
for (int i = 0; i < zz[ind].size(); ++i) {
if (zz[ind][i].first) ret = min(ret, 1 + solve(ind + zz[ind][i].first));
if (zz[ind][i].second) ret = min(ret, 1 + solve(ind + zz[ind][i].second));
}
return ret;
}
void build(int ind) {
if (ind == m) return;
for (int i = 0; i < zz[ind].size(); ++i) {
if (zz[ind][i].first && 1 + solve(ind + zz[ind][i].first) == solve(ind)) {
printf("%d %d\n", pos[ind][i].first,
pos[ind][i].first + zz[ind][i].first - 1);
build(ind + zz[ind][i].first);
return;
}
if (zz[ind][i].second && 1 + solve(ind + zz[ind][i].second) == solve(ind)) {
printf("%d %d\n", pos[ind][i].second,
pos[ind][i].second - zz[ind][i].second + 1);
build(ind + zz[ind][i].second);
return;
}
}
}
int main() {
scanf("%s", s1);
scanf("%s", s2);
n = strlen(s1), m = strlen(s2);
for (int ind = 0; ind < m; ++ind) {
sz = 0;
for (int i = ind; i < m; ++i) arr[sz++] = s2[i];
arr[sz++] = '?';
for (int i = 0; i < n; ++i) arr[sz++] = s1[i];
ZAlgo();
for (int i = m - ind + 1; i < sz; ++i)
zz[ind].push_back(make_pair(z[i], 0)),
pos[ind].push_back(make_pair(i - m + ind, 0));
reverse(arr + m - ind + 1, arr + sz);
ZAlgo();
for (int i = m - ind + 1, j = 0; i < sz; ++i, ++j)
zz[ind][j].second = z[i], pos[ind][j].second = n - (i - m + ind - 1);
}
memset(memo, -1, sizeof(memo));
int ans = solve(0);
if (ans == INF)
puts("-1");
else
printf("%d\n", ans), build(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 200000000;
const int MOD = 1000000007;
pair<int, pair<int, int> > f[3000];
vector<pair<int, int> > ans;
vector<int> prefix_function(string s1, string s) {
s = s1 + "#" + s;
int n = (int)s.length();
vector<int> pi(n);
for (int i = 1; i < n; ++i) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) ++j;
pi[i] = j;
}
vector<int> f;
for (int i = s1.length() + 1; i < n; i++) {
f.push_back(pi[i]);
}
return f;
}
int main() {
ios_base::sync_with_stdio(0);
string s1, s2;
cin >> s1 >> s2;
string t = s2;
string s3 = s1;
reverse(s3.begin(), s3.end());
int n = s1.length();
for (int i = 0; i < s2.length(); i++) {
int c = 0;
if (i > 0 && f[i - 1].first == 0) continue;
if (i != 0) c = f[i - 1].first;
vector<int> p = prefix_function(t, s1);
for (int j = 0; j < p.size(); j++) {
if (p[j] == 0) continue;
if (i + p[j] - 1 < s2.length()) {
if (f[i + p[j] - 1].first == 0 || f[i + p[j] - 1].first > c + 1) {
f[i + p[j] - 1] = make_pair(c + 1, make_pair(j - p[j] + 2, j + 1));
}
}
}
p.clear();
p = prefix_function(t, s3);
for (int j = 0; j < p.size(); j++) {
if (p[j] == 0) continue;
if (i + p[j] - 1 < s2.length()) {
if (f[i + p[j] - 1].first == 0 || f[i + p[j] - 1].first > c + 1) {
f[i + p[j] - 1] =
make_pair(c + 1, make_pair(n - (j - p[j] + 1), n - j));
}
}
}
t.erase(0, 1);
}
if (f[s2.length() - 1].first == 0) {
cout << -1 << endl;
return 0;
}
cout << f[s2.length() - 1].first << endl;
int i = s2.length() - 1;
while (i >= 0) {
ans.push_back(make_pair(f[i].second.first, f[i].second.second));
i -= abs(f[i].second.first - f[i].second.second) + 1;
}
for (int i = ans.size() - 1; i >= 0; i--)
cout << ans[i].first << ' ' << ans[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 2100;
int dp[MAXn + 5], lng[MAXn + 5];
pair<int, pair<int, int> > par[MAXn + 5];
vector<int> d[2][MAXn + 2][MAXn + 2];
string s, t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s >> t;
for (int i = 0; i < (int)s.size(); i++)
if (s[i] == t[t.size() - 1]) {
d[0][t.size() - 1][t.size() - 1].push_back(i);
d[1][t.size() - 1][t.size() - 1].push_back(i);
lng[t.size() - 1] = 1;
}
for (int i = (int)t.size() - 2; i >= 0; i--) {
if (lng[i + 1] > 0)
for (int j = i + lng[i + 1]; j > i; j--) {
for (int k = 0; k < (int)d[0][i + 1][j].size(); k++)
if (d[0][i + 1][j][k] - 1 >= 0 && s[d[0][i + 1][j][k] - 1] == t[i]) {
d[0][i][j].push_back(d[0][i + 1][j][k] - 1);
lng[i] = max(lng[i], j - i + 1);
}
for (int k = 0; k < (int)d[1][i + 1][j].size(); k++)
if (d[1][i + 1][j][k] + 1 < (int)s.size() &&
s[d[1][i + 1][j][k] + 1] == t[i]) {
d[1][i][j].push_back(d[1][i + 1][j][k] + 1);
lng[i] = max(lng[i], j - i + 1);
}
}
for (int j = 0; j < (int)s.size(); j++)
if (s[j] == t[i]) {
if (j + 1 < (int)s.size()) {
if (s[j + 1] != t[i + 1]) {
d[0][i][i].push_back(j);
lng[i] = max(lng[i], 1);
}
} else {
d[0][i][i].push_back(j);
lng[i] = max(lng[i], 1);
}
if (j - 1 >= 0) {
if (s[j - 1] != t[i + 1]) {
d[1][i][i].push_back(j);
lng[i] = max(lng[i], 1);
}
} else {
d[1][i][i].push_back(j);
lng[i] = max(lng[i], 1);
}
}
}
dp[t.size()] = 0;
for (int i = t.size() - 1; i >= 0; i--) {
dp[i] = INT_MAX;
if (lng[i] > 0)
for (int j = i + lng[i]; j > i; j--)
if (dp[j] != INT_MAX && dp[j] + 1 < dp[i]) {
dp[i] = dp[j] + 1;
par[i].first = j;
if (d[0][i][i + lng[i] - 1].size() > 0)
par[i].second = make_pair(d[0][i][i + lng[i] - 1][0],
d[0][i][i + lng[i] - 1][0] + j - i - 1);
else
par[i].second = make_pair(d[1][i][i + lng[i] - 1][0],
d[1][i][i + lng[i] - 1][0] - j + i + 1);
}
}
if (dp[0] == INT_MAX)
cout << -1 << endl;
else {
cout << dp[0] << endl;
int pt = 0;
while (pt < (int)t.size()) {
cout << par[pt].second.first + 1 << " " << par[pt].second.second + 1
<< endl;
pt = par[pt].first;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 2e4 + 7, P = 129192391239123187, PP = 1291923912391231247;
int read() {
int ans = 0, f = 1, c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0');
c = getchar();
}
return ans * f;
}
char S[M], T[M];
int ls, lt, L, R;
unsigned long long h1[M], h2[M], w[M], hh1[M], hh2[M], ww[M];
bool find(int len, unsigned long long now, unsigned long long nnow) {
for (int i = 1; i <= ls - len + 1; i++) {
int l = i, r = i + len - 1;
if (h1[r] - h1[l - 1] * w[len] == now &&
hh1[r] - hh1[l - 1] * ww[len] == nnow) {
L = l;
R = r;
return 1;
}
}
for (int i = 1; i <= ls - len + 1; i++) {
int l = i, r = i + len - 1;
if (h2[r] - h2[l - 1] * w[len] == now &&
hh2[r] - hh2[l - 1] * ww[len] == nnow) {
L = ls - l + 1;
R = ls - r + 1;
return 1;
}
}
return 0;
}
int cnt;
struct node {
int l, r;
} ans[M];
int main() {
w[0] = 1;
for (int i = 1; i < M; i++) w[i] = w[i - 1] * P;
ww[0] = 1;
for (int i = 1; i < M; i++) ww[i] = ww[i - 1] * PP;
scanf("%s %s", S + 1, T + 1);
ls = strlen(S + 1);
lt = strlen(T + 1);
for (int i = 1; i <= ls; i++)
h1[i] = h1[i - 1] * P + S[i], hh1[i] = hh1[i - 1] * PP + S[i];
int x = 1;
for (int i = ls; i >= 1; i--)
h2[x] = h2[x - 1] * P + S[i], hh2[x] = hh2[x - 1] * PP + S[i], x++;
int l = 1, r = 1, f;
while (l <= lt) {
unsigned long long now = T[l], nnow = T[l];
f = 0;
while (r <= lt && find(r - l + 1, now, nnow))
f = 1, r++, now = now * P + T[r], nnow = nnow * PP + T[r];
if (!f) break;
cnt++;
ans[cnt].l = L;
ans[cnt].r = R;
l = r;
}
if (!f)
puts("-1");
else {
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d %d\n", ans[i].l, ans[i].r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2107;
char A[M], B[M];
int la, lb, ca[M][M], cb[M][M], cnt;
struct node {
int l, r;
} ans[M];
int main() {
scanf("%s %s", A + 1, B + 1);
la = strlen(A + 1);
lb = strlen(B + 1);
for (int i = lb; i >= 1; i--) {
for (int j = la; j >= 1; j--)
if (B[i] == A[j]) ca[i][j] = ca[i + 1][j + 1] + 1;
for (int j = la; j >= 1; j--)
if (B[i] == A[la - j + 1]) cb[i][j] = cb[i + 1][j + 1] + 1;
}
int now = 1, f = 1;
while (now <= lb) {
int x, mx = 0;
for (int i = 1; i <= la; i++)
if (ca[now][i] > mx) {
mx = ca[now][i];
x = i;
}
int y, my = 0;
for (int i = 1; i <= la; i++)
if (cb[now][i] > my) {
my = cb[now][i];
y = i;
}
int len = max(mx, my);
if (!len) {
f = 0;
break;
}
cnt++;
if (mx >= my) {
ans[cnt].l = x;
ans[cnt].r = x + len - 1;
} else {
ans[cnt].l = la - y + 1;
ans[cnt].r = la - (y + len - 1) + 1;
}
now += len;
}
if (!f)
puts("-1");
else {
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d %d\n", ans[i].l, ans[i].r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5500];
int dp[5500];
void kmp(string str) {
int n = str.size();
int j = 0;
a[0] = 0;
for (int i = 1; i < n; i++) {
if (str[i] == str[j])
a[i] = ++j;
else if (j)
i--, j = a[j - 1];
else
a[i] = 0;
}
j = 0;
while (str[j] != '*') j++;
j++;
for (int i = 0; j < n; i++, j++) a[i] = a[j];
}
pair<int, int> ans[5500];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(dp, 63, sizeof(dp));
string s, t, sr;
cin >> sr >> t;
s = sr;
reverse(sr.begin(), sr.end());
int n = s.size();
int m = t.size();
dp[0] = 0;
for (int i = 0; i < m; i++) {
string str;
for (int j = i; j >= 0; j--) str.push_back(t[j]);
kmp(str + '*' + s);
for (int j = 0; j < n; j++) {
if (dp[i + 1] > 1 + dp[i + 1 - a[j]])
dp[i + 1] = 1 + dp[i + 1 - a[j]],
ans[i + 1] = pair<int, int>(j + 2 - a[j], j + 1);
}
kmp(str + '*' + sr);
for (int j = 0; j < n; j++) {
if (dp[i + 1] > 1 + dp[i + 1 - a[j]])
dp[i + 1] = 1 + dp[i + 1 - a[j]],
ans[i + 1] =
pair<int, int>(n + 1 - (j + 2 - a[j]), n + 1 - (j + 1));
}
}
if (dp[m] < 1e9)
cout << dp[m] << "\n";
else {
cout << -1 << "\n";
return 0;
}
int i = m;
stack<pair<int, int> > st;
while (i > 0) {
st.push(pair<int, int>(ans[i].second, ans[i].first));
i = i - (abs(ans[i].first - ans[i].second) + 1);
}
while (!st.empty())
cout << st.top().first << ' ' << st.top().second << "\n", st.pop();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
const int N = 2500, p = 31;
struct node {
node *next[26];
int Left, Right;
node(int ll = -1, int rr = -1) {
for (int i = 0; i < 26; i++) {
next[i] = nullptr;
}
Left = ll;
Right = rr;
}
};
node *root = new node();
void add(string &second, int L, int tp) {
node *cur = root;
int R = L;
for (int i = 0; i < (int)second.size(); i++) {
int id = second[i] - 'a';
if (cur->next[id] == nullptr) {
cur->next[id] = new node(L, R);
}
R += tp;
cur = cur->next[id];
}
}
void build(string &second) {
int n = (int)second.size();
for (int i = 0; i < n; i++) {
string cur = second.substr(i, n - i);
add(cur, i, 1);
cur = second.substr(0, n - i);
reverse(cur.begin(), cur.end());
add(cur, n - i - 1, -1);
}
}
vector<pair<int, int>> ans;
void solve(string &second) {
node *cur = root;
second += '?';
int n = (int)second.size(), cnt = 0;
for (int i = 0; i < n; i++) {
int id = second[i] - 'a';
if (cnt == 2) {
ans.clear();
return;
}
if (i == n - 1) {
ans.push_back({cur->Left, cur->Right});
return;
}
if (cur->next[id] != nullptr) {
cur = cur->next[id];
cnt = 0;
} else {
if (i == 0) {
return;
}
ans.push_back({cur->Left, cur->Right});
cur = root;
i--;
cnt++;
}
}
}
int main() {
string second, t;
cin >> second >> t;
build(second);
solve(t);
if (ans.empty()) {
cout << -1;
return 0;
}
cout << ans.size() << "\n";
for (auto i : ans) {
cout << i.first + 1 << " " << i.second + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-9;
const int N = 3000 + 10, maxn = 2000 + 10, inf = 0x3f3f3f3f,
INF = 0x3f3f3f3f3f3f3f3f;
const unsigned long long bs = 163;
char s[N], p[N];
unsigned long long Hash[N][N];
int ssz, psz;
vector<pair<int, int> > v;
void init() {
for (int i = 1; i <= ssz; i++) {
Hash[i][i] = s[i] - 'a';
for (int j = i + 1; j <= ssz; j++)
Hash[i][j] = Hash[i][j - 1] * bs + s[j] - 'a';
for (int j = i - 1; j >= 1; j--)
Hash[i][j] = Hash[i][j + 1] * bs + s[j] - 'a';
}
}
pair<int, int> solve(unsigned long long x, int dis) {
for (int i = 1; i + dis <= ssz; i++)
if (Hash[i][i + dis] == x) return make_pair(i, i + dis);
for (int i = dis + 1; i <= ssz; i++)
if (Hash[i][i - dis] == x) return make_pair(i, i - dis);
return make_pair(-1, -1);
}
int main() {
scanf("%s%s", s + 1, p + 1);
ssz = strlen(s + 1), psz = strlen(p + 1);
init();
unsigned long long te = 0;
int ans = 0, last = 0;
for (int i = 1; i <= psz; i++) {
te = te * bs + p[i] - 'a';
if (i - 1 == last && solve(te, 0).first == -1) return 0 * puts("-1");
if (i + 1 <= psz && solve(te * bs + p[i + 1] - 'a', i - last).first == -1) {
v.push_back(solve(te, i - last - 1));
te = 0, last = i;
}
}
if (solve(te, psz - last - 1).first == -1)
return 0 * puts("-1");
else
v.push_back(solve(te, psz - last - 1));
printf("%d\n", v.size());
for (int i = 0; i < v.size(); i++) printf("%d %d\n", v[i].first, v[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 7;
const int MAXA = 1e5 + 10;
const long long MOD = (long long)1e9 + 7;
const long long INFLL = 9e18 + 7;
string s, sr, t;
vector<pair<int, int> > ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s >> t;
sr = s;
reverse(sr.begin(), sr.end());
for (int(j) = (0); (j) <= (t.length() - 1); (j)++) {
int mx = 0;
int x = -1, y = -1;
for (int(i) = (1); (i) <= (min(s.length(), t.length())); (i)++) {
string temp = t.substr(j, i);
size_t pos = s.find(temp);
if (i > mx && pos != string::npos) {
x = pos;
y = pos + temp.length() - 1;
mx = i;
} else if (pos == string::npos)
break;
}
for (int(i) = (1); (i) <= (min(s.length(), t.length())); (i)++) {
string temp = t.substr(j, i);
size_t pos = sr.find(temp);
if (i > mx && pos != string::npos) {
x = s.length() - pos - 1;
y = x - temp.length() + 1;
mx = i;
} else if (pos == string::npos)
break;
}
if (mx == 0) return cout << "-1", 0;
j += mx - 1;
ans.push_back(pair<int, int>(x, y));
}
cout << ans.size() << endl;
for (int(i) = (0); (i) <= (ans.size() - 1); (i)++) {
cout << ++ans[i].first << " " << ++ans[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e3 + 10;
char s[MAXN], t[MAXN], s_rev[MAXN];
int lcp[MAXN][MAXN], lcp_rev[MAXN][MAXN], lcp_max[MAXN], lcp_rev_max[MAXN];
int pre[MAXN], type[MAXN], lcp_rev_since[MAXN], lcp_since[MAXN];
int dp[MAXN];
void print(int p) {
if (!p) return;
print(pre[p]);
if (type[p] == 0) {
printf("%d %d\n", lcp_since[pre[p] + 1],
lcp_since[pre[p] + 1] + (p - pre[p] - 1));
} else {
printf("%d %d\n", lcp_rev_since[pre[p] + 1],
lcp_rev_since[pre[p] + 1] - (p - pre[p] - 1));
}
}
int main() {
scanf("%s%s", s + 1, t + 1);
int m = strlen(s + 1);
int n = strlen(t + 1);
for (int i = 1; i <= m; i++) {
s_rev[i] = s[m - i + 1];
}
for (int i = n; i >= 1; i--) {
lcp[i][m + 1] = 0;
lcp_max[i] = 0;
for (int j = m; j >= 1; j--) {
if (t[i] == s[j]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
} else {
lcp[i][j] = 0;
}
if (lcp_max[i] < lcp[i][j]) {
lcp_max[i] = max(lcp_max[i], lcp[i][j]);
lcp_since[i] = j;
}
}
}
for (int i = n; i >= 1; i--) {
lcp_rev[i][0] = 0;
lcp_rev_max[i] = 0;
for (int j = 1; j <= m; j++) {
if (t[i] == s[j]) {
lcp_rev[i][j] = lcp_rev[i + 1][j - 1] + 1;
} else {
lcp_rev[i][j] = 0;
}
if (lcp_rev_max[i] < lcp_rev[i][j]) {
lcp_rev_max[i] = max(lcp_rev_max[i], lcp_rev[i][j]);
lcp_rev_since[i] = j;
}
}
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = n + 2;
for (int j = 0; j < i; j++) {
if ((lcp_max[j + 1] >= i - j) && dp[i] > dp[j] + 1) {
dp[i] = dp[j] + 1;
pre[i] = j;
type[i] = 0;
}
if ((lcp_rev_max[j + 1] >= i - j) && dp[i] > dp[j] + 1) {
dp[i] = dp[j] + 1;
pre[i] = j;
type[i] = 1;
}
}
}
if (dp[n] == n + 2) {
puts("-1");
return 0;
}
printf("%d\n", dp[n]);
print(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
map<char, data*> subData;
pair<int, int> FL;
data() {}
data(pair<int, int> fl) { FL = fl; }
};
int main() {
string s, t;
cin >> s;
data top;
for (int i = 0; i < s.size(); i++) {
data* DP = ⊤
for (int j = i; j < s.size(); j++) {
if (!DP->subData[s[j]])
DP->subData[s[j]] = new data(make_pair(i + 1, j + 1));
DP = DP->subData[s[j]];
}
}
for (int i = s.size() - 1; i > -1; i--) {
data* DP = ⊤
for (int j = i; j > -1; j--) {
if (!DP->subData[s[j]])
DP->subData[s[j]] = new data(make_pair(i + 1, j + 1));
DP = DP->subData[s[j]];
}
}
int i = 0;
cin >> t;
vector<pair<int, int>> ans;
while (i < t.size()) {
if (!top.subData[t[i]]) break;
data* DP = ⊤
while (i < t.size() && DP->subData[t[i]]) {
DP = DP->subData[t[i]];
i++;
}
ans.push_back(DP->FL);
}
if (i < t.size())
cout << -1;
else {
cout << ans.size() << endl;
for (auto a : ans) {
printf("%d %d\n", a.first, a.second);
}
}
return 0;
}
|
#include <bits/stdc++.h>
typedef long double ld;
const long long INF = LLONG_MAX;
const long long NINF = LLONG_MIN;
const long long MAX = 1e6 + 5;
const long long MOD = 1e9 + 7;
using namespace std;
inline long long gcd(long long a, long long b) {
long long t;
if (a < b) {
a ^= b;
b ^= a;
a ^= b;
}
while (b != 0) {
t = a;
a = b;
b = t % b;
}
return a;
}
inline long long mpow(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b & 1) {
ans = ans * a;
}
a = a * a;
b >>= 1;
}
return ans;
}
long long KMP(string a, string b) {
char aa[a.size() + 1], bb[b.size() + 1];
for (long long i = 0; i < a.size(); i++) {
aa[i] = a[i];
}
aa[a.size()] = '\0';
for (long long i = 0; i < b.size(); i++) {
bb[i] = b[i];
}
bb[b.size()] = '\0';
if (strstr(bb, aa) != NULL) {
return strstr(bb, aa) - bb;
} else {
return -1;
}
}
int main() {
long long c, i, j, k, y, x;
string s, sx, ss, sxx, s1, s2;
vector<long long> v;
c = 0;
s = "";
sx = "";
cin >> s1 >> s2;
s2 += "*";
j = 0;
for (i = 0; i < s2.size(); i++) {
s = s + s2[i];
sx = s2[i] + sx;
if (KMP(s, s1) == -1 && KMP(sx, s1) == -1 && s.size() == 1) {
cout << "-1\n";
return 0;
} else if (KMP(s, s1) == -1 && KMP(sx, s1) == -1) {
ss = "";
for (k = 0; k < s.size() - 1; k++) {
ss += s[k];
}
sxx = "";
for (k = 1; k < sx.size(); k++) {
sxx += sx[k];
}
x = KMP(ss, s1);
y = KMP(sxx, s1);
if (x != -1) {
c++;
v.push_back(x);
v.push_back(x + ss.size() - 1);
} else if (y != -1) {
c++;
v.push_back(y + sxx.size() - 1);
v.push_back(y);
} else {
cout << "-1\n";
return 0;
}
s = s2[i];
sx = s2[i];
}
}
printf("%lld\n", c);
for (i = 0; i < c; i++) {
printf("%lld ", v[2 * i] + 1);
printf("%lld\n", v[2 * i + 1] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
string s, t, srev;
int n, m;
void prepare_pattern(const string &pat, vector<int> &T) {
int n = (int)pat.length();
T.assign(n + 1, -1);
for (int i = 1; i <= n; i++) {
int pos = T[i - 1];
while (pos != -1 && pat[pos] != pat[i - 1]) pos = T[pos];
T[i] = pos + 1;
}
}
vector<pair<int, int> > find_pattern(const string &s, const string &pat,
const vector<int> &T) {
int sp = 0, kp = 0;
int slen = (int)s.size(), plen = pat.size();
vector<pair<int, int> > res(plen + 1, pair<int, int>(-1, -1));
while (sp < slen) {
while (kp != -1 && (kp == plen || pat[kp] != s[sp])) kp = T[kp];
kp++;
sp++;
res[kp] = pair<int, int>(sp - kp, sp - 1);
}
return res;
}
int memo[3010];
pair<int, int> cons[3010];
int dp(int id) {
int &res = memo[id];
if (res != -1) return res;
if (id == n) return 0;
res = INF;
string tmp = string(t.begin() + id, t.end());
vector<int> T;
prepare_pattern(tmp, T);
vector<pair<int, int> > forwards = find_pattern(s, tmp, T);
vector<pair<int, int> > backwards = find_pattern(srev, tmp, T);
for (int len = 1; len <= (int)tmp.length(); len++) {
if (forwards[len].first != -1) {
if (1 + dp(id + len) < res) {
res = 1 + dp(id + len);
cons[id] = forwards[len];
}
} else if (backwards[len].first != -1) {
if (1 + dp(id + len) < res) {
res = 1 + dp(id + len);
cons[id] = {m - 1 - backwards[len].first,
m - 1 - backwards[len].second};
}
}
}
return memo[id] = res;
}
int main() {
cin >> s >> t;
srev = s;
reverse(srev.begin(), srev.end());
n = (int)t.size();
m = (int)s.size();
memset(memo, -1, sizeof memo);
int res = dp(0);
if (res == INF) {
cout << "-1\n";
return 0;
}
cout << res << "\n";
int id = 0;
while (id < n) {
pair<int, int> p = cons[id];
cout << p.first + 1 << ' ' << p.second + 1 << "\n";
id += abs(p.first - p.second) + 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000006;
struct substr_t {
int l, r;
};
struct link_t {
int l;
int next;
substr_t substr;
};
struct trie_t {
trie_t *p[26];
substr_t substr;
};
trie_t *new_trie(int l, int r) {
trie_t *t = new trie_t;
memset(t->p, 0, sizeof(t->p));
t->substr = {l, r};
return t;
}
int main() {
string s, t;
cin >> s >> t;
int sl = s.size();
int tl = t.size();
trie_t root = {};
for (int l = 0; (l) < (sl); ++(l)) {
trie_t *it = &root;
for (int r = (l + 1); (r) < (sl + 1); ++(r)) {
int i = s[r - 1] - 'a';
if (not it->p[i]) it->p[i] = new_trie(r, l + 1);
it = it->p[i];
}
}
for (int r = 0; (r) < (sl + 1); ++(r)) {
trie_t *it = &root;
for (int l = (r)-1; (l) >= 0; --(l)) {
int i = s[l] - 'a';
if (not it->p[i]) it->p[i] = new_trie(l + 1, r);
it = it->p[i];
}
}
vector<link_t> dp(tl + 1, (link_t){INF});
dp[0].l = 0;
for (int r = 0; (r) < (tl + 1); ++(r)) {
trie_t *it = &root;
for (int l = (r)-1; (l) >= 0; --(l)) {
int i = t[l] - 'a';
if (not it->p[i]) break;
it = it->p[i];
if (dp[l].l + 1 < dp[r].l) {
dp[r] = {dp[l].l + 1, l, it->substr};
}
}
}
if (dp[tl].l == INF) {
cout << -1 << endl;
} else {
cout << dp[tl].l << endl;
link_t it = dp[tl];
vector<link_t> lnks;
while (it.l) {
lnks.push_back(it);
it = dp[it.next];
}
reverse(lnks.begin(), lnks.end());
for (link_t lnk : lnks) {
cout << lnk.substr.l << ' ' << lnk.substr.r << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2207;
int n, m, l, p[MaxN][2];
char a[MaxN], b[MaxN];
int lcp[2][MaxN][MaxN];
int main() {
int i, j, k, s, t;
scanf("%s", b + 1);
m = strlen(b + 1);
scanf("%s", a + 1);
n = strlen(a + 1);
for (i = n; i >= 1; i--) {
for (j = m; j >= 1; j--)
if (a[i] == b[j]) lcp[0][i][j] = lcp[0][i + 1][j + 1] + 1;
for (j = 1; j <= m; j++)
if (a[i] == b[j]) lcp[1][i][j] = lcp[1][i + 1][j - 1] + 1;
}
for (i = 1; i <= n; i += s) {
s = 0;
t = k = -1;
for (j = 1; j <= m; j++) {
if (lcp[0][i][j] > s) s = lcp[0][i][j], k = j, t = 0;
if (lcp[1][i][j] > s) s = lcp[1][i][j], k = j, t = 1;
}
if (s == 0) {
printf("-1\n");
return 0;
} else {
l++;
if (t == 0)
p[l][0] = k, p[l][1] = k + s - 1;
else
p[l][0] = k, p[l][1] = k - s + 1;
}
}
printf("%d\n", l);
for (i = 1; i <= l; i++) printf("%d %d\n", p[i][0], p[i][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int frd[2110][2110], rev[2110][2110];
vector<int> v;
int main() {
int a, b, c, d, e, i, j, p, q, mx, mx1, len;
string x, y;
cin >> x >> y;
a = x.length();
b = y.length();
x = "%" + x;
y = "*" + y;
for (i = b; i >= 1; i--) {
for (j = a; j >= 1; j--) {
if (y[i] == x[j]) {
frd[i][j] = frd[i + 1][j + 1] + 1;
}
}
for (j = 1; j <= a; j++) {
if (y[i] == x[j]) {
rev[i][j] = rev[i + 1][j - 1] + 1;
}
}
}
for (i = 1; i <= b;) {
p = -1;
q = -1;
mx = -1;
mx1 = -1;
for (j = 1; j <= a; j++) {
if (frd[i][j] > mx) {
mx = frd[i][j];
p = j;
}
}
for (j = 1; j <= a; j++) {
if (rev[i][j] > mx1) {
mx1 = rev[i][j];
q = j;
}
}
len = max(mx, mx1);
if (len == 0) {
cout << "-1" << endl;
return 0;
}
if (len == mx) {
v.push_back(p);
v.push_back(p + len - 1);
} else {
v.push_back(q);
v.push_back(q - len + 1);
}
i = i + len;
}
cout << v.size() / 2 << endl;
e = v.size();
for (i = 0; i < e; i = i + 2) {
cout << v[i] << " " << v[i + 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[2200], b[2200], s[2200];
int mx, k, q, i, j, ct1, ct2, t, n, r, tt, p1[2200], p2[2200], ok;
int main() {
cin >> a;
cin >> s;
for (i = 0; a[i] != 0; i++) {
n++;
}
for (i = 0; s[i] != 0; i++) {
mx = 0;
r = 0;
ct1 = 1;
ct2 = 1;
for (j = 0; a[j] != 0; j++) {
if (a[j] == s[i]) {
ct1 = 1;
if (1 > mx) {
mx = 1;
q = j;
r = 1;
}
for (t = j + 1; a[t] != 0; t++) {
if (a[t] == s[i + ct1]) {
ct1++;
if (ct1 > mx) {
mx = ct1;
q = j;
r = 1;
}
} else
break;
}
}
}
for (j = n - 1; j >= 0; j--) {
if (a[j] == s[i]) {
ct2 = 1;
if (1 > mx) {
mx = 1;
q = j;
r = 2;
}
for (t = j - 1; t >= 0; t--) {
if (a[t] == s[i + ct2]) {
ct2++;
if (ct2 > mx) {
mx = ct2;
q = j;
r = 2;
}
} else
break;
}
}
}
if (r == 1) {
tt++;
p1[tt] = q + 1;
p2[tt] = q + mx;
i = i + mx - 1;
} else if (r == 2) {
tt++;
p1[tt] = q + 1;
p2[tt] = q + 1 - mx + 1;
i = i + mx - 1;
} else if (ok == 0) {
cout << "-1";
ok = 1;
break;
}
}
if (ok == 0) {
cout << tt << "\n";
for (i = 1; i <= tt; i++) {
cout << p1[i] << " " << p2[i] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e6;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
vector<int> kmp(string s) {
int n = s.size();
vector<int> f(n);
for (int i = 1; i < n; i++) {
int j = f[i - 1];
while (j and s[i] != s[j]) j = f[j - 1];
j += (s[i] == s[j]), f[i] = j;
}
return (f);
}
string s, r;
string t;
int cnt[27], ans;
vector<int> f, fr;
vector<pair<int, int> > an;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s >> t;
r = s;
reverse(r.begin(), r.end());
for (auto i : t) cnt[i - 'a'] = 1;
for (auto i : s) cnt[i - 'a'] = 0;
for (int i = 0; i < 27; i++)
if (cnt[i]) return (cout << -1, 0);
;
while (t.size()) {
int m = t.size(), n = s.size();
f = kmp(t + "&" + s);
fr = kmp(t + "&" + r);
int l = 0, r = 0;
int mx = 0;
for (int i = m + 1; i < (int)f.size(); i++) {
if (f[i] > mx) {
r = i - m;
l = i - m - f[i] + 1;
mx = f[i];
}
if (fr[i] > mx) {
r = i - m;
l = i - m - fr[i] + 1;
mx = fr[i];
l = n - (l - 1);
r = n - (r - 1);
}
}
string boz = "";
for (int i = 0; i < m; i++)
if (i >= mx) boz += t[i];
an.push_back({l, r});
t = boz;
ans++;
}
cout << ans << '\n';
for (auto [i, j] : an) cout << i << ' ' << j << '\n';
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
long lcpts[2500][2500], lcprev[2500][2500];
int main() {
string s, l;
cin >> l >> s;
long m, n;
m = s.size();
n = l.size();
s = "@" + s + "(";
l = "^" + l + "!";
for (int i = m; i >= 1; i--) {
for (int j = n; j >= 1; j--) {
if (s[i] == l[j]) lcpts[i][j] = lcpts[i + 1][j + 1] + 1;
}
for (int j = 1; j <= n; j++) {
if (s[i] == l[j]) lcprev[i][j] = lcprev[i + 1][j - 1] + 1;
}
}
vector<pair<long, long> > ans;
for (int i = 1; i <= m;) {
int i1 = max_element(lcpts[i] + 1, lcpts[i] + n + 1) - lcpts[i];
int i2 = max_element(lcprev[i] + 1, lcprev[i] + n + 1) - lcprev[i];
long len = max(lcpts[i][i1], lcprev[i][i2]);
if (len == 0) {
cout << "-1";
return 0;
}
if (len == lcpts[i][i1]) {
ans.push_back({i1, i1 + len - 1});
} else {
ans.push_back({i2, i2 - len + 1});
}
i += len;
}
long len = ans.size();
cout << len << endl;
for (int i = 0; i < len; i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const double EXP = 2.7182818284590452;
const double Pi = 3.14159265;
const double EPS = 1e-13;
const int INF = 1000 * 1000 * 1001;
const long long INFL = (long long)INF * (long long)INF;
map<pair<long long, long long>, long long> hashgcd;
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (hashgcd.find(std::make_pair(a, b)) != hashgcd.end())
return hashgcd[std::make_pair(a, b)];
while (b != 0) {
a %= b;
swap(a, b);
}
hashgcd[std::make_pair(a, b)] = a;
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long extgcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x11, y11;
long long d = extgcd(b % a, a, x11, y11);
x = y11 - (b / a) * x11;
y = x11;
return d;
}
long long poww(long long v, long long p, long long mod) {
if (p == 0) return 1;
if (p & 1) {
return (poww(v, p - 1, mod) * v) % mod;
} else {
long long t = poww(v, p / 2, mod);
return (t * t) % mod;
}
}
const unsigned long long L31018 = 3000000000000000000L;
string s, t;
string rstr, str;
int cur = 0, len;
int d[10004];
pair<int, int> p1, p2;
vector<std::pair<int, int> > seq;
pair<int, int> kmp(string& S) {
int l = S.length(), j, mmax = len + 1;
std::pair<int, int> res = std::make_pair(-1, -1);
d[cur] = 0;
for (int i = ((cur + 1)); i < (l); ++i) {
j = d[i - 1];
while (j > 0 && S[i] != S[j + cur]) j = d[j - 1 + cur];
if (S[i] == S[j + cur]) ++j;
d[i] = j;
}
for (int i = ((len + 1)); i < (l); ++i) {
if (d[mmax] < d[i]) mmax = i;
}
if (d[mmax] != 0) {
res = std::make_pair(mmax - len - d[mmax], mmax - len - 1);
}
return res;
}
void accept() {
cin >> s >> t;
str = t + "#";
str += s;
reverse(s.begin(), s.end());
rstr = t + "#";
rstr += s;
len = t.length();
while (cur < len) {
p1 = kmp(str);
p2 = kmp(rstr);
if (p1.first == -1 && p2.first == -1) {
cout << -1;
return;
}
if (p1.second - p1.first >= p2.second - p2.first) {
seq.push_back(p1);
cur += p1.second - p1.first + 1;
} else {
p1 = p2;
p2.first = s.length() - p1.first - 1;
p2.second = s.length() - p1.second - 1;
seq.push_back(p2);
cur += p1.second - p1.first + 1;
}
}
cout << seq.size() << "\n";
for (int i = (0); i < (seq.size()); ++i) {
printf("%d %d\n", seq[i].first + 1, seq[i].second + 1);
}
}
int main(void) {
accept();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
using namespace std;
using ld = long double;
using lli = long long;
using ii = pair<int, int>;
using vi = vector<int>;
struct SuffixAutomaton {
struct Node : map<char, int> {
int link = -1;
int len = 0;
int pos = 0;
};
vector<Node> trie;
int last;
SuffixAutomaton() { last = newNode(); }
int newNode() {
trie.push_back({});
return int(trie.size()) - 1;
}
void extend(char c) {
int u = newNode();
trie[u].len = trie[last].len + 1;
trie[u].pos = trie[u].len - 1;
int p = last;
while (p != -1 && !trie[p].count(c)) {
trie[p][c] = u;
p = trie[p].link;
}
if (p == -1)
trie[u].link = 0;
else {
int q = trie[p][c];
if (trie[p].len + 1 == trie[q].len)
trie[u].link = q;
else {
int clone = newNode();
trie[clone] = trie[q];
assert(trie[clone].pos == trie[q].pos);
trie[clone].len = trie[p].len + 1;
while (p != -1 && trie[p][c] == q) {
trie[p][c] = clone;
p = trie[p].link;
}
trie[q].link = trie[u].link = clone;
}
}
last = u;
}
int leftmost(string &second, int l, int r, int u = 0) {
int len = r - l + 1;
for (; l <= r; l++) {
char c = second[l];
if (!trie[u].count(c)) return -1;
u = trie[u][c];
}
return trie[u].pos - len + 1;
}
Node &operator[](int u) { return trie[u]; }
} sam[2];
const int N = 2101, inf = 1e9;
int mem[N];
string second[2], want;
template <class T>
void umin(T &a, T b) {
a = min(a, b);
}
int dp(int i) {
if (i >= int(want.size())) return 0;
int &ans = mem[i];
if (ans == -1) {
ans = inf;
for (auto k = (0) - ((0) > (2)); k != (2) - ((0) > (2));
k += 1 - 2 * ((0) > (2))) {
int u = 0;
for (int j = i; j < int(want.size()); j++) {
char c = want[j];
u = sam[k][u][c];
if (u == 0) {
break;
}
umin(ans, dp(j + 1) + 1);
}
}
}
return ans;
}
void solve(int i) {
if (i >= int(want.size())) {
cout << '\n';
return;
}
int ans = inf;
ii go = {-1, -1};
for (auto k = (0) - ((0) > (2)); k != (2) - ((0) > (2));
k += 1 - 2 * ((0) > (2))) {
int u = 0;
for (int j = i; j < int(want.size()); j++) {
char c = want[j];
u = sam[k][u][c];
if (u == 0) {
break;
}
if (dp(j + 1) + 1 < ans) {
ans = dp(j + 1) + 1;
go.first = j;
go.second = k;
}
}
}
int len = go.first - i + 1;
;
int pos = sam[go.second].leftmost(want, i, go.first);
int l = pos + 1, r = pos + len;
;
if (go.second) {
;
cout << int(second[1].size()) - l + 1 << " "
<< int(second[1].size()) - r + 1 << '\n';
} else {
;
cout << l << " " << r << '\n';
};
solve(go.first + 1);
}
int main() {
cin.tie(0)->sync_with_stdio(0), cout.tie(0);
while (cin >> second[0] >> want) {
second[1] = second[0];
reverse(begin(second[1]), end(second[1]));
;
for (auto k = (0) - ((0) > (2)); k != (2) - ((0) > (2));
k += 1 - 2 * ((0) > (2))) {
sam[k] = SuffixAutomaton();
for (char c : second[k]) sam[k].extend(c);
}
memset(mem, -1, sizeof(mem));
int mn = dp(0);
if (mn < inf) {
cout << mn << '\n';
solve(0);
} else {
cout << -1 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int add(int a, int b, int m = 1000000007) {
a += b;
if (a >= m) a -= m;
return a;
}
inline int mul(int a, int b, int m = 1000000007) {
return (int)(((long long)a * (long long)b) % m);
}
inline int norm(int x, int m = 1000000007) {
if (x >= m) x %= m;
if (x < 0) x += m;
return x;
}
inline int neg(int x, int m = 1000000007) {
x = -x;
return norm(x);
}
vector<int> z_function(string s) {
int n = s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
int ns, nt;
ns = int((s).size()), nt = int((t).size());
string sr = s;
reverse((sr).begin(), (sr).end());
int i = 0;
vector<pair<int, int> > yay;
bool gg = 0;
while (i < nt) {
string a, b;
for (int j = i; j <= nt - 1; ++j) a += t[j];
a += "#";
b = a;
a += s;
b += sr;
vector<int> za = z_function(a);
vector<int> zb = z_function(b);
int val = 0;
pair<int, int> ans;
for (int j = nt + 1 - i; j <= int((za).size()) - 1; ++j) {
if (za[j] > val) {
val = za[j];
ans.first = j - (nt + 1 - i);
ans.second = j - (nt + 1 - i) + za[j] - 1;
}
}
for (int j = nt + 1 - i; j <= int((zb).size()) - 1; ++j) {
if (zb[j] > val) {
val = zb[j];
ans.first = j - (nt + 1 - i);
ans.second = j - (nt + 1 - i) + zb[j] - 1;
ans.first = ns - ans.first - 1;
ans.second = ns - ans.second - 1;
if (ans.first <= ans.second) swap(ans.first, ans.second);
}
}
i += val;
if (val == 0) {
cout << "-1\n";
return 0;
}
yay.push_back(ans);
}
cout << int((yay).size()) << "\n";
for (auto it = (yay).begin(); it != (yay).end(); ++it) {
cout << it->first + 1 << " " << it->second + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string start, end;
cin >> start >> end;
string srev = start;
reverse(srev.begin(), srev.end());
vector<int> vs[26], vr[26];
int slen = start.length();
for (int i = 0; i < slen; i++) {
vs[start[i] - 'a'].push_back(i);
vr[srev[i] - 'a'].push_back(i);
}
int elen = end.length();
bool flag = true;
for (int i = 0; i < elen; i++) {
if (vs[end[i] - 'a'].size() == 0) {
flag = false;
break;
}
}
if (!flag)
cout << -1 << endl;
else {
int no = 0;
vector<pair<int, int> > res;
for (int i = 0; i < elen;) {
int size = vs[end[i] - 'a'].size();
pair<int, int> p;
int maxl, ans = 0, index, tmp;
for (int j = 0; j < size; j++) {
index = vs[end[i] - 'a'][j];
tmp = index;
maxl = i;
while ((index < slen - 1) && (maxl < elen - 1) &&
start[index + 1] == end[maxl + 1]) {
index++;
maxl++;
}
if (maxl - i + 1 > ans) {
ans = maxl - i + 1;
p = make_pair(tmp, index);
}
}
maxl = i;
for (int j = 0; j < size; j++) {
index = vr[end[i] - 'a'][j];
tmp = index;
maxl = i;
while ((index < slen - 1) && (maxl < elen - 1) &&
srev[index + 1] == end[maxl + 1]) {
index++;
maxl++;
}
if (maxl - i + 1 > ans) {
ans = maxl - i + 1;
p = make_pair(slen - 1 - tmp, slen - 1 - index);
}
}
i += ans;
no++;
res.push_back(p);
}
cout << no << endl;
for (int i = 0; i < res.size(); i++)
cout << res[i].first + 1 << " " << res[i].second + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MM = 2105, MOD = 1e9 + 7;
int N, M, fwd[MM][MM], bwd[MM][MM];
vector<pair<int, int>> vec;
string s, t;
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
cin >> s >> t;
N = s.size();
M = t.size();
s = "!" + s + "@";
t = "#" + t + "$";
for (int i = M; i >= 1; --i)
for (int j = N; j >= 1; --j)
if (t[i] == s[j]) fwd[i][j] = fwd[i + 1][j + 1] + 1;
for (int i = M; i >= 1; --i)
for (int j = 1; j <= N; ++j)
if (t[i] == s[j]) bwd[i][j] = bwd[i + 1][j - 1] + 1;
int idx = 1;
while (idx <= M) {
int flrg = 0, fw = 0, blrg = 0, bw = 0;
for (int j = 1; j <= N; ++j)
if (fwd[idx][j] > flrg) flrg = fwd[idx][j], fw = j;
for (int j = 1; j <= N; ++j)
if (bwd[idx][j] > blrg) blrg = bwd[idx][j], bw = j;
if (max(flrg, blrg) == 0) {
cout << -1 << "\n";
return 0;
}
if (max(flrg, blrg) == flrg) {
vec.emplace_back(fw, fw + flrg - 1);
} else {
vec.emplace_back(bw, bw - blrg + 1);
}
idx += max(flrg, blrg);
}
cout << vec.size() << "\n";
for (pair<int, int> &e : vec) {
cout << e.first << " " << e.second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = ((ans % m) * (a % m)) % m;
b /= 2;
a = ((a % m) * (a % m)) % m;
}
return ans % m;
}
const long double eps = 1e-10L;
vector<int> g[30];
string s, t;
int dp[2200];
int lcp[2200][2200];
int lcp_prev[2200][2200];
void LCP() {
int m = t.length();
int n = s.length();
for (int i = m - 1; i >= 0; i--)
for (int j = n - 1; j >= 0; j--)
if (t[i] == s[j]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
for (int i = m - 1; i >= 0; i--)
for (int j = 0; j < n; j++)
if (t[i] == s[j]) {
if (j - 1 >= 0)
lcp_prev[i][j] = lcp_prev[i + 1][j - 1] + 1;
else
lcp_prev[i][j] = 1;
}
}
int solve(int x) {
if (x >= t.length()) return 0;
if (dp[x] != -1) return dp[x];
int ans = 1000000;
int id = t[x] - 'a';
for (int i = 0; i < g[id].size(); i++) {
int l = g[id][i];
ans = min(ans, 1 + solve(x + lcp[x][l]));
ans = min(ans, 1 + solve(x + lcp_prev[x][l]));
}
return dp[x] = ans;
}
void print(int x) {
if (x >= t.length()) return;
int ans = 1000000;
int id = t[x] - 'a';
for (int i = 0; i < g[id].size(); i++) {
int l = g[id][i];
if (dp[x] == 1 + solve(x + lcp[x][l])) {
cout << l + 1 << " " << l + lcp[x][l] << "\n";
print(x + lcp[x][l]);
return;
}
ans = min(ans, 1 + solve(x + lcp_prev[x][l]));
if (dp[x] == 1 + solve(x + lcp_prev[x][l])) {
cout << l + 1 << " " << l - lcp_prev[x][l] + 2 << "\n";
print(x + lcp_prev[x][l]);
return;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> s >> t;
for (int i = 0; i < s.length(); i++) g[s[i] - 'a'].push_back(i);
LCP();
memset(dp, -1, sizeof dp);
int ans = solve(0);
if (ans == 1000000) {
cout << "-1";
return 0;
}
cout << ans << "\n";
print(0);
}
|
#include <bits/stdc++.h>
using namespace std;
void begin() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void end() {
fclose(stdin);
fclose(stdout);
}
template <class TAT>
void read(TAT &a) {
static char cc;
static bool fff;
while (((cc = getchar()) < '0' || cc > '9') && cc != '-')
;
if (cc == '-')
fff = 1, a = 0;
else
fff = 0, a = cc - 48;
while ((cc = getchar()) >= '0' && cc <= '9') a = a * 10 + cc - 48;
if (fff) a = -a;
}
template <class TAT>
void write(TAT a) {
static char cc[25];
static int ct;
if (a == 0) {
putchar('0');
return;
}
if (a < 0) {
putchar('-');
a = -a;
}
ct = 0;
while (a) {
cc[++ct] = a % 10 + 48;
a /= 10;
}
while (ct) {
putchar(cc[ct--]);
}
}
template <class TAT>
void Ckmin(TAT &a, const TAT &b) {
if (a > b) a = b;
}
template <class TAT>
void Ckmax(TAT &a, const TAT &b) {
if (a < b) a = b;
}
const int maxn = 5205;
int n, m;
char A[maxn] = {0};
char B[maxn] = {0};
int Long[maxn][3] = {0};
int f[maxn] = {0};
int from[maxn] = {0};
int out[maxn][3], ott = 0;
void Init() {
memset(f, 0x3f, sizeof(f));
f[0] = 0;
scanf("%s%s", B, A);
n = strlen(A);
m = strlen(B);
}
void Prepare() {
register int i, j, k;
register int last;
for (i = m; i <= n + 1; ++i) B[i] = '&';
A[n] = '*';
for (i = -(n - 1); i < m; ++i) {
last = 0;
for (j = 0; j <= n; ++j) {
if (i + j < 0)
last = j + 1;
else if (B[i + j] != A[j]) {
for (k = last; k < j; ++k) {
if (Long[k + 1][0] < j - k) {
Long[k + 1][0] = j - k;
Long[k + 1][1] = i + k;
Long[k + 1][2] = 0;
}
}
last = j + 1;
}
}
}
reverse(B, B + m);
for (i = -(n - 1); i < m; ++i) {
last = 0;
for (j = 0; j <= n; ++j) {
if (i + j < 0)
last = j + 1;
else if (B[i + j] != A[j]) {
for (k = last; k < j; ++k) {
if (Long[k + 1][0] < j - k) {
Long[k + 1][0] = j - k;
Long[k + 1][1] = i + k;
Long[k + 1][2] = 1;
}
}
last = j + 1;
}
}
}
}
void Solve() {
register int i, j, k;
f[0] = 0;
for (i = 0; i < n; ++i) {
for (j = Long[i + 1][0]; j >= 1; --j) {
if (f[i + j] > f[i] + 1) {
f[i + j] = f[i] + 1;
from[i + j] = i;
}
}
}
if (f[n] > 2e8) {
puts("-1");
return;
} else {
write(f[n]);
putchar('\n');
int now, last;
now = from[n], last = n;
while (last != 0) {
++ott;
if (Long[now + 1][2] == 0) {
out[ott][0] = Long[now + 1][1] + 1;
out[ott][1] = out[ott][0] + (last - now) - 1;
} else {
out[ott][0] = m - Long[now + 1][1];
out[ott][1] = out[ott][0] - (last - now - 1);
}
last = now;
now = from[now];
}
for (i = ott; i >= 1; --i) {
printf("%d %d\n", out[i][0], out[i][1]);
}
}
}
int main() {
Init();
Prepare();
Solve();
end();
return 0;
}
|
#include <bits/stdc++.h>
int t[3000], next[3000], d[3000], e[3000][3000], r[3000][3000], l[3000];
char a[3000], b[3000];
void baga(int p) {
if (p == 0) {
return;
}
baga(next[p]);
if (t[p] > 0) {
fprintf(stdout, "%d %d\n", t[p] - (p - next[p]) + 1, t[p]);
} else {
fprintf(stdout, "%d %d\n", -t[p] + (p - next[p] - 1), -t[p]);
}
}
int main() {
int ans, n, m, i, j, k;
char ch, aux;
ch = fgetc(stdin);
n = 0;
while (ch != '\n') {
a[++n] = ch;
ch = fgetc(stdin);
}
ch = fgetc(stdin);
m = 0;
while (ch != '\n') {
b[++m] = ch;
ch = fgetc(stdin);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i] == b[j]) {
e[i][j] = e[i - 1][j - 1] + 1;
if (e[i][j] > l[j]) {
l[j] = e[i][j];
t[j] = i;
}
}
}
}
for (i = 1, j = n; i < j; i++, j--) {
aux = a[i];
a[i] = a[j];
a[j] = aux;
}
for (i = 1, k = n; i <= n; i++, k--) {
for (j = 1; j <= m; j++) {
if (a[i] == b[j]) {
r[i][j] = r[i - 1][j - 1] + 1;
if (r[i][j] > l[j]) {
l[j] = r[i][j];
t[j] = -k;
}
}
}
}
ans = n;
for (i = 1; i <= m; i++) {
if (l[i] == 0) {
ans = 0;
}
}
for (i = 1; i <= m; i++) {
d[i] = m + 1;
for (j = 1; j <= l[i]; j++) {
if (d[i] > d[i - j] + 1) {
d[i] = d[i - j] + 1;
next[i] = i - j;
}
}
}
if (ans == 0) {
fprintf(stdout, "-1\n");
} else {
fprintf(stdout, "%d\n", d[m]);
baga(m);
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct state {
int len, it, e;
state(int len, int it, int e) : len(len), it(it), e(e) {}
};
const int N = 3001, oo = 2e9;
int n, m, dp[N];
char a[N], b[N];
vector<int> node(26, -1), E;
vector<vector<int> > g;
vector<pair<int, int> > sol;
vector<state> can[N];
void add(int s, int it) {
int cur = 0;
for (int i = s; i < n; ++i) {
if (g[cur][a[i] - 'a'] == -1) {
g[cur][a[i] - 'a'] = g.size();
g.push_back(node);
E.push_back(-1);
}
cur = g[cur][a[i] - 'a'];
if (!it)
E[cur] = i;
else
E[cur] = n - s - 1;
}
}
void find(int s, int it) {
int cur = 0, len = 1;
for (int i = s; i < m; ++i) {
if (g[cur][b[i] - 'a'] == -1) return;
cur = g[cur][b[i] - 'a'];
can[s].push_back(state(len++, it, E[cur]));
}
}
int calc(int at) {
if (at == m) return 0;
int &res = dp[at];
if (res != -1) return res;
res = oo;
for (size_t i = 0; i < can[at].size(); ++i)
res = min(res, calc(at + can[at][i].len) + 1);
return res;
}
void path(int at) {
if (at == m) return;
int res = calc(at);
for (size_t i = 0; i < can[at].size(); ++i)
if (calc(at + can[at][i].len) + 1 == res) {
int s = can[at][i].e - can[at][i].len + 1;
if (!can[at][i].it)
sol.push_back(make_pair(s, can[at][i].e));
else
sol.push_back(make_pair(can[at][i].e, s));
path(at + can[at][i].len);
return;
}
}
int main() {
scanf("%s%s", a, b);
n = strlen(a);
m = strlen(b);
for (int it = 0; it < 2; ++it) {
g.push_back(node);
E.push_back(-1);
for (int i = 0; i < n; ++i) add(i, it);
for (int i = 0; i < m; ++i) find(i, it);
g.clear();
E.clear();
reverse(a, a + n);
}
memset(dp, -1, sizeof dp);
int res = calc(0);
if (res == oo) {
puts("-1");
return 0;
}
printf("%d\n", res);
path(0);
for (size_t i = 0; i < sol.size(); ++i)
printf("%d %d\n", sol[i].first + 1, sol[i].second + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modulo(long long a, long long b, long long c) {
long long x = 1LL, y = a;
while (b > 0LL) {
if (b % 2LL == 1LL) {
x = (x * y) % c;
}
y = (y * y) % c;
b /= 2LL;
}
return x % c;
}
int lps[2109][2109];
void computeLPSArray(char *pat, int st, int M) {
int len = st;
int i;
lps[st][st] = st;
i = st + 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[st][i] = len;
i++;
} else {
if (len != st)
len = lps[st][len - 1];
else {
lps[st][i] = st;
i++;
}
}
}
}
int KMPSearch(char *txt, char *pat, int st, int en) {
int N = strlen(txt);
int M = en + 1;
int j = st;
int i = 0;
while (i < N) {
if (pat[j] == txt[i]) {
j++;
i++;
}
if (j == M) {
return 1;
j = lps[st][j - 1];
} else if (i < N && pat[j] != txt[i]) {
if (j != st)
j = lps[st][j - 1];
else
i = i + 1;
}
}
return 0;
}
int func(char *txt, char *pat, int st, int en) {
int N = strlen(txt);
int M = en + 1;
int j = st;
int i = 0;
while (i < N) {
if (pat[j] == txt[i]) {
j++;
i++;
}
if (j == M) {
return (i - (en - st + 1));
j = lps[st][j - 1];
} else if (i < N && pat[j] != txt[i]) {
if (j != st)
j = lps[st][j - 1];
else
i = i + 1;
}
}
return -1;
}
char s1[100011], s2[10001], s3[10011];
int dp[10011], par[10011], n1[10011], n2[10011];
vector<pair<int, int> > v;
int c[50];
int main() {
gets(s1);
gets(s2);
int i, j, n = strlen(s1), m = strlen(s2);
for (i = 0; i < n; i++) c[s1[i] - 'a'] = 1;
for (i = 0; i < m; i++)
if (c[s2[i] - 'a'] == 0) break;
if (i != m) {
printf("-1\n");
return 0;
}
for (i = 0; i < n; i++) s3[i] = s1[n - i - 1];
s3[n] = '\0';
for (i = 0; i < m; i++) computeLPSArray(s2, i, m);
for (j = 0; j < m; j++) dp[j] = 1000000000;
for (i = 0; i < m; i++) {
int l = 1, r = m - i, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (KMPSearch(s1, s2, i, i + mid - 1) ||
KMPSearch(s3, s2, i, i + mid - 1))
ans = max(ans, mid), l = mid + 1;
else
r = mid - 1;
}
for (j = i; j < i + ans; j++) {
int y;
if (i == 0)
y = 0;
else
y = dp[i - 1];
if (y + 1 < dp[j]) {
dp[j] = y + 1;
par[j] = i - 1;
int y = func(s1, s2, i, j);
if (y == -1) {
y = func(s3, s2, i, j);
y = n - y - 1;
n2[j] = y - (j - i);
n1[j] = y;
} else {
n1[j] = y;
n2[j] = y + (j - i);
}
}
}
}
if (dp[m - 1] == 1000000000) {
printf("-1\n");
return 0;
}
i = m - 1;
while (i != -1) {
v.push_back(make_pair(n1[i], n2[i]));
i = par[i];
}
printf("%d\n", v.size());
reverse(v.begin(), v.end());
for (i = 0; i < v.size(); i++)
printf("%d %d\n", v[i].first + 1, v[i].second + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
const int N = 1e6 + 10;
vector<pair<int, int> > kq;
string s, t;
pair<int, int> check(int x) {
int rel = -1;
int rer = -1;
for (int i = 0; i < s.size(); i++) {
if (s[i] != t[x]) continue;
int yes = 0;
while ((i + yes < s.size()) && (x + yes < t.size()))
if (s[i + yes] == t[x + yes])
yes++;
else
break;
if (yes != 0) {
if ((rel == -1) || ((abs(rel - rer) + 1) < yes)) {
rel = i;
rer = i + yes - 1;
}
}
yes = 0;
while ((i - yes >= 0) && (x + yes < t.size()))
if (s[i - yes] == t[x + yes])
yes++;
else
break;
if (yes != 0) {
if ((rel == -1) || ((abs(rel - rer) + 1) < yes)) {
rel = i;
rer = i - yes + 1;
}
}
}
return make_pair(rel, rer);
}
void xuly() {
int i = 0;
pair<int, int> x;
while (i < t.size()) {
x = check(i);
if (x.first == -1) {
cout << -1;
return;
}
kq.push_back(x);
i += abs(x.first - x.second) + 1;
}
cout << kq.size() << "\n";
for (int k = 0; k < kq.size(); k++) {
cout << kq[k].first + 1 << " " << kq[k].second + 1 << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> s;
cin >> t;
xuly();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, v[2200][2], x, i, m, ok;
char s1[2200], s2[2200];
int caut(int x) {
int j = x, i = 0, i1, i2, mx = 0, nr;
while (i < n && j < m) {
nr = 0;
while (s1[i] == s2[j] && i < n && j < m) i++, j++, nr++;
if (nr > mx) {
i1 = i - nr + 1;
i2 = i;
mx = nr;
}
j -= nr;
i -= nr - 1;
}
j = x;
i = n - 1;
while (i >= 0 && j < m) {
nr = 0;
while (s1[i] == s2[j] && i >= 0 && j < m) i--, j++, nr++;
if (nr > mx) {
i1 = i + nr + 1;
i2 = i + 2;
mx = nr;
}
j -= nr;
i += nr - 1;
}
p++;
v[p][0] = i1;
v[p][1] = i2;
return mx;
}
int main() {
cin.getline(s1, 2200);
cin.getline(s2, 2200);
i = 0;
n = strlen(s1);
m = strlen(s2);
while (i < m) {
x = caut(i);
if (x)
i += x;
else {
cout << -1;
ok = 1;
break;
}
}
if (!ok) {
cout << p << '\n';
for (i = 1; i <= p; i++) cout << v[i][0] << ' ' << v[i][1] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[2110], b[2110], c[2110];
cin >> a >> b;
int la = strlen(a), lb = strlen(b);
int i, j, p[2110];
for (i = 0; i < la; i++) c[i] = a[la - i - 1];
int k1, k2, o1, o2, len = 0, ans[2110][2];
while (lb = strlen(b), lb) {
p[0] = j = -1;
for (i = 1; i < lb; i++) {
while (j >= 0 && b[j + 1] != b[i]) j = p[j];
if (b[j + 1] == b[i]) j++;
p[i] = j;
}
j = -1;
k1 = o1 = 0;
for (i = 0; i < la; i++) {
while (j >= 0 && b[j + 1] != a[i]) j = p[j];
if (b[j + 1] == a[i]) j++;
if (j >= k1) k1 = j + 1, o1 = i + 1;
}
j = -1;
k2 = o2 = 0;
for (i = 0; i < la; i++) {
while (j >= 0 && b[j + 1] != c[i]) j = p[j];
if (b[j + 1] == c[i]) j++;
if (j >= k2) k2 = j + 1, o2 = i + 1;
}
if (k1 == 0 && k2 == 0) {
cout << -1;
return 0;
}
if (k1 >= k2) {
ans[len][0] = o1 - k1 + 1;
ans[len][1] = o1;
for (i = k1; i < lb; i++) b[i - k1] = b[i];
b[lb - k1] = '\0';
} else {
ans[len][0] = la - o2 + k2;
ans[len][1] = la - o2 + 1;
for (i = k2; i < lb; i++) b[i - k2] = b[i];
b[lb - k2] = '\0';
}
len++;
}
cout << len << endl;
for (i = 0; i < len; i++) cout << ans[i][0] << ' ' << ans[i][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vrr;
int main() {
long long l, r, x, i, was, y, le;
string s, t;
cin >> s >> t;
le = 0;
while (le < t.size()) {
was = 0;
for (i = 0; i < s.size(); i++) {
if (s[i] == t[le]) {
x = i;
y = le;
while ((x < s.size()) && (y < t.size()) && (s[x] == t[y])) {
x++;
y++;
}
y--;
x--;
if (was == 0) {
l = i;
r = x;
} else if (abs(r - l) < abs(i - x)) {
l = i;
r = x;
}
was = 1;
}
}
for (i = s.size() - 1; i >= 0; i--) {
if (s[i] == t[le]) {
x = i;
y = le;
while ((0 <= x) && (y < t.size()) && (s[x] == t[y])) {
x--;
y++;
}
y--;
x++;
if (was == 0) {
l = i;
r = x;
} else if (abs(r - l) < abs(i - x)) {
l = i;
r = x;
}
was = 1;
}
}
if (was == 0) {
cout << "-1";
return 0;
}
vrr.push_back(make_pair(l, r));
le += abs(r - l) + 1;
}
cout << vrr.size() << '\n';
for (i = 0; i < vrr.size(); i++) {
cout << vrr[i].first + 1 << " " << vrr[i].second + 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
string s_rev(s.rbegin(), s.rend());
vector<vector<int> > lcp(s.size() + 1, vector<int>(t.size() + 1));
vector<vector<int> > lcp_rev(s.size() + 1, vector<int>(t.size() + 1));
for (int i_s = s.size() - 1; i_s >= 0; --i_s) {
for (int j_t = t.size() - 1; j_t >= 0; --j_t) {
if (s[i_s] == t[j_t]) {
lcp[i_s][j_t] = lcp[i_s + 1][j_t + 1] + 1;
}
if (s_rev[i_s] == t[j_t]) {
lcp_rev[i_s][j_t] = lcp_rev[i_s + 1][j_t + 1] + 1;
}
}
}
vector<pair<int, int> > ans;
for (int i_t = 0; i_t < t.size();) {
int cur_max = 0;
pair<int, int> cand;
for (int j_s = 0; j_s < s.size(); ++j_s) {
if (lcp[j_s][i_t] > cur_max) {
cur_max = lcp[j_s][i_t];
cand = make_pair(j_s, j_s + cur_max - 1);
}
if (lcp_rev[j_s][i_t] > cur_max) {
cur_max = lcp_rev[j_s][i_t];
cand =
make_pair(s.size() - 1 - j_s, s.size() - 1 - (j_s + cur_max - 1));
}
}
if (!cur_max) {
cout << -1 << endl;
return 0;
}
ans.push_back(cand);
i_t += cur_max;
}
cout << ans.size() << endl;
for (auto&& pa : ans) {
cout << (pa.first + 1) << " " << (pa.second + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
int f;
} a[2100];
string s1, s2, s1rev;
int find(string s, int count, int len2, int &fl, int &fr) {
int len = s.size();
int j;
int max = 0;
int l = 0, r = 0;
for (int i = 0; i < len; ++i) {
int flag = 0;
if (s[i] == s2[count]) {
flag = 1;
for (j = 1; j + i < len && j + count < len2; ++j) {
if (s[i + j] != s2[count + j]) break;
}
l = i, r = i + j - 1;
}
if (flag && r - l + 1 > max) {
max = r - l + 1;
fl = l, fr = r;
}
}
return max;
}
int main() {
cin >> s1 >> s2;
s1rev = s1;
reverse(s1rev.begin(), s1rev.end());
int len1, len2;
int l1, l2, r1, r2;
int count = 0;
len1 = s1.size();
len2 = s2.size();
bool flag = true;
int ans = 0;
while (count < len2) {
int max1 = find(s1, count, len2, l1, r1);
int max2 = find(s1rev, count, len2, l2, r2);
ans++;
if (max1 == 0 && max2 == 0) {
flag = false;
break;
} else if (max1 >= max2) {
a[ans].l = l1;
a[ans].r = r1;
a[ans].f = 1;
count += max1;
} else {
a[ans].l = l2;
a[ans].r = r2;
a[ans].f = 0;
count += max2;
}
}
if (!flag)
cout << "-1\n";
else {
cout << ans << '\n';
for (int i = 1; i <= ans; ++i) {
if (a[i].f) {
cout << a[i].l + 1 << " " << a[i].r + 1 << "\n";
} else {
cout << len1 - a[i].l << " " << len1 - a[i].r << "\n";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
class SuffixAutomata {
public:
struct state {
int len, link, pos;
std::map<char, int> next;
};
state st[17000];
int sz, last;
void buildSuffixAutomata(std::string str) {
sz = last = 0;
st[0].len = 0;
st[0].pos = -1;
st[0].link = -1;
++sz;
for (auto c : str) {
add(c);
}
}
int go(int ver, char c, int &len, int &pos) {
while (ver != 0 && st[ver].next.find(c) == st[ver].next.end()) {
ver = st[ver].link;
}
if (st[ver].next.find(c) == st[ver].next.end()) {
len = -1;
ver = 0;
} else {
len = st[ver].len + 1;
ver = st[ver].next[c];
pos = st[ver].pos;
}
return ver;
}
private:
void add(char c) {
int cur = sz++;
st[cur].len = st[last].len + 1;
st[cur].pos = st[last].pos + 1;
int p;
for (p = last; p != -1 && !st[p].next.count(c); p = st[p].link)
st[p].next[c] = cur;
if (p == -1)
st[cur].link = 0;
else {
int q = st[p].next[c];
if (st[p].len + 1 == st[q].len)
st[cur].link = q;
else {
int clone = sz++;
st[clone].pos = st[cur].pos;
st[clone].len = st[p].len + 1;
st[clone].next = st[q].next;
st[clone].link = st[q].link;
for (; p != -1 && st[p].next[c] == q; p = st[p].link)
st[p].next[c] = clone;
st[q].link = st[cur].link = clone;
}
}
last = cur;
}
};
void solve() {
std::string input, output;
std::cin >> input >> output;
SuffixAutomata aut;
std::string base = input + "#";
std::reverse(input.begin(), input.end());
base += input;
aut.buildSuffixAutomata(base);
int pos = 0, ver = 0, len = 0, alen, ans, lastans = 0;
std::vector<std::pair<int, int> > moves;
while (pos < output.size()) {
bool next;
ver = aut.go(ver, output[pos], alen, ans);
if (alen >= len + 1) {
++len;
++pos;
} else {
if (len == 0) {
std::cout << -1;
return;
} else {
ver = 0;
moves.push_back(std::pair<int, int>(lastans - len + 1, lastans));
len = 0;
ans = 0;
}
}
lastans = ans;
}
if (len) {
moves.push_back(std::pair<int, int>(lastans - len + 1, lastans));
}
std::cout << moves.size() << std::endl;
for (std::pair<int, int> &move : moves) {
if (move.first > input.size()) {
move.first -= (input.size() + 1);
move.second -= (input.size() + 1);
move.first = input.size() - 1 - move.first;
move.second = input.size() - 1 - move.second;
}
std::cout << move.first + 1 << " " << move.second + 1 << std::endl;
}
}
int main(int argc, char **argv) {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long lcp[2500][2500], lcpr[2500][2500];
int main() {
vector<pair<long long, long long> > v;
string s, t;
long long m, n, i, j;
cin >> s;
cin >> t;
m = s.length();
n = t.length();
string rs = s;
reverse(rs.begin(), rs.end());
for (i = m - 1; i >= 0; i--) {
for (j = n - 1; j >= 0; j--) {
if (s[i] == t[j]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
}
}
for (i = m - 1; i >= 0; i--) {
for (j = n - 1; j >= 0; j--) {
if (rs[i] == t[j]) {
lcpr[i][j] = lcpr[i + 1][j + 1] + 1;
}
}
}
long long k, l;
k = 0;
l = 0;
long long ans = 0;
long long a, b, ai, bi;
while (1) {
b = a = -1;
for (i = 0; i < m; i++) {
if (a < lcp[i][k]) {
a = lcp[i][k];
ai = i;
}
if (b < lcpr[i][k]) {
b = lcpr[i][k];
bi = i;
}
}
if ((a == 0 && b == 0) || (k > n)) {
break;
}
if (a > b) {
v.push_back(make_pair(ai + 1, ai + a));
k += a;
} else {
v.push_back(make_pair(m - bi, m - (bi + b - 1)));
k += b;
}
ans++;
}
if (k < n) {
cout << -1;
return 0;
}
cout << ans << "\n";
for (i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e18;
long long int p = 1e9 + 7;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, y, x, k, z, w, g, c, key, l, r, n, m;
long long int l1, l2, r1, r2;
long long int t2, t3, t4, t1;
long long int src, end;
string s, t;
cin >> s >> t;
n = s.length();
m = t.length();
string srev = s;
reverse(srev.begin(), srev.end());
vector<pair<long long int, long long int>> ans;
for (i = 0; i < m; i++) {
j = i;
string str = "";
long long int f = 0;
long long int end;
while (j != m) {
f = 0;
str.push_back(t[j]);
string S;
for (k = 0; k < str.length(); k++) S.push_back(str[k]);
S.push_back('%');
for (k = 0; k < n; k++) S.push_back(s[k]);
long long int N = S.length();
vector<long long int> pi(N);
pi[0] = 0;
for (long long int ti = 1; ti < N; ti++) {
long long int tj = pi[ti - 1];
while (tj > 0 && S[tj] != S[ti]) tj = pi[tj - 1];
if (S[tj] == S[ti]) tj++;
pi[ti] = tj;
if (pi[ti] == j - i + 1) {
f = 1;
end = ti - (j - i + 2);
break;
}
}
if (f == 1)
j++;
else
break;
}
if (j == i) {
cout << "-1";
return 0;
}
long long int j2 = i;
long long int end2;
str = "";
while (j2 != m) {
f = 0;
str.push_back(t[j2]);
string S;
for (k = 0; k < str.length(); k++) S.push_back(str[k]);
S.push_back('%');
for (k = 0; k < n; k++) S.push_back(srev[k]);
long long int N = S.length();
vector<long long int> pi(N);
pi[0] = 0;
for (long long int ti = 1; ti < N; ti++) {
long long int tj = pi[ti - 1];
while (tj > 0 && S[tj] != S[ti]) tj = pi[tj - 1];
if (S[tj] == S[ti]) tj++;
pi[ti] = tj;
if (pi[ti] == j2 - i + 1) {
f = 1;
end2 = n - 1 - (ti - (j2 - i + 2));
break;
}
}
if (f == 1)
j2++;
else
break;
}
if (j >= j2) {
long long int len = j - i;
ans.push_back(make_pair(end - len + 1, end));
i = j - 1;
} else {
long long int len = j2 - i;
ans.push_back(make_pair(end2 + len - 1, end2));
i = j2 - 1;
}
}
cout << ans.size() << "\n";
for (auto u : ans) cout << u.first + 1 << " " << u.second + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[3000];
void buildfail(char *p, int l) {
for (int i = 0; i < l; i++) f[i] = -1;
int q = -1;
for (int i = 1; i < l; i++) {
while (q > -1 && p[q + 1] != p[i]) q = f[q];
if (p[q + 1] == p[i]) q++;
f[i] = q;
}
}
int lf, rh;
int len = 0;
int kmp(char *p, char *s, int l1, int l2) {
buildfail(p, l1);
int q = -1;
for (int i = 0; i < l2; i++) {
while (q > -1 && p[q + 1] != s[i]) q = f[q];
if (p[q + 1] == s[i]) q++;
if (q + 1 > len) {
len = q + 1;
lf = i - len + 1;
rh = i;
}
if (q == l1 - 1) {
return l1;
q = f[q];
}
}
return len;
}
char str[2105], pat[2105], strr[2105];
bool tag[26];
vector<pair<int, int> > res;
int main() {
scanf(" %s", str);
int l2 = strlen(str);
scanf(" %s", pat);
int l1 = strlen(pat);
for (int i = 0; i <= (l2 - 1); i++) tag[str[i] - 'a'] = true;
for (int i = 0; i <= (l1 - 1); i++)
if (!tag[pat[i] - 'a']) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i <= (l2 - 1); i++) strr[i] = str[l2 - 1 - i];
int cnt = 0;
while (cnt < l1) {
len = 0;
int l11 = kmp(pat + cnt, str, l1 - cnt, l2);
int l22 = kmp(pat + cnt, strr, l1 - cnt, l2);
if (l11 < l22) {
lf = l2 - lf - 1;
rh = l2 - rh - 1;
}
res.push_back(make_pair(lf, rh));
cnt = cnt + len;
}
cout << res.size() << endl;
for (int i = 0; i <= (res.size() - 1); i++)
cout << res[i].first + 1 << " " << res[i].second + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
int n = s.length();
int m = t.length();
s = "$" + s + '*';
t = '(' + t + ')';
int lcsp[m + 2][n + 2], lcss[m + 2][n + 2];
memset(lcsp, 0, sizeof(lcsp));
memset(lcss, 0, sizeof(lcss));
for (int i = m; i >= 1; i--) {
for (int j = n; j >= 1; j--) {
if (t[i] == s[j]) lcsp[i][j] = lcsp[i + 1][j + 1] + 1;
}
for (int j = 1; j <= n; j++) {
if (t[i] == s[j]) lcss[i][j] = lcss[i + 1][j - 1] + 1;
}
}
vector<pair<int, int>> ans;
for (int i = 1; i <= m;) {
int i1 = max_element(lcsp[i] + 1, lcsp[i] + n + 1) - lcsp[i];
int i2 = max_element(lcss[i] + 1, lcss[i] + n + 1) - lcss[i];
int len = max(lcsp[i][i1], lcss[i][i2]);
if (len == 0) {
cout << -1;
return 0;
} else if (lcsp[i][i1] > lcss[i][i2])
ans.push_back({i1, i1 + len - 1});
else
ans.push_back({i2, i2 - len + 1});
i += len;
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000;
struct node {
int r, l;
} ans[maxn];
int main() {
string s, t;
int cnt = 0, flag = 0;
ios::sync_with_stdio(false);
cin >> s >> t;
int len1 = s.length();
int len2 = t.length();
int len, l1, rr = 0, ll = 0, k;
for (int i = 0; i < len2; i++) {
len = 0;
for (int j = 0; j < len1; j++) {
if (t[i] == s[j]) {
l1 = j;
for (k = 1; j - k >= 0; k++) {
if (t[i + k] != s[j - k]) break;
l1--;
}
if (k > len) {
len = k;
ll = j;
rr = l1;
}
l1 = j;
for (k = 1; j + k < len1; k++) {
if (t[i + k] != s[j + k]) break;
l1++;
}
if (k > len) {
len = k;
ll = j;
rr = l1;
}
}
}
if (len == 0) {
flag = 1;
break;
}
i = i + len - 1;
cnt++;
ans[cnt].l = ll + 1;
ans[cnt].r = rr + 1;
}
if (flag) {
printf("-1\n");
} else {
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d %d\n", ans[i].l, ans[i].r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string second, t, r = "";
long long n, m, k;
long long lcp[2105][2105], lcp_prev[2105][2105];
pair<long long, long long> ans[2105];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> second >> t;
n = second.length();
m = t.length();
for (long long i = (long long)(n - 1); i >= (long long)(0); i--)
r += second[i];
for (long long i = (long long)(m); i >= (long long)(1); i--)
for (long long j = (long long)(n); j >= (long long)(1); j--)
if (second[j - 1] == t[i - 1]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
for (long long i = (long long)(m); i >= (long long)(1); i--)
for (long long j = (long long)(n); j >= (long long)(1); j--)
if (r[j - 1] == t[i - 1]) lcp_prev[i][j] = lcp_prev[i + 1][j + 1] + 1;
for (long long i = (long long)(1); i <= (long long)(m); i++) {
long long Max = 0, lft, rt;
lft = rt = -1;
for (long long j = (long long)(1); j <= (long long)(n); j++) {
if (lcp[i][j] > Max) {
Max = lcp[i][j];
lft = j;
rt = lft + Max - 1;
}
}
for (long long j = (long long)(1); j <= (long long)(n); j++) {
if (lcp_prev[i][j] > Max) {
Max = lcp_prev[i][j];
lft = n - j + 1;
rt = lft - Max + 1;
}
}
if (lft == -1) {
cout << "-1" << endl;
return 0;
}
ans[k] = {lft, rt};
k++;
i = i + Max - 1;
}
cout << k << endl;
for (long long i = (long long)(0); i <= (long long)(k - 1); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2100 + 7;
int dp[N][N], rp[N][N];
string s, t;
vector<pair<int, int> > ans;
int main() {
ios::sync_with_stdio(false);
cin >> s >> t;
int n = s.length(), m = t.length();
for (int i = m - 1; i >= 0; i--)
for (int j = n - 1; j >= 0; j--)
if (t[i] == s[j]) dp[i][j] = max(dp[i][j], dp[i + 1][j + 1] + 1);
for (int i = m - 1; i >= 0; i--)
for (int j = 0; j < n; j++)
if (t[i] == s[j])
rp[i][j] = max(rp[i][j], (j > 0 ? rp[i + 1][j - 1] : 0) + 1);
int p = 0;
while (p < m) {
int mx = 0, l = 0, r = 0;
for (int j = 0; j < n; j++)
if (mx < dp[p][j]) {
mx = dp[p][j];
l = j + 1;
r = j + mx;
}
for (int j = 0; j < n; j++)
if (mx < rp[p][j]) {
mx = rp[p][j];
l = j + 1;
r = j + 2 - mx;
}
if (mx == 0) {
cout << "-1\n";
return 0;
}
ans.push_back({l, r});
p += mx;
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void matar(string NotaSuicida) {
cout << NotaSuicida;
exit(0);
}
string a, b;
struct node {
int q, w;
set<char> s;
map<char, int> h;
};
node tt[4420000];
int q = 1;
bool P() {
set<char> ss;
for (char u : a) ss.insert(u);
for (char u : b)
if (ss.count(u) == 0) return false;
return true;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> a >> b;
node* ini = new node;
if (P() == false) matar("-1");
vector<pair<int, int> > res;
for (int i = 0; i < ((int)a.size()); i++) {
int y = 0;
for (int j = i; j < ((int)a.size()); j++) {
if (tt[y].s.count(a[j]) == 0) {
tt[y].s.insert(a[j]);
tt[y].h[a[j]] = q++;
}
y = tt[y].h[a[j]];
tt[y].q = i;
tt[y].w = j;
}
}
for (int i = ((int)a.size()) - 1; i >= 0; i--) {
int y = 0;
for (int j = i; j >= 0; j--) {
if (tt[y].s.count(a[j]) == 0) {
tt[y].s.insert(a[j]);
tt[y].h[a[j]] = q++;
}
y = tt[y].h[a[j]];
tt[y].q = i;
tt[y].w = j;
}
}
int y = 0;
int x = 0;
while (y < ((int)b.size())) {
if (tt[x].s.count(b[y]) == 0) {
res.push_back(make_pair(tt[x].q, tt[x].w));
x = 0;
} else {
x = tt[x].h[b[y]];
y++;
}
}
if (x != 0) res.push_back(make_pair(tt[x].q, tt[x].w));
cout << ((int)res.size()) << "\n";
for (pair<int, int> u : res)
cout << u.first + 1 << " " << u.second + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s3, a, b;
cin >> s1 >> s2;
s3 = s1;
reverse(s3.begin(), s3.end());
int i, j, l1, l2, f;
vector<pair<int, int> > V;
pair<int, int> p;
l1 = s1.length();
l2 = s2.length();
a = "";
for (j = 0; j < l2; j++) {
a += s2[j];
f = s1.find(a);
if (f == -1) {
f = s3.find(a);
} else {
p.first = f + 1;
p.second = f + 1 + a.size() - 1;
continue;
}
if (f == -1) {
if (a.size() == 1) {
cout << -1;
return 0;
}
V.push_back(p);
j--;
a.clear();
} else {
p.first = f + 1;
p.second = f + 1 + a.size() - 1;
p.first = l1 + 1 - p.first;
p.second = l1 + 1 - p.second;
}
}
V.push_back(p);
l1 = V.size();
cout << l1 << endl;
for (i = 0; i < l1; i++) {
cout << V[i].first << " " << V[i].second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int lens, lent, sz = 0, lps[2105], spl[2105], maxi, l, r, len, temp;
char s1[2105], s2[2105], t[2105];
bool ada[30];
vector<pair<int, int> > v;
scanf("%s %s", s1, t);
lens = strlen(s1);
lent = strlen(t);
memset(ada, false, sizeof ada);
for (int i = 0; i < lens; i++) {
ada[s1[i] - 'a'] = true;
s2[i] = s1[lens - i - 1];
}
for (int i = 0; i < lent; i++)
if (!ada[t[i] - 'a']) {
puts("-1");
return 0;
}
for (int i = 0; i < lent; i += maxi) {
maxi = 0;
lps[i] = len = i;
temp = i + 1;
while (temp < lent) {
if (t[temp] == t[len])
lps[temp++] = ++len;
else if (len != i)
len = lps[len - 1];
else
lps[temp++] = i;
}
temp = 0;
len = i;
while (temp < lens) {
if (t[len] == s1[temp]) {
temp++;
len++;
}
if (len - i > maxi) {
maxi = len - i;
r = temp;
l = r - maxi + 1;
}
if (len == lent) break;
if ((temp < lens) && (t[len] != s1[temp])) {
if (len != i)
len = lps[len - 1];
else
temp++;
}
}
spl[i] = len = i;
temp = i + 1;
while (temp < lent) {
if (t[temp] == t[len])
spl[temp++] = ++len;
else if (len != i)
len = spl[len - 1];
else
spl[temp++] = i;
}
temp = 0;
len = i;
while (temp < lens) {
if (t[len] == s2[temp]) {
temp++;
len++;
}
if (len - i > maxi) {
maxi = len - i;
r = temp;
l = r - maxi + 1;
l = lens - l + 1;
r = lens - r + 1;
}
if (len == lent) break;
if ((temp < lens) && (t[len] != s2[temp])) {
if (len != i)
len = spl[len - 1];
else
temp++;
}
}
v.push_back(make_pair(l, r));
sz++;
}
printf("%d\n", sz);
for (int i = 0; i < sz; i++) printf("%d %d\n", v[i].first, v[i].second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
string s, t;
string::iterator it;
char ch[N], ch2[N];
int z[N], n, n2, mx, p, p2;
vector<int> res, res2;
void zFunction(long long frst, int lst, char ch[]) {
int lft = -1, rght = -1, t, i, j, k;
for (i = frst + 1; i <= lst; i++) {
if (ch[i] != ch[frst])
z[i] = 0;
else if (i > rght) {
lft = rght = i;
for (j = i, k = frst; j <= lst && ch[j] == ch[k]; j++, k++) rght = j;
z[i] = rght - lft + 1;
} else {
t = i - lft + frst;
if (z[t] < rght - i + 1)
z[i] = z[t];
else {
lft = i;
for (j = rght, k = rght - lft + frst; j <= lst && ch[j] == ch[k];
j++, k++)
rght = j;
z[i] = rght - lft + 1;
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> s >> t;
n = 0;
for (it = t.begin(); it != t.end(); it++) {
n++;
ch[n] = ch2[n] = (*it);
}
for (it = s.begin(); it != s.end(); it++) {
n++;
ch[n] = (*it);
}
n2 = n;
for (it = s.begin(); it != s.end(); it++) {
ch2[n2] = (*it);
n2--;
}
for (int i = 1; i <= n2;) {
zFunction(i, n, ch);
mx = 0;
for (int j = n2 + 1, k = 1; j <= n; j++, k++) {
if (z[j] >= n2 - i + 1) z[j] = n2 - i + 1;
if (z[j] > mx) {
mx = z[j];
p = k;
p2 = k + z[j] - 1;
}
}
zFunction(i, n, ch2);
for (int j = n2 + 1, k = n - n2; j <= n; j++, k--) {
if (z[j] >= n2 - i + 1) z[j] = n2 - i + 1;
if (z[j] > mx) {
mx = z[j];
p = k;
p2 = k - z[j] + 1;
}
}
if (mx == 0) {
cout << "-1\n";
return 0;
}
res.push_back(p);
res2.push_back(p2);
i += mx;
}
cout << res.size() << "\n";
for (int i = 0; i < res.size(); i++) {
cout << res[i] << " " << res2[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans = 0;
string a, b;
vector<pair<int, int> > an;
int main() {
cin >> a;
cin >> b;
vector<pair<pair<int, int>, int> > v[2];
for (int i = 0; i < b.size(); i++) {
int i1 = (i + 1) % 2, i0 = 1 - i1;
for (int j = 0; j < v[i1].size(); j++) {
int idx = v[i1][j].first.second + v[i1][j].second;
if (idx >= 0 && idx < a.size() && a[idx] == b[i])
v[i0].push_back(pair<pair<int, int>, int>(
pair<int, int>(v[i1][j].first.first, idx), v[i1][j].second));
}
if (v[i0].size() == 0) {
ans++;
if (v[i1].size() != 0) an.push_back(v[i1][0].first);
for (int j = 0; j < a.size(); j++) {
if (b[i] == a[j]) {
v[i0].push_back(pair<pair<int, int>, int>(pair<int, int>(j, j), 1));
v[i0].push_back(pair<pair<int, int>, int>(pair<int, int>(j, j), -1));
}
}
if (v[i0].size() == 0) {
printf("-1");
return 0;
}
}
if (i + 1 == b.size()) {
ans++;
an.push_back(v[i0][0].first);
}
v[i1].clear();
}
printf("%d\n", an.size());
for (int i = 0; i < an.size(); i++)
printf("%d %d\n", an[i].first + 1, an[i].second + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str1, str2, str3;
vector<int> v1, v2;
int l, r;
vector<pair<int, int> > v3;
int kmpstart(int a) {
int sz, p1, p2;
p2 = 0;
v2[0] = 0;
v2[1] = 0;
for (p1 = 2; p1 <= str2.size(); p1++) {
p2 = v2[p1 - 1];
while (1) {
if (str2[p1 - 1] == str2[p2]) {
v2[p1] = p2 + 1;
break;
} else if (p2 == 0) {
v2[p1] = 0;
break;
} else
p2 = v2[p2];
}
}
}
int kmpfinal1(int a) {
int sz, p1, p2;
p1 = 0;
p2 = 0;
sz = 0;
while (1) {
if (p1 == str1.size()) break;
if (str1[p1] == str2[p2]) {
p1++;
p2++;
if (sz < p2) {
sz = p2;
l = p1 - p2 + 1;
r = p1;
}
if (p2 == str1.size()) break;
} else if (p2 > 0)
p2 = v2[p2];
else
p1++;
}
return sz;
}
int kmpfinal2(int a) {
int sz, p1, p2;
p1 = 0;
p2 = 0;
sz = 0;
while (1) {
if (p1 == str3.size()) break;
if (str3[p1] == str2[p2]) {
p1++;
p2++;
if (sz < p2) {
sz = p2;
l = p1 - p2;
r = p1 - 1;
}
if (p2 == str3.size()) break;
} else if (p2 > 0)
p2 = v2[p2];
else
p1++;
}
return sz;
}
int main() {
int n, m, p1, p2, chng1, chng2, l1, r1;
cin >> str1 >> str2;
for (p1 = str1.size() - 1; p1 >= 0; p1--) str3.push_back(str1[p1]);
v1.resize(26, 0);
for (p1 = 0; p1 < str1.size(); p1++) v1[str1[p1] - 'a']++;
for (p1 = 0; p1 < str2.size(); p1++)
if (v1[str2[p1] - 'a'] == 0) {
cout << -1;
return 0;
}
p1 = 0;
chng1 = 0;
chng2 = 0;
while (str2.size() > 0) {
v2.clear();
v2.resize(str2.size() + 1, 0);
l = r = -1;
kmpstart(p1);
chng1 = kmpfinal1(p1);
l1 = l;
r1 = r;
chng2 = kmpfinal2(p1);
if (chng1 >= chng2) {
p1 += chng1;
l = l1;
r = r1;
str2.erase(0, chng1);
} else {
p1 += chng2;
l = str1.size() - l;
r = str1.size() - r;
str2.erase(0, chng2);
}
v3.push_back(make_pair(l, r));
}
cout << v3.size() << "\n";
for (p1 = 0; p1 < v3.size(); p1++)
cout << v3[p1].first << " " << v3[p1].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> z_function(string s) {
int n = (int)s.size();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int main() {
string s, t;
cin >> s >> t;
string s_reversed = s;
reverse(s_reversed.begin(), s_reversed.end());
vector<pair<int, int> > ans;
int ptr = 0;
while (ptr != t.size()) {
pair<int, pair<int, int> > best = make_pair(0, make_pair(0, 0));
string conc1 = t.substr(ptr, t.size() - ptr) + '$' + s;
vector<int> v1 = z_function(conc1);
string conc2 = t.substr(ptr, t.size() - ptr) + '$' + s_reversed;
vector<int> v2 = z_function(conc2);
for (int i = t.size() - ptr + 1; i < conc1.size(); i++) {
best = max(best, make_pair(v1[i], make_pair(i, 1)));
best = max(best, make_pair(v2[i], make_pair(i, 2)));
}
if (best.first == 0) {
printf("-1\n");
return 0;
}
if (best.second.second == 1) {
int idx = best.second.first;
idx -= t.size() - ptr + 1;
idx++;
ans.push_back(make_pair(idx, idx + best.first - 1));
} else {
int idx = best.second.first;
idx -= t.size() - ptr + 1;
idx = s.size() - 1 - idx;
idx++;
ans.push_back(make_pair(idx, idx - best.first + 1));
}
ptr += best.first;
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Set(long long N, long long pos) { return N = N | (1 << pos); }
long long reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
void CI(long long &_x) { cin >> _x; }
void CO(long long &_x) { cout << _x; }
template <typename T>
void getarray(T a[], long long n) {
for (long long i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void prLLIarray(T a[], long long n) {
for (long long i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const long long INF = 0x7f7f7f7f;
long long dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
long long dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
long long dr4[4] = {0, 0, 1, -1};
long long dc4[4] = {-1, 1, 0, 0};
long long kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
long long kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
string s1, s2, s3;
int lcp[2105][2105];
int lcp_rev[2105][2105];
int main() {
cin >> s1 >> s2;
s3 = s1;
reverse(s3.begin(), s3.end());
for (int i = s2.size() - 1; i >= 0; i--) {
for (int j = s1.size() - 1; j >= 0; j--)
if (s2[i] == s1[j]) {
lcp[i][j] = 1 + lcp[i + 1][j + 1];
}
for (int j = s3.size() - 1; j >= 0; j--)
if (s2[i] == s3[j]) {
lcp_rev[i][j] = 1 + lcp_rev[i + 1][j + 1];
}
}
vector<pair<int, int> > V;
for (int i = 0; i < s2.size();) {
int maxi = -1, temp;
int pos;
for (int j = 0; j < s1.size(); j++) {
if (maxi < lcp[i][j]) {
pos = j;
maxi = lcp[i][j];
temp = 1;
}
if (maxi < lcp_rev[i][j]) {
pos = j;
maxi = lcp_rev[i][j];
temp = 2;
}
}
int j = pos;
if (maxi == 0) {
puts("-1");
return 0;
}
if (temp == 1) {
V.push_back(make_pair(j + 1, j + maxi));
} else {
int sz = s1.size();
V.push_back(make_pair(sz - j, sz - j - maxi + 1));
}
i += maxi;
}
cout << V.size() << "\n";
for (int i = 0; i < V.size(); i++)
cout << V[i].first << " " << V[i].second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n, m;
string s, t;
char str[2100 + 1 + 9];
vector<pair<int, int> > ans;
struct trie {
int idx, beg;
trie *child[26];
trie() {
beg = -1;
idx = -1;
memset(child, 0, sizeof child);
}
} * root;
void insert(trie *cur, int idx, int beg) {
cur->beg = beg;
cur->idx = idx - 1;
if (idx == n) return;
trie *&nw = cur->child[s[idx] - 'a'];
if (nw == NULL) nw = new trie;
insert(nw, idx + 1, beg);
}
void insert1(trie *cur, int idx, int beg) {
cur->beg = beg;
cur->idx = idx + 1;
if (idx == -1) return;
trie *&nw = cur->child[s[idx] - 'a'];
if (nw == NULL) nw = new trie;
insert1(nw, idx - 1, beg);
}
void build() {
root = new trie;
for (int i = 0; i < n; i++) insert(root, i, i);
for (int i = n - 1; i >= 0; i--) insert1(root, i, i);
}
pair<int, int> find_for(trie *cur, int idx) {
if (idx == m || cur->child[t[idx] - 'a'] == NULL) {
return make_pair(cur->beg, cur->idx);
}
return find_for(cur->child[t[idx] - 'a'], idx + 1);
}
int get_ans() {
ans.clear();
int idx = 0;
while (idx != m) {
pair<int, int> xy = find_for(root, idx);
int x = xy.first, y = xy.second;
int len = abs(y - x) + 1;
ans.push_back(make_pair(x, y));
idx += len;
}
}
bool special() {
bool have[26] = {0};
for (int i = 0; i < m; i++) have[t[i] - 'a'] = 1;
bool haves[26] = {0};
for (int i = 0; i < n; i++) haves[s[i] - 'a'] = 1;
for (int i = 0; i < 26; i++)
if (have[i] && !haves[i]) {
printf("-1\n\n");
return true;
}
return false;
}
int main() {
read_file();
while (scanf("%s", str) != EOF) {
s = str;
n = s.length();
scanf("%s", str);
t = str;
m = t.length();
if (special()) continue;
build();
get_ans();
int sz = ans.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool isused[26];
string s, t;
vector<pair<int, int> > v;
int abs(int num) {
if (num < 0)
return -num;
else
return num;
}
int main(void) {
cin >> s >> t;
int slen = s.size();
for (int i = 0; i < slen; i++) isused[(s[i] - 'a')] = true;
int tlen = t.size();
for (int i = 0; i < tlen; i++) {
if (isused[(t[i] - 'a')] == false) {
cout << -1 << endl;
return 0;
}
}
for (int i = 0; i < tlen;) {
pair<int, int> temp = make_pair(-1, -1);
for (int j = 0; j < slen; j++) {
if (t[i] == s[j]) {
int k1 = 0;
while (i + k1 + 1 < tlen && j + k1 + 1 < slen &&
t[i + k1 + 1] == s[j + k1 + 1])
k1++;
int k2 = 0;
while (i + k2 + 1 < tlen && j - k2 - 1 >= 0 &&
t[i + k2 + 1] == s[j - k2 - 1])
k2++;
if (k1 >= k2) {
if (temp.first == -1)
temp = make_pair(j, j + k1);
else if (abs(temp.second - temp.first) < k1)
temp = make_pair(j, j + k1);
} else {
if (temp.first == -1)
temp = make_pair(j, j - k2);
else if (abs(temp.first - temp.second) < k2)
temp = make_pair(j, j - k2);
}
}
}
if (temp.first <= temp.second)
i += (temp.second - temp.first) + 1;
else
i += (temp.first - temp.second) + 1;
v.push_back(make_pair(temp.first + 1, temp.second + 1));
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string p, s, rp;
int alph[256];
vector<pair<int, int> > ans;
int main() {
cin >> p >> s;
rp = p;
p.push_back('#');
p = '#' + p;
reverse(s.begin(), s.end());
for (int i = 0; i < p.size(); i++) alph[p[i]] = 1;
for (int i = 0; i < s.size(); i++)
if (!alph[s[i]]) {
cout << -1;
return 0;
}
while (s.size() > 0) {
int nl = 0, l, r;
for (int i = 1; i < p.size(); i++) {
int w = 0;
for (int j = s.size() - 1, w = 0; j >= 0; j--, w++)
if (p[i + w] != s[j]) {
if (w > nl) {
nl = w;
l = i;
r = i + w - 1;
}
break;
} else if (j == 0) {
w++;
if (w > nl) {
nl = w;
l = i;
r = i + w - 1;
}
}
}
for (int i = p.size() - 2; i > 0; i--) {
int w = 0;
for (int j = s.size() - 1; j >= 0 && i - w >= 0; j--, w++)
if (p[i - w] != s[j]) {
if (w > nl) {
nl = w;
l = i;
r = i - w + 1;
}
break;
} else if (j == 0) {
w++;
if (w > nl) {
nl = w;
l = i;
r = i - w + 1;
}
}
}
for (int i = 0; i < nl; i++) s.pop_back();
ans.push_back(make_pair(l, r));
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << ' ' << ans[i].second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long lcp[2500][2500], lcpr[2500][2500];
int main() {
vector<pair<long long, long long> > v;
string s, t;
long long m, n, i, j;
cin >> s;
cin >> t;
m = s.length();
n = t.length();
string rs = s;
reverse(rs.begin(), rs.end());
for (i = m - 1; i >= 0; i--) {
for (j = n - 1; j >= 0; j--) {
if (s[i] == t[j]) {
lcp[i][j] = lcp[i + 1][j + 1] + 1;
}
}
}
for (i = m - 1; i >= 0; i--) {
for (j = n - 1; j >= 0; j--) {
if (rs[i] == t[j]) {
lcpr[i][j] = lcpr[i + 1][j + 1] + 1;
}
}
}
long long k, l;
k = 0;
l = 0;
long long ans = 0;
long long a, b, ai, bi;
while (1) {
b = a = -1;
for (i = 0; i < m; i++) {
if (a < lcp[i][k]) {
a = lcp[i][k];
ai = i;
}
if (b < lcpr[i][k]) {
b = lcpr[i][k];
bi = i;
}
}
if ((a == 0 && b == 0) || (k > n)) {
break;
}
if (a > b) {
v.push_back(make_pair(ai + 1, ai + a));
k += a;
} else {
v.push_back(make_pair(m - bi, m - (bi + b - 1)));
k += b;
}
ans++;
}
if (k < n) {
cout << -1;
return 0;
}
cout << ans << "\n";
for (i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod1 = 1000000087;
const int mod2 = 998244353;
const int X1 = 880301;
const int X2 = 1009;
const int N = 2106;
pair<int, int> operator+(const pair<int, int> &p1, const pair<int, int> &p2) {
return make_pair((p1.first + p2.first) % mod1,
(p1.second + p2.second) % mod2);
}
pair<int, int> operator-(const pair<int, int> &p1, const pair<int, int> &p2) {
return make_pair((p1.first - p2.first + mod1) % mod1,
(p1.second - p2.second + mod2) % mod2);
}
pair<int, int> operator*(const pair<int, int> &p1, const pair<int, int> &p2) {
return make_pair(p1.first * 1ll * p2.first % mod1,
p1.second * 1ll * p2.second % mod2);
}
pair<int, int> pre[N];
pair<int, int> ppow[N];
vector<pair<pair<int, int>, pair<int, int> > > v;
const pair<int, int> yuuki = make_pair(-1, -1);
bool hhave(pair<int, int> p) {
auto iter = lower_bound(v.begin(), v.end(), make_pair(p, yuuki));
if (iter == v.end()) return false;
if (iter->first != p) return false;
return true;
}
pair<int, int> get_range(pair<int, int> p) {
auto iter = lower_bound(v.begin(), v.end(), make_pair(p, yuuki));
return iter->second;
}
pair<int, int> hash_val(int L, int R) {
return (pre[R] - pre[L - 1]) * ppow[N - L - 2];
}
int main() {
ppow[0] = make_pair(1, 1);
for (int i = 1; i < N; ++i) {
ppow[i] = (ppow[i - 1]) * (make_pair(X1, X2));
}
string s;
cin >> s;
set<char> st;
for (char i : s) st.insert(i);
string t;
cin >> t;
for (char i : t) {
if (st.find(i) == st.end()) {
cout << -1 << endl;
return 0;
}
}
int n = (int)s.size();
for (int i = 1; i <= n; ++i) {
pre[i] = pre[i - 1] + (make_pair(s[i - 1], s[i - 1]) * ppow[i]);
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
pair<int, int> val = (pre[j] - pre[i - 1]) * ppow[N - i - 2];
v.push_back({val, {i, j}});
}
}
reverse(s.begin(), s.end());
for (int i = 1; i <= n; ++i) {
pre[i] = pre[i - 1] + (make_pair(s[i - 1], s[i - 1]) * ppow[i]);
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
pair<int, int> val = (pre[j] - pre[i - 1]) * ppow[N - i - 2];
v.push_back({val, {n - i + 1, n - j + 1}});
}
}
sort(v.begin(), v.end());
t += "*";
int m = (int)t.size();
for (int i = 1; i <= m; ++i) {
pre[i] = pre[i - 1] + (make_pair(t[i - 1], t[i - 1]) * ppow[i]);
}
vector<pair<int, int> > ans;
for (int i = 1; i <= m;) {
int j = i;
while (hhave(hash_val(i, j))) ++j;
ans.push_back(get_range(hash_val(i, j - 1)));
i = j;
if (i == m) break;
}
cout << ans.size() << endl;
for (pair<int, int> p : ans) cout << p.first << ' ' << p.second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2105;
int neXt[MAXN];
void getNext(string s) {
int n = s.length();
neXt[0] = -1;
int k = -1, j = 0;
while (j < n) {
if (k == -1 || s[j] == s[k]) {
j++;
k++;
neXt[j] = k;
} else {
k = neXt[k];
}
}
}
int kmp(string s, string p) {
int i = 0, j = 0;
int m = s.length(), n = p.length();
while (i < m && j < n) {
if (j == -1 || s[i] == p[j])
i++, j++;
else
j = neXt[j];
}
if (j == n) return i - j;
return -1;
}
bool solve(string x, string y, vector<pair<int, int>>& ans) {
string z(x);
reverse(z.begin(), z.end());
int m = x.length();
int n = y.length();
int start = 0;
while (start < n) {
int l = 1, r = n - start, res = 0, pos = -1;
bool flg = true;
while (l <= r) {
int mid = (l + r) >> 1;
string tmp = y.substr(start, mid);
getNext(tmp);
int p = kmp(x, tmp);
if (p != -1) {
res = mid;
pos = p;
flg = true;
l = mid + 1;
} else if ((p = kmp(z, tmp)) != -1) {
res = mid;
pos = p;
flg = false;
l = mid + 1;
} else
r = mid - 1;
}
if (!res) return false;
if (flg)
ans.push_back(pair<int, int>(pos + 1, pos + res));
else
ans.push_back(pair<int, int>(m - pos, m - pos - res + 1));
start += res;
}
return true;
}
int main() {
string x, y;
cin >> x >> y;
vector<pair<int, int>> res;
if (solve(x, y, res)) {
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << endl;
} else {
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, la, lb, num = 1;
int q[3000][10];
char a[3000], b[3000];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
scanf("%s", a);
scanf("%s", b);
la = strlen(a);
lb = strlen(b);
int f;
for (i = 0; i < lb;) {
f = 1;
int ma = -1, ui = i, mi = i;
for (j = 0; j < la; j++) {
if (b[ui] != a[j]) continue;
f = 0;
int k1 = ui + 1, p1 = j + 1, f1 = 0;
while (k1 < lb && p1 < la && b[k1] == a[p1]) k1++, p1++, f1++;
int k2 = ui + 1, p2 = j - 1, f2 = 0;
while (k2 < lb && p2 >= 0 && b[k2] == a[p2]) k2++, p2--, f2++;
if (f2) p2 += 2;
if (f1 > ma) ma = f1, q[num][1] = p1, mi = k1, q[num][0] = j + 1;
if (f2 > ma) ma = f2, q[num][1] = p2, mi = k2, q[num][0] = j + 1;
ui = i;
}
i = mi;
num++;
if (f) {
printf("-1\n");
return 0;
}
}
printf("%d\n", num - 1);
for (i = 1; i < num; i++) printf("%d %d\n", q[i][0], q[i][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long mod = 1e9 + 7;
struct letter {
int start;
letter* next[26];
int depth;
letter() {
for (int i = 0; i < 26; i++) next[i] = 0;
depth = 0;
}
};
class Trie {
private:
letter* root;
public:
Trie() { root = new letter(); }
void insert(string s, int id) {
letter* cur = root;
for (int i = 0; i < s.length(); i++) {
if (cur->next[s[i] - 97] == 0) {
cur->next[s[i] - 97] = new letter();
cur->next[s[i] - 97]->start = id;
cur->next[s[i] - 97]->depth = cur->depth + 1;
} else
cur->next[s[i] - 97]->start = id;
cur = cur->next[s[i] - 97];
}
}
pair<int, int> search(string s) {
letter* cur = root;
for (int i = 0; i < s.length(); i++) {
if (cur->next[s[i] - 97] == 0) {
if (cur == root) return make_pair((0), (0));
;
return make_pair(cur->start, cur->depth);
}
cur = cur->next[s[i] - 97];
}
return make_pair(cur->start, cur->depth);
}
};
int main() {
Trie t1, t2;
string s2;
cin >> s2;
string s1 = s2;
int n = s1.length();
reverse(s2.begin(), s2.end());
for (int i = 0; i < s1.length(); i++) t1.insert(s1.substr(i), i);
for (int i = 0; i < s2.length(); i++) t2.insert(s2.substr(i), i);
string patt;
cin >> patt;
int j = 0;
pair<int, int> p1, p2;
vector<pair<int, int> > result;
while (j < patt.length()) {
p1 = t1.search(patt.substr(j));
p2 = t2.search(patt.substr(j));
if (p1.second == 0 && p2.second == 0) {
puts("-1");
return 0;
}
if (p1.second >= p2.second) {
result.push_back(make_pair(p1.first + 1, p1.first + p1.second));
j += p1.second;
} else {
result.push_back(make_pair(n - p2.first, n - p2.first - p2.second + 1));
j += p2.second;
}
}
cout << result.size() << endl;
for (int i = 0; i < result.size(); i++)
cout << result[i].first << " " << result[i].second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using pi = pair<int, int>;
using vs = vector<string>;
using vpi = vector<pi>;
using ll = long long int;
template <typename T>
string tostr(T x) {
ostringstream oss;
oss << x;
return oss.str();
}
template <typename T1, typename T2, typename T3>
T1 modpow(T1 a, T2 p, T3 mod) {
T1 ret = 1;
a %= mod;
for (; p > 0; p /= 2) {
if (p & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod;
}
return ret;
}
int dx[]{-1, 0, 1, 0, 1, 1, -1, -1};
int dy[]{0, -1, 0, 1, 1, -1, 1, -1};
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 10;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
string s, t;
vpi ans;
class Trie {
public:
pi p;
Trie* ch[26];
Trie() {
p = make_pair(-1, -1);
for (auto i = 0, _i = (26); i < _i; ++i) ch[i] = NULL;
}
pi match(string& s, int i) {
if (i == (int)(s.size())) return p;
if (ch[(int)s[i] - 'a'] == NULL) return make_pair(-1, -1);
return ch[(int)s[i] - 'a']->match(s, i + 1);
}
} * root;
void solve() {
int i = 0;
while (i < (int)(t.size())) {
int lo = i, hi = (int)(t.size()) - 1;
while (lo < hi) {
int m = (lo + hi + 1) / 2;
string cur = t.substr(i, m - i + 1);
if (root->match(cur, 0).first != -1) {
lo = m;
} else {
hi = m - 1;
}
}
string cur = t.substr(i, lo - i + 1);
;
if (root->match(cur, 0).first != -1) {
ans.push_back(root->match(cur, 0));
i = lo + 1;
} else {
ans.clear();
break;
}
}
}
int main() {
cin >> s >> t;
root = new Trie();
for (auto i = 0, _i = ((int)(s.size())); i < _i; ++i) {
Trie* cur = root;
for (auto j = i, _j = ((int)(s.size())); j < _j; ++j) {
if (cur->ch[(int)s[j] - 'a'] == NULL)
cur->ch[(int)s[j] - 'a'] = new Trie();
cur = cur->ch[(int)s[j] - 'a'];
cur->p = make_pair(i, j);
}
cur = root;
for (int j = i; j >= 0; --j) {
if (cur->ch[(int)s[j] - 'a'] == NULL)
cur->ch[(int)s[j] - 'a'] = new Trie();
cur = cur->ch[(int)s[j] - 'a'];
cur->p = make_pair(i, j);
}
}
solve();
if ((int)(ans.size()) == 0) {
printf("-1\n");
} else {
printf("%d\n", (int)(ans.size()));
for (auto entry : ans) {
printf("%d %d\n", entry.first + 1, entry.second + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int preprocess(char pat[], int lps[], int lenpat) {
int i, q = 0;
lps[1] = 0;
for (i = 2; i <= lenpat; i++) {
while (q > 0 && pat[q + 1] != pat[i]) {
q = lps[q];
}
if (pat[q + 1] == pat[i]) {
q++;
}
lps[i] = q;
}
return 0;
}
pair<int, int> matcher(char pat[], char text[], int lps[], int lentext,
int lenpat) {
int q = 0, i, maxi = 0, end;
for (i = 1; i <= lentext; i++) {
while (q > 0 && pat[q + 1] != text[i]) {
q = lps[q];
}
if (pat[q + 1] == text[i]) {
q++;
}
if (q > maxi) {
maxi = q;
end = i;
}
}
return make_pair(maxi, end);
}
int main() {
char s[2105], t[2105], revs[2105];
int lps[2105], lens, lent, start, i, j;
vector<pair<int, int> > out;
out.clear();
pair<int, int> p, q;
bool c[26];
for (i = 0; i < 26; i++) c[i] = false;
scanf("%s", s + 1);
scanf("%s", t + 1);
i = 1;
while (s[i] != 0) {
c[s[i] - 'a'] = true;
i++;
}
j = 1;
while (t[j] != 0) {
if (c[t[j] - 'a'] == false) {
printf("-1\n");
return 0;
}
j++;
}
lens = i - 1;
for (i = 1; i <= lens; i++) {
revs[lens - i + 1] = s[i];
}
lent = j - 1;
start = 1;
while (start <= lent) {
preprocess(t + start - 1, lps, lent - start + 1);
p = matcher(t + start - 1, s, lps, lens, lent - start + 1);
q = matcher(t + start - 1, revs, lps, lens, lent - start + 1);
if (p.first >= q.first) {
out.push_back(make_pair(p.second - p.first + 1, p.second));
start += p.first;
} else {
out.push_back(
make_pair(lens - (q.second - q.first + 1) + 1, lens - q.second + 1));
start += q.first;
}
}
printf("%d\n", (int)out.size());
for (i = 0; i < out.size(); i++) {
printf("%d %d\n", out[i].first, out[i].second);
}
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 1e9 + 5;
const long long linf = 5e18 + 5;
const long double eps = 1e-7;
const long long mod = 1e9 + 7;
const int dd = 2e4 + 7;
const int maxn = 2e3 + 10;
using namespace std;
vector<pair<string, int> > qwe;
vector<pair<string, int> > asd;
int main() {
ios_base::sync_with_stdio(0);
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
} else {
if (!01) {
freopen(
"document"
".in",
"r", stdin);
freopen(
"document"
".out",
"w", stdout);
}
}
string a, b;
cin >> a >> b;
int n = a.size();
string ra;
ra = a;
for (long long i = 0; i < n; ++i) {
qwe.push_back(make_pair(ra, i));
ra.pop_back();
reverse(qwe[i].first.begin(), qwe[i].first.end());
}
sort(qwe.begin(), qwe.end());
ra = a;
reverse(ra.begin(), ra.end());
for (long long i = 0; i < n; ++i) {
asd.push_back(make_pair(ra, i));
ra.pop_back();
reverse(asd[i].first.begin(), asd[i].first.end());
}
sort(asd.begin(), asd.end());
vector<pair<int, int> > ans;
while (b.size()) {
int qwel = 0;
int asdl = 0;
int qwei = -1;
int asdi = -1;
{
int l = 0;
int r = qwe.size();
while (l != r - 1) {
int m = (l + r) / 2;
if (qwe[m].first > b)
r = m;
else
l = m;
}
int lqwe = 0;
while (lqwe < qwe[l].first.size() && lqwe < b.size() &&
qwe[l].first[lqwe] == b[lqwe])
lqwe++;
if (l != qwe.size() - 1) {
int lqwe1 = 0;
while (lqwe1 < qwe[l + 1].first.size() && lqwe1 < b.size() &&
qwe[l + 1].first[lqwe1] == b[lqwe1]) {
lqwe1++;
}
if (lqwe1 > lqwe) {
l++;
lqwe = lqwe1;
}
}
qwel = lqwe;
qwei = l;
}
{
int l = 0;
int r = asd.size();
while (l != r - 1) {
int m = (l + r) / 2;
if (asd[m].first > b)
r = m;
else
l = m;
}
int lqwe = 0;
while (lqwe < asd[l].first.size() && lqwe < b.size() &&
asd[l].first[lqwe] == b[lqwe])
lqwe++;
if (l != asd.size() - 1) {
int lqwe1 = 0;
while (lqwe1 < asd[l + 1].first.size() && lqwe1 < b.size() &&
asd[l + 1].first[lqwe1] == b[lqwe1])
lqwe1++;
if (lqwe1 > lqwe) {
l++;
lqwe = lqwe1;
}
}
asdl = lqwe;
asdi = l;
}
if (asdl == 0 && qwel == 0) {
cout << -1;
exit(0);
}
if (asdl > qwel) {
int ind = asd[asdi].second;
ans.push_back(make_pair(ind + 1, ind + asdl));
for (long long i = 0; i < asdl; ++i) b.erase(b.begin());
} else {
int ind = a.size() - qwe[qwei].second;
ans.push_back(make_pair(ind, ind - qwel + 1));
for (long long i = 0; i < qwel; ++i) b.erase(b.begin());
}
}
cout << ans.size() << "\n";
for (long long i = 0; i < ans.size(); ++i)
cout << ans[i].first << ' ' << ans[i].second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool RD(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1, ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
const int N = 3e3 + 10;
char s[N], rev[N];
char g[N];
int dp0[N][N], dp1[N][N];
int ans[N];
int n, lens;
vector<pair<int, int> > res;
void print(int pos) {
if (pos == 0) return;
for (int i = 1; i <= int(lens); i++) {
if (ans[pos] == ans[pos - dp0[i][pos]] + 1) {
res.push_back(pair<int, int>(i - dp0[i][pos] + 1, i));
print(pos - dp0[i][pos]);
return;
} else if (ans[pos] == ans[pos - dp1[lens - i + 1][pos]] + 1) {
res.push_back(pair<int, int>(i + dp1[lens - i + 1][pos] - 1, i));
print(pos - dp1[lens - i + 1][pos]);
return;
}
}
}
int main() {
scanf("%s%s", s + 1, g + 1);
for (int i = 1; s[i]; i++)
for (int j = 1; g[j]; j++) {
if (s[i] == g[j])
dp0[i][j] = dp0[i - 1][j - 1] + 1;
else
dp0[i][j] = 0;
}
lens = strlen(s + 1);
for (int i = 1; i <= lens / 2; i++) swap(s[i], s[lens - i + 1]);
for (int i = 1; s[i]; i++)
for (int j = 1; g[j]; j++) {
if (s[i] == g[j])
dp1[i][j] = dp1[i - 1][j - 1] + 1;
else
dp1[i][j] = 0;
}
n = strlen(g + 1);
memset(ans, 0x3f, sizeof(ans));
ans[0] = 0;
for (int j = 1; j <= int(n); j++) {
for (int i = 1; i <= int(lens); i++) {
ans[j] = min(ans[j], ans[j - dp0[i][j]] + 1);
ans[j] = min(ans[j], ans[j - dp1[lens - i + 1][j]] + 1);
}
}
if (ans[n] == 0x3f3f3f3f) {
puts("-1");
return 0;
}
printf("%d\n", ans[n]);
print(n);
for (__typeof((res).rbegin()) it = (res).rbegin(); it != (res).rend(); ++it)
printf("%d %d\n", (*it).first, (*it).second);
}
|
#include <bits/stdc++.h>
using namespace std;
const size_t MAX_N = 1000 * 1000 * 1000 + 1;
string in, rin;
string out;
pair<int, int> find_max(int skip, const string &in, const string &out) {
int pos = -1, len = 0;
for (int i = 0; i < in.size(); ++i) {
int matched = 0;
for (int j = i; j < in.size() && skip + (j - i) < out.size(); ++j) {
if (out[skip + j - i] == in[j])
++matched;
else
break;
}
if (matched > len) {
len = matched;
pos = i;
}
}
return {pos, len};
}
int main() {
int i, j, k;
auto &fs = cin;
fs >> in >> out;
rin = in;
reverse(rin.begin(), rin.end());
int skip = 0;
int i1, len1, i2, len2;
vector<pair<int, int> > result;
while (skip < out.size()) {
tie(i1, len1) = find_max(skip, in, out);
tie(i2, len2) = find_max(skip, rin, out);
if (len1 > len2) {
skip += len1;
result.emplace_back(i1 + 1, i1 + len1);
} else if (len1 == len2) {
if (len1 > 0) {
skip += len1;
result.emplace_back(i1 + 1, i1 + len1);
} else
break;
} else {
skip += len2;
result.emplace_back(rin.size() - i2, rin.size() - (i2 + len2 - 1));
}
}
if (skip != out.size()) {
cout << -1 << endl;
return 0;
}
cout << result.size() << '\n';
for (const auto &p : result) {
cout << p.first << ' ' << p.second << '\n';
}
cout.flush();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.