text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 1;
unsigned long long hash1[N], hash2[N], p[N];
int base = 133331, dp[N], n, ans;
char s[N], ss[N];
inline unsigned long long get(int l, int r) {
return hash1[r] - hash1[l - 1] * p[r - l + 1];
}
inline unsigned long long getre(int l, int r) {
return hash2[r] - hash2[l - 1] * p[r - l + 1];
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) ss[i] = s[n - i + 1];
p[0] = 1;
for (int i = 1; i <= n; i++) {
hash1[i] = hash1[i - 1] * base + int(s[i]);
p[i] = p[i - 1] * base;
}
for (int i = 1; i <= n; i++) hash2[i] = hash2[i - 1] * base + int(ss[i]);
for (int i = 1; i <= n; i++) {
unsigned long long right = get(1, i / 2),
left = getre(n - i + 1, n - i + i / 2);
if (right == left) dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
return cout << ans, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[10000005];
int plen[10000005], pdeg[10000005], slen, idfront = 0, idback = -1, center,
dist;
long long ans;
int main() {
scanf("%s", s);
slen = strlen(s);
for (int i = slen - 1; i >= 0; --i) {
s[2 * i] = s[i];
s[2 * i + 1] = '-';
}
slen = 2 * slen - 1;
for (int i = 0; i < slen; ++i) {
if (idback == slen - 1) break;
if (i > idback) {
while (plen[i] <= i && i + plen[i] < slen) {
if (s[i + plen[i]] == s[i - plen[i]])
plen[i]++;
else
break;
}
idfront = i - plen[i] + 1;
idback = i + plen[i] - 1;
center = i;
if (idfront == 0) {
pdeg[i] = pdeg[(i - 1) / 2] + 1;
ans += pdeg[i];
}
} else {
dist = i - center;
if (center - dist - plen[center - dist] + 1 < idfront) {
plen[i] = center - dist - idfront + 1;
} else if (center - dist - plen[center - dist] + 1 == idfront) {
plen[i] = plen[center - dist];
while (plen[i] <= i && i + plen[i] < slen) {
if (s[i + plen[i]] == s[i - plen[i]])
plen[i]++;
else
break;
}
idfront = i - plen[i] + 1;
idback = i + plen[i] - 1;
center = i;
if (idfront == 0) {
pdeg[i] = pdeg[(i - 1) / 2] + 1;
ans += pdeg[i];
}
} else {
plen[i] = plen[center - dist];
}
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000004 * 5;
const int base = 499;
long long hashs[maxn], hashe[maxn], t[maxn];
int ans;
int degree[maxn];
int main() {
string s;
cin >> s;
t[0] = 1;
for (int i = 1; i < maxn; i++) t[i] = t[i - 1] * base;
int sz = s.size();
for (int i = 0; i < sz; i++) hashs[i + 1] = hashs[i] * base + s[i];
reverse(s.begin(), s.end());
for (int i = 0; i < sz; i++) hashe[i + 1] = hashe[i] * base + s[i];
ans++;
degree[1] = 1;
for (int i = 2; i <= sz; i++) {
int mid = i / 2;
if (i % 2 == 1) {
if (hashs[mid] == hashe[sz - mid - 1] - hashe[sz - i] * t[mid]) {
degree[i] = degree[mid] + 1;
ans += degree[i];
}
}
if (i % 2 == 0) {
if (hashs[mid] == hashe[sz - mid] - hashe[sz - i] * t[mid]) {
degree[i] = degree[mid] + 1;
ans += degree[i];
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch - '0' < 0 || ch - '0' > 9) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch - '0' >= 0 && ch - '0' <= 9) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, len;
char s[5000010], t[5000010 * 2];
int f[5000010];
void pre() {
for (int i = 1; i <= 2 * n + 1; i++) {
if (i & 1)
t[i] = '#';
else
t[i] = s[i / 2];
}
len = 2 * n + 1;
}
int R[5000010 * 2];
void Manacher() {
int p = 1, mx = 1;
R[1] = 1;
for (int i = 2; i <= len; i++) {
if (mx < i)
R[i] = 1;
else {
int j = 2 * p - i;
R[i] = min(R[j], mx - i);
}
while (t[i + R[i]] == t[i - R[i]] && i + R[i] < len && i - R[i] > 0) R[i]++;
if (i + R[i] - 1 > mx) {
mx = i + R[i] - 1;
p = i;
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
pre();
Manacher();
for (int i = 1; i <= len; i++) {
int l = i - R[i] + 1, r = i + R[i] - 1;
l = (l + 1) / 2;
r /= 2;
if (l > r) continue;
if (l == 1) f[r] = f[r / 2] + 1;
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans += f[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
void run(std::istream &in, std::ostream &out) {
std::string str;
in >> str;
size_t n = str.length();
std::vector<int> pi(n + 1);
pi[0] = -1;
for (size_t i = 1; i <= n; i++) {
int v = pi[i - 1];
while (v >= 0 && str[v] != str[i - 1]) {
v = pi[v];
}
pi[i] = v + 1;
}
std::string rstr = str;
std::reverse(rstr.begin(), rstr.end());
int cur_pi = 0;
int rev_pos;
for (rev_pos = 0; rev_pos < n; rev_pos++) {
while (cur_pi >= 0 && rstr[rev_pos] != str[cur_pi]) {
cur_pi = pi[cur_pi];
}
cur_pi++;
}
std::vector<int> palindromes(2 * cur_pi + 2);
int64_t answer = 0;
while (cur_pi > 0) {
palindromes[cur_pi] =
1 + palindromes[2 * cur_pi] + palindromes[2 * cur_pi + 1];
answer += palindromes[cur_pi];
cur_pi = pi[cur_pi];
}
out << answer << std::endl;
}
int main() {
run(std::cin, std::cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
vector<unsigned int> dig, a, b;
void Start() {
dig.push_back(1);
for (int i = 1; i < (s.size() + 1); i++) dig.push_back(dig[i - 1] * 31);
a.push_back(s[0]);
for (int i = 1; i < (s.size()); i++) a.push_back(a[i - 1] + (s[i] * dig[i]));
reverse(s.begin(), s.end());
b.push_back(s[0]);
for (int i = 1; i < (s.size()); i++) b.push_back(b[i - 1] + (s[i] * dig[i]));
}
bool Test(int i, int j) {
unsigned int tmp1, tmp2;
tmp1 = a[i] * dig[s.size()];
tmp2 = b[s.size() - 1];
if (j) tmp2 -= b[j - 1];
tmp2 *= dig[s.size() - j];
return tmp1 == tmp2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
Start();
int ans = 1;
for (int i = 1; i < (s.size()); i++) {
int k = 0;
int ind = i;
while (Test(ind, s.size() - ind - 1) && ind) {
k++;
ind = (ind - 1) / 2;
}
if (ind == 0) k++;
ans += k;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
inline int cmp(double x, double y = 0, double tol = 1e-9) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
std::string str;
int P[10000007], D[10000007];
int n;
void manacher() {
int i2, l, r, Ri;
int C = -1, R = -1;
n = 2 * (str.size() - 1);
for (int i = 0; i <= n; ++i) {
i2 = 2 * C - i;
P[i] = (R >= i) ? std::min(R - i + 1, P[i2]) : !(i % 2);
l = (i - P[i]) >> 1;
r = (i + P[i] + 1) >> 1;
while (l >= 0 && r < str.size() && str[l] == str[r]) {
P[i] += 2;
l -= 1;
r += 1;
}
Ri = P[i] ? ((i + P[i]) >> 1) << 1 : i;
if (Ri > R) {
C = i;
R = Ri;
}
}
}
int main() {
std::cin >> str;
manacher();
long long int sum = D[0] = 1;
for (int i = 1; i <= n; ++i) {
if (P[i] == i + 1)
D[i] = D[(i - 1) / 2] + 1;
else
D[i] = 0;
sum += D[i];
}
std::cout << sum << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans[5000010] = {0};
int main() {
cin.sync_with_stdio(0);
string s;
cin >> s;
int len = s.length();
ans[1] = 1;
long long sm = 1;
long long base = 37;
long long pbase = 37;
long long h1 = s[0] - 'A' + 1;
long long h2 = s[0] - 'A' + 1;
for (long long i = 2; i <= len; i++) {
h1 = h1 * base + (s[i - 1] - 'A' + 1);
h2 = h2 + (s[i - 1] - 'A' + 1) * pbase;
pbase *= base;
if (h1 == h2) {
ans[i] = ans[i / 2] + 1;
sm += ans[i];
}
}
cout << sm;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long base = 1001, mod1 = 1e18 + 7, MAXn = 5e6 + 10;
long long ans = 0, hp1, hp2, hp3, ans1[MAXn];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
hp3 = 1;
for (int i = 0; i < s.size(); i++) {
hp1 = (hp1 * base + (int)s[i]);
hp2 = (hp2 + hp3 * (int)s[i]);
hp3 = (hp3 * base);
if (hp1 == hp2) {
ans1[i] = ans1[(i - 1) / 2] + 1;
ans += ans1[i];
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000010];
int pw[5000010] = {1}, h1[5000010], h2[5000010], dp[5000010];
int main() {
int n = strlen(gets(s + 1));
for (int i = 1; i <= n; i++) pw[i] = pw[i - 1] * 131;
for (int i = 1; i <= n; i++) h1[i] = h1[i - 1] * 131 + s[i];
for (int i = 1; i <= n; i++) h2[i] = h2[i - 1] + s[i] * pw[i - 1];
for (int i = 1; i <= n; i++)
if (h1[i] == h2[i]) dp[i] = dp[i / 2] + 1;
int ans = 0;
for (int i = 1; i <= n; i++) ans += dp[i];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int BASE = 257;
const int MOD = 1e9 + 9;
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;
long long pref[5000005], suff[5000005], power[5000005];
long long dp[5000005];
void hashvalue(string s) {
pref[0] = 0;
suff[0] = 0;
long long n = s.length();
string t = s;
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] + ((s[i - 1] - '0' + 1) * (per))) % 1000000007;
suff[i] = (suff[i - 1] + ((t[i - 1] - '0' + 1) * (per))) % 1000000007;
}
}
long long isPalindrome(string &s, long long len) {
if (len % 2 == 0) {
if (((pref[len / 2] * power[inpL - len]) % 1000000007) !=
(suff[inpL - (len / 2)] - suff[inpL - len] + 1000000007) % 1000000007)
return 0;
else
return 1;
} else if (len % 2 == 1) {
if (((pref[len / 2] * power[inpL - len]) % 1000000007) ==
((suff[inpL - (len / 2) - 1] - suff[inpL - len] + 1000000007) %
1000000007))
return 1;
else
return 0;
}
}
long long solve(string &temp, long long len) {
if (isPalindrome(temp, len)) {
dp[len] = dp[len / 2] + 1;
return dp[len];
} else {
dp[len] = 0;
return 0;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string inp;
cin >> inp;
long long n = inp.length();
power[0] = 1;
dp[0] = 0;
for (long long i = 1; i < n + 2; i++) {
power[i] = (power[i - 1] * 83) % 1000000007;
}
inpL = n;
hashvalue(inp);
long long ans = 0;
string temp;
for (long long i = 0; i < n; i++) {
temp.push_back(inp[i]);
ans += solve(temp, i + 1);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> calcPalindromes(const char *str) {
int n = strlen(str);
vector<int> res = vector<int>((n << 1) | 1);
int m = 0, i = 0, pl = 0;
while (i < n) {
if (i > pl && str[i - pl - 1] == str[i]) {
pl += 2;
i++;
continue;
}
res[m++] = pl;
int s = m - 2, e = s - pl, j;
for (j = s; j > e; j--) {
int d = j - e - 1;
if (res[j] >= d) {
pl = d;
break;
}
res[m++] = min(d, res[j]);
}
if (j == e) {
pl = 1;
i++;
}
}
res[m++] = pl;
int s = m - 2, e = s - ((n << 1) + 1 - m);
for (int i = s; i > e; i--) {
int d = i - e - 1;
res[m++] = min(d, res[i]);
}
return res;
}
const int MAXN = 5000001;
int n;
char s[MAXN];
vector<int> length, degree;
int main() {
scanf("%s", s);
n = strlen(s);
length = calcPalindromes(s);
degree = vector<int>(n + 1);
for (int i = (1); i < ((n << 1) + 1); i++) {
if (i == length[i]) {
degree[(i + length[i]) >> 1] = 1;
}
}
long long res = 0;
for (int i = (1); i < (n + 1); i++) {
if (degree[i]) {
degree[i] = degree[i / 2] + 1;
res += degree[i];
}
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5e6 + 5;
int p[maxn];
int f[maxn * 2];
char s[maxn];
char t[maxn * 2];
int n;
void prep() {
t[0] = '$';
n = 1;
for (int i = 0; s[i]; ++i) {
t[n++] = '#';
t[n++] = s[i];
}
t[n++] = '#';
t[n] = 0;
int mx = 0, mi;
for (int i = 0; t[i]; ++i) {
if (mx > i)
f[i] = std::min(f[2 * mi - i], mx - i);
else
f[i] = 1;
for (; t[i - f[i]] == t[i + f[i]]; ++f[i])
;
if (i + f[i] > mx) {
mx = i + f[i];
mi = i;
}
}
}
bool isP(int x, int y) { return f[x + y + 2] == y - x + 2; }
int main() {
scanf("%s", s);
prep();
long long int ans = 0;
for (int i = 0; s[i]; ++i) {
if (isP(0, i)) {
p[i] = p[std::max(0, (i + 1) / 2 - 1)] + 1;
}
ans += p[i];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> pref_hash_fn(string &s) {
long long p = 31, m = 1e9 + 9;
long long pp = 1, n = (long long)(s.size());
vector<long long> h(n + 1, 0);
for (auto i = 0 - (0 > n); i != n - (0 > n); i += 1 - 2 * (0 > n))
h[i + 1] = (h[i] + (s[i] - 'a' + 1) * pp) % m, pp = (pp * p) % m;
return h;
}
vector<long long> pref_inv_hash_fn(string &s) {
long long p = 31, m = 1e9 + 9, n = (long long)(s.size());
vector<long long> h(n + 1, 0);
for (auto i = 0 - (0 > n); i != n - (0 > n); i += 1 - 2 * (0 > n))
h[i + 1] = (h[i] * p + s[i] - 'a' + 1) % m;
return h;
}
void solve() {
string s;
cin >> s;
vector<long long> a = pref_hash_fn(s);
vector<long long> b = pref_inv_hash_fn(s);
vector<long long> dp((long long)(s.size()), 0);
dp[0] = 1;
for (auto i = 1 - (1 > (long long)(s.size()));
i != (long long)(s.size()) - (1 > (long long)(s.size()));
i += 1 - 2 * (1 > (long long)(s.size())))
if (a[i + 1] == b[i + 1]) dp[i] = dp[(i - 1) >> 1] + 1;
long long ans = 0;
for (auto i = 0 - (0 > (long long)(dp.size()));
i != (long long)(dp.size()) - (0 > (long long)(dp.size()));
i += 1 - 2 * (0 > (long long)(dp.size())))
ans += dp[i];
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cin.exceptions(cin.failbit), setprecision(12), cout.precision(18);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> z_function(string s) {
int n = (int)s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
void solve() {
string s;
cin >> s;
int n = s.size(), ans = 1;
vector<int> z = z_function(s + '$' + string(s.rbegin(), s.rend())), p(n);
p[0] = 1;
for (int i = 1; i < n; ++i) {
if (z[n * 2 - i] == i + 1) {
p[i] = p[(i + 1) / 2 - 1] + 1;
} else {
p[i] = 0;
}
ans += p[i];
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size(), ans = 1;
vector<int> z = z_function(s + '$' + string(s.rbegin(), s.rend())), p(n);
p[0] = 1;
for (int i = 1; i < n; ++i) {
if (z[n * 2 - i] == i + 1) {
p[i] = p[(i + 1) / 2 - 1] + 1;
} else {
p[i] = 0;
}
ans += p[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int base = 151;
const int mod = 1000950101;
const int maxn = 5e6 + 5;
int _hash[maxn], _rhash[maxn];
int ans[maxn];
int pwr[maxn];
long long get_hash(int l, int r, int typ) {
if (typ == 1) {
return ((_hash[r] - (1LL * _hash[l - 1] * pwr[r - l + 1]) % mod) + mod) %
mod;
} else {
return ((_rhash[l] - (1LL * _rhash[r + 1] * pwr[r - l + 1]) % mod) + mod) %
mod;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
pwr[0] = 1;
for (int i = 1; i < maxn; i++) {
pwr[i] = (1LL * pwr[i - 1] * base) % mod;
}
string str;
cin >> str;
int n = str.size();
_hash[0] = 0;
_rhash[n + 1] = 0;
for (int i = 1; i <= n; i++) {
_hash[i] = ((1LL * _hash[i - 1] * base) % mod + str[i - 1]) % mod;
_rhash[n - i + 1] =
((1LL * _rhash[n - i + 2] * base) % mod + str[n - i]) % mod;
}
long long res = 0;
for (int i = 0; i <= n; i++) ans[i] = -1;
ans[0] = 0;
for (int i = 1; i <= n; i++) {
if (get_hash(1, i, 1) == get_hash(1, i, 2) && ans[i / 2] >= 0) {
ans[i] = ans[i / 2] + 1;
res += ans[i];
} else
ans[i] = 0;
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mo = 1000000007;
char c[5000010];
long long n, base = 23, ans;
long long fac[5000010], fro[5000010], bac[5000010], f[5000010];
long long find_front_hash(long long l, long long r) {
return (fro[r] - (fro[l - 1] * fac[r - l + 1]) % mo + mo) % mo;
}
long long find_back_hash(long long l, long long r) {
return (bac[l] - (bac[r + 1] * fac[r - l + 1]) % mo + mo) % mo;
}
signed main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cin >> c + 1;
n = strlen(c + 1);
fac[0] = 1;
for (long long i = 1; i <= n; ++i) {
fac[i] = fac[i - 1] * base % mo;
}
for (long long i = 1; i <= n; ++i) {
fro[i] = fro[i - 1] * base + c[i];
fro[i] %= mo;
}
for (long long i = n; i >= 1; --i) {
bac[i] = bac[i + 1] * base + c[i];
bac[i] %= mo;
}
for (long long i = 1; i <= n; ++i) {
(find_front_hash(1, i / 2) == find_back_hash(i - i / 2 + 1, i))
? f[i] = f[i / 2] + 1
: f[i] = 0;
ans += f[i];
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void init() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int MOD1 = 1e9 + 7;
const int MOD2 = 1e9 + 9;
const int N = 5e6 + 6;
void polonomial_hash(int *key1, int *key2, int *p1, int *p2, string &str) {
for (int i = 1; i <= (int)str.size(); ++i) {
key1[i] = (key1[i - 1] +
(((long long)p1[i - 1]) * ((int)(str[i - 1]) + 1)) % MOD1) %
MOD1;
key2[i] = (key2[i - 1] +
(((long long)p2[i - 1]) * ((int)(str[i - 1]) + 1)) % MOD2) %
MOD2;
}
}
void calcPowers(int *p1, int *p2, int len) {
for (int i = 0; i < len; ++i) {
p1[i + 1] = (263 * (long long)p1[i]) % MOD1;
p2[i + 1] = (257 * (long long)p2[i]) % MOD2;
}
}
int k1[N], k2[N], k1_r[N], k2_r[N], p1[N], p2[N], palin_deg[N];
int main() {
init();
string str, rev;
long long ans = 0;
k1[0] = k2[0] = k1_r[0] = k2_r[0] = palin_deg[0] = 0;
p1[0] = 1, p2[0] = 1;
cin >> str;
rev = str;
int len = str.size();
reverse(rev.begin(), rev.end());
calcPowers(p1, p2, len);
polonomial_hash(k1, k2, p1, p2, str);
polonomial_hash(k1_r, k2_r, p1, p2, rev);
for (int i = 1; i <= len; ++i) {
long long a1 =
(long long)((((long long)k1[i]) * (long long)p1[(len - i)] + MOD1) %
MOD1);
long long b1 =
(long long)((((long long)k2[i]) * p2[(len - i)] + MOD2) % MOD2);
long long a2 =
((long long)(((long long)k1_r[len]) - k1_r[len - i] + MOD1) % MOD1);
long long b2 =
((long long)(((long long)k2_r[len]) - k2_r[len - i] + MOD2) % MOD2);
if (a1 == a2 && b1 == b2)
palin_deg[i] = 1 + palin_deg[i / 2];
else
palin_deg[i] = 0;
ans += palin_deg[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
bool debug = false;
using namespace std;
int n;
char s[5000004], a[5000004 * 2];
int Next[5000004 * 2];
bool Pal[5000004];
int F[5000004];
int main() {
gets(s);
n = strlen(s);
for (int i = 1; i <= n; i++) a[i] = s[i - 1];
for (int i = n + 1; i <= 2 * n; i++) a[i] = a[2 * n - i + 1];
int k = 0;
for (int i = 2; i <= 2 * n; i++) {
while (k && a[k + 1] != a[i]) k = Next[k];
if (a[k + 1] == a[i]) k++;
Next[i] = k;
}
int i = Next[2 * n];
while (i) {
if (i > n) {
i = Next[i];
continue;
}
Pal[i] = true;
i = Next[i];
}
long long res = 0;
for (int i = 1; i <= n; i++)
if (Pal[i]) {
F[i] = F[i / 2] + 1;
res += F[i];
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int max_n = 5e6 + 500;
ll mod = 1e9 + 7;
ll p[max_n], h[max_n], oh[max_n];
string s;
int n;
ll get(int l, int r) {
return ((h[r] - (l ? h[l - 1] : 0) + mod) * p[n - l + 2]) % mod;
}
ll getoh(int l, int r) {
l = n - l - 1;
r = n - r - 1;
swap(l, r);
return ((oh[r] - (l ? oh[l - 1] : 0) + mod) * p[n - l + 2]) % mod;
}
int main() {
char tmp[max_n];
scanf("%s", &tmp);
s = tmp;
n = s.size();
p[0] = 1;
h[0] = s[0];
oh[0] = s[n - 1];
for (int i = 1; i < max_n; i++) p[i] = (p[i - 1] * 119) % mod;
for (int i = 1; i < n; i++) h[i] = (h[i - 1] + s[i] * p[i]) % mod;
for (int i = 1; i < n; i++) oh[i] = (oh[i - 1] + s[n - i - 1] * p[i]) % mod;
vector<ll> ans(n);
ans[0] = 1;
ll a = 1;
for (int i = 1; i < n; i++) {
int len = (i + 1) / 2;
if (get(0, len - 1) == getoh(len + !(i % 2), len * 2 - i % 2)) {
ans[i] = ans[len - 1] + 1;
}
a += ans[i];
}
printf("%lld", a);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 50, P = 41, D = 1000173169, M = 262143;
unsigned long long pows[N], f[2][N];
char a[2][N];
int n;
unsigned long long hashs(int l, int r, int state) {
return f[state][r] - f[state][l - 1] * pows[r - l + 1];
}
void hash_init(int n, int state) {
for (int i = 1; i <= n; i++) f[state][i] = f[state][i - 1] * P + a[state][i];
}
int level[N];
int main() {
int i, j;
for (pows[0] = i = 1; i < N; i++) pows[i] = pows[i - 1] * P;
scanf("%s", a[0] + 1);
strcpy(a[1] + 1, a[0] + 1);
int len = strlen(a[0] + 1);
reverse(a[1] + 1, a[1] + 1 + len);
hash_init(len, 0);
hash_init(len, 1);
memset(level, 0, sizeof(level));
level[1] = 1;
long long ans = 1;
for (i = 2; i <= len; i++) {
int mid = i / 2;
if (hashs(1, mid, 0) == hashs(len - i + 1, len - i + mid, 1))
level[i] = level[mid] + 1;
else
level[i] = 0;
ans += level[i];
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int base = 727, md = 1e9 + 7;
string s;
long long pwr[5555555], prehs[5555555], sufhs[5555555], dp[5555555], ans = 1;
inline bool pal(int i) {
return (prehs[i] == (sufhs[0] - (sufhs[i + 1] * pwr[i + 1] % md) + md) % md);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
int n = s.size();
pwr[0] = 1;
for (int i = 1; i <= n; i++) pwr[i] = (pwr[i - 1] * base) % md;
prehs[0] = s[0];
for (int i = 1; i < n; i++) {
prehs[i] = (prehs[i - 1] * base + s[i]) % md;
}
for (int i = n - 1; i >= 0; i--) {
sufhs[i] = (sufhs[i + 1] * base + s[i]) % md;
}
dp[0] = 1;
for (int i = 1; i < n; i++) {
if (pal(i)) {
dp[i] = dp[(i - 1) / 2] + 1;
}
ans += dp[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int com[5000001];
int main() {
string s;
cin >> s;
unsigned long long p = 1;
unsigned long long res = 0, h1 = 0, h2 = 0;
for (int i = 0; i < s.size(); i++) {
h1 = h1 * ((int)257) + s[i];
h2 = h2 + p * s[i];
int tem = 0;
if (h1 == h2) tem = com[(i + 1) / 2] + 1;
res += tem;
p *= ((int)257);
if (i + 1 < s.size()) com[i + 1] = tem;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 7;
string s;
int n, dp[maxn], val, curr, cnt = 1, ans = 1;
void solve() {
cin >> s;
n = s.size();
memset(dp, 0, sizeof(dp));
dp[0] = 1, val = s[0], curr = s[0];
for (int i = 1; s[i]; ++i) {
cnt *= 131, val *= 131;
val += s[i];
curr += s[i] * cnt;
if (val == curr) {
dp[i] = dp[(i - 1) >> 1] + 1;
}
ans += dp[i];
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
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))) % 1000950101;
suff[i] = (suff[i - 1] + ((t[i - 1] - '0' + 1) * (per))) % 1000950101;
power[i] = (power[i - 1] * 151) % 1000950101;
}
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]) % 1000950101) ==
(suff[inpL - (len / 2)] - suff[inpL - len] + 1000950101) %
1000950101) {
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]) % 1000950101) ==
((suff[inpL - (len / 2) - 1] - suff[inpL - len] + 1000950101) %
1000950101)) {
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;
char str[5000010], nstr[5000010 * 2];
int rad[5000010 * 2], num[5000010 * 2] = {0};
long long cal() {
long long sum = 0;
int len = strlen(str);
for (int i = 0; i < len; ++i) {
nstr[i * 2 + 1] = '#';
nstr[i * 2 + 2] = str[i];
}
nstr[0] = '$';
nstr[2 * len + 1] = '#';
nstr[2 * len + 2] = '*';
num[1] = -1;
for (int i = 1, j = 0, k; i <= len + 1;) {
while (nstr[i - j] == nstr[i + j]) ++j;
rad[i] = j;
if (j == i) {
num[i] = num[(i + 1) / 2] + 1;
sum += num[i];
}
for (k = 1; k < j && j - k != rad[i - k]; ++k)
rad[i + k] = min(j - k, rad[i - k]);
i += k;
j = max(j - k, 0);
}
return sum;
}
int main() {
scanf("%s", str);
cout << cal();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 5e6 + 44;
const int B = 7531;
const int MOD = 1e9 + 9;
char tab[MN];
int dp[MN];
long long pows[MN];
pair<long long, int> s(char a) { return make_pair(a, 1); }
pair<long long, int> operator*(pair<long long, int> a, pair<long long, int> b) {
return make_pair((a.first * pows[b.second] + b.first) % MOD,
a.second + b.second);
}
const pair<long long, int> empty = make_pair(0, 0);
int main() {
pows[0] = 1;
for (int i = 1; i < MN; ++i) pows[i] = pows[i - 1] * B % MOD;
scanf("%s", tab);
int n = strlen(tab);
pair<long long, int> left = empty, right = empty;
int res = 0;
for (int i = 0; i < n; ++i) {
left = left * s(tab[i]);
right = s(tab[i]) * right;
if (i) {
if (left == right)
dp[i] = dp[(i - 1) / 2] + 1;
else
dp[i] = 0;
} else
dp[i] = 1;
res += dp[i];
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
int T, n, m, k, t, x = 987;
char str[10000009];
int isp[10000009];
int main() {
int ncase = 0;
while (scanf("%s", str) != EOF) {
n = strlen(str);
int cnt = 0;
unsigned long long l = 0, r = 0;
unsigned long long e = 1;
memset(isp, 0, sizeof(isp));
for (int i = 0; i < n; ++i) {
l = l * x + str[i];
r += str[i] * e;
e *= x;
if (l == r) {
isp[i + 1] = isp[(i + 1) / 2] + 1;
cnt += isp[i + 1];
}
}
printf("%d\n", cnt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void run();
int main() {
ios::sync_with_stdio(0);
run();
}
char v[6000000];
int deg[6000000];
int hsh[3][6000000];
int rsh[3][6000000];
int dv[3][6000000];
int md[3];
template <int mul, int mod>
inline void hush(int *h, int *u, int *d, char *l, char *r) {
d[0] = 1;
for (int i = 0; i < r - l; i++) {
h[i + 1] = (h[i] * mul + l[+0 + i]) % mod;
u[i + 1] = (u[i] * mul + r[-1 - i]) % mod;
d[i + 1] = (d[i] * mul) % mod;
}
}
inline bool check(int a, int b, int l, int r) {
for (int i = 3; i--;) {
int u = (hsh[i][b] - ((hsh[i][a] * dv[i][b - a]) % md[i]) + md[i]) % md[i];
int v = (rsh[i][r] - ((rsh[i][l] * dv[i][r - l]) % md[i]) + md[i]) % md[i];
if (u != v) return false;
}
return true;
}
void run() {
int n;
cin >> v;
n = strlen(v);
md[0] = 46021, md[1] = 46027, md[2] = 46049;
hush<25733, 46021>(hsh[0], rsh[0], dv[0], v, v + n);
hush<45413, 46027>(hsh[1], rsh[1], dv[1], v, v + n);
hush<39491, 46049>(hsh[2], rsh[2], dv[2], v, v + n);
long long res = deg[1] = 1;
for (int i = 2, w = 1; i <= n; w += (i++) & 1) {
if (check(0, w, n - i, n - (i - w))) {
deg[i] = deg[w] + 1;
res += deg[i];
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void run();
int main() {
ios::sync_with_stdio(0);
run();
}
int deg[10000002];
int man[10000002];
char wd[10000002];
char buf[5000002];
void run() {
int n;
scanf(" %s%n", buf, &n);
for (int i = 0, j = 0; i < n; ++i, j += 2) {
wd[j] = buf[i];
}
int done = 0;
int piv = man[0] = 0;
for (int i = 1; i < n * 2 - 1; ++i) {
if (piv + man[piv] >= i) {
man[i] = min(man[piv * 2 - i], piv + man[piv] - i);
}
while (i - man[i] > 0 and i + man[i] < n * 2 - 2 and
wd[i - man[i] - 1] == wd[i + man[i] + 1])
++man[i];
if (piv + man[piv] < i + man[i]) piv = i;
}
long long res = deg[0] = 1;
for (int i = 1; i < n; ++i) {
if (man[i] == i) {
res += (deg[i] = deg[(i - 1) / 2] + 1);
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
string s;
long long p[5000100], h[5000100], rh[5000100];
int pal[5000100];
long long ans = 1, n;
int main() {
getline(cin, s);
p[0] = 1;
n = s.size();
for (int i = 1; i < 5000100; i++) p[i] = p[i - 1] * 307;
h[0] = int(s[0]);
rh[0] = int(s[n - 1]);
for (int i = 1; i < s.size(); i++) {
h[i] = h[i - 1] + int(s[i]) * p[i];
rh[i] = rh[i - 1] + int(s[n - i - 1]) * p[i];
}
pal[0] = 1;
for (int i = 1; i < s.size(); i++) {
int j = (i + 1) / 2 - 1, j1 = i - (i + 1) / 2 + 1;
if (h[j] * p[n - j] ==
(rh[n - j1 - 1] - ((i + 1 == n) ? (0) : (rh[n - i - 2]))) * p[j1 + 1])
pal[i] = pal[j] + 1;
ans += pal[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
template <class T>
int size(const T &x) {
return x.size();
}
const int N = 5000100;
int deg[N];
char s[N];
int base = 251;
int mod = 1000000007;
int main() {
scanf("%s", s);
int n = strlen(s);
deg[0] = 1;
long long res = 1;
int left = s[0], right = s[0];
int p = 1;
for (int i = 2; i <= n; i++) {
deg[i - 1] = 0;
left = ((long long)left * base + s[i - 1]) % mod;
p = ((long long)p * base) % mod;
right = (right + (long long)p * s[i - 1]) % mod;
if (left == right) {
deg[i - 1] = deg[i / 2 - 1] + 1;
}
res += deg[i - 1];
}
cout << res << 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 = 1723;
const long long inf = 2e18;
int dp[maxn5];
long long now, tav, modh, pre[maxn5];
int get_val(char a) { return int(a); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
modh = 7e8 + 1723;
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 unsigned long long BASE = 1e9 + 7;
const int MAXN = 5000005;
char s[MAXN];
int N;
unsigned long long fhash[MAXN], bhash[MAXN], pows[MAXN];
int dp[MAXN];
bool ispal(int l, int r) {
return (fhash[r] - fhash[l - 1]) * pows[l - 1] ==
(bhash[r] - bhash[l - 1]) * pows[N - r];
}
int main(int argc, char *argv[]) {
scanf("%s", s);
pows[0] = 1;
for (int i = 1; i < MAXN; i++) pows[i] = pows[i - 1] * BASE;
N = strlen(s);
for (int i = 0, _i = N; i < _i; ++i) {
fhash[i + 1] = fhash[i] + (unsigned long long)s[i] * pows[N - i - 1];
bhash[i + 1] = bhash[i] + (unsigned long long)s[i] * pows[i];
}
int ans = 1;
dp[1] = 1;
for (int i = 2; i <= N; i++) {
if (ispal(1, i)) dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int z[10000001];
int kp[10000001];
char s[10000001];
void z_func() {
int L = 0, R = 0;
for (int i = 1; i < n; ++i) {
if (i > R) {
L = R = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < n && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) s[i + n] = s[n - i - 1];
n *= 2;
z_func();
int ans = 1;
kp[0] = 1;
for (int i = 1; i < n / 2; ++i) {
int sz = (i + 1) / 2;
int ps = i - sz + 1;
if (z[n - i - 1] >= i + 1) {
kp[i] = kp[sz - 1] + 1;
}
ans += kp[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5000 * 1001, M = 719, MOD = 1e9 + 7;
long long n, _hash[N], hash_rev[N], dp[N], pw[N];
long long sum;
string s;
bool is_pal(long long r) {
if (r == 0) return true;
long long mid = (r + 1) / 2 - 1;
long long tt = n - 1 - (mid + 1);
if (r % 2 == 0) tt--;
long long t = _hash[mid], t2 = hash_rev[tt] - hash_rev[tt - mid - 1];
if ((pw[tt - mid] * t) % MOD == (t2 + MOD) % MOD) return true;
return false;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> s;
n = s.size();
pw[0] = 1;
_hash[0] = (long long)s[0];
for (long long i = 1; i < n; i++) {
pw[i] = (pw[i - 1] * M) % MOD;
_hash[i] = (_hash[i - 1] + (pw[i] * (long long)s[i])) % MOD;
}
reverse(s.begin(), s.end());
hash_rev[0] = (long long)s[0];
for (long long i = 1; i < n; i++)
hash_rev[i] = (hash_rev[i - 1] + (pw[i] * (long long)s[i])) % MOD;
reverse(s.begin(), s.end());
for (long long i = 1; i <= n; i++) {
if (is_pal(i - 1)) dp[i] = dp[i / 2] + 1;
sum += dp[i];
}
cout << sum << "\n";
}
|
#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 = 1610612741;
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;
char s[10000000];
int d[10000000];
int d1[10000000];
int d2[10000000];
bool p[10000000];
int main() {
gets(s);
int n = strlen(s);
int l = 0, r = -1;
for (int i = 0; i < n; ++i) {
int k = (i > r ? 0 : min(d1[l + r - i], r - i)) + 1;
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)) + 1;
while (i + k - 1 < 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;
}
for (int i = n; i >= 1; i--) d1[i] = d1[i - 1] + 1, d2[i] = d2[i - 1];
for (int i = 1; i <= n; i++) {
if (d1[i] >= i) p[2 * i - 1] = true;
if (d2[i] >= i - 1) p[2 * i - 2] = true;
}
for (int i = 1; i <= n; i++)
if (p[i])
d[i] = d[i / 2] + 1;
else
d[i] = 0;
long long res = 0;
for (int i = 1; i <= n; i++) res += (long long)(d[i]);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5000003;
char S[MaxN << 1];
int L, N, f[MaxN << 1], ind[MaxN];
int main() {
gets(S + 1);
L = strlen(S + 1);
for (int i = 1; i <= L; ++i) S[2 * L + 2 - i] = S[i];
S[L + 1] = '.';
N = L * 2 + 1;
S[N + 1] = 0;
f[1] = N;
int p = 0;
for (; S[p + 1] == S[p + 2]; ++p)
;
f[2] = p;
p = 2;
for (int i = 3; i <= N; ++i) {
int t = p + f[p] - 1;
if (t < i) {
int &len = f[i];
for (len = 0; S[len + 1] == S[i + len]; ++len)
;
p = i;
} else {
int rem = t - i + 1;
f[i] = f[i - p + 1];
if (f[i] >= rem) {
f[i] = rem;
int &len = f[i];
for (; S[len + 1] == S[i + len]; ++len)
;
p = i;
}
}
}
long long res = 1;
ind[1] = 1;
for (int i = 2; i <= L; ++i) {
int n = i >> 1;
if (f[N + 1 - i] >= n)
ind[i] = ind[n] + 1;
else
ind[i] = 0;
res += ind[i];
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long dp[5000006];
char s[5000006];
int main() {
unsigned long long i, j, k, n, m, t;
scanf("%s", s);
n = strlen(s);
dp[0] = 1;
unsigned long long fhash = s[0], rhash = s[0];
unsigned long long cpo = 1;
unsigned long long ans = 1;
for (i = 1; i < n; i++) {
cpo *= 37;
fhash = fhash * 37 + s[i];
rhash += s[i] * cpo;
if (fhash == rhash) {
dp[i] = dp[(i + 1) / 2 - 1] + 1;
}
ans += dp[i];
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e6 + 10, NM = 1 << 16, MOD = 1e9 + 7, INF = 1e15 + 10,
SQ = 640, LOG = 20, BH = 723, BH2 = 87651, MH = 1610612741,
MH2 = 924467661;
int n, m, x1, x2, z, x, y, y2, t, maxi, ans, mini, ptr, k, p, pos, posi, l, r,
pw[2][N], hshl[2][N], hshr[2][N], dp[N];
string s;
pair<int, int> hsh(int l, int r, int q, int mod) {
long long tmp1 = hshl[q][r];
if (l) {
tmp1 -= (1ll * hshl[q][l - 1] * pw[q][r - l + 1]) % mod;
if (tmp1 < 0) tmp1 += mod;
if (tmp1 >= mod) tmp1 %= mod;
}
long long tmp2 = hshr[q][l];
if (r != n - 1) {
tmp2 -= (1ll * hshr[q][r + 1] * pw[q][r - l + 1]) % mod;
if (tmp2 < 0) tmp2 += mod;
if (tmp2 >= mod) tmp2 %= mod;
}
return {tmp1, tmp2};
}
int hsh2(int l, int r, int q, int mod) {
long long tmp1 = hshl[q][r];
if (l) {
tmp1 -= (1ll * hshl[q][l - 1] * pw[q][r - l + 1]) % mod;
if (tmp1 < 0) tmp1 += mod;
if (tmp1 >= mod) tmp1 %= mod;
}
return tmp1;
}
void prehash(int base, int mod, int q) {
pw[q][0] = 1;
for (int i = 1; i < N; i++) {
pw[q][i] = (1ll * pw[q][i - 1] * base) % mod;
if (pw[q][i] >= mod) pw[q][i] %= mod;
}
for (int i = 0; i < n; i++) {
if (i) {
hshl[q][i] = (1ll * hshl[q][i - 1] * base) % mod;
if (hshl[q][i] >= mod) hshl[q][i] %= mod;
}
hshl[q][i] += s[i];
if (hshl[q][i] >= mod) hshl[q][i] %= mod;
}
for (int i = n - 1; i >= 0; i--) {
if (i != n - 1) {
hshr[q][i] = (1ll * hshr[q][i + 1] * base) % mod;
if (hshr[q][i] >= mod) hshr[q][i] %= mod;
}
hshr[q][i] += s[i];
if (hshr[q][i] >= mod) hshr[q][i] %= mod;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
n = s.size();
prehash(BH, MH, 0);
for (int i = 0; i < n; i++) {
if (i == 0) {
dp[i] = 1;
ans++;
continue;
}
int mid = i / 2;
if (i % 2 == 0) mid--;
int mid1 = i / 2;
if (i % 2 == 0) {
mid1++;
} else {
mid1++;
}
pair<int, int> kk = hsh(0, i, 0, MH);
if (kk.first == kk.second) dp[i] = 1;
if (dp[i] && (hsh2(0, mid, 0, MH) == hsh2(mid1, i, 0, MH))) {
dp[i] += dp[mid];
}
ans += dp[i];
}
cout << ans;
}
|
#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 = 179, mod = (int)((1ll << 31) - 1);
int pre[5000005], nxt[5000005], len, powb[5000005] = {1}, ans = 0;
char s[5000005];
long long f[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>
using namespace std;
int ans = 0;
int i, j, n, m, k, z, x, y, t;
int a[5111111], p[111111], b[111111];
pair<int, int> d[111111];
string st, s;
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
m = 1;
for (i = 1; i <= (int)s.size(); i++) {
x = x * 337 + s[i - 1];
y += m * s[i - 1];
m *= 337;
if (x == y) {
a[i] = a[i / 2] + 1;
ans += a[i];
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000001;
string cad;
long long int h[MAXN];
long long int h2[MAXN];
long long int pot[MAXN];
long long int grado[MAXN];
long long int S(int a, int b) {
if (b == cad.size()) return h[a];
return h[a] - h[b + 1] * pot[b - a + 1];
}
long long int S2(int a, int b) {
if (b == cad.size()) return h2[a];
return h2[a] - h2[b + 1] * pot[b - a + 1];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pot[0] = 1;
for (int i = 1; i < MAXN; i++) pot[i] = pot[i - 1] * 33;
cin >> cad;
for (int i = cad.size() - 1; i >= 0; i--)
if (i == cad.size() - 1)
h[i] = cad[i];
else
h[i] = h[i + 1] * 33 + cad[i];
reverse(cad.begin(), cad.end());
for (int i = cad.size() - 1; i >= 0; i--)
if (i == cad.size() - 1)
h2[i] = cad[i];
else
h2[i] = h2[i + 1] * 33 + cad[i];
for (int i = 1; i <= cad.size(); i++) {
i--;
long long int uno = S(0, i);
long long int dos = S2(cad.size() - i - 1, cad.size() - 1);
i++;
if (uno == dos) grado[i] = grado[i >> 1] + 1;
}
long long int s = 0;
for (int i = 1; i <= cad.size(); i++) s += grado[i];
cout << s << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 5e6 + 10;
const long long mod = 1000696969;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
long long H[N], RH[N], P[N], dp[N], base = 256;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
string s;
cin >> s;
int n = (int)s.size();
s = "." + s + ".";
P[0] = 1;
for (int i = 1; i < N; i++) {
P[i] = P[i - 1] * base % mod;
}
for (int i = 1; i <= n; i++) {
H[i] = (H[i - 1] * base % mod + (long long)(s[i])) % mod;
}
for (int i = n; i >= 1; i--) {
RH[i] = (RH[i + 1] * base % mod + (long long)(s[i])) % mod;
}
long long res = 1;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
long long cu = (RH[1] - ((RH[i + 1] * P[i]) % mod) + 5 * mod) % mod;
if (H[i] == cu) {
dp[i] = dp[i / 2] + 1;
}
res += dp[i];
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char w[5000001];
int res[5000001], d[5000001][2];
int palindro(int i) { return d[(i + 1) >> 1][i & 1] == ((i + 1) >> 1); }
int main() {
gets(w);
int n = strlen(w);
for (int t = 0; t < 2; t++) {
int l = 0, r = -1, j;
for (int i = 0; i < n; i++) {
if (i > r)
j = 1;
else
j = min(d[l + r - i + t][t], r - i + t) + 1;
while (i + j - t < n && i - j >= 0 && w[i + j - t] == w[i - j]) j++;
j--;
d[i][t] = j;
if (i + j + t > r) {
l = i - j;
r = i + j - t;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (palindro(i - 1))
res[i] = res[i / 2] + 1;
else
res[i] = 0;
ans += res[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const double pi = (double)(2.0 * acos(0.0));
const int inf = 1 << 30;
const double eps = 1E-9;
const double e = exp(1.0);
const int sz = 5000000 + 5;
const int mod = 1000000000 + 7;
using namespace std;
bool ch[sz];
char s[sz];
long long int dp[sz];
int n;
int main() {
int t;
scanf("%s", &s);
n = strlen(s);
memset(dp, 0, sizeof(dp));
memset(ch, 0, sizeof(ch));
vector<int> d1(n);
int l = 0, r = -1;
for (int i = 0; i < n; ++i) {
int k = (i > r ? 0 : min(d1[l + r - i], r - i)) + 1;
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;
}
vector<int> d2(n);
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)) + 1;
while (i + k - 1 < 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;
}
for (int i = 0; i < n; i++) {
int k = d1[i];
{
l = i - k;
r = i + k;
if (l == 0 && l <= r) ch[r] = 1;
}
k = d2[i];
{
l = i - k;
r = i + k - 1;
if (l == 0 && l <= r) ch[r] = 1;
}
}
for (int i = 0; i < n; i++) {
if (ch[i]) {
dp[i] = 1 + dp[(i - 1) / 2];
}
}
long long int res = 0;
for (int i = 0; i < n; i++) res += dp[i];
printf("%I64d\n", res);
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 = 1723;
const long long inf = 2e18;
int dp[maxn5];
long long now, tav, modh, pre[maxn5];
int get_val(char a) { return int(a); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
modh = 1e9 + 7;
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 long long maxn = 5000 * 1000 + 5, base = 737;
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, n = (long long)(s).size();
for (long long i = 0; i < n; i++) {
x *= base;
x += s[i] - '0';
y += b * (s[i] - '0');
b *= base;
if (x == y) p[i] = true;
}
long long ans = 1;
dp[0] = 1;
for (long long i = 1; i < n; i++) {
if (p[i]) dp[i] = dp[(i + 1) / 2 - 1] + 1;
ans += dp[i];
}
cout << ans << endl;
return false;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using namespace std::chrono;
using ll = long long;
using pll = pair<ll, ll>;
const int MAX_N = 5e6 + 5;
const ll P1 = 1e9 + 7;
const ll X = 67;
int n;
char Str[MAX_N];
int dp[MAX_N] = {0};
ll Pref[MAX_N], InvPref[MAX_N];
ll BasePow[MAX_N];
ll getCharValue(char c) {
if (isdigit(c)) {
return 1 + c - '0';
} else {
if (islower(c)) {
return 11 + c - 'a';
} else {
return 37 + c - 'A';
}
}
}
ll getHash(int l, int r) {
if (l == 0) return Pref[r];
return (Pref[r] - (Pref[l - 1] * BasePow[r - l + 1]) % P1 + P1) % P1;
}
void fillBasePow() {
BasePow[0] = 1;
for (int i = 1; i <= n; i++) {
BasePow[i] = BasePow[i - 1] * X;
BasePow[i] %= P1;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto start = system_clock::now();
auto end = system_clock::now();
scanf("%s", &Str);
end = system_clock::now();
cerr << "Read string time: "
<< duration_cast<std::chrono::milliseconds>(end - start).count()
<< "ms\n";
for (n = 0; Str[n] != '\0'; n++)
;
fillBasePow();
ll hash = 0LL;
ll invHash = 0LL;
for (int i = 0; i < n; i++) {
ll c = getCharValue(Str[i]);
hash *= X;
hash %= P1;
hash += c;
hash %= P1;
Pref[i] = hash;
invHash += (BasePow[i] * c) % P1;
invHash %= P1;
InvPref[i] = invHash;
if (i % 2 == 0) {
int mid = i / 2;
if (InvPref[mid - 1] == getHash(mid + 1, i)) {
dp[i] = dp[mid - 1] + 1;
}
} else {
if (InvPref[i / 2] == getHash(i / 2 + 1, i)) {
dp[i] = dp[i / 2] + 1;
}
}
}
end = system_clock::now();
cerr << "Finished hashing shinanigens time: "
<< duration_cast<std::chrono::milliseconds>(end - start).count()
<< "ms\n";
ll ans = accumulate(dp, dp + n, 0LL);
printf("%lld\n", ans);
end = system_clock::now();
cerr << "Execution time: "
<< duration_cast<std::chrono::milliseconds>(end - start).count()
<< "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int z[5000000], n, z0[5000000], f[5000001], an = 1;
char s[5000001];
void bld() {
int l = 0, r = 0, i;
for (i = 1; s[i]; ++i) {
if (i > r) {
l = r = i;
while (s[r - l] == s[r]) ++r;
z0[i] = r-- - l;
} else {
int k = i - l;
if (z0[k] < r - i + 1)
z0[i] = z0[k];
else {
l = i;
while (s[r - l] == s[r]) ++r;
z0[i] = r-- - l;
}
}
}
n = i;
l = r = -1;
for (int i = 0; i < n; ++i) {
if (i > r) {
l = r = i;
while (s[r - l] == s[n - (r + 1)]) ++r;
z[i] = r-- - l;
} else {
int k = i - l;
if (z0[k] < r - i + 1)
z[i] = z0[k];
else {
l = i;
while (s[r - l] == s[n - (r + 1)]) ++r;
z[i] = r-- - l;
}
}
}
}
int main() {
scanf("%s", s);
bld();
f[1] = 1;
int l = n + 1;
for (int i = 2; i < l; ++i) {
int h = i >> 1;
if (z[n - i] >= h) an += f[i] = 1 + f[h];
}
printf("%d", an);
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
long long readIn() {
long long a = 0;
bool positive = true;
char ch = getchar();
while (!(ch == '-' || std::isdigit(ch))) ch = getchar();
if (ch == '-') {
positive = false;
ch = getchar();
}
while (std::isdigit(ch)) {
a = a * 10 - (ch - '0');
ch = getchar();
}
return positive ? -a : a;
}
void printOut(long long x) {
char buffer[20];
int length = 0;
if (x < 0)
putchar('-');
else
x = -x;
do buffer[length++] = -(x % 10) + '0';
while (x /= 10);
do putchar(buffer[--length]);
while (length);
putchar('\n');
}
const int maxn = int(6e6) + 5;
struct Manacher {
char str[maxn * 2];
int length;
int rl[maxn * 2];
void init(const char* s) {
str[length++] = '#';
for (; *s != '\0'; s++) {
str[length++] = *s;
str[length++] = '#';
}
}
void manacher() {
int center;
int maxRight = -1;
for (int i = 0; i < length; i++) {
if (i <= maxRight) {
rl[i] = std::min(rl[2 * center - i], maxRight - i + 1);
} else
rl[i] = 1;
while (i - rl[i] >= 0 && i + rl[i] < length &&
str[i - rl[i]] == str[i + rl[i]])
rl[i]++;
if (i + rl[i] - 1 > maxRight) {
maxRight = i + rl[i] - 1;
center = i;
}
}
}
inline bool judge(int i) { return rl[i + 1] >= i + 2; }
} manacher;
int n;
char str[maxn];
int f[maxn];
inline bool isValid(char ch) { return std::isalpha(ch) || std::isdigit(ch); }
void run() {
char ch = getchar();
while (!isValid(ch)) ch = getchar();
while (isValid(ch)) {
str[n++] = ch;
ch = getchar();
}
manacher.init(str);
manacher.manacher();
register long long ans = 1;
f[0] = 1;
for (register int i = 1; i < n; i++) {
if (manacher.judge(i))
f[i] = f[(i - 1) >> 1] + 1;
else
f[i] = 0;
ans += f[i];
}
printOut(ans);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5E6 + 6;
long long cen, MR, ans, n;
long long p[2 * N], f[2 * N];
string s;
void print() {
for (long long(i) = (1); (i) <= (n); ++(i)) cout << s[i] << " ";
cout << endl;
for (long long(i) = (1); (i) <= (n); ++(i)) cout << p[i] << " ";
cout << endl;
}
inline int judge(int l, int r) {
int mid = (l + r) >> 1;
if (p[mid] >= ((l + r) >> 1) - 1) return 1;
return 0;
}
int main() {
s = ' ';
char ch = getchar();
while (ch != '\n') {
s += ch;
ch = getchar();
}
string str = "#";
n = s.size() - 1;
for (long long(i) = (1); (i) <= (n); ++(i)) {
str += s[i];
str += '#';
}
string e = s;
s = str;
s = ' ' + s;
n = s.size() - 1;
for (long long(i) = (1); (i) <= (n); ++(i)) {
if (i < MR) {
long long mir = 2 * cen - i;
p[i] = min(p[mir], MR - i);
}
long long j = p[i] + 1;
while (i + j <= n && i - j >= 1 && s[i + j] == s[i - j]) ++j;
p[i] = j - 1;
if (i + p[i] > MR) {
cen = i;
MR = i + p[i];
}
}
for (int i = 2; i <= n; i += 2) {
if (!judge(1, i + 1)) continue;
f[i] = f[(i >> 2) << 1] + 1;
ans += f[i];
}
cout << ans << endl;
}
|
#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 = 1723;
const long long inf = 2e18;
int dp[maxn5];
long long now, tav, modh, pre[maxn5];
int get_val(char a) { return int(a); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
modh = 9e8 + 1723;
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>
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", t);
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5555555;
const int Base = 727;
const unsigned long long Mod = 1e9 + 9;
string s;
long long dp[Maxn], n;
long long ans, pw[Maxn], H[Maxn], R[Maxn];
long long mul(long long a, long long b) { return (a * b) % Mod; }
long long sum(long long a, long long b) { return (a + b + Mod) % Mod; }
long long get(int l, int r) {
return sum(H[r], -(mul(H[l - 1], pw[r - l + 1])));
}
long long getR(int l, int r) {
l = n - l + 1;
r = n - r + 1;
return sum(R[l], -(mul(R[r - 1], pw[l - r + 1])));
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
pw[0] = 1;
for (int i = 1; i < Maxn; i++) pw[i] = mul(pw[i - 1], Base);
cin >> s;
n = s.size();
H[1] = int(s[0]);
for (int i = 2; i <= n; i++) H[i] = sum(mul(H[i - 1], Base), int(s[i - 1]));
reverse(s.begin(), s.end());
R[1] = int(s[0]);
for (int i = 2; i <= n; i++) R[i] = sum(mul(R[i - 1], Base), int(s[i - 1]));
reverse(s.begin(), s.end());
for (int i = 1; i <= n; i++) {
int mid = i >> 1;
if (get(1, mid) == getR(i - mid + 1, i))
dp[i] = dp[mid] + 1;
else
dp[i] = 0;
ans += dp[i];
}
cout << ans;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
const int mod = int(1e9) + 7;
const int L = 5000010;
int n, m, i, j, k, l, p, ans;
char A[L], a[L];
int r[L];
long long H[L], G[L], c[L];
long long get0(int x, int y) {
if (x > y) return 0;
return ((H[y] - H[x - 1] * c[y - x + 1]) % mod + mod) % mod;
}
long long get1(int x, int y) {
if (x < y) return 0;
return ((G[y] - G[x + 1] * c[x - y + 1]) % mod + mod) % mod;
}
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
c[0] = 1;
for (i = 1; i <= n; i++) c[i] = c[i - 1] * 128 % mod;
for (i = 1; i <= n; i++) H[i] = (H[i - 1] * 128 + a[i]) % mod;
for (i = n; i >= 1; i--) G[i] = (G[i + 1] * 128 + a[i]) % mod;
for (i = 1; i <= (n + 1) / 2; i++) {
if (get0(1, 2 * i - 1) == get1(2 * i - 1, 1))
ans += r[2 * i - 1] = r[i - 1] + 1;
if (2 * i <= n && get0(1, 2 * i) == get1(2 * i, 1))
ans += r[2 * i] = r[i] + 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long Base = 47289, mod = 998244353;
long long base = 1;
std::string s;
long long n, ans, pre, lst, f[5000001];
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
std::cin >> s;
n = s.size();
for (long long i = 0; i <= n - 1; i++) {
pre = (pre * Base + (long long)s[i] + mod) % mod;
lst = (lst + (long long)(s[i]) * base + mod) % mod;
base = base * Base % mod;
if (pre == lst) f[i] = f[(i - 1) / 2] + 1, ans += f[i];
}
std::cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long c = 6000000, inf = 2000000000, b = 157, mod = 1000000009;
long long h1[c], h2[c], n, res = 0;
long long memo[c];
string second;
long long power[c];
long long counter = 0;
long long first(long long r) {
if (r == 1) return 1;
if (memo[r] != -1) return memo[r];
counter++;
int x = (h1[r] - h1[0] * power[r]) % mod;
int y = (h2[1] - h2[r + 1] * power[r]) % mod;
if (x < 0) x += mod;
if (y < 0) y += mod;
if (x == y)
return memo[r] = first(r / 2) + 1;
else
return memo[r] = 0;
}
int main() {
memset(h1, 0, sizeof(h1));
memset(h2, 0, sizeof(h2));
memset(memo, -1, sizeof(memo));
power[0] = 1;
for (int i = 1; i < c; i++) power[i] = power[i - 1] * b % mod;
cin >> second;
n = second.size();
for (long long i = 1; i <= n; i++)
h1[i] = (h1[i - 1] * b + second[i - 1]) % mod;
for (long long i = n; i > 0; i--)
h2[i] = (h2[i + 1] * b + second[i - 1]) % mod;
for (long long i = 1; i <= n; i++) res += first(i);
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long B = 701;
const int maxn = 5e6 + 321;
int n;
string s;
long long b[maxn], h[maxn], Rh[maxn], dp[maxn], ans;
inline void build() {
b[0] = 1;
for (int i = 1; i <= n; i++) b[i] = b[i - 1] * B;
for (int i = 1; i <= n; i++) {
h[i] = h[i - 1] * B;
h[i] += (long long)s[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
Rh[i] = Rh[i + 1] * B;
Rh[i] += (long long)s[i];
}
}
long long gethash(int l, int r, int t) {
if (t) return h[r] - (h[l] * b[r - l]);
return Rh[l] - (Rh[r] * b[r - l]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
build();
dp[1] = 1, ans = 1;
for (int i = 2; i <= n; i++) {
if (gethash(0, i, 1) == gethash(0, i, 0))
dp[i] = dp[i / 2] + 1;
else
dp[i] = 0;
ans += dp[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int X = 5000009, P = 10000007, M = 129, Q = 9999997;
char s[X];
int dp[X];
int main() {
scanf("%s", s);
long long result = 1;
dp[0] = 1;
int L, R;
L = R = s[0];
int L2, R2;
L2 = R2 = s[0];
int m = M, m2 = M;
for (int i = 1; s[i]; i++) {
L = (L * M + s[i]) % P;
R = (s[i] * m + R) % P;
L2 = (L2 * M + s[i]) % Q;
R2 = (s[i] * m2 + R2) % Q;
m = (m * M) % P;
m2 = (m2 * M) % Q;
if (L == R && L2 == R2) {
dp[i] = dp[(i + 1) / 2 - 1] + 1;
} else {
dp[i] = 0;
}
result += dp[i];
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sq(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
int A[5000001], len;
long long dp[5000001];
int convert(char c) {
if (c >= 'a' && c <= 'z')
return (int)(c - 87);
else if (c >= '0' && c <= '9')
return (int)(c - 48);
else
return (int)(c - 29);
}
int main(int argc, char *argv[]) {
string S;
int i;
long long k1, k2, v = 1, res = 1;
cin >> S;
len = S.length();
for (i = 0; i <= len - 1; i++) A[i] = convert(S[i]);
dp[0] = 1;
k1 = A[0];
k2 = A[0];
for (i = 1; i <= len - 1; i++) {
v *= 5;
k1 += (v * A[i]);
k2 = 5 * k2 + A[i];
if (k1 == k2) dp[i] = dp[(i + 1) / 2 - 1] + 1;
res += dp[i];
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 10;
unsigned long long tmp, p, q;
char s[N];
int f[N];
int n;
long long ans;
int main() {
scanf("%s", s);
n = strlen(s);
f[0] = 1;
p = q = s[0];
tmp = 1;
for (int i(1); i <= (n - 1); ++i) {
p = p * 131 + s[i];
tmp = tmp * 131;
q += s[i] * tmp;
if (p == q) f[i] = f[(i - 1) / 2] + 1;
}
for (int i(0); i <= (n - 1); ++i) ans += 1ll * f[i];
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long h1[5000000 + 5], h2[5000000 + 5], p[5000000 + 5], dp[5000000 + 5];
char s[5000000 + 5];
void calculate_hash(int l) {
p[0] = 1;
for (int i = 1; i < l; i++) p[i] = (83 * p[i - 1]) % 1000000007;
for (int i = 0; i < l; i++) {
if (i == 0)
h1[i] = (p[i] * (long long)(s[i] - 'a') + 1000000007) % 1000000007;
else
h1[i] = (h1[i - 1] + (p[i] * (long long)(s[i] - 'a')) % 1000000007 +
1000000007) %
1000000007;
}
reverse(s, s + l);
for (int i = 0; i < l; i++) {
if (i == 0)
h2[i] = (p[i] * (long long)(s[i] - 'a') + 1000000007) % 1000000007;
else
h2[i] = (h2[i - 1] + (p[i] * (long long)(s[i] - 'a')) % 1000000007 +
1000000007) %
1000000007;
}
}
bool is_palindrome(int i, int l) {
long long k1 = h1[i];
k1 = (k1 * p[l - 1]) % 1000000007;
int j = l - 1 - i;
long long k2 = h2[l - 1];
if (j != 0) k2 = (k2 - h2[j - 1] + 1000000007) % 1000000007;
k2 = (k2 * p[l - 1 - j]) % 1000000007;
if (k1 == k2)
return true;
else
return false;
}
int main(int argc, const char* argv[]) {
scanf("%s", s);
int l = (int)strlen(s);
calculate_hash(l);
dp[0] = 1;
long long ans = 1;
for (int i = 1; i < l; i++) {
if (is_palindrome(i, l)) {
int j = i / 2;
if (i % 2 == 0) j--;
dp[i] = dp[j] + 1;
ans += dp[i];
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p[5000010 * 2], Dp[5000010];
char S[5000010 * 2];
long long Ans;
void Manacher() {
int m = 0, x = 1;
for (int i = 1; i <= n; i++) {
p[i] = 1;
if (m > i) p[i] = min(m - i, p[2 * x - i]);
while (S[i - p[i]] == S[i + p[i]]) p[i]++;
if (i - p[i] + 1 == 1 && p[i] != 1) {
Dp[p[i] - 1] = Dp[(p[i] - 1) / 2] + 1;
Ans += Dp[p[i] - 1];
}
if (m < i + p[i] - 1) m = i + p[i] - 1, x = i;
}
}
int main() {
scanf("%s", S);
n = (int)strlen(S);
for (int i = n; i >= 0; i--) S[i * 2 + 2] = S[i], S[i * 2 + 1] = '#';
S[0] = '$';
n = n * 2 + 1;
Manacher();
cout << Ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[5005000];
int f[5005000];
int main() {
gets(ch);
int l = 0, r = 0, tmp = 1, ans = 0, len = strlen(ch);
for (int i = 0; i < len; i++) {
l = l * 103 + ch[i];
r = r + ch[i] * tmp;
tmp *= 103;
if (l == r) f[i + 1] = f[(i + 1) / 2] + 1;
ans += f[i + 1];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 5e6 + 5;
const int base = 13331;
char s[maxn];
unsigned long long p[maxn], sum[maxn], suf[maxn];
int f[maxn];
int idx(char c) {
if (c >= 'a' && c <= 'z') return c - 'a' + 1;
if (c >= 'A' && c <= 'Z') return c - 'A' + 27;
return c - '0' + 53;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
p[0] = 1;
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] * base;
sum[i] = sum[i - 1] * base + idx(s[i]);
}
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] * base + idx(s[i]);
int ans = 1;
f[1] = 1;
for (int i = 2; i <= n; i++) {
int p1 = i / 2, p2 = i - i / 2 + 1;
unsigned long long tmp1 = sum[p1], tmp2 = suf[p2] - suf[i + 1] * p[i / 2];
if (tmp1 == tmp2) {
f[i] = f[i / 2] + 1;
ans += f[i];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 5e6 + 5;
int P[SIZE * 2], k[SIZE];
string convertToNewString(const string &s) {
string newString = "@";
for (int i = 0; i < s.size(); i++) {
newString += "#" + s.substr(i, 1);
}
newString += "#$";
return newString;
}
vector<int> v;
bool vis[SIZE];
void longestPalindromeSubstring(const string &s) {
string Q = convertToNewString(s);
int c = 0, r = 0;
for (int i = 1; i < Q.size() - 1; i++) {
int iMirror = c - (i - c);
if (r > i) {
P[i] = min(r - i, P[iMirror]);
}
while (Q[i + 1 + P[i]] == Q[i - 1 - P[i]]) {
P[i]++;
}
if (i + P[i] > r) {
c = i;
r = i + P[i];
}
}
for (int i = 1; i < Q.size() - 1; i++) {
if (!P[i]) continue;
int idx = (i - 1 - P[i]) / 2;
if (!idx && !vis[P[i]]) v.push_back(P[i]), vis[P[i]] = 1;
}
}
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
longestPalindromeSubstring(s);
long long sum = 0;
for (auto i : v) sum += (k[i] = k[i / 2] + 1);
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 1000001;
const unsigned long long T = 257;
char s[MAXN];
int n, f[MAXN], i, ans;
unsigned long long h[MAXN], revH[MAXN], t[MAXN];
void calcT(int n) {
t[0] = 1;
for (int i = 1; i <= n; i++) t[i] = t[i - 1] * T;
}
void calcH(char* s, int n) {
h[0] = 0;
for (int i = 1; i <= n; i++) {
h[i] = h[i - 1] + s[i - 1] * t[i - 1];
}
}
unsigned long long getH(int l, int r) {
return t[n - l + 1] * (h[r] - h[l - 1]);
}
void calcRevH(char* s, int n) {
h[n + 1] = 0;
for (int i = n; i >= 1; i--) {
revH[i] = revH[i + 1] + s[i - 1] * t[n - i];
}
}
unsigned long long getRevH(int l, int r) {
return t[r] * (revH[l] - revH[r + 1]);
}
int main() {
gets(s);
n = strlen(s);
calcT(n);
calcH(s, n);
calcRevH(s, n);
f[1] = 1;
for (i = 2; i <= n; i++) {
int l, r, ll, rr;
int m = i / 2;
l = 1, r = m;
rr = i;
if (i % 2 == 1)
ll = m + 2;
else
ll = m + 1;
if (getH(l, r) == getRevH(ll, rr))
f[i] = f[m] + 1;
else
f[i] = 0;
}
for (i = 1; i <= n; i++) {
ans += f[i];
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int HashNum = 89, MAXN = 5 * 1000 * 1000 + 10;
string s;
int Hash[MAXN], HashRev[MAXN], Power[MAXN], dp[MAXN], ans;
int main() {
ios::sync_with_stdio(0);
cin >> s;
Power[0] = 1;
for (int i = 1; i <= s.size(); i++) Power[i] = Power[i - 1] * HashNum;
for (int i = 1; i <= s.size(); i++)
Hash[i] = HashNum * Hash[i - 1] + s[i - 1];
for (int i = 1; i <= s.size(); i++)
HashRev[i] = HashRev[i - 1] + Power[i - 1] * s[i - 1];
for (int i = 1; i <= s.size(); i++)
if (Hash[i] == HashRev[i]) dp[i] = dp[i / 2] + 1;
for (int i = 1; i <= s.size(); i++) ans += dp[i];
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 = 1e9 + 7;
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 inf = 1e9 + 10;
const long long int INF = 2e18 + 10;
const int Mod = 1e9 + 7;
const int MAXN = 5e6 + 10;
const int N = 2e3 + 10;
const int M = 1e3 + 10;
int l, r, p = 131, q = 1, ans, h[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < n; i++) {
l = l * p + s[i];
r = r + s[i] * q;
q *= p;
if (l == r) {
h[i + 1] = 1 + h[(i + 1) / 2];
ans += h[i + 1];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000010];
long long p[5000010];
string st;
int main() {
scanf("%s", s);
st = s;
long long cnt = p[0] = 1;
long long h1, h2, g1, g2, po1, po2;
po2 = po1 = 1;
g1 = h1 = s[0];
g2 = h2 = s[0];
p[0] = 1;
for (long long i = 1; i < st.size(); i++) {
po1 = po1 * 313LL % 1057489703LL;
g1 = (g1 + s[i] * po1 % 1057489703LL) % 1057489703LL;
h1 = h1 * 313LL % 1057489703LL;
h1 = (h1 + s[i]) % 1057489703LL;
po2 = po2 * 311LL % 1057481927LL;
g2 = (g2 + s[i] * po2 % 1057481927LL) % 1057481927LL;
h2 = h2 * 311LL % 1057481927LL;
h2 = (h2 + s[i]) % 1057481927LL;
if (g1 == h1 && g2 == h2) {
p[i] = p[(i - 1) >> 1] + 1;
cnt += p[i];
}
}
cout << cnt << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned t[5000005];
int main() {
string s;
cin >> s;
unsigned a = 0, b = 0, pot = 1;
long long res = 0;
for (int i = 0; i < s.length(); i++) {
a = a * 10007 + s[i];
b += pot * s[i];
pot *= 10007;
if (a == b) {
t[i + 1] = t[(i + 1) / 2] + 1;
res += t[i + 1];
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
long long dp[5000005];
char s[5000005];
using namespace std;
int main() {
long long ans = 0, l = 0, r = 0, k = 1;
scanf("%s", s);
for (int i = 0; s[i]; i++) {
l = l * 33 + s[i] - 'a';
r = r + (s[i] - 'a') * k;
k = k * 33;
if (l == r) dp[i + 1] = dp[(i + 1) / 2] + 1;
ans += dp[i + 1];
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000006];
long long rsum[5000006], Pow[5000006], dp[5000006], ans, sum;
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1);
Pow[0] = 1;
for (int i = len; i >= 1; i--)
rsum[i] = rsum[i + 1] * 131 + s[i], Pow[len - i + 1] = Pow[len - i] * 131,
dp[i] = 1;
for (int i = 1; i <= len; i++) {
sum = sum * 131 + s[i];
if (sum == rsum[1] - rsum[i + 1] * Pow[i])
dp[i * 2] = dp[i * 2 + 1] = dp[i] + 1, ans += dp[i];
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
struct Hash {
long long SEED = 1331;
long long MOD = 1000000007;
vector<long long> ha;
vector<long long> power;
Hash(string x) {
ha = vector<long long>(x.size());
power = vector<long long>(x.size());
build(x);
}
void build(string x) {
power[0] = 1;
for (int i = 1; i < (int)power.size(); i++)
power[i] = (power[i - 1] * SEED) % MOD;
ha[0] = x[0];
for (int i = 1; i < (int)ha.size(); i++)
ha[i] = (ha[i - 1] * SEED + x[i]) % MOD;
}
long long get(int i, int j) {
long long ret = ha[j];
if (i) ret -= ha[i - 1] * power[j - i + 1];
ret = (ret % MOD + MOD) % MOD;
return ret;
}
};
const int N = 5000500;
char r[N];
int Dp[N];
int main() {
scanf("%s", r);
string s(r), t(r);
reverse(t.begin(), t.end());
Hash Hs(s), Ht(t);
int n = s.size();
int Ans = Dp[0] = 1;
for (int i = 1; i < n; i++) {
int x1 = Hs.get(0, i);
int x2 = Ht.get(n - 1 - i, n - 1);
if (x1 == x2) {
Dp[i] = 1 + Dp[(i - 1) / 2];
Ans += Dp[i];
}
}
cout << Ans;
}
|
#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];
long long Exp[MAXN];
long long Hash[MAXN];
long long RHash[MAXN];
long long L[MAXN];
void calcExp() {
Exp[0] = 1;
for (int i = 1; i < n; ++i) {
Exp[i] = (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] = (Hash[i - 1] * BASE + s[i]) % MOD;
RHash[n - i + 1] = (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] - (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] - (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;
int main() {
ios_base::sync_with_stdio(false);
string s;
getline(cin, s);
int n = s.size();
if (n < 2) {
cout << n << endl;
return 0;
}
vector<int> dp(n + 1, 0);
dp[1] = 1;
int res = 1;
n = 2 * n + 1;
vector<int> L(n, 0);
L[1] = 1;
int C = 1, R = 2;
int iMirror, diff;
for (int i = 2; i <= n / 2; i++) {
iMirror = 2 * C - i;
diff = R - i;
if (diff > 0) {
L[i] = min(L[iMirror], diff);
}
while ((i + L[i] < n) && (i - L[i] > 0) &&
(((i + L[i] + 1) % 2 == 0) ||
(s[(i + L[i] + 1) / 2] == s[(i - L[i] - 1) / 2]))) {
L[i]++;
}
if (i + L[i] > R) {
C = i;
R = i + L[i];
}
if (L[i] == i) {
dp[i] = dp[i / 2] + 1;
res += dp[i];
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
if (y == 0)
return 1;
else if (y == 1)
return x;
else {
long long t = power(x, y / 2);
if (y % 2 == 0) {
return (t * t) % 1000000007;
} else {
return (x * ((t * t) % 1000000007)) % 1000000007;
}
}
}
long long mod(long long x) {
return (x % 1000000007 + 1000000007) % 1000000007;
}
int arr[5000005];
long long pow1[5000005];
long long pow2[5000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long pref1 = 0;
long long suff1 = 0;
long long pref2 = 0;
long long suff2 = 0;
long long len = 0;
arr[0] = 1;
pow1[0] = 1;
pow2[0] = 1;
for (int i = 1; i < s.size(); i++) {
pow1[i] = mod(pow1[i - 1] * 29);
pow2[i] = mod(pow2[i - 1] * 31);
}
for (int i = 1; i < s.size(); i++) {
if (i % 2 == 0) {
suff1 -= s[i / 2] * pow1[len - 1];
suff1 *= 29;
suff1 += s[i];
suff1 = mod(suff1);
suff2 -= s[i / 2] * pow2[len - 1];
suff2 *= 31;
suff2 += s[i];
suff2 = mod(suff2);
} else {
len += 1;
pref1 += s[i / 2] * pow1[len - 1];
pref2 += s[i / 2] * pow2[len - 1];
pref1 = mod(pref1);
pref2 = mod(pref2);
suff1 *= 29;
suff1 += s[i];
suff2 *= 31;
suff2 += s[i];
suff1 = mod(suff1);
suff2 = mod(suff2);
}
if (pref1 == suff1 && pref2 == suff2) {
arr[i] = arr[(i - 1) / 2] + 1;
}
}
long long second = 0;
for (int i = 0; i < s.size(); i++) {
second += arr[i];
}
cout << second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
long long f(char x) {
if ('0' <= x && x <= '9') {
return x - '0' + 1;
} else {
if ('a' <= x && x <= 'z') {
return x - 'a' + 11;
} else {
return x - 'A' + 11 + ('z' - 'a' + 1);
}
}
}
long long deg[(int)5e6 + 10], pre_hashes[(int)5e6], suf_hashes[(int)5e6];
long long ans[(int)5e6];
int main() {
string s;
cin >> s;
deg[0] = 1;
for (int i = 1; i < (int)5e6 + 10; ++i) {
deg[i] = (deg[i - 1] * 67) % M;
}
pre_hashes[0] = f(s[0]);
for (int i = 1; i < (s).size(); ++i) {
pre_hashes[i] = (pre_hashes[i - 1] + f(s[i]) * deg[i]) % M;
}
reverse((s).begin(), (s).end());
suf_hashes[0] = f(s[0]);
for (int i = 1; i < (s).size(); ++i) {
suf_hashes[i] = (suf_hashes[i - 1] + f(s[i]) * deg[i]) % M;
}
memset((ans), (0), sizeof(ans));
long long r = 1;
ans[0] = 1;
for (int i = 1; i < (s).size(); ++i) {
if ((deg[(s).size() - i - 1] * pre_hashes[(i - 1) / 2]) % M ==
(suf_hashes[(s).size() - 1 - (i - (i - 1) / 2)] -
suf_hashes[(s).size() - 2 - i] + M) %
M) {
ans[i] = ans[(i - 1) / 2] + 1;
} else {
ans[i] = 0;
}
r += ans[i];
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string str;
cin >> str;
long long int prime1 = 137;
long long int store = 1, val;
long long int forward = 0, revhash = 0;
long long int len = str.size();
long long int hash[len + 1];
long long int ans = 0;
hash[0] = 0;
for (long long int i = 1; i <= len; i++) {
val = str[i - 1];
forward = (forward * prime1 + val) % 1000000007;
revhash += (store * val) % 1000000007;
revhash = revhash % 1000000007;
store = (store * prime1) % 1000000007;
if (revhash != forward) {
hash[i] = 0;
continue;
}
hash[i] = hash[i / 2] + 1;
ans += hash[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000050;
int dp[MAXN];
char str[MAXN];
int main() {
scanf("%s", str + 1);
unsigned int left = 0, right = 0, e = 107, u = 1;
int ans = 0;
for (int i = 1; str[i]; ++i) {
left = left * e + str[i];
right = right + u * str[i];
u *= e;
if (left == right) dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[10000001];
int n, n2, z[10000001], f[5000001], res;
void calcZ() {
int L = 0, R = 0;
for (int i = 1; i < n2; ++i) {
if (i > R) {
L = R = i;
while (R < n2 && s[R] == s[R - L]) ++R;
z[i] = R - L;
--R;
} else {
int k = i - L;
if (z[k] <= R - i)
z[i] = z[k];
else {
L = i;
while (R < n2 && s[R] == s[R - L]) ++R;
z[i] = R - L;
--R;
}
}
}
}
int main() {
scanf("%s", s);
n = strlen(s);
n2 = n * 2;
for (int i = 0; i < n; ++i) s[n2 - i - 1] = s[i];
calcZ();
f[0] = res = 1;
for (int i = 1; i < n; ++i) {
if (z[n2 - i - 1] == i + 1) f[i] = f[(i - 1) >> 1] + 1;
res += f[i];
}
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[5000001];
int dp[5000000];
int main() {
gets(s);
unsigned long long a = 0, l = 0, r = 0, t = 1;
for (int i = 0; s[i]; i++) {
l = (l * 109) + s[i];
r = r + s[i] * t;
t *= 109;
if (l == r) dp[i + 1] = dp[(i + 1) / 2] + 1;
a += dp[i + 1];
}
cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long base = 71;
const long long mod = 1e9 + 9;
int convert(char a) {
if (a >= 'a' && a <= 'z') return (a - 'a') + 1;
if (a >= 'A' && a <= 'Z') return (a - 'A') + 27;
return (a - '0') + 53;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = (int)s.length();
long long ans = 0;
vector<long long> V(n);
long long H = 0;
long long I = 0;
long long p = 1;
V[0] = 1ll;
for (int i = 0; i < n; ++i) {
H = (H * base % mod + (long long)convert(s[i])) % mod;
I = (I + p * (long long)convert(s[i]) % mod) % mod;
p = (p * base) % mod;
if (i && H == I) V[i] = V[(i - 1) / 2] + 1ll;
ans += V[i];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long int m = 200000000000000003;
string s;
int a[5000000];
char t[5000001];
int z;
unsigned long long int x, y, w(1);
int main() {
gets(t);
s = t;
for (int i = 0; i < s.size(); i++) {
x = (x * 76 + (s[i] - 47)) % m;
y = (y + w * (s[i] - 47)) % m;
w *= 76;
w %= m;
if (x == y) a[i] = a[(i - 1) / 2] + 1;
z += a[i];
}
printf("%d", z);
}
|
#include <bits/stdc++.h>
using namespace std;
char a[5000010], s[10000010];
int f[10000010];
int n;
inline void change() {
s[0] = s[1] = '#';
for (register int i = 0; i < n; i++)
s[(i << 1) + 2] = a[i], s[(i << 1) + 3] = '#';
n = n * 2 + 2;
s[n] = '\0';
}
inline void manacher() {
int MaxRight = 0, mid;
for (register int i = 1; i < n; i++) {
if (i < MaxRight)
f[i] = min(f[(mid << 1) - i], f[mid] + mid - i);
else
f[i] = 1;
for (; s[i + f[i]] == s[i - f[i]]; f[i]++) {
if (f[i] + i > MaxRight) {
MaxRight = f[i] + i;
mid = i;
}
}
}
}
int dp[5000010];
int main() {
scanf("%s", a);
n = strlen(a);
int l = n;
change();
manacher();
int ans = 1;
dp[2] = 1;
for (register int i = 3; i <= (n >> 1); i++) {
if (f[i] == i)
dp[i] = dp[(i + 1) >> 1] + 1;
else
dp[i] = 0;
ans += dp[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sl, f, b, MOD = 998244353;
char s[5000005];
long long base = 1;
int dp[5000005], ans;
inline void get_hash(int x) {
f = (f * 32767ll + (long long)s[x] + MOD) % MOD;
b = (b + (long long)(s[x]) * base + MOD) % MOD;
base = base * 32767ll % MOD;
}
int main() {
scanf("%s", s);
sl = strlen(s);
for (register int i = 0; i < sl; i++) {
get_hash(i);
if (f == b) {
dp[i] = dp[(i - 1 >> 1)] + 1, ans += dp[i];
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, m, s, r;
bool f;
char str[50000010];
int A[50000010], ll[2], rr[2], rr2[2], I[2], P[100][2], power[2],
mod[] = {40009, 40013};
int fun(char c) {
if (islower(c)) return c - 'a' + 1;
if (isupper(c)) return c - 'A' + 27;
return c - '0' + 53;
}
int main() {
for (i = 0; i < 2; i++)
for (j = 1, P[0][i] = 63; j < 100; j++)
P[j][i] = P[j - 1][i] * P[j - 1][i] % mod[i];
scanf("%s", str);
n = strlen(str);
for (i = 0; i < n; i++) {
A[i + 1] = fun(str[i]);
str[i] = A[i + 1];
}
for (i = 0; i < 2; i++) {
ll[i] = A[1];
for (I[i] = 1; (I[i] * 63) % mod[i] != 1; I[i]++)
;
rr[i] = 0;
for (j = n; j > 1; j--) rr[i] = (63 * rr[i] + A[j]) % mod[i];
rr2[i] = rr[i];
}
k = 2;
r = 1;
power[0] = power[1] = 63;
for (i = 2, A[1] = s = 1; i <= n; i++) {
m = i / 2;
while (k < i - m + 1) {
for (j = 0; j < 2; j++) {
rr2[j] = (rr2[j] - str[k - 1] + mod[j]) % mod[j];
rr2[j] = (rr2[j] * I[j]) % mod[j];
}
k++;
}
while (r < m) {
r++;
for (j = 0; j < 2; j++) {
ll[j] = (63 * ll[j] + str[r - 1]) % mod[j];
power[j] = 63 * power[j] % mod[j];
}
}
for (j = 0, f = 1; j < 2; j++) {
rr[j] = (rr[j] - A[i] + mod[j]) % mod[j];
rr[j] = (rr[j] * I[j]) % mod[j];
if (ll[j] != (rr2[j] + mod[j] - (rr[j] * power[j]) % mod[j]) % mod[j])
f = 0;
}
if (f)
A[i] = A[m] + 1;
else
A[i] = 0;
s += A[i];
}
cout << s << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long a[5000000 + 5];
long long f, b, p;
int main() {
cin >> s;
p = 1, f = b = 0;
long long ans = 0;
for (int i = (1), _b = (s.size()); i <= _b; i++) a[i] = 0;
for (int i = (1), _b = (s.size()); i <= _b; i++) {
f = f * 13331 + s[i - 1];
b = s[i - 1] * p + b;
p *= 13331;
if (f == b) {
a[i] = a[i / 2] + 1;
ans += a[i];
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
template <class T>
int size(const T &x) {
return x.size();
}
long long base = 256;
long long mod = 2147483549;
const int N = 5000010;
char s[N];
int arr[N], arr2[N], pm[N], deg[N];
int main() {
scanf("%s\n", s);
int n = strlen(s);
pm[0] = 1;
for (int i = 1; i <= n; i++) {
pm[i] = ((long long)pm[i - 1] * base) % mod;
}
arr[0] = arr2[0] = 0;
for (int i = 0; i < n; i++) {
arr[i + 1] = ((long long)arr[i] * base + s[i]) % mod;
arr2[i + 1] = ((long long)arr2[i] * base + s[n - i - 1]) % mod;
}
deg[0] = 0;
long long sm = 1;
deg[1] = 1;
for (int i = 2; i <= n; i++) {
int j = i / 2;
if (((arr[(j - 1) + 1] -
((long long)arr[(0)] * pm[(j - 1) - (0) + 1]) % mod + mod) %
mod) ==
((arr2[(n - (i - j) - 1) + 1] -
((long long)arr2[(n - (i - 1) - 1)] * pm[(i - 1) - (i - j) + 1]) %
mod +
mod) %
mod)) {
deg[i] = deg[j] + 1;
} else {
deg[i] = 0;
}
sm += deg[i];
}
cout << sm << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e6 + 100;
const long long M = 20;
const long long SQ = 320;
const long long INF = 1e16;
const long long MOD = 1e9 + 7;
const long long base = 12347;
const long long MOD1 = 1e9 + 7;
const long long MOD2 = 1e9 + 9;
int n;
string s;
char tmp[N];
long long t[N], hsh[N], rhsh[N];
int f[N];
long long get_hash(int x, int y) { return hsh[y] - 1LL * t[y - x] * hsh[x]; }
long long rev_hash(int x, int y) { return rhsh[x] - 1LL * t[y - x] * rhsh[y]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%s", tmp);
s = tmp;
n = s.size();
t[0] = 1;
for (int i = 1; i <= n; i++) {
t[i] = 1LL * t[i - 1] * base;
}
for (int i = 1; i <= n; i++) {
hsh[i] = (1LL * hsh[i - 1] * base + s[i - 1]);
}
for (int i = n - 1; i >= 0; i--) {
rhsh[i] = (1LL * rhsh[i + 1] * base + s[i]);
}
f[0] = 1;
long long ans = 1;
for (int i = 1; i < n; i++) {
if (get_hash(0, (i + 1) / 2) == rev_hash(i / 2 + 1, i + 1))
f[i] = f[(i - 1) / 2] + 1;
else
f[i] = 0;
ans += f[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[6000000];
int dp[6000000];
int d1[6000000];
int d2[6000000];
int n;
void calc() {
int l = 0, r = -1;
d1[0] = 1;
for (int i = 1; i < n; ++i) {
int k = (i > r ? 0 : min(d1[l + r - i], r - i)) + 1;
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;
if (s[0] == s[1]) d2[0] = 1;
for (int i = 1; i < n; ++i) {
int k = (i > r ? 0 : min(d2[l + r - i + 1], r - i + 1)) + 1;
while (i + k - 1 < 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 pr[6000000];
int main() {
gets(s);
n = strlen(s);
calc();
long long res = 0;
dp[0] = 1;
for (int i = 1; i < n; i++) {
if (d1[i] == i) pr[i + i + 1] = 1;
if (d2[i] == i) pr[i + i] = 1;
}
pr[0] = 1;
pr[1] = 1;
dp[1] = 1;
for (int i = 2; i <= n; i++)
if (pr[i]) dp[i] = dp[i / 2] + 1;
for (int i = 1; i <= n; i++) res += (long long)(dp[i]);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[20000001];
int deg[20000001];
string a;
string modify(string a) {
string b = "^";
for (int i = 0; i < a.size(); i++) {
b.push_back('#');
b.push_back(a[i]);
}
b.push_back('#');
b.push_back('$');
return b;
}
int main() {
cin >> a;
a = modify(a);
int n = a.size();
int R = 0;
int C = 0;
memset(dp, 0, sizeof dp);
for (int i = 1; i < n - 1; i++) {
int i_mirror = 2 * C - i;
dp[i] = (R > i) ? min(R - i, dp[i_mirror]) : 0;
while (a[i + 1 + dp[i]] == a[i - 1 - dp[i]]) dp[i]++;
if (i + dp[i] > R) {
C = i;
R = i + dp[i];
}
}
memset(deg, 0, sizeof deg);
long long int ans = 0;
for (int i = 2; i < n - 1; i++) {
if (dp[i] >= (i - 1)) {
deg[i] = deg[((i - 1) / 2) + 1] + 1;
ans += deg[i];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
getline(cin, s);
int n = s.size();
if (n < 2) {
cout << n << endl;
return 0;
}
vector<int> dp(n + 1, 0);
dp[1] = 1;
int res = 1;
n = 2 * n + 1;
vector<int> L(n / 2 + 1, 0);
L[1] = 1;
int C = 1, R = 2;
for (int i = 2; i <= n / 2; i++) {
int j = 2 * C - i;
if (R - i > 0) L[i] = min(L[j], R - i);
while (i + L[i] < n && i - L[i] > 0 &&
((i + L[i]) % 2 == 1 ||
s[(i + L[i] + 1) / 2] == s[(i - L[i] - 1) / 2])) {
L[i]++;
}
if (i + L[i] > R) {
C = i;
R = i + L[i];
}
if (L[i] == i) {
dp[i] = dp[i / 2] + 1;
res += dp[i];
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O5")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
const int inf = INT_MAX;
const long long linf = LLONG_MAX;
const int mod = 1000000007;
template <typename X>
inline void getarr(X *a, int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename X>
inline void getarr(X *a, int n, int m) {
for (int i = 0; i < n; i++) getarr(a[i], m);
}
template <typename X>
inline void putarr(X *a, int n, char ch = ' ') {
for (int i = 0; i < n; i++) cout << a[i] << ch;
}
template <typename X>
inline void putarr(X *a, int n, int m) {
for (int i = 0; i < n; i++) {
putarr(a[i], m, ' ');
cout << '\n';
}
}
template <typename X>
inline X abs(X a) {
return a < 0 ? a * (-1) : a;
}
char s[5000009];
int hm = 1000000009;
const int q = 5000000;
int n;
template <typename X>
X binpow(X a, long long n, int mm) {
X res = 1;
while (n) {
if (n & 1) {
res *= a;
if (res >= mm) res %= mm;
}
a *= a;
if (a >= mm) a %= mm;
n >>= 1;
}
return res;
}
int h11[q], h12[q], st1[q];
int ans[q];
long long hsub1(int r) {
long long res = h12[0];
if (r != n - 1) res -= h12[r + 1];
if (res < 0) res += hm;
res *= st1[n - 1 - r];
if (res >= hm) res = (res) % hm;
return res;
}
long long base = 151;
long long rb1 = binpow(base, hm - 2, hm);
int main() {
gets(s);
n = strlen(s);
long long p1 = base, p2 = base;
h11[0] = s[0];
for (int i = 1; i < n; ++i) {
h11[i] = (h11[i - 1] + s[i] * p1) % hm;
p1 = (p1 * base) % hm;
}
p1 = base;
h12[n - 1] = s[n - 1];
for (int i = n - 2; i >= 0; --i) {
h12[i] = (h12[i + 1] + s[i] * p1) % hm;
p1 = (p1 * base) % hm;
}
st1[0] = 1;
for (int i = 1; i < n; ++i) {
st1[i] = (st1[i - 1] * rb1) % hm;
}
long long k = 0;
for (int i = 0; i < n; ++i) {
if (hsub1(i) == h11[i]) {
if (i == 0)
ans[i] = 1;
else
ans[i] = ans[(i - 1) / 2] + 1;
} else
ans[i] = 0;
k += ans[i];
}
cout << k;
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
template <class T>
inline void read(T& x) {
int sign = 1;
char c = getchar();
x = 0;
while (c > '9' || c < '0') {
if (c == '-') sign = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= sign;
}
using namespace std;
const int maxn = 5e6 + 10;
unsigned long long ji = 1;
long long dp[maxn];
unsigned long long prehash[maxn], sufhash[maxn];
char s[maxn];
inline int val(char x) {
if (x >= '0' && x <= '9') return x - '0';
if (x >= 'a' && x <= 'z') return x - 'a' + 10;
if (x >= 'A' && x <= 'Z') return x - 'Z' + 36;
}
int main() {
scanf("%s", s + 1);
int len = 0;
for (int i = 1; s[i]; ++i) s[i] = val(s[i]);
for (int i = 1; s[i]; ++i) prehash[i] = prehash[i - 1] * 131 + 1ll * s[i];
for (int i = 1; s[i]; ++i) {
sufhash[i] = sufhash[i - 1] + 1ll * s[i] * ji;
ji *= 131;
}
long long res = 0;
for (int i = 1; s[i]; ++i) {
if (prehash[i] == sufhash[i]) {
dp[i] = dp[i >> 1] + 1;
}
res += dp[i];
}
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e6 + 100, Mod = 1e9 + 7, B = 599;
long long h[maxn], rh[maxn], P[maxn], ls, dp[maxn], ans;
string s;
long long g(long long l, long long r) {
return (h[r] - (h[l - 1] * P[r - l + 1]) + Mod * Mod) % Mod;
}
long long gr(long long l, long long r) {
return (rh[l] - (rh[r + 1] * P[r - l + 1]) + Mod * Mod) % Mod;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
ls = s.size();
P[0] = 1;
for (long long i = 1; i < maxn; i++) P[i] = (P[i - 1] * B) % Mod;
for (long long i = 1; i <= ls; i++) {
h[i] = (h[i - 1] * B + s[i - 1]) % Mod;
rh[ls - i + 1] = (rh[ls - i + 2] * B + s[ls - i]) % Mod;
}
dp[1] = 1;
for (long long i = 2; i <= ls; i++) {
if (i % 2 == 0 && g(1, i / 2 + i % 2) == gr(i / 2 + i % 2 + 1, i))
dp[i] = dp[i / 2] + 1;
else if (i % 2 && g(1, i / 2) == gr(i / 2 + 2, i))
dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
cout << ans + 1;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.