text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int c = 10000100;
char s[c];
int z[c];
int p[c];
int n, ans;
int main() {
gets(s);
n = strlen(s);
memcpy(s + n, s, (n + 1) * sizeof(char));
reverse(s + n, s + 2 * n);
int i, j;
z[0] = 2 * n;
int lf = 0, rg = 0;
for (i = 1; i < 2 * n; ++i) {
if (i > rg) {
lf = i;
for (j = i; j < 2 * n; ++j)
if (s[j] != s[j - lf]) break;
rg = j - 1;
z[i] = rg - lf + 1;
} else if (i + z[i - lf] - 1 < rg)
z[i] = z[i - lf];
else {
lf = i;
for (j = rg + 1; j < 2 * n; ++j)
if (s[j] != s[j - lf]) break;
rg = j - 1;
z[i] = rg - lf + 1;
}
}
p[0] = 1;
ans = 1;
for (i = 1; i < n; ++i) {
if (z[2 * n - i - 1] >= (i + 1) / 2) p[i] = p[(i - 1) / 2] + 1;
ans += p[i];
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5000009;
char s[MaxN], t[MaxN];
int p[MaxN], q[MaxN], r[MaxN], z[MaxN];
int n;
int main(void) {
int i, j, k, res;
while (scanf(" %s", s + 1) != EOF) {
s[0] = t[0] = '\0';
n = strlen(s + 1);
for (i = 1; i <= n; i++) t[n - i + 1] = s[i];
t[n + 1] = '\xFF';
k = -1;
p[0] = k;
for (i = 1; i <= n; i++) {
while (k >= 0 && s[k + 1] != s[i]) k = p[k];
k++;
p[i] = k;
}
k = 0;
q[0] = k;
for (i = 1; i <= n; i++) {
while (k >= 0 && s[k + 1] != t[i]) k = p[k];
k++;
q[i] = k;
}
memset(z, 0, sizeof(z));
k = 0;
i = 1;
while (i <= n) {
if (k == -1) k++;
while (t[i + k] == s[k + 1]) k++;
z[i] = k;
i += k - p[k];
k = p[k];
}
memset(r, 0, sizeof(r));
res = 0;
k = 0;
for (i = 1; i <= n; i++) {
j = i >> 1;
if (z[n - i + 1] >= j) r[i] = 1 + r[j];
}
for (i = 1; i <= n; i++) res += r[i];
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 23;
void manacher(int n, const char s[], int r[]) {
int m = 0, i = 0, pl = 0;
while (i < n) {
if (i > pl && s[i - pl - 1] == s[i]) {
pl += 2;
i++;
continue;
}
r[m++] = pl;
int b = m - 2, e = b - pl, j;
for (j = b; j > e; j--) {
int d = j - e - 1;
if (r[j] >= d) {
pl = d;
break;
}
r[m++] = min(d, r[j]);
}
if (j == e) {
pl = 1;
i++;
}
}
r[m++] = pl;
int b = m - 2, e = b - ((n << 1) + 1 - m);
for (int i = b; i > e; i--) {
int d = i - e - 1;
r[m++] = min(d, r[i]);
}
}
char s[MAXN];
int r[MAXN];
int d[MAXN];
int main() {
int n, ans;
scanf("%s", s);
n = strlen(s);
manacher(n, s, r);
ans = d[0] = 0;
for (int i = 1; i <= n; ++i) {
if (r[i] == i) {
d[i] = d[i / 2] + 1;
} else {
d[i] = 0;
}
ans += d[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5 * 1000100];
int f[5 * 1000100];
int X = 103;
int Y = 1;
int main() {
scanf("%s", s);
int len = strlen(s);
int l = 0, r = 0;
int sol = 0;
for (int i = 0; i < len; i++) {
l *= X;
l += s[i];
r += s[i] * Y;
Y *= X;
if (l == r) f[i + 1] = f[(i + 1) / 2] + 1;
sol += f[i + 1];
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long readint() {
long long x = 0, s = 1;
char c;
while ((c = getchar()), c < '0' || c > '9') {
if (c == '-') s = -1;
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return s * x;
}
void putint(int x) {
char c[20];
if (!x) {
putchar('0');
return;
}
if (x < 0) putchar('-'), x = -x;
int i = 0;
while (x > 0) c[++i] = x % 10, x /= 10;
while (i) putchar(c[i--] + 48);
}
template <typename T>
void print(T x) {
putint(x);
}
template <typename T, typename... A>
inline void print(T x, A... args) {
print(x);
putchar(' ');
print(args...);
}
template <typename T>
void scan(T &x) {
x = readint();
}
template <typename T, typename... A>
inline void scan(T &x, A &...args) {
scan(x);
scan(args...);
}
struct Manacher {
long long n;
string s;
vector<long long> d1, d2;
Manacher(string s) : s(s) {
n = s.size();
d1.resize(n);
d2.resize(n);
build();
}
void build() {
for (long long i = 0, l = 0, r = -1; i < n; i++) {
long long k = (i > r) ? 1 : min(d1[l + r - i], r - i + 1);
while (0 <= i - k && i + k < n && s[i - k] == s[i + k]) {
k++;
}
d1[i] = k--;
if (i + k > r) {
l = i - k;
r = i + k;
}
}
for (long long i = 0, l = 0, r = -1; i < n; i++) {
long long k = (i > r) ? 0 : min(d2[l + r - i + 1], r - i + 1);
while (0 <= i - k - 1 && i + k < n && s[i - k - 1] == s[i + k]) {
k++;
}
d2[i] = k--;
if (i + k > r) {
l = i - k - 1;
r = i + k;
}
}
}
bool isPal(long long l, long long r) {
long long len = r - l + 1;
long long i = l + r + 1 >> 1;
if (len % 2) {
return d1[i] > len / 2;
} else {
return d2[i] >= len / 2;
}
}
};
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
long long n = s.size();
vector<long long> dp(n);
Manacher man(s);
long long ans = dp[0] = 1;
for (long long i = 1; i < n; i++) {
if (man.isPal(0, i)) {
dp[i] = 1 + dp[(i + 1) / 2 - 1];
ans += dp[i];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int BASE = 257;
const int MOD = 1e9 + 7;
const int SIZE = 5 * 1e6 + 1;
int k_pal[SIZE];
void solve() {
string s;
cin >> s;
long long hash = 0;
long long rev_hash = 0;
long long deg = 1;
int ans = 0;
for (int i = 1; i <= s.size(); i++) {
hash = (hash + s[i - 1] * deg) % MOD;
rev_hash = (rev_hash * BASE + s[i - 1]) % MOD;
deg = (deg * BASE) % MOD;
if (hash == rev_hash) {
k_pal[i] = k_pal[i / 2] + 1;
ans += k_pal[i];
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inpL;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string inp;
cin >> inp;
long long n = inp.length();
long long pref[n + 1], suff[n + 1], power[n + 2];
long long dp[n + 1];
power[0] = 1;
dp[0] = 0;
inpL = n;
pref[0] = 0;
suff[0] = 0;
string t = inp;
reverse(t.begin(), t.end());
for (long long i = 1; i < n + 1; i++) {
long long per = power[i - 1];
pref[i] = (pref[i - 1] + ((inp[i - 1] - '0' + 1) * (per))) % 1000000007;
suff[i] = (suff[i - 1] + ((t[i - 1] - '0' + 1) * (per))) % 1000000007;
power[i] = (power[i - 1] * 83) % 1000000007;
}
long long ans = 0;
string temp;
for (long long i = 0; i < n; i++) {
temp.push_back(inp[i]);
long long len = i + 1;
if (len % 2 == 0) {
if (((pref[len / 2] * power[inpL - len]) % 1000000007) ==
(suff[inpL - (len / 2)] - suff[inpL - len] + 1000000007) %
1000000007) {
dp[len] = dp[len / 2] + 1;
ans += dp[len];
} else
dp[len] = 0;
} else if (len % 2 == 1) {
if (((pref[len / 2] * power[inpL - len]) % 1000000007) ==
((suff[inpL - (len / 2) - 1] - suff[inpL - len] + 1000000007) %
1000000007)) {
dp[len] = dp[len / 2] + 1;
ans += dp[len];
} else
dp[len] = 0;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[5000005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
memset(a, 0, sizeof a);
a[0] = 1;
long long res = 1, p = 1, h1 = s[0], h2 = s[0];
for (int i = 1; i < s.size(); i++) {
h1 = (h1 * 1811 + s[i]) % 1000000007;
p = (p * 1811) % 1000000007;
h2 = (h2 + p * s[i]) % 1000000007;
if (h1 == h2) a[i] = a[(i - 1) / 2] + 1;
res += a[i];
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000005];
long long l = 0, r = 0, e = 1, p[5000005], ans = 0;
int main() {
scanf("%s", s);
for (int i = 0; s[i]; i++) {
l = l * 107 + s[i];
r = r + s[i] * e;
e *= 107;
if (l == r) p[i + 1] = p[(i + 1) / 2] + 1;
ans += p[i + 1];
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[5000005];
char s[5000005];
int main() {
scanf("%s", s);
int l = 0, r = 0, v = 1, kq = 0;
for (int i = 0; s[i]; i++) {
l = l * 175 + s[i];
r = r + s[i] * v;
v *= 175;
if (l == r) a[i + 1] = a[(i + 1) / 2] + 1;
kq += a[i + 1];
}
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000010];
int f[5000010];
int main() {
scanf("%s", s);
int l = 0, r = 0, e = 1, ans = 0;
for (int i = 0; s[i]; i++) {
l = l * 107 + s[i];
r = r + s[i] * e;
e *= 107;
if (l == r) f[i + 1] = f[(i + 1) / 2] + 1;
ans += f[i + 1];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int maxn = 5e6 + 5;
char s[maxn];
int h[maxn];
const int M = 10007;
int main() {
scanf("%s", s);
int p = 0, q = 0, f = 1, ans = 0;
for (int i = 0; s[i]; ++i) {
p = p * M + s[i];
q = q + s[i] * f;
f *= M;
if (p == q) h[i + 1] = h[(i + 1) >> 1] + 1;
ans += h[i + 1];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) {
f |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
const int base = 101, mod = (int)((1ll << 31) - 1);
int pre[5000005], nxt[5000005], f[5000005], len, powb[5000005] = {1}, ans = 0;
char s[5000005];
inline void init() {
for (register int i = 1; i <= 5000000; ++i)
(powb[i] = powb[i - 1] * base) >= mod ? powb[i] %= mod : 0;
}
inline bool is_level(int l, int r) {
return (pre[r] - pre[l - 1]) * powb[len - r - l + 1] == (nxt[l] - nxt[r + 1]);
}
int main() {
init();
scanf("%s", s + 1);
len = strlen(s + 1);
for (register int i = 1; i <= len; ++i)
pre[i] = (pre[i - 1] + s[i] * powb[i - 1]) % mod;
for (register int i = len; i >= 1; --i)
nxt[i] = (nxt[i + 1] + s[i] * powb[len - i]) % mod;
for (register int i = 1; i <= len; ans += f[i], ++i)
if (is_level(1, i)) f[i] = f[i >> 1] + 1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
namespace solution {
class ISolution {
public:
virtual void init(){};
virtual bool input() { return false; };
virtual void output(){};
virtual int run() = 0;
};
} // namespace solution
namespace hash {
namespace rolling_hash {
template <class T>
class IRollingHash {
public:
virtual void init(){};
virtual void pushBack(int c){};
virtual void popBack(){};
virtual void pushFront(int c){};
virtual void popFront(){};
virtual T getHash() = 0;
};
} // namespace rolling_hash
} // namespace hash
namespace math {
template <class T>
T extgcd(T a, T b, T& x, T& y) {
for (T u = y = 1, v = x = 0; a;) {
T q = b / a;
std::swap(x -= q * u, u);
std::swap(y -= q * v, v);
std::swap(b -= q * a, a);
}
return b;
}
} // namespace math
namespace math {
template <class T>
T mod_inverse(T a, T m) {
T x, y;
extgcd(a, m, x, y);
x %= m;
while (x < 0) x += m;
return x;
}
} // namespace math
namespace hash {
namespace rolling_hash {
class RollingHash {
public:
unsigned long long B, hash, bases;
RollingHash(unsigned long long B) : B(B) { init(); }
void init() { hash = 0, bases = 1; }
void pushBack(int c) { hash = hash * B + c, bases = bases * B; }
};
} // namespace rolling_hash
} // namespace hash
namespace solution {
using namespace std;
using namespace hash::rolling_hash;
const int SIZE = 5000011;
const unsigned long long BASE = 263LL;
unsigned long long dp[SIZE];
class Solution : public ISolution {
public:
string s;
int n;
void init() { fill(dp, dp + SIZE, 0); }
bool input() {
if (!(cin >> s)) return false;
n = s.size();
return true;
}
vector<unsigned long long> calc_hash_prefix() {
int n = s.size();
RollingHash rh(BASE);
vector<unsigned long long> res(n + 1, 0);
for (int i = 0; i < n; ++i) {
rh.pushBack(s[i]);
res[i + 1] = rh.hash;
}
return res;
}
vector<unsigned long long> calc_hash_suffix() {
int n = s.size();
RollingHash rh(BASE);
vector<unsigned long long> res(n + 1, 0);
for (int i = 0; i < n; ++i) {
rh.pushBack(s[n - i - 1]);
res[i + 1] = rh.hash;
}
return res;
}
vector<unsigned long long> calc_bases() {
vector<unsigned long long> res(SIZE);
res[0] = 1;
for (int i = 1; i < SIZE; ++i) res[i] = res[i - 1] * BASE;
return res;
}
unsigned long long solve() {
vector<unsigned long long> HP = calc_hash_prefix();
vector<unsigned long long> HS = calc_hash_suffix();
vector<unsigned long long> B = calc_bases();
unsigned long long res = 0;
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
int len = i / 2;
int rlen = i - len;
if (HP[len] != HS[n - rlen] - HS[n - rlen - len] * B[len]) {
dp[i] = 0;
continue;
}
dp[i] = dp[len] + 1;
res += dp[i];
}
return res;
}
void output(unsigned long long result) { cout << result << endl; }
int run() {
while (init(), input()) {
output(solve());
}
return 0;
}
};
} // namespace solution
int main() { return solution::Solution().run(); }
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 100;
const long long inf = 1e18;
const unsigned long long hs = 3797;
unsigned long long F[maxn], L[maxn], R[maxn];
char in[maxn];
int n, dp[maxn];
unsigned long long seg(int x, int y) { return (L[y] - L[x - 1]) * F[n - y]; }
unsigned long long seg2(int x, int y) { return (R[x] - R[y + 1]) * F[x - 1]; }
bool palindrome(int x, int y) { return seg(x, y) == seg2(x, y); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
F[0] = 1;
for (int i = 1; i < maxn; i++) F[i] = F[i - 1] * hs;
cin >> (in + 1);
n = strlen(in + 1);
for (int i = 1; i <= n; i++) L[i] = L[i - 1] + in[i] * F[i - 1];
for (int i = n; i >= 1; i--) R[i] = R[i + 1] + in[i] * F[n - i];
long long ans = 0;
for (int i = 1; i <= n; i++) {
int mid = (i / 2);
if (palindrome(1, i)) {
dp[i] = dp[mid] + 1;
ans += dp[i];
} else
dp[i] = 0;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int N = 6e6, X = 103;
char s[N];
int i, l, r, t = 1, ans, f[N];
int main() {
for (gets(s); s[i]; i++)
l = l * X + s[i], r += s[i] * t, t *= X,
f[i + 1] = (l == r) ? f[(i + 1) / 2] + 1 : 0, ans += f[i + 1];
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Int(T &a) {
bool minus = false;
a = 0;
char ch = getchar();
while (true) {
if (ch == '-' or (ch >= '0' && ch <= '9')) break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
a = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
a = a * 10 + (ch - '0');
}
if (minus) a *= -1;
}
template <typename T>
inline void Int(T &a, T &b) {
Int(a), Int(b);
}
template <typename T>
inline void Int(T &a, T &b, T &c) {
Int(a, b), Int(c);
}
template <typename T>
inline void Int(T &a, T &b, T &c, T &d) {
Int(a, b), Int(c, d);
}
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ' ';
err(++it, args...);
}
const int N = (int)5e6 + 5;
const int maxN = (int)1e6 + 6;
const long long Mod = (long long)1e9 + 7;
const int inf = (int)2e9;
const long long Inf = (long long)1e18;
const int mod = (int)1e9 + 7;
inline int add(int a, int b, int mod) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b, int mod) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b, int mod) { return (long long)a * b % mod; }
char s[N];
unsigned long long prime[N], p = 79;
int dp[N];
long long compute(int n) {
long long res = 0;
dp[0] = 1;
unsigned long long backHash = 0, frontHash = 0;
for (int i = 1; i <= n; ++i) {
frontHash += (s[i] - '0') * prime[i - 1];
backHash = backHash * p + (s[i] - '0');
if (frontHash == backHash) {
dp[i] = 1;
int f = i, cnt = 1, ans = 0;
;
while (f) {
ans += dp[f];
if (!dp[f]) break;
f /= 2;
}
res += ans;
}
}
return res;
}
int main() {
int test = 1, tc = 0;
while (test--) {
scanf("%s", s + 1);
int n = strlen(s + 1);
prime[0] = 1;
for (int i = 1; i <= n; ++i) prime[i] = prime[i - 1] * p;
long long res = compute(n);
printf("%lld\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 1, mod = 1e9 + 9;
int dp[maxn], n, h[maxn], h_rev[maxn], seed = 491, poww[maxn];
long long ans;
string s;
void prepare() {
poww[0] = 1;
for (int i = 1; i < maxn; i++) {
poww[i] = (1ll * poww[i - 1] * seed) % mod;
}
for (int i = 1; i <= n; i++) {
h[i] = ((1ll * h[i - 1] * seed) % mod + (s[i - 1])) % mod;
}
for (int i = n; i >= 1; i--) {
h_rev[i] = ((1ll * h_rev[i + 1] * seed) % mod + (s[i - 1])) % mod;
}
return;
}
int get(int R) { return h[R]; }
int get_rev(int L, int R) {
return (h_rev[L] - (1ll * h_rev[R + 1] * poww[R - L + 1]) % mod + mod) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
n = s.size();
prepare();
for (int i = 1; i <= n; i++) {
int t2, t3, t4;
if (i == 1) {
t2 = 1;
t3 = 1;
t4 = 1;
} else {
t2 = i / 2;
t3 = (i + 1) / 2 + 1;
t4 = i;
}
if (get(t2) == get_rev(t3, t4)) {
dp[i] = dp[i / 2] + 1;
}
ans += dp[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
char s[5000005];
int dp[5000005];
int main() {
scanf("%s", s);
memset(dp, 0, sizeof(dp));
dp[0] = 1;
unsigned long long ha = s[0];
unsigned long long haf = s[0];
unsigned long long hb = 1;
int ans = 1;
for (int i = 1; s[i]; i++) {
hb *= 131;
ha = ha * 131 + s[i];
haf = s[i] * hb + haf;
if (ha == haf) dp[i] = dp[(i - 1) >> 1] + 1;
ans += dp[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int N = 1e7 + 5;
int dp[N];
char s[N];
long long int p1 = 131, t1 = 1;
long long int p2 = 127, t2 = 1;
long long int h1 = 0, rh1 = 0, h2 = 0, rh2 = 0;
int main() {
int res = 0;
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
h1 = (h1 * p1 % 1000000009 + s[i]) % 1000000009;
rh1 = (rh1 + s[i] * t1 % 1000000009) % 1000000009;
t1 = t1 * p1 % 1000000009;
h2 = (h2 * p2 % 1000000009 + s[i]) % 1000000009;
rh2 = (rh2 + t2 * s[i] % 1000000009) % 1000000009;
t2 = t2 * p2 % 1000000009;
if (h1 == rh1 && h2 == rh2) {
dp[i] = dp[i / 2] + 1;
res += dp[i];
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 5;
const int base = 303;
const int mod = 1e9 + 9;
string s;
int n, res, f[N];
long long hash_fw[N], hash_bw[N], pw[N];
long long gethash_fw(int x, int y) {
return ((hash_fw[y] - hash_fw[x - 1] * pw[y + 1 - x]) % mod + mod) % mod;
}
long long gethash_bw(int x, int y) {
return ((hash_bw[x] - hash_bw[y + 1] * pw[y + 1 - x]) % mod + mod) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s;
n = s.size();
s = " " + s;
pw[0] = 1;
for (int i = 1; i <= n; i++) {
pw[i] = (pw[i - 1] * base) % mod;
hash_fw[i] = (hash_fw[i - 1] * base + (int)(s[i])) % mod;
}
for (int i = n; i >= 1; i--) {
hash_bw[i] = (hash_bw[i + 1] * base + (int)(s[i])) % mod;
}
for (int i = 1; i <= n; i++) {
if (gethash_fw(1, i) == gethash_bw(1, i)) {
f[i] = f[i / 2] + 1;
res += f[i];
} else {
f[i] = 0;
}
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long del;
char s[5000001];
unsigned long long dp[5000001];
int main() {
int i;
unsigned long long l, r, mark, sum;
while (scanf("%s", s + 1) != EOF) {
dp[0] = 0;
sum = 0;
l = r = 0;
del = 1;
mark = 129;
for (i = 1; s[i]; i++) {
l = l * mark + s[i];
r = r + s[i] * del;
del *= mark;
if (l == r) {
dp[i] = dp[i >> 1] + 1;
sum += dp[i];
}
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int r = 0, l = 0, k = 1, Ti = 0, dp[5000005] = {0};
string s;
int main() {
ios::sync_with_stdio(false);
cin >> s;
for (int i = 1; i <= s.size(); i++) {
l = l * 33 + (s[i - 1] - 'A');
r += (s[i - 1] - 'A') * k;
k *= 33;
if (r == l)
dp[i] = dp[i / 2] + 1;
else
dp[i] = 0;
Ti += dp[i];
}
cout << Ti << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 10, P = 29, mod = 1e9 + 7;
string s;
int n, sum, degree[2 * N];
long long p[N];
long long pref_hash[N], suf_hash[N];
bool is_palindrome(int right) {
return (pref_hash[right] * p[n - right]) % mod ==
(suf_hash[1] - suf_hash[right + 1] + mod) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
p[0] = 1;
for (int i = 1; i <= n + 5; ++i) {
p[i] = p[i - 1] * P % mod;
}
for (int i = 1; i <= n; ++i) {
pref_hash[i] = (pref_hash[i - 1] + ((int)s[i - 1] - 48) * p[i]) % mod;
}
for (int i = n; i >= 1; --i) {
suf_hash[i] = (suf_hash[i + 1] + ((int)s[i - 1] - 48) * p[n - i + 1]) % mod;
}
for (int i = 1; i <= n; ++i) {
if (is_palindrome(i)) {
degree[i]++;
degree[2 * i] = degree[i];
degree[2 * i + 1] = degree[i];
sum += degree[i];
}
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000006];
int pre[5000006], n, sum = 1;
int h1, h2, p = 127, pp = 1;
int main() {
pre[1] = 1;
gets(s);
for (int l = 2; s[l - 1]; ++l) {
if (l & 1) {
h2 = (h2 - s[l >> 1] * pp) * p + s[l - 1];
pp *= p;
} else {
h1 = h1 + s[(l >> 1) - 1] * pp;
h2 = h2 * p + s[l - 1];
}
if (h1 == h2) {
pre[l] = pre[l >> 1] + 1;
sum += pre[l];
}
}
printf("%d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long BASE = 666013;
const int Lmax = 5e6 + 2;
int pal[Lmax];
char S[Lmax];
int N, solution;
unsigned long long H1[Lmax], H2[Lmax], Hpow[Lmax];
void pregen() {
Hpow[0] = 1;
for (int i = 1; i <= N; ++i) Hpow[i] = Hpow[i - 1] * BASE;
for (int i = 1; i <= N; ++i) {
H1[i] = H1[i - 1] * BASE + S[i];
H2[i] = H2[i - 1] * BASE + S[N - i + 1];
}
}
unsigned long long getHash(unsigned long long H[], int i, int j) {
return H[j] - H[i - 1] * Hpow[j - i + 1];
}
int main() {
cin.sync_with_stdio(false);
cin >> (S + 1);
N = strlen(S + 1);
pregen();
pal[1] = 1;
for (int i = 2; i <= N; ++i) {
if (getHash(H1, 1, i) == getHash(H2, N - i + 1, N)) {
pal[i] = pal[i / 2] + 1;
}
solution += pal[i];
}
cout << solution + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5e6 + 5;
char s[maxn];
int h[maxn];
const int M = 131;
int main() {
scanf("%s", s);
int p = 0, q = 0, f = 1, ans = 0;
for (int i = 0; s[i]; ++i) {
p = p * M + s[i];
q = q + s[i] * f;
f *= M;
if (p == q) h[i + 1] = h[(i + 1) >> 1] + 1;
ans += h[i + 1];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int r[5000005];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> s;
n = s.size();
unsigned long long f = 0, b = 0, p = 1;
for (int i = 1; i <= n; i++) {
f += s[i - 1] * p;
b = 555 * b + s[i - 1];
p *= 555;
if (f == b) {
r[i] = r[i >> 1] + 1;
}
}
cout << accumulate(r, r + n + 1, 0) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
vector<long long> manacher(long long n, const T &s) {
if (n == 0) {
return vector<long long>();
}
vector<long long> res(2 * n - 1, 0);
long long l = -1, r = -1;
for (long long z = 0; z < 2 * n - 1; z++) {
long long i = (z + 1) >> 1;
long long j = z >> 1;
long long p = (i >= r ? 0 : min(r - i, res[2 * (l + r) - z]));
while (j + p + 1 < n && i - p - 1 >= 0) {
if (!(s[j + p + 1] == s[i - p - 1])) {
break;
}
p++;
}
if (j + p > r) {
l = i - p;
r = j + p;
}
res[z] = p;
}
return res;
}
template <typename T>
vector<long long> LPS(const T &s) {
return manacher((long long)s.size(), s);
}
bool is_palindrome(vector<long long> &lps, long long l, long long r,
long long n) {
return l >= 0 && r < n && (2 * lps[r + l]) >= r - l;
}
void solve() {
string s;
cin >> s;
long long N = s.size();
vector<long long> lps = LPS(s);
long long ans = 0;
vector<long long> palin(N, 0);
for (long long i = 0; i < N; i++) {
if (is_palindrome(lps, 0, i, N)) {
palin[i] = 1;
}
}
vector<long long> dp(N, 0);
for (long long i = 0; i < N; i++) {
if (palin[i] == 0) continue;
long long j = ((i + 1) / 2) - 1, k = 1;
if (j >= 0) {
k += dp[j];
}
ans += k;
dp[i] = k;
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M4 = 1e4 + 10, M5 = 1e5 + 10, M6 = 1e6 + 10;
const int P = 79, maxn = 5000 * 1000 + 10, k = '0' - 1;
const long long mod = 1e9 + 7;
long long p[maxn], h[maxn], h2[maxn];
int n, f[maxn];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
n = (int)(s).size();
p[0] = 1;
for (int i = 1; i < maxn; i++) p[i] = (p[i - 1] * P) % mod;
h[1] = s[0] - k;
for (int i = 1; i < n; i++) h[i + 1] = (h[i] * P + s[i] - k) % mod;
h2[1] = s[0] - k;
for (int i = 1; i < n; i++) h2[i + 1] = (h2[i] + (s[i] - k) * p[i]) % mod;
f[1] = 1;
long long ans = 1;
for (int i = 2; i <= n; i++) {
int t = i / 2;
long long h0 = (h[t] * p[(i + 1) / 2]) % mod,
h1 = (h2[i] - h2[i - t] + mod) % mod;
if (h0 == h1) f[i] = f[i / 2] + 1;
ans += f[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[10000100];
int z[10000100], f[10000100];
int main(void) {
gets(s);
int n = strlen(s);
for (int i = 0; i < n; i++) {
s[i + n] = s[n - i - 1];
}
int l = 0;
for (int i = 1; i < n + n; i++) {
z[i] = l + z[l] > i ? min(l + z[l] - i, z[i - l]) : 0;
while (s[z[i]] == s[i + z[i]]) {
z[i]++;
}
if (i + z[i] > l + z[l]) {
l = i;
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
res += (f[i] = (z[2 * n - i] == i) ? f[i / 2] + 1 : 0);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const unsigned long long base = 2333;
const int maxn = 5e6 + 50;
const int maxm = 10 + 5;
const int maxv = 1e6 + 5;
const int mod = 1e9 + 7;
const int ba = 3e5;
unsigned long long a[maxn];
unsigned long long b[maxn];
unsigned long long pw[maxn];
long long is_pa[maxn];
char s[maxn];
int len;
void Cal_hash() {
a[0] = 0;
len = strlen(s);
for (int i = 0; i < len; i++) {
a[i + 1] = a[i] * base + s[i];
}
b[len + 1] = 0;
for (int i = len - 1; i >= 0; i--) {
b[i + 1] = b[i + 2] * base + s[i];
}
}
void Cal_ans() {
long long ans = 1;
pw[0] = 1;
for (int i = 1; i <= len; i++) pw[i] = pw[i - 1] * base;
is_pa[1] = 1;
for (int i = 2; i <= len; i++) {
if (a[i] == b[1] - b[i + 1] * pw[i]) {
int x = i / 2;
ans += is_pa[x] + 1;
is_pa[i] = is_pa[x] + 1;
}
}
printf("%lld\n", ans);
}
int main() {
scanf("%s", s);
Cal_hash();
Cal_ans();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int MOD = 1e9 + 7;
mt19937 rng((int)chrono::steady_clock::now().time_since_epoch().count());
int uniform(int l, int r) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
const int MAX = 5e6 + 10;
int memo[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long p = uniform(250, MOD - 1);
long long tp = 1;
string str;
cin >> str;
int n = int((str).size());
long long h1 = 0, rh1 = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
h1 = (h1 * p + str[i]) % MOD;
rh1 = (rh1 + tp * str[i]) % MOD;
tp = (tp * p) % MOD;
if (h1 == rh1) memo[i] = memo[(i - 1) / 2] + 1;
ans += memo[i];
}
cout << ans << '\n';
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5000009;
long long md = 2000000063;
long long mdi = 622568113;
long long bs = 257;
long long sv[MAX];
inline long long pow(long long n, long long p) {
if (p == 0) return 1;
if (sv[p]) return sv[p];
long long t = pow(n, p / 2) % md;
if (p % 2) return (((t * t) % md) * n) % md;
return sv[p] = ((t * t) % md);
}
inline long long addDigit(long long n, long long val, long long ind) {
long long temp = (pow(bs, ind) * val) % md;
return (n + temp) % md;
}
inline long long shiftRight(long long n) { return (n * bs) % md; }
inline long long shiftLeft(long long n) { return (n * mdi) % md; }
inline long long removeDigit(long long n, long long val, long long ind) {
long long temp = (pow(bs, ind) * val) % md;
return (n + md - temp) % md;
}
char str[MAX];
long long k[MAX];
int main() {
int n, i;
scanf("%s", str);
n = strlen(str);
k[0] = 1;
if (str[0] == str[1])
k[1] = 2;
else
k[1] = 0;
int res = k[0] + k[1];
long long first = str[0], second = str[1];
for (i = 2; i < n; ++i) {
if (i & 1) {
first = shiftRight(first);
first = addDigit(first, str[i / 2], 0);
second = addDigit(second, str[i], i / 2);
} else {
second = removeDigit(second, str[i / 2], 0);
second = shiftLeft(second);
second = addDigit(second, str[i], (i / 2) - 1);
}
if (first == second) {
k[i] = k[(i - 1) / 2] + 1;
res += k[i];
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 10;
const unsigned long long p = 233;
int n, f[N], ans;
char s[N];
unsigned long long ha[N], pows[N], fha[N];
unsigned long long ask(int l, int r) {
return ha[r] - ha[l - 1] * pows[r - l + 1];
}
unsigned long long fask(int l, int r) {
return fha[l] - fha[r + 1] * pows[r - l + 1];
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
pows[0] = 1;
for (int i = 1; i <= n; i++) {
pows[i] = pows[i - 1] * p;
ha[i] = ha[i - 1] * p + (s[i] - 'a');
}
for (int i = n; i >= 1; i--) fha[i] = fha[i + 1] * p + (s[i] - 'a');
ans = f[1] = 1;
for (int i = 2; i <= n; i++)
if (ask(1, i / 2) == fask((i + 1) / 2 + 1, i))
f[i] = f[i / 2] + 1, ans += f[i];
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x;
scanf("%d", &x);
return x;
}
int readln() {
int x;
scanf("%d\n", &x);
return x;
}
const int MAXN = int(5e6) + 6;
const long long BASE = int(1e4) + 7;
const long long MODC = int(1e9) + 7;
long long Pow[MAXN], a[MAXN], b[MAXN];
char s[MAXN];
int n, deg[MAXN];
long long number(char x) { return int(x) - 47; }
long long calA(int i, int j) {
if (i == 0)
return a[j];
else
return a[j] - a[i - 1] * Pow[j - i + 1];
}
long long calB(int i, int j) {
if (j == n - 1)
return b[i];
else
return b[i] - b[j + 1] * Pow[j - i + 1];
}
int isPalin(int i) { return (calA(0, i) == calB(0, i)); }
int main() {
scanf("%s", &s);
n = strlen(s);
Pow[0] = 1;
a[0] = number(s[0]);
for (int i = 1; i < n; ++i) {
Pow[i] = Pow[i - 1] * BASE;
a[i] = a[i - 1] * BASE + number(s[i]);
}
b[n - 1] = number(s[n - 1]);
for (int i = n - 2; i >= 0; --i) b[i] = b[i + 1] * BASE + number(s[i]);
int ans = 0;
for (int i = 0; i < n; ++i) {
if (i == 0 || isPalin(i))
deg[i] = deg[(i - 1) / 2] + 1;
else
deg[i] = 0;
ans += deg[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s_new[10000005], str[5000005];
int p[10000005];
int Init(void) {
s_new[0] = '$', s_new[1] = '#';
int slen = 2, len = strlen(str);
for (int i = 0; i < len; i++) {
s_new[slen++] = str[i];
s_new[slen++] = '#';
}
s_new[slen] = '\0';
return slen;
}
int Man(void) {
int len = Init();
int max_len = -1;
int id, mx = 0;
for (int i = 1; i < len; i++) {
if (i < mx) {
p[i] = min(p[2 * id - i], mx - i);
} else {
p[i] = 1;
}
while (s_new[i + p[i]] == s_new[i - p[i]]) {
p[i]++;
}
if (mx < i + p[i]) {
id = i;
mx = i + p[i];
}
max_len = max(max_len, p[i] - 1);
}
return max_len;
}
long long dp[10000005];
int main(void) {
long long sum = 0;
scanf("%s", str);
Man();
int fp = 4;
int len = strlen(str);
dp[2] = dp[3] = 1;
for (int k = 1; k < len; k++) {
if (p[fp / 2 + 1] - 1 >= fp / 2) {
dp[fp] = dp[fp + 1] = dp[fp / 2] + 1;
} else {
dp[fp] = dp[fp + 1] = 0;
}
sum += dp[fp + 1];
fp += 2;
}
printf("%lld\n", sum + 1);
return 0;
}
|
#include <bits/stdc++.h>
const int fin = 0, maxn = 10000020;
int n;
char a[maxn];
int p[maxn], f[maxn];
bool b[maxn];
int main() {
int m, ans, i, j;
char ch;
n = 0;
while (scanf("%c", &ch) == 1) a[++n] = ch;
for (i = 1; i <= n; ++i) a[2 * n - i + 2] = a[i];
a[n + 1] = 1;
m = 2 * n + 1;
j = 0;
p[1] = 0;
for (i = 2; i <= m; ++i) {
while (j && a[j + 1] != a[i]) j = p[j];
if (a[j + 1] == a[i]) ++j;
p[i] = j;
}
for (i = p[m]; i; i = p[i]) b[i] = true;
ans = 0;
for (i = 1; i <= n; ++i) {
if (b[i]) f[i] = f[i / 2] + 1;
ans += f[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e6 + 6, P = 1e9 + 7, H = 137;
int h[MAXN], bh[MAXN], pwh[MAXN], dp[MAXN];
string s;
int n;
void input();
int mul(int, int);
int sum(int, int);
void solve();
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
input();
solve();
return 0;
}
void input() {
cin >> s;
n = s.size();
pwh[0] = 1;
for (int i = 1; i <= n; i++) pwh[i] = mul(pwh[i - 1], H);
}
int mul(int a, int b) { return 1ll * a * b % P; }
int sum(int a, int b) { return (P + a + b) % P; }
int get(int l, int r) { return sum(h[r], -mul(h[l], pwh[r - l])); }
void solve() {
for (int i = 0; i < n; i++) h[i + 1] = sum(mul(h[i], H), int(s[i]) + 1);
for (int i = n - 1; i >= 0; i--)
bh[i] = sum(mul(bh[i + 1], H), int(s[i]) + 1);
int ans = 0;
for (int i = 1; i <= n; i++)
if (get(0, i) == sum(bh[0], -mul(bh[i], pwh[i]))) {
int mid = i / 2;
dp[i] = 1;
if (get(0, mid) == get(i - mid, i)) dp[i] += dp[mid];
ans += dp[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long MX = 5000000;
long long base[] = {129, 137};
long long mod[] = {1479386893, 1928476349};
long long powBase[2][MX + 5];
void ctPow() {
powBase[0][0] = powBase[1][0] = 1;
for (long long i = 1; i <= MX; i++) {
powBase[0][i] = (powBase[0][i - 1] * base[0]) % mod[0];
}
}
long long palPre[MX + 5];
void getHash(string s) {
long long len = s.size();
long long hash1 = 0, hash2 = 0, revHash1 = 0, revHash2 = 0;
for (long long i = 0; i < len; i++) {
hash1 = ((hash1 * base[0]) % mod[0] + (s[i] - '0' + 1)) % mod[0];
hash2 = ((hash2 * base[1]) % mod[1] + (s[i] - '0' + 1)) % mod[1];
revHash1 =
(revHash1 + ((s[i] - '0' + 1) * powBase[0][i]) % mod[0]) % mod[0];
if (hash1 == revHash1)
palPre[i] = 1;
else
palPre[i] = 0;
}
}
long long solve(string s) {
getHash(s);
long long len = s.size();
for (long long i = 1; i < len; i++) {
if (palPre[i] != 0) {
palPre[i] += palPre[(i - 1) / 2];
}
}
long long sum = 0;
for (long long i = 0; i < len; i++) sum += palPre[i];
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ctPow();
string s;
cin >> s;
long long ans = solve(s);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5000 * 1000 + 5, base = 737,
mod = 1000 * 1000 * 1000 + 7;
long long dp[maxn];
bool p[maxn];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long x = 0, y = 0, b = 1;
for (long long i = 0; i < (long long)(s).size(); i++) {
x *= base;
x += s[i] - '0';
y += b * (s[i] - '0');
b *= base;
y %= mod;
x %= mod;
b %= mod;
if (x == y) p[i] = true;
}
long long ans = 1;
dp[0] = 1;
for (long long i = 1; i < (long long)(s).size(); i++) {
if (p[i]) dp[i] = dp[(i + 1) / 2 - 1] + 1;
ans += dp[i];
}
cout << ans << endl;
return false;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long fac, fro, bac;
int n, dp[5000005], ans;
char c[5000005];
int main() {
scanf("%s", c), n = strlen(c), fac = 1;
for (register int i = 0; i < n; ++i) {
fro = fro * 13 + c[i], bac = bac + fac * c[i], fac = fac * 13;
if (!(fro ^ bac)) dp[i] = dp[i - 1 >> 1] + 1, ans += dp[i];
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int L;
char str[5333333];
char strrr[5333333 * 2];
int Manacher[5333333 * 2];
int srt[5333333];
void MAN() {
int i;
int mx = 0;
int id;
for (i = 1; i <= 2 * L - 1; i++) {
if (mx > i)
Manacher[i] = min(Manacher[2 * id - i], mx - i);
else
Manacher[i] = 1;
for (; i - Manacher[i] >= 1 &&
strrr[i + Manacher[i]] == strrr[i - Manacher[i]];
Manacher[i]++)
;
if (Manacher[i] + i > mx) {
mx = Manacher[i] + i;
id = i;
}
}
}
int main() {
while (gets(str)) {
L = strlen(str);
for (int i = 0; i <= L - 2; i++) {
strrr[2 * (i + 1) - 1] = str[i];
strrr[2 * (i + 1)] = '#';
};
strrr[2 * (L)-1] = str[L - 1];
MAN();
long long sum = 0;
srt[0] = 1;
sum = 1;
for (int i = 1; i <= L - 1; i++) {
if (Manacher[i + 1] == i + 1) {
srt[i] = srt[(i + 1) / 2 - 1] + 1;
sum += srt[i];
}
}
printf("%lld\n", sum);
memset(str, ' ', sizeof(str));
memset(strrr, ' ', sizeof(strrr));
memset(Manacher, 0, sizeof(Manacher));
memset(srt, 0, sizeof(srt));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1500000000;
const int MOD = 1000000007;
const int HASH = 137;
int prefix[5000000 + 1];
char text[5000000 + 1];
int Power(int x) {
if (x == 0) return 1;
if (prefix[x] == -1) {
int k = Power(x >> 1);
if (x % 2)
prefix[x] = k * k * HASH;
else
prefix[x] = k * k;
}
return prefix[x];
}
int main() {
scanf("%s", text);
int L = strlen(text);
int H[L], RH[L], dp[L], Ans = 1;
for (int i = 0; i < L; i++) prefix[i] = -1;
H[0] = text[0];
for (int i = 1; i < L; i++) H[i] = H[i - 1] * HASH + text[i];
RH[L - 1] = text[L - 1];
for (int i = L - 2; i >= 0; i--) RH[i] = RH[i + 1] * HASH + text[i];
dp[0] = 1;
for (int i = 1; i < L; i++) {
int half = (i + 1) >> 1;
if (i == L - 1 && H[half - 1] == RH[i - half + 1])
dp[i] = dp[half - 1] + 1;
else if (H[half - 1] == RH[i - half + 1] - RH[i + 1] * Power(half))
dp[i] = dp[half - 1] + 1;
else
dp[i] = 0;
Ans += dp[i];
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int d1[(1 << 23)];
int d2[(1 << 23)];
void manacher(string& s) {
int l = 0, r = -1, n = s.size();
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
int k = i > r ? 1 : min(d1[l + r - i], r - i);
while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) k++;
d1[i] = k--;
if (i + k > r) l = i - k, r = i + k;
}
l = 0;
r = -1;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
int k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
k++;
while (i + k <= n && i - k >= 0 && s[i + k - 1] == s[i - k]) k++;
d2[i] = --k;
if (i + k - 1 > r) l = i - k, r = i + k - 1;
}
}
char _s[(1 << 23)];
string s;
int f[(1 << 23)];
long long r;
int main() {
scanf("%s", _s);
s = string(_s);
manacher(s);
int n = ((int)(s).size());
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
if (i - d1[i] < 0) f[i + d1[i]] = 1;
for (int i = 1, ThxDem = n; i < ThxDem; ++i)
if (i - d2[i] == 0) f[i + d2[i]] = 1;
for (int i = 1, ThxDem = n + 1; i < ThxDem; ++i)
if (f[i]) f[i] = 1 + f[i / 2], r += f[i];
printf("%lld\n", r);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 10101010;
char s[N];
int c[N], w[N], n, l, r = -1, p[N], ans;
int main() {
scanf("%s", s);
while (s[n]) n++;
for (int i = 0; i < n; i++) {
if (i <= r)
c[i] = (c[l + r - i] < r - i ? c[l + r - i] : r - i) + 1;
else
c[i] = 1;
while (i - c[i] >= 0 && i + c[i] < n && s[i - c[i]] == s[i + c[i]]) c[i]++;
if (i + --c[i] > r) r = i + c[i], l = i - c[i];
}
r = -1;
for (int i = 0; i < n; i++) {
if (i <= r)
w[i] = (w[l + r - i + 1] < r - i + 1 ? w[l + r - i + 1] : r - i + 1) + 1;
else
w[i] = 0;
while (i - w[i] >= 0 && i + w[i] - 1 < n && s[i - w[i]] == s[i + w[i] - 1])
w[i]++;
if (i + --w[i] + 1 > r) l = i - w[i], r = i + w[i] - 1;
}
p[0] = 1;
for (int i = 1; i < n; i++) {
if (i & 1) {
if (w[(i + 1) / 2] == (i + 1) / 2) p[i] = p[(i - 1) / 2] + 1;
} else if (c[(i + 1) / 2] == (i + 1) / 2)
p[i] = p[(i - 1) / 2] + 1;
ans += p[i];
}
printf("%d", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 5e6 + 10;
long long Hash[mx];
int mod = 3;
char s[mx];
int main() {
gets(s);
int p = 1, a = 0, b = 0, ans = 0;
for (int i = 0; s[i]; i++) {
a = a * mod + s[i];
b += s[i] * p;
p *= mod;
if (a == b) {
Hash[i + 1] = Hash[(i + 1) >> 1] + 1;
ans += Hash[i + 1];
} else
Hash[i + 1] = 0;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e6 + 3;
const int MOD = 1e9 + 9;
const int BASE = 131;
int n;
char s[MAXN];
int Exp[MAXN];
int Hash[MAXN];
int RHash[MAXN];
int L[MAXN];
void calcExp() {
Exp[0] = 1;
for (int i = 1; i < n; ++i) {
Exp[i] = ((long long)Exp[i - 1] * BASE) % MOD;
}
}
void solve() {
gets(s + 1);
n = strlen(s + 1);
Hash[0] = RHash[n + 1] = 0;
for (int i = 1; i <= n; ++i) {
Hash[i] = ((long long)Hash[i - 1] * BASE + s[i]) % MOD;
RHash[n - i + 1] =
((long long)RHash[n - i + 2] * BASE + s[n - i + 1]) % MOD;
}
calcExp();
memset(L, 0, n * sizeof(int));
L[1] = 1;
long long res = 1;
int t = n / 2;
for (int i = 1; i <= t; ++i) {
if (Hash[i] ==
(RHash[i + 1] - ((long long)RHash[i + i + 1] * Exp[i]) % MOD + MOD) %
MOD) {
L[i + i] = L[i] + 1;
res += L[i + i];
}
if (Hash[i + 1] ==
(RHash[i + 1] - ((long long)RHash[i + i + 2] * Exp[i + 1]) % MOD +
MOD) %
MOD) {
L[i + i + 1] = L[i] + 1;
res += L[i + i + 1];
}
}
printf("%I64d", res);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
const long long int INF = LONG_LONG_MAX;
const vector<vector<long long int> > adj4({{0, 1}, {0, -1}, {1, 0}, {-1, 0}});
const vector<vector<long long int> > adj8(
{{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}});
long long int clk_ar[10];
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int powMod(long long int a, long long int b, long long int mod) {
long long int n = 1;
long long int p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= mod;
}
p *= p;
p %= mod;
b /= 2;
}
return n;
}
long long int modularInverse(long long int a, long long int mod) {
return powMod(a, mod - 2, mod);
}
long long int binarysearch(long long int l, long long int r,
bool (*bsfunction)(long long int)) {
while (r - l > 1) {
long long int mid = (l + r) / 2;
bool val = bsfunction(mid);
if (val) {
r = mid;
} else {
l = mid;
}
}
return l;
}
stringstream sss;
const long long int M = 1000075057;
const long long int B = 986444689;
const long long int maxn = 5000010;
long long int pows[maxn];
long long int lh[maxn];
long long int rh[maxn];
long long int dp[maxn];
void MAIN() {
pows[0] = 1;
for (long long int i = (1); i < (maxn); ++i) {
pows[i] = pows[i - 1] * B % M;
}
string s;
cin >> s;
long long int n = s.size();
for (long long int i = 0; i < (n); ++i) {
lh[i + 1] = (lh[i] * B + s[i]) % M;
}
for (long long int i = 0; i < (n); ++i) {
rh[n - i - 1] = (rh[n - i] * B + s[n - i - 1]) % M;
}
long long int r = 0;
dp[0] = 0;
for (long long int i = (1); i < (n + 1); ++i) {
long long int h1 = lh[i];
long long int h2 = (rh[0] - rh[i] * pows[i] % M + M) % M;
if (h1 == h2) {
dp[i] = dp[i / 2] + 1;
}
r += dp[i];
}
cout << (r) << '\n';
}
long long int TESTCASEN = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
sss << R"(
abacaba
)";
for (long long int test = 0; test < (TESTCASEN); ++test) {
MAIN();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5000000, SEED = 99991;
char buf[MAX_N + 2];
int n, f[MAX_N + 1];
bool c[MAX_N + 1];
unsigned long long hs[MAX_N + 1], sh[MAX_N + 1], pw[MAX_N + 1];
int calc(int len) {
if (c[len]) return f[len];
c[len] = 1;
if (len == 1) return f[len] = 1;
int h = len / 2;
if ((hs[(1 + h - 1)] - hs[(1) - 1] * pw[(1 + h - 1) - (1) + 1]) !=
(sh[(n - (len - h + 1) + 1)] -
sh[(n - len + 1) - 1] * pw[(n - (len - h + 1) + 1) - (n - len + 1) + 1]))
return f[len] = 0;
else
return f[len] = calc(h) + 1;
}
int main() {
scanf("%s", buf + 1);
n = strlen(buf + 1), pw[0] = 1ULL;
for (int i = 1; i <= n; i++)
hs[i] = hs[i - 1] * SEED + buf[i], pw[i] = pw[i - 1] * SEED;
reverse(buf + 1, buf + n + 1);
for (int i = 1; i <= n; i++) sh[i] = sh[i - 1] * SEED + buf[i];
int ans = 0;
for (int i = 1; i <= n; i++) ans += calc(i);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 1000000 + 100;
char str[maxn << 1], s[maxn];
int p[maxn << 1];
int ans;
int n;
int f[maxn << 1];
void Init(void) {
str[0] = '$', str[1] = '#';
for (int i = 0; i < n; i++) {
str[i * 2 + 2] = s[i];
str[i * 2 + 3] = '#';
}
int nn = 2 * n + 2;
str[nn] = 0;
int mx = 0, id;
for (int i = 1; i < nn; i++) {
if (mx > i) {
p[i] = min(p[2 * id - i], mx - i);
} else
p[i] = 1;
while (str[i + p[i]] == str[i - p[i]]) p[i]++;
if (i + p[i] > mx) mx = i + p[i], id = i;
}
}
void solve(void) {
long long ans = 0;
for (int i = 1; i <= n; i++) {
int l = 2, r = 2 * i;
int m = (l + r) >> 1;
if (p[m] * 2 - 1 >= r - l + 1) f[r] = f[m - 1 + ((m % 2) ? 0 : -1)] + 1;
ans += f[r];
}
printf("%I64d\n", ans);
}
int main(void) {
scanf("%s", s);
n = strlen(s);
Init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int a = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c) && c != EOF) {
if (c == '-') f = 1;
c = getchar();
}
if (c == EOF) exit(0);
while (isdigit(c)) {
a = a * 10 + c - 48;
c = getchar();
}
return f ? -a : a;
}
const int MAXN = 5e6 + 7;
char s[MAXN], S[MAXN << 1];
int len[MAXN], val[MAXN], L;
void work() {
int maxR = 1, maxI = 1;
for (int i = 1; i <= L; ++i) {
len[i] = min(len[2 * maxI - i], maxR - i);
while (i - len[i] && i + len[i] < 2 * L && S[i - len[i]] == S[i + len[i]])
++len[i];
if (!(i - len[i])) {
int L = (i + len[i]) >> 1;
val[L] = val[L >> 1] + 1;
}
if (i + len[i] >= maxR) {
maxR = i + len[i];
maxI = i;
}
}
}
int main() {
scanf("%s", s + 1);
L = strlen(s + 1);
for (int i = 1; i <= L; ++i) S[2 * i - 1] = s[i];
work();
long long ans = 0;
for (int i = 1; i <= L; ++i) ans += val[i];
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 10;
string s;
int d1[N];
int d2[N];
int sp[N];
int n;
void manacher() {
int l = 0, r = -1;
for (int i = 0; i < n; i++) {
int k = i > r ? 1 : min(d1[l + r - i], r - i);
while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) k++;
d1[i] = k--;
if (i + k > r) l = i - k, r = i + k;
}
l = 0;
r = -1;
for (int i = 0; i < n; i++) {
int k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
k++;
while (i + k <= n && i - k >= 0 && s[i + k - 1] == s[i - k]) k++;
d2[i] = --k;
if (i + k - 1 > r) l = i - k, r = i + k - 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.length();
manacher();
long long res = 1;
sp[0] = 1;
for (int i = 1; i <= n; i++) {
if (~i & 1 && d1[i / 2] - 1 == i / 2) {
sp[i] = sp[i / 2 - 1] + 1;
res += sp[i];
} else if (i & 1 && d2[(i + 1) / 2] == (i + 1) / 2) {
sp[i] = sp[(i + 1) / 2 - 1] + 1;
res += sp[i];
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
char s[5000100];
long long a = 0, b = 0, k = 1, pcount[5000100], sum = 0;
int main() {
gets(s);
int len = strlen(s);
for (int i = 1; i <= len; i++) {
a = s[i - 1] - 'A' + a * 3;
b = b + (s[i - 1] - 'A') * k;
if (a == b) {
pcount[i] = pcount[i / 2] + 1;
}
sum = sum + pcount[i];
k *= 3;
}
printf("%lld", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 5e6 + 1, Base = 256, Mod = 1e9 + 7;
char s[mx];
long long int n, f[mx], ans[mx], res;
long long int ph[mx], sh[mx], Bpow[mx];
int main() {
scanf("%s", s);
n = strlen(s);
Bpow[0] = 1;
for (int i = 1; i <= n; i++) Bpow[i] = (Bpow[i - 1] * Base) % Mod;
ph[0] = s[0];
for (int i = 1; i < n; i++) ph[i] = (ph[i - 1] * Base + s[i]) % Mod;
sh[n - 1] = s[n - 1];
for (int i = n - 2; i >= 0; i--) sh[i] = (sh[i + 1] * Base + s[i]) % Mod;
for (int i = 0; i < n; i++) {
if ((ph[i] == (sh[0] - ((sh[i + 1] * Bpow[i + 1]) % Mod) + Mod) % Mod) ||
(i == n - 1 && ph[i] == sh[0])) {
ans[i] = ans[(i + 1) / 2 - 1] + 1;
res += ans[i];
}
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5e6 + 5;
char s[maxn];
int h[maxn];
const int M = 131;
int main() {
scanf("%s", s);
int p = 0, q = 0, f = 1, ans = 0;
for (int i = 0; s[i]; ++i) {
p = p * M + s[i];
q = q + s[i] * f;
f *= M;
if (p == q) h[i + 1] = h[(i + 1) >> 1] + 1;
ans += h[i + 1];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long MX = 5000000;
long long base = 129;
long long mod = 1479386893;
long long powBase[MX + 5];
void ctPow() {
powBase[0] = 1;
for (long long i = 1; i <= MX; i++) {
powBase[i] = (powBase[i - 1] * base) % mod;
}
}
long long palPre[MX + 5];
void getHash(string s) {
long long len = s.size();
long long hsh = 0, revHsh = 0;
for (long long i = 0; i < len; i++) {
hsh = ((hsh * base) % mod + (s[i] - '0' + 1)) % mod;
revHsh = (revHsh + ((s[i] - '0' + 1) * powBase[i]) % mod) % mod;
;
if (hsh == revHsh)
palPre[i] = 1;
else
palPre[i] = 0;
}
}
long long solve(string s) {
getHash(s);
long long len = s.size();
for (long long i = 1; i < len; i++) {
if (palPre[i] != 0) {
palPre[i] += palPre[(i - 1) / 2];
}
}
long long sum = 0;
for (long long i = 0; i < len; i++) sum += palPre[i];
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ctPow();
string s;
cin >> s;
long long ans = solve(s);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000");
using namespace std;
const int MAXN = 5000010;
char s[MAXN];
unsigned long long e = 256;
unsigned long long pre[MAXN], suf[MAXN];
unsigned long long p1[MAXN], s1[MAXN];
long long K[MAXN];
int main() {
scanf("%s", s + 1);
int i, n = strlen(s + 1);
for (i = 1, pre[0] = 0; i <= n; ++i) pre[i] = pre[i - 1] * e + s[i];
for (i = 2, suf[1] = s[1]; i <= n; ++i)
suf[i] = suf[i - 1] + s[i] * e, e *= 256;
e = 256;
for (i = 1, p1[0] = 0; i <= n; ++i) {
p1[i] = p1[i - 1] * e + s[i];
p1[i] %= 1000000007;
}
for (i = 2, s1[1] = s[1]; i <= n; ++i) {
s1[i] = s1[i - 1] + s[i] * e, e *= 256;
e %= 1000000007, s1[i] %= 1000000007;
}
K[0] = 0;
for (K[0] = 0, i = 1; i <= n; ++i) {
if (pre[i] == suf[i] && p1[i] == s1[i])
K[i] = K[i / 2] + 1;
else
K[i] = 0;
}
long long ans = 0;
for (i = 1; i <= n; ++i) ans += K[i];
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int p[10000010];
int a[10000010];
char s[10000010];
int n;
int min(int x, int y) { return x < y ? x : y; }
void calclcp(char *s) {
int l, r, l1;
l = r = 1;
p[0] = n;
while (l < n) {
if (s[r] == s[r - l])
r++;
else {
l1 = l;
p[l] = r - l;
while (l < n && l < r && (s[r] != s[r - l] || l + p[l - 1] < r)) {
p[l] = min(p[l - l1], r - l);
l++;
}
if (l == r)
while (l < n && s[r] != s[0]) {
p[l] = 0;
l++;
r++;
}
}
}
}
int main() {
int i, m;
long long ans = 0;
scanf("%s", s);
n = strlen(s);
s[n] = '#';
for (i = 1; i <= n; i++) s[n + i] = s[n - i];
s[2 * n + 1] = 0;
m = n;
n = 2 * n + 1;
s[n] = 0;
calclcp(s);
a[0] = 1;
ans = 1;
for (i = 1; i < m; i++) {
if ((p[n - i - 1] << 1) >= i + 1) a[i] = a[(i - 1) >> 1] + 1;
ans += a[i];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long INF64 = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL;
char s[10 * 1000100];
int z[10 * 1000100];
int n;
void Load() {
gets(s);
n = strlen(s);
s[n] = '#';
for (int i = n - 1; i >= 0; i--) s[2 * n - i] = s[i];
}
inline void z_func() {
int l, r, q;
l = r = 0;
for (int k = 1; k < 2 * n + 1; k++) {
if (k > r) {
q = k;
while (q < 2 * n + 1 && s[q] == s[q - k]) q++;
z[k] = q - k;
l = k;
r = q - 1;
} else {
if (z[k - l] < r - k + 1)
z[k] = z[k - l];
else {
q = r + 1;
while (q < 2 * n + 1 && s[q] == s[q - k]) q++;
z[k] = q - k;
l = k;
r = q - 1;
}
}
}
}
inline int f(int pos) {
if (pos == 0) return z[pos] == 1 ? 1 : 0;
if (z[pos] == pos + 1)
return 1 + f((pos - 1) >> 1);
else
return 0;
}
void Solve() {
z_func();
reverse(z, z + 2 * n + 1);
int ans = 0;
for (int i = 0; i < n; i++) ans += f(i);
cout << ans;
}
int main() {
Load();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 1e6 + 10;
const int maxn5 = 5e6 + 10;
const int maxnt = 1.2e6 + 10;
const int maxn3 = 1e3 + 10;
const int mod = 5e8;
const int ssq = 460;
const long long alp = 64;
const long long inf = 2e18;
int dp[maxn5];
long long now, tav, modh, pre[maxn5];
int get_val(char a) {
if (a >= 'a' && a <= 'z') return a - 'a' + 1;
if (a >= 'A' && a <= 'Z') return a - 'A' + 1 + 26;
return a - '0' + 1 + 52;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
modh = 987654319;
pre[0] = get_val(s[0]);
tav = 1;
for (int i = 1; i < n; i++) {
tav *= alp;
tav %= modh;
long long val = get_val(s[i]);
pre[i] = pre[i - 1] + (tav * val);
pre[i] %= modh;
}
dp[0] = 1;
long long ans = 1;
int last = 1;
tav = 1;
now = 0;
for (int i = 1; i < n; i++) {
long long val = get_val(s[i]), val2 = get_val(s[last]);
if (i % 2 == 1) {
now *= alp;
now += val;
now %= modh;
if (i > 1) {
tav *= alp;
tav %= modh;
}
} else {
last++;
now = (modh + now - (tav * val2) % modh) % modh;
now *= alp;
now += val;
now %= modh;
}
if (now == pre[(i + 1) / 2 - 1]) dp[i] = dp[(i + 1) / 2 - 1] + 1;
ans += dp[i];
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string s;
cin >> s;
int n = s.size();
vector<int> d1(n), d2(n), res(n);
for (int i = 0, l = 0, r = -1; i < n; i++) {
int k = (i > r) ? 1 : min(d1[l + r - i], r - i + 1);
while (0 <= i - k && i + k < n && s[i - k] == s[i + k]) {
k++;
}
d1[i] = k--;
if (i + k > r) {
l = i - k;
r = i + k;
}
}
for (int i = 0, l = 0, r = -1; i < n; i++) {
int k = (i > r) ? 0 : min(d2[l + r - i + 1], r - i + 1);
while (0 <= i - k - 1 && i + k < n && s[i - k - 1] == s[i + k]) {
k++;
}
d2[i] = k--;
if (i + k > r) {
r = i + k;
l = i - k - 1;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
int c = (i + 1) / 2;
int t = d2[c];
if (2 * t == i + 1) {
res[i] = 1 + res[c - 1];
} else
res[i] = 0;
} else {
int c = i / 2;
int t = d1[c];
if (2 * t - 1 == i + 1) {
res[i] = 1 + (c == 0 ? 0 : res[c - 1]);
} else
res[i] = 0;
}
ans += res[i];
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
inline void scanint(int &x) {
register int c = 0;
x = 0;
int flag = 0;
for (; ((c != 45) && (c < 48 || c > 57)); c = getchar())
;
for (; ((c == 45) || (c > 47 && c < 58)); c = getchar()) {
if (c == 45)
flag = 1;
else
x = (x << 1) + (x << 3) + c - 48;
}
if (flag) x = -x;
}
int p[10000005], n, len;
char s[10000005];
void manacher() {
n = strlen(s);
len = 2 * n + 1;
p[1] = 1;
int C = 1, R = 2;
int i, _i, flag;
for (i = 2; i < len; i++) {
_i = 2 * C - i;
if (R > i) p[i] = min(p[_i], R - i);
while (((i + p[i]) < len && (i - p[i]) > 0) &&
(((i + p[i] + 1) % 2 == 0) ||
(s[(i + p[i] + 1) / 2] == s[(i - p[i] - 1) / 2])))
p[i]++;
if (i + p[i] > R) {
C = i;
R = i + p[i];
}
}
}
int dp[10000005];
int main() {
int t, m, i, j, k, l, ans, count, temp, sum, flag;
scanf("%s", s);
manacher();
dp[0] = 1;
for (i = 1; i < n; i++) {
int id = i * 2 + 1;
if ((id / 2 + 1) == p[id / 2 + 1]) {
if (i % 2)
dp[i] = dp[i / 2] + 1;
else
dp[i] = dp[i / 2 - 1] + 1;
}
}
long long an = 0;
for (i = 0; i < n; i++) an += dp[i];
cout << an << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
const int MAXN = 5e6 + 100;
int d1[MAXN], d2[MAXN];
string second;
int DP[MAXN];
int rek(int now) {
if (!now) return 0;
int &ret = DP[now];
if (ret != -1) return ret;
ret = 0;
if (now % 2 == 0) {
if (d2[now / 2] == now / 2) {
ret = rek(now / 2) + 1;
}
} else {
if (d1[now / 2] == (now + 1) / 2) {
ret = rek(now / 2) + 1;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> second;
int l = 0, r = -1;
for (int i = 0; i < second.size(); i++) {
int k = (i > r ? 1 : min(d1[l + r - i], r - i + 1));
while (i - k >= 0 && i + k < second.size() &&
second[i - k] == second[i + k]) {
k++;
}
d1[i] = k;
if (i + k - 1 > r) {
l = i - k + 1;
r = i + k - 1;
}
}
l = 0, r = -1;
for (int i = 0; i < second.size(); i++) {
int k = (i > r ? 0 : min(d2[l + r - i + 1], r - i + 1));
while (i - k - 1 >= 0 && i + k < second.size() &&
second[i - k - 1] == second[i + k]) {
k++;
}
d2[i] = k;
if (i + k - 1 > r) {
l = i - k;
r = i + k - 1;
}
}
memset(DP, -1, sizeof DP);
long long res = 0;
for (int i = 0; i < second.size() + 1; i++) res += rek(i);
cout << res << '\n';
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
template <typename first>
inline first abs(const first& a) {
return a < 0 ? -a : a;
}
template <typename first>
inline first sqr(const first& a) {
return a * a;
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
const int INF = 1000 * 1000 * 1000;
const int N = 5 * 1000 * 1000 + 13;
int n;
char s[N];
int d1[N], d2[N];
int k[N];
int main() {
scanf("%s", s);
n = strlen(s);
int lf = 0, rg = -1;
for (int i = 0; i < int(n); i++) {
if (i <= rg) d1[i] = min(d1[lf + (rg - i)], rg - i + 1);
while (i + d1[i] < n && i - d1[i] >= 0 && s[i + d1[i]] == s[i - d1[i]])
d1[i]++;
if (rg < i + d1[i] - 1) rg = i + d1[i] - 1, lf = i - d1[i] + 1;
}
lf = 0, rg = -1;
for (int i = 0; i < int(n); i++) {
if (i <= rg) d2[i] = min(d2[lf + (rg - i)], rg - i);
while (i + d2[i] < n && i - 1 - d2[i] >= 0 &&
s[i + d2[i]] == s[i - 1 - d2[i]])
d2[i]++;
if (rg < i + d2[i]) rg = i + d2[i], lf = i - d2[i];
}
long long ans = 0;
int cur = 0;
k[0] = 1;
for (int i = 1; i <= int(n - 1); i++) {
if (i - d2[i] == 0) k[i + d2[i] - 1] = k[i - 1] + 1;
if (i - d1[i] + 1 == 0) k[i + d1[i] - 1] = k[i - 1] + 1;
}
for (int i = 0; i < int(n); i++) ans += k[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 5, mod = 1e9 + 7, pr = 31, mod2 = 1e9 + 9, pr2 = 53;
int dp[N];
pair<int, int> inv[N], a[N], b[N];
string s;
int fp(int a, int p, int m) {
if (!p) return 1;
int t = fp(a, p >> 1, m);
t = (t * 1ll * t) % m;
if (p & 1) t = (t * 1ll * a) % m;
return t;
}
int n;
pair<int, int> get(int i, int j) {
pair<int, int> t;
t.first = (b[j].first - b[i + 1].first + mod) % mod;
t.first = (t.first * 1ll * inv[n - i + 1].first) % mod;
t.second = (b[j].second - b[i + 1].second + mod2) % mod2;
t.second = (t.second * 1ll * inv[n - i + 1].second) % mod2;
return t;
}
int get(char x) {
if (x >= 'a' && x <= 'z') return x - 'a' + 1;
if (x >= '0' && x <= '9') return x - '0' + 27;
return x - 'A' + 38;
}
int pw[N], pw2[N], S[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
pw[0] = pw2[0] = 1;
for (int i = 1; i < n; i++) {
pw[i] = (pw[i - 1] * 1ll * pr) % mod;
pw2[i] = (pw2[i - 1] * 1ll * pr2) % mod2;
}
inv[n].first = fp(pw[n - 1], mod - 2, mod);
inv[n].second = fp(pw2[n - 1], mod2 - 2, mod2);
for (int i = n - 1; i >= 0; i--) {
inv[i].first = (inv[i + 1].first * 1ll * pw[1]) % mod;
inv[i].second = (inv[i + 1].second * 1ll * pw2[1]) % mod2;
}
for (int i = 1; i <= n; i++) {
S[i] = get(s[i - 1]);
a[i].first = (S[i] * 1ll * pw[i - 1]) % mod;
a[i].second = (S[i] * 1ll * pw2[i - 1]) % mod2;
a[i].first += a[i - 1].first;
if (a[i].first >= mod) a[i].first -= mod;
a[i].second += a[i - 1].second;
if (a[i].second >= mod2) a[i].second -= mod2;
}
for (int i = n, j = 0; i >= 1; i--, j++) {
b[i].first = (S[i] * 1ll * pw[j]) % mod;
b[i].second = (S[i] * 1ll * pw2[j]) % mod2;
b[i].first += b[i + 1].first;
if (b[i].first >= mod) b[i].first -= mod;
b[i].second += b[i + 1].second;
if (b[i].second >= mod2) b[i].second -= mod2;
}
long long ans = 1;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i >> 1] == get(i, i - (i >> 1) + 1)) dp[i] = dp[i >> 1] + 1;
ans += dp[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inpL;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string inp;
cin >> inp;
long long n = inp.length();
long long pref[n + 1], suff[n + 1], power[n + 2];
long long dp[n + 1];
power[0] = 1;
dp[0] = 0;
inpL = n;
pref[0] = 0;
suff[0] = 0;
string t = inp;
reverse(t.begin(), t.end());
for (long long i = 1; i < n + 1; i++) {
long long per = power[i - 1];
pref[i] = (pref[i - 1] + ((inp[i - 1] - '0' + 1) * (per))) % 1000000007;
suff[i] = (suff[i - 1] + ((t[i - 1] - '0' + 1) * (per))) % 1000000007;
power[i] = (power[i - 1] * 83) % 1000000007;
}
long long ans = 0;
string temp = "";
for (long long i = 0; i < n; i++) {
temp.push_back(inp[i]);
long long len = i + 1;
if (len % 2 == 0) {
if (((pref[len / 2] * power[inpL - len]) % 1000000007) ==
(suff[inpL - (len / 2)] - suff[inpL - len] + 1000000007) %
1000000007) {
dp[len] = dp[len / 2] + 1;
ans += dp[len];
} else
dp[len] = 0;
} else if (len % 2 == 1) {
if (((pref[len / 2] * power[inpL - len]) % 1000000007) ==
((suff[inpL - (len / 2) - 1] - suff[inpL - len] + 1000000007) %
1000000007)) {
dp[len] = dp[len / 2] + 1;
ans += dp[len];
} else
dp[len] = 0;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
char str[5555555];
int d[5555555];
int main() {
while (scanf("%s", str + 1) != EOF) {
int len = strlen(str + 1), tp = 3, p = 1;
int a = 0, b = 0, ans = 0;
d[1] = 0;
for (int i = 1; i <= len; i++) {
a = a * tp + str[i], b = b + str[i] * p, p = p * tp;
if (a == b) {
d[i] = d[i / 2] + 1;
ans += d[i];
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char cad[5000001];
unsigned long long h[5000001], h2[5000001], pot[5000000];
int f[5000001];
int i, j, res, l;
void rev() {
int med = l / 2;
for (i = 0; i < med; i++) {
swap(cad[i], cad[l - i - 1]);
}
}
unsigned long long coso(int i, int j) {
swap(i, j);
i = l - i - 1;
j = l - j - 1;
if ((i == 0) && (j == 0)) {
return h2[0];
}
if (i == 0) {
return (h2[j]);
}
unsigned long long a, x, d, m, exp;
x = (j - i + 1);
x = pot[x];
a = (h2[i - 1] * x) % 4294967291;
return (4294967291 + h2[j] - a) % 4294967291ll;
}
unsigned long long cosa(int i, int j) { return (h[j]); }
int func(int l) {
if (f[l] == -1) {
if (l == 0) {
f[l] = 0;
return 0;
}
if (l == 1) {
f[l] = 1;
return 1;
}
int med = (l - 1) / 2;
int res;
if (cosa(0, med - (l & 1)) == coso(med + 1, l - 1)) {
res = func(med + 1 - (l & 1)) + 1;
} else {
res = 0;
}
f[l] = res;
return res;
} else
return f[l];
}
int main() {
pot[0] = 1;
for (i = 1; i <= 5000000; i++) {
pot[i] = (pot[i - 1] * 64) % 4294967291ll;
}
scanf("%s", &cad);
l = 0;
while (cad[l] != 0) {
if ((cad[l] >= '0') && (cad[l] <= '9')) {
cad[l] = cad[l] - '0';
}
if ((cad[l] >= 'a') && (cad[l] <= 'z')) {
cad[l] = cad[l] - 'a' + 10;
}
if ((cad[l] >= 'A') && (cad[l] <= 'Z')) {
cad[l] = cad[l] - 'A' + 36;
}
l++;
}
h[0] = cad[0];
for (i = 1; i < l; i++) {
h[i] = (h[i - 1] * 64) % 4294967291;
h[i] = (h[i] + cad[i]) % 4294967291;
}
rev();
h2[0] = cad[0];
for (i = 1; i < l; i++) {
h2[i] = (h2[i - 1] * 64) % 4294967291;
h2[i] = (h2[i] + cad[i]) % 4294967291;
}
for (i = 0; i <= l; i++) {
f[i] = -1;
}
for (i = 1; i <= l; i++) {
res = res + func(i);
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 5;
char s[maxn];
int n;
struct haash {
int seed, mod, hs[maxn], bas[maxn];
void init() {
bas[0] = 1;
for (int i = 1; i < n + 1; ++i) {
bas[i] = 1ll * bas[i - 1] * seed % mod;
hs[i] = 1ll * hs[i - 1] * seed % mod + s[i];
if (hs[i] >= mod) hs[i] -= mod;
}
}
int getsum(int *h, int l, int r) {
int res = h[r] - 1ll * h[l - 1] * bas[r - l + 1] % mod;
if (res < 0) res += mod;
return res;
}
} hh[2];
void hash_init() {
hh[0].seed = 18051329, hh[0].mod = 998244353;
hh[0].init();
reverse(s + 1, s + n + 1);
hh[1].seed = 18051329, hh[1].mod = 998244353;
hh[1].init();
}
int ww[maxn];
void solve() {
long long ans = 1;
ww[1] = 1;
for (int i = 2; i < n + 1; ++i) {
if (hh[0].getsum(hh[0].hs, 1, i / 2) ==
hh[1].getsum(hh[1].hs, n - i + 1, n - (i + 1) / 2))
ww[i] = ww[i / 2] + 1;
ans += ww[i];
}
printf("%lld\n", ans);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
hash_init();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long f(char c) {
if (isdigit(c)) return c - '0' + 1;
if (islower(c)) return c - 'a' + 11;
return c - 'A' + 37;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
s = '#' + s;
long long n = s.size() - 1;
long long e[n + 2];
e[0] = 1;
long long P = 67;
for (long long i = 1; i < n + 2; ++i) e[i] = e[i - 1] * P;
long long p[n + 1];
p[0] = 0;
for (long long i = 1; i <= n; ++i) p[i] = (p[i - 1] + f(s[i]) * e[i]);
long long q[n + 2];
q[n + 1] = 0;
for (long long i = n; i >= 1; --i) q[i] = (q[i + 1] + f(s[i]) * e[n + 1 - i]);
long long d[n + 1];
d[0] = 0;
for (long long i = 1; i <= n; ++i) {
if (p[i / 2] * e[n - i] - (q[(i + 3) / 2] - q[i + 1]))
d[i] = 0;
else
d[i] = d[i / 2] + 1;
}
long long ans = accumulate(d + 1, d + n + 1, 0LL);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const int64_t modulo = 1000000000000037LL, base = 128;
int64_t prefix, suffix, multi = 1, answer = 1;
int d[5 * 1000001];
char line[5 * 1000001];
int main() {
char *c;
int i;
scanf("%s", line);
for (c = line, i = 0, d[0] = 1; *c; ++c, ++i) {
prefix = ((prefix * base) % modulo + line[i]) % modulo;
suffix = ((multi * line[i]) % modulo + suffix) % modulo;
multi = (multi * base) % modulo;
int prev = (i + 1) / 2 - 1;
if (i && prefix == suffix) {
d[i] = 1 + d[prev];
answer += d[i];
}
}
printf("%lld\n", answer);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000010];
int f[5000010];
int main() {
scanf("%s", s);
int l = 0, r = 0, e = 1, ans = 0;
for (int i = 0; s[i]; i++) {
l = l * 103 + s[i];
r = r + s[i] * e;
e *= 103;
if (l == r) f[i + 1] = f[(i + 1) / 2] + 1;
ans += f[i + 1];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 10, base = 103;
int power[maxn] = {1}, hs1, hs2, ans, dp[maxn];
string s;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
for (int i = 1; i < maxn; i++) power[i] = power[i - 1] * base;
for (int i = 0; i < s.size(); i++) {
hs1 = hs1 * base + s[i] - 'a' + 1;
hs2 = hs2 + (s[i] - 'a' + 1) * power[i];
if (hs1 == hs2) ans += (dp[i + 1] = dp[(i + 1) / 2] + 1);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 1e6 + 10;
const int maxn5 = 5e6 + 10;
const int maxnt = 1.2e6 + 10;
const int maxn3 = 1e3 + 10;
const int mod = 5e8;
const int ssq = 460;
const long long alp = 64;
const long long inf = 2e18;
int dp[maxn5];
long long now, tav, modh, pre[maxn5];
int get_val(char a) {
if (a >= 'a' && a <= 'z') return a - 'a' + 1;
if (a >= 'A' && a <= 'Z') return a - 'A' + 1 + 26;
return a - '0' + 1 + 52;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
modh = 1610612743;
pre[0] = get_val(s[0]);
tav = 1;
for (int i = 1; i < n; i++) {
tav *= alp;
tav %= modh;
long long val = get_val(s[i]);
pre[i] = pre[i - 1] + (tav * val);
pre[i] %= modh;
}
dp[0] = 1;
long long ans = 1;
int last = 1;
tav = 1;
now = 0;
for (int i = 1; i < n; i++) {
long long val = get_val(s[i]), val2 = get_val(s[last]);
if (i % 2 == 1) {
now *= alp;
now += val;
now %= modh;
if (i > 1) {
tav *= alp;
tav %= modh;
}
} else {
last++;
now = (modh + now - (tav * val2) % modh) % modh;
now *= alp;
now += val;
now %= modh;
}
if (now == pre[(i + 1) / 2 - 1]) dp[i] = dp[(i + 1) / 2 - 1] + 1;
ans += dp[i];
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000008;
int n, ans, f[maxn], p[maxn << 1];
char S[maxn << 1];
void Manacher() {
int Id = 0;
for (int i = 1; i < n; i++) {
if (Id + p[Id] <= i)
p[i] = 1;
else
p[i] = min(Id + p[Id] - i, p[Id * 2 - i]);
while (S[i + p[i]] == S[i - p[i]]) p[i]++;
if (p[i] + i > p[Id] + Id) Id = i;
}
}
int main() {
scanf("%s", S);
n = strlen(S) + 1 << 1;
for (int i = n - 1; i; i--) S[i] = (i & 1) ? '#' : S[i - 1 >> 1];
S[0] = '$';
Manacher();
for (int i = 1; i < (n >> 1); i++)
f[i] = p[i + 1] == i + 1 ? f[i >> 1] + 1 : 0, ans += f[i];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int SEED = 103;
static const int MAXN = 5000000;
long long f[MAXN + 10];
int dp[MAXN + 10];
char s[MAXN + 10];
int main() {
scanf("%s", s);
int len = strlen(s);
f[0] = 1;
for (int i = 1; i < len; i++) f[i] = f[i - 1] * SEED;
long long pre = 0, tail = 0, ans = 0;
for (int i = 0; i < len; i++) {
pre = pre * SEED + s[i];
tail = tail + f[i] * s[i];
if (pre == tail) {
dp[i + 1] = dp[i + 1 >> 1] + 1;
ans += dp[i + 1];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 10;
string s;
int d1[N];
int d2[N];
int n, sp[N];
void manacher() {
int l = 0, r = -1;
for (int i = 0; i < n; i++) {
int k = i > r ? 1 : min(d1[l + r - i], r - i);
while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) k++;
d1[i] = k--;
if (i + k > r) l = i - k, r = i + k;
}
l = 0;
r = -1;
for (int i = 0; i < n; i++) {
int k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
k++;
while (i + k <= n && i - k >= 0 && s[i + k - 1] == s[i - k]) k++;
d2[i] = --k;
if (i + k - 1 > r) l = i - k, r = i + k - 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.length();
manacher();
long long res = 1;
sp[0] = 1;
for (int i = 1; i <= n; i++) {
if (~i & 1 && d1[i / 2] - 1 == i / 2)
sp[i] = sp[i / 2 - 1] + 1, res += sp[i];
else if (i & 1 && d2[(i + 1) / 2] == (i + 1) / 2)
sp[i] = sp[(i + 1) / 2 - 1] + 1, res += sp[i];
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int DIM = 5 * 1000 * 1000 + 10;
char s[DIM];
int l;
long long h[DIM], hr[DIM], st[DIM];
int p[DIM];
void init() {
st[0] = 1;
for (int i = (1); i < (DIM); i++) st[i] = st[i - 1] * 137;
for (int i = (0); i < (l); i++) h[i + 1] = h[i] * 137 + s[i];
for (int i = l - 1; i >= 0; i--) hr[i] = hr[i + 1] * 137 + s[i];
}
bool pal(int k) {
long long h1 = h[k + 1];
long long h2 = hr[0] - hr[k + 1] * st[k + 1];
return (h1 == h2);
}
int main() {
scanf("%s", s);
l = strlen(s);
init();
int ans = 0;
ans++;
p[0] = 1;
pal(0);
for (int i = (1); i < (l); i++) {
if (pal(i)) {
p[i] = p[(i - 1) / 2] + 1;
ans += p[i];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000003;
char s[maxn];
int len;
int degree[maxn];
const unsigned int basis = 131;
unsigned int now = 1;
unsigned int nowh = s[0];
unsigned int renowh = s[0];
bool is(int r) {
now *= basis;
nowh = nowh * basis + s[r];
renowh += s[r] * now;
return nowh == renowh;
}
int ans = 1;
int main() {
scanf("%s", s);
len = strlen(s);
degree[0] = 1;
now = 1;
nowh = s[0];
renowh = s[0];
for (int i = 1; i <= len - 1; ++i) {
if (is(i)) {
degree[i] = degree[(i + 1) / 2 - 1] + 1;
ans += degree[i];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e6 + 2;
const long long INF = 1e9;
const int M = 1e9 + 7;
const int b = 727;
int n, q, ans, a[maxn], h[maxn], hr[maxn], dp[maxn];
string s, k;
int get(int l, int r) {
return (hr[r] - (long long)hr[l] * a[r - l] % M + M) % M;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
k = s;
reverse(k.begin(), k.end());
a[0] = 1;
n = s.size();
for (int i = 1; i <= n; i++) a[i] = (long long)a[i - 1] * b % M;
for (int i = 1; i <= n; i++) {
h[i] = ((long long)h[i - 1] * b + s[i - 1]) % M;
hr[i] = ((long long)hr[i - 1] * b + k[i - 1]) % M;
}
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (h[i] == get(n - i, n)) dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
cout << ans + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e6 + 5;
char s[MAXN];
char Ma[MAXN * 2];
int Mp[MAXN * 2];
int dp[MAXN];
int len;
void Manacher(char s[]) {
int l = 0;
Ma[l++] = '$';
Ma[l++] = '#';
for (int i = 0; i < len; i++) {
Ma[l++] = s[i];
Ma[l++] = '#';
}
Ma[l] = 0;
int mx = 0, id = 0;
for (int i = 0; i < l; i++) {
Mp[i] = mx > i ? min(Mp[2 * id - i], mx - i) : 1;
while (Ma[i + Mp[i]] == Ma[i - Mp[i]]) Mp[i]++;
if (i + Mp[i] > mx) {
mx = i + Mp[i];
id = i;
}
}
}
int main() {
scanf("%s", s);
len = strlen(s);
Manacher(s);
long long ans = 0;
for (int i = 1; i <= len; i++) {
if (Mp[i + 1] >= i + 1) {
dp[i] = dp[i >> 1] + 1;
}
ans += dp[i];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int base = 131;
unsigned long long hl[5000010], p[5000010], hr[5000010];
char s[5000010];
unsigned long long get1(int l, int r) {
return hl[r] - hl[l - 1] * p[r - l + 1];
}
unsigned long long get2(int l, int r) {
return hr[r] - hr[l - 1] * p[r - l + 1];
}
int f[5000010];
int main() {
scanf("%s", s + 1);
p[0] = 1;
int l = strlen(s + 1);
for (int i = 1; i <= l; i++) {
hl[i] = hl[i - 1] * base + s[i];
p[i] = p[i - 1] * base;
}
for (int i = l; i; i--) {
hr[l - i + 1] = hr[l - i] * base + s[i];
}
int ans = 0;
for (int i = 1; i <= l; i++) {
unsigned long long t1 = get1(1, i / 2), t2 = get2(l - i + 1, l - i + i / 2);
if (t1 == t2) f[i] = f[i / 2] + 1;
ans += f[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = int(5e6) + 10, p = 1201, MOD = int(1e9) + 7;
string s;
int a[N];
long long int DP[N], L[N], R[N];
void build_hash() {
int len = (int)(s.size());
for (int i = 0; i < len; i++) {
a[i] = s[i] - '.';
}
long long int temp = 1;
for (int i = 1; i <= len; i++) {
L[i] = (L[i - 1] + a[i - 1] * temp) % MOD;
temp = (temp * p) % MOD;
}
for (int i = 1; i <= len; i++) {
R[i] = (R[i - 1] * p + a[i - 1]) % MOD;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
long long int ans = 0;
build_hash();
for (int i = (int)1; i < (int)(int)(s.size()) + 1; i++) {
if (L[i] == R[i]) {
DP[i] = DP[i >> 1] + 1;
ans += DP[i];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const long double eps = 1e-7;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
int dx[8] = {+1, +1, +1, 0, 0, -1, -1, -1};
int dy[8] = {+1, 0, -1, +1, -1, +1, 0, -1};
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
template <typename T>
T gcd(T a, T mp) {
if (a == 0) return mp;
return gcd(mp % a, a);
}
template <typename T>
T powm(T a, T mp, long long m) {
T cnt = 1;
while (mp > 0) {
if (mp % 2 == 1) cnt = (cnt * a) % m;
mp /= 2;
a = (a * a) % m;
}
return cnt % m;
}
long long ncr(long long n, long long r) {
long long res = 1;
if (r > n) return 0;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long sqr(long long x) { return x * x; }
void prec() {}
struct Hashs {
vector<int> hashs;
vector<int> pows;
int P;
int MOD;
Hashs() {}
Hashs(string &s, int P, int MOD) : P(P), MOD(MOD) {
int n = s.size();
pows.resize(n + 1, 0);
hashs.resize(n + 1, 0);
pows[0] = 1;
for (int i = n - 1; i >= 0; i--) {
hashs[i] = (1LL * hashs[i + 1] * P + s[i] - 'a' + 1) % MOD;
pows[n - i] = (1LL * pows[n - i - 1] * P) % MOD;
}
pows[n] = (1LL * pows[n - 1] * P) % MOD;
}
int get_hash(int l, int r) {
int ans = hashs[l] + MOD - (1LL * hashs[r + 1] * pows[r - l + 1]) % MOD;
ans %= MOD;
return ans;
}
};
Hashs h1, h2;
string s, t;
void run() {
cin >> s;
int n = (long long)s.size();
t = s;
reverse((t).begin(), (t).end());
h1 = Hashs(s, 31, 1000000009);
h2 = Hashs(t, 31, 1000000009);
long long dp[n + 5];
dp[0] = 1;
long long ans = 1;
for (long long i = (1); i <= (n - 1); ++i) {
dp[i] = 0;
if (h1.get_hash(0, i) == h2.get_hash(n - i - 1, n - 1) and (i + 1) & 1)
dp[i] = dp[i / 2 - 1] + 1;
else if (h1.get_hash(0, i) == h2.get_hash(n - i - 1, n - 1))
dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
cout << ans;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int tc = 1;
prec();
for (long long i = 0; i < tc; ++i) run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long N = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
string str;
cin >> str;
vector<unsigned long long> hash[2];
unsigned long long tmp = N;
hash[0].push_back(str[0]);
hash[1].push_back(str[0]);
for (int i = 1; i < str.size(); ++i) {
hash[0].push_back(hash[0].back() * N + str[i]);
hash[1].push_back(hash[1].back() + str[i] * tmp);
tmp *= N;
}
int ans = 1;
vector<int> dp(str.size());
dp[0] = 1;
for (int i = 1; i < str.size(); ++i) {
if (hash[0][i] == hash[1][i]) {
dp[i] = dp[(i - 1) / 2] + 1;
ans += dp[i];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 5e6 + 10;
const long long INF = 1e18 + 5;
const long long MOD = 1e9 + 7;
const long long MAX = 25;
const long long N = 2.5e5 + 200;
const double PI = 3.14159265358979323846264338327950288419716939937510;
long long d[M];
struct str_hash {
vector<int> h1, h2;
static vector<int> b1, b2;
constexpr static int B = 31, M1 = 1e9 + 7, M2 = 1e9 + 9;
str_hash(const string& s) {
h1.resize(s.size() + 1, 0);
h2.resize(s.size() + 1, 0);
b1.reserve(s.size() + 1), b2.reserve(s.size() + 1);
while (b1.size() <= s.size()) {
b1.push_back(1LL * b1.back() * B % M1);
b2.push_back(1LL * b2.back() * B % M2);
}
for (int i = 0; i < s.size(); ++i) {
h1[i + 1] = (1LL * h1[i] * B + s[i]) % M1;
h2[i + 1] = (1LL * h2[i] * B + s[i]) % M2;
}
}
long long hash(int i, int j) const {
long long a1 = (h1[j + 1] - 1LL * h1[i] * b1[j - i + 1]) % M1;
long long a2 = (h2[j + 1] - 1LL * h2[i] * b2[j - i + 1]) % M2;
if (a1 < 0) a1 += M1;
if (a2 < 0) a2 += M2;
return a1 ^ (a2 << 32);
}
};
vector<int> str_hash::b1 = {1}, str_hash::b2 = {1};
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string s;
cin >> s;
string t(s);
reverse(t.begin(), t.end());
str_hash h(s);
str_hash g(t);
long long sum = 1;
d[1] = 1;
for (long long i = 1; i < s.length(); i++) {
long long u = h.hash(0, i / 2);
long long y = g.hash(s.length() - 1 - i, s.length() - 1 - i + i / 2);
if (u == y) d[i + 1] = d[(i + 1) / 2] + 1;
sum += d[i + 1];
}
cout << sum << "\n";
}
|
#include <bits/stdc++.h>
const int N = 6e6, M = 107;
int a[5000005], l, r, t, i, p = 1;
char s[5000005];
int main() {
for (gets(s); s[i]; i++)
l = l * M + s[i], r += s[i] * p, p *= M,
a[i + 1] = (l == r) ? a[(i + 1) / 2] + 1 : 0, t += a[i + 1];
printf("%d\n", t);
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5e6 + 10;
const int Prime = 13331;
unsigned long long prePrime[Maxn], Hash_1[Maxn], Hash_2[Maxn];
char str[Maxn];
int dp[Maxn];
unsigned long long getHash(unsigned long long* Hash, int l, int r) {
return Hash[r] - Hash[l - 1] * prePrime[r - l + 1];
}
int main() {
scanf("%s", str + 1);
int strLen = strlen(str + 1);
prePrime[0] = 1;
for (int i = 1; i <= strLen; ++i) {
Hash_1[i] = Hash_1[i - 1] * Prime + str[i];
prePrime[i] = prePrime[i - 1] * Prime;
}
for (int i = 1; i <= strLen; ++i) {
Hash_2[i] = Hash_2[i - 1] * Prime + str[strLen - i + 1];
}
long long result = 0;
for (int i = 1; i <= strLen; ++i) {
if ((i & 1) &&
getHash(Hash_1, 1, (i + 1) >> 1) !=
getHash(Hash_2, strLen - i + 1, strLen - ((i + 1) >> 1) + 1))
continue;
if ((i & 1) == 0 && getHash(Hash_1, 1, i >> 1) !=
getHash(Hash_2, strLen - i + 1, strLen - (i >> 1)))
continue;
dp[i] = dp[i / 2] + 1;
result += dp[i];
}
printf("%lld\n", result);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 5000010, seed = 10007;
long long n, m, k, u, v, x, y, t, a, b, ans;
int dp[MAXN];
long long tav[MAXN];
long long hl[MAXN];
long long hr[MAXN];
string s;
long long gethl(int l, int r) {
long long res = (hl[r] - hl[l - 1] * tav[r - l + 1]) % mod;
return (res + mod) % mod;
}
long long gethr(int l, int r) {
long long res = (hr[l] - hr[r + 1] * tav[r - l + 1]) % mod;
return (res + mod) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
tav[0] = 1;
for (int i = 1; i < MAXN; i++) tav[i] = tav[i - 1] * seed % mod;
cin >> s;
n = s.size();
s = " " + s;
for (int i = 1; i <= n; i++) hl[i] = (hl[i - 1] * seed + s[i]) % mod;
for (int i = n; i; i--) hr[i] = (hr[i + 1] * seed + s[i]) % mod;
for (int i = 1; i <= n; i++) {
int mid = (i + 1) / 2;
int a = mid, b = mid + 1;
if (i & 1) a--;
if (gethl(1, a) != gethr(b, i)) continue;
dp[i] = dp[a] + 1;
ans += dp[i];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
int extend[5000000], next[5000000], re[5000000 + 1], pal[5000000 + 1];
char S[5000000 + 1], S_[5000000 + 1];
int main() {
int n, p, a, l, i, j, ans = 0;
scanf("%s", S);
n = strlen(S);
for (i = 0; i < n; i++) {
S_[i] = S[n - i - 1];
}
memset(re, 0, sizeof(re));
memset(pal, 0, sizeof(pal));
next[0] = n;
j = -1;
p = 0;
a = 0;
for (i = 1; i < n; i++) {
l = next[i - a];
if (i + l < p) {
next[i] = l;
} else {
if (j < 0) {
p = i;
j = 0;
}
while (p < n && S[p] == S[j]) {
p++;
j++;
}
next[i] = j;
a = i;
}
j--;
}
j = -1;
a = 0;
p = -1;
for (i = 0; i < n; i++) {
l = next[i - a];
if (i + l < p) {
extend[i] = l;
} else {
if (j < 0) {
p = i;
j = 0;
}
while (p < n && S_[p] == S[j]) {
p++;
j++;
}
extend[i] = j;
a = i;
}
j--;
if (extend[i] == n - i) {
re[n - i] = 1;
}
}
for (i = 1; i <= n; i++) {
if (re[i]) {
pal[i] = pal[i >> 1] + 1;
ans += pal[i];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
double const PI = 4 * atan(1.0);
using namespace std;
char s[5000111];
int f1[5000111] = {0}, f2[5000111] = {0}, f[5000111];
int n, res;
void manacher_odd() {
int l = 0, r = -1, k;
for (int i = 1; i < n; i++) {
k = (i > r ? 0 : min(f1[l + r - i], r - i)) + 1;
while (i - k >= 0 && i + k < n && s[i - k] == s[i + k]) k++;
f1[i] = --k;
if (i + f1[i] > r) l = i - f1[i], r = i + f1[i];
}
}
void manacher_even() {
int l = 0, r = -1, k;
for (int i = 1; i < n; i++) {
k = (i > r ? 0 : min(f2[l + r - i], r - i + 1)) + 1;
while (i - k >= 0 && i + k - 1 < n && s[i - k] == s[i + k - 1]) k++;
f2[i] = --k;
if (i + f2[i] - 1 > r) l = i - f2[i], r = i + f2[i] - 1;
}
}
int main() {
scanf("%s", s);
n = strlen(s);
manacher_odd();
manacher_even();
f[0] = 1;
res = 1;
for (int i = 1; i < n; i++) {
if (i & 1) {
if (f2[(i + 1) / 2] >= (i + 1) / 2)
f[i] = f[(i - 1) / 2] + 1;
else
f[i] = 0;
} else {
if (f1[i / 2] >= i / 2)
f[i] = f[i / 2 - 1] + 1;
else
f[i] = 0;
}
res += f[i];
}
printf("%d", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)5e6 + 100;
const int mod = (int)1e9 + 7;
const int maxlog = (int)20;
const int P = mod;
string second;
int dp[maxn], h[maxn], hr[maxn], pw[maxn], sum;
int get(int l, int r) { return h[r + 1] - h[l] * pw[r - l + 1]; }
int getr(int l, int r) { return hr[r + 1] - hr[l] * pw[r - l + 1]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> second;
int n = second.size();
pw[0] = 1;
for (int i = 0; i < n; i++) {
h[i + 1] = h[i] * P + second[i];
hr[i + 1] = hr[i] * P + second[n - i - 1];
pw[i + 1] = pw[i] * P;
}
dp[0] = 1;
sum = 1;
for (int i = 1; i < n; i++) {
if (get(0, i) == getr(n - i - 1, n - 1)) dp[i] = dp[(i + 1) / 2 - 1] + 1;
sum += dp[i];
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 5e6 + 100;
char s[N];
int dp[N];
unsigned long long hash1[N], hash2[N];
unsigned long long f[N];
int n;
void HASH() {
hash1[0] = hash2[n + 1] = 0;
f[0] = 1;
for (int i = 1; i <= n; i++) {
hash1[i] = hash1[i - 1] * 233 + s[i];
f[i] = f[i - 1] * 233;
}
for (int i = n; i >= 1; i--) hash2[i] = hash2[i + 1] * 233 + s[i];
}
inline unsigned long long gethash1(int l, int r) {
return hash1[r] - hash1[l - 1] * f[r - l + 1];
}
inline unsigned long long gethash2(int l, int r) {
return hash2[l] - hash2[r + 1] * f[r - l + 1];
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
HASH();
int ans = 0;
for (int i = 1; i <= n; i++) {
if (gethash1(1, i) == gethash2(1, i)) {
if (i & 1)
dp[i] = dp[(i - 1) / 2] + 1;
else
dp[i] = dp[i / 2] + 1;
} else
dp[i] = 0;
ans += dp[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 1e6 + 10;
const int maxn5 = 5e6 + 10;
const int maxnt = 1.2e6 + 10;
const int maxn3 = 1e3 + 10;
const int mod = 5e8;
const int ssq = 460;
const long long alp = 64;
const long long inf = 2e18;
int dp[maxn5];
long long now, tav, modh, pre[maxn5];
int get_val(char a) {
if (a >= 'a' && a <= 'z') return a - 'a' + 1;
if (a >= 'A' && a <= 'Z') return a - 'A' + 1 + 26;
return a - '0' + 1 + 52;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
modh = 1e9 + 9;
pre[0] = get_val(s[0]);
tav = 1;
for (int i = 1; i < n; i++) {
tav *= alp;
tav %= modh;
long long val = get_val(s[i]);
pre[i] = pre[i - 1] + (tav * val);
pre[i] %= modh;
}
dp[0] = 1;
long long ans = 1;
int last = 1;
tav = 1;
now = 0;
for (int i = 1; i < n; i++) {
long long val = get_val(s[i]), val2 = get_val(s[last]);
if (i % 2 == 1) {
now *= alp;
now += val;
now %= modh;
if (i > 1) {
tav *= alp;
tav %= modh;
}
} else {
last++;
now = (modh + now - (tav * val2) % modh) % modh;
now *= alp;
now += val;
now %= modh;
}
if (now == pre[(i + 1) / 2 - 1]) dp[i] = dp[(i + 1) / 2 - 1] + 1;
ans += dp[i];
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
string s, a = "#", m = "";
long long sum, res, L, R, ii, P[10000001], degree[10000001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
for (long long i = 0; i <= s.length() - 1; ++i) {
m = m + s[i] + '#';
a += m;
m = "";
}
L = R = -1;
P[0] = 0;
for (long long i = 1; i <= a.length() - 1; i++) {
if (i > R) {
L = R = i;
while (R <= a.length() - 1 && L >= 0 && a[R] == a[L]) {
R++;
L--;
}
P[i] = R - L - 1;
R--;
L++;
} else {
ii = (L + R) - i;
if (P[ii] / 2 < R - i)
P[i] = P[ii];
else {
L = 2 * i - R;
while (R <= a.length() - 1 && L >= 0 && a[R] == a[L]) {
R++;
L--;
}
P[i] = R - L - 1;
R--;
L++;
}
}
if (P[i] / 2 == i) {
degree[i] = degree[i / 2] + 1;
sum += degree[i];
}
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e6;
int deg[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
unsigned long long hi = s[0], hb = s[0];
unsigned long long base = 1e8 + 7;
unsigned long long B = base;
deg[0] = 1;
int ans = 1;
for (int pos = 1; pos < s.size(); ++pos) {
hi *= base;
hi += s[pos];
hb += s[pos] * B;
B *= base;
if (hi == hb) {
deg[pos] = deg[(pos - 1) >> 1] + 1;
ans += deg[pos];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[10000010], p[10000010];
long long ans;
char s[10000010], a[10000010];
inline void manacher() {
int cnt = 0;
a[++cnt] = '#';
for (register int i = 0; s[i]; i++) a[++cnt] = s[i], a[++cnt] = '#';
int id = 0, mx = 0;
for (register int i = 1; a[i]; i++) {
if (mx > i) p[i] = min(mx - i, p[id * 2 - i]);
while (i - p[i] && a[i - p[i]] == a[i + p[i]]) p[i]++;
if (i + p[i] > mx) mx = i + p[i], id = i;
if (p[i] == i) f[i - 1] = 1;
}
}
int main() {
gets(s);
manacher();
f[0] = 0;
for (register int i = 1; s[i - 1]; i++)
if (f[i]) f[i] += f[i >> 1], ans += f[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int maxn = 10 * 1000002;
char s[maxn];
int k[maxn];
int z[maxn];
void zfunc(int n) {
z[0] = 0;
int l = -1, r = -1;
for (int i = 1; i < n; ++i) {
int w;
if (r < i)
w = 0;
else
w = min(z[i - l], r - i);
while (i + w <= n && s[w] == s[i + w]) w++;
z[i] = w;
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
bool palin(int len, int m) {
if (z[m - 1 - len + 1] >= len / 2) return true;
return false;
}
int main() {
scanf("%s", s);
int n = strlen(s);
s[n] = '$';
int m = n + 1;
for (int i = 0; i < n; ++i) s[m++] = s[n - i - 1];
zfunc(m);
k[0] = 1;
for (int i = 1; i < n; ++i) {
if (palin(i + 1, m))
k[i] = 1 + k[(i + 1) / 2 - 1];
else
k[i] = 0;
}
long long sum = 0;
for (int i = 0; i < n; ++i) sum += k[i];
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 5;
char s[maxn];
unsigned long long Hash1[maxn], Hash2[maxn];
unsigned long long sum1[maxn], sum2[maxn];
unsigned long long f[maxn];
long long dp[maxn];
long long sum;
int n;
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1);
n = len;
memset(dp, 0, sizeof(dp));
f[0] = 1;
sum = 0;
for (int i = 1; i <= len; i++) {
f[i] = f[i - 1] * 131;
}
for (int i = 1; i <= n; i++) {
Hash1[i] = (s[i] - 'a' + 1) * f[i - 1];
}
for (int i = n; i >= 1; i--) {
Hash2[i] = (s[i] - 'a' + 1) * f[n - i];
}
for (int i = 1; i <= n; i++) {
Hash1[i] += Hash1[i - 1];
}
for (int i = n; i >= 1; i--) {
Hash2[i] += Hash2[i + 1];
}
unsigned long long ans1, ans2;
for (int i = 1; i <= len; i++) {
int temp2 = len - i;
ans1 = Hash1[i];
ans2 = Hash2[1] - Hash2[i + 1];
ans1 *= f[temp2];
if (ans1 == ans2) {
dp[i] = dp[i / 2] + 1;
}
}
for (int i = 1; i <= len; i++) sum += dp[i];
printf("%lld\n", sum);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.