text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int firstCake, secondCake;
cin >> n >> firstCake >> secondCake;
long long int max = 0;
for (size_t i = 1; i < n; i++) {
int minimum;
if ((int)(firstCake / i) < (int)(secondCake / (n - i)))
minimum = (int)(firstCake / i);
else
minimum = (int)(secondCake / (n - i));
if (minimum > max) max = minimum;
}
std::cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 1e5 + 100;
int ax[maxn], n, a, b;
bool calc(int x) {
if (x == 0) return false;
int ans1 = 0;
int temp1 = a, temp2 = b;
while (temp1 >= x) temp1 -= x, ans1++;
while (temp2 >= x) temp2 -= x, ans1++;
return ans1 < n;
}
int main() {
while (scanf("%d%d%d", &n, &a, &b) != EOF) {
int value = min(a, b);
int ans = 0;
for (int i = value; i >= 0; i--) {
if (i == 0) break;
int ans1 = 0;
int temp1 = a;
int temp2 = b;
while (temp1 >= i) temp1 -= i, ans1++;
while (temp2 >= i) temp2 -= i, ans1++;
if (ans1 >= n) {
ans = i;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void go() {
int i;
int c = 0;
for (i = 0; i < 1000; i++) {
c++;
}
}
int main() {
go();
int n, a, b, i, j;
cin >> n >> a >> b;
int l = n / 2;
int h = n / 2 + n % 2;
if (a <= b) swap(a, b);
int ans = 0;
for (i = 1; i < n; i++) {
j = n - i;
int r = a / i;
int p = b / j;
ans = max(ans, min(r, p));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long t = 0, f = 1;
char tmp = getchar();
while (tmp < '0' || tmp > '9') {
if (tmp == '-') f = -1;
tmp = getchar();
}
while (tmp >= '0' && tmp <= '9') t = t * 10 + tmp - 48, tmp = getchar();
return t * f;
}
int n, a, b;
int main() {
n = read();
a = read();
b = read();
for (int i = min(a, b); i >= 0; --i) {
if ((a / i + b / i) >= n) {
printf("%d\n", i);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int o, n, x = 2, z, d, i, t, w, j, p, h, max = 0, y, k, m, l, r, q;
cin >> n >> m >> k;
int a[n];
for (i = 1, j = 0; i < n; i++, j++) {
l = m / i;
d = k / (n - i);
a[j] = l > d ? d : l;
}
sort(a, a + n - 1);
cout << a[n - 2];
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> a >> b;
long long ans = 0;
for (long long i = 1; i <= 5000000; i++) {
long long v1 = a / i;
long long v2 = b / i;
if (v1 == 0 || v2 == 0) continue;
if (v1 + v2 < n) continue;
ans = max(ans, i);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
scanf("%d%d%d", &n, &m, &k);
int maxx = min(m, k);
for (int i = maxx; i >= 1; i--) {
int res = m / i + k / i;
if (res >= n) {
printf("%d", i);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = -999;
ll n, a, b;
void init() { cin >> n >> a >> b; }
void solve() {
ll res = 1;
for (; res <= min(a, b); ++res) {
if (a / res + b / res < n) break;
}
cout << --res;
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cout << fixed << setprecision(20);
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int x = a;
while ((a / x + b / x) < n) x--;
if (a < x)
cout << a;
else if (b < x)
cout << b;
else
cout << x;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, ts = 0;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> a >> b;
int mx = 0;
for (int x = 1; x <= a + b; x++) {
if ((a / x) + (b / x) < n || x > b || x > a) {
cout << x - 1;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, a, b, ans = INT_MIN;
cin >> n >> a >> b;
for (long long int i = 1; i < n; i++) ans = max(ans, min(a / i, b / (n - i)));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long cmpfunc(const void* a, const void* b) {
return (*(long long*)a - *(long long*)b);
}
int main(void) {
long long int test, i, j, n, count, flag = 0, o1 = 0, o2 = 0, b1, x, m, l,
max, sum2, min, f, c, r, o, sum1, sum = 0,
y, a, b, count1 = 0, a2, b2;
scanf("%lld%lld%lld", &n, &a, &b);
max = f = x = y = 0;
for (i = 1; i < n; i++) {
x = a / i;
y = b / (n - i);
if (x > y) {
f = y;
} else {
f = x;
}
if (f > max) {
max = f;
}
}
printf("%lld", max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using vi = vector<int>;
int main() {
int n, a, b;
cin >> n >> a >> b;
int maxc = max(a, b), minc = min(a, b);
int mi = 0;
for (int i = 1; i < n; i++) {
int micur = min(i, n - i);
int macur = max(i, n - i);
if (min(maxc / macur, minc / micur) > mi)
mi = min(maxc / macur, minc / micur);
}
cout << mi;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, m;
cin >> n >> a >> b;
int najlepszywynik = 0;
for (int k = 1; k < n; k++) {
m = (min(a / k, b / (n - k)));
najlepszywynik = max(m, najlepszywynik);
}
cout << najlepszywynik << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, x;
cin >> n >> a >> b;
if (n == a + b)
cout << 1;
else {
int max = 0;
int x, y;
int min = 201;
int z, l;
for (int i = 1; i < n; i++) {
x = a / i;
y = b / (n - i);
if (x < y) {
min = x;
} else
min = y;
if (max < min) {
max = min;
}
}
cout << max;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, ans = 0;
cin >> n >> a >> b;
for (int i = 0; i <= n; i++) {
long long x = i == 0 ? 0 : a / i;
long long y = i == n ? 0 : b / (n - i);
ans = max((long long)ans, min(x, y));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powm(long long base, long long exp, long long mod = 1000000007) {
long long ans = 1;
while (exp) {
if (exp & 1) ans = (ans * base) % mod;
exp >>= 1, base = (base * base) % mod;
}
return ans;
}
long long addm(long long a, long long b) {
long long tmp = a + b;
if (tmp > 1000000007) tmp -= 1000000007;
return tmp;
}
long long a[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
long long i, j, k, t, m, n, res = 0, flag = 0;
long long a, b;
cin >> n >> a >> b;
for (long long i = 1; i < 100005; i++) {
if (i > a) {
cout << a;
return 0;
}
if (i > b) {
cout << b;
return 0;
}
j = a / i;
k = b / i;
if (j + k < n) {
cout << i - 1;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, ans = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
for (int i = 1; i < n; i++) {
ans = max(ans, min(a / i, b / (n - i)));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, mx = 0;
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i < n; i++) {
mx = max(mx, min(a / i, b / (n - i)));
}
printf("%d", mx);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const double oula = 0.57721566490153286060651209;
using namespace std;
int n, a, b;
bool Check(int mid) {
int sum = a / mid;
sum += b / mid;
if (sum >= n) return true;
return false;
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> a >> b;
int L = 1, R = min(a, b), mid;
while (L <= R) {
mid = L + R >> 1;
if (Check(mid)) {
L = mid + 1;
} else {
R = mid - 1;
}
}
cout << R << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n >> a >> b;
long long ans = LONG_LONG_MIN;
for (long long i = 1; i < n; i++) {
long long one = i;
long long two = n - i;
ans = max(ans, min(a / one, b / two));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 + 10;
int main() {
int n, a, b;
cin >> n >> a >> b;
int mx = 1;
for (int i = 1; i < n; i++) {
int x = a / i;
int y = b / (n - i);
if (min(x, y) > mx) mx = min(x, y);
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long nod1(long long a, long long b) { return a ? nod1(b % a, a) : b; }
long long nod(long long a, long long b) {
if (a > b) swap(a, b);
return nod1(a, b);
}
long long nok(long long a, long long b) { return a / nod(a, b) * b; }
long long sum(vector<int> v) {
long long ans = 0;
for (int i = 0; i < v.size(); i++) ans += v[i];
return ans;
}
long long sum(vector<long long> v) {
long long ans = 0;
for (int i = 0; i < v.size(); i++) ans += v[i];
return ans;
}
bool letter(char c) { return 'a' <= c && c <= 'z'; }
bool LETTER(char c) { return 'A' <= c && c <= 'Z'; }
string intToStr1(long long n) {
return n ? intToStr1(n / 10) + (char)('0' + n % 10) : "";
}
string intToStr(long long n) { return n ? intToStr(n) : "0"; }
long long strToInt(string s) {
long long ans = 0;
for (int i = 0; i < s.size(); i++) ans = 10 * ans + (s[i] - '0');
return ans;
}
bool digit(char c) { return '0' <= c && c <= '9'; }
bool prime(int n) {
if (n == 1) return 0;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return 0;
return 1;
}
const double zero = 0;
const long long null = 0;
const long long INF = 1e18;
const long long MOD = 1000000007;
const double PI = atan2(0, -1);
const int MAXN = 200001;
const double eps = 1e-8;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
int a[MAXN];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n >> a >> b;
int x = min(a, b);
while (true) {
if (a / x + b / x >= n) break;
x--;
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, i;
cin >> n >> a >> b;
long long int x, y, z, k = 0;
for (i = 1; i < n; i = i + 1) {
x = a / i;
y = b / (n - i);
z = min(x, y);
k = max(k, z);
}
cout << k << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int roundi(float d) { return floor(d + 0.5); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, a, b;
cin >> n >> a >> b;
int ans = -1;
for (int i = 1; i < n; i++) {
ans = max(ans, min(a / i, b / (n - i)));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int chia(int pt, int s) { return s / pt; }
int main() {
scanf("%d %d %d", &n, &a, &b);
if (n == a + b) {
printf("1");
return 0;
}
int x, y, ans = 1;
for (int i = 1; i < n; i++) {
int j = n - i;
x = chia(i, a);
y = chia(j, b);
int so = min(x, y);
if (ans < so) ans = so;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, a, b;
cin >> n >> a >> b;
if (n == a + b)
cout << 1;
else {
int st = 0, mx = 0;
for (int i = 1; i < n; i++) {
st = min(a / i, b / (n - i));
mx = max(st, mx);
}
cout << mx << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int multitest = 0;
int n, a, b;
void input() { cin >> n >> a >> b; }
void solve() {
int ans = min(a, b / (n - 1));
for (int i = 1; i < n; i++) {
int z = a / i;
int zz = b / (n - i);
ans = max(ans, min(z, zz));
}
cout << ans << '\n';
}
int main() {
if (multitest) {
int t;
cin >> t;
while (t--) {
input();
solve();
}
} else {
input();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, a, b, ans = 0;
cin >> n >> a >> b;
for (int i = 1; i < n; i++) {
int tmp = min(a / i, b / (n - i));
ans = max(ans, tmp);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, i;
cin >> n >> a >> b;
long long int x = -1;
for (i = 1; i < n; ++i) {
long long int temp = min(a / i, b / (n - i));
x = max(x, temp);
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, a, b;
cin >> n >> a >> b;
long long ans = -1;
for (long long i = 1; i < min(a, b) + 1; ++i) {
if (max(a / i, (long long)1) + max(b / i, (long long)1) >= n) ans = i;
}
if (ans == -1) {
cout << 0;
return 0;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, a, b;
cin >> n >> a >> b;
long long ans = 1;
for (int i = 1; i <= min(a, b); i++) {
if (((a / i) + (b / i)) >= n) {
ans = i;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void timer(void) { cout << clock() / CLOCKS_PER_SEC; }
int main() {
int n, a, b, x = 0;
cin >> n >> a >> b;
for (int i = 1; i < n; i++) {
int la = i, lb = n - i;
x = ((x > ((a / la > b / lb) ? b / lb : a / la))
? x
: ((a / la > b / lb) ? b / lb : a / la));
}
cout << x << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int l = 1, r = max(a, b);
while (r - l > 0) {
int mid = l + (r - l + 1) / 2;
int v = (a / mid) + (b / mid);
if (v > n - 1 && a / mid > 0 && b / mid > 0) {
l = mid;
} else {
r = mid - 1;
}
}
cout << l << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
while (cin >> n >> a >> b) {
int Max = 0;
for (int i = 1; i < n; i++) {
int ret = n - i;
Max = max(Max, min(b / ret, a / i));
}
cout << Max << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool ok(int mid, int a, int b, int n) {
if (a / mid + b / mid < n)
return false;
else
return true;
}
int main() {
int n, a, b;
int low, high;
cin >> n >> a >> b;
if (a < b)
low = 1, high = a;
else
low = 1, high = b;
while (low < high) {
int mid = (low + high + 1) / 2;
if (ok(mid, a, b, n)) {
low = mid;
} else
high = mid - 1;
}
cout << low << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
ios_base::sync_with_stdio();
cin.tie();
cout.tie();
int n, a, b, ans = 1;
cin >> n >> a >> b;
while (a / ans + b / ans >= n && ans <= a && ans <= b) ans++;
cout << --ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int ans = -1;
for (int i = 1; i <= n - 1; i++) {
for (int k = 1; true; k++) {
if (i * k <= a && (n - i) * k <= b)
ans = max(ans, k);
else
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b;
cin >> t >> a >> b;
int ans = 0;
for (int i = 1; i < t; i++) {
ans = max(ans, min(a / i, b / (t - i)));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int x;
for (x = 1; x <= (a + b) / n; x++) {
if (a / x + b / x < n || a / x == 0 || b / x == 0) {
break;
}
}
x--;
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long double PI = acos(-1.0);
bool AreSame(long double a, long double b) { return fabs(a - b) < 1e-9; }
long long int power(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int ceil2(long long int a, long long int b) {
long long int c = a / b;
if (a % b) c++;
return c;
}
bool isPalindrome(string s) {
string t = s;
reverse(t.begin(), t.end());
return s == t;
}
bool is_valid(long long int n, long long int a, long long int b,
long long int mid) {
long long int t1 = a / mid, t2 = b / mid;
return t1 + t2 >= n && t1 > 0 && t2 > 0;
}
void solve() {
long long int n, a, b;
cin >> n >> a >> b;
long long int start = 1, end = a + b;
long long int res = -LLONG_MAX;
while (start <= end) {
long long int mid = (start + end) / 2;
bool bo = is_valid(n, a, b, mid);
;
if (bo) {
res = max(res, mid);
start = mid + 1;
} else
end = mid - 1;
}
cout << res << "\n";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
scanf("%d %d %d", &n, &a, &b);
if (a > b) {
swap(a, b);
}
int ans = 0, x = n;
for (int i = 1; i <= a; i++) {
x -= (a / i);
if (x != 0) {
ans = max(ans, min(i, b / x));
}
x = n;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n;
char s[1000010], t[1000010];
struct PAM {
struct node {
int Next[26];
int fail;
int len;
int diff, anc;
long long f;
node(int _len = 0) {
memset(Next, 0, sizeof Next);
fail = 0;
diff = anc = 0;
f = 0;
len = _len;
}
} t[1000010];
int s[1000010];
int last;
int n;
int p;
int newnode(int len) {
t[p] = node(len);
return p++;
}
void init() {
p = 0;
newnode(0);
newnode(-1);
last = 0;
n = 0;
s[n] = -1;
t[0].fail = t[1].fail = 1;
t[0].anc = 1;
}
int get_fail(int x) {
while (s[n - t[x].len - 1] != s[n]) x = t[x].fail;
return x;
}
void add(int c) {
c -= 'a';
s[++n] = c;
int cur = get_fail(last);
if (!t[cur].Next[c]) {
int now = newnode(t[cur].len + 2);
t[now].fail = t[get_fail(t[cur].fail)].Next[c];
t[cur].Next[c] = now;
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].Next[c];
}
void gao(char *s, long long g[]) {
init();
g[0] = 1;
int len = strlen(s + 1);
for (int i = 1; i <= len; ++i) {
add(s[i]);
int it = last;
while (it) {
t[it].f = g[i - t[t[it].anc].len - t[it].diff];
if (t[it].fail != t[it].anc) {
(t[it].f += t[t[it].fail].f) %= mod;
}
if (i % 2 == 0) (g[i] += t[it].f) %= mod;
it = t[it].anc;
}
}
printf("%lld\n", g[len]);
}
} pam;
long long g[1000010];
void run() {
int len = strlen(s + 1);
for (int i = 1; i <= len; i += 2) {
t[i] = s[(i + 1) / 2];
}
reverse(s + 1, s + 1 + len);
for (int i = 2; i <= len; i += 2) {
t[i] = s[(i + 1) / 2];
}
memset(g, 0, sizeof g);
pam.gao(t, g);
}
int main() {
while (scanf("%s", s + 1) != EOF) run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < 48 || c > 59; c = getchar())
if (!(c ^ 45)) f = 1;
for (; c >= 48 && c <= 57; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
f ? x = -x : 0;
}
const int P = 1e9 + 7, N = 1000005;
struct pamn {
int ch[26], fa, len, sz, df, tp;
} S[N];
int smt, sls;
int n, dp[N], g[N];
char inc[N], c[N];
inline int gc(char s) { return s == 'A' ? 0 : s == 'C' ? 1 : s == 'G' ? 2 : 3; }
inline void paminit() { smt = sls = 2, S[1].len = -1, S[1].fa = S[2].fa = 1; }
inline void pamins(int wh, int c, char *s) {
int p = sls;
for (; s[wh] ^ s[wh - S[p].len - 1]; p = S[p].fa)
;
if (S[p].ch[c]) return sls = S[p].ch[c], S[sls].sz++, void();
int np = sls = ++smt, ph = S[p].fa;
S[np].len = S[p].len + 2;
memset(S[np].ch, 0, sizeof(S[np].ch));
for (; s[wh] ^ s[wh - S[ph].len - 1]; ph = S[ph].fa)
;
S[np].fa = S[ph].ch[c] ? S[ph].ch[c] : 2, S[p].ch[c] = np, S[np].sz = 1;
S[np].df = S[np].len - S[S[np].fa].len;
S[np].tp = (S[np].df == S[S[np].fa].df && S[np].df * 2 <= S[np].len)
? S[S[np].fa].tp
: S[np].fa;
}
int main() {
scanf("%s", inc + 1), paminit(), c[0] = -1, n = strlen(inc + 1);
for (int i = 1, ct = 0; i <= n; i++)
c[++ct] = inc[i], c[++ct] = inc[n - i + 1];
dp[0] = 1;
for (int i = 1; i <= n; i++) {
pamins(i, c[i] -= 'a', c);
for (int x = sls; x > 2; x = S[x].tp) {
g[x] = dp[i - S[S[x].tp].len - S[x].df];
if (S[x].df == S[S[x].fa].df) (g[x] += g[S[x].fa]) %= P;
if (i % 2 == 0) (dp[i] += g[x]) %= P;
}
}
return printf("%d\n", dp[n]), 0;
}
|
#include <bits/stdc++.h>
char aa[1 + 1000000 + 1];
int tt[2 + 1000000][26], fff[2 + 1000000][26], ff[2 + 1000000],
ff_[2 + 1000000], len[2 + 1000000], diff[2 + 1000000], dp_[2 + 1000000];
int node(int l) {
static int _;
len[_] = l;
return _++;
}
void init() {
int a;
node(0), node(-1);
aa[0] = -1;
for (a = 0; a < 26; a++) fff[0][a] = fff[1][a] = 1;
}
int main() {
static char cc[1000000 + 1];
static int dp[1000000 + 1];
int n, m, s_;
init();
scanf("%s", cc), n = strlen(cc);
dp[0] = 1;
s_ = 0;
for (m = 1; m <= n; m++) {
int a = (m % 2 == 1 ? cc[m / 2] : cc[n - m / 2]) - 'a', s, x;
aa[m] = a;
if (aa[m - 1 - len[s_]] != a) s_ = fff[s_][a];
if (tt[s_][a] == 0) {
int t = node(len[s_] + 2), f = tt[fff[s_][a]][a];
diff[t] = len[t] - len[f], ff[t] = f,
ff_[t] = diff[t] != diff[f] ? f : ff_[f];
tt[s_][a] = t;
memcpy(fff[t], fff[f], sizeof fff[f]), fff[t][(int)aa[m - len[f]]] = f;
}
s_ = tt[s_][a];
s = s_, x = 0;
while (len[s] > 0) {
int f = ff[s], f_ = ff_[s];
dp_[s] = ((diff[f] == diff[s] ? dp_[f] : 0) + dp[m - len[f_] - diff[s]]) %
1000000007;
x = (x + dp_[s]) % 1000000007, s = f_;
}
if (m % 2 == 0) dp[m] = x;
}
printf("%d\n", dp[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 (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]]) 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;
template <typename T>
inline void read(T& x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T, typename... U>
inline void read(T& x, U&... y) {
read(x), read(y...);
}
const int N = 1e6 + 10, P = 1e9 + 7;
int n, cnt, now, last;
int fa[N], len[N], d[N], top[N], ch[N][26];
char s[N], t[N];
int F[N], G[N];
void Init() {
cnt = 1;
len[1] = -1;
s[0] = '#';
fa[0] = 1;
}
int Fail(int p) {
while (s[now - len[p] - 1] != s[now]) p = fa[p];
return p;
}
void Extend(int x) {
int p = Fail(last);
if (!ch[p][x]) {
int np = ++cnt;
len[np] = len[p] + 2;
fa[np] = ch[Fail(fa[p])][x];
d[np] = len[np] - len[fa[np]];
top[np] = d[np] == d[fa[np]] ? top[fa[np]] : fa[np];
ch[p][x] = np;
}
last = ch[p][x];
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) return puts("0"), 0;
for (int i = 1; i <= n >> 1; ++i) s[i * 2 - 1] = t[i];
for (int i = n; i > n >> 1; --i) s[(n - i + 1) * 2] = t[i];
Init();
F[0] = 1;
for (int i = 1; i <= n; ++i) {
now = i;
Extend(s[i] - 'a');
for (int p = last; p > 1; p = top[p]) {
G[p] = F[i - len[top[p]] - d[p]];
if (d[p] == d[fa[p]]) (G[p] += G[fa[p]]) %= P;
if (i % 2 == 0) (F[i] += G[p]) %= P;
}
}
printf("%d\n", F[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const long long mm = 1e9 + 7;
int ch[maxn][27], fail[maxn];
long long cnt[maxn];
long long s[maxn], len[maxn];
int slink[maxn];
int dif[maxn];
char sp[maxn];
long long g[maxn];
int last, sz, n;
int newnode(int x) {
for (int i = 0; i < 26; ++i) {
ch[sz][i] = 0;
}
cnt[sz] = 0;
len[sz] = x;
return sz++;
}
void init() {
sz = 0;
newnode(0);
newnode(-1);
last = 0, n = 0;
fail[0] = 1;
fail[1] = 0;
s[0] = -1;
}
int getfail(int u) {
while (s[n - len[u] - 1] != s[n]) u = fail[u];
return u;
}
int pos[maxn];
void add(int c) {
s[++n] = c;
int u = getfail(last);
if (!ch[u][c]) {
int np = newnode(len[u] + 2);
fail[np] = ch[getfail(fail[u])][c];
ch[u][c] = np;
dif[np] = len[np] - len[fail[np]];
if (dif[np] == dif[fail[np]]) {
slink[np] = slink[fail[np]];
} else
slink[np] = fail[np];
}
last = ch[u][c];
pos[last] = n;
cnt[last]++;
}
void count() {
for (int i = sz - 1; i >= 0; --i) {
cnt[fail[i]] += cnt[i];
}
}
long long dp[maxn];
char dsp[maxn];
int main() {
init();
dsp[0] = 'a';
scanf("%s", dsp + 1);
int le = strlen(dsp + 1);
int j = 0;
for (int i = 1; i <= le; ++i) {
sp[++j] = dsp[i];
sp[++j] = dsp[le - i + 1];
}
dp[0] = 1;
for (int i = 1; i <= le; ++i) {
add(sp[i] - 'a');
for (int j = last; j >= 2; j = slink[j]) {
g[j] = dp[i - len[slink[j]] - dif[j]];
if (dif[j] == dif[fail[j]]) g[j] = (g[j] % mm + g[fail[j]] % mm) % mm;
if (i % 2 == 0) dp[i] = (dp[i] % mm + g[j] % mm) % mm;
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + (c - '0'), c = getchar();
return f * x;
}
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
template <typename T>
bool umax(T& a, T t) {
if (t > a) return a = t, 1;
return 0;
}
template <typename T>
bool umin(T& a, T t) {
if (t < a) return a = t, 1;
return 0;
}
const int MAXN = 1000011, mod = 1e9 + 7;
inline int S(int x) { return x < mod ? x : x - mod; }
char s[MAXN], tp[MAXN];
int f[MAXN], ed[MAXN];
namespace PTree {
int t[MAXN][26], fail[MAXN], len[MAXN], top[MAXN], sig[MAXN];
int last, tot, now;
void init() { last = tot = 1, len[0] = -1, top[0] = 0; }
int extend(int w) {
int pos = last;
while (pos && s[now - len[pos]] - 'a' != w) pos = fail[pos];
if (!t[pos][w]) {
t[pos][w] = ++tot, len[tot] = len[pos] + 2;
if (!pos)
fail[tot] = 1, top[tot] = tot;
else {
pos = fail[pos];
while (pos && s[now - len[pos]] - 'a' != w) pos = fail[pos];
fail[tot] = t[pos][w];
top[tot] =
(len[tot] - len[fail[tot]] == len[fail[tot]] - len[fail[fail[tot]]]
? top[fail[tot]]
: tot);
}
last = tot;
} else
last = t[pos][w];
++now;
return last;
}
void solve() {
int n = now;
f[0] = 1;
for (int i = 1; i <= n; ++i)
for (int x = ed[i]; x > 1; x = fail[top[x]]) {
sig[x] =
top[x] == x ? f[i - len[x]] : S(sig[fail[x]] + f[i - len[top[x]]]);
if (!(i & 1)) f[i] = S(f[i] + sig[x]);
}
printf("%d\n", f[n]);
}
} // namespace PTree
int main() {
scanf("%s", tp + 1);
int n = strlen(tp + 1);
for (int i = 1; i <= (n >> 1); ++i) s[2 * i - 1] = tp[i];
for (int i = n; i > (n >> 1); --i) s[2 * (n - i + 1)] = tp[i];
PTree::init();
for (int i = 1; i <= n; ++i) ed[i] = PTree::extend(s[i] - 'a');
PTree::solve();
return 0;
}
|
#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], diff[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;
diff[np] = len[np] - len[fa[np]];
anc[np] = diff[np] == diff[fa[np]] ? anc[fa[np]] : fa[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 = anc[j]) {
g[j] = f[i - len[anc[j]] - diff[j]];
if (anc[j] != fa[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>
using namespace std;
const int MAXN = 1e6 + 10, MAXM = 4e6 + 10;
const int INF = INT_MAX, SINF = 0x3f3f3f3f;
const long long llINF = LLONG_MAX;
const int MOD = 1e9 + 7, mod = 119;
const int Lim = 1 << 20;
struct 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 newnode(int l) {
sz++;
memset(ch[sz], 0, sizeof(ch[sz]));
len[sz] = l;
fail[sz] = cnt[sz] = dep[sz] = 0;
return sz;
}
void init() {
sz = -1;
last = 0;
s[tot = 0] = '$';
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'];
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]++;
}
} pam;
int n, dp[MAXN], g[MAXN];
char s[MAXN], t[MAXN];
int main() {
pam.init();
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]);
for (int x = pam.last; x > 1; x = pam.slink[x]) {
g[x] = dp[i - pam.len[pam.slink[x]] - pam.dif[x]];
if (pam.dif[x] == pam.dif[pam.fail[x]])
g[x] = (g[x] + g[pam.fail[x]]) % MOD;
if (i % 2 == 0) dp[i] = (dp[i] + g[x]) % MOD;
}
}
printf("%d", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5 + 1e6, MOD = 1e9 + 7;
inline void mo(int& x) { x >= MOD ? x -= MOD : 0; }
inline int mo1(int x) { return x >= MOD ? x - MOD : x; }
struct Ari {
int l, r, d;
};
struct Pam {
struct Node {
int s[26], fa, len, top, delta;
} t[N];
int top;
inline int new_node() {
t[++top] = (Node){{}, 0, 0, 0, 0};
return top;
}
Pam() {
top = -1;
new_node();
new_node();
t[0].fa = t[1].fa = 1;
t[0].len = 0;
t[1].len = -1;
t[0].delta = t[1].delta = -1;
}
int get_fa(int p, int s[], int n) {
while (t[p].len == n - 1 || s[n] != s[n - t[p].len - 1]) p = t[p].fa;
return p;
}
int extend(int p, int s[], int n) {
int c = s[n];
p = get_fa(p, s, n);
if (t[p].s[c] == 0) {
int x = new_node();
t[x].fa = t[get_fa(t[p].fa, s, n)].s[c];
t[x].len = t[p].len + 2;
t[x].delta = t[x].len - t[t[x].fa].len;
t[x].top = (t[x].delta == t[t[x].fa].delta ? t[t[x].fa].top : t[x].fa);
t[p].s[c] = x;
}
return t[p].s[c];
}
vector<Ari> get_border(int x) {
vector<Ari> ret;
for (; x > 1; x = t[x].top)
ret.push_back((Ari){t[t[x].top].len + t[x].delta, t[x].len, t[x].delta});
return ret;
}
} pam;
map<pair<int, int>, int> mp[N];
int a[N], f[N];
char s[N];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n / 2; ++i) {
a[i + i - 1] = s[i] - 'a';
a[i + i] = s[n - i + 1] - 'a';
}
int last = 1;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
last = pam.extend(last, a, i);
if (i & 1) continue;
vector<Ari> g = pam.get_border(last);
for (int j = 0; j < g.size(); ++j) {
Ari d = g[j];
if (~d.d & 1) {
if (d.l & 1) continue;
} else {
if (d.l & 1) d.l += d.d;
if (d.r & 1) d.r -= d.d;
d.d <<= 1;
if (d.l > d.r) continue;
}
mp[i][make_pair(d.l, d.d)] =
mo1(f[i - d.l] +
(d.r - d.d >= d.l ? mp[i - d.d][make_pair(d.l, d.d)] : 0));
mo(f[i] += mp[i][make_pair(d.l, d.d)]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[1000010], Ch[1000010];
int n;
long long F[1000010], S[1000010];
int C[1000010][26], Pr[1000010], Sz[1000010], D[1000010], Pl[1000010],
cnt = 1, l = 1, tot = 0;
int getp(int x) {
for (; Ch[tot - Sz[x] - 1] != Ch[tot]; x = Pr[x])
;
return x;
}
void add(int x, int b) {
Ch[++tot] = x;
l = getp(l);
if (C[l][x])
l = C[l][x];
else {
Sz[++cnt] = Sz[l] + 2;
Pr[cnt] = C[getp(Pr[l])][x];
l = (C[l][x] = cnt);
D[l] = Sz[l] - Sz[Pr[l]];
}
for (int i = l; i; i = Pl[i]) {
if (D[i] == D[Pr[i]]) {
Pl[i] = Pl[Pr[i]];
S[i] = (F[tot - Sz[Pl[i]] - D[i]] + S[Pr[i]]) % 1000000007;
} else {
Pl[i] = Pr[i];
S[i] = F[tot - Sz[Pl[i]] - D[i]];
}
if (b) F[tot] = (F[tot] + S[i]) % 1000000007;
}
}
int main() {
Ch[0] = 123;
scanf("%s", ch);
n = strlen(ch);
Pr[0] = 1;
Sz[1] = -1;
F[0] = 1;
for (int i = 0; i < n / 2; i++) {
add(ch[i] - 'a', 0);
add(ch[n - i - 1] - 'a', 1);
}
printf("%lld\n", (F[n] % 1000000007 + 1000000007) % 1000000007);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e6 + 5, md = 1e9 + 7;
char t[N], s[N];
int n, k, ch[N][26], len[N], lst, fail[N], tot, fa[N], dlt[N];
int ans[N], f[N];
inline void upd(int& a) { a += a >> 31 & md; }
void ins(int pos) {
int p = lst, c = s[pos] - 'a';
while (s[pos] != s[pos - len[p] - 1]) p = fail[p];
if (!ch[p][c]) {
int np = ++tot;
len[np] = len[p] + 2;
int q = fail[p];
for (; s[pos] != s[pos - len[q] - 1]; q = fail[q])
;
int x = fail[np] = ch[q][c];
dlt[np] = len[np] - len[x];
fa[np] = dlt[np] == dlt[x] ? fa[x] : x;
ch[p][c] = np;
}
lst = ch[p][c];
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) return puts("0"), 0;
for (int l = 1, r = n; l <= r; ++l, --r) s[++k] = t[l], s[++k] = t[r];
lst = tot = 1, len[1] = -1, len[0] = 0, fail[0] = ans[0] = 1;
for (int i = 1; i <= n; ++i) {
ins(i);
for (int j = lst; j; j = fa[j]) {
f[j] = ans[i - len[fa[j]] - dlt[j]];
if (dlt[j] == dlt[fail[j]]) upd(f[j] += f[fail[j]] - md);
upd(ans[i] += f[j] - md);
}
if (i & 1) ans[i] = 0;
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int g[1000010], f[1000010], trans[1000010][26];
int fail[1000010], len[1000010];
char st[1000010];
int c[1000010];
int d[1000010], pos[1000010];
int n, lst, cnt;
inline int mo(int x) {
if (x >= MOD) return x - MOD;
return x;
}
int getfail(int i, int x) {
while (c[i - len[x] - 1] != c[i]) x = fail[x];
return x;
}
int main() {
scanf("%s", st + 1);
n = strlen(st + 1);
for (int i = 1; i <= n; i++)
c[i] = (i & 1 ? st[(i + 1) >> 1] : st[n - (i >> 1) + 1]) - 'a';
len[1] = -1;
fail[0] = cnt = 1;
f[0] = 1;
c[0] = -1;
for (int i = 1; i <= n; i++) {
int x = getfail(i, lst);
if (!trans[x][c[i]]) {
int v = getfail(i, fail[x]);
fail[++cnt] = trans[v][c[i]];
trans[x][c[i]] = cnt;
len[cnt] = len[x] + 2;
d[cnt] = len[cnt] - len[fail[cnt]];
pos[cnt] = d[cnt] == d[fail[cnt]] ? pos[fail[cnt]] : fail[cnt];
}
lst = trans[x][c[i]];
for (x = lst; x; x = pos[x]) {
g[x] = f[i - len[pos[x]] - d[x]];
if (pos[x] != fail[x]) g[x] = mo(g[x] + g[fail[x]]);
if (!(i & 1)) f[i] = mo(f[i] + g[x]);
}
}
printf("%d\n", f[n]);
}
|
#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>
char S[1000000 + 5], T[1000000 + 5];
int c[1000000 + 5][26], l[1000000 + 5], f[1000000 + 5], tn, df[1000000 + 5],
ff[1000000 + 5], s[1000000 + 5], F[1000000 + 5];
int main() {
int n, i, j, x;
scanf("%s", S + 1);
n = strlen(S + 1);
T[0] = 255;
for (i = 1; i <= n / 2; ++i)
T[2 * i - 1] = S[i] - 'a', T[2 * i] = S[n - i + 1] - 'a';
f[0] = 1;
l[++tn] = -1;
for (F[0] = i = x = 1; i <= n; ++i) {
while (T[i] != T[i - l[x] - 1]) x = f[x];
if (!c[x][T[i]]) {
for (j = f[x]; T[i - l[j] - 1] != T[i]; j = f[j])
;
f[++tn] = c[j][T[i]];
l[c[x][T[i]] = tn] = l[x] + 2;
df[tn] = l[tn] - l[f[tn]];
ff[tn] = df[tn] == df[f[tn]] ? ff[f[tn]] : tn;
}
x = c[x][T[i]];
for (j = x; j; j = f[ff[j]]) {
s[j] = F[i - l[ff[j]]];
if (ff[j] != j) s[j] = (s[j] + s[f[j]]) % 1000000007;
if (~i & 1) F[i] = (F[i] + s[j]) % 1000000007;
}
}
printf("%d", F[n]);
}
|
#include <bits/stdc++.h>
class Palindrome_Automaton {
private:
static const int MAXS = 1e6, MOD = 1e9 + 7;
int Cnt, Last, Aux[MAXS + 5], F[MAXS + 5], Dif[MAXS + 5], Anc[MAXS + 5];
struct Node {
int L, Fa, Ch[26];
Node() {}
Node(const int l, const int f = 0) {
L = l, Fa = f;
for (register int i = 0; i ^ 26; ++i) Ch[i] = 0;
}
} nd[MAXS + 5];
public:
inline void Init() {
for (register int i = 1; i <= Cnt; ++i) nd[i] = Node(0);
Cnt = Last = F[0] = 1;
nd[0] = Node(0, 1), nd[1] = Node(-1, 0);
}
inline int NewNode() {
nd[++Cnt] = Node(0);
return Cnt;
}
inline int Extend(char* S) {
int l = strlen(S + 1);
for (register int i = 1; i <= l; ++i) {
int c = S[i] - 'a', p = Last;
for (; S[i] ^ S[i - nd[p].L - 1]; p = nd[p].Fa)
;
if (!nd[p].Ch[c]) {
int Cur = NewNode(), q = nd[p].Fa;
nd[Cur].L = nd[p].L + 2;
for (; S[i] ^ S[i - nd[q].L - 1]; q = nd[q].Fa)
;
nd[Cur].Fa = nd[q].Ch[c], nd[p].Ch[c] = Cur;
Dif[Cur] = nd[Cur].L - nd[nd[Cur].Fa].L;
Anc[Cur] = Dif[Cur] == Dif[nd[Cur].Fa] ? Anc[nd[Cur].Fa] : nd[Cur].Fa;
}
for (p = Last = nd[p].Ch[c]; p; p = Anc[p]) {
Aux[p] = F[i - nd[Anc[p]].L - Dif[p]];
if (Anc[p] ^ nd[p].Fa) Aux[p] = (Aux[p] + Aux[nd[p].Fa]) % MOD;
if (!(i & 1)) F[i] = (F[i] + Aux[p]) % MOD;
}
}
return F[l];
}
};
const int MAXL = 1e6;
char tmp[MAXL + 5], S[MAXL + 5];
Palindrome_Automaton PAM;
inline void Work() {
scanf("%s", tmp);
int l = strlen(tmp);
for (register int i = 0; i ^ l; ++i)
S[i < l >> 1 ? i << 1 | 1 : (l << 1) - (i << 1)] = tmp[i];
PAM.Init();
printf("%d\n", PAM.Extend(S));
}
int main() {
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
template <typename T>
inline void Read(T &x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
const int N = 1000010;
int n, lst, cnt, f[N], g[N], h[N], anc[N], par[N], dif[N], len[N], nxt[N][26];
char s[N], p[N], q[N];
inline void Extend(int w, int n) {
int p;
for (p = lst; s[n] != s[n - len[p] - 1]; p = par[p])
;
if (!nxt[p][w]) {
int x = ++cnt, k = par[p];
for (; s[n] != s[n - len[k] - 1]; k = par[k])
;
len[x] = len[p] + 2, par[x] = nxt[k][w], nxt[p][w] = x,
dif[x] = len[x] - len[par[x]],
anc[x] = dif[x] == dif[par[x]] ? anc[par[x]] : par[x];
}
lst = nxt[p][w];
}
int main() {
int i, j;
scanf("%s", p + 1);
n = strlen(p + 1);
for (i = 1; i <= n; i++)
if (i & 1)
s[i] = p[i / 2 + 1];
else
s[i] = p[n - i / 2 + 1];
lst = cnt = 1, par[0] = 1, par[1] = 0, len[1] = -1, f[0] = 1;
s[0] = -1;
for (int i = 1; i <= n; ++i) {
Extend(s[i] - 'a', i);
for (int x = lst; x; x = anc[x]) {
g[x] = f[i - len[anc[x]] - dif[x]];
if (anc[x] != par[x]) {
g[x] = (g[x] + g[par[x]]) % mod;
}
if (!(i & 1)) {
f[i] = (f[i] + g[x]) % mod;
}
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 1e6;
long long ans;
long long pw[maxn + 5];
char s[maxn + 5], t[maxn + 5];
struct Palindromic_Tree {
int ch[maxn + 5][26];
int s[maxn + 5];
int fail[maxn + 5];
int cnt[maxn + 5];
int num[maxn + 5];
int len[maxn + 5];
int diff[maxn + 5];
int anc[maxn + 5];
int last;
int n;
int p;
int newnode(int l) {
for (int i = 0; i < 26; ++i) ch[p][i] = 0;
cnt[p] = 0;
num[p] = 0;
diff[p] = anc[p] = 0;
len[p] = l;
return p++;
}
void init() {
for (int i = 0; i <= p; ++i)
fail[i] = cnt[i] = num[i] = len[i] = diff[i] = anc[i] = 0;
for (int i = 0; i <= p; ++i)
for (int j = 0; j < 26; ++j) ch[i][j] = 0;
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 c) {
c -= 'a';
s[++n] = c;
int cur = get_fail(last);
if (!ch[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = ch[get_fail(fail[cur])][c];
ch[cur][c] = now;
num[now] = num[fail[now]] + 1;
diff[now] = len[now] - len[fail[now]];
anc[now] = diff[now] == diff[fail[now]] ? anc[fail[now]] : fail[now];
}
last = ch[cur][c];
cnt[last]++;
}
void count() {
for (int i = p - 1; i >= 0; --i) cnt[fail[i]] += cnt[i];
}
} PT;
int f[maxn + 5], dp[maxn + 5];
int main() {
scanf("%s", t + 1);
int len = strlen(t + 1);
if (len & 1) return 0 * printf("0");
for (int i = 1; i <= len / 2; ++i) s[2 * i - 1] = t[i];
for (int i = len; i > len / 2; --i) s[(len - i + 1) * 2] = t[i];
PT.init();
dp[0] = 1;
for (int i = 1; i <= len; ++i) {
PT.add(s[i]);
for (int p = PT.last; p > 1; p = PT.anc[p]) {
f[p] = dp[i - PT.len[PT.anc[p]] - PT.diff[p]];
if (PT.diff[p] == PT.diff[PT.fail[p]])
f[p] = (f[p] + f[PT.fail[p]]) % mod;
if (i % 2 == 0) dp[i] = (dp[i] + f[p]) % mod;
}
}
cout << dp[len] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
char S[1000005];
char S2[1000005];
int N, ind, cur, Serial[1000005], DP[1000005], suff;
struct PTree {
int suf, next[26], len, slink, diff;
} Palind[1000005];
void initTree() {
cur = suff = 2;
Palind[1].suf = 1;
Palind[1].len = -1;
Palind[2].suf = 1;
Palind[2].len = 0;
}
void Read() {
cin.getline(S + 1, 1000005);
N = strlen(S + 1);
}
void precalcS() {
int left = 1, right = N;
while (left <= right) {
if (left > right) break;
S2[++ind] = S[left];
++left;
if (left > right) break;
S2[++ind] = S[right];
--right;
}
}
void precalcSLink(int i) {
Palind[i].diff = Palind[i].len - Palind[Palind[i].suf].len;
if (Palind[i].diff == Palind[Palind[i].suf].diff)
Palind[i].slink = Palind[Palind[i].suf].slink;
else
Palind[i].slink = Palind[i].suf;
}
void addLetter(int pos) {
int let = S2[pos] - 'a';
int curr = suff, len;
while (1) {
if (pos - Palind[curr].len - 1 >= 1 &&
S2[pos] == S2[pos - Palind[curr].len - 1])
break;
curr = Palind[curr].suf;
}
if (Palind[curr].next[let] != 0) {
suff = Palind[curr].next[let];
return;
}
suff = ++cur;
Palind[cur].len = Palind[curr].len + 2;
Palind[curr].next[let] = cur;
if (Palind[cur].len == 1) {
Palind[cur].suf = 2;
Palind[cur].slink = 2;
Palind[cur].diff = 1;
precalcSLink(cur);
return;
}
while (1) {
curr = Palind[curr].suf;
len = Palind[curr].len;
if (pos - len - 1 >= 1 && S2[pos - len - 1] == S2[pos]) {
Palind[cur].suf = Palind[curr].next[let];
precalcSLink(cur);
return;
}
}
}
void Solve() {
DP[0] = 1;
for (int i = 1; i <= N; i++) {
addLetter(i);
int v = suff;
DP[i] = 0;
while (v > 2) {
Serial[v] = DP[i - (Palind[Palind[v].slink].len + Palind[v].diff)];
if (Palind[v].suf != Palind[v].slink) {
Serial[v] = Serial[v] + Serial[Palind[v].suf];
if (Serial[v] >= MOD) Serial[v] -= MOD;
}
DP[i] = DP[i] + Serial[v];
if (DP[i] >= MOD) DP[i] -= MOD;
v = Palind[v].slink;
}
if (i & 1) DP[i] = 0;
}
cout << DP[N] << "\n";
}
int main() {
Read();
precalcS();
initTree();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
const int MOD = 1e9 + 7;
inline int add(int a, int b) { return (a += b) >= MOD ? a - MOD : a; }
inline void inc(int& a, int b) { a = add(a, b); }
struct PAM {
struct node {
int ch[26], fail, len, dif, anc;
} t[MAXN];
int totn, lst;
inline int newnode(int nl) {
int u = ++totn;
t[u].len = nl;
t[u].fail = t[u].dif = t[u].anc = 0;
memset(t[u].ch, 0, sizeof t[u].ch);
return u;
}
inline void reset() {
totn = -1;
newnode(0);
newnode(-1);
t[0].fail = 1;
t[1].fail = 1;
lst = 1;
}
char s[MAXN];
inline int getFail(int u, int x) {
while (s[x - t[u].len - 1] != s[x]) u = t[u].fail;
return u;
}
int f[MAXN], g[MAXN];
inline void extend(int c, int pos) {
int cur = getFail(lst, pos);
if (!t[cur].ch[c]) {
int now = newnode(t[cur].len + 2);
t[now].fail = t[getFail(t[cur].fail, pos)].ch[c];
t[now].dif = t[now].len - t[t[now].fail].len;
t[now].anc =
t[now].dif == t[t[now].fail].dif ? t[t[now].fail].anc : t[now].fail;
t[cur].ch[c] = now;
}
lst = t[cur].ch[c];
for (int p = lst; p > 1; p = t[p].anc) {
g[p] = f[pos - t[t[p].anc].len - t[p].dif];
if (t[p].fail != t[p].anc) inc(g[p], g[t[p].fail]);
if (!(pos & 1)) inc(f[pos], g[p]);
}
}
inline void build(char* ns, int len) {
for (int i = 1; i <= len; i++) s[i] = ns[i];
reset();
f[0] = 1;
for (int i = 1; i <= len; i++) extend(s[i] - 'a', i);
}
} S;
char s[MAXN], t[MAXN];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= (n >> 1); i++)
t[(i << 1) - 1] = s[i], t[i << 1] = s[n - i + 1];
S.build(t, n);
printf("%d\n", S.f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 2;
const int M = 1000000007;
const int A = 26;
void add(int &a, int b) {
a += b;
if (a >= M) {
a -= M;
}
}
int series_link[N], series[N], diff[N];
int link[N], length[N], to[N][A];
string t;
int get(int u, int i) {
while (true) {
int j = i - 1 - length[u];
if (j >= 0 && t[j] == t[i]) {
break;
}
u = link[u];
}
return u;
}
int ways[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < n / 2; ++i) {
t += s[i], t += s[n - 1 - i];
}
int u = 0, m = 2;
length[1] = -1;
link[0] = 1;
ways[0] = 1;
for (int i = 0; i < n; ++i) {
u = get(u, i);
if (to[u][t[i] - 'a'] == 0) {
length[m] = length[u] + 2;
link[m] = to[get(link[u], i)][t[i] - 'a'];
diff[m] = length[m] - length[link[m]];
if (diff[m] == diff[link[m]]) {
series_link[m] = series_link[link[m]];
} else {
series_link[m] = link[m];
}
to[u][t[i] - 'a'] = m++;
}
u = to[u][t[i] - 'a'];
for (int v = u; length[v] > 0; v = series_link[v]) {
series[v] = ways[i + 1 - length[series_link[v]] - diff[v]];
if (diff[v] == diff[link[v]]) {
add(series[v], series[link[v]]);
}
add(ways[i + 1], series[v]);
}
if (i % 2 == 0) {
ways[i + 1] = 0;
}
}
cout << ways[n] << "\n";
}
|
#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], cnt;
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);
int l = 1, r = n;
for (int i = 1; i <= n / 2; i++) {
t[2 * i - 1] = s[i];
t[2 * i] = s[n + 1 - i];
}
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 int N = 1234567, mod = 1e9 + 7;
void add(int& x, int y) {
x += y;
if (x >= mod) {
x -= mod;
}
}
int n, last, tt, ch[N][26], father[N], len[N], diff[N], anc[N], sum[N], dp[N];
string r, s, t;
int new_node(int from) {
len[++tt] = len[from] + 2;
return tt;
}
int extend(int i, int c) {
int p = last;
while (t[i - 1 - len[p]] - 'a' != c) {
p = father[p];
}
if (!ch[p][c]) {
int np = new_node(p), q = father[p];
while (t[i - 1 - len[q]] - 'a' != c) {
q = father[q];
}
father[np] = ch[q][c];
diff[np] = len[np] - len[father[np]];
anc[np] = diff[np] == diff[father[np]] ? anc[father[np]] : father[np];
ch[p][c] = np;
}
return last = ch[p][c];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> r;
n = r.length();
if (n & 1) {
cout << 0 << '\n';
exit(0);
}
for (int i = 0; i < (n >> 1); ++i) {
s.push_back(r[i]);
s.push_back(r[n - i - 1]);
}
tt = 1;
len[1] = -1;
father[0] = 1;
t.push_back('z' + 1);
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
t.push_back(s[i - 1]);
int here = extend(i, s[i - 1] - 'a');
for (int j = here; j > 1; j = anc[j]) {
sum[j] = dp[i - (len[anc[j]] + diff[j])];
if (father[j] != anc[j]) {
add(sum[j], sum[father[j]]);
}
if (!(i & 1)) {
add(dp[i], sum[j]);
}
}
}
cout << dp[n] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
const int maxn = 1000111;
char s[maxn];
int n, tot, go[maxn][26], fail[maxn], slink[maxn], len[maxn], dlen[maxn];
int st[maxn];
int append(int p, int l) {
int c = s[l] - 'a';
while (s[l - len[p] - 1] != s[l]) p = fail[p];
if (!go[p][c]) {
int np = ++tot;
len[np] = len[p] + 2;
int t = fail[p];
while (s[l - len[t] - 1] != s[l]) t = fail[t];
fail[np] = go[t][c];
dlen[np] = len[np] - len[fail[np]];
slink[np] = dlen[np] == dlen[fail[np]] ? slink[fail[np]] : fail[np];
go[p][c] = np;
}
return go[p][c];
}
int dp[maxn], gdp[maxn];
void upd(int &x, int v) { x = x + v >= mod ? x + v - mod : x + v; }
int main() {
static char ss[maxn];
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n / 2; i++) ss[i * 2 - 1] = s[i];
reverse(s + n / 2 + 1, s + n + 1);
for (int i = 1; i <= n / 2; i++) ss[i * 2] = s[i + n / 2];
swap(s, ss);
int p = 1;
tot = 1;
len[1] = -1;
fail[0] = 1;
st[0] = 1;
for (int i = 1; i <= n; i++) {
p = append(p, i);
st[i] = p;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
for (int p = st[i]; p; p = slink[p]) {
int cur = dp[i - (len[slink[p]] + dlen[p])];
gdp[p] = cur;
if (dlen[p] == dlen[fail[p]]) {
upd(gdp[p], gdp[fail[p]]);
}
if (i % 2 == 0) upd(dp[i], gdp[p]);
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s[1000005], top[1000005], f[1000005], g[1000005];
int c[1000005][26], F[1000005], len[1000005], cnt, pos[1000005];
char str[1000005];
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
s[0] = -1;
for (int i = 1; i <= n / 2; i++) {
s[i * 2 - 1] = str[i] - 'a';
s[i * 2] = str[n - i + 1] - 'a';
}
len[0] = -1;
cnt = 1;
for (int i = 1, now = 1; i <= n; i++) {
while (s[i - len[now] - 1] != s[i]) now = F[now];
if (!c[now][s[i]]) {
cnt++;
len[cnt] = len[now] + 2;
int tmp = F[now];
while (s[i - len[tmp] - 1] != s[i]) tmp = F[tmp];
F[cnt] = c[tmp][s[i]] ? c[tmp][s[i]] : 1;
c[now][s[i]] = cnt;
}
pos[i] = now = c[now][s[i]];
}
top[1] = 1;
for (int i = 2; i <= cnt; i++)
if (F[i] != 1 && len[i] + len[F[F[i]]] == len[F[i]] * 2)
top[i] = top[F[i]];
else
top[i] = i;
f[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = pos[i]; j != 1; j = F[top[j]]) {
if (top[j] != j)
g[j] = (g[F[j]] + f[i - len[top[j]]]) % 1000000007;
else
g[j] = f[i - len[j]];
f[i] = (f[i] + g[j]) % 1000000007;
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int mod = 1e9 + 7;
namespace pam {
int ch[N][26], fail[N], dif[N], slink[N], cnt[N], dep[N], len[N];
int sz, tot, lst;
char s[N];
int new_node(int lenn) {
++sz;
memset(ch[sz], 0, sizeof(ch[sz]));
len[sz] = lenn;
cnt[sz] = dep[sz] = fail[sz] = 0;
return sz;
}
void clear() {
lst = tot = 0;
sz = -1;
s[tot] = '$';
new_node(0);
new_node(-1);
fail[0] = 1;
}
int get_fail(int x) {
while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
return x;
}
void insert(char c) {
s[++tot] = c;
int now = get_fail(lst), v = (int)c - (int)'a';
if (!ch[now][v]) {
int x = new_node(len[now] + 2);
fail[x] = ch[get_fail(fail[now])][v];
dep[x] = dep[fail[x]] + 1;
ch[now][v] = x;
dif[x] = len[x] - len[fail[x]];
if (dif[x] == dif[fail[x]])
slink[x] = slink[fail[x]];
else
slink[x] = fail[x];
}
lst = ch[now][v];
++cnt[lst];
}
} // namespace pam
inline void upd(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
return;
}
using pam::dif;
using pam::fail;
using pam::len;
using pam::slink;
int n;
int dp[N], g[N];
char s[N], t[N << 1];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
pam::clear();
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]);
for (int x = pam::lst; x > 1; x = slink[x]) {
g[x] = dp[i - len[slink[x]] - dif[x]];
if (dif[x] == dif[fail[x]]) upd(g[x], g[fail[x]]);
if (!(i & 1)) upd(dp[i], g[x]);
}
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long p1 = 1000000, p2 = 0;
char buf[1000005], wb[1000005];
long long gc() {
if (p1 >= 1000000) fread(buf, 1, 1000000, stdin), p1 = 0;
return buf[p1++];
}
long long getint() {
long long ret = 0, flag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
ret = (ret << 3) + (ret << 1) + c - '0';
c = getchar();
}
return ret * flag;
}
void pc(char x) {
if (p2 >= 1000000) fwrite(wb, 1, 1000000, stdout), p2 = 0;
wb[p2++] = x;
}
void wrt(long long x) {
if (x < 0) pc('-'), x = -x;
long long c[24] = {0};
if (!x) return pc('0'), void();
while (x) c[++c[0]] = x % 10, x /= 10;
while (c[0]) pc(c[c[0]--] + '0');
}
int n, g[1000005], f[1000005];
struct PAM {
int tot, lst, len, s[1000005];
struct node {
int ch[26], fail, num, len, jp, dec;
} v[1000005];
int new_node(int x) {
++tot;
for (int i = 0; i < 26; i++) v[tot].ch[i] = 0;
v[tot].fail = v[tot].num = 0;
v[tot].len = x;
return tot;
}
void init() {
tot = -1, s[len = 0] = -1, lst = 0;
new_node(0), new_node(-1);
v[0].fail = v[1].fail = 1;
}
int get_fail(int x) {
while (s[len] != s[len - v[x].len - 1]) x = v[x].fail;
return x;
}
int ins(int x, int id) {
int now, p;
s[++len] = x;
p = get_fail(lst);
if (!v[p].ch[x]) {
now = new_node(v[p].len + 2);
v[now].fail = v[get_fail(v[p].fail)].ch[x];
v[now].num = v[v[now].fail].num + 1;
v[p].ch[x] = now;
v[now].dec = v[now].len - v[v[now].fail].len;
v[now].jp =
(v[now].dec == v[v[now].fail].dec) ? v[v[now].fail].jp : v[now].fail;
}
now = v[p].ch[x];
return lst = v[p].ch[x];
}
} P;
char lc[1000005], c[1000005];
void ask(int p, int now) {
while (now) {
g[now] = f[p - P.v[P.v[now].jp].len - P.v[now].dec];
if (P.v[now].jp != P.v[now].fail)
g[now] = (g[now] + g[P.v[now].fail]) % int(1e9 + 7);
if (!(p & 1)) f[p] = (f[p] + g[now]) % int(1e9 + 7);
now = P.v[now].jp;
}
}
int main() {
P.init();
f[0] = 1, g[0] = 1;
scanf("%s", lc + 1);
n = strlen(lc + 1);
for (int i = 1; i <= n >> 1; i++)
c[(i << 1) - 1] = lc[i], c[(i << 1)] = lc[n - i + 1];
for (int i = 1; i <= n; i++) ask(i, P.ins(c[i] - 97, i));
wrt(f[n]), pc('\n');
fwrite(wb, 1, p2, stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
template <typename T>
inline void Add(T &x, T y) {
x += y;
if (x >= mod) x -= mod;
}
namespace PAM {
int ne[1000010][26], fail[1000010], len[1000010], las, cnt, n, d[1000010],
anc[1000010], t[1000010];
long long info[1000010];
void init() {
t[n = 0] = -1;
len[cnt = 1] = -1;
fail[las = 0] = 1;
}
inline int getfail(int x) {
for (; t[n - len[x] - 1] != t[n];) x = fail[x];
return x;
}
inline void extend(int c) {
t[++n] = c;
int p = getfail(las);
if (!ne[p][c]) {
int u = ++cnt, q = getfail(fail[p]);
len[u] = len[p] + 2;
fail[u] = ne[q][c];
ne[p][c] = u;
d[u] = len[u] - len[fail[u]];
anc[u] = (d[u] == d[fail[u]]) ? anc[fail[u]] : fail[u];
}
las = ne[p][c];
}
} // namespace PAM
using PAM::anc;
using PAM::d;
using PAM::extend;
using PAM::fail;
using PAM::info;
using PAM::init;
using PAM::las;
using PAM::len;
long long f[1000010];
int n;
char t[1000010], s[1000010];
int main() {
scanf("%s", t + 1);
int n = strlen(t + 1);
for (int i = 1; i <= (n >> 1); i++)
s[(i << 1) - 1] = t[i], s[i << 1] = t[n - i + 1];
init();
f[0] = 1;
for (int i = 1; i <= n; i++) {
extend(s[i] - 'a');
for (int j = las; len[j] > 0; j = anc[j]) {
info[j] = f[i - len[anc[j]] - d[j]];
if (anc[j] != fail[j]) Add(info[j], info[fail[j]]);
if (!(i & 1)) Add(f[i], info[j]);
}
}
printf("%lld\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type const& x() const {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type& x() {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type const& y() const {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type& y() {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type const& z() const {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type& z() {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type const& w() const {
return get<3>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type& w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...> >
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
const int N = 1e6 + 128;
map<int, int> to[N];
int link[N];
int diff[N];
int slink[N];
int len[N];
int last[N];
int n, m;
int s[N];
void init() {
link[0] = link[1] = 0;
last[0] = 0;
len[0] = -1;
len[1] = 0;
diff[0] = diff[1] = -1;
slink[0] = slink[1] = -1;
n = 0;
m = 2;
}
void add(int x) {
s[n] = x;
n += 1;
last[n] = last[n - 1];
for (;; last[n] = link[last[n]]) {
if (s[n - 2 - len[last[n]]] == x) {
if (!to[last[n]].count(x)) {
int v = m;
m++;
to[last[n]][x] = v;
len[v] = len[last[n]] + 2;
if (len[v] == 1) {
link[v] = 1;
} else {
link[v] = link[last[n]];
while (s[n - 2 - len[link[v]]] != x) link[v] = link[link[v]];
link[v] = to[link[v]][x];
}
diff[v] = len[v] - len[link[v]];
if (diff[v] == diff[link[v]]) {
slink[v] = slink[link[v]];
} else {
slink[v] = link[v];
}
last[n] = v;
} else {
last[n] = to[last[n]][x];
}
return;
}
}
}
const lli MOD = 1e9 + 7;
lli nmod(lli x) { return (x % MOD + MOD) % MOD; }
struct Zn {
lli x;
Zn() : x(0) {}
Zn(lli x_) : x(x_) {
x %= MOD;
if (x < 0) x = (x + MOD) % MOD;
}
Zn operator+(Zn const& o) const { return Zn(x + o.x); }
Zn operator-(Zn const& o) const { return Zn(x - o.x); }
Zn operator*(Zn const& o) const { return Zn(x * o.x); }
Zn& operator+=(Zn const& o) { return *this = *this + o; }
Zn& operator-=(Zn const& o) { return *this = *this - o; }
Zn& operator*=(Zn const& o) { return *this = *this * o; }
};
Zn dp[N];
Zn ans[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
init();
string t;
for (lli i = 0; i < (lli)(n / 2); ++i) {
t.push_back(s[i]);
t.push_back(s[s.size() - 1 - i]);
}
ans[0] = 1;
dp[0] = dp[1] = 0;
for (lli i = 0; i < (lli)(n); ++i) {
add(t[i]);
ans[i + 1] = 0;
for (int v = last[i + 1]; v > 1; v = slink[v]) {
dp[v] = 0;
if (((i + 1) - (len[slink[v]] + diff[v])) % 2 == 0) {
dp[v] = ans[(i + 1) - (len[slink[v]] + diff[v])];
}
if (diff[v] == diff[link[v]]) dp[v] += dp[link[v]];
if ((i + 1) % 2 == 0) ans[i + 1] += dp[v];
}
}
cout << ans[n].x << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int MAXN = 1000006, Mo = 1e9 + 7;
namespace PAM {
static const int H = 26;
int last, Slen, size;
int nt[MAXN][H], fl[MAXN], len[MAXN], S[MAXN];
int seriesLink[MAXN], f[MAXN], g[MAXN];
int newnode(int l) {
for (int i = (0); i <= (H - 1); ++i) nt[size][i] = 0;
len[size] = l;
return size++;
}
inline int diff(int x) { return len[x] - len[fl[x]]; }
void init() {
size = last = Slen = 0;
newnode(0), newnode(-1);
S[Slen] = -1, fl[0] = 1, fl[1] = 1;
f[0] = 1, g[0] = g[1] = 0;
}
int getFail(int x) {
while (S[Slen - len[x] - 1] != S[Slen]) x = fl[x];
return x;
}
inline void update(int x[], int y, int z) {
if (x[0] > y) x[0] = y, x[1] = z;
}
int getSum(int x) {
int y = Slen - (len[seriesLink[x]] + diff(x));
g[x] = f[y];
if (diff(x) == diff(fl[x])) {
g[x] += g[fl[x]];
if (g[x] >= Mo) g[x] -= Mo;
}
return g[x];
}
void add(int c) {
S[++Slen] = (c -= 'a');
int cur = getFail(last);
if (!nt[cur][c]) {
int now = newnode(len[cur] + 2);
fl[now] = nt[getFail(fl[cur])][c], nt[cur][c] = now;
if (diff(now) == diff(fl[now]))
seriesLink[now] = seriesLink[fl[now]];
else
seriesLink[now] = fl[now];
}
last = nt[cur][c];
f[Slen] = 0;
int tmp = 0;
for (int now = last; len[now] > 0; now = seriesLink[now]) {
int gS = getSum(now);
if (!(Slen & 1)) {
tmp += gS;
if (tmp >= Mo) tmp -= Mo;
}
}
f[Slen] = tmp;
}
void print() {
for (int i = (1); i <= (Slen); ++i) putchar('a' + S[i]);
puts("");
for (int i = (1); i <= (Slen); ++i) printf("%d%c", f[i], " \n"[i == Slen]);
for (int i = (0); i <= (size - 1); ++i) {
printf("%d:fail[%d]=%d,len[%d]=%d\n", i, i, fl[i], i, len[i]);
for (int j = (0); j <= (H - 1); ++j)
if (nt[i][j]) printf("(%c%d)", 'a' + j, nt[i][j]);
puts("");
}
}
}; // namespace PAM
int n, m;
char s[MAXN];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
PAM::init();
for (int i = (1); i <= (n / 2); ++i) PAM::add(s[i]), PAM::add(s[n + 1 - i]);
printf("%d\n", PAM::f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1E9 + 7;
const int maxn = 1E6 + 77;
struct Node {
int s, d, c;
int last() { return (d == -1) ? (s) : (s + d * (c - 1)); }
} G[maxn], aux[maxn];
int cg = 0, caux = 0;
char SS[maxn], S[maxn];
int L;
long long dp[maxn], F[maxn];
int main() {
scanf("%s", SS);
int l = strlen(SS);
if (l & 1) {
printf("0\n");
return 0;
}
for (int i = 0, j = l - 1; i < j; ++i, --j) {
S[++L] = SS[i];
S[++L] = SS[j];
}
dp[0] = 1;
for (int i = 2; i <= L; ++i) {
caux = 0;
for (int g = 0; g < cg; ++g) {
--G[g].s;
if (S[i] == S[G[g].s]) {
if (G[g].c >= 2) {
int s = G[g].s;
G[g].s += G[g].d;
G[g].c--;
aux[caux] = (Node){s, caux ? (s - aux[caux - 1].last()) : -1, 1};
caux++;
aux[caux++] = G[g];
} else {
aux[caux] =
(Node){G[g].s, caux ? (G[g].s - aux[caux - 1].last()) : -1, 1};
caux++;
}
}
}
if (S[i] == S[i - 1]) {
aux[caux] = (Node){i - 1, caux ? (i - 1 - aux[caux - 1].last()) : -1, 1};
caux++;
}
cg = 0;
if (caux) {
assert(aux[0].c > 0);
G[cg++] = aux[0];
}
for (int g = 1; g < caux; ++g) {
assert(aux[g].c > 0);
assert(G[cg - 1].last() + aux[g].d == aux[g].s);
if (aux[g].d == G[cg - 1].d)
G[cg - 1].c += aux[g].c;
else
G[cg++] = aux[g];
}
for (int g = 0; g < cg; ++g) {
assert(G[g].c > 0);
assert((G[g].c == 1) || ((G[g].d & 1) == 0));
assert(((i - G[g].s) & 1) == 1);
if (G[g].c == 1) {
dp[i] += dp[G[g].s - 1];
if (dp[i] >= mod) dp[i] -= mod;
} else {
if (G[g].c == 2) {
F[G[g].s - G[g].d] = dp[G[g].s - 1];
}
dp[i] += F[G[g].s - G[g].d];
if (dp[i] >= mod) dp[i] -= mod;
dp[i] += dp[G[g].last() - 1];
if (dp[i] >= mod) dp[i] -= mod;
F[G[g].s - G[g].d] += dp[G[g].last() - 1];
if (F[G[g].s - G[g].d] >= mod) F[G[g].s - G[g].d] -= mod;
}
}
}
int ans = dp[L];
printf("%d\n", ans);
}
|
#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 = 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 = 0;
t[1].len = -1;
}
int n = (int)s.size();
s = "#" + join_halfs(s);
vector<int> dp(n + 1);
dp[0] = 1;
max_suff = 0;
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[s[i]];
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) {
{
int j = i - t[t[x].slink].len - t[x].diff;
t[x].dp = dp[j];
}
if (t[x].diff == t[t[x].link].diff) {
_inc(t[x].dp, t[t[x].link].dp);
}
if (i % 2 == 0) {
_inc(dp[i], t[x].dp);
}
}
}
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 mod = 1e9 + 7;
inline int read() {
int w = 1, s = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return w * s;
}
int n, diff[2010100], cnt, fail[2010100], len[2001010], Slink[2001010],
pos[1010010], las, ch[1010010][26], g[2000100], f[2000100];
char s[1010000], tmp[1001010];
inline int pls(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
inline void Insert(int c, int idx) {
int p = las;
while (tmp[idx] != tmp[idx - len[p] - 1]) p = fail[p];
if (!ch[p][c]) {
int np = ++cnt, k = fail[p];
len[np] = len[p] + 2;
while (tmp[idx] != tmp[idx - len[k] - 1]) k = fail[k];
fail[np] = ch[k][c];
ch[p][c] = np;
diff[np] = len[np] - len[fail[np]];
Slink[np] = (diff[np] == diff[fail[np]]) ? Slink[fail[np]] : fail[np];
}
las = ch[p][c];
pos[idx] = las;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int cur = 0;
for (register int i = 1; i <= n; i += 2) tmp[i] = s[++cur];
cur = n + 1;
for (register int i = 2; i <= n; i += 2) tmp[i] = s[--cur];
fail[0] = 1;
len[1] = -1;
cnt = 1;
for (register int i = 1; i <= n; ++i) Insert(tmp[i] - 'a', i);
f[0] = 1;
for (register int i = 1; i <= n; ++i) {
for (register int p = pos[i]; p; p = Slink[p]) {
g[p] = f[i - (len[Slink[p]] + diff[p])];
g[p] = pls(g[p], diff[p] == diff[fail[p]] ? g[fail[p]] : 0);
if ((i & 1)) continue;
f[i] = pls(g[p], f[i]);
}
}
cout << f[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0;
x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f |= (ch == '-');
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
const int mod = 1e9 + 7;
int fix(int x) { return x >= mod ? x - mod : x; }
const int N = 1e6 + 5;
namespace PAM {
int t[N][26], fa[N], anc[N], len[N], d[N];
int pos[N], sz, las;
void init(char s[], int n) {
len[++sz] = -1, fa[1] = fa[0] = 1;
for (int i = (1); i <= (n); i++) {
int p = las, c = s[i] - 'a';
for (; s[i - 1 - len[p]] != s[i]; p = fa[p])
;
if (!t[p][c]) {
int nw = ++sz, q = fa[p];
for (; s[i - 1 - len[q]] != s[i]; q = fa[q])
;
len[nw] = len[p] + 2;
fa[nw] = t[q][c], t[p][c] = nw;
d[nw] = len[nw] - len[fa[nw]];
anc[nw] = (d[nw] == d[fa[nw]] ? anc[fa[nw]] : fa[nw]);
}
pos[i] = las = t[p][c];
}
}
} // namespace PAM
using namespace PAM;
char s[N], st[N];
int f[N], g[N], n;
int main() {
scanf("%s", st + 1);
n = strlen(st + 1);
for (int i = 1, j = n, k = 1; i <= j; i++, j--)
s[k++] = st[i], s[k++] = st[j];
init(s, n), f[0] = 1;
for (int i = (1); i <= (n); i++) {
for (int u = pos[i]; len[u]; u = anc[u]) {
g[u] = f[i - (len[anc[u]] + d[u])];
if (d[u] == d[fa[u]]) g[u] = fix(g[u] + g[fa[u]]);
if (!(i & 1)) f[i] = fix(f[i] + g[u]);
}
}
cout << f[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1001000, P = 1e9 + 7;
int n, cnt, x, y, u;
int Fa[N], s[N][30], l[N], fa[N], tp[N];
int p[N], f[N], g[N], ok[N], d[N];
char S[N], T[N];
void ins(int c, int p) {
for (x = y; S[p] != S[p - l[x] - 1]; x = Fa[x])
;
if (s[x][c]) return y = s[x][c], void();
l[s[x][c] = y = ++cnt] = l[x] + 2;
ok[y] = ok[x];
if (x == 1) return;
for (x = Fa[x]; S[p] != S[p - l[x] - 1]; x = Fa[x])
;
Fa[y] = s[x][c];
}
int main() {
scanf("%s", T + 1);
n = strlen(T + 1);
if (n & 1) return puts("0");
for (int i = 1; i <= n / 2; i++) S[i * 2 - 1] = T[i], S[i * 2] = T[n - i + 1];
l[Fa[0] = ok[0] = y = cnt = 1] = -1;
for (int i = 1; i <= n; i++) ins(S[i] - 'a', i), p[i] = y;
for (int i = 1; i <= cnt; i++) {
fa[i] = ok[Fa[i]] ? Fa[i] : fa[Fa[i]];
d[i] = l[i] - l[fa[i]];
if (ok[i] && fa[i] != 0) tp[i] = d[i] == d[fa[i]] ? tp[fa[i]] : fa[i];
}
f[0] = 1;
for (int i = 1; i <= n; i++)
if (!(i & 1)) {
f[i] = 0;
for (u = ok[p[i]] ? p[i] : fa[p[i]]; u; u = tp[u]) {
if (d[u] != d[fa[u]])
(f[i] += (g[u] = f[i - l[u]])) %= P;
else
(f[i] += (g[u] = (g[fa[u]] + f[i - l[tp[u]] - d[u]]) % P)) %= P;
}
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100000;
const int mod = 1e9 + 7;
int n, m;
char S[maxn];
int str[maxn];
int id[maxn], f[maxn], g[maxn];
struct pTree {
int fail[maxn], trans[maxn][26], diff[maxn], nxt[maxn], len[maxn];
int cnt, last;
void init() {
cnt = 1;
last = 0;
memset(trans[0], 0, sizeof trans[0]);
memset(trans[1], 0, sizeof trans[1]);
len[0] = 0, len[1] = -1;
fail[0] = 1;
}
int newnode(int l) {
++cnt;
memset(trans[cnt], 0, sizeof trans[cnt]);
len[cnt] = l;
return cnt;
}
int extend(int i) {
int p = last, np, w = str[i];
while (str[i - len[p] - 1] != str[i]) p = fail[p];
if (!trans[p][w]) {
np = newnode(len[p] + 2);
int t = fail[p];
while (str[i - len[t] - 1] != str[i]) t = fail[t];
fail[np] = trans[t][w];
diff[np] = len[np] - len[fail[np]];
if (diff[np] == diff[fail[np]])
nxt[np] = nxt[fail[np]];
else
nxt[np] = fail[np];
trans[p][w] = np;
} else
np = trans[p][w];
return last = np;
}
} tr;
int main() {
scanf("%s", S);
n = strlen(S);
if (n & 1) return puts("0"), 0;
str[m = 0] = -1;
for (int i = 0; i < n / 2; i++)
str[++m] = S[i] - 'a', str[++m] = S[n - i - 1] - 'a';
tr.init();
for (int i = 1; i <= m; i++) id[i] = tr.extend(i);
f[0] = 1;
for (int i = 1; i <= m; i++) {
for (int p = id[i]; p; p = tr.nxt[p]) {
g[p] = f[i - tr.len[tr.nxt[p]] - tr.diff[p]];
if (tr.diff[p] == tr.diff[tr.fail[p]]) (g[p] += g[tr.fail[p]]) %= mod;
if (!(i & 1)) (f[i] += g[p]) %= mod;
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx2,tune=native")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-funroll-loops")
const int N = 1e6 + 17;
const int mod = 1e9 + 7;
int n;
const int base = 313;
int makeH(char c) { return c; }
vector<int> pows = {1};
int Add(int x, int y) {
x = (x + y);
if (x >= mod) x -= mod;
if (x < 0) x += mod;
return x;
}
int Mul(int x, int y) { return 1ll * x * y % mod; }
struct HashRange {
string s;
vector<int> cum = {0};
void add(char c) {
s += c;
cum.push_back(Add(Mul(cum.back(), base), makeH(c)));
}
void add(string x) {
for (auto u : x) add(u);
}
void extend(int len) {
while ((int)pows.size() < (int)s.size()) {
pows.push_back(Mul(base, pows.back()));
}
}
int hash(int l, int r) {
int len = r - l + 1;
extend(len);
return Add(cum[r + 1], -Mul(cum[l], pows[len]));
}
bool operator==(HashRange &rhs) { return cum.back() == rhs.cum.back(); }
};
HashRange hr;
string st;
unordered_map<int, int> msi;
vector<int> v = {-1};
int t;
struct node {
map<int, int> nxt, prv;
int link = 0, len = 0;
int acc = 0;
int diff = 0;
int slink = 0;
node() {}
};
vector<node> eer;
int suff;
int series_ans[N], dp[N];
int s[N];
int c = 0;
int get_link(int x) {
while (s[c - eer[x].len - 2] != s[c - 1]) {
x = eer[x].link;
}
return x;
}
bool extend(int ch) {
s[c++] = ch;
suff = get_link(suff);
if (eer[suff].nxt[ch]) {
suff = eer[suff].nxt[ch];
return 0;
}
int lst = suff;
suff = eer.size();
eer.push_back(node());
eer[suff].len = 2 + eer[lst].len;
eer[suff].link = eer[get_link(eer[lst].link)].nxt[ch];
eer[lst].nxt[ch] = suff;
eer[suff].diff = eer[suff].len - eer[eer[suff].link].len;
if (eer[suff].diff == eer[eer[suff].link].diff)
eer[suff].slink = eer[eer[suff].link].slink;
else
eer[suff].slink = eer[suff].link;
return 1;
}
void process() {
eer.push_back(node()), eer.push_back(node());
eer[0].link = 1;
eer[1].len = -1;
s[c++] = -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> st;
hr.add(st);
n = st.size();
int l = 0;
for (int i = 0; i < n / 2; ++i) {
int lhs = hr.hash(l, i);
if (lhs == hr.hash(n - i - 1, n - l - 1)) {
if (msi[lhs] == 0) {
msi[lhs] = ++t;
}
v.push_back(msi[lhs]);
l = i + 1;
}
}
if (l != st.size() / 2) {
return cout << 0, 0;
}
dp[0] = 1;
process();
for (int i = 1; i < v.size(); ++i) {
extend(v[i]);
for (int u = suff; eer[u].len > 0; u = eer[u].slink) {
series_ans[u] = (dp[i - (eer[eer[u].slink].len + eer[u].diff)]) % mod;
if (eer[u].diff == eer[eer[u].link].diff)
series_ans[u] = (series_ans[u] + series_ans[eer[u].link]) % mod;
dp[i] = (dp[i] + series_ans[u]) % mod;
}
}
cout << dp[v.size() - 1];
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 cnt[MAXN], num[MAXN], trans[MAXN], diff[MAXN], slink[MAXN];
int newnode(int _len) {
len[pcnt] = _len;
cnt[pcnt] = num[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;
num[now] = num[fail[now]] + 1;
if (len[now] <= 2)
trans[now] = fail[now];
else {
int x = trans[cur];
while (S[scnt - len[x] - 1] != S[scnt] || (len[x] + 2) * 2 > len[now])
x = fail[x];
trans[now] = ch[x][c];
}
diff[now] = len[now] - len[fail[now]];
slink[now] = (diff[now] == diff[fail[now]]) ? slink[fail[now]] : fail[now];
}
last = ch[cur][c];
cnt[last]++;
}
void count() {
for (int i = pcnt - 1; i >= 0; i--) cnt[fail[i]] += cnt[i];
}
}; // 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;
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);
f[i + 1] = 0;
extend(s[sn - 1 - (i >> 1)] - 'a');
sol(i + 2, last);
}
cout << f[sn] << endl;
return 0;
}
|
#include <bits/stdc++.h>
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline void sub(long long &a, long long b) {
a -= b;
if (a < 0) a += 1000000007;
}
inline void add(long long &a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
template <typename T>
inline T const &MAX(T const &a, T const &b) {
return a > b ? a : b;
}
template <typename T>
inline T const &MIN(T const &a, T const &b) {
return a < b ? a : b;
}
inline long long qp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007, b >>= 1;
}
return ans;
}
inline long long qp(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c, b >>= 1;
}
return ans;
}
using namespace std;
const unsigned long long ba = 233;
const double eps = 1e-5;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1000000 + 10, maxn = 1000000 + 10, inf = 0x3f3f3f3f;
struct PAM {
int ch[N][26], fail[N], len[N], s[N], sf[N], dif[N];
long long dp[N], ta[N];
int last, n, p;
int newnode(int w) {
for (int i = 0; i < 26; i++) ch[p][i] = 0;
len[p] = w;
return p++;
}
void init() {
dp[0] = 1;
p = last = n = 0;
newnode(0);
newnode(-1);
s[n] = -1;
fail[0] = 1;
}
int getfail(int x) {
while (s[n - len[x] - 1] != s[n]) x = fail[x];
return x;
}
void ins(int c) {
s[++n] = c;
int cur = getfail(last);
if (!ch[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = ch[getfail(fail[cur])][c];
dif[now] = len[now] - len[fail[now]];
sf[now] = dif[now] == dif[fail[now]] ? sf[fail[now]] : fail[now];
ch[cur][c] = now;
}
last = ch[cur][c];
for (int now = last; now; now = sf[now]) {
ta[now] = dp[n - (len[sf[now]] + dif[now])];
if (dif[now] == dif[fail[now]]) add(ta[now], ta[fail[now]]);
if (n % 2 == 0) add(dp[n], ta[now]);
}
}
} pam;
char s[N];
int main() {
pam.init();
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n / 2; i++) {
pam.ins(s[i] - 'a');
pam.ins(s[n - i + 1] - 'a');
}
printf("%lld\n", pam.dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T read() {
T x = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -w;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * w;
}
template <class T>
inline T read(T& x) {
return x = read<T>();
}
const int mod = 1000000000 + 7;
inline int add(int a, int b) { return (a += b) >= mod ? a - mod : a; }
inline int mul(int a, int b) { return (long long)a * b % mod; }
inline int fpow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) ans = mul(ans, a);
return ans;
}
const int N = 1000000 + 10;
namespace PAM {
int str[N], n;
int last, tot;
int ch[N][26], trans[N][26], len[N], fa[N];
int diff[N], anc[N];
void init() {
memset(str, -1, sizeof str), n = 0;
last = tot = 1;
len[0] = 0, len[1] = -1, fa[0] = fa[1] = 1;
fill(trans[0], trans[0] + 26, 1);
diff[0] = 0;
}
void extend(int c) {
str[++n] = c;
int p = last;
if (str[n - len[p] - 1] != str[n]) p = trans[p][c];
if (!ch[p][c]) {
int cur = ++tot;
len[cur] = len[p] + 2;
fa[cur] = ch[trans[p][c]][c];
ch[p][c] = cur;
copy(trans[fa[cur]], trans[fa[cur]] + 26, trans[cur]);
trans[cur][str[n - len[fa[cur]]]] = fa[cur];
diff[cur] = len[cur] - len[fa[cur]];
anc[cur] = diff[cur] == diff[fa[cur]] ? anc[fa[cur]] : fa[cur];
}
last = ch[p][c];
}
} // namespace PAM
char tmp[N], str[N];
int dp[N], ans[N];
int main() {
scanf("%s", tmp + 1);
int n = strlen(tmp + 1);
if (n & 1) return puts("0"), 0;
for (int i = 1; i <= n; i += 2) str[i] = tmp[(i + 1) / 2];
reverse(tmp + 1, tmp + n + 1);
for (int i = 2; i <= n; i += 2) str[i] = tmp[i / 2];
PAM::init();
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
PAM::extend(str[i] - 'a');
for (int p = PAM::last; p; p = PAM::anc[p]) {
dp[p] = ans[i - PAM::len[PAM::anc[p]] - PAM::diff[p]];
if (PAM::anc[p] != PAM::fa[p]) dp[p] = add(dp[p], dp[PAM::fa[p]]);
if (~i & 1) ans[i] = add(ans[i], dp[p]);
}
}
printf("%d\n", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, f[1000005], g[1000005];
char s[1000005], s2[1000005];
namespace PAM {
int fa[1000005] = {1, 1}, ch[1000005][26], len[1000005] = {0, -1}, last, sz = 1,
anc[1000005], dif[1000005];
void extend(int x) {
int p = last, c = s[x] - 'a';
while (s[x] != s[x - len[p] - 1]) p = fa[p];
if (!ch[p][c]) {
int q = fa[p];
len[++sz] = len[p] + 2;
while (s[x] != s[x - len[q] - 1]) q = fa[q];
fa[sz] = ch[q][c], dif[sz] = len[sz] - len[fa[sz]];
anc[sz] = dif[sz] == dif[fa[sz]] ? anc[fa[sz]] : fa[sz];
ch[p][c] = sz;
}
last = ch[p][c];
}
} // namespace PAM
using namespace PAM;
int main() {
scanf("%s", s + 1), n = strlen(s + 1);
for (int i = 1; i <= n; i += 2) s2[i] = s[(i + 1) / 2];
for (int i = 2; i <= n; i += 2) s2[i] = s[n - i / 2 + 1];
for (int i = 1; i <= n; i++) s[i] = s2[i];
f[0] = 1;
for (int i = 1; i <= n; i++) {
extend(i);
for (int x = last; x; x = anc[x]) {
g[x] = f[i - len[anc[x]] - dif[x]];
if (anc[x] != fa[x]) g[x] = (g[x] + g[fa[x]]) % mod;
if (!(i & 1)) f[i] = (f[i] + g[x]) % mod;
}
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 1, maxl = maxn, 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;
}
if (m && i - 1 - las == dif[m]) {
++cnt[m];
} else {
sta[++m] = i - 1;
dif[m] = sta[m] - las;
cnt[m] = 1;
}
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]);
}
if (i & 1) f[i] = 0;
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
register T sum(0), fg(1);
register char ch(getchar());
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fg = -1;
for (; isdigit(ch); ch = getchar()) sum = sum * 10 - '0' + ch;
return sum * fg;
}
const int MOD = (int)1e9 + 7;
const int MAXN = (int)1e6;
int n;
char s0[MAXN + 5];
inline void input() { scanf("%s", s0 + 1), n = strlen(s0 + 1); }
namespace PAM {
const int MAX_NODE = MAXN * 2, alpha = 26;
int fail[MAX_NODE + 5], trans[MAX_NODE + 5][alpha], nxt[MAX_NODE + 5], cnt;
int len[MAX_NODE + 5], delta[MAX_NODE + 5];
int rt0, rt1, lst;
int S[MAX_NODE + 5], N = 0;
inline void init() {
S[0] = -1;
cnt = 1, lst = 0;
memset(trans[0], 0, sizeof trans[0]);
memset(trans[1], 0, sizeof trans[1]);
len[0] = 0, len[1] = -1;
fail[0] = 1;
}
inline int new_node(int l) {
len[++cnt] = l;
fail[cnt] = 0;
memset(trans[cnt], 0, sizeof trans[cnt]);
return cnt;
}
inline int extend(int ch) {
int p = lst;
S[++N] = ch;
while (S[N - len[p] - 1] != S[N]) p = fail[p];
int np = -1;
if (!trans[p][ch]) {
np = new_node(len[p] + 2);
int t = fail[p];
while (S[N - len[t] - 1] != S[N]) t = fail[t];
fail[np] = trans[t][ch];
delta[np] = len[np] - len[fail[np]];
nxt[np] = delta[np] == delta[fail[np]] ? nxt[fail[np]] : fail[np];
trans[p][ch] = np;
} else
np = trans[p][ch];
return lst = np;
}
} // namespace PAM
inline void solve() {
static int s[MAXN + 5];
for (int i = 1; i <= n / 2; ++i) {
s[i * 2 - 1] = s0[i] - 'a';
s[i * 2] = s0[n - i + 1] - 'a';
}
static int nd[MAXN + 5];
PAM::init();
for (int i = 1; i <= n; ++i) nd[i] = PAM::extend(s[i]);
static int f[MAXN + 5], g[MAXN + 5];
f[0] = 1;
for (int i = 1; i <= n; ++i)
for (int p = nd[i]; p; p = PAM::nxt[p]) {
g[p] = f[i - PAM::len[PAM::nxt[p]] - PAM::delta[p]];
if (PAM::delta[p] == PAM::delta[PAM::fail[p]])
(g[p] += g[PAM::fail[p]]) %= MOD;
if (i % 2 == 0) (f[i] += g[p]) %= MOD;
}
printf("%d\n", (f[n] + MOD) % MOD);
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000010;
const int mod = 1e9 + 7;
const int MAX = 1000000010;
const double eps = 1e-6;
const double PI = acos(-1);
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do x = x * 10 + ch - '0', ch = getchar();
while (ch <= '9' && ch >= '0');
x *= f;
}
template <typename A, typename B>
inline void read(A &x, B &y) {
read(x);
read(y);
}
template <typename A, typename B, typename C>
inline void read(A &x, B &y, C &z) {
read(x);
read(y);
read(z);
}
template <typename A, typename B, typename C, typename D>
inline void read(A &x, B &y, C &z, D &w) {
read(x);
read(y);
read(z);
read(w);
}
template <typename A, typename B>
inline A fexp(A x, B p) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % mod)
if (p & 1) ans = 1LL * ans * x % mod;
return ans;
}
template <typename A, typename B>
inline A fexp(A x, B p, A mo) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % mo)
if (p & 1) ans = 1LL * ans * x % mo;
return ans;
}
int n, cnt, lst;
char st[maxn], s[maxn];
int f[maxn], fa[maxn], len[maxn], anc[maxn], dif[maxn], nxt[maxn][26], sm[maxn];
void extend(int c, int n) {
int cur = lst;
while (s[n - len[cur] - 1] != s[n]) cur = fa[cur];
if (!nxt[cur][c]) {
int x = ++cnt, k = fa[cur];
len[x] = len[cur] + 2;
for (; s[n] != s[n - len[k] - 1]; k = fa[k])
;
fa[x] = nxt[k][c];
nxt[cur][c] = x;
dif[x] = len[x] - len[fa[x]];
anc[x] = dif[x] == dif[fa[x]] ? anc[fa[x]] : fa[x];
}
lst = nxt[cur][c];
}
void Work() {
f[0] = 1;
lst = cnt = 1, fa[0] = 1, fa[1] = 0, len[1] = -1;
for (int i = (1); i <= (n); i++) {
extend(s[i] - 'a', i);
for (int x = lst; x; x = anc[x]) {
sm[x] = f[i - len[anc[x]] - dif[x]];
if (anc[x] != fa[x]) sm[x] = (sm[x] + sm[fa[x]]) % mod;
if (i % 2 == 0) f[i] = (f[i] + sm[x]) % mod;
}
}
printf("%d\n", f[n]);
}
void Init() {
scanf("%s", st + 1);
n = strlen(st + 1);
if (n & 1) {
puts("0");
exit(0);
}
for (int i = (1); i <= (n); i++)
if (i & 1)
s[i] = st[(i + 1) >> 1];
else
s[i] = st[n - i / 2 + 1];
}
int main() {
Init();
Work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int C = 26, N = 1e6 + 5, MOD = 1e9 + 7;
struct node {
node *child[C], *fail, *slink;
int length, cnt, diff, series;
node(int length) : fail(NULL), slink(NULL), length(length) {
memset(child, NULL, sizeof(child));
cnt = diff = series = 0;
}
};
int size, text[N];
node *odd, *even;
node *match(node *now) {
for (; text[size - now->length - 1] != text[size]; now = now->fail)
;
return now;
}
bool extend(node *&last, int token) {
text[++size] = token;
node *now = match(last);
if (now->child[token]) return last = now->child[token], false;
last = now->child[token] = new node(now->length + 2);
if (now == odd)
last->fail = even;
else {
now = match(now->fail);
last->fail = now->child[token];
}
last->cnt++;
last->diff = last->length - last->fail->length;
if (last->diff == last->fail->diff) {
last->slink = last->fail->slink;
} else {
last->slink = last->fail;
}
return true;
}
void init() {
text[size = 0] = -1;
even = new node(0), odd = new node(-1);
even->fail = odd;
}
node *pos[N];
int ans[N], series_ans[N];
void build(char *s) {
int n = (int)strlen(s);
pos[0] = odd;
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
extend(pos[i] = pos[i - 1], s[i - 1] - 'a');
for (node *v = pos[i]; v->length > 0; v = v->slink) {
v->series = ans[i - (v->slink->length + v->diff)];
if (v->diff == v->fail->diff) {
(v->series += v->fail->series) %= MOD;
}
(ans[i] += v->series) %= MOD;
}
if (i & 1) ans[i] = 0;
}
for (int i = n; i > 0; --i) pos[i]->fail->cnt += pos[i]->cnt;
}
char s[N], t[N];
int main() {
scanf("%s", s);
int n = (int)strlen(s);
if (n & 1) return 0 * puts("0");
for (int i = 0; i < n / 2; ++i) t[i * 2] = s[i];
for (int i = n - 1; i >= n / 2; --i) t[(n - 1 - i) * 2 + 1] = s[i];
init();
build(t);
printf("%d\n", ans[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type const& x() const {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type& x() {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type const& y() const {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type& y() {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type const& z() const {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type& z() {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type const& w() const {
return get<3>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type& w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...> >
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
const int N = 1e6 + 128;
map<int, int> to[N];
int link[N];
int diff[N];
int slink[N];
int len[N];
int last[N];
int n, m;
int s[N];
void init() {
link[0] = link[1] = 0;
last[0] = 0;
len[0] = -1;
len[1] = 0;
diff[0] = diff[1] = -1;
slink[0] = slink[1] = -1;
n = 0;
m = 2;
}
void add(int x) {
s[n] = x;
n += 1;
last[n] = last[n - 1];
for (;; last[n] = link[last[n]]) {
if (s[n - 2 - len[last[n]]] == x) {
if (!to[last[n]].count(x)) {
int v = m;
m++;
to[last[n]][x] = v;
len[v] = len[last[n]] + 2;
if (len[v] == 1) {
link[v] = 1;
} else {
link[v] = link[last[n]];
while (s[n - 2 - len[link[v]]] != x) link[v] = link[link[v]];
link[v] = to[link[v]][x];
}
diff[v] = len[v] - len[link[v]];
if (diff[v] == diff[link[v]]) {
slink[v] = slink[link[v]];
} else {
slink[v] = link[v];
}
last[n] = v;
} else {
last[n] = to[last[n]][x];
}
return;
}
}
}
const lli MOD = 1e9 + 7;
lli nmod(lli x) { return (x % MOD + MOD) % MOD; }
struct Zn {
lli x;
Zn() : x(0) {}
Zn(lli x_) : x(x_) {
x %= MOD;
if (x < 0) x = (x + MOD) % MOD;
}
Zn operator+(Zn const& o) const { return Zn(x + o.x); }
Zn operator-(Zn const& o) const { return Zn(x - o.x); }
Zn operator*(Zn const& o) const { return Zn(x * o.x); }
Zn& operator+=(Zn const& o) { return *this = *this + o; }
Zn& operator-=(Zn const& o) { return *this = *this - o; }
Zn& operator*=(Zn const& o) { return *this = *this * o; }
};
Zn dp[N];
Zn ans[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
init();
string t;
for (lli i = 0; i < (lli)(n / 2); ++i) {
t.push_back(s[i]);
t.push_back(s[s.size() - 1 - i]);
}
for (char c : t) add(c);
ans[0] = 1;
dp[0] = dp[1] = 0;
for (lli i = 0; i < (lli)(n); ++i) {
ans[i + 1] = 0;
for (int v = last[i + 1]; v > 1; v = slink[v]) {
dp[v] = 0;
if (((i + 1) - (len[slink[v]] + diff[v])) % 2 == 0) {
dp[v] = ans[(i + 1) - (len[slink[v]] + diff[v])];
}
if (diff[v] == diff[link[v]]) dp[v] += dp[link[v]];
if ((i + 1) % 2 == 0) ans[i + 1] += dp[v];
}
}
cout << ans[n].x << endl;
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], even[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];
even[cnt] = parent[cnt];
if (mxlen[even[cnt]] & 1) even[cnt] = even[even[cnt]];
last = cnt;
if (mxlen[cnt] % 2 == 0 && even[cnt] > 2 &&
mxlen[even[cnt]] * 2 > mxlen[cnt] &&
(!d[even[cnt]] || mxlen[cnt] - mxlen[even[cnt]] == d[even[cnt]])) {
d[cnt] = mxlen[cnt] - mxlen[even[cnt]], bot[cnt] = bot[even[cnt]];
d[even[cnt]] = mxlen[cnt] - mxlen[even[cnt]];
} else
d[cnt] = 0, bot[cnt] = cnt;
}
if (i % 2 == 0) {
for (register int cur = last; cur; cur = even[bot[cur]]) {
if (mxlen[cur] & 1) cur = even[cur];
if (bot[cur] != cur)
g[cur] = g[even[cur]];
else
g[cur] = 0;
if (mxlen[bot[cur]]) g[cur] = (g[cur] + f[i - mxlen[bot[cur]]]) % mod;
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;
const int maxn = 1 << 20, mod = 1e9 + 7;
int len[maxn], diff[maxn], link[maxn], slink[maxn];
map<int, int> to[maxn];
int sz, cur;
basic_string<int> s;
void init() {
len[0] = -1;
sz = 2, cur = 0;
}
bool bad(int v) {
return (int)s.size() - len[v] - 2 < 0 || s.back() != s[s.size() - len[v] - 2];
}
int find_link(int v) {
if (!bad(v)) return v;
while (bad(link[v])) v = slink[v];
return link[v];
}
int aux[maxn], dp[maxn];
int scalc(int v) {
aux[v] = dp[s.size() - len[slink[v]] - diff[v]];
if (slink[v] ^ link[v]) aux[v] = (aux[v] + aux[link[v]]) % mod;
return aux[v];
}
void add(int c) {
s += c;
cur = find_link(cur);
if (!to[cur][c]) {
len[sz] = len[cur] + 2;
link[sz] = max(1, to[find_link(link[cur])][c]);
diff[sz] = len[sz] - len[link[sz]];
slink[sz] = diff[link[sz]] == diff[sz] ? slink[link[sz]] : link[sz];
to[cur][c] = sz++;
}
cur = to[cur][c];
for (int v = cur; v > 1; v = slink[v]) (dp[s.size()] += scalc(v)) %= mod;
}
int hsh[maxn], pw[maxn];
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int B = 26 + (rng() % 6969696) + 9;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
pw[0] = 1;
for (int i = 1; i < maxn; i++) pw[i] = pw[i - 1] * 1ll * B % mod;
string t;
cin >> t;
int n = t.size();
t = " " + t;
for (int i = 1; i <= n; i++)
hsh[i] = (hsh[i - 1] + pw[i] * 1ll * (t[i] - 'a' + 1)) % mod;
auto get = [&](int l, int r) {
return (mod - hsh[l - 1] + hsh[r]) * 1ll * pw[maxn - 1 - r] % mod;
};
int l = 1;
map<int, int> id;
basic_string<int> v;
for (int i = 1; i <= n / 2; i++) {
if (get(l, i) == get(n + 1 - i, n + 1 - l)) {
if (!id.count(get(l, i))) id[get(l, i)] = id.size();
v.push_back(id[get(l, i)]);
l = i + 1;
}
}
if (l - 1 != n / 2) return cout << "0\n", 0;
init(), dp[0] = 1;
for (auto i : v) add(i);
cout << dp[s.size()] << '\n';
}
|
#include <bits/stdc++.h>
const int P = 1000000007;
inline int mul(const int &a, const int &b) { return 1ll * a * b % P; }
inline int add(int a, const int &b) {
a += b;
return (a >= P) ? a - P : a;
}
inline int sub(int a, const int &b) {
a -= b;
return (a < 0) ? a + P : a;
}
int n, s[1000001], son[1000001][26], fail[1000001],
cnt = 1, last = 1, len[1000001], pos[1000001], f[1000001], dif[1000001],
an[1000001], g[1000001];
char tem[1000001];
int get_fail(int x) {
while (s[n - len[x] - 1] != s[n]) x = fail[x];
return x;
}
void add(int x) {
s[++n] = x;
int p = get_fail(last);
if (!son[p][x]) {
len[++cnt] = len[p] + 2;
fail[cnt] = son[get_fail(fail[p])][x];
son[p][x] = cnt;
dif[cnt] = len[cnt] - len[fail[cnt]];
an[cnt] = (dif[cnt] == dif[fail[cnt]]) ? an[fail[cnt]] : fail[cnt];
}
last = son[p][x];
}
int main() {
scanf("%s", tem + 1);
int nl = strlen(tem + 1);
len[1] = s[0] = -1;
fail[0] = 1;
f[0] = 1;
for (int i = 1; i <= nl; i++) {
add(tem[i % 2 == 1 ? (i + 1) >> 1 : (nl - (i >> 1) + 1)] - 'a');
for (int j = last; j; j = an[j]) {
int tem = 0;
g[j] =
add((an[j] == fail[j]) ? 0 : g[fail[j]], f[i - len[an[j]] - dif[j]]);
f[i] = add(f[i], g[j]);
}
if (i % 2) f[i] = 0;
}
printf("%d\n", f[nl]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K;
struct PAM {
struct node {
int ch[26];
int len, fail;
int dif, slink;
} t[2000000 + 5];
int ptr = 0, last = 0;
char *str;
void ini(char *in) {
str = in;
ptr = 1;
(t[0].fail) = 1;
(t[1].len) = -1;
}
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].dif = (t[cur].len) - (t[(t[cur].fail)].len);
if (t[cur].dif == t[(t[cur].fail)].dif)
t[cur].slink = t[(t[cur].fail)].slink;
else
t[cur].slink = (t[cur].fail);
t[p].ch[c] = cur;
}
last = t[p].ch[c];
}
int dp[2000000 + 5], g[2000000 + 5];
int solve() {
dp[0] = 1;
for (int i = 1; i <= n; i++) {
insert(str[i] - 'a', i);
for (int x = last; x > 1; x = t[x].slink) {
g[x] = dp[i - (t[t[x].slink].len) - t[x].dif];
if (t[x].dif == t[(t[x].fail)].dif)
g[x] = (g[x] + g[(t[x].fail)]) % 1000000007;
if (i % 2 == 0) dp[i] = (dp[i] + g[x]) % 1000000007;
}
}
return dp[n];
}
} T;
char s[2000000 + 5], t[2000000 + 5];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1, ptr = 0; i <= n / 2; i++) {
t[++ptr] = s[i];
t[++ptr] = s[n - i + 1];
}
T.ini(t);
printf("%d\n", T.solve());
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e6 + 7;
const int M = N << 1;
long long mod = 1e9 + 7;
struct pam {
int t[N][26], fa[N], len[N], rs[N], cnt[N], num[N];
int dif[N], slink[N];
int sz, n, last;
int _new(int l) {
len[sz] = l;
cnt[sz] = num[sz] = 0;
return sz++;
}
void init() {
memset(t, 0, sz * sizeof(t[0]));
rs[n = sz = 0] = -1;
last = _new(0);
fa[last] = _new(-1);
}
int get_fa(int x) {
while (rs[n - 1 - len[x]] != rs[n]) x = fa[x];
return x;
}
void ins(int ch) {
rs[++n] = ch;
int p = get_fa(last);
if (!t[p][ch]) {
int np = _new(len[p] + 2);
num[np] = num[fa[np] = t[get_fa(fa[p])][ch]] + 1;
t[p][ch] = np;
dif[np] = len[np] - len[fa[np]];
if (dif[np] == dif[fa[np]])
slink[np] = slink[fa[np]];
else
slink[np] = fa[np];
}
++cnt[last = t[p][ch]];
}
} pa;
long long dp[N], g[N];
char s[N], t[N * 2];
int main() {
pa.init();
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int i = 1, j = 0; i <= len; i++) t[++j] = s[i], t[++j] = s[len - i + 1];
dp[0] = 1;
for (int i = 1; i <= len; i++) {
pa.ins(t[i] - 'a');
for (int x = pa.last; x > 1; x = pa.slink[x]) {
g[x] = dp[i - pa.len[pa.slink[x]] - pa.dif[x]];
if (pa.dif[x] == pa.dif[pa.fa[x]]) g[x] = (g[x] + g[pa.fa[x]]) % mod;
if (i % 2 == 0) dp[i] = (dp[i] + g[x]) % mod;
}
}
printf("%d\n", dp[len]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T Tmin(const T &lch, const T &rch) {
if (lch < rch) return lch;
return rch;
}
template <class T>
inline T Tmax(const T &lch, const T &rch) {
if (lch < rch) return rch;
return lch;
}
const int Inf = 0x3f3f3f3f;
const int Mod = 1e9 + 7;
const int Gp = 3;
inline int R_int() {
register int n = 0;
register char ch = getchar();
register bool I = false;
while (ch < '0' || ch > '9') I = (ch == '-' ? 1 : 0), ch = getchar();
while (ch >= '0' && ch <= '9')
n = (n << 1) + (n << 3) + (ch ^ '0'), ch = getchar();
return I ? -n : n;
}
inline int Add(int a, int b) {
int ans = (a + b);
ans = (ans >= Mod ? ans - Mod : ans);
return ans;
}
inline int Mis(int a, int b) {
int ans = a - b;
ans = (ans < 0 ? ans + Mod : ans);
return ans;
}
inline int Mul(int a, int b) { return a * 1ll * b % Mod; }
inline int Pow(int a, long long k) {
int ans = 1;
while (k) {
if (k & 1) ans = Mul(ans, a);
a = Mul(a, a);
k = k >> 1;
}
return ans;
}
const int maxn = 1000000 + 10;
char str[maxn];
char ss[maxn];
int f[maxn];
int g[maxn];
int n, m;
namespace PAM {
int ch[maxn][26];
int fail[maxn];
int size[maxn];
int dif[maxn];
int len[maxn];
int pos[maxn];
int c[maxn];
int last;
int tot;
int n;
inline void PAM() {
n = 0;
c[0] = -1;
tot = last = 1;
fail[0] = fail[1] = 1;
len[0] = 0;
len[1] = -1;
}
inline void Insert(int x) {
int p = last;
c[++n] = x;
while (c[n - len[p] - 1] ^ x) p = fail[p];
if (!ch[p][x]) {
int np = ++tot, q = fail[p];
len[np] = len[p] + 2;
while (c[n - len[q] - 1] ^ x) q = fail[q];
fail[np] = ch[q][x];
ch[p][x] = np;
dif[np] = len[np] - len[fail[np]];
pos[np] = (dif[np] == dif[fail[np]]) ? pos[fail[np]] : fail[np];
}
size[last = ch[p][x]]++;
}
} // namespace PAM
signed main() {
scanf("%s", str + 1);
n = strlen(str + 1);
if (n & 1) return !puts("0");
for (int i = 1; i <= n; i += 2)
ss[i] = str[(i + 1) >> 1], ss[i + 1] = str[n - (i >> 1)];
PAM::PAM();
f[0] = 1;
for (int i = 1; i <= n; i++) {
PAM::Insert(ss[i] - 'a');
for (int x = PAM::last; x; x = PAM::pos[x]) {
g[x] = f[i - PAM::len[PAM::pos[x]] - PAM::dif[x]];
if (PAM::pos[x] != PAM::fail[x]) g[x] = Add(g[x], g[PAM::fail[x]]);
if (!(i & 1)) f[i] = Add(f[i], g[x]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100000;
const int MOD = 1000000007;
char t[maxn], s[maxn];
int fail[maxn], len[maxn], nxt[maxn][26], diff[maxn], slink[maxn], n, p, last;
int newnode(int l) {
len[p] = l;
return p++;
}
void init() {
p = 0;
newnode(0);
newnode(-1);
fail[last = 0] = 1;
s[n = 0] = 0;
}
int getfail(int x) {
while (s[n - len[x] - 1] != s[n]) x = fail[x];
return x;
}
int add() {
int c = s[++n] - 'a';
int cur = getfail(last);
if (!nxt[cur][c]) {
int now = newnode(len[cur] + 2);
fail[now] = nxt[getfail(fail[cur])][c];
diff[now] = len[now] - len[fail[now]];
slink[now] = diff[now] == diff[fail[now]] ? slink[fail[now]] : fail[now];
nxt[cur][c] = now;
}
last = nxt[cur][c];
return last;
}
int f[maxn], g[maxn];
int main() {
int i;
scanf("%s", t + 1);
n = strlen(t + 1);
if (n & 1) {
puts("0");
return 0;
}
for (i = (1); i <= (n >> 1); i++)
s[2 * i - 1] = t[i], s[2 * i] = t[n - i + 1];
int tmp = n;
init();
f[0] = 1;
for (i = (1); i <= (tmp); i++) {
for (int x = add(); len[x] > 0; x = slink[x]) {
g[x] = f[i - len[slink[x]] - diff[x]];
if (diff[x] == diff[fail[x]]) (g[x] += g[fail[x]]) %= MOD;
(f[i] += g[x]) %= MOD;
}
if (i & 1) f[i] = 0;
}
cout << f[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
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] = 0;
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]++;
}
void print() {
for (int i = 0; i <= sz; ++i) {
cout << "i"
<< ":" << i << " "
<< "fail[i]"
<< ":" << fail[i] << " "
<< "len[i]"
<< ":" << len[i] << " "
<< "slink[i]"
<< ":" << slink[i] << endl;
for (int j = 0; j < 26; ++j) cout << ch[i][j] << " \n"[j == 25];
cout << endl;
}
}
} // 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]);
for (int x = pam::last; x > 1; x = slink[x]) {
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]);
}
}
printf("%d", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ch[1000005][26];
int fail[1000005], len[1000005];
int d[1000005], nxt[1000005];
int tot, last2, now;
void init() {
tot = last2 = 1;
len[1] = -1;
fail[0] = 1;
}
char str[1000005];
int getfail(int x) {
while (str[now] != str[now - len[x] - 1]) x = fail[x];
return x;
}
int add(char x) {
x -= 'a';
now++;
int p = getfail(last2);
if (!ch[p][x]) {
tot++;
len[tot] = len[p] + 2;
fail[tot] = ch[getfail(fail[p])][x];
d[tot] = len[tot] - len[fail[tot]];
if (d[tot] == d[fail[tot]])
nxt[tot] = nxt[fail[tot]];
else
nxt[tot] = fail[tot];
ch[p][x] = tot;
}
last2 = ch[p][x];
return last2;
}
int f[1000005], g[1000005];
char str2[1000005];
int main() {
scanf("%s", str2 + 1);
int n = strlen(str2 + 1);
for (int i = 1; i <= n; i++)
if (i & 1)
str[i] = str2[(i + 1) >> 1];
else
str[i] = str2[n - (i >> 1) + 1];
init();
f[0] = 1;
for (int i = 1; i <= n; i++) {
int p = add(str[i]);
for (; p > 1; p = nxt[p]) {
g[p] = f[i - len[nxt[p]] - d[p]];
if (d[p] == d[fail[p]]) g[p] = (g[p] + g[fail[p]]) % 1000000007;
if (!(i & 1)) f[i] = (f[i] + g[p]) % 1000000007;
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
int add(int a, int b) {
int r = a + b;
return r < P ? r : r - P;
}
int sub(int a, int b) {
int r = a - b;
return r < 0 ? r + P : r;
}
namespace pam {
char s[1 << 20];
int g[1 << 20][26], f[1 << 20], l[1 << 20], d[1 << 20], t[1 << 20], nc;
int dp[1 << 20], v[1 << 20];
int gn(int len) {
int p = nc++;
l[p] = len;
f[p] = 0;
fill_n(g[p], 26, 0);
return p;
}
void clr() {
nc = 0;
gn(0);
gn(-1);
f[0] = 1;
f[1] = -1;
s[0] = 1;
}
int getf(int p, int i) {
while (s[i] != s[i - l[p] - 1]) p = f[p];
return p;
}
int extend(int p, int o, int i) {
s[i] = o + 'a';
p = getf(p, i);
int& q = g[p][o];
if (!q) {
q = gn(l[p] + 2);
if (p != 1) f[q] = g[getf(f[p], i)][o];
d[q] = l[q] - l[f[q]];
t[q] = d[f[q]] == d[q] ? t[f[q]] : f[q];
}
for (int r = q; r > 1; r = t[r]) {
v[r] = dp[i - l[t[r]] - d[r]];
if (d[r] == d[f[r]]) v[r] = add(v[r], v[f[r]]);
if (i % 2 == 0) dp[i] = add(dp[i], v[r]);
}
return q;
}
} // namespace pam
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
string t(n, '0');
for (int i = 0; i != n / 2; ++i) {
t[2 * i + 1] = s[i];
t[2 * i] = s[n - i - 1];
}
pam::dp[0] = 1;
pam::clr();
int p = 0;
for (int i = 0; i != n; ++i) p = pam::extend(p, t[i] - 'a', i + 1);
cout << pam::dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(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 N = 1e6 + 10, mod = 1e9 + 7;
int ch[N][26], fail[N], len[N], diff[N], last;
int fa[N];
struct Palindromic_Tree {
char S[N];
int ncnt, n;
void init() {
n = 0;
S[0] = -1;
ncnt = last = 1;
fail[1] = 0, fail[0] = 1, len[0] = 0, len[1] = -1;
}
int get(int u) {
while (S[n - len[u] - 1] != S[n]) u = fail[u];
return u;
}
void insert(int c) {
S[++n] = c;
int cur = get(last);
if (!ch[cur][c]) {
int now = ++ncnt;
len[now] = len[cur] + 2;
fail[now] = ch[get(fail[cur])][c], ch[cur][c] = now;
diff[now] = len[now] - len[fail[now]];
fa[now] = (diff[now] == diff[fail[now]]) ? fa[fail[now]] : fail[now];
}
last = ch[cur][c];
}
} PT;
char str[N], s1[N];
int n;
int f[N], g[N];
int main() {
scanf("%s", s1 + 1);
n = strlen(s1 + 1);
if (n & 1) {
puts("0");
return 0;
}
for (int i = 1, l = 0; i * 2 <= n; ++i)
str[++l] = s1[i], str[++l] = s1[n - i + 1];
f[0] = 1;
PT.init();
for (int i = 1; i <= n; ++i) {
PT.insert(str[i] - 'a');
for (int v = last; v; v = fa[v]) {
g[v] = f[i - len[fa[v]] - diff[v]];
if (diff[v] == diff[fail[v]]) g[v] = (g[v] + g[fail[v]]) % mod;
if (!(i & 1)) f[i] = (f[i] + g[v]) % mod;
}
}
printf("%d", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
const int maxn = 2000111;
int n;
char s[maxn], t[1000111];
int tot, go[maxn][26], len[maxn], par[maxn], slink[maxn], diff[maxn];
int gpl[maxn], dp[maxn];
int append(int n, int p, char c) {
int ic = c - 'a';
while (s[n - len[p] - 1] != c) p = par[p];
if (!go[p][ic]) {
int q = ++tot;
len[q] = len[p] + 2;
int t = par[p];
while (s[n - len[t] - 1] != c) t = par[t];
par[q] = go[t][ic];
go[p][ic] = q;
diff[q] = len[q] - len[par[q]];
slink[q] = diff[q] == diff[par[q]] ? slink[par[q]] : par[q];
}
return go[p][ic];
}
void upd(int &x, int v) { x = x + v >= mod ? x + v - mod : x + v; }
int main() {
par[0] = tot = 1;
len[1] = -1;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) t[i] = s[n - i + 1];
for (int i = n; i >= 1; i--) s[(i << 1) - 1] = s[i];
for (int i = 1; i <= n; i++) s[(i << 1)] = t[i];
int st = 0;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
dp[i] = 0;
st = append(i, st, s[i]);
for (int p = st; p; p = slink[p]) {
int lst = i - len[slink[p]] - diff[p];
gpl[p] = dp[lst];
if (diff[par[p]] == diff[p]) upd(gpl[p], gpl[par[p]]);
if (!(i & 1)) upd(dp[i], gpl[p]);
}
}
cout << dp[n] << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.