text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int N = 26;
long long f[MAXN], g[MAXN];
const long long mod = 1e9 + 7;
struct Palindromic_Tree {
int next[MAXN][N];
int fail[MAXN];
int cnt[MAXN];
int num[MAXN];
int len[MAXN];
int S[MAXN];
int last;
int n;
int p;
int delta[MAXN], start[MAXN];
int newnode(int l) {
for (int i = 0; i < N; ++i) next[p][i] = 0;
cnt[p] = 0;
num[p] = 0;
len[p] = l;
return p++;
}
void init() {
p = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
S[n] = -1;
fail[0] = 1;
}
int get_fail(int x) {
while (S[n - len[x] - 1] != S[n]) x = fail[x];
return x;
}
void add(int i, int c) {
c -= 'a';
S[++n] = c;
int cur = get_fail(last);
if (!next[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = next[get_fail(fail[cur])][c];
next[cur][c] = now;
num[now] = num[fail[now]] + 1;
delta[now] = len[now] - len[fail[now]];
if (delta[now] == delta[fail[now]])
start[now] = start[fail[now]];
else
start[now] = now;
}
last = next[cur][c];
for (int j = last; j >= 1; j = fail[start[j]]) {
g[j] = f[i - len[start[j]]];
if (start[j] != j) g[j] = (g[j] + g[fail[j]]) % mod;
if (i % 2 == 0) f[i] = (f[i] + g[j]) % mod;
}
cnt[last]++;
}
void count() {
for (int i = p - 1; i >= 0; --i) cnt[fail[i]] += cnt[i];
}
} P;
char s[MAXN], str[MAXN];
int main() {
scanf("%s", str);
int n = strlen(str);
int num = 0;
for (int i = 1; i <= n; i += 2) s[i] = str[num++];
num = n - 1;
for (int i = 2; i <= n; i += 2) s[i] = str[num--];
f[0] = 1;
P.init();
for (int i = 1; i <= n; i++) {
P.add(i, s[i]);
}
printf("%lld", f[n]);
}
|
#include <bits/stdc++.h>
const int N = 1e6;
const int mod = 1e9 + 7;
using namespace std;
int n;
char s[N + 5], ns[N + 5];
struct PAM {
int ch[N + 5][26], fail[N + 5], len[N + 5], nc, las, f[N + 5], sf[N + 5],
d[N + 5], pos[N + 5];
char s[N + 5];
void init(char *ch) {
for (int i = 1; i <= n; i++) s[i] = ch[i];
s[0] = '#';
len[1] = -1;
pos[0] = 1;
fail[0] = 1;
f[0] = 1;
nc = 1;
}
void insert(int x) {
int p = las;
while (s[x - len[p] - 1] != s[x]) p = fail[p];
if (!ch[p][s[x] - 'a']) {
len[++nc] = len[p] + 2;
int j = fail[p];
while (s[x - len[j] - 1] != s[x]) j = fail[j];
fail[nc] = ch[j][s[x] - 'a'];
d[nc] = len[nc] - len[fail[nc]];
if (d[nc] == d[fail[nc]])
pos[nc] = pos[fail[nc]];
else
pos[nc] = fail[nc];
ch[p][s[x] - 'a'] = nc;
}
las = ch[p][s[x] - 'a'];
int j = las;
while (j > 1) {
sf[j] = f[x - len[pos[j]] - d[j]];
if (pos[j] != fail[j]) sf[j] += sf[fail[j]], sf[j] %= mod;
if (x % 2 == 0) f[x] += sf[j], f[x] %= mod;
j = pos[j];
}
}
void build() {
for (int i = 1; i <= n; i++) insert(i);
}
} pa;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int l = 1, r = n;
for (int i = 1; i <= n; i++)
if (i % 2 == 1)
ns[i] = s[l++];
else
ns[i] = s[r--];
pa.init(ns);
pa.build();
cout << pa.f[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
inline long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
char _s[1000010], s[1000010];
int n;
int ch[1000010][26], dif[1000010], anc[1000010], fail[1000010], len[1000010],
cnt, f[1000010], g[1000010], lst;
inline int newnode(int Len) {
++cnt, len[cnt] = Len;
return cnt;
}
inline void extend(int c, int n) {
int p = lst, q = ch[p][c];
while (s[n - len[p] - 1] != s[n]) p = fail[p];
if (!ch[p][c]) {
int np = newnode(len[p] + 2);
q = fail[p];
while (s[n - len[q] - 1] != s[n]) q = fail[q];
fail[np] = ch[q][c];
ch[p][c] = np;
dif[np] = len[np] - len[fail[np]];
anc[np] = dif[np] == dif[fail[np]] ? anc[fail[np]] : fail[np];
}
lst = ch[p][c];
}
int main() {
scanf("%s", _s + 1);
n = strlen(_s + 1);
for (int l = 1, r = n, p = 1; l <= r; ++l, --r)
s[p++] = _s[l], s[p++] = _s[r];
cnt = lst = 1;
len[0] = 0, len[1] = -1;
fail[0] = fail[1] = 1;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
extend(s[i] - 'a', i);
for (int j = lst; j; j = anc[j]) {
g[j] = f[i - len[anc[j]] - dif[j]];
if (anc[j] ^ fail[j]) g[j] = (g[j] + g[fail[j]]) % 1000000007;
if (~i & 1) f[i] = (f[i] + g[j]) % 1000000007;
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 1, maxl = 25, mod = (int)1e9 + 7;
int n, m, sta[maxl], dif[maxl], cnt[maxl], f[maxn], g[maxn];
char buf[maxn], str[maxn];
inline void mod_inc(int &x, int y) { (x += y) >= mod && (x -= mod); }
int main() {
scanf("%s", buf + 1);
n = strlen(buf + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n >> 1; ++i) {
str[(i << 1) - 1] = buf[i];
str[i << 1] = buf[n - i + 1];
}
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int tp = m, las = -maxn;
static int tsta[maxl], tdif[maxl], tcnt[maxl];
m = 0;
memcpy(tsta + 1, sta + 1, tp * sizeof(int));
memcpy(tdif + 1, dif + 1, tp * sizeof(int));
memcpy(tcnt + 1, cnt + 1, tp * sizeof(int));
for (int j = 1; j <= tp; ++j) {
if (str[tsta[j]] == str[i]) {
if (m && dif[m] == tsta[j] - 1 - las) {
++cnt[m];
} else {
sta[++m] = tsta[j] - 1;
dif[m] = sta[m] - las;
cnt[m] = 1;
}
las = tsta[j] - 1;
}
if (tcnt[j] > 1 && str[tsta[j] + tdif[j]] == str[i]) {
if (m && dif[m] == tsta[j] + tdif[j] - 1 - las) {
cnt[m] += tcnt[j] - 1;
} else {
sta[++m] = tsta[j] + tdif[j] - 1;
dif[m] = sta[m] - las;
cnt[m] = tcnt[j] - 1;
}
las = tsta[j] + tdif[j] * (tcnt[j] - 1) - 1;
}
}
if (str[i - 1] == str[i]) {
if (m && i - 2 - las == dif[m]) {
++cnt[m];
} else {
sta[++m] = i - 2;
dif[m] = sta[m] - las;
cnt[m] = 1;
}
las = i - 2;
}
for (int j = 1; j <= m; ++j) {
int tsta = sta[j], tdif = dif[j], tcnt = cnt[j],
tend = tsta + (tcnt - 1) * tdif;
g[tend] = f[tend];
if (tcnt > 1) mod_inc(g[tend], g[tend - tdif]);
mod_inc(f[i], g[tend]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[1000000 + 5], t[1000000 + 5];
struct PAM {
struct node {
int ch[26];
int len;
int fail;
int d;
int top;
} t[1000000 * 2 + 5];
int ptr, last;
char *str;
void ini(char *in) {
str = in;
ptr = 1;
t[0].len = 0;
t[0].fail = 1;
t[1].len = -1;
t[1].fail = 0;
last = 0;
}
int get_fail(int x, int n) {
while (str[n - t[x].len - 1] != str[n]) x = t[x].fail;
return x;
}
void insert(int c, int pos) {
int p = get_fail(last, pos);
if (!t[p].ch[c]) {
int cur = ++ptr;
(t[cur].len) = (t[p].len) + 2;
(t[cur].fail) = t[get_fail((t[p].fail), pos)].ch[c];
t[cur].d = t[cur].len - t[(t[cur].fail)].len;
if (t[cur].d == t[(t[cur].fail)].d)
t[cur].top = t[(t[cur].fail)].top;
else
t[cur].top = (t[cur].fail);
t[p].ch[c] = cur;
}
last = t[p].ch[c];
}
long long sum[1000000 + 5];
long long dp[1000000 + 5];
void solve() {
dp[0] = 1;
for (int i = 1; i <= n; i++) {
insert(str[i] - 'a', i);
for (int j = last; j > 1; j = t[j].top) {
sum[j] = dp[i - (t[t[j].top].len) - t[j].d];
if (t[j].d == t[(t[j].fail)].d)
sum[j] = (sum[j] + sum[(t[j].fail)]) % 1000000007;
if (i % 2 == 0) dp[i] = (dp[i] + sum[j]) % 1000000007;
}
}
printf("%lld\n", dp[n]);
}
} T;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n / 2; i++) {
t[2 * i - 1] = s[i];
t[2 * i] = s[n + 1 - i];
}
T.ini(t);
T.solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
using vvi = vector<vi>;
using vii = vector<pii>;
string s;
bool read() {
if (!(cin >> s)) {
return 0;
}
return 1;
}
const int mod = (int)1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void sub(int &a, int b) {
a -= b;
if (a < 0) a += mod;
}
void kill(vi &v) {
v.clear();
v.shrink_to_fit();
}
struct gap_jumper {
string s;
vi value;
int n;
gap_jumper(string s_, int n_) {
n = n_;
value.resize(n + 1);
s = s_;
assert(int((s).size()) == 2 * n);
}
vi d_was;
vvi next_, prev_, sum_;
int get_id(int step) {
int pos = find((d_was).begin(), (d_was).end(), step) - d_was.begin();
if (pos != int((d_was).size())) return pos;
d_was.push_back(step);
next_.push_back(vi(2 * n)), prev_.push_back(vi(2 * n)),
sum_.push_back(vi());
sum_.back().reserve(n);
vi &next = next_.back();
vi &prev = prev_.back();
for (int i = int(2 * n) - 1; i >= 0; --i) {
if (i + step >= 2 * n)
next[i] = 1;
else
next[i] = (s[i] != s[i + step] ? 1 : next[i + step] + 1);
}
for (int i = 0; i < int(2 * n); ++i) {
if (i < step)
prev[i] = 1;
else
prev[i] = (s[i] != s[i - step] ? 1 : prev[i - step] + 1);
}
return pos;
}
int first_left(int pos, int step, char what) {
const int id = get_id(step);
const vi &prev = prev_[id];
if (what != s[pos]) return 0;
return prev[pos];
}
int first_right(int pos, int step, char what) {
const int id = get_id(step);
const vi &next = next_[id];
if (what != s[pos]) return 0;
return next[pos];
}
int sum(int pos, int step, int len) {
const int id = get_id(step);
vi &sum = sum_[id];
int to = pos + step * (len - 1);
assert(0 <= pos && pos <= to && to < int((value).size()));
while (int((sum).size()) <= to) {
const int cur_id = int((sum).size());
sum.push_back(value[cur_id]);
if (cur_id >= step) add(sum.back(), sum[cur_id - step]);
}
int res = sum[to];
if (pos - step >= 0) sub(res, sum[pos - step]);
return res;
}
};
struct prog {
int start, diff, len;
int get(int id) const { return start + diff * id; }
int get_end() const { return start + diff * (len - 1); }
};
void relax(vector<prog> &v) {
vector<prog> nv;
for (const auto &pr : v) {
if (pr.len == 0) continue;
if (nv.empty())
nv.push_back(pr);
else {
auto &top = nv.back();
if (top.len == 1 && pr.len == 1)
top = prog{top.start, pr.start - top.start, 2};
else if (top.len == 1 && pr.start - top.start == pr.diff) {
top = prog{top.start, pr.diff, pr.len + 1};
} else if (pr.len == 1 && pr.start - top.get_end() == top.diff) {
top.len++;
} else if (pr.diff == top.diff && pr.start - top.get_end() == top.diff) {
top.len += pr.len;
} else {
nv.push_back(pr);
}
}
}
v.swap(nv);
}
void incr_all(vector<prog> &v, int delta) {
for (auto &pr : v) pr.start += delta;
}
void add_start(vector<prog> &v, int num) {
assert(v.empty() || num < v.front().start);
v.insert(v.begin(), prog{num, 1, 1});
}
void del(vector<prog> &v, const vi &who) {
int ptr = 0;
vector<prog> nv;
for (const auto &pr : v) {
int last_alive = 0;
while (ptr < int((who).size()) && pr.start <= who[ptr] &&
who[ptr] <= pr.get_end()) {
assert((who[ptr] - pr.start) % pr.diff == 0);
int cur_id = (who[ptr] - pr.start) / pr.diff;
if (last_alive < cur_id)
nv.push_back(prog{pr.get(last_alive), pr.diff, cur_id - last_alive});
assert(last_alive <= cur_id);
last_alive = cur_id + 1;
ptr++;
}
const int total = pr.len;
if (last_alive < total)
nv.push_back(prog{pr.get(last_alive), pr.diff, total - last_alive});
}
v.swap(nv);
relax(v);
}
void print(const vector<prog> &v) {
for (const auto &pr : v) {
for (int i = 0; i < int(pr.len); ++i)
;
;
};
;
}
double time() { return (double)clock() / CLOCKS_PER_SEC; }
int work_old() {
const int n = int((s).size()) / 2;
assert(int((s).size()) == 2 * n);
vi dp(n + 1);
dp[0] = 1;
vi pref;
for (int len = 0; len < int(n + 1); ++len)
if (len) {
if (int((pref).size()) >= 50) return -1;
const int l = n - len, r = n + len;
vi npref;
for (int i : pref) {
if (s[l] == s[r - i - 2] && s[l + i + 1] == s[r - 1] && i + 2 <= len)
npref.push_back(i + 2);
}
if (s[l] == s[r - 1]) npref.push_back(1);
if (len >= 2 && s[l] == s[r - 2] && s[l + 1] == s[r - 1])
npref.push_back(2);
pref = npref;
for (int i : pref) add(dp[len], dp[len - i]);
}
return dp[n];
}
void solve() {
const int n = int((s).size()) / 2;
assert(int((s).size()) == 2 * n);
int ans = work_old();
if (ans != -1) {
cout << ans << endl;
return;
}
gap_jumper info(s, n);
vi dp(n + 1);
dp[0] = 1;
info.value[0] = 1;
vector<prog> pref;
for (int len = 0; len < int(n + 1); ++len)
if (len) {
const int l = n - len, r = n + len;
vi to_del;
for (const auto &pr : pref) {
for (int i = 0; i < pr.len;) {
int cur = pr.get(i);
const int left_steps = info.first_left(r - cur - 2, pr.diff, s[l]);
const int right_steps =
info.first_right(l + cur + 1, pr.diff, s[r - 1]);
const int steps = min(left_steps, right_steps);
i += steps;
if (i >= pr.len) break;
cur = pr.get(i);
assert(!(s[l] == s[r - cur - 2] && s[l + cur + 1] == s[r - 1]));
to_del.push_back(cur);
i++;
}
}
if (!pref.empty() && pref.back().get_end() == len - 1 &&
!count((to_del).begin(), (to_del).end(), len - 1))
to_del.push_back(len - 1);
del(pref, to_del);
incr_all(pref, 2);
if (len >= 2 && s[l] == s[r - 2] && s[l + 1] == s[r - 1])
add_start(pref, 2);
if (s[l] == s[r - 1]) add_start(pref, 1);
relax(pref);
assert(int((pref).size()) <= 20);
for (const auto &pr : pref) {
int start = len - pr.get_end();
int cur_sum = info.sum(start, pr.diff, pr.len);
add(dp[len], cur_sum);
}
vi allowed;
for (const auto &pr : pref) allowed.push_back(pr.diff);
sort((allowed).begin(), (allowed).end());
allowed.resize(unique((allowed).begin(), (allowed).end()) -
allowed.begin());
info.value[len] = dp[len];
}
cout << dp[n] << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
while (read()) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 5, SIG = 26;
int str[MX], len[MX], link[MX], to[MX][SIG], slink[MX], dif[MX];
int cur, sl, sz;
void init() {
memset(to, 0, sizeof(to));
cur = sl = 0;
str[sl++] = -1;
link[0] = 1, len[0] = 0;
link[1] = 0, len[1] = -1;
sz = 2;
}
int getLink(int v) {
while (str[sl - len[v] - 2] != str[sl - 1]) v = link[v];
return v;
}
void insert(int c) {
str[sl++] = c;
cur = getLink(cur);
if (!to[cur][c]) {
len[sz] = len[cur] + 2;
link[sz] = to[getLink(link[cur])][c];
dif[sz] = len[sz] - len[link[sz]];
if (dif[sz] == dif[link[sz]])
slink[sz] = slink[link[sz]];
else
slink[sz] = link[sz];
to[cur][c] = sz++;
}
cur = to[cur][c];
}
const int mod = 1e9 + 7;
string s, in;
int dp[MX], acu[MX];
void sum(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> in;
for (int i = 0; s.size() < in.size(); i++)
s.push_back(in[i]), s.push_back(in[in.size() - i - 1]);
init();
dp[0] = 1;
for (int i = 1; i <= s.size(); i++) {
insert(s[i - 1] - 'a');
for (int j = cur; j > 1; j = slink[j]) {
acu[j] = dp[i - len[slink[j]] - dif[j]];
if (dif[j] == dif[link[j]]) sum(acu[j], acu[link[j]]);
sum(dp[i], acu[j]);
}
if (i % 2) dp[i] = 0;
}
cout << dp[s.size()] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 1, maxc = 26, mod = (int)1e9 + 7;
int len[maxn], link[maxn], to[maxn][maxc + 1];
int slink[maxn], diff[maxn], f[maxn], g[maxn];
int sz, last, n;
char buf[maxn], s[maxn];
inline int get_link(int v) {
for (; s[n - len[v] - 2] != s[n - 1]; v = link[v])
;
return v;
}
void add_letter(char c) {
s[n++] = c -= 'a';
last = get_link(last);
if (!to[last][(int)c]) {
len[sz] = len[last] + 2;
link[sz] = to[get_link(link[last])][c];
diff[sz] = len[sz] - len[link[sz]];
if (diff[sz] == diff[link[sz]])
slink[sz] = slink[link[sz]];
else
slink[sz] = link[sz];
to[last][c] = sz++;
}
last = to[last][c];
}
inline void mod_inc(int &x, int y) { (x += y) >= mod && (x -= mod); }
int main() {
scanf("%s", s);
int n = strlen(s);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 0; i < n >> 1; ++i) buf[i << 1] = s[i];
for (int i = 0; i < n >> 1; ++i) buf[i << 1 | 1] = s[n - 1 - i];
s[::n++] = -1;
link[0] = 1;
len[1] = -1;
sz = 2;
f[0] = 1;
for (int i = 1; i <= n; i++) {
add_letter(buf[i - 1]);
for (int v = last; len[v] > 0; v = slink[v]) {
g[v] = f[i - (len[slink[v]] + diff[v])];
if (diff[v] == diff[link[v]]) mod_inc(g[v], g[link[v]]);
if (!(i & 1)) mod_inc(f[i], g[v]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1000054, mod = 1000000007;
int n;
int f[N], F[N];
char s[N], t[N], *ptr;
inline void add(int &x, const int y) { x += y - mod, x += x >> 31 & mod; }
namespace PAM {
int p, cnt;
int d[N][26], fail[N], val[N];
int per[N], fst[N];
void init() { val[1] = -1, p = 0, *fail = cnt = 1; }
int get_fail(int x) {
for (; ptr[~val[x]] != *ptr; x = fail[x])
;
return x;
}
int extend(int x) {
int &q = d[p = get_fail(p)][x];
if (!q)
fail[++cnt] = d[get_fail(fail[p])][x], val[q = cnt] = val[p] + 2,
per[cnt] = val[cnt] - val[fail[cnt]],
fst[cnt] = (per[cnt] == per[fail[cnt]] ? fst[fail[cnt]] : fail[cnt]);
return p = q;
}
} // namespace PAM
int main() {
int i, j, p = 0, l;
scanf("%s", t), n = strlen(t);
if (n & 1) return putchar(48), putchar(10), 0;
for (i = 0, j = n - 1; i < j; s[p++] = t[i++], s[p++] = t[j--])
;
PAM::init();
for (*f = i = 1, ptr = s; i <= n; ++i, ++ptr)
for (p = PAM::extend(*ptr - 97); p; p = j) {
j = PAM::fst[p], l = PAM::val[j] + PAM::per[p], F[p] = f[i - l];
if (PAM::val[p] != l) add(F[p], F[PAM::fail[p]]);
if (!(i & 1)) add(f[i], F[p]);
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 9;
const int mod = 1e9 + 7;
int ans[N], series_ans[N];
struct PalindromicTree {
struct node {
int nxt[26], len, st, en, suflink, diff, slink;
int cnt;
int oc;
};
string s;
vector<node> t;
int sz, suf;
void init(int len) {
t.clear();
t.resize(len + 9);
sz = 2, suf = 2;
t[1].len = -1, t[1].suflink = 1;
t[2].len = 0, t[2].suflink = 1;
t[1].diff = t[2].diff = 0;
t[1].slink = 1;
t[2].slink = 2;
}
int add_letter(int pos) {
int cur = suf, curlen = 0;
int ch = s[pos] - 'a';
while (1) {
curlen = t[cur].len;
if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos]) break;
cur = t[cur].suflink;
}
if (t[cur].nxt[ch]) {
suf = t[cur].nxt[ch];
t[suf].oc++;
return 0;
}
sz++;
suf = sz;
t[sz].oc = 1;
t[sz].len = t[cur].len + 2;
t[cur].nxt[ch] = sz;
t[sz].en = pos;
t[sz].st = pos - t[sz].len + 1;
if (t[sz].len == 1) {
t[sz].suflink = 2;
t[sz].cnt = 1;
t[sz].diff = 1;
t[sz].slink = 2;
return 1;
}
while (1) {
cur = t[cur].suflink;
curlen = t[cur].len;
if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos]) {
t[sz].suflink = t[cur].nxt[ch];
break;
}
}
t[sz].cnt = 1 + t[t[sz].suflink].cnt;
t[sz].diff = t[sz].len - t[t[sz].suflink].len;
if (t[sz].diff == t[t[sz].suflink].diff)
t[sz].slink = t[t[sz].suflink].slink;
else
t[sz].slink = t[sz].suflink;
return 1;
}
int build(string &p) {
s = p;
int n = p.size();
int tot = 0;
for (int i = 0; i < n; i++) tot += add_letter(i);
return tot;
}
void calc_oc() {
for (int i = sz; i >= 3; i--) t[t[i].suflink].oc += t[i].oc;
}
void calc_dp(int i) {
for (int v = suf; t[v].len > 0; v = t[v].slink) {
series_ans[v] = ans[i - (t[t[v].slink].len + t[v].diff)];
if (t[v].diff == t[t[v].suflink].diff)
series_ans[v] = (series_ans[v] + series_ans[t[v].suflink]) % mod;
if (i % 2 == 0) ans[i] = (ans[i] + series_ans[v]) % mod;
}
}
} t;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string p;
cin >> p;
string s = "";
int n = p.size();
for (int i = 0, j = n - 1; i <= j; i++, j--) s += p[i], s += p[j];
t.init(n);
t.s = s;
ans[0] = 1;
for (int i = 0; i < n; i++) {
t.add_letter(i);
t.calc_dp(i + 1);
}
cout << ans[n] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e6 + 100;
const int mod = 1e9 + 7;
char s[N], t[N];
int n;
long long f[N], g[N];
struct Palindrome_tree {
int nxt[N][26];
int fail[N];
int len[N];
int cnt[N];
int sed[N];
int record[N];
int diff[N], anc[N];
char s[N];
int tot;
int last;
int n;
void newnode() {
tot++;
memset(nxt[tot], 0, sizeof(nxt[tot]));
cnt[tot] = sed[tot] = len[tot] = fail[tot] = 0;
}
void init() {
n = 0;
tot = -1;
newnode();
newnode();
len[0] = 0, len[1] = -1;
tot = 1, last = 0;
fail[0] = 1;
}
int getfail(int x, int n) {
while (s[n - len[x] - 1] != s[n] || n - len[x] - 1 < 0) x = fail[x];
return x;
}
void insert(char ch) {
int c = ch - 'a';
s[++n] = ch;
int p = getfail(last, n);
if (!nxt[p][c]) {
newnode();
len[tot] = len[p] + 2;
fail[tot] = nxt[getfail(fail[p], n)][c];
sed[tot] = sed[fail[tot]] + 1;
nxt[p][c] = tot;
diff[tot] = len[tot] - len[fail[tot]];
anc[tot] = diff[tot] == diff[fail[tot]] ? anc[fail[tot]] : fail[tot];
}
last = nxt[p][c];
cnt[last]++;
record[last] = n;
trans(n);
}
void trans(int i) {
for (int j = last; j > 1; j = anc[j]) {
g[j] = f[i - len[anc[j]] - diff[j]];
if (diff[j] == diff[fail[j]]) g[j] = (g[j] + g[fail[j]]) % mod;
f[i] = (f[i] + (i % 2 == 0) * g[j]) % mod;
}
}
void get_cnt() {
for (int i = tot; i > 0; i--) cnt[fail[i]] += cnt[i];
}
} tree;
int main() {
tree.init();
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n / 2; i++) {
t[2 * i - 1] = s[i];
t[2 * i] = s[n - i + 1];
}
f[0] = 1;
for (int i = 1; i <= n; i++) tree.insert(t[i]);
printf("%lld\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 2e5 + 100;
struct str {
long long start, delta, count;
str(long long start1 = 0, long long delta1 = 0, long long count1 = 0)
: start(start1), delta(delta1), count(count1) {}
long long end() { return start + delta * (count - 1); }
};
vector<str> g1;
void push(str t) {
if ((long long)g1.size() == 0 || g1.back().delta != t.delta) {
g1.push_back(t);
} else {
g1.back().count += t.count;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = (long long)s.size();
string s1;
for (long long i = 0; i < n / 2; i++) {
s1 += s[i];
s1 += s[n - i - 1];
}
vector<str> g;
vector<long long> d(n + 1), cache(n + 1);
d[0] = 1;
for (long long i = 0; i < n; i++) {
long long prev = -i - 1;
for (auto t : g) {
if (t.start > 0 && s1[t.start - 1] == s1[i]) {
t.start--;
if (prev != t.start - t.delta) {
push(str(t.start, t.start - prev, 1));
t.start += t.delta;
t.count--;
}
if (t.count > 0) {
push(t);
}
prev = t.end();
}
}
if (i >= 1 && s1[i - 1] == s1[i]) {
push(str(i - 1, i - 1 - prev, 1));
}
g = move(g1);
for (auto &t : g) {
long long add = d[t.end()];
if (t.count > 1) {
add += cache[t.start - t.delta];
}
add %= mod;
if (t.start - t.delta >= 0) {
cache[t.start - t.delta] = add;
}
d[i + 1] += add;
d[i + 1] %= mod;
}
g1.clear();
}
cout << d[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
string s;
struct tree {
string s;
int to[26][1000007];
int suf[1000007];
int slink[1000007];
int diff[1000007];
int len[1000007];
int last;
int sz;
tree() {
s = "#";
for (int i = 0; i < 26; i++)
for (int j = 0; j < 1000007; j++) to[i][j] = -1;
sz = 2;
last = 1;
len[0] = -1;
suf[1] = 0;
suf[0] = -1;
}
void add(char c) {
s += c;
while (c != s[(int)s.size() - len[last] - 2]) last = suf[last];
if (to[c - 'a'][last] == -1) {
int v = sz++;
to[c - 'a'][last] = v;
len[v] = len[last] + 2;
do {
last = suf[last];
} while (last != -1 && s[(int)s.size() - len[last] - 2] != c);
if (last == -1) {
suf[v] = 1;
} else {
suf[v] = to[c - 'a'][last];
}
diff[v] = len[v] - len[suf[v]];
if (diff[v] == diff[suf[v]])
slink[v] = slink[suf[v]];
else
slink[v] = suf[v];
last = v;
} else
last = to[c - 'a'][last];
}
} tr;
int dp[1000007];
int dpKek[1000007];
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
string t;
for (int i = 0; i < s.size(); i++) {
if (i % 2 == 0) {
t += s[i / 2];
} else {
t += s[(int)s.size() - i / 2 - 1];
}
}
dp[0] = 1;
for (int i = 1; i <= t.size(); i++) {
char c = t[i - 1];
tr.add(c);
for (int v = tr.last; v > 1; v = tr.slink[v]) {
dpKek[v] = dp[i - tr.len[tr.slink[v]] - tr.diff[v]];
if (tr.diff[v] == tr.diff[tr.suf[v]]) add(dpKek[v], dpKek[tr.suf[v]]);
add(dp[i], dpKek[v]);
}
if (i % 2 == 1) {
dp[i] = 0;
}
}
cout << dp[t.size()];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn(1e6 + 5);
const int mod(1e9 + 7);
inline void Inc(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
int n, f[maxn], dif[maxn], anc[maxn], g[maxn];
int fa[maxn], len[maxn], trans[26][maxn], tot, last;
char s[maxn], tmp[maxn];
inline void Extend(int c, int pos) {
register int np, p = last, q, i;
while (s[pos] != s[pos - len[p] - 1]) p = fa[p];
if (!trans[c][p]) {
np = ++tot, len[np] = len[p] + 2, q = fa[p];
while (s[pos] != s[pos - len[q] - 1]) q = fa[q];
fa[np] = trans[c][q], trans[c][p] = np;
dif[np] = len[np] - len[fa[np]];
anc[np] = dif[np] == dif[fa[np]] ? anc[fa[np]] : np;
}
last = trans[c][p];
}
int main() {
register int i, j, l = 0;
scanf(" %s", tmp + 1), n = strlen(tmp + 1);
if (n & 1) return puts("0"), 0;
for (i = 1, j = n; i <= j; ++i, --j) s[++l] = tmp[i], s[++l] = tmp[j];
f[0] = 1, len[1] = -1, fa[1] = fa[0] = 1, tot = last = 1;
for (i = 1; i <= n; ++i) {
Extend(s[i] - 'a', i);
for (j = last; j; j = fa[anc[j]]) {
g[j] = f[i - len[anc[j]]];
if (anc[j] != j) Inc(g[j], g[fa[j]]);
if (~i & 1) Inc(f[i], g[j]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
register long long x = 0, f = 1;
register char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
const int maxn = 1e6 + 233;
const int mod = 1e9 + 7;
int ans = 0, n;
char s[maxn], ss[maxn];
int len[maxn], fail[maxn], tot, last, L[maxn];
int anc[maxn], f[maxn], g[maxn], dif[maxn];
int first[maxn], tote, nxtv[maxn], nxtx[maxn], nxtp[maxn];
inline void init() {
s[0] = '#';
len[0] = 0;
len[1] = -1;
fail[0] = fail[1] = 1;
tot = 1, last = 0;
memset(first, -1, sizeof(first));
tote = 0;
}
inline void add(int x, int v, int to) {
nxtv[tote] = v;
nxtp[tote] = first[x];
nxtx[tote] = to;
first[x] = tote++;
}
inline int find(int x, int v) {
for (int e = first[x]; ~e; e = nxtp[e])
if (nxtv[e] == v) return nxtx[e];
return 0;
}
inline int gfail(int x, int pos) {
while (s[pos - len[x] - 1] != s[pos]) x = fail[x];
return x;
}
void extend(int x) {
last = gfail(last, x);
if (!find(last, s[x])) {
++tot;
len[tot] = len[last] + 2;
int j = gfail(fail[last], x);
fail[tot] = find(j, s[x]);
dif[tot] = len[tot] - len[fail[tot]];
anc[tot] = fail[tot];
if (dif[tot] == dif[fail[tot]]) anc[tot] = anc[fail[tot]];
add(last, s[x], tot);
}
last = find(last, s[x]);
}
int main() {
scanf("%s", ss + 1);
n = strlen(ss + 1);
if (n & 1) return puts("0"), 0;
for (register int i = (1); i <= int(n / 2); ++i) {
s[i * 2 - 1] = ss[i] - 'a';
s[i * 2] = ss[n - i + 1] - 'a';
}
init();
f[0] = 1;
for (register int i = (1); i <= int(n); ++i) {
extend(i);
for (int x = last; x; x = anc[x]) {
if (dif[x] == dif[fail[x]]) {
g[x] = f[i - (len[anc[x]] + dif[x])];
g[x] = (g[x] + g[fail[x]]) % mod;
} else {
g[x] = f[i - (len[anc[x]] + dif[x])];
}
if (i % 2 == 0) f[i] = (f[i] + g[x]) % mod;
}
}
writeln(f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
void update(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
struct Palindromic_Tree {
int next[maxn][26];
int fail[maxn];
int len[maxn];
int S[maxn];
int last;
int diff[maxn], slink[maxn], fp[maxn];
int n;
int p;
int newnode(int l) {
for (int i = 0; i < 26; ++i) next[p][i] = 0;
len[p] = l;
return p++;
}
void init() {
p = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
S[n] = -1;
fail[0] = 1;
}
int get_fail(int x) {
while (S[n - len[x] - 1] != S[n]) x = fail[x];
return x;
}
int add(int c) {
c -= 'a';
S[++n] = c;
int cur = get_fail(last);
if (!next[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = next[get_fail(fail[cur])][c];
next[cur][c] = now;
diff[now] = len[now] - len[fail[now]];
slink[now] =
(diff[now] == diff[fail[now]] ? slink[fail[now]] : fail[now]);
}
last = next[cur][c];
return last;
}
void solve(int dp[], char s[], int n) {
int i, j;
init();
dp[0] = 1;
for (i = 1; i <= n; i++) {
for (j = add(s[i]); j; j = slink[j]) {
fp[j] = dp[i - (len[slink[j]] + diff[j])];
if (diff[j] == diff[fail[j]]) update(fp[j], fp[fail[j]]);
if (!(i & 1)) update(dp[i], fp[j]);
}
}
}
} Pt;
char s1[maxn], ss[maxn];
int ans[maxn];
int main() {
int n, i, l, r;
scanf(" %s", s1);
n = strlen(s1);
for (i = 1, l = 0, r = n - 1; i <= n; i++) {
if (i & 1)
ss[i] = s1[l++];
else
ss[i] = s1[r--];
}
memset(ans, 0, sizeof(ans));
Pt.solve(ans, ss, n);
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
char t[N];
int n, m = 0, s[N], ch[N][26], fa[N], len[N], diff[N], anc[N], tot = 0, p = 0,
f[N], g[N];
void extend(int n, int c) {
while (s[n] != s[n - len[p] - 1]) p = fa[p];
if (!ch[p][c]) {
int q = ++tot;
len[q] = len[p] + 2;
int v = fa[p];
while (s[n] != s[n - len[v] - 1]) v = fa[v];
fa[q] = ch[v][c];
ch[p][c] = q;
diff[q] = len[q] - len[fa[q]],
anc[q] = diff[q] == diff[fa[q]] ? anc[fa[q]] : fa[q];
}
p = ch[p][c];
}
int main() {
scanf("%s", t + 1), n = strlen(t + 1);
for (int i = 1; i <= n / 2; i++)
s[++m] = t[i] - 'a', s[++m] = t[n - i + 1] - 'a';
s[0] = -1, s[n + 1] = -2;
len[++tot] = -1, fa[0] = fa[1] = 1;
f[0] = 1;
for (int i = 1; i <= n; i++) {
extend(i, s[i]);
for (int v = p; v; v = anc[v]) {
g[v] = f[i - len[anc[v]] - diff[v]];
if (fa[v] != anc[v]) g[v] = (g[v] + g[fa[v]]) % mod;
if (!(i & 1)) f[i] = (f[i] + g[v]) % mod;
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mo = 1e9 + 7;
char s[N], g[N];
int n, slink[N], link[N], c[N][26], len[N], tot, last, d[N];
long long f[N], sumf[N][2];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
if (n % 2) {
printf("0");
return 0;
}
for (int i = 1; i * 2 <= n; i++) g[i * 2 - 1] = s[i];
for (int i = n, w = 2; i > (n >> 1); i--, w += 2) {
g[w] = s[i];
}
memcpy(s, g, sizeof s);
f[0] = 1;
len[1] = -1;
link[0] = 1;
tot = 1;
for (int i = 1; i <= n; i++) {
while (s[i - 1 - len[last]] != s[i]) {
last = link[last];
}
int r = s[i] - 'a';
if (c[last][r] == 0) {
len[++tot] = len[last] + 2;
int k = link[last];
while (s[i - 1 - len[k]] != s[i]) k = link[k];
link[tot] = c[k][r];
c[last][r] = tot;
d[tot] = len[tot] - len[link[tot]];
slink[tot] = d[tot] == d[link[tot]] ? slink[link[tot]] : link[tot];
}
last = c[last][r];
for (int v = last; len[v] > 0; v = slink[v]) {
sumf[v][0] = sumf[v][1] = 0;
sumf[v][(i - len[slink[v]] - d[v]) & 1] = f[i - len[slink[v]] - d[v]];
if (d[v] == d[link[v]]) {
sumf[v][0] = (sumf[v][0] + sumf[link[v]][0]) % mo;
sumf[v][1] = (sumf[v][1] + sumf[link[v]][1]) % mo;
}
f[i] = (f[i] + sumf[v][i & 1]) % mo;
}
}
cout << f[n] << endl;
}
|
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
constexpr int N(1e6 + 10), Mod(1e9 + 7);
inline void Add(int &x, const int &y) { x += y - Mod, x += x >> 31 & Mod; }
int n, son[N][26], fail[N], len[N], s[N], f[N], g[N];
int last = 0, cur = 1, cnt, dlt[N], pre[N];
char ch[N], a[N];
void Init() { len[1] = -1, fail[0] = 1, s[0] = 26; }
int find(int x) {
while (s[cnt - len[x] - 1] != s[cnt]) x = fail[x];
return x;
}
void extend(int c) {
s[++cnt] = c;
int t = find(last);
if (!son[t][c]) {
len[++cur] = len[t] + 2, fail[cur] = son[find(fail[t])][c], son[t][c] = cur,
dlt[cur] = len[cur] - len[fail[cur]],
pre[cur] = (dlt[cur] == dlt[fail[cur]] ? pre[fail[cur]] : fail[cur]);
}
last = son[t][c];
}
int main() {
std::scanf("%s", ch + 1), n = std::strlen(ch + 1), f[0] = 1, Init();
for (int i = 1, j = 0; i <= n && j <= n; i++)
a[++j] = ch[i], a[++j] = ch[n - i + 1];
for (int i = 1; i <= n; i++) {
extend(a[i] - 'a');
for (int x = last; x > 1; x = pre[x]) {
g[x] = f[i - len[pre[x]] - dlt[x]];
if (dlt[x] == dlt[fail[x]]) Add(g[x], g[fail[x]]);
if (!(i & 1)) Add(f[i], g[x]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int X = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
X = (X << 3) + (X << 1) + ch - '0', ch = getchar();
return X * w;
}
char ch[1000007], s[1000007];
int n, last, tot, anc[1000007], diz[1000007], ans[1000007], f[1000007];
struct mmp {
int z, len, son[26];
} t[1000007];
void extend(int c, int n, char *s) {
int p = last;
while (s[n - t[p].len - 1] != s[n]) {
p = t[p].z;
}
if (!t[p].son[c]) {
int v = ++tot, k = t[p].z;
t[v].len = t[p].len + 2;
while (s[n - t[k].len - 1] != s[n]) {
k = t[k].z;
}
t[v].z = t[k].son[c];
t[p].son[c] = v;
diz[v] = t[v].len - t[t[v].z].len;
anc[v] = (diz[v] == diz[t[v].z]) ? anc[t[v].z] : t[v].z;
}
last = t[p].son[c];
}
int main() {
t[tot = 1].len = -1;
t[0].z = t[1].z = 1;
anc[0] = 1;
scanf("%s", ch + 1);
n = strlen(ch + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i += 2) {
s[i] = ch[(i + 1) / 2];
}
reverse(&ch[1], &ch[n + 1]);
for (int i = 2; i <= n; i += 2) {
s[i] = ch[(i + 1) / 2];
}
ans[0] = 1;
for (int i = 1; i <= n; i++) {
extend(s[i] - 97, i, s);
for (int k = last; k; k = anc[k]) {
f[k] = ans[i - t[anc[k]].len - diz[k]];
if (anc[k] != t[k].z) {
f[k] = (f[k] + f[t[k].z]) % 1000000007;
}
if (!(i & 1)) {
ans[i] = (ans[i] + f[k]) % 1000000007;
}
}
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mo = 1e9 + 7;
template <typename _T>
_T Fabs(_T x) {
return x > 0 ? x : -x;
}
template <typename _T>
void read(_T &x) {
_T f = 1;
x = 0;
char s = getchar();
while ('0' > s || '9' < s) {
if (s == '-') f = -1;
s = getchar();
}
while ('0' <= s && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
char str[1000100], astr[1000100];
int dp[1000100], g[1000100], n;
struct ming {
int ch[30], len, fail, siz, eail, dif;
};
int add(int x, int y) { return x + y < mo ? x + y : x + y - mo; }
class PAM {
public:
ming a[1000100];
int tot, las;
int getfail(int x, int pos) {
while (str[pos - a[x].len - 1] != str[pos]) x = a[x].fail;
return x;
}
void init() {
a[1].len = -1;
a[0].fail = a[1].fail = 1;
tot = 1;
las = 0;
}
void extend(int x, int p) {
int cur = getfail(las, p), now = a[cur].ch[x];
if (!now) {
now = ++tot;
a[now].len = a[cur].len + 2;
a[now].fail = a[getfail(a[cur].fail, p)].ch[x];
a[cur].ch[x] = now;
a[now].dif = a[now].len - a[a[now].fail].len;
if (a[now].dif == a[a[now].fail].dif)
a[now].eail = a[a[now].fail].eail;
else
a[now].eail = a[now].fail;
}
a[las = now].siz++;
while (now > 1) {
g[now] = dp[p - a[a[now].eail].len - a[now].dif];
if (a[now].eail != a[now].fail) g[now] = add(g[now], g[a[now].fail]);
if (!(p & 1)) dp[p] = add(dp[p], g[now]);
now = a[now].eail;
}
}
} T;
signed main() {
scanf("%s", str + 1);
n = (int)strlen(str + 1);
int l = 1, r = n, id = 0;
while (l <= r) astr[++id] = str[l++], astr[++id] = str[r--];
T.init();
for (int i = 1; i <= n; i++) str[i] = astr[i];
dp[0] = 1;
for (int i = 1; i <= n; i++) T.extend(str[i] - 'a', i);
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
bool m1;
FILE *Input = stdin, *Output = stdout;
const int maxn = 1e6 + 5, Mod = 1e9 + 7, maxa = 30;
int trans[maxn][maxa], link[maxn], len[maxn], totn;
int diff[maxn], slink[maxn], dp[maxn], Sum[maxn];
int S[maxn], pos[maxn];
char Buf[maxn];
bool m2;
int Plus(int ar1, int ar2, int ar3) {
return ar3 - ar1 <= ar2 ? ar1 - ar3 + ar2 : ar1 + ar2;
}
int Minu(int ar1, int ar2, int ar3) {
return ar1 - ar2 < 0 ? ar1 - ar2 + ar3 : ar1 - ar2;
}
int Mul(int ar1, int ar2, int ar3) {
return 1LL * ar1 * ar2 >= ar3 ? 1LL * ar1 * ar2 % ar3 : ar1 * ar2;
}
void Build_PAM(int ar1[], int ar2) {
totn = 2;
len[1] = -1;
len[2] = 0;
link[2] = 1;
int nowlast = 2;
for (int i = 1; i <= ar2; i++) {
int now = nowlast;
while (ar1[i] != ar1[i - len[now] - 1]) now = link[now];
if (!trans[now][ar1[i]]) {
trans[now][ar1[i]] = ++totn;
len[totn] = len[now] + 2;
if (~len[now]) {
int nowlink = link[now];
while (ar1[i] != ar1[i - len[nowlink] - 1]) nowlink = link[nowlink];
link[totn] = trans[nowlink][ar1[i]];
} else
link[totn] = 2;
diff[totn] = len[totn] - len[link[totn]];
slink[totn] =
(diff[totn] == diff[link[totn]] ? slink[link[totn]] : link[totn]);
}
nowlast = trans[now][ar1[i]];
pos[i] = nowlast;
}
}
int main() {
fscanf(Input, "%s", Buf + 1);
int n = strlen(Buf + 1);
for (int i = 1; i <= n; i++)
S[i] = (i & 1 ? Buf[(i >> 1) + 1] : Buf[n - (i >> 1) + 1]) - 96;
Build_PAM(S, n);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = pos[i]; j != 2; j = slink[j]) {
Sum[j] = Plus(link[j] == slink[j] ? 0 : Sum[link[j]],
dp[i - len[slink[j]] - diff[j]], Mod);
if (!(i & 1)) dp[i] = Plus(dp[i], Sum[j], Mod);
}
}
fprintf(Output, "%d\n", dp[n]);
fclose(Input);
fclose(Output);
return 0;
}
|
#include <bits/stdc++.h>
const int mxN(1000233), p(1000000007), sta(0), debug(0);
int n, str[mxN];
inline void init() {
if (sta == 1 || sta == 2) freopen("a.in", "r", stdin);
static char s[mxN];
scanf("%s", s);
n = strlen(s);
if (n & 1) {
puts("0");
exit(0);
}
for (int i = 0, j = n - 1; i < j; ++i, --j)
str[i << 1 | 1] = s[i] - 'a', str[(i + 1) << 1] = s[j] - 'a';
str[0] = -1;
}
namespace PT {
struct D {
int l, d, v[2];
D *f, *a, *e[26];
} ar[mxN], *ed = ar;
int m;
inline void init() {
m = 2;
ar->f = ar + 1;
ar[1].l = -1;
}
inline void insert(int n) {
int c = str[n];
D *u = ed;
for (; c != str[n - u->l - 1]; u = u->f)
;
if (u->e[c]) {
ed = u->e[c];
return;
}
D *v = u->e[c] = ed = ar + m++;
v->l = u->l + 2;
if (u == ar + 1) {
v->f = v->a = ar;
v->d = 1;
return;
}
for (u = u->f; c != str[n - u->l - 1]; u = u->f)
;
v->f = u->e[c];
v->a = (v->d = v->l - v->f->l) == v->f->d ? v->f->a : v->f;
}
} // namespace PT
int main() {
init();
PT::init();
static int f[mxN];
f[0] = 1;
for (int i = 1; i <= n; ++i) {
PT::insert(i);
if (debug) {
using namespace PT;
printf("%d\n", str[i]);
printf("%ld %ld %ld\n", ed - ar, ed->f - ar, ed->a - ar);
}
for (PT::D *u = PT::ed; u != PT::ar; u = u->a) {
u->v[(u->a->l + u->d) & 1] = f[i - u->a->l - u->d];
u->v[~(u->a->l + u->d) & 1] = 0;
if (u->f != u->a) {
u->v[0] = (u->v[0] + u->f->v[u->d & 1]) % p;
u->v[1] = (u->v[1] + u->f->v[~u->d & 1]) % p;
}
f[i] = (f[i] + u->v[0]) % p;
}
}
printf("%d\n", (f[n] + p) % p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
namespace PAM {
char buf[1000010];
class node {
public:
int fail, nxt[26], len, num, cnt, diff, anc;
};
class PAM {
public:
node t[1000010];
int s[1000010];
int nodecnt, last, n;
int newnode(int l) {
int p = nodecnt++;
memset(t[p].nxt, 0, sizeof(t[p].nxt));
t[p].num = t[p].cnt = 0;
t[p].len = l;
return p;
}
void init() {
nodecnt = 0;
newnode(0);
newnode(-1);
last = n = 0;
s[n] = -1;
t[0].fail = 1;
t[0].anc = 1;
}
inline int getfail(int x) {
while (s[n - t[x].len - 1] != s[n]) x = t[x].fail;
return x;
}
void insert(int c) {
s[++n] = c;
int cur = getfail(last);
if (!t[cur].nxt[c]) {
int now = newnode(t[cur].len + 2);
t[now].fail = t[getfail(t[cur].fail)].nxt[c];
t[cur].nxt[c] = now;
t[now].num = t[t[now].fail].num + 1;
t[now].diff = t[now].len - t[t[now].fail].len;
t[now].anc = (t[now].diff == t[t[now].fail].diff) ? t[t[now].fail].anc
: t[now].fail;
}
last = t[cur].nxt[c];
++t[last].cnt;
}
void count() {
for (int i = nodecnt - 1; i > 0; i--) t[t[i].fail].cnt += t[i].cnt;
}
} p;
} // namespace PAM
int n;
char s[1000010], s2[1000010];
int f[1000010], g[1000010];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
PAM::p.init();
for (int i = 1; i <= n; i++) {
if (i > n + 1 - i) break;
s2[i * 2 - 1] = s[i];
if (i != n + 1 - i) s2[i * 2] = s[n + 1 - i];
}
memcpy(s, s2, sizeof(s2));
f[0] = 1;
for (int i = 1; i <= n; i++) {
PAM::p.insert(s[i] - 'a');
int pos = PAM::p.last;
for (int j = pos; j; j = PAM::p.t[j].anc) {
g[j] = f[i - PAM::p.t[PAM::p.t[j].anc].len - PAM::p.t[j].diff];
if (PAM::p.t[j].anc != PAM::p.t[j].fail)
g[j] = add(g[j], g[PAM::p.t[j].fail]);
if (!(i & 1)) f[i] = add(f[i], g[j]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1E+6 + 5;
const long long mod = 1E+9 + 7;
int n;
char s[maxn], t[maxn];
namespace PAM {
int ind, last, ch[maxn][26];
int fa[maxn], len[maxn];
int dif[maxn], sf[maxn];
inline void init() {
ind = fa[0] = 1;
len[0] = last = 0;
len[1] = fa[1] = -1;
}
inline int getfa(int u) {
while (s[n - len[u] - 1] != s[n]) u = fa[u];
return u;
}
inline int extend(int c) {
int p = getfa(last);
if (ch[p][c]) return last = ch[p][c];
int np = ++ind;
len[np] = len[p] + 2;
fa[np] = ch[getfa(fa[p])][c];
ch[p][c] = np, dif[np] = len[np] - len[fa[np]];
if (dif[np] == dif[fa[np]])
sf[np] = sf[fa[np]];
else
sf[np] = fa[np];
return last = np;
}
} // namespace PAM
long long f[maxn], g[maxn];
int main() {
scanf("%s", t + 1), PAM::init();
int Len = strlen(t + 1);
for (int i = 1; i <= Len; ++i)
s[i] = i & 1 ? t[i / 2 + 1] : t[Len - i / 2 + 1];
f[0] = 1;
for (n = 1; n <= Len; ++n) {
for (int p = PAM::extend(s[n] - 'a'); p > 1; p = PAM::sf[p]) {
g[p] = f[n - PAM::len[PAM::sf[p]] - PAM::dif[p]];
if (PAM::dif[p] == PAM::dif[PAM::fa[p]]) (g[p] += g[PAM::fa[p]]) %= mod;
(f[n] += g[p]) %= mod;
}
if (n & 1) f[n] = 0;
}
printf("%lld", f[Len]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 50;
const int mod = 1e9 + 7;
int n, f[N], tot = 1;
char s[N], t[N];
int last, son[N][27], diff[N], len[N], link[N], slink[N], series_ans[N];
inline int getfail(int pos, int l) {
while (s[l - len[pos] - 1] != s[l]) pos = link[pos];
return pos;
}
int main() {
len[1] = -1;
link[0] = 1;
diff[0] = 1;
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i++) {
if (i & 1)
s[i] = t[(i + 1) / 2];
else
s[i] = t[n - i / 2 + 1];
}
f[0] = 1;
for (int i = 1; i <= n; i++) {
int c = s[i] - 'a' + 1;
int now = getfail(last, i);
if (!son[now][c]) {
len[++tot] = len[now] + 2;
link[tot] = son[getfail(link[now], i)][c];
diff[tot] = len[tot] - len[link[tot]];
if (diff[tot] == diff[link[tot]])
slink[tot] = slink[link[tot]];
else
slink[tot] = link[tot];
son[now][c] = tot;
}
last = son[now][c];
for (int v = last; len[v]; v = slink[v]) {
series_ans[v] = f[i - (len[slink[v]] + diff[v])];
if (diff[v] == diff[link[v]])
series_ans[v] = (series_ans[v] + series_ans[link[v]]) % mod;
f[i] = (f[i] + series_ans[v]) % mod;
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
template <typename T>
void chkmax(T &a, T b) {
a = max(a, b);
}
template <typename T>
void chkmin(T &a, T b) {
a = min(a, b);
}
template <typename T>
void ADD(T &a, T b) {
a = a + b;
if (a >= MOD) a -= MOD;
}
const int N = 1100000;
int n;
char P[N], S[N];
int par[N], anc[N], len[N], nxt[N][30], F[N], G[N];
int tot, cnt, las;
void append(int c) {
c -= 'a' - 1;
S[++tot] = c;
int p = las;
while (p && S[tot] != S[tot - len[p] - 1]) p = par[p];
if (!p) p = 1;
if (nxt[p][c])
las = nxt[p][c];
else {
int np = las = nxt[p][c] = ++cnt;
len[np] = len[p] + 2;
int q = par[p];
while (q && S[tot] != S[tot - len[q] - 1]) q = par[q];
if (!q)
par[np] = 2;
else
par[np] = nxt[q][c];
int nq = par[np];
if (len[np] - len[nq] == len[nq] - len[par[nq]] && nq != 2)
anc[np] = anc[nq];
else
anc[np] = np;
}
for (int np = nxt[p][c]; np != 2; np = par[anc[np]]) {
G[np] = ((np != anc[np] ? G[par[np]] : 0) + F[tot - len[anc[np]]]) % MOD;
ADD(F[tot], G[np]);
}
}
int main() {
ios ::sync_with_stdio(0);
cin >> (P + 1);
n = strlen(P + 1);
cnt = 2;
las = 1;
len[1] = -1;
par[2] = 1;
anc[1] = 1;
anc[2] = 2;
F[0] = 1;
for (int i = 1, j = n; i < j; ++i, --j)
append(P[i]), F[tot] = 0, append(P[j]);
cout << F[tot] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
const int N = 1010000;
int fail[N];
int go[N][26], len[N], diff[N], anc[N], lst;
int n;
char str[N];
int p;
int s[N];
int f[N], g[N];
void addChar(int c, int ww) {
int x = lst;
while (s[ww] != s[ww - len[x] - 1]) {
x = fail[x];
}
if (!go[x][c]) {
len[p] = len[x] + 2;
int k = fail[x];
while (s[ww] != s[ww - len[k] - 1]) k = fail[k];
fail[p] = go[k][c];
go[x][c] = p;
diff[p] = len[p] - len[fail[p]];
if (diff[p] == diff[fail[p]])
anc[p] = anc[fail[p]];
else
anc[p] = fail[p];
p++;
}
lst = go[x][c];
}
void init() {
p = 2;
len[0] = 0;
len[1] = -1;
fail[0] = 1;
fail[1] = 0;
f[0] = 1;
lst = 1;
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
if (n & 1) {
printf("0\n");
return 0;
}
for (int i = (int)1; i <= (int)n / 2; i++) {
s[i * 2 - 1] = str[i] - 'a';
s[i * 2] = str[n + 1 - i] - 'a';
}
s[0] = -1;
init();
for (int i = (int)1; i <= (int)n; i++) {
addChar(s[i], i);
for (int x = lst; x; x = anc[x]) {
g[x] = f[i - (len[anc[x]] + diff[x])];
if (anc[x] != fail[x]) {
g[x] = (g[x] + g[fail[x]]) % P;
}
if (i % 2 == 0) f[i] = (f[i] + g[x]) % P;
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, P = 1e9 + 7;
int n, cnt, pos[N], len[N], dis[N], fa[N], top[N], ch[N][26];
char t[N], s[N];
int f[N], ans[N];
int jump(int x, int p) {
while (s[p - len[x] - 1] != s[p]) x = fa[x];
return x;
}
int Insert(int x, int p) {
x = jump(x, p);
int c = s[p] - 'a';
if (!ch[x][c]) {
++cnt;
len[cnt] = len[x] + 2;
int y = jump(fa[x], p);
fa[cnt] = ch[y][c];
y = cnt;
dis[y] = len[y] - len[fa[y]];
if (dis[y] != dis[fa[y]])
top[y] = y;
else
top[y] = top[fa[y]];
ch[x][c] = y;
}
return ch[x][c];
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) return puts("0") & 0;
for (int i = 1; i <= n; i += 2) s[i] = t[i / 2 + 1];
for (int i = 2; i <= n; i += 2) s[i] = t[n - i / 2 + 1];
len[1] = -1;
fa[0] = top[1] = cnt = 1;
for (int i = 1; i <= n; i++) pos[i] = Insert(pos[i - 1], i);
ans[0] = 1;
for (int i = 1; i <= n; i++) {
for (int x = pos[i]; x; x = fa[top[x]]) {
f[x] = ans[i - len[top[x]]];
if (x != top[x]) (f[x] += f[fa[x]]) %= P;
if (!(i & 1)) (ans[i] += f[x]) %= P;
}
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma G++ optimize("O2")
using namespace std;
const int N = 1111111;
const int M = 666666;
const int MOD = 1e9 + 7;
const int intINF = 1e9;
const long long llINF = 2e18;
const double pi = acos(-1.0);
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
const double eps = 1e-10;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
unsigned long long readull() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
char ch[N];
int m;
void predo() {}
void init() {
scanf("%s", ch + 1);
m = strlen(ch + 1);
}
int q, p, id, num[N], F[N], f[N], _f[N], len[N], sk[N], df[N], t[N][26];
int s[N], n;
struct pam {
void add(int x, int n) {
while (s[n - len[p] - 1] != s[n]) p = F[p];
if (!t[p][x]) {
int q = ++id, k = F[p];
len[q] = len[p] + 2;
while (s[n - len[k] - 1] != s[n]) k = F[k];
F[q] = t[k][x];
t[p][x] = q;
df[q] = len[q] - len[F[q]];
sk[q] = (df[q] == df[F[q]] ? sk[F[q]] : F[q]);
}
p = t[p][x];
}
} pam;
void solve() {
int i = 1, j = m;
n = 0;
while (n < m) {
s[++n] = ch[i] - 'a';
i++;
s[++n] = ch[j] - 'a';
j--;
}
s[0] = s[n + 1] = 114514;
id = F[0] = 1;
len[1] = -1;
_f[0] = 1;
f[0] = 1;
for (int i = (int)1; i <= (int)n; i++) {
pam.add(s[i], i);
for (int x = p; x; x = sk[x]) {
_f[x] = f[i - len[sk[x]] - df[x]];
if (df[F[x]] == df[x]) _f[x] = (_f[x] + _f[F[x]]) % MOD;
f[i] = (f[i] + _f[x]) % MOD;
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
}
int main() {
predo();
int cas = 1;
while (cas--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const int N = 1000010;
const int P = 1000000007;
char s[N];
int n, m, c[N], sz, ch[N][26], fail[N], len[N], diff[N], slink[N], g[N], f[N],
last;
inline void Init() {
c[0] = 233;
(len[sz] = (0), sz++);
(len[sz] = (-1), sz++);
fail[0] = 1;
fail[1] = 1;
last = 0;
}
inline int find(int x) {
while (c[m - len[x] - 1] != c[m]) x = fail[x];
return x;
}
inline void insert(int x) {
c[++m] = x;
int idx = find(last);
if (!ch[idx][x]) {
int nw = (len[sz] = (len[idx] + 2), sz++);
fail[nw] = ch[find(fail[idx])][x];
ch[idx][x] = nw;
diff[nw] = len[nw] - len[fail[nw]];
slink[nw] = diff[nw] == diff[fail[nw]] ? slink[fail[nw]] : fail[nw];
}
last = ch[idx][x];
}
int main() {
Init();
scanf("%s", s + 1);
n = strlen(s + 1);
int l = n >> 1, r = l + 1, cur = 0;
register int x, ans;
f[0] = 1;
while (r - l <= n) {
++cur;
insert(cur & 1 ? s[l--] - 'a' : s[r++] - 'a');
ans = 0;
for (x = last; x; x = slink[x]) {
g[x] = f[cur - (len[slink[x]] + diff[x])];
if (diff[x] == diff[fail[x]]) g[x] = (g[x] + g[fail[x]]) % P;
ans = (ans + g[x]) % P;
}
if (!(cur & 1)) f[cur] = ans;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int N = 1e6 + 5;
const int CS = 26;
const int MOD = 1e9 + 7;
namespace PAM {
int next[N][CS], length[N], fail[N], link[N], diff[N], jump[N], last = 0;
int nodeCnt = 0;
char str[N];
int len = 0;
inline int newNode(int len) {
length[nodeCnt] = len;
return nodeCnt++;
}
inline void init() {
newNode(0);
newNode(-1);
fail[0] = 1;
str[0] = '$';
}
inline int getFail(int x) {
while (str[len - 1 - length[x]] != str[len]) {
x = fail[x];
}
return x;
}
inline void extend() {
++len;
int cur = getFail(last);
int d = str[len] - 'a';
if (!next[cur][d]) {
int u = newNode(length[cur] + 2);
fail[u] = next[getFail(fail[cur])][d];
next[cur][d] = u;
diff[u] = length[u] - length[fail[u]];
if (diff[u] == diff[fail[u]]) {
jump[u] = jump[fail[u]];
} else {
jump[u] = fail[u];
}
}
last = next[cur][d];
}
} // namespace PAM
inline void inc(int &x, const int &y) {
x += y;
if (x >= MOD) {
x -= MOD;
} else if (x < 0) {
x += MOD;
}
}
int n;
char str[N];
int f[N], ans[N];
int main() {
PAM::init();
scanf("%s", str);
n = strlen(str);
if (n % 2 == 1) {
puts("0");
return 0;
}
for (int i = 0; i < n; i += 2) {
PAM::str[i + 1] = str[i / 2];
}
reverse(str, str + n);
for (int i = 0; i < n; i += 2) {
PAM::str[i + 2] = str[i / 2];
}
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
PAM::extend();
for (int u = PAM::last; u != 0; u = PAM::jump[u]) {
f[u] = ans[i - PAM::length[PAM::jump[u]] - PAM::diff[u]];
if (PAM::jump[u] != PAM::fail[u]) {
inc(f[u], f[PAM::fail[u]]);
}
if (i % 2 == 0) {
inc(ans[i], f[u]);
}
}
}
printf("%d\n", ans[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
int n, l, t, las, cnt, a[1000005], fail[1000005], len[1000005], h[1000005],
g[1000005], f[1000005], ans[1000005], tr[1000005][28];
char s[1000005];
inline int get_fail(int x, int y) {
while (a[x] != a[x - len[y] - 1]) y = fail[y];
return y;
}
int main() {
scanf("%s", s), n = strlen(s), l = n >> 1, fail[0] = ans[0] = cnt = 1,
len[1] = a[0] = -1;
if (n & 1) {
puts("0");
return 0;
}
for (register int i = 0; i < l; ++i) a[(i << 1) | 1] = s[i] - 97;
for (register int i = l; i < n; ++i) a[(n - i) << 1] = s[i] - 97;
for (register int i = 1; i <= n; ++i) {
t = get_fail(i, las);
if (!tr[t][a[i]]) {
fail[++cnt] = tr[get_fail(i, fail[t])][a[i]], len[cnt] = len[t] + 2,
h[cnt] = len[cnt] - len[fail[cnt]], tr[t][a[i]] = cnt;
if (h[cnt] == h[fail[cnt]])
g[cnt] = g[fail[cnt]];
else
g[cnt] = fail[cnt];
}
las = tr[t][a[i]];
for (register int j = las; j; j = g[j]) {
f[j] = ans[i - len[g[j]] - h[j]];
if (g[j] != fail[j]) f[j] = (f[j] + f[fail[j]]) % Mod;
if (!(i & 1)) ans[i] = (ans[i] + f[j]) % Mod;
}
}
printf("%d", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007, N = 1000005;
int n, m, ch[N][26], len[N], tot, k, i, j, las, fail[N];
int d[N], g[N];
char cc[N], c[N];
long long dp[N], f[N];
int main() {
scanf("%s", cc + 1);
n = strlen(cc + 1);
len[1] = -1;
fail[0] = 1;
for (i = 1; i <= n / 2; ++i) {
c[++k] = cc[i];
c[++k] = cc[n - i + 1];
}
tot = 1;
dp[0] = 1;
for (i = 1; i <= n; ++i) {
int p = las;
while (c[i - len[p] - 1] != c[i]) p = fail[p];
if (ch[p][c[i] - 'a'] == 0) {
int v = p;
p = fail[p];
while (c[i - len[p] - 1] != c[i]) p = fail[p];
fail[++tot] = ch[p][c[i] - 'a'];
ch[v][c[i] - 'a'] = tot;
len[tot] = len[v] + 2;
las = tot;
d[tot] = len[tot] - len[fail[tot]];
if (d[tot] == d[fail[tot]])
g[tot] = g[fail[tot]];
else
g[tot] = fail[tot];
} else
las = ch[p][c[i] - 'a'];
p = las;
while (p) {
f[p] = dp[i - d[p] - len[g[p]]];
if (g[p] != fail[p]) f[p] = (f[p] + f[fail[p]]) % M;
if ((i & 1) ^ 1) dp[i] = (dp[i] + f[p]) % M;
p = g[p];
}
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& num) {
num = 0;
T f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') num = num * 10 + ch - '0', ch = getchar();
num *= f;
}
inline int getgcd(int x, int y) {
if (!x) return y;
return getgcd(y % x, x);
}
inline int power(int x, int k, int p) {
int res = 1;
for (; k; k >>= 1, x = (long long)x * x % p)
if (k & 1) res = (long long)res * x % p;
return res;
}
const double pi = acos(-1);
inline void judge() { freopen("input.txt", "r", stdin); }
const int maxn = 1e6 + 5, mod = 1e9 + 7;
int cnt, lst, n;
char str[maxn], a[maxn];
int f[maxn], g[maxn], len[maxn], nxt[maxn][26], pre[maxn], anc[maxn],
diff[maxn];
void extend(int n, int x) {
while (a[n] != a[n - len[lst] - 1]) lst = pre[lst];
if (nxt[lst][x])
lst = nxt[lst][x];
else {
int now = pre[lst];
while (a[n] != a[n - len[now] - 1]) now = pre[now];
pre[++cnt] = nxt[now][x];
nxt[lst][x] = cnt;
len[cnt] = len[lst] + 2;
diff[cnt] = len[cnt] - len[pre[cnt]];
if (diff[cnt] == diff[pre[cnt]])
anc[cnt] = anc[pre[cnt]];
else
anc[cnt] = pre[cnt];
lst = cnt;
}
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int(i) = (1); (i) <= (n / 2); (i)++)
a[2 * i - 1] = str[i], a[2 * i] = str[n - i + 1];
len[1] = -1;
pre[1] = pre[0] = 1;
cnt = 1;
f[0] = 1;
for (int(i) = (1); (i) <= (n); (i)++) {
extend(i, a[i] - 'a');
for (int tmp = lst; tmp; tmp = anc[tmp]) {
g[tmp] = f[i - len[anc[tmp]] - diff[tmp]];
if (diff[tmp] == diff[pre[tmp]]) g[tmp] = (g[tmp] + g[pre[tmp]]) % mod;
f[i] = (f[i] + g[tmp]) % mod;
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, t = 1;
register char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return x * t;
}
char ch[1000100], s[1000100];
int n, anc[1000100], diff[1000100];
int ans[1000100], f[1000100];
struct Palindromic_Tree {
struct Node {
int son[26];
int ff, len;
} t[1000100];
int last, tot;
void init() {
t[tot = 1].len = -1;
t[0].ff = t[1].ff = 1;
anc[0] = 1;
}
void extend(int c, int n, char *s) {
int p = last;
while (s[n - t[p].len - 1] != s[n]) p = t[p].ff;
if (!t[p].son[c]) {
int v = ++tot, k = t[p].ff;
t[v].len = t[p].len + 2;
while (s[n - t[k].len - 1] != s[n]) k = t[k].ff;
t[v].ff = t[k].son[c];
t[p].son[c] = v;
diff[v] = t[v].len - t[t[v].ff].len;
anc[v] = (diff[v] == diff[t[v].ff]) ? anc[t[v].ff] : t[v].ff;
}
last = t[p].son[c];
}
} PT;
int main() {
PT.init();
scanf("%s", ch + 1);
n = strlen(ch + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i += 2) s[i] = ch[(i + 1) / 2];
reverse(&ch[1], &ch[n + 1]);
for (int i = 2; i <= n; i += 2) s[i] = ch[(i + 1) / 2];
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
PT.extend(s[i] - 97, i, s);
for (int k = PT.last; k; k = anc[k]) {
f[k] = ans[i - PT.t[anc[k]].len - diff[k]];
if (anc[k] != PT.t[k].ff) f[k] = (f[k] + f[PT.t[k].ff]) % 1000000007;
if (!(i & 1)) ans[i] = (ans[i] + f[k]) % 1000000007;
}
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int readint() {
int a = 0;
char c = getchar(), f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -f;
for (; '0' <= c && c <= '9'; c = getchar())
a = (a << 3) + (a << 1) + (c ^ 48);
return a * f;
}
const int MaxN = 1000005;
const int CharSiz = 26;
const int Mod = 1e9 + 7;
int f[MaxN], g[MaxN];
char s[MaxN] = {-1};
namespace PAM {
int ch[MaxN][CharSiz];
int fail[MaxN] = {1, 1};
int len[MaxN] = {0, -1};
int lst = 1, cntNode = 1;
int top[MaxN] = {0, 1};
void add(int n) {
int p = lst;
while (s[n - len[p] - 1] != s[n]) p = fail[p];
int now = ch[p][s[n] - 'a'];
if (now == 0) {
now = ++cntNode;
len[now] = len[p] + 2;
fail[now] = fail[p];
while (s[n - len[fail[now]] - 1] != s[n]) fail[now] = fail[fail[now]];
fail[now] = ch[fail[now]][s[n] - 'a'];
ch[p][s[n] - 'a'] = now;
if ((len[fail[now]] << 1) == len[now] + len[fail[fail[now]]])
top[now] = top[fail[now]];
else
top[now] = fail[now];
}
lst = now;
}
int maintain(int n) {
int res = 0;
for (int p = lst; p && p != 1; p = top[p]) {
int dif = len[p] - len[fail[p]];
g[p] = f[n - len[top[p]] - dif];
if (top[p] != fail[p]) g[p] = (g[p] + g[fail[p]]) % Mod;
res = (res + g[p]) % Mod;
}
return (n & 1) ? 0 : res;
}
} // namespace PAM
char sy[MaxN];
int main() {
scanf("%s", sy);
int n = strlen(sy);
for (int i = 0; (i << 1) < n; ++i) s[2 * i + 1] = sy[i];
for (int i = n - 1; 2 * (n - i) <= n; --i) s[2 * (n - i)] = sy[i];
f[0] = 1;
for (int i = 1; i <= n; ++i) {
PAM::add(i);
f[i] = PAM::maintain(i);
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 1000007;
const int MOD = 1e9 + 7;
struct sT {
sT() : s(0), d(0), k(0) {}
sT(int _s, int _d, int _k) : s(_s), d(_d), k(_k) {}
int s, d, k;
};
int n;
char os[MAXN], s[MAXN];
int dp[MAXN], gpl[MAXN];
vector<sT> g, g1;
void init();
void input();
void work();
int add(int x, int y) {
x += y;
if (x >= MOD) x -= MOD;
return x;
}
void addv(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() { scanf("%s", os); }
void work() {
n = strlen(os);
int ttk = 0;
for (int i = 0; i < n >> 1; ++i) s[++ttk] = os[i], s[++ttk] = os[n - i - 1];
dp[0] = 1;
int pre, size, cv;
for (int i = 1; i <= n; ++i) {
g1.clear();
pre = -i;
for (auto &x : g) {
if (x.s > 1 && s[x.s - 1] == s[i]) {
if ((x.s - 1 - pre) ^ x.d) {
g1.push_back(sT(x.s - 1, x.s - 1 - pre, 1));
if (x.k > 1) g1.push_back(sT(x.s - 1 + x.d, x.d, x.k - 1));
} else
g1.push_back(sT(x.s - 1, x.d, x.k));
pre = g1.back().s + g1.back().d * (g1.back().k - 1);
}
}
if (i > 1 && s[i] == s[i - 1]) g1.push_back(sT(i - 1, i - 1 - pre, 1));
g.clear();
if (!g1.empty()) {
g.push_back(g1.front());
size = g1.size();
for (int i = 1; i < size; ++i) {
if (g1[i].d == g.back().d)
g.back().k += g1[i].k;
else
g.push_back(g1[i]);
}
}
dp[i] = 0;
for (auto x : g) {
cv = dp[x.s + x.d * (x.k - 1) - 1];
if (x.k > 1) addv(cv, gpl[x.s - x.d]);
if (x.s - x.d >= 0) gpl[x.s - x.d] = cv;
addv(dp[i], cv);
}
}
printf("%d\n", dp[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
namespace eertree {
int nxt[MAXN][26];
int par[MAXN], len[MAXN], slink[MAXN], ptr[MAXN], diff[MAXN], series[MAXN], piv;
void clear(int n = MAXN) {
memset(par, 0, sizeof(int) * n);
memset(len, 0, sizeof(int) * n);
memset(slink, 0, sizeof(int) * n);
memset(nxt, 0, sizeof(int) * 26 * n);
piv = 0;
}
void init(int n, char *a) {
par[0] = 0;
par[1] = 1;
a[0] = -1;
len[0] = -1;
piv = 1;
int cur = 1;
for (int i = 1; i <= n; i++) {
while (a[i] != a[i - len[cur] - 1]) cur = slink[cur];
if (!nxt[cur][a[i]]) {
nxt[cur][a[i]] = ++piv;
par[piv] = cur;
len[piv] = len[cur] + 2;
int lnk = slink[cur];
while (a[i] != a[i - len[lnk] - 1]) {
lnk = slink[lnk];
}
if (nxt[lnk][a[i]]) lnk = nxt[lnk][a[i]];
if (len[piv] == 1 || lnk == 0) lnk = 1;
slink[piv] = lnk;
diff[piv] = len[piv] - len[lnk];
if (diff[piv] == diff[lnk])
series[piv] = series[lnk];
else
series[piv] = piv;
}
cur = nxt[cur][a[i]];
ptr[i] = cur;
}
}
int query(int s, int e) {
int pos = ptr[e];
while (len[pos] >= e - s + 1) {
if (len[pos] % diff[pos] == (e - s + 1) % diff[pos] &&
len[series[pos]] <= e - s + 1)
return true;
pos = series[pos];
pos = slink[pos];
}
return false;
}
int add(int x, int y) { return (x + y) % 1000000007; }
vector<pair<int, int> > minimum_partition(int n) {
vector<pair<int, int> > dp(n + 1);
vector<pair<int, int> > series_ans(n + 10);
dp[0] = pair<int, int>(0, 1);
for (int i = 1; i <= n; i++) {
dp[i] = pair<int, int>(0, 0);
for (int j = ptr[i]; len[j] > 0;) {
int slv = slink[series[j]];
series_ans[j] = dp[i - (len[slv] + diff[j])];
assert(len[slv] + diff[j] != 0);
if (diff[j] == diff[slink[j]]) {
series_ans[j].first =
add(series_ans[j].first, series_ans[slink[j]].first);
series_ans[j].second =
add(series_ans[j].second, series_ans[slink[j]].second);
}
auto val = series_ans[j];
dp[i].first = add(dp[i].first, val.second);
dp[i].second = add(dp[i].second, val.first);
j = slv;
}
if (i & 1) dp[i] = pair<int, int>(0, 0);
}
return dp;
}
} // namespace eertree
int n;
char str[MAXN];
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
if (n & 1) {
puts("0");
return 0;
}
string c;
for (int i = 1; i <= n / 2; i++)
c.push_back(str[i]), c.push_back(str[n + 1 - i]);
for (int i = 1; i <= n; i++) str[i] = c[i - 1] - 'a';
eertree::init(n, str);
auto x = eertree::minimum_partition(n)[n];
cout << (x.first + x.second) % 1000000007 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T = int>
T read() {
T x = 0;
char ch = 0;
bool f = false;
while (!isdigit(ch)) f |= (ch = getchar()) == '-';
for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ '0');
return f ? -x : x;
}
const int MOD = 1e9 + 7;
int add(int a, int b) { return a + b < MOD ? a + b : a + b - MOD; }
void dadd(int &a, int b) { a = add(a, b); }
const int N = 1.1e6;
const int C = 26;
namespace PAM {
struct Node {
int fa, ch[C];
int len;
int d, sf;
int sans;
} o[N];
int ns = 0;
int ert = ++ns;
int ort = ++ns;
int last;
int ans[N];
void solve(const char *s) {
o[ert].fa = ort;
o[ort].len = -1;
last = ort;
ans[0] = 1;
int i;
for (i = 0; s[i]; i++) {
int c = s[i] - 'a';
int l = last;
while (l && (o[l].len == i || s[i - o[l].len - 1] != s[i])) l = o[l].fa;
if (o[l].ch[c])
last = o[l].ch[c];
else {
o[l].ch[c] = ++ns;
o[ns].len = o[l].len + 2;
l = o[l].fa;
while (l && (o[l].len == i || s[i - o[l].len - 1] != s[i])) l = o[l].fa;
int f = o[l].ch[c];
if (!f) f = ert;
o[ns].fa = f;
last = ns;
o[ns].d = o[ns].len - o[f].len;
o[ns].sf = o[ns].d == o[f].d ? o[f].sf : f;
}
int &a = ans[i + 1];
a = 0;
for (int l = last; o[l].len > 0; l = o[l].sf) {
o[l].sans = ans[i + 1 - (o[o[l].sf].len + o[l].d)];
if (o[l].sf != o[l].fa) {
dadd(o[l].sans, o[o[l].fa].sans);
}
if (i % 2 == 1) dadd(a, o[l].sans);
}
}
printf("%d\n", ans[i]);
}
} // namespace PAM
char in[N];
char s[N];
int main() {
scanf("%s", in);
int n = strlen(in);
for (int i = 0; i < (int)(n >> 1); i++) {
s[i * 2] = in[i];
s[i * 2 + 1] = in[n - 1 - i];
}
PAM::solve(s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 7;
int MOD = 1e9 + 7;
namespace PAM {
int scnt, S[MAXN];
int pcnt, last, len[MAXN], fail[MAXN], ch[MAXN][26];
int diff[MAXN], slink[MAXN];
int newnode(int _len) {
len[pcnt] = _len;
diff[pcnt] = slink[pcnt] = 0;
for (int i = 0; i < 26; i++) ch[pcnt][i] = 0;
return pcnt++;
}
inline void init() {
S[scnt = 0] = -1;
pcnt = 0;
newnode(0);
newnode(-1);
fail[0] = 1;
last = 0;
}
int getfail(int x) {
while (S[scnt - len[x] - 1] != S[scnt]) x = fail[x];
return x;
}
void extend(int c) {
S[++scnt] = c;
int cur = getfail(last);
if (!ch[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = ch[getfail(fail[cur])][c];
ch[cur][c] = now;
diff[now] = len[now] - len[fail[now]];
slink[now] = (diff[now] == diff[fail[now]]) ? slink[fail[now]] : fail[now];
}
last = ch[cur][c];
}
}; // namespace PAM
using namespace PAM;
int g[MAXN], f[MAXN];
void sol(int i, int cur) {
for (; cur; cur = slink[cur]) {
g[cur] = f[i - len[slink[cur]] - diff[cur]];
if (slink[cur] != fail[cur]) g[cur] = (g[cur] + g[fail[cur]]) % MOD;
if (!(i & 1)) f[i] = (f[i] + g[cur]) % MOD;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int sn = s.size();
init();
f[0] = 1;
for (int i = 0; i < sn; i += 2) {
extend(s[i >> 1] - 'a');
sol(i + 1, last);
extend(s[sn - 1 - (i >> 1)] - 'a');
sol(i + 2, last);
}
cout << f[sn] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int MAXN = 1e6 + 5;
template <typename _T>
void read(_T &x) {
x = 0;
char s = getchar();
int f = 1;
while (s < '0' || '9' < s) {
f = 1;
if (s == '-') f = -1;
s = getchar();
}
while ('0' <= s && s <= '9') {
x = (x << 3) + (x << 1) + s - '0', s = getchar();
}
x *= f;
}
template <typename _T>
void write(_T x) {
if (x < 0) {
putchar('-'), x = -x;
}
if (9 < x) {
write(x / 10);
}
putchar(x % 10 + '0');
}
int g[MAXN], f[MAXN], slink[MAXN], dif[MAXN];
int ch[MAXN][26], fa[MAXN], len[MAXN];
char Snat[MAXN], S[MAXN];
int N, lst, siz;
int main() {
scanf("%s", Snat + 1);
N = strlen(Snat + 1);
for (int i = 1; i <= N >> 1; i++) S[(i << 1) - 1] = Snat[i];
for (int i = (N >> 1) + 1; i <= N; i++) S[(N - i + 1) << 1] = Snat[i];
int x, p, cur;
f[0] = 1;
fa[0] = ++siz, len[1] = -1;
for (int i = 1; i <= N; i++) {
x = S[i] - 'a';
while (S[i] ^ S[i - len[lst] - 1]) lst = fa[lst];
if (!ch[lst][x]) {
cur = ++siz, p = fa[lst];
len[cur] = len[lst] + 2;
while (S[i] ^ S[i - len[p] - 1]) p = fa[p];
fa[cur] = ch[p][x], ch[lst][x] = cur;
dif[cur] = len[cur] - len[fa[cur]],
slink[cur] = (dif[cur] == dif[fa[cur]]) ? slink[fa[cur]] : fa[cur];
}
lst = ch[lst][x];
for (p = lst; p; p = slink[p]) {
g[p] = f[i - len[slink[p]] - dif[p]];
if (slink[p] ^ fa[p]) g[p] = (g[p] + g[fa[p]]) % mod;
if (!(i & 1)) f[i] = (f[i] + g[p]) % mod;
}
}
write(f[N]), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char T[1000010], s[1000010];
int n, tot, fin, ch[1000010][26], fail[1000010], len[1000010], dif[1000010],
top[1000010], f[1000010], g[1000010];
int getf(int u, int i) {
while (s[i] ^ s[i - len[u] - 1]) u = fail[u];
return u;
}
int main() {
scanf("%s", T + 1), n = strlen(T + 1);
if (n & 1) puts("0"), exit(0);
for (int i = 1; i <= n / 2; i++) s[i * 2 - 1] = T[i], s[i * 2] = T[n - i + 1];
len[0] = 0, len[1] = -1, fail[0] = 1, fail[1] = 0, tot = 1;
f[0] = 1;
for (int i = 1; i <= n; i++) {
int c = s[i] - 97, p = getf(fin, i);
if (!ch[p][c]) {
len[++tot] = len[p] + 2;
fail[tot] = ch[getf(fail[p], i)][c];
int F = fail[tot];
dif[tot] = len[tot] - len[F];
top[tot] = dif[tot] == dif[F] ? top[F] : F;
ch[p][c] = tot;
}
fin = ch[p][c];
int t = fin;
while (t) {
g[t] = f[i - len[top[t]] - dif[t]];
if (top[t] ^ fail[t]) (g[t] += g[fail[t]]) %= 1000000007;
if (i % 2 == 0) (f[i] += g[t]) %= 1000000007;
t = top[t];
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, od, ev, c, ls, nx[1000010][26], sm[1000010], f[1000010], len[1000010],
fail[1000010], hf[1000010], d[1000010];
char S[1000010], s[1000010];
int nwc(int L) {
len[++c] = L + 2;
return c;
}
int find(int x, int w) {
for (; x && s[w] != s[w - len[x] - 1]; x = fail[x])
;
return x;
}
void ins(int w, int c) {
int p = find(ls, w);
if (nx[p][c]) {
ls = nx[p][c];
return;
}
int nw = nx[p][c] = nwc(len[p]);
int x = find(fail[p], w);
if (!x)
fail[nw] = ev;
else
fail[nw] = nx[x][c];
d[nw] = len[nw] - len[fail[nw]];
hf[nw] = d[nw] == d[fail[nw]] ? hf[fail[nw]] : fail[nw];
ls = nw;
}
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
ls = od = nwc(-3);
ev = nwc(-2);
fail[ev] = od;
for (int i = 1; i <= n; ++i) s[i] = S[i % 2 ? i + 1 >> 1 : n + 1 - (i >> 1)];
f[0] = 1;
for (int i = 1; i <= n; ++i) {
ins(i, s[i] - 97);
for (int u = ls; u > ev; u = hf[u]) {
sm[u] = f[i - len[hf[u]] - d[u]];
if (hf[u] ^ fail[u]) sm[u] = (sm[u] + sm[fail[u]]) % 1000000007;
if (1 + i & 1) f[i] = (f[i] + sm[u]) % 1000000007;
}
}
printf("%d", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
T data = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
data = (data << 3) + (data << 1) + ch - '0';
ch = getchar();
}
x = f * data;
}
template <typename T, typename... Args>
inline void read(T &t, Args &...args) {
read(t);
read(args...);
}
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int maxn = 1e6 + 9;
const int mod = 1e9 + 7;
char st[maxn], t[maxn];
int anc[maxn], dp[maxn], diff[maxn], val[maxn];
namespace PAM {
int sz, tot, last;
int cnt[maxn], ch[maxn][26], len[maxn], fail[maxn];
char s[maxn];
int newnode(int ln) {
sz++;
memset(ch[sz], 0, sizeof(ch[sz]));
len[sz] = ln;
fail[sz] = cnt[sz] = 0;
return sz;
}
void clear() {
sz = -1;
last = tot = 0;
s[tot] = '$';
newnode(0);
newnode(-1);
fail[0] = 1;
}
int getfail(int x) {
while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
return x;
}
void insert(char c) {
s[++tot] = c;
int now = getfail(last);
if (!ch[now][c - 'a']) {
int x = newnode(len[now] + 2);
fail[x] = ch[getfail(fail[now])][c - 'a'];
ch[now][c - 'a'] = x;
diff[x] = len[x] - len[fail[x]];
anc[x] = (diff[x] == diff[fail[x]] ? anc[fail[x]] : fail[x]);
}
last = ch[now][c - 'a'];
cnt[last]++;
}
}; // namespace PAM
using namespace PAM;
signed main() {
scanf("%s", st + 1);
int n = strlen(st + 1), l = 1, r = n;
for (int i = 1; i <= n; ++i) {
if (i & 1)
t[i] = st[l++];
else
t[i] = st[r--];
}
clear();
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
insert(t[i]);
for (int j = last; j; j = anc[j]) {
if (anc[j] != fail[j])
val[j] = val[fail[j]];
else
val[j] = 0;
int k = i - len[anc[j]] - diff[j];
val[j] = (val[j] + dp[k]) % mod;
if (i % 2 == 0) dp[i] = (dp[i] + val[j]) % mod;
}
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pct(int x) { return __builtin_popcount(x); }
int pct(long long x) { return __builtin_popcountll(x); }
int bt(int x) { return 31 - __builtin_clz(x); }
int bt(long long x) { return 63 - __builtin_clzll(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
long long cdiv(long long a, long long b) {
return a / b + !(a < 0 || a % b == 0);
}
int nxt_C(int x) {
int c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
long long nxt_C(long long x) {
long long c = x & -x, r = x + c;
return (((r ^ x) >> 2) / c) | r;
}
vector<int> get_bits(int mask) {
vector<int> bb;
while (mask) {
int b = bt(mask);
bb.push_back(b);
mask ^= (1 << b);
}
reverse(bb.begin(), bb.end());
return bb;
}
int get_mask(vector<int> v) {
int mask = 0;
for (int x : v) {
mask ^= (1 << x);
}
return mask;
}
template <typename T>
void uniq(vector<T> &v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand(long long l, long long r) {
uniform_int_distribution<long long> uid(l, r);
return uid(rng);
}
void sc() {}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &...T) {
cin >> H;
sc(T...);
}
const int mod = 1e9 + 7;
int pwr(int a, long long b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
const int maxn = 1e6 + 5, sigma = 26;
int len[maxn], link[maxn], to[maxn][sigma];
int slink[maxn], diff[maxn], series_ans[maxn];
int sz, last, n;
char s[maxn];
void init() {
s[n++] = -1;
link[0] = 1;
len[1] = -1;
sz = 2;
}
int get_link(int v) {
while (s[n - len[v] - 2] != s[n - 1]) v = link[v];
return v;
}
void add_letter(char c) {
s[n++] = c -= 'a';
last = get_link(last);
if (!to[last][c]) {
len[sz] = len[last] + 2;
link[sz] = to[get_link(link[last])][c];
diff[sz] = len[sz] - len[link[sz]];
if (diff[sz] == diff[link[sz]])
slink[sz] = slink[link[sz]];
else
slink[sz] = link[sz];
to[last][c] = sz++;
}
last = to[last][c];
}
const int N = 1e6 + 5;
int ans[N];
void solve() {
init();
string t;
cin >> t;
string s = "";
for (int i = 0; i <= (int)t.size() / 2 - 1; i++) {
s += t[i];
s += t[(int)t.size() - 1 - i];
}
int n = s.size();
ans[0] = 1;
for (int i = 1; i <= n; i++) {
add_letter(s[i - 1]);
for (int v = last; len[v] > 0; v = slink[v]) {
series_ans[v] = ans[i - (len[slink[v]] + diff[v])];
if (diff[v] == diff[link[v]]) {
series_ans[v] += series_ans[link[v]];
series_ans[v] %= mod;
}
ans[i] += series_ans[v];
ans[i] %= mod;
}
if (i & 1) ans[i] = 0;
}
cout << ans[n];
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
const int mod = inf + 7;
inline int _sum(int a, int b) { return a + b < mod ? a + b : a + b - mod; }
inline int _mul(int a, int b) { return (1ll * a * b) % mod; }
inline int _sub(int a, int b) { return a >= b ? a - b : a - b + mod; }
inline void _inc(int& x, int y) {
if ((x += y) >= mod) {
x -= mod;
}
}
inline void _dec(int& x, int y) {
if ((x -= y) < 0) {
x += mod;
}
}
inline int _binpow(int x, int pw) {
int res = 1;
int tmp = x;
while (pw > 0) {
if (pw & 1) {
res = _mul(res, tmp);
}
tmp = _mul(tmp, tmp);
pw >>= 1;
}
return res;
}
inline int _div(int a, int b) { return _mul(a, _binpow(b, mod - 2)); }
void read(string& s) { cin >> s; }
void gen(string& s) {
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int n = 2 * (rnd() % 3 + 1);
s.resize(n, '?');
for (int i = 0; i < n; i++) {
s[i] = rnd() % 5 == 0 ? 'a' : 'b';
}
}
string join_halfs(string s) {
int n = (int)s.size();
string t;
for (int i = 0; i < n / 2; i++) {
t.push_back(s[i]);
t.push_back(s[n - 1 - i]);
}
return t;
}
int slow(string s) {
s = join_halfs(s);
int n = (int)s.size();
s = "#" + s;
vector<int> dp(n + 1);
dp[0] = 1;
cout << s << "\n";
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
if ((i - j + 1) % 2) continue;
string hlp = s.substr(j, i - j + 1);
string rhlp = hlp;
reverse(rhlp.begin(), rhlp.end());
if (hlp == rhlp) {
_inc(dp[i], dp[j - 1]);
}
}
}
return dp[n];
}
const int N = 2e6 + 5;
struct Node {
map<int, int> nxt;
int link = -1;
int dp[2] = {0, 0};
int slink = -1;
int len = 0;
int diff = 0;
Node() = default;
};
Node t[N];
int sz, max_suff;
int fast(string s) {
{
sz = 0;
t[sz++] = Node();
t[sz++] = Node();
max_suff = 1;
t[0].link = 1;
t[1].link = 0;
t[0].len = -1;
t[1].len = 0;
}
int n = (int)s.size();
s = "#" + join_halfs(s);
vector<int> dp(n + 1);
dp[0] = 1;
max_suff = 1;
for (int i = 1; i <= n; i++) {
{
while (s[i] != s[i - t[max_suff].len - 1]) {
max_suff = t[max_suff].link;
}
if (!t[max_suff].nxt.count(s[i])) {
t[sz++] = Node();
t[sz - 1].len = t[max_suff].len + 2;
int next_max_suff = t[max_suff].link;
while (s[i] != s[i - t[next_max_suff].len - 1]) {
next_max_suff = t[next_max_suff].link;
}
t[sz - 1].link =
t[next_max_suff].nxt.count(s[i]) ? t[next_max_suff].nxt[s[i]] : 1;
t[sz - 1].diff = t[sz - 1].len - t[t[sz - 1].link].len;
if (t[sz - 1].diff == t[t[sz - 1].link].diff) {
t[sz - 1].slink = t[t[sz - 1].link].slink;
} else {
t[sz - 1].slink = t[sz - 1].link;
}
t[max_suff].nxt[s[i]] = sz - 1;
}
max_suff = t[max_suff].nxt[s[i]];
}
for (int x = max_suff; t[x].len > 0; x = t[x].slink) {
t[x].dp[0] = t[x].dp[1] = 0;
{
int j = i - t[t[x].slink].len - t[x].diff;
t[x].dp[j & 1] = dp[j];
}
if (t[x].diff == t[t[x].link].diff) {
_inc(t[x].dp[0], t[t[x].link].dp[0]);
_inc(t[x].dp[1], t[t[x].link].dp[1]);
}
_inc(dp[i], t[x].dp[i & 1]);
}
}
return dp[n];
}
void WORK() {
string s;
read(s);
cout << fast(s) << "\n";
}
void TEST() {
while (1) {
string s;
gen(s);
cout << "s = " << s << endl;
int sl = slow(s);
int fs = fast(s);
if (sl == fs) {
cout << "OK (" << fs << ")" << endl;
} else {
cout << "WA" << endl;
cout << "exp = " << sl << endl;
cout << "fnd = " << fs << endl;
break;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
WORK();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int p = 1e9 + 7;
int l, t, num, lst, a[N], len[N], fail[N], dif[N], g[N], f[N], ans[N],
tr[N][28];
char s[N];
inline int get_fail(int x, int y) {
while (a[x] ^ a[x - len[y] - 1]) y = fail[y];
return y;
}
inline int inc(int x, int y) {
x += y;
return x < p ? x : x - p;
}
int main() {
scanf("%s", s + 1), l = strlen(s + 1);
if (l & 1) {
putchar(48);
return 0;
}
t = l >> 1, len[1] = a[0] = -1, fail[0] = ans[0] = num = 1;
for (register int i = 1; i <= t; ++i) a[(i << 1) - 1] = s[i] - 97;
for (register int i = l; i > t; --i) a[(l - i + 1) << 1] = s[i] - 97;
for (register int i = 1; i <= l; ++i) {
int u = a[i], v = get_fail(i, lst);
if (!tr[v][u]) {
fail[++num] = tr[get_fail(i, fail[v])][u],
len[tr[v][u] = num] = len[v] + 2, dif[num] = len[num] - len[fail[num]];
if (dif[num] == dif[fail[num]])
g[num] = g[fail[num]];
else
g[num] = fail[num];
}
for (register int j = lst = tr[v][u]; j; j = g[j]) {
f[j] = ans[i - len[g[j]] - dif[j]];
if (g[j] ^ fail[j]) f[j] = inc(f[j], f[fail[j]]);
if (!(i & 1)) ans[i] = inc(ans[i], f[j]);
}
}
printf("%d", ans[l]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, MOD = 1e9 + 7, P = 26;
inline int add(int a, const int &b) {
if ((a += b) >= MOD) a -= MOD;
return a;
}
inline int sub(int a, const int &b) {
if ((a -= b) < 0) a += MOD;
return a;
}
inline int mul(const int &a, const int &b) { return 1ll * a * b % MOD; }
inline int &inc(int &a, const int &b) { return a = add(a, b); }
inline int &dec(int &a, const int &b) { return a = sub(a, b); }
inline int &pro(int &a, const int &b) { return a = mul(a, b); }
inline int qpow(int a, int b) {
int c = 1;
for (; b; b >>= 1, pro(a, a))
if (b & 1) pro(c, a);
return c;
}
int n, fa[N], anc[N], len[N], a[N], lst, ptr, ch[N][P], f[N], g[N], dif[N];
char s[N];
inline void init() {
fa[0] = fa[1] = lst = ptr = 1;
len[1] = -1;
anc[0] = 1;
}
inline void append(int n) {
int c = a[n], p = lst;
while (a[n - len[p] - 1] ^ a[n]) p = fa[p];
if (!ch[p][c]) {
int q = fa[p];
while (a[n - len[q] - 1] ^ a[n]) q = fa[q];
fa[++ptr] = ch[q][c];
ch[p][c] = ptr;
len[ptr] = len[p] + 2;
dif[ptr] = len[ptr] - len[fa[ptr]];
anc[ptr] = dif[ptr] == dif[fa[ptr]] ? anc[fa[ptr]] : fa[ptr];
}
lst = ch[p][c];
}
int main() {
init();
scanf("%s", s + 1);
n = strlen(s + 1);
if (n & 1) return puts("0"), 0;
for (int i = 1; i <= n; i += 2) a[i] = s[i + 1 >> 1] - 'a';
for (int i = 2; i <= n; i += 2) a[i] = s[n - (i >> 1) + 1] - 'a';
a[0] = -1;
f[0] = 1;
for (int x = 1; x <= n; x++) {
append(x);
for (int i = lst; i; i = anc[i]) {
g[i] = f[x - len[anc[i]] - dif[i]];
if (fa[i] ^ anc[i]) inc(g[i], g[fa[i]]);
if (~x & 1) inc(f[x], g[i]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, lst, cnt, f[1001000], g[1001000], h[1001000];
int anc[1001000], fail[1001000];
int diff[1001000], len[1001000];
int nxt[1001000][26];
char s[1001000], A[1001000];
void upd(int& x, int y) {
if ((x += y) >= 1000000007) x -= 1000000007;
}
void append(int n, int w) {
int p;
for (p = lst; s[n] != s[n - len[p] - 1]; p = fail[p])
;
if (!nxt[p][w]) {
int x = ++cnt, k = fail[p];
for (; s[n] != s[n - len[k] - 1]; k = fail[k])
;
len[x] = len[p] + 2;
fail[x] = nxt[k][w];
nxt[p][w] = x;
diff[x] = len[x] - len[fail[x]];
anc[x] = diff[x] == diff[fail[x]] ? anc[fail[x]] : fail[x];
}
lst = nxt[p][w];
}
int main() {
scanf("%s", A + 1);
n = strlen(A + 1);
for (int i = 1; i <= n / 2; ++i) {
s[i * 2 - 1] = A[i];
s[i * 2] = A[n + 1 - i];
}
f[0] = 1;
lst = cnt = 1;
fail[0] = 1, fail[1] = 0;
len[1] = -1;
for (int i = 1; i <= n; ++i) {
append(i, s[i] - 'a');
for (int x = lst; x; x = anc[x]) {
g[x] = f[i - len[anc[x]] - diff[x]];
if (anc[x] != fail[x]) upd(g[x], g[fail[x]]);
if (i % 2 == 0) upd(f[i], g[x]);
}
}
printf("%d", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
using std::bitset;
const double Pi = acos(-1);
namespace fastIO {
template <class T>
inline void read(T &x) {
x = 0;
bool fu = 0;
char ch = 0;
while (ch > '9' || ch < '0') {
ch = getchar();
if (ch == '-') fu = 1;
}
while (ch <= '9' && ch >= '0') x = (x * 10 - 48 + ch), ch = getchar();
if (fu) x = -x;
}
inline int read() {
int x = 0;
bool fu = 0;
char ch = 0;
while (ch > '9' || ch < '0') {
ch = getchar();
if (ch == '-') fu = 1;
}
while (ch <= '9' && ch >= '0') x = (x * 10 - 48 + ch), ch = getchar();
return fu ? -x : x;
}
char _n_u_m_[40];
template <class T>
inline void write(T x) {
if (x == 0) {
putchar('0');
return;
}
T tmp = x > 0 ? x : -x;
if (x < 0) putchar('-');
register int cnt = 0;
while (tmp > 0) {
_n_u_m_[cnt++] = tmp % 10 + '0';
tmp /= 10;
}
while (cnt > 0) putchar(_n_u_m_[--cnt]);
}
template <class T>
inline void write(T x, char ch) {
write(x);
putchar(ch);
}
} // namespace fastIO
using namespace fastIO;
const int MAXN = 1000005;
int len[MAXN], ch[MAXN][26], fail[MAXN], cnt, lst, up[MAXN], orz[MAXN];
long long qwq[MAXN], ans[MAXN];
char c[MAXN], ccf[MAXN];
int now, n;
inline void insert(int pos) {
while (c[pos] != c[pos - len[lst] - 1]) lst = fail[lst];
if (!ch[lst][c[pos] - 97]) {
len[++cnt] = len[lst] + 2;
register int i = fail[lst];
while (c[pos] != c[pos - len[i] - 1]) i = fail[i];
fail[cnt] = ch[i][c[pos] - 97];
ch[lst][c[pos] - 97] = cnt;
orz[cnt] = len[cnt] - len[fail[cnt]];
if (orz[cnt] == orz[fail[cnt]])
up[cnt] = up[fail[cnt]];
else
up[cnt] = fail[cnt];
}
lst = ch[lst][c[pos] - 97];
}
int main() {
len[1] = -1;
fail[0] = 1;
up[0] = 1;
ans[0] = 1;
cnt = 1;
scanf("%s", ccf + 1);
n = strlen(ccf + 1);
if (n % 2) {
cerr << "Fuck CCF!!!" << endl;
cout << 0;
return 0;
}
for (register int i = 1, iend = n / 2; i <= iend; ++i) {
c[2 * i - 1] = ccf[i];
c[i << 1] = ccf[n - i + 1];
}
for (register int i = 1, iend = n; i <= iend; ++i) {
insert(i);
for (register int j = lst; j; j = up[j]) {
qwq[j] = ans[i - len[up[j]] - orz[j]];
if (up[j] != fail[j]) qwq[j] += qwq[fail[j]];
qwq[j] %= 1000000007ll;
if (!(i & 1)) ans[i] += qwq[j], ans[i] %= 1000000007ll;
}
}
cout << ans[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
struct PAM {
static const int N = (int)1e6 + 50;
int s[N], now;
int nxt[N][26], fail[N], l[N], last, tot;
int diff[N], anc[N];
int ans[N], dp[N];
void clear() {
s[0] = l[1] = -1;
fail[0] = tot = now = 1;
last = l[0] = 0;
memset(nxt[0], 0, sizeof nxt[0]);
memset(nxt[1], 0, sizeof nxt[1]);
}
PAM() { clear(); }
int newnode(int len) {
tot++;
memset(nxt[tot], 0, sizeof nxt[tot]);
fail[tot] = 0;
l[tot] = len;
return tot;
}
int get_fail(int x) {
while (s[now - l[x] - 2] != s[now - 1]) x = fail[x];
return x;
}
void add(int ch) {
s[now++] = ch;
int cur = get_fail(last);
if (!nxt[cur][ch]) {
int tt = newnode(l[cur] + 2);
fail[tt] = nxt[get_fail(fail[cur])][ch];
nxt[cur][ch] = tt;
diff[tt] = l[tt] - l[fail[tt]];
anc[tt] = diff[tt] == diff[fail[tt]] ? anc[fail[tt]] : fail[tt];
}
last = nxt[cur][ch];
}
void trans(int i) {
for (int p = last; p > 1; p = anc[p]) {
dp[p] = ans[i - l[anc[p]] - diff[p]];
if (diff[p] == diff[fail[p]]) {
(dp[p] += dp[fail[p]]) %= mod;
}
(ans[i] += (i % 2 == 0) * dp[p]) %= mod;
}
}
} pam;
int n;
string s1, s2;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> s1;
n = s1.length();
for (int i = 0; i < n / 2; i++) {
s2.push_back(s1[i]);
s2.push_back(s1[n - 1 - i]);
}
pam.ans[0] = 1;
s2 = " " + s2;
for (int i = 1; i <= n; i++) {
pam.add(s2[i] - 'a');
pam.trans(i);
}
cout << pam.ans[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1 << 30;
const int maxn = 1000000 + 5;
inline int add(int x, int y) {
x += y;
return x >= mod ? x -= mod : x;
}
namespace pam {
int sz, tot, last;
int ch[maxn][26], len[maxn], fail[maxn];
int cnt[maxn], dep[maxn], dif[maxn], slink[maxn];
char s[maxn];
int node(int l) {
sz++;
memset(ch[sz], 0, sizeof(ch[sz]));
len[sz] = l;
fail[sz] = 0;
cnt[sz] = dep[sz] = 0;
return sz;
}
void clear() {
sz = -1;
last = 0;
s[tot = 0] = '$';
node(0);
node(-1);
fail[0] = 1;
}
int getfail(int x) {
while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
return x;
}
void insert(char c) {
s[++tot] = c;
int now = getfail(last);
if (!ch[now][c - 'a']) {
int x = node(len[now] + 2);
fail[x] = ch[getfail(fail[now])][c - 'a'];
dep[x] = dep[fail[x]] + 1;
ch[now][c - 'a'] = x;
dif[x] = len[x] - len[fail[x]];
if (dif[x] == dif[fail[x]])
slink[x] = slink[fail[x]];
else
slink[x] = fail[x];
}
last = ch[now][c - 'a'];
cnt[last]++;
}
} // namespace pam
using pam::dif;
using pam::fail;
using pam::len;
using pam::slink;
int n, dp[maxn], g[maxn];
char s[maxn], t[maxn];
int main() {
pam::clear();
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1, j = 0; i <= n; i++) t[++j] = s[i], t[++j] = s[n - i + 1];
dp[0] = 1;
for (int i = 1; i <= n; i++) {
pam::insert(t[i]);
int c = 0;
for (int x = pam::last; x > 1; x = slink[x]) {
c++;
g[x] = dp[i - len[slink[x]] - dif[x]];
if (dif[x] == dif[fail[x]]) g[x] = add(g[x], g[fail[x]]);
if (i % 2 == 0) dp[i] = add(dp[i], g[x]);
}
assert(c <= 19);
}
printf("%d", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 7;
const long long mod = 1e9 + 7;
using namespace std;
char str[maxn], s[maxn];
int n, cnt;
long long f[maxn], g[maxn];
struct node {
int fail, len, last, delta;
int son[26];
} t[maxn];
void build() {
cnt = 1;
t[0].fail = 1;
t[0].len = 0;
t[1].fail = 0;
t[1].len = -1;
int now = 1;
for (int i = 1; i <= n; i++) {
while (s[i] != s[i - t[now].len - 1]) now = t[now].fail;
if (!t[now].son[s[i] - 'a']) {
cnt++;
int k = t[now].fail;
while (s[i] != s[i - t[k].len - 1]) k = t[k].fail;
t[cnt].fail = t[k].son[s[i] - 'a'];
t[now].son[s[i] - 'a'] = cnt;
t[cnt].len = t[now].len + 2;
t[cnt].delta = t[cnt].len - t[t[cnt].fail].len;
if (t[cnt].delta == t[t[cnt].fail].delta)
t[cnt].last = t[t[cnt].fail].last;
else
t[cnt].last = cnt;
}
now = t[now].son[s[i] - 'a'];
for (int j = now; j > 0; j = t[t[j].last].fail) {
g[j] = f[i - t[t[j].last].len];
if (t[j].last != j) g[j] = (g[j] + g[t[j].fail]) % mod;
if (i % 2 == 0) f[i] = (f[i] + g[j]) % mod;
}
}
}
int main() {
scanf("%s", str);
n = strlen(str);
int num = 0;
for (int i = 1; i <= n; i += 2) s[i] = str[num++];
num = n - 1;
for (int i = 2; i <= n; i += 2) s[i] = str[num--];
f[0] = 1;
build();
printf("%lld", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long L, pos, newp = 1, now, last;
long long g[1000002], dp[1000002];
char s[1000002], t[1000002];
struct Node {
int fail, len, cnt, diff, slink;
int ch[26];
} pam[1000005];
int GetFail(int p) {
while (t[pos] != t[pos - 1 - pam[p].len]) p = pam[p].fail;
return p;
}
void Insert(char c) {
int x = c - 'a', f;
now = GetFail(last);
if (!pam[now].ch[x]) {
pam[++newp].len = pam[now].len + 2;
f = pam[newp].fail = pam[GetFail(pam[now].fail)].ch[x];
pam[now].ch[x] = newp;
pam[newp].diff = pam[newp].len - pam[f].len;
if (pam[newp].diff == pam[f].diff)
pam[newp].slink = pam[f].slink;
else
pam[newp].slink = f;
}
++pam[last = pam[now].ch[x]].cnt;
}
int main() {
scanf("%s", s + 1);
L = strlen(s + 1);
for (int i = 1, j = 0; j < L; ++i) t[++j] = s[i], t[++j] = s[L - i + 1];
pam[0].fail = pam[1].fail = 1, pam[1].len = -1, dp[0] = 1;
for (pos = 1; pos <= L; ++pos) {
Insert(t[pos]);
for (int x = last; x > 1; x = pam[x].slink) {
g[x] = dp[pos - pam[pam[x].slink].len - pam[x].diff];
if (pam[x].diff == pam[pam[x].fail].diff)
g[x] = (g[x] + g[pam[x].fail]) % MOD;
if (pos % 2 == 0) dp[pos] = (dp[pos] + g[x]) % MOD;
}
}
printf("%lld\n", dp[L]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read() {
register int x = 0, t = 1;
register char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return x * t;
}
char ch[1000100], s[1000100];
int n, anc[1000100], diff[1000100];
int ans[1000100], f[1000100];
struct Palindromic_Tree {
struct Node {
int son[26];
int ff, len;
} t[1000100];
int last, tot;
void init() {
t[tot = 1].len = -1;
t[0].ff = t[1].ff = 1;
anc[0] = 1;
}
void extend(int c, int n, char *s) {
int p = last;
while (s[n - t[p].len - 1] != s[n]) p = t[p].ff;
if (!t[p].son[c]) {
int v = ++tot, k = t[p].ff;
t[v].len = t[p].len + 2;
while (s[n - t[k].len - 1] != s[n]) k = t[k].ff;
t[v].ff = t[k].son[c];
t[p].son[c] = v;
diff[v] = t[v].len - t[t[v].ff].len;
anc[v] = (diff[v] == diff[t[v].ff]) ? anc[t[v].ff] : t[v].ff;
}
last = t[p].son[c];
}
} PT;
int main() {
PT.init();
scanf("%s", ch + 1);
n = strlen(ch + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i += 2) s[i] = ch[(i + 1) / 2];
reverse(&ch[1], &ch[n + 1]);
for (int i = 2; i <= n; i += 2) s[i] = ch[(i + 1) / 2];
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
PT.extend(s[i] - 97, i, s);
for (int k = PT.last; k; k = anc[k]) {
f[k] = ans[i - PT.t[anc[k]].len - diff[k]];
if (anc[k] != PT.t[k].ff) f[k] = (f[k] + f[PT.t[k].ff]) % 1000000007;
if (!(i & 1)) ans[i] = (ans[i] + f[k]) % 1000000007;
}
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int MOD = 1000000007;
int n, last, sz, len[N], fail[N], ch[N][26], id[N], f[N], diff[N], nxt[N], g[N];
char str[N], s[N];
int extend(int x, int n) {
int p = last;
while (s[n - len[p] - 1] != s[n]) p = fail[p];
if (!ch[p][x]) {
int now = ++sz, k = fail[p];
len[now] = len[p] + 2;
while (s[n - len[k] - 1] != s[n]) k = fail[k];
fail[now] = ch[k][x];
ch[p][x] = now;
diff[now] = len[now] - len[fail[now]];
if (diff[now] == diff[fail[now]])
nxt[now] = nxt[fail[now]];
else
nxt[now] = fail[now];
}
last = ch[p][x];
return last;
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
int now = 0;
for (int i = 1; i <= n; i += 2) s[i] = str[++now];
now = n + 1;
for (int i = 2; i <= n; i += 2) s[i] = str[--now];
fail[0] = 1;
len[1] = -1;
sz = 1;
for (int i = 1; i <= n; i++) id[i] = extend(s[i] - 'a', i);
f[0] = 1;
for (int i = 1; i <= n; i++)
for (int p = id[i]; p; p = nxt[p]) {
g[p] = f[i - (len[nxt[p]] + diff[p])];
if (diff[p] == diff[fail[p]]) (g[p] += g[fail[p]]) %= MOD;
if (!(i & 1)) (f[i] += g[p]) %= MOD;
}
printf("%d", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const mod = 1e9 + 7;
int const MAXN = 1e6 + 5;
char s[MAXN], t[MAXN];
int child[MAXN << 1][26], parent[MAXN << 1], mxlen[MAXN << 1], cnt = 2,
last = 1;
int d[MAXN << 1], bot[MAXN << 1];
int f[MAXN], g[MAXN << 1];
int GetFail(int now, int pos) {
while (now && s[pos] != s[pos - mxlen[now] - 1]) now = parent[now];
return now;
}
int main() {
cin >> (t + 1);
int n = strlen(t + 1);
for (register int i = 1; i <= n; ++i)
s[i] = (i & 1) ? t[i / 2 + 1] : t[n - i / 2 + 1];
parent[1] = 2;
mxlen[1] = 0, mxlen[2] = -1;
for (register int i = 0; i < 26; ++i) child[0][i] = 1;
f[0] = 1;
for (register int i = 1; i <= n; ++i) {
int ch = s[i] - 'a';
last = GetFail(last, i);
if (child[last][ch])
last = child[last][ch];
else {
++cnt;
child[last][ch] = cnt;
mxlen[cnt] = mxlen[last] + 2;
parent[cnt] = child[GetFail(parent[last], i)][ch];
last = cnt;
if (parent[cnt] > 2 && mxlen[parent[cnt]] * 2 > mxlen[cnt] &&
(!d[parent[cnt]] ||
mxlen[cnt] - mxlen[parent[cnt]] == d[parent[cnt]])) {
d[cnt] = mxlen[cnt] - mxlen[parent[cnt]], bot[cnt] = bot[parent[cnt]];
d[parent[cnt]] = mxlen[cnt] - mxlen[parent[cnt]];
} else
d[cnt] = 0, bot[cnt] = cnt;
}
for (register int cur = last; cur; cur = parent[bot[cur]]) {
if (bot[cur] != cur)
g[cur] = g[parent[cur]];
else
g[cur] = 0;
if (mxlen[bot[cur]] % 2 == 0 && mxlen[bot[cur]])
g[cur] = (g[cur] + f[i - mxlen[bot[cur]]]) % mod;
if (i % 2 == 0) f[i] = (f[i] + g[cur]) % mod;
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
using vvi = vector<vi>;
using vii = vector<pii>;
string s;
bool read() {
if (!(cin >> s)) {
return 0;
}
return 1;
}
const int mod = (int)1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void sub(int &a, int b) {
a -= b;
if (a < 0) a += mod;
}
void kill(vi &v) {
v.clear();
v.shrink_to_fit();
}
struct gap_jumper {
string s;
vi value;
int n;
gap_jumper(string s_, int n_) {
n = n_;
value.resize(n + 1);
s = s_;
assert(int((s).size()) == 2 * n);
}
vi d_was;
vvi next_, prev_, sum_;
int get_id(int step) {
int pos = find((d_was).begin(), (d_was).end(), step) - d_was.begin();
if (pos != int((d_was).size())) return pos;
d_was.push_back(step);
next_.push_back(vi(2 * n)), prev_.push_back(vi(2 * n)),
sum_.push_back(vi());
sum_.back().reserve(n);
vi &next = next_.back();
vi &prev = prev_.back();
for (int i = int(2 * n) - 1; i >= 0; --i) {
if (i + step >= 2 * n)
next[i] = 1;
else
next[i] = (s[i] != s[i + step] ? 1 : next[i + step] + 1);
}
for (int i = 0; i < int(2 * n); ++i) {
if (i < step)
prev[i] = 1;
else
prev[i] = (s[i] != s[i - step] ? 1 : prev[i - step] + 1);
}
return pos;
}
int first_left(int pos, int step, char what) {
const int id = get_id(step);
const vi &prev = prev_[id];
if (what != s[pos]) return 0;
return prev[pos];
}
int first_right(int pos, int step, char what) {
const int id = get_id(step);
const vi &next = next_[id];
if (what != s[pos]) return 0;
return next[pos];
}
int sum(int pos, int step, int len) {
const int id = get_id(step);
vi &sum = sum_[id];
int to = pos + step * (len - 1);
assert(0 <= pos && pos <= to && to < int((value).size()));
while (int((sum).size()) <= to) {
const int cur_id = int((sum).size());
sum.push_back(value[cur_id]);
if (cur_id >= step) add(sum.back(), sum[cur_id - step]);
}
int res = sum[to];
if (pos - step >= 0) sub(res, sum[pos - step]);
return res;
}
void purge(const vi &allowed) {
vi to_del;
for (int i = 0; i < int(int((d_was).size())); ++i) {
const int id = d_was[i];
if (!binary_search((allowed).begin(), (allowed).end(), id))
to_del.push_back(i);
}
reverse((to_del).begin(), (to_del).end());
for (int id : to_del) {
d_was[id] = -1;
kill(sum_[id]);
kill(prev_[id]);
kill(next_[id]);
}
}
};
struct prog {
int start, diff, len;
int get(int id) const { return start + diff * id; }
int get_end() const { return start + diff * (len - 1); }
};
void relax(vector<prog> &v) {
vector<prog> nv;
for (const auto &pr : v) {
if (pr.len == 0) continue;
if (nv.empty())
nv.push_back(pr);
else {
auto &top = nv.back();
if (top.len == 1 && pr.len == 1)
top = prog{top.start, pr.start - top.start, 2};
else if (top.len == 1 && pr.start - top.start == pr.diff) {
top = prog{top.start, pr.diff, pr.len + 1};
} else if (pr.len == 1 && pr.start - top.get_end() == top.diff) {
top.len++;
} else if (pr.diff == top.diff && pr.start - top.get_end() == top.diff) {
top.len += pr.len;
} else {
nv.push_back(pr);
}
}
}
v.swap(nv);
}
void incr_all(vector<prog> &v, int delta) {
for (auto &pr : v) pr.start += delta;
}
void add_start(vector<prog> &v, int num) {
assert(v.empty() || num < v.front().start);
v.insert(v.begin(), prog{num, 1, 1});
}
void del(vector<prog> &v, const vi &who) {
int ptr = 0;
vector<prog> nv;
for (const auto &pr : v) {
int last_alive = 0;
while (ptr < int((who).size()) && pr.start <= who[ptr] &&
who[ptr] <= pr.get_end()) {
assert((who[ptr] - pr.start) % pr.diff == 0);
int cur_id = (who[ptr] - pr.start) / pr.diff;
if (last_alive < cur_id)
nv.push_back(prog{pr.get(last_alive), pr.diff, cur_id - last_alive});
assert(last_alive <= cur_id);
last_alive = cur_id + 1;
ptr++;
}
const int total = pr.len;
if (last_alive < total)
nv.push_back(prog{pr.get(last_alive), pr.diff, total - last_alive});
}
v.swap(nv);
relax(v);
}
void print(const vector<prog> &v) {
for (const auto &pr : v) {
for (int i = 0; i < int(pr.len); ++i)
;
;
};
;
}
double time() { return (double)clock() / CLOCKS_PER_SEC; }
int work_old() {
const int n = int((s).size()) / 2;
assert(int((s).size()) == 2 * n);
vi dp(n + 1);
dp[0] = 1;
vi pref;
for (int len = 0; len < int(n + 1); ++len)
if (len) {
if (int((pref).size()) >= 50) return -1;
const int l = n - len, r = n + len;
vi npref;
for (int i : pref) {
if (s[l] == s[r - i - 2] && s[l + i + 1] == s[r - 1] && i + 2 <= len)
npref.push_back(i + 2);
}
if (s[l] == s[r - 1]) npref.push_back(1);
if (len >= 2 && s[l] == s[r - 2] && s[l + 1] == s[r - 1])
npref.push_back(2);
pref = npref;
for (int i : pref) add(dp[len], dp[len - i]);
}
return dp[n];
}
void solve() {
const int n = int((s).size()) / 2;
assert(int((s).size()) == 2 * n);
int ans = work_old();
if (ans != -1) {
cout << ans << endl;
return;
}
gap_jumper info(s, n);
vi dp(n + 1);
dp[0] = 1;
info.value[0] = 1;
vector<prog> pref;
for (int len = 0; len < int(n + 1); ++len)
if (len) {
const int l = n - len, r = n + len;
vi to_del;
for (const auto &pr : pref) {
for (int i = 0; i < pr.len;) {
int cur = pr.get(i);
const int left_steps = info.first_left(r - cur - 2, pr.diff, s[l]);
const int right_steps =
info.first_right(l + cur + 1, pr.diff, s[r - 1]);
const int steps = min(left_steps, right_steps);
i += steps;
if (i >= pr.len) break;
cur = pr.get(i);
assert(!(s[l] == s[r - cur - 2] && s[l + cur + 1] == s[r - 1]));
to_del.push_back(cur);
i++;
}
}
if (!pref.empty() && pref.back().get_end() == len - 1 &&
!count((to_del).begin(), (to_del).end(), len - 1))
to_del.push_back(len - 1);
del(pref, to_del);
incr_all(pref, 2);
if (len >= 2 && s[l] == s[r - 2] && s[l + 1] == s[r - 1])
add_start(pref, 2);
if (s[l] == s[r - 1]) add_start(pref, 1);
relax(pref);
assert(int((pref).size()) <= 20);
for (const auto &pr : pref) {
int start = len - pr.get_end();
int cur_sum = info.sum(start, pr.diff, pr.len);
add(dp[len], cur_sum);
}
vi allowed;
for (const auto &pr : pref) allowed.push_back(pr.diff);
sort((allowed).begin(), (allowed).end());
allowed.resize(unique((allowed).begin(), (allowed).end()) -
allowed.begin());
info.value[len] = dp[len];
}
cout << dp[n] << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
while (read()) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, S = 26, P = 1e9 + 7;
inline void pls(int &a, int b) {
a += b;
if (a >= P) a -= P;
}
char s0[N], s[N];
int st, t, nxt[N][S], l[N], fa[N], lk[N], df[N], g[N], f[N];
void init() {
st = 1;
t = 1;
l[1] = -1;
fa[0] = 1;
}
void insert(int n) {
int c = s[n] - 'a', p, f;
for (p = st; s[n - l[p] - 1] != s[n]; p = fa[p])
;
f = p;
if (!nxt[f][c]) {
for (p = fa[f]; s[n - l[p] - 1] != s[n]; p = fa[p])
;
fa[++t] = nxt[p][c];
nxt[f][c] = t;
l[t] = l[f] + 2;
df[t] = l[t] - l[fa[t]];
lk[t] = df[t] == df[fa[t]] ? lk[fa[t]] : fa[t];
}
st = nxt[f][c];
}
int main() {
init();
scanf("%s", s0 + 1);
int n = strlen(s0 + 1);
for (register int i = 1, j = 0; i << 1 <= n; i++)
s[++j] = s0[i], s[++j] = s0[n - i + 1];
f[0] = 1;
for (register int i = 1; i <= n; i++) {
insert(i);
for (register int p = st; p; p = lk[p]) {
g[p] = f[i - df[p] - l[lk[p]]];
if (lk[p] != fa[p]) pls(g[p], g[fa[p]]);
if (i & 1 ^ 1) pls(f[i], g[p]);
}
}
printf("%d", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int w = 1, c = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = -1;
for (; isdigit(ch); ch = getchar()) c = (c << 1) + (c << 3) + (ch ^ 48);
return w * c;
}
const int M = 1e6 + 10, mod = 1e9 + 7;
char s[M], hry[M];
int n, fa[M], len[M], tot, lst, del[M], slink[M], t[M][26];
void init() {
fa[1] = fa[0] = 1;
len[1] = -1;
tot = 1;
lst = 1;
}
int gt(int x, int id) {
for (; hry[id] ^ hry[id - len[x] - 1]; x = fa[x])
;
return x;
}
void extend(int id) {
int p = gt(lst, id), o = hry[id] - 'a';
if (!t[p][o]) {
int np = ++tot;
fa[np] = t[gt(fa[p], id)][o];
t[p][o] = np;
len[np] = len[p] + 2;
del[np] = len[np] - len[fa[np]];
if (del[np] != del[fa[np]])
slink[np] = fa[np];
else
slink[np] = slink[fa[np]];
}
lst = t[p][o];
}
long long ans[M], f[M];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
if (n & 1) {
cout << 0 << "\n";
return 0;
}
int o = 0;
for (int i = (1); i <= (n / 2); ++i) {
hry[++o] = s[i];
hry[++o] = s[n - i + 1];
}
init();
ans[0] = 1;
for (int i = (1); i <= (n); ++i) {
extend(i);
for (int x = lst; x; x = slink[x]) {
f[x] = ans[i - len[slink[x]] - del[x]];
if (del[x] == del[fa[x]]) f[x] = (f[x] + f[fa[x]]) % mod;
if (i % 2 == 0) ans[i] = (ans[i] + f[x]) % mod;
}
}
cout << ans[n] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace prom {
int read() {
char a = getchar();
int res = 0;
int f = 1;
while (a < '0' || a > '9') {
if (a == '-') f = -1;
a = getchar();
}
while (a >= '0' && a <= '9') res = res * 10 + a - '0', a = getchar();
return res * f;
}
const int p = 1000000007;
const int Maxn = 1000005;
void upd(int& x, int y) { x = (x + y) % p; }
struct TR {
int son[26];
int len, diff;
int slink, fail;
} tr[Maxn];
int tot, last, n;
int newTR(int len) {
int ro = ++tot;
tr[ro] = TR();
tr[ro].len = len;
return ro;
}
int S[Maxn];
void Init() {
tot = -1;
last = n = 0;
newTR(0);
newTR(-1);
tr[0].fail = 1;
S[0] = -1;
}
int getfail(int x) {
while (S[n] != S[n - tr[x].len - 1]) x = tr[x].fail;
return x;
}
void ins(int a) {
S[++n] = a;
int p = getfail(last);
if (!tr[p].son[a]) {
int np = newTR(tr[p].len + 2);
int fail = tr[getfail(tr[p].fail)].son[a];
tr[np].fail = fail;
tr[np].diff = tr[np].len - tr[fail].len;
tr[np].slink = (tr[np].diff == tr[fail].diff) ? tr[fail].slink : fail;
tr[p].son[a] = np;
}
last = tr[p].son[a];
}
char s[Maxn], T[Maxn];
int dp[Maxn], sr_g[Maxn];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i * 2 <= n; i++) T[i * 2 - 1] = s[i], T[i * 2] = s[n - i + 1];
dp[0] = 1;
Init();
for (int i = 1; i <= n; i++) {
ins(T[i] - 'a');
for (int j = last; tr[j].len > 0; j = tr[j].slink) {
sr_g[j] = dp[i - (tr[tr[j].slink].len + tr[j].diff)];
if (tr[j].diff == tr[tr[j].fail].diff) upd(sr_g[j], sr_g[tr[j].fail]);
upd(dp[i], sr_g[j]);
}
if (i & 1) dp[i] = 0;
}
printf("%d\n", dp[n]);
return 0;
}
} // namespace prom
int main() { return prom::main(); }
|
#include <bits/stdc++.h>
using namespace std;
struct PalindromicTree {
struct node {
int nxt[30], len, st, en, link, diff, slink, cnt, oc;
};
string s;
vector<node> t;
int sz, last;
PalindromicTree() {}
PalindromicTree(string _s) {
s = _s;
int n = s.size();
t.clear();
t.resize(n + 9);
sz = 2, last = 2;
t[1].len = -1, t[1].link = 1;
t[1].diff = t[2].diff = 0;
t[2].len = 0, t[2].link = 1;
t[1].slink = 1;
t[2].slink = 2;
}
int extend(int pos) {
int cur = last, curlen = 0;
int ch = s[pos] - 'a';
while (1) {
curlen = t[cur].len;
if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos]) break;
cur = t[cur].link;
}
if (t[cur].nxt[ch]) {
last = t[cur].nxt[ch];
t[last].oc++;
return 0;
}
sz++;
last = sz;
t[sz].oc = 1;
t[sz].len = t[cur].len + 2;
t[cur].nxt[ch] = sz;
t[sz].en = pos;
t[sz].st = pos - t[sz].len + 1;
if (t[sz].len == 1) {
t[sz].link = 2;
t[sz].cnt = 1;
t[sz].diff = 1;
t[sz].slink = 2;
return 1;
}
while (1) {
cur = t[cur].link;
curlen = t[cur].len;
if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos]) {
t[sz].link = t[cur].nxt[ch];
break;
}
}
t[sz].cnt = 1 + t[t[sz].link].cnt;
t[sz].diff = t[sz].len - t[t[sz].link].len;
if (t[sz].diff == t[t[sz].link].diff)
t[sz].slink = t[t[sz].link].slink;
else
t[sz].slink = t[sz].link;
return 1;
}
void calc_orrurrences() {
for (int i = sz; i >= 3; i--) t[t[i].link].oc += t[i].oc;
}
};
int dp[4000005], series_ans[4000005], par[4000005];
void solve() {
string s, t, st;
int n;
cin >> s;
n = s.size();
for (int i = 0; i < n / 2; i++) {
st.push_back(s[i]);
st.push_back(s[n - i - 1]);
}
PalindromicTree pal(st);
dp[0] = 1;
for (int i = 1; i <= st.size(); i++) {
dp[i] = 0;
pal.extend(i - 1);
for (int v = pal.last; pal.t[v].len > 0; v = pal.t[v].slink) {
series_ans[v] = dp[i - pal.t[pal.t[v].slink].len - pal.t[v].diff];
if (pal.t[v].diff == pal.t[pal.t[v].link].diff) {
if (pal.t[v].diff == pal.t[pal.t[v].link].diff)
series_ans[v] =
(series_ans[v] + series_ans[pal.t[v].link]) % 1000000007;
}
}
if (i % 2 == 0)
for (int v = pal.last; pal.t[v].len > 0; v = pal.t[v].slink) {
dp[i] = (dp[i] + series_ans[v]) % 1000000007;
}
}
cout << dp[st.size()] << endl;
int i = st.size();
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
using namespace std;
const int N = 1e6 + 5, P = 1e9 + 7;
typedef int arr[N];
struct PAM {
int n, T, las, ch[N][26];
char s[N];
arr fa, len, gp, d;
inline void init() {
las = n = 0;
T = fa[0] = 1, s[0] = len[1] = -1;
}
inline int gf(int x) {
while (s[n - len[x] - 1] ^ s[n]) x = fa[x];
return x;
}
inline void ins(int v) {
s[++n] = v;
las = gf(las);
if (!ch[las][v]) {
fa[++T] = ch[gf(fa[las])][v], len[T] = len[las] + 2;
d[T] = len[T] - len[fa[T]];
ch[las][v] = T;
gp[T] = d[T] == d[fa[T]] ? gp[fa[T]] : fa[T];
}
las = ch[las][v];
}
} p;
int n;
arr f, g;
char s[N], ch[N];
inline int add(int a, int b) { return a += b, a >= P ? a - P : a; }
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
f[0] = 1;
if (n & 1) return puts("0"), 0;
p.init();
for (int i = 1; i <= n; i += 2) ch[i] = s[(i >> 1) + 1];
for (int i = 2; i <= n; i += 2) ch[i] = s[n - (i >> 1) + 1];
for (register int i = 1, I = n + 1; i < I; ++i) {
p.ins(ch[i] - 'a');
for (int j = p.las; j; j = p.gp[j]) {
g[j] = f[i - p.len[p.gp[j]] - p.d[j]];
if (p.gp[j] ^ p.fa[j]) g[j] = add(g[j], g[p.fa[j]]);
if (~i & 1) f[i] = add(f[i], g[j]);
}
}
printf("%d", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long lnf = 0x3f3f3f3f3f3f3f3f;
const double dnf = 1e18;
const int mod = 1e9 + 7;
const double eps = 1e-5;
const double pi = acos(-1.0);
const int hp = 13331;
const int maxn = 1000100;
const int maxp = 1100;
const int maxm = 4000100;
const int up = 1000;
const int N = 26;
struct Palindromic_Tree {
int t[maxn][N];
int fail[maxn];
int cnt[maxn];
int num[maxn];
int len[maxn];
int S[maxn];
int di[maxn];
int pre[maxn];
int last;
int n;
int p;
int newnode(int l) {
for (int i = 0; i < N; ++i) t[p][i] = 0;
cnt[p] = 0;
num[p] = 0;
len[p] = l;
return p++;
}
void init(void) {
p = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
S[n] = -1;
fail[0] = 1;
pre[0] = 1;
}
int get_fail(int x) {
while (S[n - len[x] - 1] != S[n]) x = fail[x];
return x;
}
void add(int c) {
c -= 'a';
S[++n] = c;
int cur = get_fail(last);
if (!t[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = t[get_fail(fail[cur])][c];
t[cur][c] = now;
num[now] = num[fail[now]] + 1;
di[now] = len[now] - len[fail[now]];
pre[now] = (di[now] == di[fail[now]]) ? pre[fail[now]] : fail[now];
}
last = t[cur][c];
cnt[last]++;
}
void _count(void) {
for (int i = p - 1; i >= 0; --i) cnt[fail[i]] += cnt[i];
}
} pam;
int dp[maxn], g[maxn];
char str[maxn], s[maxn];
int main(void) {
scanf("%s", str + 1);
int n = strlen(str + 1);
if (n & 1) {
printf("0\n");
return 0;
}
int cnt = 0;
int l = 1, r = n;
for (int i = 1; i <= n / 2; i++) s[++cnt] = str[l++], s[++cnt] = str[r--];
pam.init();
dp[0] = 1;
for (int i = 1; i <= n; i++) {
pam.add(s[i]);
for (int p = pam.last; p != 1 && p != 0; p = pam.pre[p]) {
g[p] = dp[i - pam.len[pam.pre[p]] - pam.di[p]];
if (pam.fail[p] != pam.pre[p]) g[p] = (g[p] + g[pam.fail[p]]) % mod;
if (i % 2 == 0) dp[i] = (dp[i] + g[p]) % mod;
}
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1010000;
const int maxAlpha = 26;
const int Mod = 1e9 + 7;
const int inf = 2147483647;
class Node {
public:
int son[maxAlpha];
int fail, len, nxt, diff;
};
char str[maxN], str2[maxN];
int nodecnt, last;
int F[maxN], G[maxN];
Node S[maxN];
void Insert(int pos, int c);
int main() {
scanf("%s", str + 1);
int len = strlen(str + 1);
if (len % 2 == 1) {
printf("0\n");
return 0;
}
for (int i = 1; 2 * i - 1 <= len; i++) str2[2 * i - 1] = str[i];
for (int i = len; (len - i + 1) * 2 <= len; i--)
str2[(len - i + 1) * 2] = str[i];
for (int i = 1; i <= len; i++) str[i] = str2[i];
nodecnt = 1;
last = 0;
S[0].len = 0;
S[1].len = -1;
S[0].fail = S[1].fail = 1;
F[0] = 1;
for (int i = 1; i <= len; i++) {
Insert(i, str[i] - 'a');
for (int p = last; p; p = S[p].nxt) {
G[p] = F[i - S[S[p].nxt].len - S[p].diff];
if (S[p].diff == S[S[p].fail].diff) G[p] = (G[p] + G[S[p].fail]) % Mod;
if (i % 2 == 0) F[i] = (F[i] + G[p]) % Mod;
}
}
printf("%d\n", F[len]);
return 0;
}
void Insert(int pos, int c) {
int p = last;
while (str[pos - 1 - S[p].len] != str[pos]) p = S[p].fail;
if (S[p].son[c] == 0) {
int np = ++nodecnt, q = S[p].fail;
while (str[pos - 1 - S[q].len] != str[pos]) q = S[q].fail;
S[np].fail = S[q].son[c];
S[np].len = S[p].len + 2;
S[p].son[c] = np;
S[np].diff = S[np].len - S[S[np].fail].len;
if (S[np].diff != S[S[np].fail].diff)
S[np].nxt = S[np].fail;
else
S[np].nxt = S[S[np].fail].nxt;
}
last = S[p].son[c];
return;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const int MOD = 1e9 + 7;
struct PAM {
int next[N][26], fail[N], len[N];
int txt[N], diff[N], link[N];
int tot, root0, root1, last, size;
void init() {
last = tot = size = 0;
txt[size] = -1;
root0 = newnode(0);
root1 = newnode(-1);
fail[root0] = 1;
fail[root1] = 0;
}
int newnode(int l) {
len[tot] = l;
diff[tot] = 0;
memset(next[tot], 0, sizeof(next[tot]));
tot++;
return tot - 1;
}
int getfail(int x) {
while (txt[size - len[x] - 1] != txt[size]) x = fail[x];
return x;
}
void extend(int c) {
txt[++size] = c;
int now = getfail(last);
if (!next[now][c]) {
int tmp = newnode(len[now] + 2);
fail[tmp] = next[getfail(fail[now])][c];
next[now][c] = tmp;
}
last = next[now][c];
diff[last] = len[last] - len[fail[last]];
if (diff[last] == diff[fail[last]])
link[last] = link[fail[last]];
else
link[last] = fail[last];
}
} pam;
char s[N], t[N];
int f[N], g[N], n;
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) {
printf("0\n");
return 0;
}
pam.init();
f[0] = 1;
for (int i = 1; i <= n; ++i)
s[i] = i & 1 ? t[(i + 1) >> 1] : t[n + 1 - (i >> 1)];
for (int i = 1; i <= n; ++i) {
pam.extend(s[i] - 'a');
for (int j = pam.last; j; j = pam.link[j]) {
g[j] = f[i - pam.diff[j] - pam.len[pam.link[j]]];
if (pam.link[j] != pam.fail[j]) g[j] = (g[j] + g[pam.fail[j]]) % MOD;
if ((i & 1) == 0) f[i] = (f[i] + g[j]) % MOD;
}
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int w = 1, c = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = -1;
for (; isdigit(ch); ch = getchar()) c = (c << 1) + (c << 3) + (ch ^ 48);
return w * c;
}
const int M = 1e6 + 10, mod = 1e9 + 7;
char s[M], hry[M];
int n, fa[M], len[M], tot, lst, del[M], slink[M], t[M][26];
void init() {
fa[1] = fa[0] = 1;
len[1] = -1;
tot = 1;
lst = 1;
}
int gt(int x, int id) {
for (; hry[id] ^ hry[id - len[x] - 1]; x = fa[x])
;
return x;
}
void extend(int id) {
int p = gt(lst, id), o = hry[id] - 'a';
if (!t[p][o]) {
int np = ++tot;
fa[np] = t[gt(fa[p], id)][o];
t[p][o] = np;
len[np] = len[p] + 2;
del[np] = len[np] - len[fa[np]];
if (del[np] != del[fa[np]])
slink[np] = fa[np];
else
slink[np] = slink[fa[np]];
}
lst = t[p][o];
}
long long ans[M], f[M];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
if (n & 1) {
cout << 0 << "\n";
return 0;
}
int o = 0;
for (int i = (1); i <= (n / 2); ++i) {
hry[++o] = s[i];
hry[++o] = s[n - i + 1];
}
init();
ans[0] = 1;
for (int i = (1); i <= (n); ++i) {
extend(i);
for (int x = lst; x; x = slink[x]) {
f[x] = ans[i - len[slink[x]] - del[x]];
if (del[x] == del[fa[x]]) f[x] = (f[x] + f[fa[x]]) % mod;
if (i % 2 == 0) ans[i] = (ans[i] + f[x]) % mod;
}
}
cout << ans[n] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct state {
state *p, *go[27], *slink;
int len, diff, dp;
state() {}
state(int length, state *fail)
: p(fail), slink(0), len(length), diff(0), dp(0) {
memset(go, 0, sizeof go);
}
void setDiff(int x) {
diff = x;
if (diff == p->diff)
slink = p->slink;
else
slink = p;
}
} pool[1100001];
int tot = 0;
inline state *new_state(int length, state *fail) {
return &(pool[tot++] = state(length, fail));
}
struct PAM {
state *oroot, *eroot, *last;
char s[1100001];
int length;
PAM()
: oroot(new_state(-1, pool)),
eroot(new_state(0, oroot)),
last(eroot),
length(0) {
oroot->setDiff(0);
eroot->setDiff(0);
}
static int ID(char x) { return x - 'a'; }
void extend(char ch) {
int x = ID(s[++length] = ch);
state *p = last;
while (s[length - p->len - 1] != ch) p = p->p;
if (p->go[x]) {
last = p->go[x];
return;
} else
p->go[x] = new_state(p->len + 2, 0);
state *q = last = p->go[x];
p = p->p;
while (s[length - p->len - 1] != ch) p = p->p;
q->p = (q->len == 1 ? eroot : p->go[x]);
q->setDiff(q->len - q->p->len);
}
};
const int mod = 1e9 + 7;
inline void add(int &a, int b) {
if ((a += b) >= mod) a -= mod;
}
char t[1100001], s[1100001];
int n, dp[1100001];
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
for (int i = 1, j = n, k = 1; i < j; i++, j--, k += 2)
s[k] = t[i], s[k + 1] = t[j];
PAM pam;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
pam.extend(s[i]);
for (state *T = pam.last; T->len > 0; T = T->slink) {
T->dp = dp[i - T->slink->len - T->diff];
if (T->diff == T->p->diff) add(T->dp, T->p->dp);
if (i % 2 == 0) add(dp[i], T->dp);
}
}
printf("%d\n", dp[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char c[1000100], S[1000100];
struct node {
int tr[26];
int len, fail;
} s[1000100];
int ptr, last;
int newnode(int l) {
s[ptr].len = l;
return ptr++;
}
void init() {
ptr = last = 0;
newnode(0);
newnode(-1);
s[0].fail = 1;
return;
}
int getfail(int i, int p) {
while (c[i - s[p].len - 1] != c[i]) p = s[p].fail;
return p;
}
int diff[1000100], anc[1000100];
void extend(int i, int k) {
int p = getfail(i, last);
if (s[p].tr[k] == 0) {
int np = newnode(s[p].len + 2);
s[np].fail = s[getfail(i, s[p].fail)].tr[k];
s[p].tr[k] = np;
diff[np] = s[np].len - s[s[np].fail].len;
anc[np] = (diff[np] == diff[s[np].fail] ? anc[s[np].fail] : s[np].fail);
}
last = s[p].tr[k];
return;
}
int f[1000100], ans[1000100];
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
if (n & 1) {
puts("0");
return 0;
}
init();
int cur = 0;
for (int i = 1, j = n; i < j; ++i, --j) {
c[++cur] = S[i];
c[++cur] = S[j];
}
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
extend(i, c[i] - 'a');
for (int p = last; p != 0; p = anc[p]) {
f[p] = ans[i - s[anc[p]].len - diff[p]];
if (anc[p] != s[p].fail) f[p] = (f[p] + f[s[p].fail]) % 1000000007;
if (i % 2 == 0) ans[i] = (ans[i] + f[p]) % 1000000007;
}
}
cout << ans[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ch[1234567][26], len[1234567], fail[1234567], s[1234567], cl, an, lst,
sf[1234567], df[1234567];
int addn(int l) {
len[an] = l;
return an++;
}
void init() {
cl = an = lst = 0;
addn(0);
addn(-1);
fail[0] = 1;
s[0] = -233;
}
int gfail(int x, int l) {
while (s[l - len[x] - 1] != s[l]) x = fail[x];
return x;
}
void add(int c) {
c -= 'a';
s[++cl] = c;
int cp = gfail(lst, cl);
if (!ch[cp][c]) {
int nn = addn(len[cp] + 2);
fail[nn] = ch[gfail(fail[cp], cl)][c];
ch[cp][c] = nn;
}
lst = ch[cp][c];
df[lst] = len[lst] - len[fail[lst]];
sf[lst] = (df[lst] == df[fail[lst]]) ? sf[fail[lst]] : fail[lst];
}
int ans[1234567], la[1234567];
const int MOD = 1e9 + 7;
char str[1234567], sc[1234567];
int main() {
scanf("%s", str + 1);
init();
int n = strlen(str + 1), g = 0;
for (int i = 1; i <= n + 1 - i; i++)
sc[++g] = str[i], sc[++g] = str[n + 1 - i];
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
add(sc[i]);
for (int j = lst; len[j] > 0; j = sf[j]) {
la[j] = ans[i - (len[sf[j]] + df[j])];
if (sf[j] != fail[j]) (la[j] += la[fail[j]]) %= MOD;
if (i % 2 == 0) (ans[i] += la[j]) %= MOD;
}
}
printf("%d\n", ans[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, ch[1000005][27], fa[1000005], tp[1000005], sum[1000005],
dp[1000005], df[1000005], len[1000005], lst, cnt, mod = 1e9 + 7;
string s, t;
int gtpre(int x, int i) {
while (t[i - len[x] - 1] != t[i]) {
x = fa[x];
}
return x;
}
void ins(int i) {
lst = gtpre(lst, i);
if (!ch[lst][t[i] - 'a']) {
fa[++cnt] = ch[gtpre(fa[lst], i)][t[i] - 'a'];
ch[lst][t[i] - 'a'] = cnt;
len[cnt] = len[lst] + 2;
df[cnt] = len[cnt] - len[fa[cnt]];
if (df[cnt] == df[fa[cnt]])
tp[cnt] = tp[fa[cnt]];
else
tp[cnt] = cnt;
}
lst = ch[lst][t[i] - 'a'];
int x = lst;
while (x) {
sum[x] = dp[i - len[tp[x]]];
if (tp[x] != x) (sum[x] += sum[fa[x]]) %= mod;
if (!(i & 1)) (dp[i] += sum[x]) %= mod;
x = fa[tp[x]];
}
}
int main() {
cnt = 1;
fa[0] = 1;
len[1] = -1;
lst = 0;
{
static char ss[1000005];
scanf(" %s", ss);
(s) = ss;
};
t = s;
for ((i) = 0; (i) < (s.length()); (i)++)
if (!(i & 1))
t[i] = s[i / 2];
else
t[i] = s[s.length() - i / 2 - 1];
t = " " + t;
s = t;
dp[0] = 1;
for ((i) = 1; (i) <= (s.length() - 1); (i)++) ins(i);
cout << dp[s.length() - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e6 + 5, mod = 1e9 + 7;
using namespace std;
char s[N], t[N];
namespace PAM {
int dfn, las, top, tot;
int dif[N], bot[N], pos[N];
int f[N], g[N];
struct node {
int len, fail, c[26];
} a[N];
int getfail(int x) {
while (s[top] != s[top - a[x].len - 1]) x = a[x].fail;
return x;
}
void extend(int k) {
++top;
int cur = getfail(las);
if (!a[cur].c[k]) {
int now = ++tot;
a[now].len = a[cur].len + 2;
a[now].fail = a[getfail(a[cur].fail)].c[k];
dif[now] = a[now].len - a[a[now].fail].len;
bot[now] = dif[now] == dif[a[now].fail] ? bot[a[now].fail] : now;
a[cur].c[k] = now;
}
las = a[cur].c[k];
}
void build(char *s) {
int len = strlen(s + 1);
las = tot = 1;
top = 0;
a[0].len = 0, a[1].len = -1;
a[0].fail = a[1].fail = 1;
for (int i = 1; i <= len; ++i) extend(s[i] - 'a'), pos[i] = las;
}
void solve(int n) {
f[0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = pos[i]; j; j = a[bot[j]].fail) {
int t = bot[j];
if (t != j)
g[j] = g[a[j].fail];
else
g[j] = 0;
if (a[t].len) g[j] = (g[j] + f[i - a[t].len]) % mod;
if (i % 2 == 0) f[i] = (f[i] + g[j]) % mod;
}
printf("%d\n", f[n]);
}
} // namespace PAM
int main() {
scanf("%s", t + 1);
int len = strlen(t + 1);
for (int i = 1; i <= len; ++i)
s[i] = i % 2 == 0 ? t[len - i / 2 + 1] : t[i + 1 >> 1];
PAM::build(s);
PAM::solve(len);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int abc = 26, mod = 1e9 + 7, maxn = 1e6 + 79;
string s, a;
void add(int& a, const int& b) {
a += b;
if (a >= mod) a -= mod;
}
vector<int> slinkdp(maxn, 0), dp(maxn, 0);
class palindromic_tree {
public:
class node {
public:
int link, slink, len, dif;
vector<int> s;
node() : link(0), len(0), slink(0), dif(0), s(vector<int>(26, -1)) {}
};
vector<node> t;
int size, last;
palindromic_tree() : t(vector<node>(maxn)), size(2), last(0) {
t[0].len = -1;
}
void add(int pos) {
int v = last;
for (;; v = t[v].link)
if (pos - t[v].len - 1 >= 0 && a[pos] == a[pos - t[v].len - 1]) break;
if (t[v].s[a[pos]] != -1) {
last = t[v].s[a[pos]];
return;
}
int nw = size++;
t[v].s[a[pos]] = nw;
t[nw].len = t[v].len + 2;
last = nw;
if (t[nw].len == 1) {
t[nw].link = t[nw].slink = t[nw].dif = 1;
return;
}
for (v = t[v].link; v; v = t[v].link)
if (pos - t[v].len - 1 >= 0 && a[pos] == a[pos - t[v].len - 1]) break;
t[nw].link = t[v].s[a[pos]];
t[nw].dif = t[nw].len - t[t[nw].link].len;
if (t[nw].dif != t[t[nw].link].dif)
t[nw].slink = t[nw].link;
else
t[nw].slink = t[t[nw].link].slink;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
for (int i = 0; i < s.size() / 2; i++)
a.push_back(s[i] - 'a'), a.push_back(s[s.size() - 1 - i] - 'a');
dp[0] = 1;
palindromic_tree p;
for (int i = 0; i < a.size(); i++) {
p.add(i);
for (int j = p.last; j > 1; j = p.t[j].slink) {
slinkdp[j] = dp[1 + i - (p.t[p.t[j].slink].len + p.t[j].dif)];
if (p.t[j].dif == p.t[p.t[j].link].dif)
add(slinkdp[j], slinkdp[p.t[j].link]);
add(dp[i + 1], slinkdp[j]);
}
dp[i + 1] *= (i & 1);
}
cout << dp[a.size()] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c;
int w = 1;
while ((c = getchar()) > '9' || c < '0')
if (c == '-') w = -1;
int ans = c - '0';
while ((c = getchar()) >= '0' && c <= '9')
ans = (ans << 1) + (ans << 3) + c - '0';
return ans * w;
}
const int xx = 1e6 + 5;
const int mod = 1e9 + 7;
char s[xx];
char c[xx];
long long dp[xx];
long long g[xx];
struct node {
int to[26];
int size;
int fail;
int diff;
int slink;
} e[xx];
int last;
int getfail(int x, int p) {
while (c[p] != c[p - e[x].size - 1]) x = e[x].fail;
return x;
}
int cst;
void add(int x, int p) {
int now = getfail(last, p);
if (e[now].to[x]) return last = e[now].to[x], void();
e[++cst].fail = e[getfail(e[now].fail, p)].to[x];
e[cst].size = e[now].size + 2;
e[now].to[x] = cst;
e[cst].diff = e[cst].size - e[e[cst].fail].size;
if (e[cst].diff == e[e[cst].fail].diff)
e[cst].slink = e[e[cst].fail].slink;
else
e[cst].slink = e[cst].fail;
last = cst;
}
int main() {
cst = 1;
last = 1;
e[1].size = -1;
e[0].fail = 1;
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (i & 1)
c[i] = s[(i + 1) / 2];
else
c[i] = s[n - i / 2 + 1];
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
add(c[i] - 'a', i);
int now = last;
while (now > 1) {
g[now] = dp[i - e[e[now].slink].size - e[now].diff];
g[now] >= mod ? g[now] -= mod : 0;
if (e[now].diff == e[e[now].fail].diff) g[now] += g[e[now].fail];
g[now] >= mod ? g[now] -= mod : 0;
if (!(i & 1)) dp[i] += g[now];
dp[i] >= mod ? dp[i] -= mod : 0;
now = e[now].slink;
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int N = 1e6 + 5;
inline int read() {
int x = 0, rev = 0, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') rev = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return rev ? -x : x;
}
int n, lst, cnt = 1, id[N], nxt[N], c[N][26], fail[N], len[N], f[N], g[N],
diff[N];
char s[N], ss[N];
int extend(int x, int n) {
int p = lst;
while (s[n - len[p] - 1] != s[n]) p = fail[p];
if (!c[p][x]) {
int now = ++cnt, k = fail[p];
len[now] = len[p] + 2;
while (s[n - len[k] - 1] != s[n]) k = fail[k];
fail[now] = c[k][x], c[p][x] = now;
diff[now] = len[now] - len[fail[now]];
if (diff[now] == diff[fail[now]])
nxt[now] = nxt[fail[now]];
else
nxt[now] = fail[now];
}
return lst = c[p][x];
}
int main() {
scanf("%s", ss + 1), n = strlen(ss + 1);
for (int i = 1, j = 0; i <= n; i += 2) s[i] = ss[++j];
for (int i = 2, j = n + 1; i <= n; i += 2) s[i] = ss[--j];
fail[0] = fail[1] = 1, len[1] = -1, f[0] = 1;
for (int i = 1; i <= n; i++) id[i] = extend(s[i] - 'a', i);
for (int i = 1; i <= n; i++) {
for (int j = id[i]; j; j = nxt[j]) {
g[j] = f[i - len[nxt[j]] - diff[j]];
if (diff[j] == diff[fail[j]]) (g[j] += g[fail[j]]) %= 1000000007;
if (!(i & 1)) (f[i] += g[j]) %= 1000000007;
}
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
const int MAXN = 1000000;
const int MOD = int(1E9) + 7;
struct node {
int len, dif, f;
node *slk, *ch[26], *fa;
} pl[MAXN + 5], *rt1, *rt2, *ncnt;
node *nd[MAXN + 5];
void build(char *S, int len) {
rt1 = ncnt = pl, rt2 = (++ncnt);
rt2->fa = rt1, rt1->len = -1, rt2->len = 0;
node *pre = rt1;
for (int i = 0; i < len; i++) {
while (S[i] != S[i - pre->len - 1]) pre = pre->fa;
if (pre->ch[S[i] - 'a'] == NULL) {
node *q = (++ncnt);
q->len = pre->len + 2;
if (pre == rt1)
q->fa = rt2;
else {
node *p = pre->fa;
while (S[i] != S[i - p->len - 1]) p = p->fa;
q->fa = p->ch[S[i] - 'a'];
}
q->dif = q->len - q->fa->len;
q->slk = (q->dif == q->fa->dif ? q->fa->slk : q->fa);
pre->ch[S[i] - 'a'] = q;
}
nd[i + 1] = pre = pre->ch[S[i] - 'a'];
}
}
char s[MAXN + 5], t[MAXN + 5];
int dp[MAXN + 5];
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len / 2; i++)
t[(i << 1) + 1] = s[i], t[(i << 1 | 1) + 1] = s[len - i - 1];
build(t + 1, len);
dp[0] = 1;
for (int i = 1; i <= len; i++) {
node *p = nd[i];
while (p != rt2) {
p->f = dp[i - p->slk->len - p->dif];
if (p->slk != p->fa) p->f = (p->f + p->fa->f) % MOD;
dp[i] = (dp[i] + p->f) % MOD;
p = p->slk;
}
if (i & 1) dp[i] = 0;
}
printf("%d\n", dp[len]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 1000005;
int ch[N][26];
int nd, la, fa[N], l[N];
int dif[N], anc[N];
int f[N], g[N], n;
char ss[N], s[N];
void init() {
nd = 1;
l[1] = -1;
fa[0] = fa[1] = 1;
anc[0] = 1;
}
void extend(int c, int n) {
int p = la;
for (; s[n - l[p] - 1] != s[n]; p = fa[p])
;
if (!ch[p][c]) {
int np = ++nd, x = fa[p];
for (; s[n - l[x] - 1] != s[n]; x = fa[x])
;
l[np] = l[p] + 2;
fa[np] = ch[x][c];
dif[np] = l[np] - l[fa[np]];
ch[p][c] = np;
anc[np] = (dif[np] == dif[fa[np]] ? anc[fa[np]] : fa[np]);
}
la = ch[p][c];
}
int main() {
init();
scanf("%s", ss + 1);
n = strlen(ss + 1);
assert(n % 2 == 0);
for (int i = (int)(1); i <= (int)(n / 2); i++) s[i * 2 - 1] = ss[i];
for (int i = (int)(1); i <= (int)(n / 2); i++) s[i * 2] = ss[n - i + 1];
g[0] = 1;
for (int i = (int)(1); i <= (int)(n); i++) {
extend(s[i] - 'a', i);
for (int j = la; j > 1; j = anc[j]) {
f[j] = g[i - l[anc[j]] - dif[j]];
if (anc[j] != fa[j]) f[j] = (f[j] + f[fa[j]]) % mo;
if (i % 2 == 0) g[i] = (g[i] + f[j]) % mo;
}
}
printf("%d\n", g[n]);
}
|
#include <bits/stdc++.h>
char zf[1000010];
int fa[1000010], trs[1000010][26], len[1000010], la = 1, sl = 2, tp[1000010],
cz[1000010];
int insert(int i, char c) {
int x = int(c - 'a');
while (i - len[la] - 1 <= 0 || zf[i - len[la] - 1] != c) la = fa[la];
if (trs[la][x]) {
la = trs[la][x];
return la;
}
int w = trs[la][x] = ++sl, t = fa[la];
len[w] = len[la] + 2;
while (t &&
(trs[t][x] == 0 || i - len[t] - 1 <= 0 || zf[i - len[t] - 1] != c))
t = fa[t];
if (trs[t][x]) {
int f = trs[t][x];
cz[w] = len[w] - len[f];
if (cz[w] == cz[f])
tp[w] = tp[f];
else
tp[w] = f;
fa[w] = f;
} else {
tp[w] = fa[w] = 2;
cz[w] = len[w];
}
return la = w;
}
char sr[1000010];
int dp[1000010], he[1000010], wz[1000010];
int main() {
len[1] = -1;
fa[2] = tp[2] = 1;
scanf("%s", sr);
int n = strlen(sr);
for (int i = 0; i < n / 2; i++) {
zf[i * 2 + 1] = sr[i];
zf[i * 2 + 2] = sr[n - 1 - i];
}
for (int i = 1; i <= n; i++) wz[i] = insert(i, zf[i]);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int u = wz[i];
while (u != 2) {
he[u] = dp[i - len[tp[u]] - cz[u]];
if (tp[u] != fa[u]) he[u] = (he[u] + he[fa[u]]) % 1000000007;
if (i % 2 == 0) dp[i] = (dp[i] + he[u]) % 1000000007;
u = tp[u];
}
}
printf("%d", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int N = 2e6 + 5;
const int P = 1e9 + 7;
char s[N], ts[N];
int ans[N], ch[N][26], f[N], g[N], anc[N], cnt = 1, las;
int dif[N], len[N], n;
int getfail(int x, int c) {
while (s[c - len[x] - 1] != s[c]) x = f[x];
return x;
}
void insert(int c, int x) {
int p = getfail(las, x);
if (!ch[p][c]) {
len[++cnt] = len[p] + 2, f[cnt] = ch[getfail(f[p], x)][c];
dif[cnt] = len[cnt] - len[f[cnt]], ch[p][c] = cnt;
anc[cnt] = (dif[cnt] == dif[f[cnt]]) ? anc[f[cnt]] : f[cnt];
}
las = ch[p][c];
}
inline void add(int &x, int y) { x += y, x >= P && (x -= P); }
int main() {
scanf("%s", ts + 1);
n = strlen(ts + 1);
if (n & 1) return write(0), 0;
int t = 0;
for (int i = 1, j = n; i <= j; i++, j--) s[++t] = ts[i], s[++t] = ts[j];
len[1] = -1, f[0] = f[1] = ans[0] = 1;
for (int i = 1; i <= n; i++) {
insert(s[i] - 'a', i);
for (int k = las; k; k = anc[k]) {
g[k] = ans[i - len[anc[k]] - dif[k]];
if (anc[k] != f[k]) add(g[k], g[f[k]]);
if (!(i & 1)) add(ans[i], g[k]);
}
}
write(ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
struct Node {
int t[26], len, f, tf, d, s;
} a[1000500];
int tn, las;
void linkd(int u) {
int fa = a[u].f;
a[u].d = a[u].len - a[fa].len;
a[u].tf = (a[u].d == a[fa].d && a[u].d * 2 <= a[u].len) ? a[fa].tf : u;
}
void ins(int k, int c, char *str) {
int p = las;
while (str[k - a[p].len - 1] != c) p = a[p].f;
if (!a[p].t[c]) {
int np = las = ++tn, v;
for (v = a[p].f; str[k - a[v].len - 1] != c; v = a[v].f)
;
if (!a[v].t[c])
a[np].f = 2;
else
a[np].f = a[v].t[c];
a[a[p].t[c] = np].len = a[p].len + 2;
linkd(np);
} else
las = a[p].t[c];
}
int f[1000500];
void dp(int k) {
for (int p = las; p > 2; p = a[a[p].tf].f) {
int tl = a[a[p].tf].len;
a[p].s = f[k - tl];
if (a[p].tf != p) a[p].s = (a[a[p].f].s + a[p].s) % mod;
if (!(k & 1)) f[k] = (f[k] + a[p].s) % mod;
}
}
void Init() {
a[1].f = a[2].f = 1;
a[1].len = -1;
las = tn = 2;
}
int n;
char s[1000500], s2[1000500];
int main() {
scanf("%s", s2 + 1);
n = strlen(s2 + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i + i <= n; i++) {
s[i * 2 - 1] = s2[n - i + 1];
s[i * 2] = s2[i];
}
s[0] = -1;
f[0] = 1;
Init();
for (int i = 1; i <= n; i++) {
ins(i, s[i] -= 'a', s);
dp(i);
}
printf("%d", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
char s[maxn], t[maxn];
int nxt[maxn][26], fail[maxn], anc[maxn], diff[maxn], len[maxn];
int last, tot;
int g[maxn], dp[maxn];
void init() {
memset(s, -1, sizeof(s));
tot = 1;
last = 0;
fail[0] = 1;
len[1] = -1;
}
void extend(char x, int idx) {
static auto get = [&](int now) -> int {
while (s[idx - len[now] - 1] != x) {
if (s[idx - len[fail[now]] - 1] == x) {
now = fail[now];
break;
} else
now = anc[now];
}
return now;
};
int p = get(last);
if (!nxt[p][x]) {
len[++tot] = len[p] + 2;
fail[tot] = nxt[get(fail[p])][x];
diff[tot] = len[tot] - len[fail[tot]];
anc[tot] = diff[tot] == diff[fail[tot]] ? anc[fail[tot]] : fail[tot];
nxt[p][x] = tot;
}
last = nxt[p][x];
for (int i = last; i > 1; i = anc[i]) {
g[i] = dp[idx - len[anc[i]] - diff[i]];
if (diff[i] == diff[fail[i]]) {
g[i] += g[fail[i]];
g[i] %= mod;
}
dp[idx] += (idx % 2 == 0) * g[i];
dp[idx] %= mod;
}
}
int main() {
init();
scanf("%s", t + 1);
int n = strlen(t + 1);
int tot = 0;
for (int i = 1; i <= n / 2; ++i) {
s[++tot] = t[i];
s[++tot] = t[n - i + 1];
}
s[tot + 1] = 0;
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
extend(s[i], i);
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int base = 26;
const int mod = 1e9 + 7;
const int MaxN = 1e6 + 5;
int n;
char s[MaxN], t[MaxN];
int ans[MaxN];
namespace PAM {
int lst, cur_n, nT = 1;
int fir[MaxN], del[MaxN], f[MaxN];
int trans[MaxN][base], len[MaxN], par[MaxN];
inline void init() {
len[1] = -1;
par[0] = par[1] = 1;
}
inline int find(int x) {
while (s[cur_n] != s[cur_n - len[x] - 1]) x = par[x];
return x;
}
inline void extend(int ch) {
++cur_n, ch -= 'a';
int cur = find(lst);
if (!trans[cur][ch]) {
int x = ++nT;
par[x] = trans[find(par[cur])][ch];
len[trans[cur][ch] = x] = len[cur] + 2;
del[x] = len[x] - len[par[x]];
if (del[x] == del[par[x]])
fir[x] = fir[par[x]];
else
fir[x] = x;
}
lst = trans[cur][ch];
}
} // namespace PAM
inline void add(int &x, const int &y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
int cur = 0;
for (int i = 1; i <= (n >> 1); ++i) {
s[++cur] = t[i];
s[++cur] = t[n - i + 1];
}
using namespace PAM;
init();
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
extend(s[i]);
for (int x = lst; x; x = par[fir[x]]) {
f[x] = ans[i - len[fir[x]]];
if (fir[x] != x) add(f[x], f[par[x]]);
if (~i & 1) add(ans[i], f[x]);
}
}
std::cout << ans[n] << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int mod = 1e9 + 7;
template <typename Tp>
void Add(Tp &x, Tp y) {
x = (x + y) % mod;
}
namespace PAM {
const int MAX = 1000010;
int tr[MAX][26], fail[MAX], len[MAX], diff[MAX], slink[MAX];
int sz, tot, lst;
char s[MAX];
int newnode(int l) {
++sz;
len[sz] = l;
fail[sz] = diff[sz] = slink[sz] = 0;
memset(tr[sz], 0, sizeof(tr[sz]));
return sz;
}
void init() {
sz = -1;
lst = 0;
s[tot = 0] = '$';
newnode(0);
newnode(-1);
fail[0] = 1;
}
int getfail(int x) {
while (s[tot] != s[tot - len[x] - 1]) x = fail[x];
return x;
}
void insert(char c) {
s[++tot] = c;
int cur = getfail(lst);
if (!tr[cur][c - 'a']) {
int now = newnode(len[cur] + 2);
fail[now] = tr[getfail(fail[cur])][c - 'a'];
tr[cur][c - 'a'] = now;
diff[now] = len[now] - len[fail[now]];
if (diff[now] == diff[fail[now]])
slink[now] = slink[fail[now]];
else
slink[now] = fail[now];
}
lst = tr[cur][c - 'a'];
}
long long solve(char *s, int n) {
static long long g[N], dp[N];
init();
memset(g, 0, sizeof(g));
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
insert(s[i]);
for (int x = lst; x > 1; x = slink[x]) {
g[x] = dp[i - len[slink[x]] - diff[x]];
if (diff[x] == diff[fail[x]]) Add(g[x], g[fail[x]]);
if (i % 2 == 0) Add(dp[i], g[x]);
}
}
return dp[n];
}
} // namespace PAM
char s[N], t[N];
int n;
int main() {
cin >> (s + 1);
n = strlen(s + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n / 2; ++i) {
t[i * 2 - 1] = s[i];
t[i * 2] = s[n - i + 1];
}
cout << PAM::solve(t, n) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
char s[1000005];
namespace PalindromicAutoMaton {
int trie[1000005][26], len[1000005], fail[1000005], cnt[1000005];
int d[1000005], top[1000005];
int tot, last;
int now;
void Build() {
tot = 1;
len[0] = 0;
fail[0] = 1;
len[1] = -1;
fail[1] = 0;
last = 0;
now = 0;
}
int New(int l) {
tot++;
memset(trie[tot], 0, sizeof(trie[tot]));
len[tot] = l, fail[tot] = 0;
return tot;
}
int GetFail(int x) {
while (s[now - len[x] - 1] != s[now]) x = fail[x];
return x;
}
void Add(int ch) {
now++;
int cur = GetFail(last);
if (!trie[cur][ch]) {
int nd = New(len[cur] + 2);
fail[nd] = trie[GetFail(fail[cur])][ch];
d[nd] = len[nd] - len[fail[nd]];
top[nd] = (d[nd] == d[fail[nd]] ? top[fail[nd]] : fail[nd]);
trie[cur][ch] = nd;
}
cnt[trie[cur][ch]]++;
last = trie[cur][ch];
}
} // namespace PalindromicAutoMaton
using namespace PalindromicAutoMaton;
char t[1000005];
int sum[1000005];
int dp[1000005];
int main() {
scanf("%s", t + 1);
int n = strlen(t + 1);
int ptr = 0;
for (int i = 1, j = n; i <= j; i++, j--) {
s[++ptr] = t[i];
s[++ptr] = t[j];
}
Build();
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
Add(s[i] - 'a');
for (int p = last; p > 1; p = top[p]) {
sum[p] = dp[i - len[top[p]] - d[p]];
if (d[p] == d[fail[p]]) {
(sum[p] += sum[fail[p]]) %= 1000000007;
}
if (i % 2 == 0) (dp[i] += sum[p]) %= 1000000007;
}
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
int link[N], slink[N], diff[N], len[N], last;
namespace PT {
int ch[N][26], ncnt;
int S[N], n;
void init() {
ncnt = 1;
link[0] = 1, link[1] = 0;
len[0] = 0, len[1] = -1;
S[0] = -1;
}
void ins(int c) {
S[++n] = c;
int p = last;
while (S[n - len[p] - 1] != S[n]) p = link[p];
if (!ch[p][c]) {
int q = ++ncnt, u = link[p];
while (S[n - len[u] - 1] != S[n]) u = link[u];
link[q] = ch[u][c], ch[p][c] = q;
len[q] = len[p] + 2, diff[q] = len[q] - len[link[q]],
slink[q] = diff[q] == diff[link[q]] ? slink[link[q]] : link[q];
}
last = ch[p][c];
}
} // namespace PT
int dp[N], g[N];
int n;
char S[N], T[N];
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
for (int i = 1, tp = 0; i < n - i + 1; ++i)
T[++tp] = S[i], T[++tp] = S[n - i + 1];
PT::init();
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
PT::ins(T[i] - 'a');
for (int u = last; len[u] > 0; u = slink[u]) {
g[u] = dp[i - len[slink[u]] - diff[u]];
if (slink[u] != link[u]) g[u] = (g[u] + g[link[u]]) % mod;
if (!(i & 1)) dp[i] = (dp[i] + g[u]) % mod;
}
}
printf("%d", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6;
const long long mod = 1e9 + 7;
namespace ModCalc {
inline void Inc(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
inline void Dec(long long &x, long long y) {
x -= y;
if (x < 0) x += mod;
}
inline long long Add(long long x, long long y) {
Inc(x, y);
return x;
}
inline long long Sub(long long x, long long y) {
Dec(x, y);
return x;
}
} // namespace ModCalc
using namespace ModCalc;
char t[N + 5], s[N + 5];
int n;
long long f[N + 5], g[N + 5], slink[N + 5], diff[N + 5];
struct PAM {
int nx[N + 5][26], fail[N + 5], len[N + 5];
int cnt, last;
void clear() {
cnt = 1;
fail[1] = fail[0] = 1;
len[1] = -1;
}
void extend(char c, int n) {
int id = c - 'a';
int p = last;
while (s[n - len[p] - 1] != s[n]) p = fail[p];
if (!nx[p][id]) {
cnt++;
len[cnt] = len[p] + 2;
int q = fail[p];
while (s[n - len[q] - 1] != s[n]) q = fail[q];
fail[cnt] = nx[q][id];
diff[cnt] = len[cnt] - len[fail[cnt]];
nx[p][id] = cnt;
slink[cnt] =
(diff[cnt] == diff[fail[cnt]] ? slink[fail[cnt]] : fail[cnt]);
}
last = nx[p][id];
p = last;
while (p >= 2) {
g[p] = f[n - len[slink[p]] - diff[p]];
if (diff[p] == diff[fail[p]]) Inc(g[p], g[fail[p]]);
if (!(n & 1)) Inc(f[n], g[p]);
p = slink[p];
}
}
} P;
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) {
puts("0");
return 0;
}
int _n = 0;
for (register int i = 1; (i << 1) <= n; i++) {
s[++_n] = t[i];
s[++_n] = t[n + 1 - i];
}
P.clear();
f[0] = 1;
for (register int i = 1; i <= n; i++) P.extend(s[i], i);
cout << f[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
char t[N], s[N];
inline int add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
inline void inc(int& x, int y) { x = add(x, y); }
namespace PAM {
int last, tot, len[N], fail[N], dif[N], slink[N], ch[N][26];
inline void pre() {
tot = 1;
len[0] = 0, len[1] = -1;
fail[1] = 1, fail[0] = 1;
last = 0;
}
inline void nd(int x, int p, int c) {
ch[p][c] = ++tot;
len[tot] = len[p] + 2;
if (p == 1)
fail[tot] = 0;
else {
p = fail[p];
while (s[x] != s[x - len[p] - 1]) p = fail[p];
fail[tot] = ch[p][c];
}
dif[tot] = len[tot] - len[fail[tot]];
if (dif[tot] != dif[fail[tot]])
slink[tot] = fail[tot];
else
slink[tot] = slink[fail[tot]];
}
inline void extend(int x, int c) {
int p = last;
while (s[x] != s[x - len[p] - 1]) p = fail[p];
if (!ch[p][c]) nd(x, p, c);
last = ch[p][c];
}
} // namespace PAM
using namespace PAM;
int f[N], g[N];
int main() {
scanf("%s", t + 1);
int n = strlen(t + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1, l = 1, r = n; l <= r; ++i) s[i] = (i & 1) ? t[l++] : t[r--];
f[0] = 1;
pre();
for (int i = 1; i <= n; ++i) {
extend(i, s[i] - 'a');
for (int p = last; p; p = slink[p]) {
g[p] = f[i - len[slink[p]] - dif[p]];
if (slink[p] != fail[p]) inc(g[p], g[fail[p]]);
if (!(i & 1)) inc(f[i], g[p]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, fa[1200000], sf[1200000], len[1200000], f[1200000], g[1200000],
diff[1200000], c[1200000][30], p, np, cnt;
char s[1200000], a[1200000];
void upd(int &x, int y) { x = (x + y) % mod; }
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n / 2; ++i) {
a[i * 2 - 1] = s[i];
a[i * 2] = s[n - i + 1];
}
fa[0] = 1;
len[0] = 0;
fa[1] = 1;
len[1] = -1;
np = cnt = 1;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int w = a[i] - 'a';
for (p = np; a[i] != a[i - len[p] - 1]; p = fa[p])
;
if (!c[p][w]) {
int q = fa[p], now = ++cnt;
len[now] = len[p] + 2;
for (; a[i] != a[i - len[q] - 1]; q = fa[q])
;
fa[now] = c[q][w];
diff[now] = len[now] - len[fa[now]];
c[p][w] = np = now;
sf[now] = diff[now] == diff[fa[now]] ? sf[fa[now]] : fa[now];
} else
np = c[p][w];
for (int q = np; q; q = sf[q]) {
g[q] = f[i - len[sf[q]] - diff[q]];
if (diff[q] == diff[fa[q]]) upd(g[q], g[fa[q]]);
upd(f[i], g[q]);
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct palindromic_tree {
static const int SIGMA = 26;
struct Node {
int len, link, slink, diff, to[SIGMA];
long long cnt;
Node(int len, int link = 0, int slink = -1, long long cnt = 1, int diff = 0)
: len(len), link(link), slink(slink), cnt(cnt), diff(diff) {
memset(to, 0, sizeof(to));
}
};
vector<Node> ns;
int last;
palindromic_tree() : last(0) {
ns.push_back(Node(-1));
ns.push_back(Node(0));
}
void add(int i, string &s) {
int p = last, c = s[i] - 'a';
while (s[i - ns[p].len - 1] != s[i]) p = ns[p].link;
if (ns[p].to[c]) {
last = ns[p].to[c];
ns[last].cnt++;
} else {
int q = ns[p].link;
while (s[i - ns[q].len - 1] != s[i]) q = ns[q].link;
q = max(1, ns[q].to[c]);
last = ns[p].to[c] = int(ns.size());
int sl, mydiff = ns[p].len + 2 - ns[q].len;
if (mydiff == ns[q].diff)
sl = ns[q].slink;
else
sl = q;
ns.push_back(Node(ns[p].len + 2, q, sl, 1, mydiff));
}
}
};
int MOD = 1e9 + 7;
int sum(int a, int b) {
int ans = a + b;
if (ans >= MOD) ans -= MOD;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> t;
int n = int(t.size());
for (int i = 0, ThxDem = int(t.size()); i < ThxDem; ++i) {
if (i & 1)
s.push_back(t[n - i / 2 - 1]);
else
s.push_back(t[i / 2]);
}
palindromic_tree p;
vector<int> dp(n + 10), sdp(n + 10);
dp[0] = 1;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
p.add(i, s);
for (int v = p.last; v > 1; v = p.ns[v].slink) {
int sl = p.ns[v].slink;
sdp[v] = dp[i + 1 - (p.ns[sl].len + p.ns[v].diff)];
if (p.ns[v].link != sl) {
sdp[v] = sum(sdp[v], sdp[p.ns[v].link]);
}
dp[i + 1] = sum(dp[i + 1], sdp[v]);
}
if (i % 2 == 0) dp[i + 1] = 0;
}
cout << dp[n] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N(1000010), MOD(1e9 + 7);
int n, cn1(1), las;
int len[N], fail[N], f[N], son[N][26], dif[N], top[N], g[N];
char s[N], t[N];
inline int read() {
register int x(0), t(1);
register char ch(getchar());
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ '0'), ch = getchar();
return x * t;
}
inline void ins(register int x, register int i) {
while (s[i - len[las] - 1] != s[i]) las = fail[las];
if (!son[las][x]) {
len[++cn1] = len[las] + 2;
register int q(fail[las]);
while (s[i - len[q] - 1] != s[i]) q = fail[q];
fail[cn1] = son[q][x];
dif[cn1] = len[cn1] - len[fail[cn1]];
top[cn1] = dif[cn1] == dif[fail[cn1]] ? top[fail[cn1]] : fail[cn1];
son[las][x] = cn1;
}
las = son[las][x];
}
int main() {
register int i, j;
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) {
puts("0");
return 0;
}
for (i = 1; i <= n / 2; ++i) {
s[(i << 1) - 1] = t[i];
s[i << 1] = t[n - i + 1];
}
len[fail[0] = g[0] = 1] = -1;
for (i = 1; i <= n; ++i) {
ins(s[i] - 'a', i);
for (j = las; j; j = top[j]) {
f[j] = g[i - len[top[j]] - dif[j]];
if (top[j] != fail[j]) {
f[j] += f[fail[j]];
if (f[j] >= MOD) f[j] -= MOD;
}
if (!(i & 1)) {
g[i] += f[j];
if (g[i] >= MOD) g[i] -= MOD;
}
}
}
printf("%d\n", g[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1000007;
char str[maxn];
struct PAM {
int next[maxn][26];
int fail[maxn];
int cnt[maxn];
int num[maxn];
int len[maxn];
int S[maxn];
long long dp[maxn];
int dif[maxn];
int anc[maxn];
long long sum[maxn];
int last, n, sz;
int newnode(int l) {
for (int i = 0; i < 26; i++) {
next[sz][i] = 0;
}
cnt[sz] = 0;
len[sz] = l;
return sz++;
}
void init() {
sz = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
S[n] = -1;
fail[0] = 1;
dp[0] = 1;
}
int getfail(int x) {
while (S[n - len[x] - 1] != S[n]) x = fail[x];
return x;
}
void insert(char ch) {
int c = ch - 'a';
S[++n] = c;
int u = getfail(last);
if (!next[u][c]) {
int v = newnode(len[u] + 2);
fail[v] = next[getfail(fail[u])][c];
next[u][c] = v;
num[v] = num[fail[v]] + 1;
}
last = next[u][c];
cnt[last]++;
dif[last] = len[last] - len[fail[last]];
anc[last] = (dif[last] == dif[fail[last]] ? anc[fail[last]] : fail[last]);
int p = last;
while (p) {
if (anc[p] == fail[p]) {
sum[p] = dp[n - len[p]];
} else {
sum[p] = (sum[fail[p]] + dp[n - len[anc[p]] - dif[p]]) % mod;
}
if (n % 2 == 0) dp[n] = (dp[n] + sum[p]) % mod;
p = anc[p];
}
}
long long count() {
long long ret = 0;
for (int i = sz - 1; i; i--) {
cnt[fail[i]] += cnt[i];
ret = (ret + cnt[i]) % mod;
}
return ret;
}
} pam;
int main() {
scanf("%s", str);
int len = strlen(str);
pam.init();
for (int i = 1; i <= len / 2; i++) {
pam.insert(str[i - 1]);
pam.insert(str[len - i]);
}
printf("%lld\n", pam.dp[len]);
}
|
#include <bits/stdc++.h>
const int MaxN = 1000000;
const int Mod = 1000000007;
int N;
int A[MaxN + 5];
int Pre[MaxN + 5], Par[MaxN + 5];
int F[MaxN + 5];
inline int add(int x, int y) { return (x += y) >= Mod ? x - Mod : x; }
inline void inc(int &x, int y = 1) { x = add(x, y); }
namespace PAM {
int cnt, last;
int ch[MaxN + 5][26], fail[MaxN + 5], len[MaxN + 5];
int diff[MaxN + 5];
void init() {
cnt = last = 2;
len[1] = -1;
fail[1] = fail[2] = 1;
Par[2] = 1;
}
inline int expand(int c, int id) {
int p = last;
while (A[id] != A[id - len[p] - 1]) p = fail[p];
if (ch[p][c] != 0) {
last = ch[p][c];
return last;
}
ch[p][c] = ++cnt;
last = cnt;
len[cnt] = len[p] + 2;
if (len[cnt] == 1) {
fail[cnt] = 2;
} else {
do p = fail[p];
while (A[id] != A[id - len[p] - 1]);
fail[cnt] = ch[p][c];
}
diff[cnt] = len[cnt] - len[fail[cnt]];
if (diff[cnt] == diff[fail[cnt]])
Par[cnt] = Par[fail[cnt]];
else
Par[cnt] = fail[cnt];
return last;
}
} // namespace PAM
void init() {
static char s[MaxN + 5];
scanf("%s", s + 1);
N = (int)strlen(s + 1);
for (int i = 1; i <= N; ++i) {
if (i & 1)
A[i] = s[(i + 1) >> 1] - 'a' + 1;
else
A[i] = s[N - (i >> 1) + 1] - 'a' + 1;
}
}
void solve() {
PAM::init();
F[0] = 1;
for (int i = 1; i <= N; ++i) {
int u = PAM::expand(A[i], i);
for (int f = u; f != 0 && f != 2; f = Par[f]) {
Pre[f] = F[i - (PAM::len[Par[f]] + PAM::diff[f])];
if (PAM::fail[f] != Par[f]) inc(Pre[f], Pre[PAM::fail[f]]);
if (i % 2 == 0) inc(F[i], Pre[f]);
}
}
printf("%d\n", F[N]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gi() {
long long ret = 0;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
char c = ch == '-' ? getchar() : ch;
while (c >= '0' && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ch == '-' ? -ret : ret;
}
const int N = 2000000 + 10;
const int mo = 1e9 + 7;
int n, last, len[N], fail[N], slink[N], link[N], diff[N], allc;
char t[N], s[N];
long long f[N], g[N];
map<int, int> tr[N];
int ins(int x) {
int p = last, c = s[x] - 'a';
while (p && s[x - len[p] - 1] != s[x]) p = fail[p];
if (s[x - len[p] - 1] != s[x]) return last = 0;
if (!tr[p][c]) {
int k = fail[p];
while (k && s[x - len[k] - 1] != s[x]) k = fail[k];
if (s[x - len[k] - 1] != s[x])
fail[++allc] = 0;
else
fail[++allc] = tr[k][c];
tr[p][c] = allc;
len[allc] = len[p] + 2;
diff[allc] = len[allc] - len[fail[allc]];
if (diff[allc] == diff[fail[allc]])
slink[allc] = slink[fail[allc]], g[allc] = g[fail[allc]];
else
slink[allc] = fail[allc];
}
return last = tr[p][c];
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
int p = n;
for (int i = 1; i <= n / 2; i += 1) s[i * 2 - 1] = t[i], s[i * 2] = t[p--];
f[0] = 1;
for (int i = 1; i <= n; i += 1) {
for (int o = ins(i); o; o = slink[o]) {
if (i & 1) break;
g[o] = f[i - len[slink[o]] - diff[o]];
if (diff[o] == diff[fail[o]]) (g[o] += g[fail[o]]) %= mo;
(f[i] += g[o]) %= mo;
}
}
cout << f[n];
return 0;
}
|
#include <bits/stdc++.h>
namespace PAM {
char s[1000015];
int fail[1000015], cnt, n, len[1000015], diff[1000015], slink[1000015],
s_f[1000015], c[1000015][26], lst;
void init() {
fail[0] = 1;
cnt = 1;
len[1] = -1;
s[0] = -1;
n = 0;
}
int get(int x) {
while (s[n] != s[n - len[x] - 1]) x = fail[x];
return x;
}
int insert(int x) {
s[++n] = x;
lst = get(lst);
if (!c[lst][x]) {
len[++cnt] = len[lst] + 2;
fail[cnt] = c[get(fail[lst])][x];
diff[cnt] = len[cnt] - len[fail[cnt]];
if (diff[cnt] == diff[fail[cnt]])
slink[cnt] = slink[fail[cnt]];
else
slink[cnt] = fail[cnt];
c[lst][x] = cnt;
}
return lst = c[lst][x];
}
} // namespace PAM
inline void add(int &x, const int y) {
if (x + y < 1000000007)
x += y;
else
x += y - 1000000007;
}
int len, f[1000015];
char tp[1000015], s[1000015];
int main() {
scanf("%s", tp + 1);
len = strlen(tp + 1);
for (int i = 1; i <= len / 2; i++)
s[i * 2 - 1] = tp[i], s[i * 2] = tp[len - i + 1];
PAM::init();
f[0] = 1;
for (int i = 1; i <= len; i++)
for (int cur = PAM::insert(s[i] - 'a'); PAM::len[cur] > 0;
cur = PAM::slink[cur]) {
PAM::s_f[cur] = f[i - (PAM::len[PAM::slink[cur]] + PAM::diff[cur])];
if (PAM::diff[cur] == PAM::diff[PAM::fail[cur]])
add(PAM::s_f[cur], PAM::s_f[PAM::fail[cur]]);
if (!(i & 1)) add(f[i], PAM::s_f[cur]);
}
printf("%d\n", f[len]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int ch[N][26], fail[N], len[N], tot = 0, now = 0, anc[N], diff[N], g[N], f[N];
char s[N], t[N];
void extend(int c, int n) {
while (s[n - len[now] - 1] != s[n]) now = fail[now];
if (!ch[now][c]) {
int v = ++tot;
len[v] = len[now] + 2;
int k = fail[now];
while (s[n - len[k] - 1] != s[n]) k = fail[k];
fail[v] = ch[k][c];
ch[now][c] = v;
diff[v] = len[v] - len[fail[v]];
anc[v] = (diff[v] == diff[fail[v]]) ? anc[fail[v]] : fail[v];
}
now = ch[now][c];
}
int main() {
scanf("%s", t);
int n = strlen(t);
for (int i = 1, p = 0; i <= n; i += 2, p++) s[i] = t[p];
for (int i = 2, p = n - 1; i <= n; i += 2, p--) s[i] = t[p];
s[n + 1] = '\0';
f[0] = 1;
len[++tot] = -1;
fail[0] = fail[1] = 1;
for (int i = 1; i <= n; i++) {
extend(s[i] - 'a', i);
for (int k = now; k > 1; k = anc[k]) {
g[k] = f[i - len[anc[k]] - diff[k]];
if (anc[k] != fail[k]) g[k] = (g[k] + g[fail[k]]) % mod;
if (!(i & 1)) f[i] = (f[i] + g[k]) % mod;
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int n;
long long ans[1000005], g[1000005];
char a[1000005], s[1000005];
struct PAM {
int s[1000005], n;
int root, las, ndsum;
int ch[1000005][26], fail[1000005], len[1000005], pre[1000005], dif[1000005];
void init() {
fail[0] = pre[0] = 1;
fail[1] = 1;
len[1] = -1;
pre[0] = 1;
s[0] = 26;
ndsum = 1;
las = 0;
}
int getfail(int x) {
while (s[n] != s[n - len[x] - 1]) x = fail[x];
return x;
}
void add_pam(int w) {
s[++n] = w;
int tmp = getfail(las);
if (!ch[tmp][w]) {
int x = ++ndsum;
len[x] = len[tmp] + 2;
fail[x] = ch[getfail(fail[tmp])][w];
ch[tmp][w] = x;
dif[x] = len[x] - len[fail[x]];
pre[x] = (dif[x] == dif[fail[x]]) ? pre[fail[x]] : fail[x];
}
las = ch[tmp][w];
}
} pam;
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
for (int i = 1; i <= n; ++i) s[i] = i % 2 ? a[i / 2 + 1] : a[n - i / 2 + 1];
pam.init();
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
pam.add_pam(s[i] - 'a');
for (int j = pam.las; j; j = pam.pre[j]) {
g[j] = ans[i - pam.len[pam.pre[j]] - pam.dif[j]];
if (pam.pre[j] != pam.fail[j]) g[j] = (g[j] + g[pam.fail[j]]) % mod;
if (i % 2 == 0) ans[i] = (ans[i] + g[j]) % mod;
}
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, fa[N], tr[N][26], len[N], d[N], pre[N], las, nodeid, dp[N], g[N];
char s[N], t[N];
void ins(int c, int m) {
int u = las;
while (t[m - len[u] - 1] != t[m]) u = fa[u];
int now = tr[u][c];
if (!now) {
now = ++nodeid;
int v = fa[u];
while (t[m - len[v] - 1] != t[m]) v = fa[v];
fa[now] = tr[v][c];
tr[u][c] = now;
len[now] = len[u] + 2;
d[now] = len[now] - len[fa[now]];
if (d[now] == d[fa[now]])
pre[now] = pre[fa[now]];
else
pre[now] = fa[now];
}
las = now;
}
inline int M(const int &o) { return o >= 1000000007 ? o - 1000000007 : o; }
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
if (n & 1) return puts("0"), 0;
for (int i = 1; (i << 1) <= n; i++)
t[i * 2 - 1] = s[i], t[i * 2] = s[n - i + 1];
fa[0] = fa[1] = 1, len[0] = 0, len[1] = -1, nodeid = 1;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
ins(t[i] - 'a', i);
for (int j = las; j > 1; j = pre[j]) {
g[j] = dp[i - len[pre[j]] - d[j]];
if (d[j] == d[fa[j]]) g[j] = M(g[j] + g[fa[j]]);
if (!(i & 1)) dp[i] = M(dp[i] + g[j]);
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
string s;
struct PalindromicTree {
int N, cur;
vector<map<int, int>> next;
vector<int> link, start, len, diff, slink;
PalindromicTree() : N(0), cur(0) {
node();
len[0] = -1;
node();
}
int node() {
next.emplace_back();
link.emplace_back(0);
start.emplace_back(0);
len.emplace_back(0);
diff.emplace_back(0);
slink.emplace_back(0);
return N++;
}
void add_letter(int idx) {
while (true) {
if (idx - len[cur] - 1 >= 0 && s[idx - len[cur] - 1] == s[idx]) break;
cur = link[cur];
}
if (next[cur].find(s[idx]) != next[cur].end()) {
cur = next[cur][s[idx]];
return;
}
node();
next[cur][s[idx]] = N - 1;
len[N - 1] = len[cur] + 2;
start[N - 1] = idx - len[N - 1] + 1;
if (len[N - 1] == 1) {
link[N - 1] = diff[N - 1] = slink[N - 1] = 1;
cur = N - 1;
return;
}
while (true) {
cur = link[cur];
if (idx - len[cur] - 1 >= 0 && s[idx - len[cur] - 1] == s[idx]) break;
}
link[N - 1] = next[cur][s[idx]];
diff[N - 1] = len[N - 1] - len[link[N - 1]];
if (diff[N - 1] == diff[link[N - 1]])
slink[N - 1] = slink[link[N - 1]];
else
slink[N - 1] = link[N - 1];
cur = N - 1;
}
};
long long dp[MAXN], sans[MAXN];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
PalindromicTree pt;
int i, cur;
string str;
cin >> str;
for (i = 0; i < (int)str.size() / 2; i++) {
s.push_back(str[i]);
s.push_back(str[(int)str.size() - i - 1]);
}
dp[0] = 1;
for (i = 1; i <= (int)s.size(); i++) {
pt.add_letter(i - 1);
for (cur = pt.cur; cur > 1; cur = pt.slink[cur]) {
sans[cur] = dp[i - pt.len[pt.slink[cur]] - pt.diff[cur]];
if (pt.diff[cur] == pt.diff[pt.link[cur]])
sans[cur] = (sans[cur] + sans[pt.link[cur]]) % 1000000007;
dp[i] = (dp[i] + sans[cur]) % 1000000007;
}
if (i & 1) dp[i] = 0;
}
cout << dp[(int)s.size()];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5, mod = 1e9 + 7;
inline int add(int x, int y) { return x + y < mod ? x + y : x + y - mod; }
inline int sub(int x, int y) { return x < y ? x - y + mod : x - y; }
int n;
char s[maxn], t[maxn];
int lst = 1, tot = 1, fa[maxn], len[maxn], ch[maxn][26], dif[maxn], slink[maxn],
pos[maxn];
int f[maxn], g[maxn];
int extend(int i) {
int x = lst, c = s[i] - 'a';
while (s[i - len[x] - 1] != s[i]) x = fa[x];
if (!ch[x][c]) {
int k = ++tot, y = fa[x];
len[k] = len[x] + 2;
while (s[i - len[y] - 1] != s[i]) y = fa[y];
fa[k] = ch[y][c];
dif[k] = len[k] - len[fa[k]];
ch[x][c] = k;
if (dif[fa[k]] == dif[k])
slink[k] = slink[fa[k]];
else
slink[k] = fa[k];
}
return lst = ch[x][c];
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n >> 1; ++i)
s[i * 2 - 1] = t[i], s[i * 2] = t[n - i + 1];
len[1] = -1;
fa[0] = 1;
for (int i = 1; i <= n; ++i) pos[i] = extend(i);
int ans = 0;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int x = pos[i];
while (x > 1) {
g[x] = f[i - len[slink[x]] - dif[x]];
if (dif[x] == dif[fa[x]]) g[x] = add(g[x], g[fa[x]]);
if (~i & 1) f[i] = add(f[i], g[x]);
x = slink[x];
}
}
printf("%d\n", f[n]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.