text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100005];
long long lf[100005];
long long countSegs(long long pk) {
long long res = 0;
map<long long, int> cnt;
for (int i = 0; i <= n; i++) {
cnt[lf[i]]++;
}
for (int i = 0; i < n; i++) {
cnt[lf[i]]--;
res += cnt[pk + lf[i]];
}
return res;
}
long long solve() {
lf[0] = 0;
for (int i = 1; i <= n; i++) {
lf[i] = lf[i - 1] + a[i];
}
long long res = 0;
long long pk = 1;
while (abs(pk) <= 1000000000000000) {
res += countSegs(pk);
pk *= k;
if (pk == 1) {
break;
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t kLimit = 1.0E15;
int64_t Abs(int64_t x) { return x < 0 ? -x : x; }
vector<int64_t> GenPowers(int64_t K) {
vector<int64_t> result;
if (K == 1) {
result.push_back(1);
} else if (K == -1) {
result.push_back(1);
result.push_back(-1);
} else {
int64_t pw = 1;
while (Abs(pw) < kLimit) {
result.push_back(pw);
pw *= K;
}
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, K;
cin >> N >> K;
vector<int> A(N);
for (int& a : A) {
cin >> a;
}
vector<int64_t> S(N);
S[0] = A[0];
for (int i = 1; i < N; ++i) {
S[i] = S[i - 1] + A[i];
}
auto powers = GenPowers(K);
map<int64_t, int> m;
for (auto s : S) {
++m[s];
}
int64_t result = 0;
for (int i = 0; i < N; ++i) {
int64_t extra = i == 0 ? 0 : S[i - 1];
for (auto p : powers) {
auto it = m.find(p + extra);
if (it != m.end()) {
result += it->second;
}
}
auto it = m.find(S[i]);
assert(it != m.end());
--it->second;
if (it->second == 0) {
m.erase(it);
}
}
cout << result << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[101000];
long long pre[101000];
map<long long, long long> Hash;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
Hash[0] = 1;
long long count = 0;
for (int i = 1; i <= n; i++) {
if (abs(k) > 1) {
for (long long p = 1; (p > 0 ? p : -p) <= 1e15; p *= k) {
if (Hash[pre[i] - p]) count += Hash[pre[i] - p];
}
} else {
if (k == 1 || k == -1) {
if (Hash[pre[i] - 1]) count += Hash[pre[i] - 1];
if (k == -1) {
if (Hash[pre[i] + 1]) count += Hash[pre[i] + 1];
}
} else {
if (Hash[pre[i]]) count += Hash[pre[i]];
}
}
Hash[pre[i]] += 1;
}
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> vec;
long long int arr[100009];
int main() {
long int n, k, i;
long long int lim, f;
arr[0] = 0;
cin >> n >> k;
for (i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
arr[i] += arr[i - 1];
}
if (k == 1)
vec.push_back(1);
else if (k == -1) {
vec.push_back(1);
vec.push_back(-1);
} else {
f = 1;
lim = 100000000000009;
while (f >= (lim * -1) && f <= lim) {
vec.push_back(f);
f *= k;
}
}
long long int cnt = 0;
vector<long long int>::iterator iter;
map<long long int, long long int> ma;
for (i = n; i >= 0; i--) {
for (iter = vec.begin(); iter != vec.end(); iter++) {
if (ma.find(arr[i] + *iter) != ma.end()) cnt += ma[arr[i] + *iter];
}
ma[arr[i]]++;
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[100013];
long long pr[100013];
long long su[100013];
long long sum = 0;
int main() {
cin >> n >> k;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
for (long long i = 1; i <= n; ++i) {
pr[i] = pr[i - 1] + a[i - 1];
}
for (long long i = n - 1; i >= 0; --i) {
su[i] = su[i + 1] + a[i];
}
long long out = 0;
if (k == 1) {
int kof = 1;
map<long long, long long> mp;
for (int i = 0; i <= n; ++i) {
++mp[su[i]];
}
for (int i = 0; i <= n; ++i) {
out += mp[sum - kof - pr[i]];
--mp[su[i]];
}
cout << out;
return 0;
}
if (k == -1) {
for (long long kof = 1, i = 0; i <= 1; kof *= k, ++i) {
map<long long, long long> mp;
for (int i = 0; i <= n; ++i) {
++mp[su[i]];
}
for (int i = 0; i <= n; ++i) {
out += mp[sum - kof - pr[i]];
--mp[su[i]];
}
}
cout << out;
return 0;
}
for (long long kof = 1; kof <= 10000000000000000; kof *= k) {
map<long long, long long> mp;
for (int i = 0; i <= n; ++i) {
++mp[su[i]];
}
for (int i = 0; i <= n; ++i) {
out += mp[sum - kof - pr[i]];
--mp[su[i]];
}
}
cout << out;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cum[(int)1e6], input[(int)1e6], k, ans;
char c;
int sz, t;
map<long long, vector<int>> pos;
int main() {
cin >> sz >> k;
for (int i = 0; i < sz; i++) {
scanf("%c%d", &c, &t);
input[i] = t;
if (i == 0) {
cum[0] = t;
} else {
cum[i] = cum[i - 1] + input[i];
}
pos[cum[i]].push_back(i);
}
for (long long target = 1; abs(target) <= 1e16; target *= k) {
for (int i = 0; i < sz; i++) {
if (i == 0) {
ans += pos[target].size();
} else {
ans += pos[target + cum[i - 1]].end() -
lower_bound(pos[target + cum[i - 1]].begin(),
pos[target + cum[i - 1]].end(), i);
}
}
if ((k == 1) || (k == -1 && target == k)) {
cout << ans << endl;
return 0;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const long long MAXN = 100010;
const long long MAXVAL = 1000000;
const long long INF = (long long)1e15 + 100;
const long long MOD = (long long)1e9 + 7;
string failMessage;
void fail() {
cout << failMessage;
exit(0);
}
void solve() {
long long n, k, x;
vector<long long> a = {1};
cin >> n >> k;
if (k == -1)
a.push_back(-1);
else if (k != 1) {
x = k;
while (abs(x) <= INF) {
a.push_back(x);
x *= k;
}
}
map<long long, long long> b;
long long sum = 0;
b[0] = 1;
long long ans = 0;
for (long long i = 0; i < n; i++) {
cin >> x;
sum += x;
for (auto e : a) ans += b[sum - e];
b[sum]++;
}
cout << ans;
}
int main() {
const string FILENAME = "111";
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> g;
long long n, k;
const long long MX = (1e16);
void init() {
long long value = 1;
for (long long i = 0, to = 60; i < to; i++) {
if (abs(value) <= MX)
g.push_back(value);
else
break;
value *= k;
}
}
map<long long, int> M;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
M[0]++;
if (k == 1) {
g.push_back(1LL);
} else if (k == -1) {
g.push_back(-1LL);
g.push_back(1LL);
} else {
init();
}
long long ans = 0;
long long num;
long long acum = 0;
for (long long i = 0, to = n; i < to; i++) {
cin >> num;
acum += num;
for (long long j = 0, to = (int)g.size(); j < to; j++) {
long long need = acum - g[j];
if (M.count(need)) ans += M[need];
}
M[acum]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)5e5 + 228;
const char nxtl = '\n';
const int mod = (int)1e9 + 7;
const double eps = (double)1e-7;
template <typename T>
inline bool updmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool updmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int k, n, a[MAXN];
vector<long long> v;
long long K = 1, cnt;
map<long long, long long> M;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
while (K <= (long long)1e15 && K >= -(long long)1e15) {
v.push_back(K);
K = K * 1ll * k;
if (K == 1) break;
}
long long sum = 0ll;
M[sum] = 1ll;
for (int i = 1; i <= n; ++i) {
sum += a[i];
for (auto &to : v) {
cnt += M[sum - to];
}
M[sum]++;
}
cout << cnt << nxtl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, mx = 1e15;
cin >> n >> k;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
map<long long int, long long int> make_pair;
long long int ansr = 0;
make_pair[0] = 1;
for (long long int i = 0; i < n; i++) {
if (i) a[i] += a[i - 1];
if (k == 1)
ansr += make_pair[a[i] - 1];
else if (k == -1) {
ansr += make_pair[a[i] - 1];
ansr += make_pair[a[i] + 1];
} else {
long long int m = 1;
while (m < mx) {
ansr += make_pair[a[i] - m];
m *= k;
}
}
make_pair[a[i]]++;
}
cout << ansr;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = 1000000000000000;
int main() {
long long n, k;
cin >> n >> k;
map<long long, long long> m;
long long sum = 0;
m[0]++;
long long res = 0;
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
sum += x;
long long l = 1;
while (abs(l) < inf) {
res += m[sum - l];
l *= k;
if (l == 1) break;
}
m[sum]++;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long k;
long long a[100005];
long long prefixsum[100005];
map<long long, vector<long long> > indexes;
set<long long> powers;
long long counter = 0;
long long diff;
int main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) {
prefixsum[i] = prefixsum[i - 1] + a[i];
}
indexes[0].push_back(0);
for (long long i = 1; i <= n; i++) {
indexes[prefixsum[i]].push_back(i);
}
for (long long i = 1; i <= 1e14; i = i * k) {
if (powers.count(i)) {
break;
}
powers.insert(i);
}
for (long long i : powers) {
for (long long j = 1; j <= n; j++) {
diff = prefixsum[j] - i;
long long result = -1;
long long left = 0;
long long right = indexes[diff].size() * 1ll - 1;
long long middle = (left + right) / 2;
while (left <= right) {
middle = (left + right) / 2;
if (indexes[diff][middle] < j) {
result = middle;
left = middle + 1;
} else {
right = middle - 1;
}
}
counter = counter + result + 1;
}
}
cout << counter << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
long long int a[maxn];
long long int pre[maxn];
map<long long int, long long int> mp[65];
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
long long int n, k;
cin >> n >> k;
long long int up = 0;
for (int i = 1; i <= n; i++) cin >> a[i], up += abs(a[i]);
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
long long int res = 0;
if (k == 1 or k == -1) {
mp[0][0]++;
for (int i = 1; i <= n; i++) {
if (mp[0].count(pre[i] - 1)) res += mp[0][pre[i] - 1];
mp[0][pre[i]]++;
}
mp[0].clear();
if (k == -1) {
mp[0][0]++;
for (int i = 1; i <= n; i++) {
if (mp[0].count(pre[i] + 1)) res += mp[0][pre[i] + 1];
mp[0][pre[i]]++;
}
}
cout << res << endl;
return 0;
}
for (long long int po = 1, ctr = 0; abs(po) <= up; po *= k, ctr++) {
mp[ctr][0]++;
for (int i = 1; i <= n; i++) {
long long int tmp = pre[i] - po;
if (mp[ctr].count(tmp)) res += mp[ctr][tmp];
mp[ctr][pre[i]]++;
}
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int static_init = []() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
return 0;
}();
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
constexpr int N = 1e5;
int n, k;
int64_t p[N + 1], ans;
unordered_set<int64_t> kp;
unordered_map<int64_t, int32_t, custom_hash> c;
int main() {
cin >> n >> k;
for (int i = 1, a; i <= n; i++) cin >> a, p[i] = p[i - 1] + a;
for (int64_t x = 1; x <= 1e14; x *= k) {
if (!kp.insert(x).second) break;
}
c.reserve(n);
for (int i = 0; i <= n; i++) {
for (auto x : kp) {
auto it = c.find(p[i] - x);
if (it != c.end()) ans += it->second;
}
c[p[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> S;
int main() {
int n, t, k;
long long s = 0, min = 0, max = 0;
scanf("%d%d", &n, &k);
S[0] = 1;
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &t);
s += t;
if (s < min) min = s;
if (s > max) max = s;
if (k == 1) {
ans += S[s - 1];
} else if (k == -1) {
ans += S[s + 1];
ans += S[s - 1];
} else if (k > 0) {
for (long long K = 1; s - K >= min; K *= k) {
ans += S[s - K];
}
} else {
for (long long K = 1; s - K >= min; K *= 1ll * k * k) {
ans += S[s - K];
}
for (long long K = k; s - K <= max; K *= 1ll * k * k) {
ans += S[s - K];
}
}
S[s]++;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const long long int Inf = 1LL << 62;
long long int sum[Max];
long long int ar[Max];
map<long long int, long long int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
sum[i] = sum[i - 1] + ar[i];
}
long long int cur = 1;
set<long long int> st;
st.insert(1);
for (int i = 0;; i++) {
cur *= k;
if (cur > 1e15 || cur < -1e15) {
break;
}
st.insert(cur);
if (st.size() <= 2 && i > 2) {
break;
}
}
for (int i = 1; i <= n; i++) {
long long int cur = sum[i];
for (long long int x : st) {
ans += mp[cur - x];
if (cur == x) ans++;
}
mp[sum[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 111;
long long n, k;
long long a[maxn], b[maxn];
long long p[maxn];
map<long long, long long> cnt;
long long poww[500];
long long sum[maxn];
long long ans;
vector<long long> v;
multiset<long long> q;
int main() {
cin >> n;
cin >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int i = n; i >= 1; i--) {
p[i] = p[i + 1] + a[i];
cnt[p[i]]++;
}
if (k == -1) {
v.push_back(1);
v.push_back(-1);
} else if (k == 1)
v.push_back(1);
else {
v.push_back(1);
for (int i = 1; v[v.size() - 1] * k <= 1e16; i++) {
v.push_back(v[v.size() - 1] * k);
}
}
cnt[0]++;
for (int i = 0; i <= n; i++) {
cnt[p[i + 1]]--;
for (int j = 0; j < v.size(); j++) ans += cnt[sum[n] - (v[j] + sum[i])];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 3e6;
const long long mod = 1e9 + 7;
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n;
int a[maxn];
long long k, ans, p = 1;
long long solve() {
long long sum = 0, res = 0;
map<long long, int> mp;
mp.clear();
mp[0] = 1;
for (int i = 1; i <= n; i++) {
sum += a[i];
if (mp.count(sum - p)) res += mp[sum - p];
mp[sum]++;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
while (abs(p) < 1e15) {
ans += solve();
p = p * k;
if (p == 1) break;
}
cout << ans;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
long long n, k, a[MAXN], s[MAXN], sol, maxE;
map<long long, long long> m;
set<long long> mk;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
m[0] = 1;
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1] + a[i];
long long p = 1;
mk.clear();
while (p < 1e16) {
if (mk.find(p) != mk.end()) break;
sol += m[s[i] - p];
mk.insert(p);
p *= k;
}
m[s[i]]++;
}
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const double eps = 1e-8;
const int iinf = INT_MAX;
const long long linf = 1e14;
const double dinf = 1e30;
const int MOD = 1000000007;
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void print(int x) {
cout << x << '\n';
exit(0);
}
void PRINT(string x) {
cout << x << '\n';
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
int n;
long long k, ans;
long long sum[N];
set<long long> a;
map<long long, long long> x;
signed main() {
scanf("%d%lld", &n, &k);
sum[0] = 0;
for (int i = 1; i <= n; i++) scanf("%lld", &sum[i]), sum[i] += sum[i - 1];
a.insert(1);
long long tmp = k;
for (int i = 1; i <= 60; i++) {
if (tmp > linf) break;
a.insert(tmp);
tmp *= k;
}
long long ans = 0;
x[0] = 1;
for (int i = 1; i <= n; i++) {
for (set<long long>::iterator it = a.begin(); it != a.end(); it++)
ans += x[sum[i] - *it];
x[sum[i]]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const long long inf = 1e14;
long long a[maxn], sum[maxn];
map<long long, long long> map1;
set<long long> s;
int main(void) {
cin.tie(0);
std::ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
s.insert(1);
long long tmp = k;
for (long long i = 1; i <= 60; i++) {
if (tmp > inf) break;
s.insert(tmp);
tmp *= k;
}
long long ans = 0;
map1[0] = 1;
for (long long i = 1; i <= n; i++) {
for (set<long long>::iterator it = s.begin(); it != s.end(); it++) {
ans += map1[sum[i] - *it];
}
map1[sum[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long big = 1000000000000000;
long long ans = 0;
int main() {
long long n, k;
cin >> n >> k;
long long Array[n];
for (long long i = 0; i < n; i++) cin >> Array[i];
map<long long, long long> mapi;
mapi[0] = 1;
long long s = 0;
for (int i = 0; i < n; i++) {
s += Array[i];
if (k == 1)
ans += mapi[s - 1];
else if (k == -1)
ans += (mapi[s - 1] + mapi[s + 1]);
else {
long long t = 1;
while (t) {
ans += mapi[s - t];
t *= k;
if (abs(t) >= big) break;
}
}
mapi[s]++;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void optimise() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long int mod = 998244353;
void normalize(long long int &a) { a = (a + mod) % mod; }
long long int modmul(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a * b) % mod;
}
long long int modadd(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a + b) % mod;
}
long long int modsub(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a - b + mod) % mod;
}
long long int me(long long int x, long long int n) {
x %= mod;
if (n == 0) return 1;
long long int u = me(x, n / 2) % mod;
u = (u * u) % mod;
if (n % 2) u = (u * x) % mod;
return u;
}
long long int me1(long long int x, long long int n) {
if (n == 0) return 1;
long long int u = me1(x, n / 2);
u = u * u;
if (n % 2) u = u * x;
return u;
}
inline long long int modInv(long long int a) { return me(a, mod - 2); }
inline long long int modDiv(long long int a, long long int b) {
return modmul(a, modInv(b));
}
long long int __gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return __gcd(b, a % b);
}
long long int inf = 1e15 + 1;
void solve() {
long long int n, k;
cin >> n >> k;
long long int min1 = -inf;
long long int max1 = inf;
vector<long long int> v1;
long long int pro = 1;
long long int i = 0;
while (pro > min1 && pro < max1 && abs(k) != 1) {
v1.push_back(pro);
i++;
pro = (me1(k, i));
}
if (k == 1)
v1.push_back(1);
else if (k == -1) {
v1.push_back(1);
v1.push_back(-1);
}
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int ans1 = 0;
for (long long int i = 0; i < v1.size(); i++) {
map<long long int, long long int> m;
long long int ans = 0;
long long int sum = 0;
for (long long int j = 0; j < n; j++) {
sum += a[j];
if (sum == v1[i]) ans++;
if (m.find(sum - v1[i]) != m.end()) ans += m[sum - v1[i]];
m[sum]++;
}
ans1 += ans;
}
cout << ans1;
}
signed main() {
optimise();
long long int t;
t = 1;
cout << fixed << setprecision(10);
while (t--) {
solve();
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const long long inf = 1e14;
long long a[maxn], sum[maxn];
map<long long, long long> map1;
set<long long> s;
int main(void) {
cin.tie(0);
std::ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
s.insert(1);
long long tmp = k;
for (long long i = 1; i <= 60; i++) {
if (tmp > inf) break;
s.insert(tmp);
tmp *= k;
}
long long ans = 0;
map1[0] = 1;
for (long long i = 1; i <= n; i++) {
map1[sum[i]]++;
for (set<long long>::iterator it = s.begin(); it != s.end(); it++) {
ans += map1[sum[i] - *it];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int n_ = 1e5 + 10;
int n, k;
long long arr[n_];
long long poww(long long a, long long e) {
long long res = 1ll;
while (e > 0) {
if ((e & ((long long)1)) == 1) res *= a;
a *= a;
e >>= (long long)1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
cin >> arr[0];
for (int i = 1; i < n; i++) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
vector<long long> powers;
if (k == 1 || k == -1) {
powers.push_back(1);
if (k == -1) powers.push_back(-1);
} else {
for (int exp = 0;; exp++) {
long long res = poww((long long)k, (long long)exp);
if (abs(res) <= 1e14)
powers.push_back(res);
else
break;
}
}
long long res = 0;
map<long long, long long> cnt;
for (int i = 0; i < n; i++) {
long long curSum = arr[i];
for (int j = 0; j < (int)powers.size(); j++) {
long long needed = curSum - powers[j];
if (needed == 0) res++;
res += cnt[needed];
}
cnt[arr[i]]++;
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
typedef std::function<long long(long long)> fun;
class Map {
int n, w, r;
std::vector<int> A, B;
std::function<int(long long)> lower, upper;
std::vector<long long> who;
std::vector<int> val;
void find_array(std::vector<int> &a, const std::vector<long long> &S, fun f,
fun g) {
a.resize(1 << r);
std::vector<std::list<long long> > set(1 << r);
std::vector<int> m(1 << (r + 1));
std::vector<int> ind;
for (long long x : S) {
if (set[f(x)].empty()) ind.push_back(f(x));
set[f(x)].push_back(x);
}
std::sort(ind.begin(), ind.end(),
[&](int x, int y) { return set[x].size() > set[y].size(); });
for (int i : ind) {
a[i] = 0;
for (int j = 0; j < r; ++j) {
int ex0 = 0, ex1 = 0;
for (long long y : set[i])
ex0 += m[(1 << (j + 1)) + ((y & ((1 << (j + 1)) - 1)) ^ a[i])],
ex1 += m[(1 << (j + 1)) +
((y & ((1 << (j + 1)) - 1)) ^ (a[i] | (1 << j)))];
if (ex1 < ex0) a[i] |= (1 << j);
}
for (long long y : set[i]) {
int v = (g(y) ^ a[i]);
for (int j = 0; j < r; ++j)
m[(1 << (r - j)) + v]++, v = v & ((1 << (r - 1 - j)) - 1);
}
}
}
public:
Map() {}
Map(const std::vector<long long> &S, int word) { init(S, word); }
int operator()(long long x) { return lower(x) ^ B[upper(x) ^ A[lower(x)]]; }
int size() { return (1 << r); }
bool have(long long x) { return who[(*this)(x)] == x; }
int &operator[](long long i) { return val[(*this)(i)]; }
void init(const std::vector<long long> &S, int word) {
n = (int)S.size();
w = word;
r = std::max(w / 2, (int)std::log2(n) + 3) + 1;
assert(*std::min_element(S.begin(), S.end()) >= 0);
assert(*std::max_element(S.begin(), S.end()) < (1ll << word));
lower = [&](long long x) { return x & ((1 << r) - 1); };
upper = [&](long long x) { return x >> (w - r); };
find_array(A, S, lower, upper);
auto f2 = [&](long long x) { return upper(x) ^ A[lower(x)]; };
auto &g2 = lower;
find_array(B, S, f2, g2);
who.resize(1 << r, -1);
for (long long x : S) who[(*this)(x)] = x;
val.resize(1 << r);
}
};
void make_unique(std::vector<long long> &A) {
std::sort(A.begin(), A.end());
A.resize(std::unique(A.begin(), A.end()) - A.begin());
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, k;
std::cin >> n >> k;
std::vector<int> A(n);
long long pref = 0;
std::vector<long long> values;
values.push_back(pref);
for (int i = 0; i < n; ++i) {
std::cin >> A[i];
pref += A[i];
values.push_back(pref);
}
make_unique(values);
long long min = *std::min_element(values.begin(), values.end());
std::vector<long long> lower, upper;
for (long long x : values)
lower.push_back((x - min) & ((1 << 24) - 1)),
upper.push_back((x - min) >> 24);
make_unique(lower);
make_unique(upper);
Map ml(lower, 24);
Map mu(upper, 24);
std::vector<long long> vals;
auto kto = [&](long long x) {
if (!ml.have((x - min) & ((1 << 24) - 1)) || !mu.have((x - min) >> 24))
return -1ll;
return ml((x - min) & ((1 << 24) - 1)) +
1ll * ml.size() * mu((x - min) >> 24);
};
for (long long x : values) vals.push_back(kto(x));
make_unique(vals);
Map map(vals, 40);
long long ans = 0;
pref = 0;
map[kto(pref)]++;
for (int i = 0; i < n; ++i) {
pref += A[i];
long long pow = 1;
while (std::abs(pow) < 1000000000ll * 100000ll + 5ll) {
long long want = (pref - pow);
if (want >= min && want <= min + (1ll << 48)) {
if (kto(want) != -1 && map.have(kto(want))) {
ans += map[kto(want)];
}
}
pow *= k;
if (pow == 1) break;
}
map[kto(pref)]++;
}
std::cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
template <class T>
inline bool read(T &n) {
T x = 0, tmp = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if (c == EOF) return false;
if (c == '-') c = getchar(), tmp = -1;
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
n = x * tmp;
return true;
}
template <class T>
inline void write(T n) {
if (n < 0) {
putchar('-');
n = -n;
}
int len = 0, data[20];
while (n) {
data[len++] = n % 10;
n /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
}
const int MAXN = 100010;
long long pre[MAXN], a[MAXN], mi[100];
map<long long, long long> dp;
int cnt = 0, n, k;
int main() {
read(n), read(k);
for (int i = 1; i <= n; i++) read(a[i]);
if (k == 1) {
mi[0] = 1;
dp[mi[0]]++;
} else if (k == -1) {
mi[0] = 1;
mi[1] = -1;
cnt = 1;
dp[mi[0]]++;
dp[mi[1]]++;
} else {
long long t = 1;
mi[cnt] = 1;
dp[mi[cnt]]++;
while (abs(t * k) < 1e15) {
cnt++;
t *= k;
mi[cnt] = t;
dp[mi[cnt]]++;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
ans += dp[pre[i]];
for (int j = 0; j <= cnt; j++) dp[pre[i] + mi[j]]++;
}
write(ans), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int lim = 1e17;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T = clock();
long long int n, k;
cin >> n >> k;
map<long long int, long long int> mpp;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int tot = 0;
mpp[0] = 1;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
tot += a[i];
long long int r = 1;
if (k == -1) {
ans += mpp[tot - 1];
ans += mpp[tot + 1];
} else if (k == 1)
ans += mpp[tot - 1];
else {
while (r < lim) {
if (mpp.find(tot - r) != mpp.end()) ans += mpp[tot - r];
r *= k;
}
}
mpp[tot]++;
}
cout << ans;
cerr << "\n\nTIME: " << (double)(clock() - T) / CLOCKS_PER_SEC << " sec\n";
T = clock();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
const int md = 1e9 + 7;
const int MAX = 1e6;
const double ep = 1.19209e-07;
long long int n, k;
long long int ans;
vector<long long int> v;
map<long long int, long long int> fr;
long long int mx;
int main() {
scanf("%lld%lld", &n, &k);
v.resize(n);
for (int i = 0; i < n; i++)
scanf("%lld", &v[i]), v[i] += i ? v[i - 1] : 0, mx = max(mx, v[i]);
if (k == 1 || k == -1) {
for (int i = 0; i < n; i++) {
ans += fr[v[i] - 1] + (v[i] == 1);
if (k == -1) {
ans += v[i] == -1;
if (!v[i])
ans += fr[1];
else if (v[i] > 0)
ans += fr[v[i] + 1];
else
ans += fr[-(abs(v[i]) - 1)];
}
fr[v[i]]++;
}
} else {
for (int i = 0; i < n; i++) {
long long int have = 1;
while (have <= 1e15) {
ans += fr[v[i] - have] + (v[i] == have);
have *= 1LL * k;
}
fr[v[i]]++;
}
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
using pii = pair<int, int>;
vector<INT> vec;
int main() {
int n, k;
scanf("%d %d", &n, &k);
if (k == 1)
vec = {1};
else if (k == -1)
vec = {1, -1};
else {
for (INT u = 1; abs(u) < 1e15; u *= k) {
vec.push_back(u);
}
}
INT ans = 0;
map<INT, int> dp;
dp[0] = 1;
for (INT s = 0; n--;) {
int u;
scanf("%d", &u), s += u;
for (INT first : vec)
if (dp.find(s - first) != dp.end()) {
ans += dp[s - first];
}
dp[s]++;
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000LL;
const int MAXN = 100005;
int n, k;
long long a[MAXN];
map<long long, long long> cnt;
int main(void) {
scanf("%d%d", &n, &k);
for (int i = (1); i < (n + 1); ++i) scanf("%lld", a + i);
for (int i = (0); i < (n); ++i) a[i + 1] += a[i];
vector<long long> powers;
if (k == 1) {
powers.push_back(1);
} else if (k == -1) {
powers.push_back(1);
powers.push_back(-1);
} else {
long long x = 1;
while (abs(x) < 1e17) {
powers.push_back(x);
x *= k;
}
}
long long sol = 0;
for (int i = (0); i < (n + 1); ++i) {
for (long long p : powers) {
sol += cnt[a[i] - p];
}
++cnt[a[i]];
}
printf("%lld\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
#pragma warning(disable : 4018)
void b_example() {
int affection[100000 + 1];
map<long long, int> exist_sum;
int chemicals_count, k;
cin >> chemicals_count >> k;
for (int i = 1; i <= chemicals_count; i++) cin >> affection[i];
long long ans_count = 0;
for (long long p = 1; abs(p) < 1e15;) {
exist_sum.clear();
exist_sum[0] = 1;
long long sum = 0;
for (int i = 1; i <= chemicals_count; i++) {
sum += affection[i];
ans_count += exist_sum[sum - p];
exist_sum[sum]++;
}
p *= k;
if (p == 1) break;
}
cout << ans_count << endl;
}
int main() {
b_example();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100003];
map<long long, long long> v;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
if (k == 1 || k == -1) {
v[0] = 1;
long long pre = 0, ans = 0;
for (int i = 1; i <= n; i++) {
pre = pre + a[i];
if (k == 1)
ans += v[pre - 1];
else
ans += v[pre - 1] + v[pre + 1];
v[pre]++;
}
cout << ans << '\n';
return 0;
}
v[0] = 1;
long long m = 1000000000000000;
long long pre = 0, ans = 0;
for (int i = 1; i <= n; i++) {
long long w = 1;
pre += a[i];
while (abs(w) < m) {
ans += v[pre - w];
w = w * k;
}
v[pre]++;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
void open() { freopen("in.txt", "r", stdin); }
int main() {
int n;
cin >> n;
long long k;
cin >> k;
long long ans = 0;
long long v;
long long s = 0;
map<long long, int> sk;
sk[0]++;
long long p;
for (int j = 0; j < n; j++) {
cin >> v;
s += v;
p = 1;
do {
ans += sk[s - p];
p *= k;
} while (p <= (1e14) && p != 1);
sk[s]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, n, m, k, cnt = 0, ans = 0, t = 1;
cin >> n >> k;
map<long long, long long> mm;
long long a[n], pr[n];
for (i = 0; i < n; i++) cin >> a[i];
pr[0] = a[0];
for (i = 1; i < n + 1; i++) pr[i] = a[i] + pr[i - 1];
vector<long long> v;
if (k == 1)
v.push_back(1);
else if (k == -1)
v.push_back(-1), v.push_back(1);
else {
j = k;
v.push_back(1);
while (j <= 1e14) v.push_back(j), j *= k;
}
for (i = 0; i < n; i++) {
for (auto it : v) {
if (it == pr[i]) ans++;
if (mm.find(pr[i] - it) != mm.end()) ans += mm[pr[i] - it];
}
mm[pr[i]]++;
}
return cout << ans, 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { cin >> x; }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <typename T, typename... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <typename T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
template <typename T>
void _W(const vector<T> &x) {
for (auto i = x.cbegin(); i != x.cend(); i++) {
if (i != x.cbegin()) putchar(' ');
_W(*i);
}
}
void W() {}
template <typename T, typename... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T>
inline void maz(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void miz(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
const int N = 100005;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
int n, m, k, q;
int A[N];
char s[N], t[N];
long long sum[N];
map<long long, int> M;
int main() {
R(n, k);
for (int i = 1; i <= n; i++) R(A[i]);
for (int i = 1; i <= n; i++) sum[i] = A[i] + sum[i - 1];
long long ans = 0;
M[0] = 1;
if (k == 1) {
for (int i = 1; i <= n; i++) {
ans += M[sum[i] - 1];
++M[sum[i]];
}
} else if (k == -1) {
for (int i = 1; i <= n; i++) {
ans += M[sum[i] - 1] + M[sum[i] + 1];
++M[sum[i]];
}
} else {
long long cur = 1;
const long long MX = 100000000000000LL;
while (cur <= MX && cur >= -MX) {
M.clear();
M[0] = 1;
for (int i = 1; i <= n; i++) {
ans += M[sum[i] - cur];
++M[sum[i]];
}
cur *= k;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 1; i < n; i++) {
a[i] += a[i - 1];
}
vector<long long> v;
v.push_back(1);
long long x = k;
while (abs(x) <= 1e14) {
if (x == 1) break;
v.push_back(x);
x *= k;
if (x == 1 || x == -1) break;
}
long long ans = 0;
map<long long, long long> mp;
for (long long i = 0; i < v.size(); i++) {
long long temp = v[i];
mp.clear();
for (long long j = 0; j < n; j++) {
if (a[j] == temp) ans++;
if (mp.find(a[j] - temp) != mp.end()) ans += mp[a[j] - temp];
mp[a[j]]++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[100100], sum[100100];
vector<long long> powers;
map<long long, vector<int> > m;
void gp(long long k) {
if (k == 1) {
powers.push_back(1);
return;
} else if (k == -1) {
powers.push_back(-1);
powers.push_back(1);
return;
}
long long g = 14 / log10(abs(k)) + 2;
powers.push_back(1);
for (int i = 1; i <= g; i++) powers.push_back(powers[i - 1] * k);
}
int main() {
long long n, k;
cin >> n >> k;
gp(k);
for (int i = 1; i <= n; i++) {
cin >> v[i];
sum[i] = sum[i - 1] + v[i];
m[sum[i]].push_back(i);
}
long long ans = 0;
for (int i = 0; i < (int)powers.size(); i++) {
for (int j = 0; j < n; j++) {
long long g = sum[n - j] - powers[i];
auto x = m[g];
auto aux = upper_bound(x.begin(), x.end(), n - j);
if (g == 0) ans++;
if (aux == x.end())
ans += x.size();
else
ans += (aux - x.begin());
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n, k;
long long a[MAXN];
long long tar;
map<long long, pair<int, int> > mp;
int id = 0;
long long ans = 0;
void solve() {
++id;
for (int i = 0; i <= n; i++) {
if (mp[a[i] - tar].second == id) ans += mp[a[i] - tar].first;
if (mp[a[i]].second != id) {
mp[a[i]] = pair<int, int>(1, id);
} else
mp[a[i]].first++;
}
}
int main() {
cin >> n >> k;
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> tar;
a[i] = a[i - 1] + tar;
}
if (abs(k) != 1)
for (tar = 1; abs(tar) <= 1e14; tar *= k) solve();
else {
tar = 1;
solve();
if (k == -1) {
tar = -1;
solve();
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
vector<vector<int> > array2_int(int N, int M, int def = 0) {
return vector<vector<int> >(N, vector<int>(M, def));
}
vector<vector<vector<int> > > array3_int(int N, int M, int K, int def = 0) {
return vector<vector<vector<int> > >(
N, vector<vector<int> >(M, vector<int>(K, def)));
}
vector<vector<long long> > array2_ll(int N, int M, long long def = 0) {
return vector<vector<long long> >(N, vector<long long>(M, def));
}
vector<vector<vector<long long> > > array3_ll(int N, int M, int K,
long long def = 0) {
return vector<vector<vector<long long> > >(
N, vector<vector<long long> >(M, vector<long long>(K, def)));
}
template <class T>
void printImpl(const vector<T>& coll) {
copy(coll.begin(), coll.end(), ostream_iterator<T>(cout, " "));
cout << endl;
}
template <class T, int N>
void printImpl(T (&coll)[N]) {
copy(coll, coll + N, ostream_iterator<T>(cout, " "));
cout << endl;
}
template <class Key, class Value>
void printImpl(const map<Key, Value>& data) {
typename map<Key, Value>::const_iterator it;
for (it = data.begin(); it != data.end(); ++it) {
cout << it->first << ":" << it->second << endl;
}
}
template <class T>
void printImpl(const T& data) {
cout << data << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, K;
cin >> N >> K;
vector<long long> a(N);
for (int i = 0; i < (N); ++i) {
cin >> a[i];
}
vector<long long> kp;
if (K == 1) {
kp.push_back(1);
} else if (K == -1) {
kp.push_back(-1);
kp.push_back(1);
} else {
long long curr = 1;
while (abs(curr) <= 10000000LL * 10000000LL) {
kp.push_back(curr);
curr *= K;
}
}
map<long long, int> counter;
counter[0] = 1;
long long currSum = 0;
long long res = 0;
for (int s = 0; s < N; ++s) {
currSum += a[s];
for (auto d : kp) {
long long need = currSum - d;
auto it = counter.find(need);
if (it != counter.end()) {
res += it->second;
}
}
counter[currSum]++;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void scale(int x) {
cout.precision(x);
cout << fixed;
}
long long lpow(long long x, int y) {
if (!y) return 1;
long long t = lpow(x, y / 2);
if (y & 1) return (y > 0) ? x * t * t : (t * t) / x;
return t * t;
}
int ipow(int x, int y) {
if (!y) return 1;
int t = ipow(x, y / 2);
if (y & 1) return (y > 0) ? x * t * t : (t * t) / x;
return t * t;
}
void toBin(int a, int len) {
vector<int> v;
while (a) {
v.emplace_back(a & 1), a >>= 1;
}
while ((int)v.size() < len) v.emplace_back(0);
reverse(v.begin(), v.end());
for (auto p : v) cout << p;
cout << endl;
}
void split(vector<string> &tmp, string &line) {
stringstream ss(line);
string s;
tmp.clear();
while (ss >> s) tmp.emplace_back(s);
}
inline void fastio(int debug) {
if (debug) {
cout << "DEBUGGING MODE..." << endl;
freopen("in", "r", stdin);
} else {
ios_base::sync_with_stdio(false), cin.tie(0);
cout.tie(0);
}
}
bool DRAFT = 1;
int a[100005], n, k, ec;
long long ans, pw[55], pref;
map<long long, long long> M;
int main(void) {
fastio(0);
cin >> n >> k;
for (int i = 1; i < n + 1; i++) cin >> a[i];
if (k != 1 && k != -1) {
long long lim = 1e14;
for (long long i = 1; abs(i) <= lim; i *= k) {
pw[ec++] = i;
}
} else {
pw[ec++] = 1;
if (k == -1) pw[ec++] = -1;
}
for (int j = 0; j < n; j++) {
M[pref]++;
pref += a[j + 1];
for (int i = 0; i < ec; i++) {
if (M.count(pref - pw[i]) > 0) ans += M[pref - pw[i]];
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int const MaxSize = 1e5 + 1;
long long k, prefixSum[MaxSize];
map<long long, int> nPSV;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
long long ans = 0;
nPSV[0] = 1;
vector<long long> powers;
powers.push_back(1);
if (1 == k) {
} else if (-1 == k) {
powers.push_back(-1);
} else {
long long power = k;
while (abs(power) <= 1e14) {
powers.push_back(power);
power *= k;
}
}
for (int i = int(1); i <= int(n); i++) {
long long ai;
cin >> ai;
prefixSum[i] = prefixSum[i - 1] + ai;
for (int pi = int(0); pi < int(powers.size()); pi++) {
long long power = powers[pi];
long long target = prefixSum[i] - power;
if (nPSV.count(target)) {
ans += nPSV[target];
}
}
nPSV[prefixSum[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, lim = 1e18, a[100004] = {0};
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
long long int g = 1, c = 0;
while (g < lim) {
long long int pile = 0;
map<long long int, int> m;
for (i = 0; i < n; i++) {
pile += a[i];
if (pile == g) c++;
c += m[pile - g];
m[pile]++;
}
g *= k;
if (g == 1) break;
}
cout << c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 112345;
const long long MAXP = 1.e15;
int n;
long long k;
long long a[MAXN];
long long p[MAXN];
int np;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
p[0] = 1ll;
if (k == 1ll) {
np = 1;
} else if (k == -1ll) {
p[1] = -1ll;
np = 2;
} else {
do {
np++;
p[np] = p[np - 1] * k;
} while (llabs(p[np]) <= MAXP);
}
map<long long, long long> count;
long long sum = 0;
count[sum]++;
long long ans = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
count[sum]++;
for (int j = 0; j < np; j++) {
auto it = count.find(sum - p[j]);
if (it != count.end()) ans += it->second;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> cnt;
int main() {
int n, k;
long long ps = 0;
cin >> n >> k;
long long ans = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
cnt[ps]++;
ps += t;
long long x = 1;
while (abs(x) <= 1e14) {
ans += cnt[ps - x];
x *= k;
if (x == 1) {
break;
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> cnt;
int n;
long long k;
int mas[100005];
void pre() {}
void load() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> mas[i];
}
int get(long long v) {
auto it = cnt.find(v);
if (it == cnt.end()) return 0;
return it->second;
}
void solve() {
const long long MX = 1e15;
long long sum = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
cnt[-sum]++;
sum += mas[i];
long long v = 1;
set<long long> was;
for (int j = 0; abs(v) <= MX && j < 64; j++) {
if (was.count(v)) break;
was.insert(v);
ans += get(v - sum);
v *= k;
}
}
cout << ans << endl;
}
void clear() {}
int main() {
double st = clock();
pre();
load();
solve();
clear();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
vector<long long> s;
if (abs(k) == 1) {
if (k == -1) s.push_back(-1);
s.push_back(1);
} else {
long long a = 1;
while (abs(a) <= 100000000000000) {
s.push_back(a);
a *= k;
}
}
sort(s.begin(), s.end());
vector<long long> p(n + 1, 0);
p[1] = v[0];
for (long long i = 2; i <= n; i++) {
p[i] = p[i - 1] + v[i - 1];
}
long long c = 0;
map<long long, long long> m;
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j < s.size(); j++) {
if (m.find(p[i] - s[j]) != m.end()) c += m[p[i] - s[j]];
}
m[p[i]]++;
}
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e14;
long long ab(long long x) { return x > 0 ? x : -x; }
long long a[100005];
long long kn[66];
long long sum[100005];
map<long long, int> mp;
int nxt[100005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
kn[0] = 1;
int cnt = 0;
for (int i = 1;; i++) {
kn[i] = kn[i - 1] * k;
if (kn[i] == 1) break;
cnt++;
if (ab(kn[i]) >= oo) break;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= cnt; j++) {
mp[sum[n] - sum[i] - kn[j]]++;
}
}
long long ans = 0, step = 0;
for (int i = n; i >= 1; i--) {
ans += mp[step];
for (int j = 0; j <= cnt; j++) {
mp[sum[n] - sum[i - 1] - kn[j]]--;
}
step += a[i];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 300005;
long long N, M, k;
long long pref[MX], arr[MX];
long long INF = 1e15;
long long pw[200];
int n;
long long poow(long long x, long long p) {
if (p == 0) return 1;
if (p == 1) return x;
long long ans = poow(x, p / 2);
ans *= ans;
if (p % 2) ans *= x;
return ans;
}
long long Ra(int l, int r) {
if (l == 0) return pref[r];
return pref[r] - pref[l - 1];
}
map<long long, long long> mp;
int main() {
cin >> N >> k;
long long s = 0, mx = 0;
for (int i = 0; i < N; i++) {
cin >> arr[i];
s += arr[i];
mx = max(mx, s);
if (i) pref[i] = pref[i - 1];
pref[i] += arr[i];
}
if (k == 1)
pw[n++] = 1;
else if (k == -1)
pw[n++] = -1, pw[n++] = 1;
else
for (int i = 0; i < 50; i++) {
long long a = powl(k, i);
pw[i] = a;
n++;
}
long long seg = 0, cur = 0;
for (int i = 0; i < n; i++) {
mp.clear();
cur = 0;
for (int j = 0; j < N; j++) {
long long S = Ra(0, j);
if (S == pw[i]) cur++;
cur += mp[S - pw[i]];
mp[S]++;
}
seg += cur;
}
cout << seg << "\n";
return 0;
}
|
#include <bits/stdc++.h>
struct Hash {
long long key;
int cnt;
Hash *next;
void set(long long k) {
key = k;
cnt = 1;
next = NULL;
}
};
Hash *hashtale[100007];
void create() {
for (int i = 0; i < 100007; i++) hashtale[i] = NULL;
}
int search(long long k) {
int l = (k % 100007 + 100007) % 100007;
Hash *tmp = hashtale[l];
if (tmp == NULL) return 0;
while (tmp != NULL && tmp->key != k) tmp = tmp->next;
if (tmp == NULL)
return 0;
else
return tmp->cnt;
}
void insert(long long k) {
int l = (k % 100007 + 100007) % 100007;
Hash *tmp = hashtale[l];
if (search(k) == 0) {
Hash *node = new Hash;
node->set(k);
if (tmp == NULL)
hashtale[l] = node;
else {
while (tmp->next != NULL) tmp = tmp->next;
tmp->next = node;
}
} else {
while (tmp->key != k) tmp = tmp->next;
tmp->cnt++;
}
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
create();
long long sum = 0;
int tmp;
long long ans = 0;
insert(0);
for (int i = 0; i < n; i++) {
scanf("%d", &tmp);
sum += tmp;
insert(sum);
if (k == 1)
ans += search(sum - 1);
else if (k == -1)
ans += search(sum - 1) + search(sum + 1);
else {
for (long long p = 1; p <= 2e14; p *= k) ans += search(sum - p);
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char B[1 << 26], *S = B, C;
int X, F;
inline int read() {
for (F = 1; (C = *S++) < '0' || C > '9';)
if (C == '-') F = -1;
for (X = C - '0'; (C = *S++) >= '0' && C <= '9';)
X = (X << 3) + (X << 1) + C - '0';
return X * F;
}
map<long long, int> mp;
long long p[50];
int pn;
int main() {
fread(B, 1, 1 << 26, stdin);
int n, k, i, j;
long long x, ans = 0;
n = read();
k = read();
for (x = 1; x >= -100000000000000LL && x <= 100000000000000LL && !mp[x];
x *= k)
p[++pn] = x, mp[x] = 1;
mp.clear();
for (i = x = 0; i < n; ++i) {
++mp[x];
x += read();
for (j = 1; j <= pn; ++j) ans += mp[x - p[j]];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); }
} _;
long long n, k, s, ans;
vector<long long> pw;
map<long long, long long> freq;
int main() {
cin >> n >> k;
if (abs(k) != 1) {
pw.push_back(1);
while (pw.back() < 1e17) pw.push_back(pw.back() * k);
}
freq[0] = 1;
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
s += a;
freq[s]++;
if (k == 1) {
if (freq.find(s - 1) != freq.end()) ans += freq[s - 1];
} else if (k == -1) {
if (freq.find(s - 1) != freq.end()) ans += freq[s - 1];
if (freq.find(s + 1) != freq.end()) ans += freq[s + 1];
} else {
for (int x = 0; abs(s - pw[x]) <= 1e15; x++) {
if (freq.find(s - pw[x]) != freq.end()) ans += freq[s - pw[x]];
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf = 300000000000010LL;
const int mxn = 200010, p = 101021;
int n, k, a[mxn];
ll s[mxn], v[mxn];
int h[p + 2], nx[mxn], cnt[mxn], t = 0;
void ins(ll x) {
int y = (x % p + p) % p, i;
for (i = h[y]; i != -1; i = nx[i])
if (v[i] == x) {
cnt[i]++;
return;
}
nx[++t] = h[y];
h[y] = t;
v[t] = x;
cnt[t] = 1;
}
int find(ll x) {
int y = (x % p + p) % p, i;
for (i = h[y]; i != -1; i = nx[i])
if (v[i] == x) {
return cnt[i];
}
return 0;
}
int main() {
int i;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s[i] = s[i - 1] + a[i];
}
ll ans = 0, x;
for (i = 0; i <= p; i++) h[i] = -1;
for (i = 1; i <= n; i++) {
ins(s[i - 1]);
if (k == 0)
ans += find(s[i]);
else if (k == 1)
ans += find(s[i] - 1);
else if (k == -1)
ans += find(s[i] - 1) + find(s[i] + 1);
else {
for (x = 1; abs(x) <= inf; x *= k) {
ans += find(s[i] - x);
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = (int)1e5 + 7;
const int MOD = (int)1e9 + 7;
int n, k;
long long num = 1, pref, ans;
vector<long long> v;
map<long long, int> kek;
int main() {
cin >> n >> k;
if (k == -1) v.push_back(-1);
v.push_back(1);
if (abs(k) > 1) {
while (abs(num) < 1e14) {
num *= k;
v.push_back(num);
}
}
kek[0] = 1;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
pref += x;
for (long long j : v) {
long long need = (j - pref) * -1;
ans += kek[need];
}
kek[pref]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 9;
const long long inf = 1e14;
long long n, k;
int main() {
long long a, b, c, d, e, f, g, h;
ios::sync_with_stdio(0);
cin >> n >> k;
vector<long long> vec;
if (abs(k) == 1) {
vec.push_back(1);
if (k < 0) vec.push_back(-1);
} else {
vec.push_back(1);
a = k;
while (abs(a) <= inf) {
vec.push_back(a);
a *= k;
}
}
g = 0;
long long ans = 0;
map<long long, long long> ma;
while (n--) {
cin >> e;
g += e;
for (int i = 0; i < vec.size(); i++) {
if (vec[i] == g) {
ans++;
break;
}
}
for (int i = 0; i < vec.size(); i++) {
e = g - vec[i];
if (ma.find(e) != ma.end()) {
ans += ma[e];
}
}
ma[g]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res *= a;
a *= a;
b >>= 1;
}
return res;
}
map<long long, int> mp;
long long sum[100001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
sum[i + 1] = sum[i] + a;
}
mp[0] = 1;
long long cnt = 0;
long long m = 0;
for (int i = 1; i <= n; i++) {
long long temp = power(k, 0);
int j = 0;
while (abs(temp) <= m + abs(sum[i])) {
cnt += mp[sum[i] - temp];
temp = power(k, ++j);
if (k == 1 && j == 1) break;
if (k == -1 && j == 2) break;
}
mp[sum[i]]++;
m = max(m, abs(sum[i]));
}
cout << cnt << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
map<long long, long long> mp;
long long n, k, v[maxn], s[maxn], mi[maxn], ct, res;
int main() {
scanf("%I64d%I64d", &n, &k);
if (k == 0) {
ct = 0, mi[0] = 1;
} else if (k == -1) {
ct = 1, mi[0] = 1, mi[1] = k;
} else {
mi[0] = 1;
for (int i = 1; i <= 63; i++) {
mi[i] = mi[i - 1] * k;
if (abs(mi[i]) > 1e15) {
ct = i;
break;
}
}
}
for (int i = 1; i <= n; i++) scanf("%I64d", &v[i]);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + v[i];
mp[0] += 1;
for (int i = 1; i <= n; i++) {
mp[s[i]] += 1;
for (int j = 0; j <= ct; j++) {
long long t = s[i] - mi[j];
res += mp[t];
}
}
printf("%I64d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
int main() {
int64 n, k;
map<int64, int64> m;
m[0] = 1;
int64 sum = 0;
int64 minpf = 0, maxpf = 0;
;
int64 res = 0;
cin >> n >> k;
for (int64 i = 0; i < n; ++i) {
int64 x;
cin >> x;
sum += x;
int64 t = 1;
if (k == 1) {
res += m[sum - 1];
} else if (k == -1) {
res += m[sum - 1] + m[sum + 1];
} else {
while (abs(t) <= max(abs(sum - minpf), abs(sum - maxpf))) {
res += m[sum - t];
t *= k;
}
}
m[sum] += 1;
minpf = min(minpf, sum);
maxpf = max(maxpf, sum);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
out << "[";
for (auto vi : v) out << vi << ", ";
out << "]";
return out;
}
int DX[] = {0, +1, 0, -1, 0};
int DY[] = {+1, 0, -1, 0, 0};
int readInt() {
int temp;
scanf("%d", &temp);
return temp;
}
vector<int> a;
map<long long, int> m;
int n, k;
void solve() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (n); ++i) {
int temp;
scanf("%d", &temp);
a.push_back(temp);
}
set<long long> kk;
for (long long p = 1; - 1e15 < p && p < 1e15; p *= k) {
if (kk.count(p) == 0)
kk.insert(p);
else
break;
}
long long sum = 0;
long long result = 0;
for (int i = 0; i < n; i++) {
m[sum]++;
sum += a[i];
for (auto p : kk) {
if (m.find(sum - p) != m.end()) {
result += m[sum - p];
}
}
}
cout << result;
}
void readData() {}
int main() {
ios::sync_with_stdio(false);
readData();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n, k, ans, sum[N];
set<long long> a;
map<long long, long long> x;
signed main() {
scanf("%d%lld", &n, &k);
sum[0] = 0;
for (long long i = 1; i <= n; i++)
scanf("%lld", &sum[i]), sum[i] += sum[i - 1];
a.insert(1);
long long tmp = k;
for (long long i = 1; i <= 60; i++) {
if (tmp > 1e14) break;
a.insert(tmp);
tmp *= k;
}
long long ans = 0;
x[0] = 1;
for (long long i = 1; i <= n; i++) {
for (set<long long>::iterator it = a.begin(); it != a.end(); it++)
ans += x[sum[i] - *it];
x[sum[i]]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
long long int n, k;
cin >> n >> k;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
;
long long int ans = 0;
long long int p = 1;
long long int cnt = 0;
while (p <= 1e14) {
map<long long int, long long int> h;
long long int c = 0;
cnt++;
h[c]++;
for (long long int i = 0; i < n; i++) {
c += a[i];
h[c]++;
ans += h[c - p];
}
p *= k;
if (k == 1 and cnt == 1) {
break;
}
if (k == -1 and cnt == 2) {
break;
}
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long> pot;
long long a[100100], acum[100100], ans, k;
map<long long, long long> occ;
int main() {
scanf("%d %lld", &n, &k);
long long mult = 1;
if (k == 1)
pot.push_back(mult);
else if (k == -1) {
pot.push_back(1);
pot.push_back(-1);
} else {
while (mult <= 100000000000000000LL) {
pot.push_back(mult);
mult *= k;
}
}
occ[0] = 1;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
acum[i] = a[i];
if (i) acum[i] += acum[i - 1];
for (int p = 0; p < pot.size(); p++) {
ans += occ[acum[i] - pot[p]];
}
occ[acum[i]]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int a[100002];
long long solve(int st, int ed) {
map<long long, long long> mp;
long long ans = 0;
if (st == ed) {
if (k == 1)
ans += (a[st] == 1);
else if (k == -1)
ans += (a[st] == 1) + (a[st] == -1);
else {
for (long long val = 1; abs(val) <= 1e15; val *= k) ans += a[st] == val;
}
return ans;
}
int mid = (st + ed) / 2;
ans += solve(st, mid);
ans += solve(mid + 1, ed);
long long su = 0;
for (int i = mid; i >= st; i--) {
su += a[i];
if (mp.find(su) == mp.end())
mp[su] = 1;
else
mp[su]++;
}
su = 0;
for (int i = mid + 1; i <= ed; i++) {
su += a[i];
if (k == 1) {
if (mp.find(1 - su) != mp.end()) ans += mp[1 - su];
} else if (k == -1) {
if (mp.find(1 - su) != mp.end()) ans += mp[1 - su];
if (mp.find(-1 - su) != mp.end()) ans += mp[-1 - su];
} else {
for (long long val = 1; abs(val) <= 1e15; val *= k) {
if (mp.find(val - su) != mp.end()) ans += mp[val - su];
}
}
}
return ans;
}
int main() {
scanf("%lld %lld", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
printf("%lld\n", solve(1, n));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int N = 1e5 + 10;
long long sum[N];
int main() {
int n;
long long k;
scanf("%d%lld", &n, &k);
sum[0] = 0;
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
sum[i] = sum[i - 1] + x;
}
set<long long> A = {1};
A.insert(k);
if (abs(k) > 1) {
long long prod = k;
while (true) {
A.insert(prod);
prod *= k;
if (abs(prod) > 1e14) break;
}
}
long long ret = 0;
for (auto& it : A) {
map<long long, int> B;
for (int i = 0; i <= n; ++i) {
ret += B[sum[i] - it];
B[sum[i]]++;
}
}
printf("%lld\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const double eps = (1e-7);
int dcmp(long double x, long double y) {
if (abs(x - y) < eps) return 0;
if (x > y) return 1;
return -1;
}
vector<int> a;
long long count(long long sum) {
map<long long, int> freq;
freq[0] = 1;
long long ret = 0, x = 0;
for (int i = 0; i < (int)(a).size(); ++i) {
x += a[i];
auto it = freq.find(x - sum);
if (it != freq.end()) ret += it->second;
freq[x]++;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
long long ans = 0;
if (k == 1)
ans = count(1);
else if (k == -1)
ans = count(1) + count(-1);
else {
long long p = 1;
while (abs(p) <= 1e15) {
ans += count(p);
p *= k;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
long long a[MAXN];
long long sum[MAXN];
map<long long, int> m;
int n, k;
long long mul(int x, int y) {
long long tmp = 1;
for (int i = 1; i <= y; i++) {
tmp *= x;
}
return tmp;
}
long long solve() {
memset(sum, 0, sizeof(sum));
sum[0] = 0;
long long cnt = 0;
long long tmp = k;
long long num;
if (tmp < 0) tmp = -tmp;
for (int i = 0; i <= n; i++) {
if (i > 0) sum[i] = sum[i - 1] + a[i];
cnt += m[sum[i]];
if (k == 1)
m[1 + sum[i]]++;
else if (k == -1)
m[1 + sum[i]]++, m[-1 + sum[i]]++;
else
for (int j = 0; j <= 60; j++) {
num = mul(k, j);
if (num > 1e15 || num < -1e15) break;
m[num + sum[i]]++;
}
}
return cnt;
}
int main() {
while (scanf("%d %d", &n, &k) != EOF) {
m.clear();
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
printf("%I64d\n", solve());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
vector<long long> s(n + 1);
for (int i = 0; i < n; i++) cin >> a[i];
s[0] = 0;
for (int i = 0; i < n; i++) s[i + 1] = s[i] + a[i];
map<long long, int> f;
f[0]++;
long long ans = 0;
long long mins = 0;
long long maxs = 0;
for (int i = 0; i < n; i++) {
if (k == 1) {
ans += f[s[i + 1] - 1];
f[s[i + 1]]++;
continue;
} else if (k == -1) {
ans += f[s[i + 1] - 1];
ans += f[s[i + 1] + 1];
f[s[i + 1]]++;
continue;
}
for (long long p = 1;
abs(p) <= max(abs(s[i + 1] - mins), abs(s[i + 1] - maxs)); p *= k) {
ans += f[s[i + 1] - p];
}
mins = min(mins, s[i + 1]);
maxs = max(maxs, s[i + 1]);
f[s[i + 1]]++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e14 + 9;
vector<long long> hash_valuen(5000009, 0);
vector<long long> hash_valuer(5000009, 0);
long long ans[5000009];
long long inv[5000009];
const long long p = 317;
const long long m = 104000717;
long long gcd(long long a, long long tri) {
long long x = 1, y = 0, ini = tri;
if (tri == 1) return 0;
while (a > 1) {
long long q = a / tri;
long long t = tri;
tri = a % tri;
a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += ini;
return x;
}
void init() {
inv[0] = gcd(p, m);
for (int i = 1; i < 5000009; i++) {
inv[i] = (inv[i - 1] * inv[0]) % m;
}
}
void compute_hash(vector<long long>& hash_value, string const& s) {
hash_value[0] = 0;
long long p_pow = 1;
int cont = 1;
for (char c : s) {
hash_value[cont] = (hash_value[cont - 1] + (c - '$' + 1) * p_pow) % m;
p_pow = (p_pow * p) % m;
cont++;
}
}
void compute_hash2(vector<long long>& hash_value2, string const& s) {
hash_value2[0] = 0;
long long p_pow = 1;
int cont = 1;
for (char c : s) {
hash_value2[cont] = (hash_value2[cont - 1] + (c - '$' + 1) * p_pow) % m;
p_pow = (p_pow * p) % m;
cont++;
}
}
long long querie(long long l, long long r) {
long long result = 0;
result = (((hash_valuen[r] - hash_valuen[l - 1] + m) % m) * inv[l]) % m;
return result;
}
long long querie2(long long l, long long r) {
long long result = 0;
result = (((hash_valuer[r] - hash_valuer[l - 1] + m) % m) * inv[l]) % m;
return result;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
long long anstotal = 0;
init();
compute_hash(hash_valuen, s);
reverse(begin(s), end(s));
compute_hash2(hash_valuer, s);
ans[1] = 1;
long long n = (long long)(s).size();
for (long long i = 2; i < ((long long)(s).size() + 1); ++i) {
if (querie(1, i) == querie2(n - i + 1, n)) ans[i] = ans[i / 2] + 1;
}
for (long long i = 1; i < ((long long)(s).size() + 1); ++i)
anstotal += ans[i];
cout << anstotal << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long N = 5e6 + 3;
long long dp[N];
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
string str;
unsigned long long temp = 1, p = 0, q = 0;
cin >> str;
long long ans = 0;
long long pppp = str.size();
for (int i = 0; i < str.size(); i++) {
p = (p * 131 + str[i]) % mod;
q = (temp * (str[i]) + q) % mod;
;
temp *= 131;
temp %= mod;
if (p == q) {
if (i == 0)
dp[i]++, ans += dp[i];
else {
dp[i] = dp[(i - 1) / 2] + 1;
ans += dp[i];
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 5110000;
;
unsigned long long H1[maxn], H2[maxn], xp[maxn], ha, hb, x = 123;
int dp[maxn], len;
char buf[maxn], rbuf[maxn];
void init() {
int i;
len = strlen(buf);
H1[len] = H2[len] = 0;
xp[0] = 1;
for (i = len - 1; i >= 0; i--) {
H1[i] = H1[i + 1] * x + buf[i];
H2[i] = H2[i + 1] * x + rbuf[i];
xp[len - i] = xp[len - i - 1] * x;
}
}
unsigned long long getHash(unsigned long long *HS, int s, int L) {
return HS[s] - HS[s + L] * xp[L];
}
int main() {
int i, ans;
while (~scanf("%s", buf)) {
ans = 0, len = strlen(buf);
for (i = 0; i < len; i++) rbuf[i] = buf[len - i - 1];
init();
ans = dp[0] = 1;
for (i = 1; i < len; i++) {
ha = getHash(H1, 0, i + 1);
hb = getHash(H2, len - i - 1, i + 1);
if (ha == hb) {
if (i & 1)
dp[i] = dp[i / 2] + 1;
else
dp[i] = dp[i / 2 - 1] + 1;
} else
dp[i] = 0;
ans += dp[i];
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 5;
int dp[maxn];
int Len[maxn * 2];
char s[maxn];
char d[maxn * 2];
void init() {
int slen = strlen(s);
int j = 0;
d[j++] = '$';
d[j++] = '#';
for (int i = 0; i < slen; ++i) {
d[j++] = s[i];
d[j++] = '#';
}
}
void manacher() {
int dlen = strlen(d);
int p = 0, p0 = 0;
for (int i = 1; i < dlen; ++i) {
if (p > i)
Len[i] = min(p - i, Len[2 * p0 - i]);
else
Len[i] = 1;
while (d[i + Len[i]] == d[i - Len[i]]) ++Len[i];
if (i + Len[i] > p) {
p = i + Len[i];
p0 = i;
}
}
}
void solve() {
init();
manacher();
int slen = strlen(s);
int ans = 1;
dp[1] = 1;
for (int i = 2; i < slen + 1; ++i) {
if (Len[i + 1] >= i + 1) {
dp[i] = dp[i >> 1] + 1;
}
ans += dp[i];
}
printf("%d\n", ans);
}
int main() {
scanf("%s", s);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[5000005];
unsigned long long hsh1[5000005], hsh2[5000005], P[5000005];
int n, ans, dep[5000005];
unsigned long long hash1(int x, int y) {
return hsh1[y] - hsh1[x - 1] * P[y - x + 1];
}
unsigned long long hash2(int x, int y) {
return hsh2[x] - hsh2[y + 1] * P[y - x + 1];
}
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
P[0] = 1;
for (int i = 1; i <= n; i++) {
hsh1[i] = hsh1[i - 1] * 137 + a[i];
P[i] = P[i - 1] * 137;
}
for (int i = n; i; i--) hsh2[i] = hsh2[i + 1] * 137 + a[i];
ans = dep[1] = 1;
for (int i = 2; i <= n; i++) {
int len = i / 2;
dep[i] = (hash1(1, len) == hash2(i - len + 1, i)) ? dep[len] + 1 : 0;
ans += dep[i];
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 100, base = 4321;
long long ans, dp[N], a[N], b[N], power[N];
string s;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
power[0] = 1;
for (int i = 1; i < N; i++) power[i] = power[i - 1] * base;
cin >> s;
a[0] = b[0] = s[0];
ans = dp[0] = 1;
for (int i = 1; i < s.length(); i++) {
a[i] = a[i - 1] * base + s[i];
b[i] = b[i - 1] + s[i] * power[i];
if (a[i] == b[i]) dp[i] = dp[(i - 1) / 2] + 1;
ans += dp[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 1e6 + 10;
char st[maxn];
char s[maxn << 1];
int p[maxn << 1];
int ans[maxn];
void init(int le) {
for (int i = le - 1; i >= 0; --i) {
s[2 * i + 2] = st[i];
s[2 * i + 3] = '*';
}
s[0] = '$';
s[1] = '*';
}
void manacher(int le) {
int mx = 0, id = 0;
for (int i = 1; i < 2 * le + 2; ++i) {
p[i] = mx > i ? min(p[id * 2 - i], mx - i) : 1;
while (s[i + p[i]] == s[i - p[i]]) p[i]++;
if (i + p[i] > mx) {
mx = i + p[i];
id = i;
}
}
}
int main() {
long long res = 0;
scanf("%s", st);
int le = strlen(st);
init(le);
manacher(le);
int u = 2;
for (int i = 0; i < le; ++i) {
if (p[i + 2] != i + 2) {
ans[i] = 0;
} else {
ans[i] = ans[(i - 1) / 2] + 1;
ans[i] = max(ans[i], 1);
}
res += ans[i];
}
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long c) {
long long x = 1, y = a;
while (b > 0) {
if (b & 1) x = (x * y) % c;
y = (y * y) % c;
b /= 2;
}
return x % c;
}
int dx[] = {0, -1, 0, 1};
int dy[] = {-1, 0, 1, 0};
int dr[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dc[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int N = 5e6 + 5;
char s[N];
long long BASE[2] = {100000009, 100000007}, MOD[2] = {1000000007, 1000000009};
long long B[N][1], IB[N][1], H[N][1], RH[N][1];
void init() {
for (int k = 0; k < 1; ++k) {
long long b = BASE[k], m = MOD[k];
B[0][k] = 1;
for (int i = 1; i <= N - 1; ++i) {
B[i][k] = (B[i - 1][k] * b) % m;
}
IB[N - 1][k] = power(B[N - 1][k], m - 2, m);
for (int i = N - 2; i >= 0; --i) {
IB[i][k] = (IB[i + 1][k] * b) % m;
}
}
}
void build(char *s) {
int len = strlen(s);
for (int k = 0; k < 1; ++k) {
long long b = BASE[k], m = MOD[k];
H[0][k] = RH[len + 1][k] = 0;
for (int i = 0, j = 1; s[i]; ++i, ++j) {
H[j][k] = (H[j - 1][k] + (s[i] * B[i][k]) % m) % m;
}
for (int i = len - 1, j = len, l = 0; i >= 0; --i, --j, ++l) {
RH[j][k] = (RH[j + 1][k] + (s[i] * B[l][k]) % m) % m;
}
}
}
long long forHash(int i, int j, int len) {
i++, j++;
long long sub[2];
for (int k = 0; k < 1; ++k) {
long long b = BASE[k], m = MOD[k];
sub[k] = ((H[j][k] + m - H[i - 1][k]) * IB[i - 1][k]) % m;
}
return (sub[0] << 32);
}
long long revHash(int i, int j, int len) {
i++, j++;
long long sub[2];
for (int k = 0; k < 1; ++k) {
long long b = BASE[k], m = MOD[k];
sub[k] = ((RH[i][k] + m - RH[j + 1][k]) * IB[len - j][k]) % m;
}
return (sub[0] << 32);
}
long long DP[N];
int main() {
init();
scanf("%s", s);
int len = strlen(s);
build(s);
DP[1] = 1;
long long ans = 1;
for (int i = 2; i <= len; ++i) {
long long ff = forHash(0, i - 1, len), rr = revHash(0, i - 1, len);
if (ff == rr) {
long long mid = (1 + i) / 2;
if (i & 1) {
DP[i] = DP[mid - 1] + 1;
} else {
DP[i] = DP[mid] + 1;
}
}
ans += DP[i];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[10000005];
char s[10000005];
int main() {
gets(s + 1);
int n = strlen(s + 1);
s[n + 1] = '#';
for (int i = 1; i <= n; ++i) {
s[n + i + 1] = s[n - i + 1];
}
n = 2 * n + 1;
for (int i = 2; i <= n; ++i) {
p[i] = p[i - 1];
while (p[i] && s[p[i] + 1] != s[i]) p[i] = p[p[i]];
if (s[p[i] + 1] == s[i]) ++p[i];
}
memset(s, 0, sizeof(s));
int c = p[n];
while (c > 0) {
s[c] = 1;
c = p[c];
}
n /= 2;
long long res = 0;
for (int i = 1; i <= n; ++i) {
if (!s[i])
p[i] = 0;
else
p[i] = p[i / 2] + 1;
res += p[i];
}
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e7 + 10;
int len, rad[MAXN];
char buf[MAXN], s[MAXN];
void Gao() {
s[0] = '$';
for (int i = 0; i < (len); i++) {
s[(i << 1) + 1] = '#';
s[(i << 1) + 2] = buf[i];
}
s[(len << 1) + 1] = '#';
s[(len << 1) + 2] = 0;
int n = (len << 1) + 1;
for (int i = 1, mx = 0, id; i <= n; ++i) {
if (mx > i)
rad[i] = min(rad[id + id - i], mx - i);
else
rad[i] = 1;
while (s[i + rad[i]] == s[i - rad[i]]) ++rad[i];
if (i + rad[i] > mx) {
mx = i + rad[i];
id = i;
}
}
for (int i = 1; i <= n; ++i) --rad[i];
}
int f[MAXN];
int main() {
while (~scanf("%s", buf)) {
len = strlen(buf);
Gao();
int ans = 0;
for (int i = 1; i <= len; ++i) {
f[i] = (rad[i + 1] >= i ? f[i >> 1] + 1 : 0);
ans += f[i];
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int maxn = 5000010;
int f[maxn], lcp[maxn], nxt[maxn];
char op[maxn], s[maxn];
int res(0), n;
void prep() {
for (int i = 0; i < n; i++) s[i] = op[n - i - 1];
s[n] = '\0';
nxt[1] = n;
int a = 0, p = 0;
for (int i = 2; i <= n; i++) {
int l = nxt[i - a + 1];
l = min(l, p - i + 1);
if (l < 0) l = 0;
while (i + l <= n && op[i + l - 1] == op[l]) l++;
nxt[i] = l;
if (i + l > p) {
p = i + l - 1;
a = i;
}
}
a = p = 0;
for (int i = 1; i <= n; i++) {
int l = nxt[i - a + 1];
l = min(l, p - i + 1);
if (l < 0) l = 0;
while (i + l <= n && op[l] == s[i + l - 1]) l++;
lcp[i] = l;
if (i + l > p) {
p = i + l - 1;
a = i;
}
}
}
int main() {
gets(op);
n = strlen(op);
while (op[n - 1] == ' ') n--;
prep();
for (int i = 1; i <= n; i++)
if (lcp[n - i + 1] >= i / 2) {
f[i] = f[i / 2] + 1;
res += f[i];
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e6 + 10;
int p[MAXN << 1];
char str[MAXN], s[MAXN << 1];
int dp[MAXN];
int L(int i) {
if (!i) return 1;
if (dp[i] != -1) return dp[i];
int ans_ = p[i + 2] / 2;
if (ans_ - 1 != i / 2) return dp[i] = 0;
return dp[i] = L((i + 1) / 2 - 1) + 1;
}
int main() {
while (~scanf("%s", str)) {
int n = 1;
int len = strlen(str);
for (int i = 0; str[i]; i++) {
s[n++] = '#';
s[n++] = str[i];
}
s[0] = '?', s[n++] = '#', s[n] = '#';
int id, right = 0;
for (int i = 1; i < n; i++) {
if (right > i)
p[i] = min(right - i, p[2 * id - i]);
else
p[i] = 1;
while (s[i + p[i]] == s[i - p[i]]) p[i]++;
if (p[i] + i > right) {
right = p[i] + i;
id = i;
}
}
memset(dp, -1, sizeof dp);
long long ans = 0LL;
for (int i = len - 1; i >= 0; i--) ans += L(i);
printf("%lld\n", ans);
}
return 0;
}
|
#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;
int dp[5000100];
string s;
long long prime = 3;
int main() {
ios::sync_with_stdio(0);
cin.tie();
cin >> s;
long long l = 0, r = 0, p = 1, ans = 0;
for (int i = 1; i <= s.size(); i++) {
l = l * prime + s[i - 1];
r = r + p * s[i - 1];
p *= prime;
if (l == r) dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long m = 257;
const unsigned long long N = 10000000;
string s;
unsigned long long hash_l = 0, hash_r = 0, e = 1, i, deg[N], sum = 0;
int main() {
memset(deg, 0, sizeof(deg));
cin >> s;
for (i = 0; i < s.length(); i++) {
hash_l = hash_l * m + s[i];
hash_r = s[i] * e + hash_r;
e *= m;
sum += (hash_l == hash_r ? (deg[i + 1] = deg[(i + 1) / 2] + 1) : 0);
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5100000;
char s[MAXN << 1];
int p[MAXN << 1];
int rk[MAXN];
int main() {
while (~scanf("%s", s)) {
int n = strlen(s);
s[2 * n + 2] = '\0';
for (int i = n - 1; i >= 0; i--) {
s[2 * i + 2] = s[i];
s[2 * i + 3] = '*';
}
s[0] = '$';
s[1] = '*';
memset(p, 0, sizeof(p));
int maxn = 0, maxi = 0;
long long ans = 0LL;
for (int i = 1; i < 2 * n + 2; i++) {
p[i] = maxn > i ? min(p[2 * maxi - i], maxn - i) : 1;
while (s[i + p[i]] == s[i - p[i]]) p[i]++;
if (maxn < i + p[i]) {
maxn = i + p[i];
maxi = i;
}
}
memset(rk, 0, sizeof(rk));
for (int i = 0; i < n; i++) {
if (p[i + 2] != i + 2) {
rk[i] = 0;
} else {
rk[i] = rk[(i - 1) / 2] + 1;
rk[i] = max(rk[i], 1);
}
ans += rk[i];
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 5e6;
char s[maxn + 10];
int a[maxn + 10];
void work() {
scanf("%s", s + 1);
int len = strlen(s + 1);
long long now1 = 0, now2 = 0, now = 1;
long long ans = 0;
for (int i = 1; i <= len; i++) {
now1 = (now1 * 31 + s[i] - 'a') % mod;
now2 = (now2 + now * (s[i] - 'a')) % mod;
if (now1 == now2) {
a[i] = a[i / 2] + 1;
ans += a[i];
} else
a[i] = 0;
now = now * 31 % mod;
}
printf("%lld\n", ans);
return;
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6000006;
unsigned long long hs = 3797;
unsigned long long F[N];
int madeF = 0;
void makeF() {
F[0] = 1;
for (int i = 1; i < N; i++) F[i] = F[i - 1] * hs;
madeF = 1;
}
vector<unsigned long long> stringhash(string s) {
if (madeF == 0) makeF();
s = '#' + s;
vector<unsigned long long> H(s.size());
H[0] = 0;
for (int i = 1; i < H.size(); i++) H[i] = H[i - 1] * hs + s[i];
return H;
}
unsigned long long subhash(vector<unsigned long long>& H, int x, int y) {
if (y < x) swap(x, y);
return H[y] - F[y - x + 1] * H[x - 1];
}
long long ans[6000006];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
string s;
cin >> s;
vector<unsigned long long> v = stringhash(s);
reverse(s.begin(), s.end());
vector<unsigned long long> vrev = stringhash(s);
ans[1] = 1;
long long sum = 1;
long long sz;
long long hf;
long long n = vrev.size();
for (int i = 2; i < v.size(); i++) {
sz = i;
hf = sz / 2;
if (sz % 2 == 0) {
if (subhash(v, 1, hf) == subhash(vrev, n - (hf + 1), n - i)) {
ans[i] = ans[hf] + 1;
sum += ans[i];
}
} else {
if (subhash(v, 1, hf) == subhash(vrev, n - (hf + 2), n - i)) {
ans[i] = ans[hf] + 1;
sum += ans[i];
}
}
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 5e6 + 10;
char str[N];
int deg[N];
int main() {
long long p = 0;
long long q = 0;
long long m = 1239;
long long a = 1;
scanf("%s", str + 1);
int ans = 0;
for (int i = 1; str[i]; i++) {
p = (p * m + str[i]);
q = (q + str[i] * a);
a = a * m;
if (p == q) {
deg[i] = deg[i >> 1] + 1;
ans += deg[i];
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int n = 6000000, x = 103;
char str[n];
int ans[n];
int main() {
int i = 0, l = 0, r = 0, t = 1, an = 0;
for (gets(str); str[i]; i++) {
l = l * x + str[i];
r += str[i] * t;
t *= x;
ans[i + 1] = (l == r) ? ans[(i + 1) / 2] + 1 : 0;
an += ans[i + 1];
}
printf("%d\n", an);
}
|
#include <bits/stdc++.h>
using namespace std;
long long p = 2127001057;
const int mod = 1e9 + 7;
const int max_n = 5000010;
int a[max_n], b[max_n], dp[max_n];
int main() {
ios_base::sync_with_stdio(false);
string str;
cin >> str;
long long x = 1;
for (int i = 1; i <= str.length(); i++)
a[i] = (a[i - 1] + x * str[i - 1]) % mod, x = (x * p) % mod;
for (int i = 1; i <= str.length(); i++)
b[i] = (b[i - 1] * p + str[i - 1]) % mod;
int ans = 0;
for (int i = 1; i <= str.length(); i++)
if (b[i] == a[i]) dp[i] = dp[i / 2] + 1, ans += dp[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline void normal(long long int &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long int modMul(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long int modAdd(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long int modSub(long long int a, long long int b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long int modInverse(long long int a) {
return modPow(a, 1000000007 - 2);
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modInverse(b));
}
inline bool isInside(pair<int, int> p, long long int n, long long int m) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < m);
}
inline bool isInside(pair<int, int> p, long long int n) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < n);
}
inline bool isSquare(long long int x) {
long long int s = sqrt(x);
return (s * s == x);
}
inline bool isFib(long long int x) {
return isSquare(5 * x * x + 4) || isSquare(5 * x * x - 4);
}
inline bool isPowerOfTwo(long long int x) {
return ((1LL << (long long int)log2(x)) == x);
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
clock_t tStart = clock();
void faltu() { cerr << endl; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
struct func {
bool operator()(pair<int, int> const &a, pair<int, int> const &b) {
if (a.first == b.first) return (a.second < b.second);
return (a.first < b.first);
}
};
const int maxn = 1e7 + 5;
int dp[maxn];
long long p1 = 131, t1 = 1;
long long p2 = 127, t2 = 1;
long long h1 = 0, rh1 = 0;
long long h2 = 0, rh2 = 0;
int main() {
ios_base::sync_with_stdio(false);
;
string s;
cin >> s;
s = '#' + s;
long long ans = 0;
int l = s.size();
for (int i = 1; i <= l; i++) {
h1 = h1 * p1 + s[i];
rh1 = s[i] * t1 + rh1;
t1 = t1 * p1;
h2 = h2 * p2 + s[i];
rh2 = s[i] * t2 + rh2;
t2 = t2 * p2;
if (h1 == rh1 && h2 == rh2) dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma gcc optimize("O2")
#pragma gcc optimize("unroll-loops")
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 5e6 + 10;
int n;
string s;
int z[N], dp[N];
int pref[N], suf[N], suf2[N];
void make_pref_suf() {
int l = 0;
for (int r = 1; r < n; r++) {
while (l != 0 && s[l] != s[r]) l = pref[l - 1];
if (s[l] == s[r]) l++;
pref[r] = l;
}
l = 0;
for (int r = n - 1; r >= 0; r--) {
while (l != 0 && s[l] != s[r]) l = pref[l - 1];
if (s[l] == s[r]) l++;
while (l != 0 && l > r) l = pref[l - 1];
suf[r] = l;
suf2[r] = pref[l - 1];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.length();
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (r >= i) {
z[i] = min(r - i + 1, z[i - l]);
}
while (z[i] + i < n && s[z[i]] == s[z[i] + i]) z[i]++;
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
make_pref_suf();
dp[0] = 1;
for (int i = 1; i < n; i++) {
if (dp[i - 1]) {
if (z[i] >= i) dp[i * 2 - 1] = dp[i - 1] + 1;
if (i + 1 < n && z[i + 1] >= i) dp[i * 2] = dp[i - 1] + 1;
} else {
if (suf[i] == i) dp[i * 2 - 1] = 1;
if (i + 1 < n && suf[i + 1] == i || suf2[i + 1] == i) dp[i * 2] = 1;
}
}
ll ans = 0;
for (int i = 0; i < n; i++) ans += (ll)dp[i];
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 10, M = 101, mod = 1e9 + 7;
long long m[N], p[N], s[N], dp[N];
string a;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
m[0] = 1;
for (int i = 1; i < N; i++) m[i] = m[i - 1] * M % mod;
cin >> a;
int n = a.size();
s[n - 1] = a[n - 1];
for (int i = n - 2; 0 <= i; i--) s[i] = (s[i + 1] * M % mod + a[i]) % mod;
p[0] = a[0];
for (int i = 1; i < n; i++) p[i] = (p[i - 1] * M % mod + a[i]) % mod;
dp[0] = 1;
for (int i = 1; i < n; i++) {
long long res = s[(i + 2) / 2];
res -= s[i + 1] * m[(i + 1) / 2] % mod;
res %= mod;
res += mod;
res %= mod;
if (p[(i - 1) / 2] == res) dp[i] = 1 + dp[(i - 1) / 2];
}
int ans = 0;
for (int i = 0; i < n; i++) ans += dp[i];
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e6 + 10;
const int INF = 0x3f3f3f3f;
char str[maxn];
int dp[maxn];
unsigned long long f1[maxn], f2[maxn];
int main() {
scanf("%s", str + 1);
int l = strlen(str + 1);
unsigned long long ans = 1;
long long sum = 0;
dp[0] = 0;
for (int i = 1; i <= l; i++) {
if (str[i] >= '0' && str[i] <= '9') {
str[i] = str[i] - '0';
} else if (str[i] >= 'a' && str[i] <= 'z') {
str[i] = str[i] - 'a' + 10;
} else {
str[i] = str[i] - 'A' + 36;
}
f1[i] = f1[i - 1] * 131 + str[i];
f2[i] = (f2[i - 1] + str[i] * ans);
ans *= 131;
if (f1[i] == f2[i]) {
dp[i] = dp[i >> 1] + 1;
sum += dp[i];
}
}
printf("%lld\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int n = 6000000, x = 103;
char str[n];
int arr[n];
int main() {
int i = 0, l = 0, r = 0, t = 1, ans = 0;
for (gets(str); str[i]; i++) {
l = l * x + str[i];
r = r + str[i] * t;
t = t * x;
arr[i + 1] = (l == r) ? arr[(i + 1) / 2] + 1 : 0;
ans = ans + arr[i + 1];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char *S, *T, F[1 << 21];
inline int read() {
int x = 0, f = 0;
char ch =
(S == T && (T = (S = F) + fread(F, 1, 1 << 21, stdin), S == T) ? EOF
: *S++);
while (!isdigit(ch)) {
f |= ch == '-';
ch = (S == T && (T = (S = F) + fread(F, 1, 1 << 21, stdin), S == T) ? EOF
: *S++);
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = (S == T && (T = (S = F) + fread(F, 1, 1 << 21, stdin), S == T) ? EOF
: *S++);
}
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 <= len; ++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() {
scanf("%s", s + 1);
len = strlen(s + 1);
init();
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>
int dx[] = {0, 1, -1, 0, 1, -1, 1, -1, -2, 2, 0, 0},
dy[] = {1, 0, 0, -1, -1, 1, 1, -1, 0, 0, -2, 2};
using namespace std;
const long long B = 3, M = INT_MAX;
int n;
long long I2N[5000006], I20[5000006], modPow[5000006];
int8_t deg0a[5000006];
bool isPalindrome(int l, int r) {
long long prefix = I2N[r];
long long suffix = I20[r];
return prefix == suffix;
}
int8_t deg0(int r) {
if (r + 1 == 1) return 1;
int8_t &ret = deg0a[r];
if (ret != -1) return ret;
ret = 0;
if (isPalindrome(0, r))
ret++;
else
return 0;
ret += deg0((r + 1) / 2 - 1);
return ret;
}
int degP(int l, int r) {
int len = r - l + 1;
if (len == 1) return 1;
int ret = 0;
if (isPalindrome(l, r))
ret++;
else
return 0;
if (len & 1)
ret += deg0a[len / 2 - 1];
else
ret += deg0a[len / 2 - 1];
return ret;
}
char str[5000006];
int main() {
ios_base::sync_with_stdio(true);
modPow[0] = 1;
memset(deg0a, -1, sizeof(deg0a));
;
scanf("%s", str);
n = strlen(str);
I20[0] = str[0];
I2N[0] = str[0];
for (int i = 1; i < n; i++) {
I20[i] = (I20[i - 1] * B + str[i]);
modPow[i] = (modPow[i - 1] * B);
I2N[i] = (I2N[i - 1] + str[i] * modPow[i]);
}
for (int i = 0; i < n; i++) deg0a[i] = deg0(i);
int sum = 0;
for (int i = 0; i < n; i++) {
sum += degP(0, i);
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MS = 5000002;
const long long MOD = 1000000009;
const long long base = 263ll;
char s[MS];
long long in[MS], ni[MS], powers[MS];
int deg[MS], ans, n;
inline long long mod(long long x) { return x % MOD; }
int main() {
powers[0] = 1ll;
for (int i = 1; i < MS; i++) powers[i] = mod(base * powers[i - 1]);
scanf(" %s", s + 1);
n = strlen(s + 1) + 1;
for (int i = 0; i < n; i++) {
in[i] = mod(in[i - (i > 0)] + s[i] * powers[i - 1]);
ni[i] = mod(ni[i - (i > 0)] * base + s[i]);
}
for (int i = 1; i < n; i++) {
if (mod(in[i] * powers[n - i]) == mod(ni[i] * powers[n - i]))
deg[i] = 1 + deg[i / 2];
ans += deg[i];
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 10;
const long long mod = 1000696969;
long long dp[N], h[N], rh[N], pw[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
s = '.' + s + '.';
for (int i = 1; i <= n; i++)
h[i] = (h[i - 1] * 256 + (long long)(s[i])) % mod;
for (int i = n; i >= 1; i--)
rh[i] = (rh[i + 1] * 256 + (long long)(s[i])) % mod;
pw[0] = 1;
for (int i = 1; i < N; i++) pw[i] = pw[i - 1] * 256 % mod;
long long ans = dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (h[i] == (rh[1] - rh[i + 1] * pw[i] % mod + mod) % mod)
dp[i] = dp[i / 2] + 1;
ans += dp[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
long long StepB = 1;
vector<long long> Hashes(n);
vector<long long> Revhashes(n);
Hashes[0] = s[0];
Revhashes[0] = s[0];
for (int i = 1; i < n; i++) {
Hashes[i] = (((Hashes[i - 1] * 137) % 1000000007) + s[i]) % 1000000007;
StepB = (StepB * 137) % 1000000007;
Revhashes[i] =
((s[i] * StepB) % 1000000007 + Revhashes[i - 1]) % 1000000007;
}
vector<int> Ks(n + 1, 0);
for (int i = 1; i <= n; i++) {
if (Hashes[i - 1] == Revhashes[i - 1]) {
Ks[i] = Ks[i / 2] + 1;
} else
Ks[i] = 0;
}
int rez = 0;
for (int i = 0; i <= n; i++) {
rez += Ks[i];
}
cout << rez << endl;
}
|
#include <bits/stdc++.h>
char s[5005000];
int h[5005000];
const int M = 1239;
int main() {
scanf("%s", s);
int a = 0, b = 0, p = 1, v = 0;
for (int i = 0; s[i]; ++i) {
a = a * M + s[i], b += s[i] * p, p *= M;
if (a == b) v += (h[i + 1] = h[(i + 1) >> 1] + 1);
}
printf("%d\n", v);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000000 + 10;
const int x = 123;
unsigned long long H[maxn], xp[maxn], H2[maxn];
char s[maxn];
int n, m, pos;
int sum = 0;
int dep[maxn];
bool isok(int i, int len) {
unsigned long long a = H[i] - H[i + len] * xp[len];
unsigned long long b;
if (i == 0)
b = H2[i + len - 1];
else
b = H2[i + len - 1] - H2[i - 1] * xp[len];
return a == b;
}
int solve(int e) {
if (e == 0) return 0;
if (!isok(0, e)) return 0;
int cur = solve(e / 2) + 1;
sum = max(sum, cur);
return cur;
}
int main() {
scanf("%s", s);
n = strlen(s);
H[n] = 0;
for (int i = n - 1; i >= 0; i--) H[i] = H[i + 1] * x + s[i];
H2[0] = s[0];
for (int i = 1; i < n; i++) H2[i] = H2[i - 1] * x + s[i];
xp[0] = 1;
for (int i = 1; i <= n; i++) xp[i] = xp[i - 1] * x;
int ans = 0;
memset(dep, 0, sizeof dep);
for (int i = 0; i < n; i++) {
sum = 0;
if (isok(0, i + 1)) {
if (isok(0, (i + 1) / 2))
dep[i + 1] = dep[(i + 1) / 2] + 1;
else {
sum = 0;
solve(i + 1);
dep[i + 1] = sum;
}
ans += dep[i + 1];
}
}
printf("%d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.