text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int a[MAXN];
long long suma[MAXN];
int n, k;
map<long long, int> mapa;
int main() {
scanf("%d %d", &n, &k);
for (int i = (int)0; i < (int)n; i++) scanf("%d", &a[i]);
suma[0] = a[0];
mapa[a[0]]++;
for (int i = (int)1; i < (int)n; i++) {
suma[i] = a[i] + suma[i - 1];
mapa[suma[i]]++;
}
long long ans = 0;
int auxk = k;
for (int j = (int)0; j < (int)n; j++) {
long long pot = 1;
while (1) {
if (pot > 1e15 || -pot > 1e15) break;
long long ant = 0;
if (j) ant = suma[j - 1];
long long t = pot + ant;
ans += mapa[t];
pot *= k;
if (k == 1) break;
if (k == -1) k = 1;
}
mapa[suma[j]]--;
k = auxk;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
struct myhashi64 {
size_t operator()(int64_t x) const {
x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
x = x ^ (x >> 31);
return x;
}
};
static int64_t cnt(const vector<int64_t> &ss, const vector<int64_t> &vkp) {
int64_t sum = 0;
unordered_map<int64_t, int64_t, myhashi64> r;
for (int i = ss.size() - 1; i >= 0; i--) {
for (auto kp : vkp) {
auto v = r.find(kp + ss[i]);
if (v != r.end()) sum += v->second;
}
r[ss[i]]++;
}
for (auto kp : vkp) {
auto v = r.find(kp);
if (v != r.end()) sum += v->second;
}
return sum;
}
int main(int argc, char **argv) {
int n, k;
cin >> n >> k;
vector<int64_t> aa(n);
vector<int64_t> ss(n, 0);
for (int i = 0; i < n; i++) cin >> aa[i];
ss[0] = aa[0];
for (int i = 1; i < n; i++) ss[i] = ss[i - 1] + aa[i];
int64_t sum = 0;
if (abs(k) > 1) {
vector<int64_t> vkp;
for (int64_t kp = 1; abs(kp) <= 100000000000000; kp *= k) vkp.push_back(kp);
sum = cnt(ss, vkp);
} else if (k == -1) {
sum = cnt(ss, vector<int64_t>{-1, 1});
} else {
sum = cnt(ss, vector<int64_t>{1});
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const long long INF = 1e15 + 7;
const int MOD = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1);
int T, cases, n, m;
map<long long, int> Map;
vector<int> G[maxn];
long long a[maxn], sum[maxn], ans;
void f(long long cnt, int i) {
if (Map.count(cnt)) {
int x = Map[cnt];
int y = G[x].size();
int tmp = lower_bound(G[x].begin(), G[x].end(), i) - G[x].begin();
ans += y - tmp;
}
}
int main() {
ios::sync_with_stdio(false);
;
long long n, k, tot = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
long long tmp = sum[i];
if (!Map.count(tmp)) Map[tmp] = ++tot;
G[Map[tmp]].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (k == 1 || k == -1) {
long long cnt = sum[i - 1] + 1;
f(cnt, i);
if (k == -1) {
cnt = sum[i - 1] - 1;
f(cnt, i);
}
} else {
long long cnt = 1;
while (abs(cnt) <= INF) {
f(cnt + sum[i - 1], i);
cnt *= k;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100100];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
const long long max_pow = 1e9 * 1e5;
vector<long long> powers = {1};
if (abs(k) > 1)
while (abs(powers.back() * k) <= max_pow)
powers.push_back(powers.back() * k);
else if (k == -1)
powers.push_back(-1);
long long ans = 0;
long long prefix_sum = 0;
map<long long, long long> cnt_sums;
for (int i = 0; i < n; i++) {
cnt_sums[prefix_sum]++;
prefix_sum += a[i];
for (auto pow : powers)
if (cnt_sums.count(prefix_sum - pow) > 0)
ans += cnt_sums[prefix_sum - pow];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 101000;
int n, k, a[N];
long long s[N], ret;
set<long long> hs;
map<long long, int> cnt;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n + 1; i++) {
scanf("%d", a + i);
s[i] = s[i - 1] + a[i];
}
hs.insert(1);
if (k == -1)
hs.insert(-1);
else if (k != 1) {
long long x = 1;
while (x * k <= (1ll << 60) && x * k >= -(1ll << 60)) {
x *= k;
hs.insert(x);
}
}
cnt[0] = 1;
for (int i = 1; i < n + 1; i++) {
for (auto p : hs)
if (cnt.count(s[i] - p)) ret += cnt[s[i] - p];
cnt[s[i]]++;
}
printf("%lld\n", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N, k;
scanf("%d%d", &N, &k);
long long x[N + 1];
x[0] = 0;
for (int i = 0; i < N; i++) scanf("%lld", &x[i + 1]);
partial_sum(x, x + N + 1, x);
if (k == 1) {
long long ans = 0;
map<long long, int> m;
for (int i = N; i >= 0; i--) {
if (m.find(x[i] + 1) != m.end()) ans += m[x[i] + 1];
m[x[i]]++;
}
printf("%lld\n", ans);
} else if (k == -1) {
long long ans = 0;
map<long long, int> m;
for (int i = N; i >= 0; i--) {
if (m.find(x[i] + 1) != m.end()) ans += m[x[i] + 1];
if (m.find(x[i] - 1) != m.end()) ans += m[x[i] - 1];
m[x[i]]++;
}
printf("%lld\n", ans);
} else {
long long ans = 0;
map<long long, int> m;
for (int i = N; i >= 0; i--) {
long long cur = 1;
while (true) {
if (abs(cur) >= 1e15) break;
if (m.find(x[i] + cur) != m.end()) ans += m[x[i] + cur];
cur *= k;
}
m[x[i]]++;
}
printf("%lld\n", ans);
}
}
signed main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const long long INF = 1e15 + 10;
int A[N];
long long pre[N];
map<long long, int> m;
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
}
pre[0] = 0;
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + A[i];
long long ans = 0;
m[0] = 1;
for (int i = 1; i <= n; i++) {
if (k == 1) {
ans += m[pre[i] - 1];
} else if (k == -1) {
ans += m[pre[i] - 1] + m[pre[i] + 1];
} else {
long long l = 1;
while (abs(l) < INF) {
ans += m[pre[i] - l];
l *= k;
}
}
m[pre[i]]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 3) return n > 1;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
long long power(long long x, long long y, long long MOD = (1e9 + 7)) {
x %= MOD;
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % MOD;
x = (x * x) % MOD;
y >>= 1;
}
return res;
}
long long findSubArrays(long long *arr, long long n, long long sum) {
map<long long, long long> prevSum;
long long res = 0;
long long currsum = 0;
for (long long i = 0; i < n; i++) {
currsum += arr[i];
if (currsum == sum) res++;
if (prevSum.find(currsum - sum) != prevSum.end())
res += (prevSum[currsum - sum]);
prevSum[currsum]++;
}
return res;
}
void solve(long long testcase) {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
set<long long> values;
for (long long i = 0; i < 63; i++) {
long long temp = pow(abs(k), i);
if (temp < 0) break;
if (k < 0 && i % 2)
values.insert(-temp);
else
values.insert(temp);
}
vector<long long> temp(values.begin(), values.end());
long long res = 0;
for (auto &x : temp) res += findSubArrays(a, n, x);
cout << res << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
for (long long i = 1; i <= t; i++) solve(i);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, k, ans, p, temp = 1, ara[1000000];
map<long long int, long long int> m;
int main() {
scanf("%lld %lld", &(n), &(k));
ara[0] = 0;
for (long long int i = (1); i < (n + 1); i++) scanf("%lld", &(ara[i]));
partial_sum(ara, ara + n + 1, ara);
if (k == 1) {
for (long long int i = (n); i >= (0); i--) {
if (m.find(ara[i] + 1) != m.end()) ans += m[ara[i] + 1];
m[ara[i]]++;
}
printf("%lld", (ans));
;
return 0;
}
if (k == -1) {
for (long long int i = (n); i >= (0); i--) {
if (m.find(ara[i] + 1) != m.end()) ans += m[ara[i] + 1];
if (m.find(ara[i] - 1) != m.end()) ans += m[ara[i] - 1];
m[ara[i]]++;
}
printf("%lld", (ans));
;
return 0;
}
for (long long int i = (n); i >= (0); i--) {
p = 1;
while (abs(p) < 1e15) {
if (m.find(ara[i] + p) != m.end()) {
ans += m[ara[i] + p];
}
p *= k;
}
m[ara[i]]++;
}
printf("%lld", (ans));
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[11] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
string yes[3] = {"YES", "Yes", "yes"};
string no[3] = {"NO", "No", "no"};
int countones(long long a) {
int count = 0;
while (a != 0) {
count++;
a = a & (a - 1);
}
return count;
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
long long Fib[] = {
0, 1, 1, 2, 3, 5,
8, 13, 21, 34, 55, 89,
144, 233, 377, 610, 987, 1597,
2584, 4181, 6765, 10946, 17711, 28657,
46368, 75025, 121393, 196418, 317811, 514229,
832040, 1346269, 2178309, 3524578, 5702887, 9227465,
14930352, 24157817, 39088169, 63245986, 102334155, 165580141,
267914296, 433494437, 701408733, 1134903170, 1836311903};
long long sum(long long n) { return (n * (n + 1)) / 2; }
long long rangesum(long long a, long long b) {
if (a <= 1) return sum(b);
return sum(b) - sum(a - 1);
}
bool isPowerOfTwo(int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
inline bool cmp(long long a, long long b) { return a > b; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool palindrome(string a) {
bool flag = 1;
int x = a.size();
for (int i = 0; i < x / 2; i++)
if (a[i] != a[x - i - 1]) {
flag = 0;
break;
}
return flag;
}
int get_dimensions(int x, int y) {
int a;
if (x > 0 && y > 0)
a = 1;
else if (x < 0 && y > 0)
a = 2;
else if (x < 0 && y < 0)
a = 3;
else if (x > 0 && y < 0)
a = 4;
else
a = 0;
return a;
}
long long fastpower(long long x, long long power) {
if (!power) return 1;
if (power == 1) return x;
if (power % 2) return (x * fastpower(x, power - 1));
long long result = fastpower(x, power / 2);
return result;
}
long long lim = (long long)1e16;
int n;
long long k, s, wyn;
map<long long, int> mapa;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
mapa[0]++;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
s += x;
mapa[s]++;
long long t = 1;
while (t <= lim) {
wyn += mapa[s - t];
t *= k;
if (t == 1) break;
}
}
cout << wyn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
vector<long long> vec;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j, t;
int n, k;
long long maxx = -1e18;
long long minn = 1e18;
long long sum = 0;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
if (i > 0) a[i] += a[i - 1];
}
long long ans = 0;
long long x = 1;
set<long long> sett;
while (1) {
vec.push_back(x);
sett.insert(x);
if (1.0 * abs(x) > 1e15 / abs(k)) break;
x *= k;
if (sett.find(x) != sett.end()) break;
}
unordered_map<long long, int> mapp;
mapp[0] = 1;
for (i = 0; i < n; i++) {
for (long long p : vec) {
if (mapp.find(a[i] - p) != mapp.end()) {
ans += mapp[a[i] - p];
}
}
mapp[a[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const long long inf = 1e16;
long long vis[70];
long long sum[MAXN];
map<long long, long long> mp;
int init(int k) {
if (k == 1 || k == -1) return 0;
vis[0] = 1;
long long cur = k;
int i;
for (i = 1; i < 64 && cur < inf; i++) {
vis[i] = cur;
cur *= k;
}
return i;
}
int main() {
int n, k;
cin >> n >> k;
int t = init(k);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (k == 1 || k == -1) {
mp[sum[i - 1] + 1]++;
if (k == -1) mp[sum[i - 1] - 1]++;
} else {
for (int j = 0; j < t; j++) {
mp[sum[i - 1] + vis[j]]++;
}
}
sum[i] = sum[i - 1] + x;
ans += mp[sum[i]];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
const int MAX = 1000 * 100 + 47;
const long long MAX1 = 10 * MAX * (long long)INF;
long long A[MAX];
map<long long, int> M;
vector<long long> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
n++;
for (int i = (1); i < (n); i++) cin >> A[i];
for (int i = (1); i < (n); i++) A[i] += A[i - 1];
long long p = 1;
if (abs(k) == 1) {
if (k == 1) {
P.push_back(1);
} else {
P.push_back(1);
P.push_back(-1);
}
} else {
while (abs(p) < MAX1) {
P.push_back(p);
p *= k;
}
}
long long ans = 0;
for (int i = (0); i < (n); i++) {
long long a = A[i];
for (int j = (0); j < ((int)P.size()); j++) {
long long b = a - P[j];
ans += M[b];
}
M[a]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15 + 7;
const int maxn = 1e5 + 7;
int a[maxn];
long long sum[maxn];
long long B[100];
map<long long, int> G;
int main() {
int n, k;
scanf("%d %d", &n, &k);
long long MAX = 0, MIN = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
MAX = max(sum[i], MAX);
MIN = min(MIN, sum[i]);
}
int cnt = 0;
long long ans = 1;
long long END = abs(MAX - MIN);
if (abs(k) == 1) {
if (k == -1) {
B[0] = 1;
B[1] = -1;
cnt = 2;
} else {
B[0] = 1;
cnt = 1;
}
} else
while (abs(ans) <= END) {
B[cnt++] = ans;
ans *= k;
}
long long res = 0;
G[0]++;
for (int j = 1; j <= n; j++) {
for (int i = 0; i < cnt; i++) {
if (G.find(sum[j] - B[i]) != G.end()) res += G[sum[j] - B[i]];
}
G[sum[j]]++;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[100010];
int nums;
long long solve(int k) {
int i = 0;
map<long long, int> mymap;
long long cur = 1;
long long out = 0;
if (k == 1) {
for (i = nums; i >= 0; i--) {
if (mymap.find(arr[i] + 1) != mymap.end()) {
out += mymap[arr[i] + 1];
}
mymap[arr[i]]++;
}
} else if (k == -1) {
for (i = nums; i >= 0; i--) {
if (mymap.find(arr[i] + 1) != mymap.end()) {
out += mymap[arr[i] + 1];
}
if (mymap.find(arr[i] - 1) != mymap.end()) {
out += mymap[arr[i] - 1];
}
mymap[arr[i]]++;
}
} else {
for (i = nums; i >= 0; i--) {
cur = 1;
while (abs(cur) < 1e15) {
if (mymap.find(arr[i] + cur) != mymap.end()) {
out += mymap[arr[i] + cur];
}
cur *= k;
}
mymap[arr[i]]++;
}
}
return out;
}
int main(int argc, char *argv[]) {
int k = 0;
int curk = 0;
scanf("%d %d", &nums, &k);
curk = 1;
int i = 0;
arr[0] = 0;
for (i = 0; i < nums; i++) {
scanf("%lld", &arr[i + 1]);
arr[i + 1] += arr[i];
}
long long finals = 0;
finals = solve(k);
printf("%lld\n", finals);
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mv = 1e14 + 10;
long long power(long long a, long long n) {
long long ans = 1;
for (long long i = 1; i <= n; i++) {
ans *= a;
}
return ans;
}
int32_t main() {
ios ::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> v;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
if (k == 1) {
v.push_back(1);
} else if (k == -1) {
v.push_back(1);
v.push_back(-1);
} else {
for (long long i = 0; i < 50; i++) {
if (abs(power(k, i)) > mv) {
break;
}
v.push_back(power(k, i));
}
}
map<long long, long long> mp;
mp[0] = 1;
long long s = 0, ans = 0;
for (long long i = 0; i < n; i++) {
s += a[i];
for (auto j : v) {
if (mp.count(s - j)) ans += mp[s - j];
}
mp[s]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
scanf("%d", &head);
RI(tail...);
}
using namespace std;
int n, k, in[100005];
long long dp[100005], ans;
void work() {
vector<long long> nums;
nums.push_back(1);
if (abs(k) != 1)
while (abs(nums.back() * k) <= (long long)1e16)
nums.push_back(nums.back() * k);
if (k == -1) nums.push_back(-1);
dp[0] = 0;
for (int i = 1; i <= n; i++) dp[i] = dp[i - 1] + in[i];
map<long long, int> cnt;
cnt[0] = 1;
for (int i = 1; i <= n; i++) {
for (long long j : nums) ans += cnt[dp[i] - j];
cnt[dp[i]]++;
}
}
int main() {
while (~scanf("%d %d", &n, &k)) {
for (int i = 1; i <= n; i++) RI(in[i]);
ans = 0;
work();
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const long long INF = 1e14 + 5;
long long sum;
int a[maxn];
map<long long, int> mp;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long pow = 1, ans = 0;
while (abs(pow) < INF) {
mp.clear();
mp[0] = 1;
sum = 0;
for (int i = 1; i <= n; i++) {
sum = sum + a[i];
ans += mp[sum - pow];
mp[sum]++;
}
pow = pow * k;
if (pow == 1) break;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ris = 0;
bool isPower(long long x, long long y) {
double res1 = log(y) / log(x);
double e = ceil(res1);
return (res1 / e == 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
map<long long, long long> prefix;
vector<long long> multi;
vector<long long> val(n);
for (int i = 0; i < n; i++) cin >> val[i];
long long scorso = 1;
while (abs(scorso) <= 1e16) {
multi.push_back(scorso);
scorso *= k;
if (scorso == 1) break;
}
long long sum = 0;
prefix[0]++;
for (int i = 0; i < n; i++) {
sum += val[i];
for (auto x : multi) {
ris += prefix[sum - x];
}
prefix[sum]++;
}
cout << ris << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 1) + (s << 3) + ch - '0', ch = getchar();
return s * w;
}
map<long long, int> s;
long long a[N];
int main() {
int n, k;
long long sum = 0, ans = 0;
s[0] = 1;
n = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) {
sum += a[i];
s[sum]++;
long long kk = 1;
do {
if (s.find(sum - kk) != s.end()) ans += s[sum - kk];
if (k == 1 || kk == -1) break;
kk *= k;
} while (kk <= 1e14);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
const long long MAXVALUE = 1e17;
map<long long, long long> mp;
long long a[MAXN];
long long sum[MAXN];
long long n, k, res, value, kMi;
int main() {
scanf("%I64d%I64d", &n, &k);
res = 0;
sum[0] = 0;
for (int i = 1; i < n + 1; i++) {
scanf("%I64d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int i = n + 1 - 1; i >= 0; i--) {
value = sum[i];
if (k == 1) {
res += mp[value + k];
} else if (k == -1) {
res += mp[value + 1];
res += mp[value - 1];
} else {
kMi = 1;
while (abs(kMi) < MAXVALUE) {
res += mp[value + kMi];
kMi *= k;
}
}
mp[value]++;
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct hashLL {
long long operator()(long long x) const {
x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
x = x ^ (x >> 31);
return x;
}
};
struct Hashmap {
long long toXor;
unordered_map<long long, int, hashLL> m;
Hashmap() {
srand(time(0));
toXor = rand();
m.reserve(4096);
m.max_load_factor(0.25);
}
int &operator[](const long long &key) { return m[key ^ toXor]; }
unordered_map<long long, int, hashLL>::iterator find(const long long &key) {
return m.find(key ^ toXor);
}
unordered_map<long long, int, hashLL>::iterator end() { return m.end(); }
};
long long a[100001];
Hashmap mp;
int n, k;
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
vector<long long> v;
if (k == 0)
v.push_back(0);
else if (k == 1)
v.push_back(1);
else if (k == -1) {
v.push_back(1);
v.push_back(-1);
} else {
long long pp = 1;
for (int i = 0;; i++) {
v.push_back(pp);
pp *= k;
if (pp > 100000000000000 || pp < -100000000000000) break;
}
}
long long c = 0;
long long sum = 0;
mp[sum]++;
for (int i = 0; i < n; i++) {
sum += a[i];
for (auto i : v) {
c += mp[sum - i];
}
mp[sum]++;
}
cout << c;
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
int main() {
std::ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
long long arr[n + 2];
long long sum[n + 2];
sum[0] = 0;
mp[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
sum[i] = sum[i - 1] + arr[i];
}
long long mn = 1e15;
mn *= -1;
long long mx = 1e15;
vector<long long> vec;
vec.push_back(1);
long long temp = 1;
while (true) {
if (k == 1) break;
if (k == -1) {
vec.push_back(-1);
break;
}
temp *= k;
if (temp > mx || temp < mn) break;
vec.push_back(temp);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
mp[sum[i]]++;
for (int j = 0; j < vec.size(); j++) {
ans += mp[(sum[i] - vec[j])];
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
int n, k, a[maxn];
long long ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
long long v = 1LL;
while (v <= 100000000000000LL) {
map<long long, int> m;
long long sum = 0;
++m[0];
for (int i = 0; i < n; ++i) {
sum += a[i];
++m[sum];
if (m.find(sum - v) != m.end()) ans += m[sum - v];
}
v *= k;
if (v == 1) break;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
map<long long, long long> ma;
long long sum[N], a[N];
int main() {
long long n, m;
cin >> n >> m;
sum[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
long long tmp = 1;
long long ans = 0;
ma.clear();
ma[0] = 1;
for (int i = 1; i <= n; i++) {
tmp = 1;
while (tmp < 1e16) {
ans += ma[sum[i] - tmp];
tmp *= m;
if (m == 1) break;
if (m == -1 && tmp == 1) break;
}
ma[sum[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> check(long long n) {
long long k = 200000000000000;
vector<long long> ret;
if (n == 1)
return vector<long long>{1};
else if (n == -1) {
ret.push_back(-1);
return vector<long long>{1, -1};
} else {
long long cur = 1;
while (abs(cur) < k) {
ret.push_back(cur);
cur *= n;
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
vector<long long> vec(n);
for (int i = 0; i < n; ++i) cin >> vec[i];
vector<long long> ch = check(k);
map<long long, long long> m;
m[0] = 1;
long long sum = 0, ans = 0, s = ch.size();
for (int i = 0; i < n; ++i) {
sum += vec[i];
for (int j = 0; j < s; ++j) {
long long f = sum - ch[j];
if (m[f]) ans += m[f];
}
++m[sum];
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18, mod = 1e9 + 7;
const int N = 3e5, inf = 1e9;
long long n, k, a[N], sum[N], pref[N], ans;
map<long long, long long> m;
vector<long long> v;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int i = n; i > 0; i--) {
pref[i] = pref[i + 1] + a[i];
m[pref[i]]++;
}
m[0]++;
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 <= 1e15 + 1111; i++)
v.push_back(v[v.size() - 1] * k);
}
for (int i = 0; i <= n; i++) {
m[pref[i + 1]]--;
for (int j = 0; j < v.size(); j++)
if (m[sum[n] - (v[j] + sum[i])]) {
ans += m[sum[n] - (v[j] + sum[i])];
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[11] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
string yes[3] = {"YES", "Yes", "yes"};
string no[3] = {"NO", "No", "no"};
int countones(long long a) {
int count = 0;
while (a != 0) {
count++;
a = a & (a - 1);
}
return count;
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
long long Fib[] = {
0, 1, 1, 2, 3, 5,
8, 13, 21, 34, 55, 89,
144, 233, 377, 610, 987, 1597,
2584, 4181, 6765, 10946, 17711, 28657,
46368, 75025, 121393, 196418, 317811, 514229,
832040, 1346269, 2178309, 3524578, 5702887, 9227465,
14930352, 24157817, 39088169, 63245986, 102334155, 165580141,
267914296, 433494437, 701408733, 1134903170, 1836311903};
long long sum(long long n) { return (n * (n + 1)) / 2; }
long long rangesum(long long a, long long b) {
if (a <= 1) return sum(b);
return sum(b) - sum(a - 1);
}
bool isPowerOfTwo(int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
inline bool cmp(long long a, long long b) { return a > b; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool palindrome(string a) {
bool flag = 1;
int x = a.size();
for (int i = 0; i < x / 2; i++)
if (a[i] != a[x - i - 1]) {
flag = 0;
break;
}
return flag;
}
int get_dimensions(int x, int y) {
int a;
if (x > 0 && y > 0)
a = 1;
else if (x < 0 && y > 0)
a = 2;
else if (x < 0 && y < 0)
a = 3;
else if (x > 0 && y < 0)
a = 4;
else
a = 0;
return a;
}
long long fastpower(long long x, long long power) {
if (!power) return 1;
if (power == 1) return x;
if (power % 2) return (x * fastpower(x, power - 1));
long long result = fastpower(x, power / 2);
return result;
}
long long lim = (long long)1e14 + 1;
int n;
long long k, s, wyn;
map<long long, int> mapa;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
mapa[0]++;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
s += x;
mapa[s]++;
long long t = 1;
while (t <= lim) {
wyn += mapa[s - t];
t *= k;
if (t == 1) break;
}
}
cout << wyn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n), p(n + 1);
for (long long i = (0); i < (n); i++) cin >> a[i], p[i + 1] = p[i] + a[i];
long long ans = 0;
map<long long, long long> m;
for (long long i = (n + 1 - 1); i >= (0); i--) {
if (k == 1) {
ans += m[p[i] + 1];
} else if (k == -1) {
ans += m[p[i] + 1];
ans += m[p[i] - 1];
} else {
long long kk = 1;
while (1) {
if (kk > 100000000000000) break;
ans += m[p[i] + kk];
kk *= k;
}
}
m[p[i]]++;
}
cout << ans << "\n";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void sol();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
long long ml = 1, ans = 0;
vector<int> ls(n);
map<long long, int> pre, mp;
mp[0] = 1;
vector<long long> an;
while (ml < 1e15) {
if (!pre[ml])
an.push_back(ml), pre[ml] = 1;
else
break;
ml *= k;
if ((ml > 1e15 || -ml > 1e15) || (ml % k != 0)) break;
}
for (int &x : ls) cin >> x;
long long sm = 0ll;
for (int x : ls) {
sm += x;
for (long long y : an)
if (mp[sm - y]) ans += mp[sm - y];
mp[sm]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
map<long long, long long> mmp;
long long sum[maxn];
long long val[maxn];
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 >> val[i], sum[i] = sum[i - 1] + val[i];
long long ans = 0;
mmp[0] = 1;
for (int i = 1; i <= n; i++) {
long long temp = 1;
while (temp < 1e15) {
ans += mmp[sum[i] - temp];
temp *= k;
if (k == 1) break;
if (k == -1 && temp == 1) break;
}
mmp[sum[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void check_min(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void check_max(T& a, T b) {
if (a < b) a = b;
}
const int MAX_N = 100100;
const long long INF = 1e16;
int n, k, a[MAX_N];
map<long long, int> mp;
vector<long long> ps;
int main() {
scanf("%d%d", &n, &k);
ps.push_back(1);
if (k == -1) {
ps.push_back(-1);
} else if (abs(k) > 1) {
while (ps.back() < INF) ps.push_back(ps.back() * k);
}
mp[0] = 1;
long long s = 0, ans = 0;
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
s += x;
for (long long p : ps) {
auto it = mp.find(s - p);
if (it == mp.end()) continue;
ans += it->second;
}
++mp[s];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e15;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n, k;
cin >> n >> k;
vector<int> first(n);
for (int i = 0; i < n; i++) cin >> first[i];
vector<long long> pr(n + 1);
for (int i = 0; i < n; i++) pr[i + 1] = pr[i] + first[i];
map<long long, int> how;
for (int i = 0; i < n; i++) {
how[pr[i + 1]]++;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if (k == 1) {
ans += how[k + pr[i]];
} else {
if (k == -1) {
ans += how[k + pr[i]];
ans += how[-k + pr[i]];
} else {
for (long long p = 1; p <= MAX; p *= k) {
ans += how[p + pr[i]];
}
}
}
how[pr[i + 1]]--;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mx = (long long)1ll * 1e5 * 1e9 * 10;
signed main() {
int n, k;
cin >> n >> k;
map<long long, int> mp;
long long cur = 1ll;
int cnt = 0;
set<long long> all;
all.insert(1ll);
while (abs(cur) < mx && cnt < 64) {
all.insert(cur * 1ll * k);
cur *= 1ll * k;
cnt++;
}
long long pref = 0, ans = 0;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
pref += 1ll * a[i];
ans += (all.find(pref) != all.end());
mp[pref]++;
}
pref = 0;
for (int i = 1; i < n; i++) {
pref += 1ll * a[i - 1];
mp[pref]--;
for (auto j : all) {
ans += mp[j + pref];
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 1039074182;
using namespace std;
int n, k;
int a[100005];
map<long long, int> m;
long long check(long long x) {
m.clear();
long long pre = 0;
long long res = 0;
for (int i = 0; i < n; i++) {
m[pre]++;
pre += a[i];
res += m[pre - x];
}
return res;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
long long basic = 1;
long long res = 0;
bool f = false;
while (basic <= 1e14) {
res += check(basic);
basic *= k;
if (basic == 1) break;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ai;
long long SUM, ans;
set<long long> PW;
map<long long, int> SUMS;
int main() {
scanf("%d%d", &n, &k);
SUMS[0] = 1;
PW.insert(1);
if (k == -1) PW.insert(-1);
if (abs(k) > 1)
for (long long p = k; p < 1e16; p *= k) PW.insert(p);
for (int i = 0; i < n; i++) {
scanf("%d", &ai);
SUM += ai;
for (auto p : PW) {
auto f = SUMS.find(SUM - p);
if (f != SUMS.end()) ans += f->second;
}
SUMS[SUM]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
vector<long long> pf(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
pf[i] = a[i];
if (i) pf[i] += pf[i - 1];
}
long long ans = 0;
long long pw = 1;
while (llabs(pw) <= 1LL * n * 1000000000) {
map<long long, int> cnt;
cnt[0] = 1;
for (int i = 0; i < n; i++) {
cnt[pf[i]]++;
ans += cnt[pf[i] - pw];
}
if (k == 1 || (k == -1 && pw == -1)) break;
pw *= k;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(1e5 + 5);
const long long MAX_SUM = (long long)(1e14);
int n;
long long k, a[N];
long long countSegments(long long targetSum) {
long long ret = 0;
map<long long, int> m;
m[0] = 1;
for (int i = 1; i <= n; ++i) {
ret += m[a[i] - targetSum];
m[a[i]]++;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i], a[i] += a[i - 1];
if (k == -1)
cout << (countSegments(-1) + countSegments(1));
else if (k == 1)
cout << countSegments(1);
else {
long long ans = 0;
for (long long e = 0;; ++e) {
long long pw = 1;
for (int i = 1; i <= e; ++i) pw *= k;
if (pw < -MAX_SUM || pw > MAX_SUM) break;
ans += countSegments(pw);
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long inf = 1e18;
inline long long in() {
long long x;
scanf("%lld", &x);
return x;
}
int32_t main() {
long long n = in();
long long k = in();
long long a[n];
for (long long i = 0; i < n; i++) a[i] = in();
map<long long, long long> f;
long long pre[n + 1];
pre[0] = 0;
for (long long i = 1; i <= n; i++) pre[i] = a[i - 1] + pre[i - 1];
long long cur = 1;
long long ans = 0, tmp = 0;
while (cur <= inf) {
tmp = 0;
for (long long i = 0; i <= n; i++) {
tmp += f[pre[i] - cur];
f[pre[i]]++;
}
f.clear();
ans += tmp;
if (k == 1 or (k == -1 and cur == -1)) break;
cur *= k;
}
cout << ans;
}
|
#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 int maxn = 1e5 + 10;
const long long inf = 1e16;
map<long long, long long> mp;
long long vis[70];
long long sum[maxn];
int n, k, a;
long long ans = 0;
void print() {
vis[0] = 1;
for (int i = 1; i <= 64; i++) {
if (vis[i - 1] < inf) {
vis[i] = vis[i - 1] * k;
}
}
return;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
mp.clear();
print();
memset(sum, 0, sizeof sum);
for (int i = 1; i <= n; i++) {
cin >> a;
for (int j = 0; j <= 64 && vis[j] < inf; j++) {
if (k == 1 || k == -1) {
if (k == -1) {
mp[sum[i - 1] - 1]++;
}
mp[sum[i - 1] + 1]++;
break;
} else {
mp[sum[i - 1] + vis[j]]++;
}
}
sum[i] = sum[i - 1] + a;
ans += mp[sum[i]];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Flandre_Scarlet {
long long n, k, a[155555];
void R1(long long &x) {
x = 0;
char c = getchar();
long long f = 1;
while (c < '0' or c > '9') f = (c == '-') ? -1 : 1, c = getchar();
while (c >= '0' and c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = (f == 1) ? x : -x;
}
void Input() {
R1(n), R1(k);
for (long long i = 1; i <= n; ++i) R1(a[i]);
}
map<long long, long long> s;
void Soviet() {
long long sum = 0;
long long ans = 0;
s[0] = 1;
for (long long i = 1; i <= n; ++i) {
sum += a[i];
for (long long j = 1; j <= 1e17; j *= k) {
long long x = sum - j;
if (s.count(x)) ans += s[x];
if (k == 1 or j == -1) break;
}
s[sum]++;
}
printf("%I64d\n", ans);
}
void IsMyWife() {
Input();
Soviet();
}
} // namespace Flandre_Scarlet
int main() {
Flandre_Scarlet::IsMyWife();
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long value[100005];
long long cumsum[100005];
long long power[100005];
map<long long, long long> mp;
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
cumsum[0] = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &value[i]);
cumsum[i] = cumsum[i - 1] + value[i];
}
long long pwr;
power[0] = 1;
for (pwr = 1; pwr <= 50; pwr++) {
power[pwr] = power[pwr - 1] * k;
if (power[pwr] > 10000000000000000) {
break;
}
}
long long ans = 0;
mp[0] = 1;
for (long long j = 1; j <= n; j++) {
for (long long l = 0; l < pwr; l++) {
if ((l == 1 && k == 1) || (l == 2 && k == -1)) break;
if (power[l] > 100000000000000000) break;
ans += mp[cumsum[j] - power[l]];
}
mp[cumsum[j]]++;
}
printf("%lld\n", ans);
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;
int32_t n, k, a[N];
unordered_set<int64_t> kp;
unordered_map<int64_t, int32_t, custom_hash> c;
int64_t run(int l, int r) {
if (l == r) return kp.count(a[l]);
int m = (l + r) / 2;
auto ans = run(l, m) + run(m + 1, r);
c.clear();
int64_t s = 0;
for (int i = m; i >= l; i--) c[s += a[i]]++;
s = 0;
for (int i = m + 1; i <= r; i++) {
s += a[i];
for (auto x : kp) {
auto it = c.find(x - s);
if (it != c.end()) ans += it->second;
}
}
return ans;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int64_t x = 1; x <= 1e14; x *= k) {
if (!kp.insert(x).second) break;
}
c.reserve(n);
cout << run(0, n - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[11] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
string yes[3] = {"YES", "Yes", "yes"};
string no[3] = {"NO", "No", "no"};
int countones(long long a) {
int count = 0;
while (a != 0) {
count++;
a = a & (a - 1);
}
return count;
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
long long Fib[] = {
0, 1, 1, 2, 3, 5,
8, 13, 21, 34, 55, 89,
144, 233, 377, 610, 987, 1597,
2584, 4181, 6765, 10946, 17711, 28657,
46368, 75025, 121393, 196418, 317811, 514229,
832040, 1346269, 2178309, 3524578, 5702887, 9227465,
14930352, 24157817, 39088169, 63245986, 102334155, 165580141,
267914296, 433494437, 701408733, 1134903170, 1836311903};
long long sum(long long n) { return (n * (n + 1)) / 2; }
long long rangesum(long long a, long long b) {
if (a <= 1) return sum(b);
return sum(b) - sum(a - 1);
}
bool isPowerOfTwo(int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
inline bool cmp(long long a, long long b) { return a > b; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool palindrome(string a) {
bool flag = 1;
int x = a.size();
for (int i = 0; i < x / 2; i++)
if (a[i] != a[x - i - 1]) {
flag = 0;
break;
}
return flag;
}
int get_dimensions(int x, int y) {
int a;
if (x > 0 && y > 0)
a = 1;
else if (x < 0 && y > 0)
a = 2;
else if (x < 0 && y < 0)
a = 3;
else if (x > 0 && y < 0)
a = 4;
else
a = 0;
return a;
}
long long fastpower(long long x, long long power) {
if (!power) return 1;
if (power == 1) return x;
if (power % 2) return (x * fastpower(x, power - 1));
long long result = fastpower(x, power / 2);
return result;
}
long long lim = (long long)1e15;
int n;
long long k, s, wyn;
map<long long, int> mapa;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
mapa[0]++;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
s += x;
mapa[s]++;
long long t = 1;
while (t <= lim) {
wyn += mapa[s - t];
t *= k;
if (t == 1) break;
}
}
cout << wyn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, n;
cin >> n >> k;
vector<long long int> v;
j = k;
long long int sum[n];
for (i = 0; i < n; i++) cin >> sum[i];
map<long long int, long long int> mpp;
mpp[sum[0]]++;
for (i = 1; i < n; i++) {
sum[i] += sum[i - 1];
mpp[sum[i]]++;
}
j = k;
long long int maxm = 0 - 1e14;
v.push_back(1);
if (k != 1)
while (j <= 1e14 && j >= maxm) {
v.push_back(j);
if (k == -1 || k == 1) break;
j = j * k;
}
sort(v.begin(), v.end());
long long int anscnt = 0;
for (i = n - 1; i >= 0; i--) {
j = sum[i];
if (*lower_bound(v.begin(), v.end(), j) == j) {
anscnt++;
}
for (auto a : v) {
long long int l = j - a;
if (mpp[l] != 0) anscnt += mpp[l];
}
mpp[j]--;
}
cout << anscnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> ct;
long long a[100010];
long long power[1000];
long long check_count(long long cumsumj, int powcount) {
long long ans = 0;
for (int i = 0; i < powcount; i++) {
long long temp = cumsumj - power[i];
ans += ct[temp];
}
return ans;
}
long long absd(long long a) {
if (a < 0) return -a;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
int powcount = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) a[i] += a[i - 1];
if (k == 1) {
power[0] = 1;
powcount = 1;
} else if (k == -1) {
power[0] = -1;
power[1] = 1;
powcount = 2;
} else {
for (long long temp = 1; absd(temp) <= 100000000000010; powcount++) {
power[powcount] = temp;
temp = temp * k;
}
}
long long ans = 0;
ct[0] = 1;
for (int i = 0; i < n; i++) {
ct[a[i]]++;
ans += check_count(a[i], powcount);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<long long> degrees = {1};
map<long long, bool> vis;
vis[1] = true;
long long cur = k;
while (llabs(cur) <= 1e14 && !vis[cur]) {
vis[cur] = true;
degrees.push_back(cur);
cur *= k;
}
long long ans = 0, sum = 0;
map<long long, int> cnt;
for (int i = 0; i < n; ++i) {
int x;
bool is_deg = false;
cin >> x;
sum += x;
for (const long long& deg : degrees) {
if (deg == sum) {
is_deg = true;
}
long long dif = sum - deg;
if (cnt.find(dif) != cnt.end()) {
ans += cnt[dif];
}
}
ans += is_deg;
++cnt[sum];
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int mod = 1000000007;
const int inf = 50000000;
const int maxn = 100010;
const long long lim = 1LL << 53;
int n, A[maxn];
long long k, pref[maxn];
map<long long, int> cnt;
int main() {
scanf("%d %lld", &n, &k);
cnt[0] = 1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
pref[i] = pref[i - 1] + A[i];
if (k == 1) {
ans += cnt[pref[i] - 1];
} else if (k == -1) {
ans += cnt[pref[i] - 1];
ans += cnt[pref[i] + 1];
} else {
long long tmp = 1;
while (tmp < lim) {
ans += cnt[pref[i] - tmp];
tmp *= k;
}
}
cnt[pref[i]] += 1;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[111111];
int main() {
cin.sync_with_stdio(false);
cin >> n >> k;
for (int i = (int)(0); i < (int)(n); i++) cin >> a[i];
long long res = 0, sum = 0;
map<long long, long long> cnt;
cnt[0]++;
for (int i = (int)(0); i < (int)(n); i++) {
sum += a[i];
int c = 0;
for (long long kk = 1; (-1e16 < kk && kk < 1e16); kk *= k, c++) {
res += cnt[sum - kk];
if ((c == 0 && k == 1) || (c == 1 && k == -1)) break;
}
cnt[sum]++;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, nguong;
long long kmu[100000];
int intlog(double base, double x) { return (int)(log(x) / log(base)); }
int main() {
cin >> n >> k;
if (abs(k) != 1) {
nguong = intlog(abs(k), numeric_limits<long long>::max());
kmu[0] = 1;
for (int i = (1); i <= (nguong); i++) kmu[i] = kmu[i - 1] * k;
}
long long curSum = 0;
long long preSum = 0;
map<long long, unsigned long long> cnt;
cnt[0] = 1;
unsigned long long res = 0;
for (int i = (1); i <= (n); i++) {
long long x;
cin >> x;
curSum += x;
if (k == 1)
res += cnt[curSum - 1];
else if (k == -1)
res = res + cnt[curSum - 1] + cnt[curSum + 1];
else {
for (int j = (0); j <= (nguong); j++) res += cnt[curSum - kmu[j]];
}
preSum += x;
cnt[preSum]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> foo;
long long too[123456];
long long abss(long long a) { return a > 0 ? a : -a; }
int main() {
long long n, k;
long long sum = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> too[i];
sum += abss(too[i]);
}
long long t = 1;
long long ans = 0;
while (abss(t) <= sum) {
long long s = 0;
foo.clear();
foo[0]++;
for (int i = 1; i <= n; i++) {
s += too[i];
ans += (foo[s - t]);
foo[s]++;
}
t *= k;
if (t == 1 && abss(k) == 1) {
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[11] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
string yes[3] = {"YES", "Yes", "yes"};
string no[3] = {"NO", "No", "no"};
int countones(long long a) {
int count = 0;
while (a != 0) {
count++;
a = a & (a - 1);
}
return count;
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
long long Fib[] = {
0, 1, 1, 2, 3, 5,
8, 13, 21, 34, 55, 89,
144, 233, 377, 610, 987, 1597,
2584, 4181, 6765, 10946, 17711, 28657,
46368, 75025, 121393, 196418, 317811, 514229,
832040, 1346269, 2178309, 3524578, 5702887, 9227465,
14930352, 24157817, 39088169, 63245986, 102334155, 165580141,
267914296, 433494437, 701408733, 1134903170, 1836311903};
long long sum(long long n) { return (n * (n + 1)) / 2; }
long long rangesum(long long a, long long b) {
if (a <= 1) return sum(b);
return sum(b) - sum(a - 1);
}
bool isPowerOfTwo(int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
inline bool cmp(long long a, long long b) { return a > b; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool palindrome(string a) {
bool flag = 1;
int x = a.size();
for (int i = 0; i < x / 2; i++)
if (a[i] != a[x - i - 1]) {
flag = 0;
break;
}
return flag;
}
int get_dimensions(int x, int y) {
int a;
if (x > 0 && y > 0)
a = 1;
else if (x < 0 && y > 0)
a = 2;
else if (x < 0 && y < 0)
a = 3;
else if (x > 0 && y < 0)
a = 4;
else
a = 0;
return a;
}
long long fastpower(long long x, long long power) {
if (!power) return 1;
if (power == 1) return x;
if (power % 2) return (x * fastpower(x, power - 1));
long long result = fastpower(x, power / 2);
return result;
}
long long lim = (long long)1e16;
int n;
long long k, s, wyn;
map<long long, int> mapa;
int main() {
cin >> n >> k;
mapa[0]++;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
s += x;
mapa[s]++;
long long t = 1;
while (t <= lim) {
wyn += mapa[s - t];
t *= k;
if (t == 1) break;
}
}
cout << wyn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long arr[n + 1];
arr[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
long long ans = 0;
if (k == 1) {
map<long long, int> mp;
for (int i = n; i >= 0; i--) {
mp[arr[i]]++;
long long c = 1;
if (mp.find(arr[i] + c) != mp.end()) {
ans += mp[arr[i] + c];
}
}
} else if (k == -1) {
map<long long, int> mp;
for (int i = n; i >= 0; i--) {
mp[arr[i]]++;
long long c = 1;
if (mp.find(arr[i] + c) != mp.end()) {
ans += mp[arr[i] + c];
}
if (mp.find(arr[i] - c) != mp.end()) {
ans += mp[arr[i] - c];
}
}
} else {
map<long long, int> mp;
for (int i = n; i >= 0; i--) {
long long c = 1;
mp[arr[i]]++;
while (true) {
if (abs(c) >= 10e15) {
break;
}
if (mp.find(arr[i] + c) != mp.end()) {
ans += mp[arr[i] + c];
}
c *= k;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 9;
const int mod = 998244353;
int a[maxn];
map<long long, int> mp;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
long long ans = 0, sum = 0;
mp[0] = 1;
for (int i = 0; i < n; i++) {
sum += a[i];
mp[sum]++;
if (m == 1)
ans += mp[sum - 1];
else if (m == -1)
ans += mp[sum - 1] + mp[sum + 1];
else {
for (long long j = 1; j <= 1e14; j *= m) ans += mp[sum - j];
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e14;
vector<long long> sum;
map<long long, int> mp;
int main() {
ios::sync_with_stdio(false);
int n, k;
long long x, res = 0, p;
cin >> n >> k;
sum.assign(n + 1, 0);
for (int i = 1; i <= n; ++i) {
cin >> x;
sum[i] = sum[i - 1] + x;
}
mp[0] = 1;
if (abs(k) == 1) {
for (int i = 1; i <= n; ++i) {
x = sum[i] - 1;
res += mp[x];
if (k == -1) {
x = sum[i] + 1;
res += mp[x];
}
++mp[sum[i]];
}
cout << res << '\n';
} else {
for (int i = 1; i <= n; ++i) {
for (p = 1; abs(p) <= inf; p *= k) {
x = sum[i] - p;
res += mp[x];
}
++mp[sum[i]];
}
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long power(long long x, int y) {
long long res = 1;
x = x % mod;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
int modInverse(long long a) { return power(a, mod - 2); }
long long factmod(long long a) {
long long val = 1;
while (a > 0) {
val = (val * a) % mod;
a--;
}
return val;
}
long long int findSubarraySum(long long int arr[], int n, long long int sum) {
map<long long int, long long int> prevSum;
long long int res = 0;
long long int currsum = 0;
for (int i = 0; i < n; i++) {
currsum += arr[i];
if (currsum == sum) res++;
if (prevSum.find(currsum - sum) != prevSum.end())
res += (prevSum[currsum - sum]);
prevSum[currsum]++;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, i;
long long int k, p, ans, s = 0;
cin >> n >> k;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i], s += abs(a[i]);
if (k == 1)
ans = findSubarraySum(a, n, (long long int)1);
else if (k == -1) {
ans = findSubarraySum(a, n, (long long int)1);
ans += findSubarraySum(a, n, (long long int)-1);
} else {
ans = findSubarraySum(a, n, (long long int)1);
p = k;
while (abs(p) <= s) {
ans += findSubarraySum(a, n, p);
p *= k;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
long long n, k;
scanf("%I64d %I64d", &n, &k);
long long power[100], num = 0;
if (k != 1 && k != -1)
for (long long i = 1; i < 1e16 && i > -1e16; i *= k, num++) power[num] = i;
else if (k == 1) {
power[0] = 1;
num = 1;
} else if (k == -1) {
power[0] = 1;
power[1] = -1;
num = 2;
}
long long a[500005];
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
map<long long, int> m;
m[0] = 1;
long long sum = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
for (int j = 0; j < num; j++) ans += m[sum - power[j]];
m[sum]++;
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3fLL;
const double err = 1e-9;
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
ll n, k;
set<ll> powers;
map<ll, ll> back;
ll pref[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> k;
ll v = 1;
powers.insert(k);
powers.insert(1);
if (abs(k) != 1)
while (llabs(v) <= 1e15) v *= k, powers.insert(v);
ll ans = 0;
ll x;
ll sum = 0;
for (int(i) = (0); (i) < (n); (i)++) {
cin >> x;
sum += x;
pref[i + 1] = sum;
}
back[0]++;
for (int(i) = (1); (i) < (n + 1); (i)++) {
for (auto a : powers) ans += back[pref[i] - a];
back[pref[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long nop = 100;
vector<int> primes(nop, 1);
long long cnt = 0;
void sieve() {
primes[1] = primes[0] = 0;
for (long long i = 2; i * i <= nop; i++) {
if (primes[i]) {
for (long long j = i * i; j <= nop; j += i) {
primes[j] = 0;
}
}
}
}
bool isVowel(char ch) {
ch = tolower(ch);
return (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u');
}
long long gcd(long long a, long long b) {
if (b > a) swap(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
void extgcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = a;
y = b;
return;
}
extgcd(b % a, a, x, y);
long long y1 = y, x1 = x;
x = y1 - (b / a) * x1;
y = x1;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long bexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans *= num;
}
num *= num;
e >>= 1;
}
return ans;
}
long long mexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans = (ans * num) % mod;
}
num = (num * num) % mod;
e >>= 1;
}
return ans % mod;
}
long long modinv(long long a) { return bexp(a, mod - 2); }
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n + 1, 0);
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
a[i] += a[i - 1];
}
map<long long, long long> cnt;
long long ans = 0;
if (k == 1) {
for (long long i = n; i >= 0; i--) {
if (cnt.find(a[i] + 1) != cnt.end()) {
ans += cnt[a[i] + 1];
}
cnt[a[i]]++;
}
}
if (k == -1) {
for (long long i = n; i >= 0; i--) {
if (cnt.find(a[i] + 1) != cnt.end()) {
ans += cnt[a[i] + 1];
}
if (cnt.find(a[i] - 1) != cnt.end()) {
ans += cnt[a[i] - 1];
}
cnt[a[i]]++;
}
} else {
long long lg = ceil(log(1e14) / log(abs(k)));
vector<long long> power(lg + 1, 1);
for (long long i = 1; i <= lg; i++) {
power[i] = power[i - 1] * k;
}
for (long long i = n; i >= 0; i--) {
for (long long j = 0; j < lg + 1; j++) {
if (cnt.find(a[i] + power[j]) != cnt.end()) {
ans += cnt[a[i] + power[j]];
}
}
cnt[a[i]]++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long INF = 1e17;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k;
cin >> n >> k;
vector<long long> nums(1, 1);
if (k == -1) {
nums.push_back(-1);
} else if (k != 1) {
while (nums.back() <= (long long)1e14 && nums.back() >= -1e14) {
nums.push_back(nums.back() * k);
}
}
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i) a[i] += a[i - 1];
}
map<long long, int> cnt;
cnt[0] = 1;
long long ans = 0;
for (int i = 0; i < n; i++) {
for (auto num : nums) {
if (cnt.count(num - a[i])) ans += cnt[num - a[i]];
}
cnt[-a[i]]++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[9] = {0, 1, -1, 0, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, 0, -1, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
const int N = 1e5 + 100;
long long pre[N], a[N], temp[200], ans = 0;
int n, k, ma = 0;
map<long long, long long> dic;
int main() {
scanf("%d", &n), scanf("%d", &k);
long long t = 1;
temp[0] = 1;
if (k == 1 || k == -1) {
if (k == 1) {
ma = 0;
temp[0] = 1;
} else {
ma = 1;
temp[0] = 1;
temp[1] = -1;
}
} else {
while (abs(t * k) < 1e15) {
ma++;
t = t * k;
temp[ma] = t;
}
}
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 0; i <= ma; i++) dic[temp[i] + 0]++;
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
ans += dic[pre[i]];
for (int j = 0; j <= ma; j++) dic[pre[i] + temp[j]]++;
}
printf("%lld\n", ans);
return 0;
}
|
#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++;
for (long long int i = 0; i < n; i++) {
c += a[i];
if (c == p) ans++;
ans += h[c - p];
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;
long long mx = 1e14;
map<long long, long long> mp;
long long arr[100007], sum[1000007];
long long P[70];
int lim;
void init(long long x) {
P[0] = 1;
lim = 0;
if (x == -1) {
P[1] = -1;
lim = 1;
return;
}
if (x == 1) return;
for (int i = 1; i <= 60; i++) {
if (llabs(P[i - 1]) >= mx) break;
P[i] = P[i - 1] * x;
lim = i;
}
}
int main() {
int n, k;
cin >> n >> k;
init(k);
for (int i = 1; i <= n; i++) cin >> arr[i], sum[i] = sum[i - 1] + arr[i];
long long ans = 0;
for (int i = n; i >= 1; i--) {
mp[sum[i]]++;
for (int j = 0; j <= lim; j++) ans += mp[P[j] + sum[i - 1]];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const int maxn = (int)1e5 + 7;
vector<long long> pre;
int a[maxn];
long long sum[maxn];
long long pow(int a, int b) {
long long res = 1;
for (int i = 1; i <= b; i++) res *= a;
return res;
}
int main() {
pre.clear();
int n, k;
long long lim = (long long)1e15 + 7;
cin >> n >> k;
if (k == 1)
pre.push_back(1);
else if (k == -1) {
pre.push_back(1);
pre.push_back(-1);
} else {
for (int i = 0;; i++) {
long long tmp = pow(k, i);
if (abs(tmp) > lim) break;
pre.push_back(tmp);
}
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sum[0] = 0;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + (long long)a[i];
map<long long, int> ma;
ma.clear();
long long ans = 0;
ma.insert(make_pair(0, 1));
for (int i = 1; i <= n; i++) {
for (int j = (0); j < ((int)(pre).size()); ++j) {
long long tmp = sum[i] - pre[j];
if (ma.count(tmp)) ans += (long long)ma[tmp];
}
if (ma.count(sum[i]))
ma[sum[i]]++;
else
ma.insert(make_pair(sum[i], 1));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
const long long INF = 1000ll * 1000ll * 1000ll * 1000ll * 1000ll;
const int MAXN = 200001;
pair<long long, int> sm[MAXN];
long long a[MAXN];
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
sm[0] = make_pair(0, 0);
a[0] = 0;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
sm[i + 1] = make_pair(sm[i].first + b, i + 1);
a[i + 1] = sm[i + 1].first;
}
sort(sm, sm + n + 1);
long long cur = 1;
long long ans = 0;
while (abs(cur) < INF) {
for (int i = 1; i <= n; i++) {
long long nd = a[i] - cur;
ans += lower_bound(sm, sm + n + 1, make_pair(nd, i)) -
lower_bound(sm, sm + n + 1, make_pair(nd, 0));
}
if ((cur == k) && (abs(k) == 1)) break;
cur *= k;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005], sum[100005];
map<long long, long long> M;
int main() {
int n;
long long k;
cin >> n >> k;
long long p = 1;
long long maxx = 10000000000000000LL, minn = -10000000000LL;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
M[sum[i]]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long x = 0, g = 1;
p = 1;
while ((abs(p) <= maxx) && g) {
x = sum[i - 1] + p;
ans += M[x];
p = p * k;
g++;
if (k == 1) {
g = 0;
} else if (k == -1) {
if (g == 3) {
g = 0;
}
}
}
M[sum[i]]--;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 5;
const long long INF = 1e14 + 5;
int n, k;
long long ans;
int box[MaxN];
map<long long, int> cont;
map<long long, bool> vis;
int main() {
while (~scanf("%d %d", &n, &k)) {
for (int i = 1; i <= n; i++) scanf("%d", &box[i]);
for (long long i = 1; !vis[i] && abs(i) <= INF; i *= k) {
vis[i] = 1;
cont.clear();
cont[0] = 1;
long long sum = 0;
for (int j = 1; j <= n; j++) {
sum += box[j];
ans += cont[sum - i];
cont[sum]++;
}
}
printf("%I64d\n", ans);
vis.clear();
cont.clear();
ans = 0;
memset(box, 0, sizeof(box));
}
return 0;
}
|
#include <bits/stdc++.h>
void init() { freopen("a.in", "r", stdin); }
using namespace std;
long long a[300000];
void solve() {
long long n, k;
map<long long, long long> z;
long long ans = 0;
cin >> n >> k;
vector<long long> st;
st.push_back(1);
if (k == -1) st.push_back(-1);
if (k != 1 && k != -1) {
st.push_back(k);
long long kk = k;
while (kk <= 1e14 + 41) {
kk *= k;
st.push_back(kk);
}
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long s = 0;
for (int i = 0; i < n; i++) {
s += a[i];
for (int j = 0; j < (int)st.size(); j++) {
if (s == st[j]) ans++;
long long diff = s - st[j];
ans += z[diff];
}
z[s]++;
}
cout << ans;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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);
}
};
long long a[100005] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
long long ans = 0;
unordered_map<long long, int, custom_hash> mp;
mp[0] = 1;
for (int i = 1; i <= n; i++) {
if (k == 1) {
if (mp.find(a[i] - 1) != mp.end()) {
ans += mp[a[i] - 1];
}
} else if (k == -1) {
if (mp.find(a[i] + 1) != mp.end()) {
ans += mp[a[i] + 1];
}
if (mp.find(a[i] - 1) != mp.end()) {
ans += mp[a[i] - 1];
}
} else {
long long p = 1;
while (p <= 1e15) {
if (mp.find(a[i] - p) != mp.end()) {
ans += mp[a[i] - p];
}
p *= k;
}
}
mp[a[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 123;
long long sum[N];
set<long long> s;
map<long long, long long> m;
int main() {
ios::sync_with_stdio(false);
long long n, k, ans = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> sum[i], sum[i] += sum[i - 1];
s.insert(1);
long long tmp = k;
for (int i = 1; i <= 60; i++) {
if (tmp > 1e14) break;
s.insert(tmp);
tmp *= k;
}
m[0] = 1;
for (int i = 1; i <= n; i++) {
for (auto x : s) {
ans += m[sum[i] - x];
}
m[sum[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int prefix[100010], n, x;
vector<long long int> powers;
long long int A[100010];
long long int fun() {
prefix[0] = 0;
for (int i = 1; i <= n; i++) prefix[i] = prefix[i - 1] + A[i - 1];
long long int k = 1;
powers.push_back(1);
if (x == -1) {
powers.push_back(-1);
} else if (x != 1) {
while (*powers.rbegin() <= 1e15) powers.push_back(*powers.rbegin() * x);
}
map<long long int, int> rt;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
if (rt.find(prefix[i - 1]) != rt.end()) {
int x = rt.find(prefix[i - 1])->second;
rt.erase(rt.find(prefix[i - 1]));
rt[prefix[i - 1]] = x + 1;
} else
rt[prefix[i - 1]] = 1;
for (auto d : powers) {
if (rt.find(prefix[i] - d) != rt.end())
ans += rt.find(prefix[i] - d)->second;
}
}
return ans;
}
int main() {
cin >> n >> x;
for (int i = 0; i < n; i++) cin >> A[i];
cout << fun() << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, x;
bool compb(char a, char b) { return a > b; }
bool compm(char a, char b) { return a < b; }
int main() {
cin >> n >> k;
vector<long long> mas(n + 1, 0);
map<long long, long long> ma;
ma[0]++;
long long res = 0;
for (long long i = 1; i <= n; i++) {
cin >> mas[i];
mas[i] += mas[i - 1];
if (k == 1)
res += ma[mas[i] - 1];
else if (k == -1)
res += ma[mas[i] - 1] + ma[mas[i] + 1];
else {
long long ex = 1;
while (ex <= 1e15) {
res += ma[mas[i] - ex];
ex *= k;
}
}
ma[mas[i]]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int arr[n];
long long int sum[n];
sum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
sum[i] = sum[i - 1] + arr[i];
}
vector<long long int> v;
long long int p = 1;
if (k == 1)
v.push_back(1);
else if (k == -1) {
v.push_back(1);
v.push_back(-1);
} else {
while (abs(p) < 2e15) {
v.push_back(p);
p *= k;
}
}
map<long long int, long long int> ma;
long long int ans = 0;
for (int j = 1; j <= n; j++) {
for (int i = 0; i < v.size(); i++) {
ma[v[i] + sum[j - 1]]++;
}
ans += ma[sum[j]];
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const long long INF = 1e14;
long long sum[N];
set<long long> s;
set<long long>::iterator ss;
map<long long, int> m;
int main() {
int n, k;
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
sum[i] = sum[i - 1] + x;
}
if (k == 1) {
s.insert(1);
} else if (k == -1) {
s.insert(1);
s.insert(-1);
} else {
s.insert(1);
long long t = k;
for (int i = 1; i <= 60; i++) {
if (t > INF) break;
s.insert(t);
t = t * k;
}
}
long long ans = 0;
m.clear();
m[0] = 1;
for (int i = 1; i <= n; i++) {
for (ss = s.begin(); ss != s.end(); ss++) {
ans += m[sum[i] - *ss];
}
m[sum[i]]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, INF = 1e15;
long long n, k, a[N], dp[N], x, ans;
vector<long long> v;
inline long long sum(long long k) {
long long res = 0;
map<long long, long long> mp;
for (long long i = 1; i <= n; i++) {
res += mp[dp[i] - k];
if (dp[i] == k) res++;
mp[dp[i]]++;
}
return res;
}
int main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
dp[i] = dp[i - 1] + a[i];
}
v.push_back(1);
if (k == -1)
v.push_back(-1);
else if (k != 1) {
x = k;
while (k < INF) {
v.push_back(k);
k *= x;
}
}
for (long long i = 0; i < v.size(); i++) ans += sum(v[i]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long SolutionForP(const vector<long long>& data, long long p) {
long long res = 0;
map<long long, long long> m;
m[0] = 1;
for (int i = 1; i < data.size(); ++i) {
res += m[data[i] - p];
++m[data[i]];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<long long> data(n), p(n + 1);
p[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> data[i];
p[i + 1] = p[i] + data[i];
}
long long step = 1;
long long MaxStep = 54;
if (k == -1) {
MaxStep = 2;
}
if (k == 1) {
MaxStep = 1;
}
long long ans = 0;
while (MaxStep && step < 100000000000009) {
--MaxStep;
ans += SolutionForP(p, step);
step = k * step;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 100007;
const long long MAX = 1e15 + 7;
int n, k;
int a[MAXN];
long long s[MAXN];
map<long long, int> mp;
void init();
void input();
void work();
long long check(long long tst);
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
}
void work() {
s[0] = 0;
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i];
long long ans = 0;
if (k == 1)
ans = check(1);
else if (k == -1)
ans = check(1) + check(-1);
else {
long long nv = 1;
while ((((nv) >= 0) ? (nv) : (-(nv))) < MAX) {
ans += check(nv);
nv *= k;
}
}
printf("%I64d\n", ans);
}
long long check(long long tst) {
long long ans = 0;
mp.clear();
for (int i = n - 1; i >= 0; --i) {
++mp[s[i + 1]];
ans += mp[s[i] + tst];
}
return ans;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> M;
void syn() {
ios_base::sync_with_stdio(false);
cin.tie(0);
}
int main() {
long long n, k, MAX = 0, s, c = 0, i, w;
syn();
cin >> n >> k;
vector<long long> A(n);
for (i = 0; i < n; i++) {
cin >> A[i];
MAX += abs(A[i]);
}
if (k == 1) {
s = 0;
w = 1;
M[0] = 1;
for (i = 0; i < n; i++) {
s += A[i];
long long x = s - w;
c += M[x];
M[s]++;
}
} else if (k == -1) {
s = 0;
w = 1;
M[0] = 1;
for (i = 0; i < n; i++) {
s += A[i];
long long x = s - w;
if (M.find(x) != M.end()) c += M[x];
x = s + w;
if (M.find(x) != M.end()) c += M[x];
M[s]++;
}
} else {
s = 0;
M[0] = 1;
for (i = 0; i < n; i++) {
s += A[i];
for (w = 1; abs(w) <= MAX; w *= k) {
long long x = s - w;
if (M.find(x) != M.end()) c += M[x];
}
M[s]++;
}
}
cout << c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
long long n, k, a[MAXN], sum[MAXN], maxa, ans = 0;
map<long long, long long> cnt;
int main() {
scanf("%lld%lld", &n, &k);
maxa = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
maxa = abs(a[i]) > maxa ? abs(a[i]) : maxa;
}
sum[0] = 0;
for (long long i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (long long cur = 1; abs(cur) <= n * maxa; cur *= k) {
cnt.clear();
cnt[0] = 1;
for (long long i = 1; i <= n; i++) {
if (cnt.count(sum[i]))
cnt[sum[i]]++;
else
cnt[sum[i]] = 1;
if (cnt.count(sum[i] - cur)) ans += cnt[sum[i] - cur];
}
if (cur * k == 1) break;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn];
map<long long, int> ma;
int main() {
long long k, times = 0, m;
int n;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long temp = 1;
long long ans = 0;
while (temp <= 1e14 && temp >= -1e14) {
ma.clear();
ma[0] = 1;
long long pre = 0;
for (int i = 1; i <= n; i++) {
pre += a[i];
ans += ma[pre - temp];
ma[pre]++;
}
temp *= k;
if (k == -1 && temp == 1) break;
if (k == 1) break;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
int n;
long long k, ans, x;
map<long long, int> mp;
int main() {
scanf("%d", &n);
scanf("%lld", &k);
ans = 0;
mp[0] = 1;
long long acc = 0;
for (int i = 1; i < (int)n + 1; i++) {
scanf("%lld", &x);
acc += x;
for (long long pot = 1, j = 0; abs(pot) <= 1e14; pot *= k, j++) {
if ((k == 1 && j == 1) || (k == -1 && j == 2)) break;
ans += mp[acc - pot];
}
mp[acc]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
long long v[100100];
map<long long, vector<int> > id;
int main() {
int n;
long long k;
cin >> n >> k;
v[0] = 0LL;
for (int i = 1; i <= n; i++) {
cin >> v[i];
v[i] += v[i - 1];
}
for (int i = 0; i <= n; i++) {
id[v[i]].push_back(i);
}
long long cnt = 0;
for (int i = 0; i <= n; i++) {
if (k == -1) {
long long x = 1LL;
if (id.find(v[i] - x) != id.end()) {
cnt += lower_bound(id[v[i] - x].begin(), id[v[i] - x].end(), i) -
id[v[i] - x].begin();
}
x = -1LL;
if (id.find(v[i] - x) != id.end()) {
cnt += lower_bound(id[v[i] - x].begin(), id[v[i] - x].end(), i) -
id[v[i] - x].begin();
}
} else if (k == 1) {
long long x = 1LL;
if (id.find(v[i] - x) != id.end()) {
cnt += lower_bound(id[v[i] - x].begin(), id[v[i] - x].end(), i) -
id[v[i] - x].begin();
}
} else {
for (long long x = 1LL; abs(x) < 1000000000000000LL; x *= k) {
if (id.find(v[i] - x) != id.end()) {
cnt += lower_bound(id[v[i] - x].begin(), id[v[i] - x].end(), i) -
id[v[i] - x].begin();
}
}
}
}
cout << cnt << "\n";
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 1e5 + 5;
map<long long, int> mp;
long long sum[maxn], ans;
int n, k;
void solve() {
long long maxx = 0, minn = 0;
scanf("%d%d", &n, &k);
mp[0] = 1;
for (int i = 1; i <= n; i++) {
long long tmp;
scanf("%I64d", &tmp);
sum[i] = sum[i - 1] + tmp;
mp[sum[i]]++;
maxx = max(maxx, sum[i]);
minn = min(minn, sum[i]);
for (long long j = 1; - 1e15 <= j && j <= 1e15; j *= k) {
if (mp.find(sum[i] - j) != mp.end()) {
ans += mp[sum[i] - j];
}
if (k == 1) break;
if (j == -1 && k == -1) break;
}
}
printf("%I64d\n", ans);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> a(n + 1);
a[0] = 0;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
if (abs(k) != 1) {
long long int ans = 0;
map<long long int, long long int> mp;
for (long long int i = n; i >= 0; i--) {
long long int pow = 1;
while (abs(pow) <= 1e15) {
ans += mp[pow + a[i]];
pow *= k;
}
mp[a[i]]++;
}
cout << ans;
return;
}
if (k == 1) {
long long int ans = 0;
map<long long int, long long int> mp;
for (long long int i = n; i >= 0; i--) {
ans += mp[1 + a[i]];
mp[a[i]]++;
}
cout << ans;
return;
}
if (k == -1) {
long long int ans = 0;
map<long long int, long long int> mp;
for (long long int i = n; i >= 0; i--) {
ans += mp[1 + a[i]];
ans += mp[-1 + a[i]];
mp[a[i]]++;
}
cout << ans;
return;
}
}
signed main() {
ios::sync_with_stdio(false);
long long int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
return os << "(" << v.first << ", " << v.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = int(0); i <= int((static_cast<int>((v).size())) - 1); ++i) {
if (i) os << ", ";
os << v[i];
}
return os << "]";
}
template <class T>
bool setmax(T& _a, T _b) {
if (_a < _b) {
_a = _b;
return true;
}
return false;
}
template <class T>
bool setmin(T& _a, T _b) {
if (_b < _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
T gcd(T _a, T _b) {
return _b == 0 ? _a : gcd(_b, _a % _b);
}
vector<int> read_vi(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<int> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%d", &a[i]);
return a;
}
vector<long long> read_vl(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<long long> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%lld", &a[i]);
return a;
}
vector<double> read_vd(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<double> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%lf", &a[i]);
return a;
}
vector<pair<int, int> > read_vpi(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<int, int> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%d%d", &a[i].first, &a[i].second);
return a;
}
vector<pair<long long, long long> > read_vpl(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<long long, long long> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%lld%lld", &a[i].first, &a[i].second);
return a;
}
vector<pair<double, double> > read_vpd(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<double, double> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%lf%lf", &a[i].first, &a[i].second);
return a;
}
inline long long powmod(long long a, long long b, long long m) {
long long r = 1;
for (; b > 0; b >>= 1, a = a * a % m) {
if (b & 1) r = r * a % m;
}
return r;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<long long> a = read_vl(n);
long long ans = 0;
vector<long long> ss;
ss.push_back(0);
for (long long x : a) ss.push_back(ss.back() + x);
sort((ss).begin(), (ss).end());
ss.erase(unique((ss).begin(), (ss).end()), ss.end());
const auto index = [&](long long s) {
auto it = lower_bound((ss).begin(), (ss).end(), s);
if (it == ss.end() || *it != s) return -1;
return int(it - ss.begin());
};
vector<long long> c(static_cast<int>((ss).size()));
c[index(0)] = 1;
long long s = 0, sa = 0;
for (long long x : a) {
s += x, sa += abs(x);
for (long long p = 1; abs(p) <= sa; p *= k) {
int i = index(s - p);
if (i >= 0) ans += c[i];
if (k == 1 || (k == -1 && p == -1)) break;
}
c[index(s)]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace fastinput {
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 16384;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = (char)('0' + x % 10), x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
} // namespace fastinput
using namespace fastinput;
const long long INF = 1e16;
map<long long, int> sums;
vector<long long> vals;
int main() {
int n = readInt(), k = readInt();
vals.push_back(1);
if (abs(k) != 1) {
while (abs(vals.back()) < INF) vals.push_back(vals.back() * k);
}
if (k == -1) vals.push_back(k);
sums[0] = 1;
long long pref = 0;
long long res = 0;
for (int i = 0; i < n; ++i) {
int x = readInt();
pref += x;
for (auto y : vals)
if (sums.count(pref - y)) res += sums[pref - y];
++sums[pref];
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long SIZE = 1000001;
const int INF = 0x3f3f3f3f;
const long long ll_INF = 0x3f3f3f3f3f3f3f3f;
const long double PI = acos(-1);
const long long MAXN = numeric_limits<long long>::max();
const long long MAX = 90000000;
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> v(n), pref(n);
cin >> v[0];
pref[0] = v[0];
for (long long i = 1; i < n; i++) {
cin >> v[i];
pref[i] = pref[i - 1] + v[i];
}
long long maxi = 1, ans = 0, ct = 0;
while (maxi <= 1e14) {
if (k == 1 and ct == 1)
break;
else if (k == -1 and ct == 2)
break;
map<long long, long long> make_pair;
make_pair[0]++;
for (long long i = 0; i < n; i++) {
ans += make_pair[pref[i] - maxi];
make_pair[pref[i]]++;
}
maxi *= k;
ct++;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
int j = 1;
while (t--) {
solve();
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int size1 = 4e5;
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
long long k, i, j;
cin >> n >> k;
static long long mas[size1];
for (i = 1; i <= n; i++) {
cin >> mas[i];
}
static long long sum[size1];
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + mas[i];
}
static long long deg[size1];
int len = 0;
deg[0] = 1;
while (true) {
if (k == 1) {
len = 0;
break;
}
if (k == -1) {
len = 1;
deg[1] = -1;
break;
}
deg[len + 1] = deg[len] * k;
if (abs(deg[len + 1]) <= 1000000000000000LL + 500) {
len++;
} else {
break;
}
}
len++;
long long ans = 0;
for (i = 1; i <= n; i++) {
bool res = false;
for (j = 0; j < len; j++) {
if (sum[i] == deg[j]) {
res = true;
}
}
if (res) {
ans++;
}
}
map<long long, int> map1;
for (i = 1; i <= n; i++) {
if (!map1.count(sum[i])) {
map1[sum[i]] = 1;
} else {
map1[sum[i]]++;
}
}
long long per = 0;
for (i = 2; i <= n; i++) {
per += mas[i - 1];
map1[sum[i - 1]]--;
for (j = 0; j < len; j++) {
ans += map1[per + deg[j]];
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)1e5 + 111;
const int INF = (int)1e9 + 111;
long long pref[Z], a[111];
int main() {
ios_base::sync_with_stdio(false);
long long x, ans = 0, pak = (long long)-INF * INF;
int n, k, s = 1;
cin >> n >> k;
a[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> x;
pref[i] = pref[i - 1] + x;
pak = max(pak, abs(pref[i]));
}
x = k;
if (k != 1 && k != -1) {
for (; abs(x) <= pak * 2; x *= k) a[s++] = x;
} else {
s = 1;
if (k == -1) {
a[1] = -1;
s = 2;
}
}
x = 1;
map<long long, int> mp;
mp[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < s; j++) {
ans += mp[pref[i] - a[j]];
}
mp[pref[i]]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T, typename TT>
inline ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &t) {
for (auto i : t) os << i.first << " : " << i.second << '\n';
return os;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v) is >> t.first >> t.second;
return is;
}
const long long mod = 1e9 + 7;
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
cin >> v;
map<long long, long long> m;
m[0] = 1;
vector<long long> pw = {1};
if (k == -1)
pw.push_back(-1);
else if (abs(k) != 1)
while (pw.back() * k < 1e15) pw.push_back(pw.back() * k);
long long pre = 0, ans = 0;
for (int i = 0; i < n; i++) {
pre += v[i];
for (int j = 0; j < pw.size(); j++) {
if (m.find(pre - pw[j]) != m.end()) ans += m[pre - pw[j]];
}
m[pre]++;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
array<int, N> a;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
long long power = 1;
while (abs(power) < 1e15) {
map<long long, int> m;
m[0] = 1;
long long sum = 0ll;
for (int i = 0; i < n; i++) {
sum += a[i];
ans += m[sum - power];
m[sum]++;
}
power *= k;
if (power == 1) break;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
return os << "(" << v.first << ", " << v.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = int(0); i <= int((static_cast<int>((v).size())) - 1); ++i) {
if (i) os << ", ";
os << v[i];
}
return os << "]";
}
template <class T>
bool setmax(T& _a, T _b) {
if (_a < _b) {
_a = _b;
return true;
}
return false;
}
template <class T>
bool setmin(T& _a, T _b) {
if (_b < _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
T gcd(T _a, T _b) {
return _b == 0 ? _a : gcd(_b, _a % _b);
}
vector<int> read_vi(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<int> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%d", &a[i]);
return a;
}
vector<long long> read_vl(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<long long> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%lld", &a[i]);
return a;
}
vector<double> read_vd(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<double> a(n);
for (int i = int(0); i <= int((n)-1); ++i) scanf("%lf", &a[i]);
return a;
}
vector<pair<int, int> > read_vpi(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<int, int> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%d%d", &a[i].first, &a[i].second);
return a;
}
vector<pair<long long, long long> > read_vpl(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<long long, long long> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%lld%lld", &a[i].first, &a[i].second);
return a;
}
vector<pair<double, double> > read_vpd(int n = -1) {
if (n < 0) scanf("%d", &n);
vector<pair<double, double> > a(n);
for (int i = int(0); i <= int((n)-1); ++i)
scanf("%lf%lf", &a[i].first, &a[i].second);
return a;
}
inline long long powmod(long long a, long long b, long long m) {
long long r = 1;
for (; b > 0; b >>= 1, a = a * a % m) {
if (b & 1) r = r * a % m;
}
return r;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<long long> a = read_vl(n);
long long sum = 0;
for (long long x : a) sum += abs(x);
long long ans = 0;
map<long long, int> c;
c[0] = 1;
long long s = 0;
for (long long x : a) {
s += x;
for (long long p = 1; abs(p) <= sum; p *= k) {
auto it = c.find(s - p);
if (it != c.end()) ans += it->second;
if (k == 1 || (k == -1 && p == -1)) break;
}
c[s]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1234567;
int n, k, a[maxn];
map<long long, int> f;
long long doit(long long k) {
long long ans = 0, sum = 0;
f.clear();
f[0] = 1;
for (int i = 1; i <= n; i++) {
sum += a[i];
ans += f[sum - k];
f[sum]++;
}
return ans;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long ans = 0;
if (k == 1)
ans = doit(1);
else if (k == -1)
ans = doit(1) + doit(-1);
else
for (long long len = 1; len <= 1e16; len *= k) ans += doit(len);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gtx() {
const int N = 1048576;
static char buffer[N];
static char *p = buffer, *end = buffer;
if (p == end) {
if ((end = buffer + fread(buffer, 1, N, stdin)) == buffer) return EOF;
p = buffer;
}
return *p++;
}
template <typename T>
inline bool rit(T& x) {
char __c = 0;
bool flag = false;
while (__c = getchar(), (__c < '0' && __c != '-') || __c > '9')
if (__c == -1) return false;
__c == '-' ? (flag = true, x = 0) : (x = __c - '0');
while (__c = getchar(), __c >= '0' && __c <= '9') x = x * 10 + __c - '0';
if (flag) x = -x;
return true;
}
template <typename T, typename... Args>
inline bool rit(T& x, Args&... args) {
return rit(x) && rit(args...);
}
const int maxn = 100000 + 5;
int n, k, a[maxn];
long long ans;
int main() {
rit(n, k);
for (int i = 0; i < n; ++i) rit(a[i]);
long long v = 1LL;
while (v <= 100000000000000LL) {
map<long long, int> m;
long long sum = 0;
++m[0];
for (int i = 0; i < n; ++i) {
sum += a[i];
++m[sum];
if (m.find(sum - v) != m.end()) ans += m[sum - v];
}
v *= k;
if (v == 1) break;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> Map;
int n, k, a[100005];
int main() {
scanf("%d%d", &n, &k);
long long sum = 0ll;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum = sum + (a[i] < 0 ? -a[i] : a[i]);
}
long long rem = 0ll, ans = 0ll;
Map[0] = 1;
for (int i = 1; i <= n; i++) {
long long tmp = 1ll;
rem += a[i];
for (int j = 0;; j++) {
if (tmp > sum || -tmp > sum) break;
ans += Map[rem - tmp];
if (tmp == 0 || k == 1) break;
if (k == -1 && j == 1) break;
tmp = tmp * k;
}
Map[rem]++;
}
printf("%I64d\n", 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++;
ans += (aux - x.begin());
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] += (i >= 1 ? a[i - 1] : 0);
}
long long result = 0;
for (long long p = 1; p <= (long long)1e14; p *= k) {
map<long long, int> numberCount;
for (int i = 0; i < n; i++) {
numberCount[a[i]]++;
}
result += numberCount[p];
for (int l = 1; l < n; l++) {
result += numberCount[a[l - 1] + p];
numberCount[a[l - 1]]--;
}
if (k == 1) break;
if (k == -1 && p == -1) break;
}
cout << result << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
FILE *fin, *fout;
int N, K;
vector<int> A;
vector<long long int> psum;
map<long long int, int> chk;
int main() {
scanf("%d %d", &N, &K);
A.resize(N);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
}
psum.resize(N);
for (int i = 0; i < N; i++) {
psum[i] = (long long int)A[i];
if (i != 0) psum[i] += psum[i - 1];
}
if (K == 1) {
chk[0] = 1;
long long int ans = 0;
for (int i = 0; i < N; i++) {
if (chk[psum[i] - 1]) ans += chk[psum[i] - 1];
chk[psum[i]]++;
}
printf("%I64d", ans);
return 0;
}
if (K == -1) {
chk[0] = 1;
long long int ans = 0;
for (int i = 0; i < N; i++) {
if (chk[psum[i] - 1]) ans += chk[psum[i] - 1];
chk[psum[i]]++;
}
chk.clear();
chk[0] = 1;
for (int i = 0; i < N; i++) {
if (chk[psum[i] + 1]) ans += chk[psum[i] + 1];
chk[psum[i]]++;
}
printf("%I64d", ans);
return 0;
}
long long int p = 1;
long long int ans = 0;
while (abs(p) <= 100000000000002) {
chk.clear();
chk[0] = 1;
for (int i = 0; i < N; i++) {
if (chk[psum[i] - p]) ans += chk[psum[i] - p];
chk[psum[i]]++;
}
p *= (long long int)K;
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[200000];
long long seg[200000];
map<long long, vector<int>> mapa;
vector<long long> veca;
int main() {
cin >> n >> k;
long long nowk = 1;
if (k != 1 && k != -1) {
while (abs(nowk) < 1000000000000000ll) {
veca.push_back(nowk);
nowk *= k;
}
} else {
veca.push_back(1);
if (k == -1) {
veca.push_back(-1);
}
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
seg[0] = a[0];
mapa[seg[0]].push_back(0);
for (int i = 1; i < n; i++) {
seg[i] = seg[i - 1] + a[i];
mapa[seg[i]].push_back(i);
}
long long ansa = 0;
for (long long nowk : veca) {
auto it = mapa.find(0 + nowk);
if (it != mapa.end()) {
auto it2 = upper_bound(it->second.begin(), it->second.end(), -1);
if (it->second.end() != it2) {
ansa += it->second.end() - it2;
}
}
}
for (int i = 0; i < n; i++) {
for (long long nowk : veca) {
auto it = mapa.find(seg[i] + nowk);
if (it != mapa.end()) {
auto it2 = upper_bound(it->second.begin(), it->second.end(), i);
if (it->second.end() != it2) {
ansa += it->second.end() - it2;
}
}
}
}
cout << ansa << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.