text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
vector<long long> a, pre, ev;
vector<vector<long long>> nxt;
long long n;
int32_t main() {
cin >> n;
a.resize(n);
pre.assign(n + 1, 0);
ev.assign(2, 0);
ev[0] = 1;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
a[i] = __builtin_popcountll(a[i]);
pre[i + 1] = pre[i] + a[i];
ev[pre[i + 1] % 2]++;
}
nxt.resize(n, vector<long long>(64, n));
auto c2 = [&](long long x) { return x * (x - 1) / 2; };
long long cnt = c2(ev[1]) + c2(ev[0]);
for (long long l = 0; l < n; ++l) {
long long su = 0, mx = 0;
for (long long r = l; r < min(n, l + 70); ++r) {
su += a[r];
mx = max(mx, a[r]);
if (su < 2LL * mx && su % 2 == 0) cnt--;
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000")
#pragma GCC target(arch = corie7 - acx)
#pragma GCC optimize(2)
using namespace std;
long long n, s1, s0, a[3000002], x, ans, s[3000002], sum;
long long lowbit(long long x) { return x & (-x); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
for (; x; x -= lowbit(x)) a[i]++;
}
for (long long i = n; i >= 1; i--) {
s[i] = s[i + 1] + a[i];
if (s[i] & 1)
ans += s1++;
else
ans += ++s0;
x = sum = 0;
for (long long j = i; j <= min(n, i + 61); j++) {
x = max(x, a[j]);
sum += a[j];
if (sum % 2 == 0 && x > sum / 2) ans--;
}
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<long long> a(n, 0);
vector<long long> pref(n + 1, 0);
vector<long long> dp(2, 0);
long long ans = 0;
for (int i = 0; (i) < n; ++(i)) {
long long ai;
cin >> ai;
bitset<64> bits(ai);
a[i] = bits.count();
pref[i + 1] = (pref[i] + a[i]) & 1;
}
for (int i = 1; i <= n; ++i) {
ans += dp[pref[i]];
dp[pref[i - 1]]++;
}
for (int r = 0; (r) < n; ++(r)) {
long long maxx = a[r];
long long su = a[r];
for (int l = r - 1; l >= max(0, r - 65); --l) {
maxx = max(maxx, a[l]);
su += a[l];
if (!(su & 1) && maxx * 2 > su) ans--;
if (su > 128) break;
}
}
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tests = 1;
for (int _ = 0; (_) < tests; ++(_)) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 3e5 + 5;
int a[N];
int sum[N];
int cnt[N][2];
int n;
int f(long long x) {
int res = 0;
for (; x; x /= 2) {
res += x % 2;
}
return res;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
long long x = read();
a[i] = f(x);
sum[i] = sum[i - 1] + a[i];
cnt[i][0] = cnt[i - 1][0];
cnt[i][1] = cnt[i - 1][1];
cnt[i][sum[i] % 2]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int MAX = 0;
for (int j = i; j <= i + 70 && j <= n; j++) {
MAX = max(MAX, a[j]);
if (2 * MAX <= sum[j] - sum[i - 1] && ((sum[j] - sum[i - 1]) % 2 == 0))
ans++;
}
if (i + 70 >= n) continue;
ans += cnt[n][sum[i - 1] % 2] - cnt[i + 70][sum[i - 1] % 2];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[(300010)], f[(70)], g[(70)], low[(300010)], high[(300010)];
int n;
int n1(long long x) {
int res = 0;
while (x) {
res++;
x -= x & -x;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
long long tmp;
scanf("%I64d", &tmp);
a[i] = n1(tmp);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int x = a[i];
for (int l = max(1, i - (64)); l < i; ++l) {
if (x < low[l]) {
low[l] = abs(x - low[l]);
} else if (x < high[l]) {
low[l] = (x ^ low[l]) & 1;
} else {
low[l] = x - high[l];
}
high[l] = x + high[l];
}
low[i] = high[i] = x;
if (i - (64) > 0) {
for (int j = 0; j <= (64); ++j) {
g[j] = 0;
}
for (int j = 0; j <= x; ++j) {
g[(j ^ x) & 1] += f[j];
}
for (int j = x + 1; j <= (64); ++j) {
g[j - x] += f[j];
}
g[low[i - (64)]]++;
for (int j = 0; j <= (64); ++j) {
f[j] = g[j];
}
}
if (i - (64) > 0) {
ans += f[0];
}
for (int j = max(1, i - (64) + 1); j <= i; ++j) {
ans += low[j] == 0;
}
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, nn, mm, ma, mb, h, r, l, i, j, ii, jj, x[1000001],
y[1000001], z, g, aa, bb, a, b, c, d, k, q, mod = 1e9 + 7;
vector<pair<long long, long long> > v[1000001];
vector<long long> vvv, vv;
queue<pair<long long, long long> > qq;
pair<long long, long long> p[1000001];
map<long long, long long> mp, mpp, mppp;
set<long long> se;
set<long long>::iterator it, itt;
string s, s1, s2;
char cc;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a;
while (a > 0) {
x[i] += a % 2;
a /= 2;
}
y[i] = x[i];
x[i] += x[i - 1];
if (i > 60) mp[x[i] % 2]++;
}
for (i = 1, j = 61; j <= n; i++, j++) {
z += mp[b % 2];
mp[x[j] % 2]--;
if (y[i] % 2 == 1) b++;
}
for (i = n; i > 1; i--) x[i] -= x[i - 1];
for (j = 1; j <= n; j++) {
m = 0;
a = 0;
for (i = j; i < j + 60 && i <= n; i++) {
a += x[i];
m = max(m, x[i]);
if (i > j && a >= m * 2 && a % 2 == 0) z++;
}
}
cout << z;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int N = 300001;
const int oo = 1e9;
int n;
long long a[N], pre[N], re, ro;
int cnt(long long u) {
int res = 0;
while (u) {
res += u % 2;
u /= 2;
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
a[i] = cnt(a[i]);
pre[i] = a[i] + pre[i - 1];
}
long long res = 0;
for (int i = 0; i <= n; ++i) {
res += pre[i] % 2 ? ro : re;
if (pre[i] % 2)
ro++;
else
re++;
}
for (int i = 1; i <= n; ++i) {
int mx = 0, sum = 0;
for (int j = i; j <= min(i + 62, n); ++j) {
mx = max(mx, (int)a[j]);
sum += a[j];
if (mx > sum - mx && sum % 2 == 0) {
res--;
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int getrnd(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
template <typename T1, typename T2>
bool relax(T1& a, const T2& b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
bool strain(T1& a, const T2& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
ll x;
cin >> x;
while (x) {
a[i] += x % 2;
x /= 2;
}
}
vector<int> sum(2, 0);
int s = 0;
sum[s] = 1;
ll ans = 0;
for (int i = 0; i < n; ++i) {
s += a[i];
ans += sum[s % 2];
int mx = a[i], temp = a[i];
for (int j = i - 1; j >= max(0, i - 64); --j) {
if (2 * mx > temp && temp % 2 == 0) {
--ans;
}
strain(mx, a[j]);
temp += a[j];
}
if (2 * mx > temp && temp % 2 == 0) {
--ans;
}
++sum[s % 2];
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
srand(time(0));
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int onecount[n];
memset(onecount, 0, sizeof(int) * n);
for (int i = 0; i < n; i++) {
while (arr[i] > 0) {
onecount[i] += (arr[i] % 2);
arr[i] /= 2;
}
}
int oddcount = 0;
int evencount = 0;
long long ans = 0;
int cumonecount[n + 1];
cumonecount[n] = 0;
int cum = 0;
for (int i = n - 1; i >= 0; i--) {
cum += onecount[i];
cumonecount[i] = cum;
}
for (int i = n - 2; i >= 0; i--) {
if (cumonecount[i + 2] % 2 == 0) {
evencount++;
} else {
oddcount++;
}
if (cumonecount[i] % 2 == 0) {
ans += evencount;
} else {
ans += oddcount;
}
}
for (int i = n - 1; i >= 0; i--) {
int sum = 0;
int max = 0;
for (int j = i; j < min(n, i + 62); j++) {
sum += onecount[j];
if (onecount[j] > max) max = onecount[j];
if (j > i && max > (sum - max)) {
if ((cumonecount[i] - cumonecount[j + 1]) % 2 == 0) {
ans--;
}
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300050], cnt[300050];
void read(long long &rem) {
rem = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') rem = rem * 10 + c - 48, c = getchar();
}
inline long long push(long long x) {
long long ans = 0;
for (int i = 0; (1ll << i) <= x; i++) ans += (x >> i) & 1;
return ans;
}
int main() {
long long output = 0, s = 0, d = 0;
long long n;
read(n);
for (int i = 1; i <= n; i++) {
long long x;
read(x);
a[i] = push(x);
long long ls = s, ld = d;
if (a[i] & 1)
cnt[i] = ld, d = ls + 1, s = ld;
else
cnt[i] += s, s++;
}
for (int i = 2; i <= n; i++) {
output += cnt[i];
long long k = a[i], ans = a[i];
for (int j = i - 1; j >= max(1, i - 70); j--) {
k = max(k, a[j]);
ans += a[j];
if ((!(ans & 1)) && k * 2 > ans) output--;
}
}
printf("%I64d", output);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n;
long long answer;
int a[maxn], cnt[2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
a[i] = __builtin_popcountll(x);
}
cnt[0] = 1;
int s = 0;
for (int i = n; i > 0; --i) {
int sum = 0, mx = 0, cur = 0;
for (int j = i; j <= n && j - i < 64; ++j) {
sum += a[j];
mx = max(mx, a[j]);
if (2 * mx > sum && sum % 2 == 0) cur--;
}
s += a[i];
cur += cnt[s % 2];
answer += cur;
cnt[s % 2]++;
}
cout << answer << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
const long long N = 3e5 + 43;
long long a[N];
long long pref[N][2];
inline void input() {
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
a[i] = __builtin_popcountll(a[i]);
}
pref[0][0] = 1;
long long sum = 0;
for (long long i = 1; i <= n; ++i) {
sum += a[i];
pref[i][0] = pref[i - 1][0];
pref[i][1] = pref[i - 1][1];
pref[i][sum % 2]++;
}
}
void solve() {
long long ans = 0;
long long sum = 0;
for (long long i = 1; i <= n; ++i) {
sum += a[i];
ans += pref[i - 1][sum % 2];
}
for (long long L = 1; L <= n; ++L) {
long long sum = 0, maxx = -1;
for (long long R = L; R <= min(n, L + 61); ++R) {
sum += a[R];
maxx = max(a[R], maxx);
if (maxx * 2 > sum && sum % 2 == 0) --ans;
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[(300010)], f[(800)], g[(800)], low[(300010)], high[(300010)];
int n;
int n1(long long x) {
int res = 0;
while (x) {
res++;
x -= x & -x;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
long long tmp;
scanf("%I64d", &tmp);
a[i] = n1(tmp);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int x = a[i];
for (int l = max(1, i - (700)); l < i; ++l) {
if (x < low[l]) {
low[l] = abs(x - low[l]);
} else if (x < high[l]) {
low[l] = (x ^ low[l]) & 1;
} else {
low[l] = x - high[l];
}
high[l] = x + high[l];
}
low[i] = high[i] = x;
if (i - (700) > 0) {
for (int j = 0; j <= (700); ++j) {
g[j] = 0;
}
for (int j = 0; j <= x; ++j) {
g[(j ^ x) & 1] += f[j];
}
for (int j = x + 1; j <= (700); ++j) {
g[j - x] += f[j];
}
g[low[i - (700)]]++;
for (int j = 0; j <= (700); ++j) {
f[j] = g[j];
}
}
if (i - (700) > 0) {
ans += f[0];
}
for (int j = max(1, i - (700) + 1); j <= i; ++j) {
ans += low[j] == 0;
}
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int get_num_one_bits(long long int num) {
long long int ans = 0;
while (num != 0) {
ans += (num % 2);
num = num / 2;
}
return ans;
}
int main() {
long long int n;
cin >> n;
vector<long long int> a(n + 1), b(n + 1), pref_sum(n + 1);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) b[i] = get_num_one_bits(a[i]);
for (int i = 1; i <= n; i++) pref_sum[i] = pref_sum[i - 1] + b[i];
vector<long long int> even_inds, odd_inds;
even_inds.clear();
odd_inds.clear();
for (int i = 0; i <= n; i++) {
if (pref_sum[i] % 2 == 0)
even_inds.push_back(i);
else
odd_inds.push_back(i);
}
long long int ans = 0;
vector<long long int> inds;
for (int p = 0; p <= 1; p++) {
if (p == 0)
inds = even_inds;
else
inds = odd_inds;
for (int l = 0; l < (long long int)inds.size() - 1; l++) {
int j = 1;
if (inds[l + 1] - inds[l] == 1) j++;
while (((l + j) < inds.size()) && (inds[l + j] - inds[l] <= 64)) {
int flag = 1;
long long int sum = pref_sum[inds[l + j]] - pref_sum[inds[l]];
for (int k = inds[l] + 1; k <= inds[l + j]; k++) {
if (b[k] > sum / 2) {
flag = 0;
break;
}
}
if (flag == 1) ans++;
j++;
}
long long int curr = l + j;
ans += (inds.size() - 1) - curr + 1;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void re(int &x) {
x = 0;
bool flag = false;
char c = getchar();
while (c < '0' || c > '9') {
flag = c == '-';
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ '0');
c = getchar();
}
if (flag) x = -x;
return;
}
int n;
int a[300010];
int cnt[2][300010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%I64d", &x);
while (x) {
if (x & 1) a[i]++;
x >>= 1;
}
}
cnt[0][0] = 1;
int now = 0;
long long ans = 0;
for (int i = 1; i <= n; i++) {
int sum = 0, notans = 0, nowmax = 0;
for (int j = i; j > 0 && i - j <= 64; j--) {
sum += a[j];
nowmax = max(a[j], nowmax);
if (sum % 2 == 0 && sum - nowmax < nowmax) notans++;
}
now += a[i];
ans += cnt[now & 1][i - 1] - notans;
cnt[0][i] += cnt[0][i - 1];
cnt[1][i] += cnt[1][i - 1];
cnt[now & 1][i]++;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> d(n);
for (int &i : d) {
long long a;
cin >> a;
i = __builtin_popcountll(a);
}
long long ans = 0;
int suf = 0;
vector<vector<int> > cnt(n + 1, vector<int>(2));
cnt[n][0] = 1;
for (int i = n - 1; i >= 0; i--) {
int second = 0, m = 0;
for (int j = i; j < min(n, i + 62); j++) {
second += d[j];
m = max(m, d[j]);
if (second % 2 == 0 && 2 * m > second) ans--;
}
suf += d[i];
ans += cnt[i + 1][suf & 1];
cnt[i][0] = cnt[i + 1][0];
cnt[i][1] = cnt[i + 1][1];
if (suf & 1) {
cnt[i][1]++;
} else {
cnt[i][0]++;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300010;
int a[MAX_N];
int n;
int cnt1[MAX_N];
int cnt2[MAX_N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
while (x > 0) {
if (x & 1) a[i]++;
x >>= 1;
}
}
int sum = 0;
sum += a[0];
if (a[0] % 2 == 1)
cnt1[0]++;
else
cnt2[0]++;
for (int i = 1; i < n; i++) {
sum += a[i];
cnt1[i] = cnt1[i - 1];
cnt2[i] = cnt2[i - 1];
if (sum % 2 == 1)
cnt1[i]++;
else
cnt2[i]++;
}
long long ans = 0;
sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
if (sum % 2 == 1)
ans += cnt1[i] - 1;
else
ans += cnt2[i];
}
for (int i = 0; i < n; i++) {
sum = 0;
int ma = 0;
for (int e = i; e < min(i + 62, n); e++) {
sum += a[e];
ma = max(ma, a[e]);
if (sum % 2 == 0 && sum < 2 * ma) ans--;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long ret = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
do {
ret = ret * 10 + c - '0';
c = getchar();
} while ('0' <= c && c <= '9');
return ret;
}
int n;
long long a[300100];
long long dp[2][300100], ans;
int main() {
long long tmp1;
int tmp2;
n = read();
for (int i = 1; i <= n; i++) {
tmp1 = read();
tmp2 = 0;
while (tmp1) {
tmp2 += (tmp1 & 1);
tmp1 >>= 1;
}
a[i] = tmp2;
}
long long fsum, fmax, add;
for (int i = 1; i <= n; i++) {
fsum = fmax = add = 0;
for (int j = i; j >= 1 && i - j < 64; j--) {
fsum += a[j];
fmax = max(fmax, a[j]);
if (fmax > fsum - fmax && fsum % 2 == 0) add--;
}
if (a[i] & 1) {
dp[0][i] = dp[1][i - 1];
dp[1][i] = dp[0][i - 1] + 1;
} else {
dp[0][i] = dp[0][i - 1] + 1;
dp[1][i] = dp[1][i - 1];
}
add += dp[0][i];
ans += add;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, w = 0;
char ch = getchar();
while (!isdigit(ch)) w |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return w ? -x : x;
}
long long a[500000], sum[500000], b[500000], ans;
inline long long calc(long long k) {
long long res = 0;
for (; k; k &= k - 1) ++res;
return res;
}
signed main() {
long long n = read();
for (long long i = 1; i <= n; ++i)
a[i] = calc(read()), sum[i] = sum[i - 1] + a[i];
b[0] = 1;
for (long long i = 1; i <= n; ++i) {
ans += b[sum[i] & 1]++;
ans -= ((sum[i] & 1) == (sum[i - 1] & 1));
}
for (long long i = 1; i <= n; ++i) {
long long mx = a[i];
for (long long j = i - 1; j >= max(1ll, i - 64); --j) {
mx = max(mx, a[j]);
long long t = sum[i] - sum[j - 1];
if (!(t & 1) && mx > t - mx) --ans;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long a[N];
int32_t bit_cnt[N];
long long dp[N][2];
int32_t prefix_sum[N];
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
bit_cnt[i] = __builtin_popcountll(a[i]);
}
for (long long i = 1; i <= n; ++i) {
prefix_sum[i] = bit_cnt[i] + prefix_sum[i - 1];
}
long long ans = 0;
dp[0][0] = 1;
for (long long i = 1; i <= n; ++i) {
long long c = prefix_sum[i] & 1LL;
dp[i][0] = dp[i - 1][0];
dp[i][1] = dp[i - 1][1];
dp[i][c] += 1;
ans += dp[i - 1][c];
long long res = -1, mx = bit_cnt[i];
long long sum = 0;
for (long long j = i; i - j <= 62 && j > 0; --j) {
mx = max(mx, (long long)bit_cnt[j]);
sum += bit_cnt[j];
if ((sum - mx < mx) && (sum & 1) == 0) {
--ans;
}
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 1; i <= t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = (int)3e5 + 1;
const int N_ = (int)1e3 + 1;
const int MAXN = (int)4e6 + 7;
const int MOD = (int)1e9;
const int INF = (int)2e9;
const int DEL = (int)3e5;
const int LOG = 20;
const int ALPH = 256;
const int DIGIT = 10;
const int BLOCK = 300;
const int LIGHT = 650;
const long long LINF = (int64_t)2e18;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-2;
using namespace std;
template <typename T>
T sqr(T a) {
return a * a;
}
template <typename T>
bool uax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool uin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &p) {
out << p.first << ' ' << p.second;
return out;
}
long long a[N];
int n, cnt[N];
void read() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
}
void solve() {
for (int i = 0; i < n; i++) {
while (a[i]) {
cnt[i] += a[i] & 1;
a[i] >>= 1;
}
}
long long ans = 0;
int even = 1, odd = 0, sum = 0;
for (int i = 0; i < n; i++) {
sum += cnt[i];
if (sum & 1)
ans += odd++;
else
ans += even++;
}
for (int i = 0; i < n; i++) {
int bit = 0, mx = 0;
for (int j = i; j < n && bit < 140; j++) {
uax(mx, cnt[j]);
bit += cnt[j];
if (mx * 2 > bit && bit % 2 == 0) ans--;
}
}
cout << ans;
}
void check_time() {
double start = clock();
read(), solve();
cout << "\nTime is " << (clock() - start) * 1.0 / CLOCKS_PER_SEC << "s\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
read();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[300010], sum[300010], mx[300010];
long long ans = 0;
void work(int l, int r) {
if (l == r) {
ans += (!a[l]);
return;
}
int mid = (l + r) >> 1, j, k, _0, _1;
work(l, mid);
work(mid + 1, r);
sum[mid] = mx[mid] = a[mid];
sum[mid + 1] = mx[mid + 1] = a[mid + 1];
for (int i = mid - 1; i >= l; i--)
sum[i] = sum[i + 1] + a[i], mx[i] = max(mx[i + 1], a[i]);
for (int i = mid + 2; i <= r; i++)
sum[i] = sum[i - 1] + a[i], mx[i] = max(mx[i - 1], a[i]);
_0 = _1 = 0;
j = k = mid;
for (int i = mid; i >= l; i--) {
while (mx[k + 1] <= mx[i] && k + 1 <= r) k++, (sum[k] & 1) ? ++_1 : ++_0;
while (sum[j + 1] + sum[i] < 2 * mx[i] && j < k)
j++, (sum[j] & 1) ? --_1 : --_0;
while (sum[j] + sum[i] >= 2 * mx[i] && j > mid)
(sum[j] & 1) ? ++_1 : ++_0, j--;
ans += (sum[i] & 1) ? _1 : _0;
}
_0 = _1 = 0;
j = k = mid + 1;
for (int i = mid + 1; i <= r; i++) {
while (mx[k - 1] < mx[i] && k - 1 >= l) k--, (sum[k] & 1) ? ++_1 : ++_0;
while (sum[j - 1] + sum[i] < 2 * mx[i] && j > k)
j--, (sum[j] & 1) ? --_1 : --_0;
while (sum[j] + sum[i] >= 2 * mx[i] && j <= mid)
(sum[j] & 1) ? ++_1 : ++_0, j++;
ans += (sum[i] & 1) ? _1 : _0;
}
}
int main() {
scanf("%d", &n);
long long w;
for (int i = 1; i <= n; i++) {
scanf("%lld", &w);
while (w) a[i] += (w & 1), w >>= 1;
}
work(1, n);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int limN = 3e5 + 5;
int cntBts(long long k) {
int ans = 0;
while (k) {
ans += k & 1;
k /= 2;
}
return ans;
}
int arb[limN];
void mete(int pos, const int nov) {
for (; pos; pos -= (pos & -pos)) arb[pos] = max(arb[pos], nov);
}
int saca(int pos) {
int ans = 0;
for (; pos < limN; pos += (pos & -pos)) ans = max(ans, arb[pos]);
return ans;
}
vector<int> poss[2];
int sumos[limN];
int bts[limN];
int quer(int pos, int nov) {
mete(pos, nov);
vector<int> &ps = poss[sumos[pos] % 2];
int k = ps.size() - 1;
ps.push_back(pos);
int ans = 0;
for (; k >= 0; k--) {
int p = ps[k];
int s = sumos[pos] - sumos[p];
if (s >= 120) {
ans += k + 1;
break;
}
int mx = saca(p + 1);
if (s >= mx * 2) ans++;
}
return ans;
}
int main() {
int N;
scanf("%d", &N);
long long a;
for (int i = 1; i <= N; i++) {
scanf("%lld", &a);
a = cntBts(a);
bts[i] = a;
sumos[i] = sumos[i - 1] + a;
}
poss[0].push_back(0);
long long ans = 0;
for (int i = 1; i <= N; i++) ans += quer(i, bts[i]);
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long N = 3e5 + 100, LOG = 62;
unsigned long long n, ans, a[N], ps[N], cnt[N];
int popcount(unsigned long long a) {
return (a ? (a & 1) + popcount(a >> 1) : 0);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i], a[i] = popcount(a[i]),
ps[i] = ((i ? ps[i - 1] : 0) + a[i]) & 1;
for (int i = n - 1; i >= 0; i--) cnt[i] = cnt[i + 1] + ps[i];
for (int i = 0; i < n; i++) {
unsigned long long maxi = 0, sum = 0;
for (int j = i; j < min(n, i + LOG); j++) {
maxi = max(maxi, a[j]);
sum += a[j];
ans += (2 * maxi <= sum && (sum & 1) == 0);
}
int PS = (i ? ps[i - 1] : 0);
if (i + LOG < n)
ans += (PS ? cnt[i + LOG] : (n - (i + LOG) - cnt[i + LOG]));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long ans, sum[300030], cnt[300030], tot[3];
int main() {
scanf("%d", &n);
tot[0] = 1;
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
while (x) {
cnt[i] += x % 2;
x >>= 1;
}
sum[i] = sum[i - 1] + cnt[i];
ans += tot[sum[i] % 2];
for (int j = i, k = i + 1, maxx = 0; j >= 1 && j >= i - 64; j--) {
while (k > j) maxx = max(1ll * maxx, cnt[k - 1]), k--;
if (maxx * 2 > sum[i] - sum[j - 1] && ((sum[i] % 2) == (sum[j - 1] % 2)))
ans--;
}
++tot[sum[i] % 2];
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100, LOG = 62;
int n, a[N], ps[N], cnt[N];
unsigned long long A, ans;
inline short popcount(unsigned long long a) {
return (a ? (a & 1) + popcount(a >> 1) : 0);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> A, a[i] = popcount(A), ps[i] = ((i ? ps[i - 1] : 0) + a[i]) & 1;
for (int i = n - 1; i >= 0; i--) cnt[i] = cnt[i + 1] + ps[i];
for (int i = 0; i < n; i++) {
int maxi = 0, sum = 0;
for (int j = i; j < min(n, i + LOG); j++) {
maxi = max(maxi, a[j]);
sum += a[j];
ans += (2 * maxi <= sum && (sum & 1) == 0);
}
int PS = (i ? ps[i - 1] : 0);
if (i + LOG < n)
ans += (PS ? cnt[i + LOG] : (n - (i + LOG) - cnt[i + LOG]));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long maxn = 3e5 + 4;
long long C[maxn], pre[maxn][2];
signed main() {
long long N;
cin >> N;
for (long long i = 1; i <= N; ++i) {
long long a;
cin >> a;
C[i] = __builtin_popcountll(a);
}
long long pp = 0;
for (long long i = 1; i <= N; ++i) {
pp ^= C[i] & 1;
pre[i][0] = pre[i - 1][0];
pre[i][1] = pre[i - 1][1];
++pre[i][pp];
}
long long ans = 0, psum = 0;
for (long long i = 1; i <= N; ++i) {
long long sum = 0, maxv = 0;
for (long long j = i; j <= N && j <= i + 64; ++j) {
sum += C[j];
maxv = max(maxv, C[j]);
if ((sum & 1) == 0 && maxv * 2 <= sum) ++ans;
}
ans += pre[N][psum] - pre[min(N, i + 64)][psum];
psum ^= C[i] & 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[300005], dp[2][300005], one = 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, i, j, ans = 0;
cin >> n;
for (i = 1; i <= n; ++i) {
long long int val;
cin >> val;
a[i] = __builtin_popcountll(val);
}
for (i = 1; i <= n; ++i) {
long long int mak = a[i], sum = a[i];
for (j = i - 1; j >= max(one, i - 62); --j) {
mak = max(a[j], mak);
sum += a[j];
if (mak <= sum - mak && sum % 2 == 0) ++ans;
}
if (sum % 2 == 1)
ans += dp[1][j];
else
ans += dp[0][j];
if (a[i] % 2) {
dp[0][i] = dp[1][i - 1];
dp[1][i] = dp[0][i - 1];
} else {
dp[0][i] = dp[0][i - 1];
dp[1][i] = dp[1][i - 1];
}
++dp[(a[i] % 2)][i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const long double pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const long long MOD = 1e18 + 9;
const long long INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n;
long long a[N];
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
a[i] = __builtin_popcountll(x);
}
long long res = 0;
for (long long i = 1; i <= n; i++) {
long long sum = 0, mx = 0;
for (long long j = i; j <= n; j++) {
if (j - i > 61) break;
sum += a[j];
mx = max(mx, a[j]);
if (sum % 2 == 0 && sum - mx < mx) ++res;
}
}
long long c1 = 0, c2 = 1, sum = 0;
for (long long i = 1; i <= n; i++) {
sum ^= (a[i] & 1);
if (sum)
c1++;
else
c2++;
}
cout << c1 * (c1 - 1) / 2ll + c2 * (c2 - 1) / 2ll - res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, a[N], sum[2][N];
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
a[i] = __builtin_popcountll(x);
}
sum[0][0] = 1;
for (int i = 1; i <= n; ++i) {
a[i] += a[i - 1];
for (int j = i - 1, cnt = 0, maxx = 0; j >= 0 && cnt < 65; --j, cnt++) {
int cur = a[i] - a[j];
maxx = max(maxx, a[j + 1] - a[j]);
if (cur % 2 == 0 && cur / 2 >= maxx) ans++;
}
sum[0][i] = sum[0][i - 1];
sum[1][i] = sum[1][i - 1];
if (a[i] % 2)
ans += (i >= 66 ? sum[1][i - 66] : 0), sum[1][i]++;
else
ans += (i >= 66 ? sum[0][i - 66] : 0), sum[0][i]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5) + 9;
int n;
long long a[N];
int b[N];
int cnt[2][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = __builtin_popcountll(a[i]);
}
long long res = 0;
int sufSum = 0;
cnt[0][n] = 1;
for (int i = n - 1; i >= 0; --i) {
int sum = 0, mx = 0;
int lstJ = i;
int add = 0;
for (int j = i; j < n && j - i < 65; ++j) {
sum += b[j];
mx = max(mx, b[j]);
if (mx > sum - mx && sum % 2 == 0) --add;
lstJ = j;
}
sufSum += b[i];
add += cnt[sufSum & 1][i + 1];
res += add;
cnt[0][i] = cnt[0][i + 1];
cnt[1][i] = cnt[1][i + 1];
if (sufSum & 1)
++cnt[1][i];
else
++cnt[0][i];
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long NMAX = 300011;
long long c[NMAX];
signed main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
while (a > 0) {
if (a & 1) c[i]++;
a >>= 1;
}
}
long long bad = 0;
for (long long i = 1; i <= n; i++) {
long long sum = c[i];
long long mx = c[i];
if ((c[i] & 1) == 0) bad++;
for (long long j = i + 1; j <= min(n, i + 64); j++) {
sum += c[j];
mx = max(mx, c[j]);
if ((sum & 1) == 0 && 2 * mx > sum) bad++;
}
}
long long cnt2 = 1;
long long cnt1 = 0;
long long sum = 0;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
sum += c[i];
if (sum & 1) {
ans += cnt1;
cnt1++;
} else {
ans += cnt2;
cnt2++;
}
}
cout << ans - bad;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m = 1000000007) {
if (b == 0) return 1;
if (b == 1) return a;
long long res = power(a, b / 2, m);
res = (res * res) % m;
if (b & 1) res = (res * a) % m;
return res;
}
long long modinv(long long a, long long m = 1000000007) {
return power(a, m - 2, m);
}
long long add(long long a, long long b, long long m = 1000000007) {
long long c = (a % m + b % m);
if (c >= m) c -= m;
return c;
}
long long sub(long long a, long long b, long long m = 1000000007) {
long long c = (a % m - b % m);
if (c < 0) c += m;
return c;
}
long long mul(long long a, long long b, long long m = 1000000007) {
return (a * b) % m;
}
void solve() {
long long n, i, j, ans = 0, sum = 0;
cin >> n;
long long a[n], maxi, p[n + 1], suf[n + 1][2];
p[0] = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
a[i] = __builtin_popcountll(a[i]);
p[i] = p[i - 1] + a[i];
}
memset(suf, 0, sizeof(suf));
for (i = n; i > 0; i--) {
suf[i][p[i] % 2] = 1;
if (i == n) continue;
suf[i][0] += suf[i + 1][0];
suf[i][1] += suf[i + 1][1];
}
for (i = n - 1; i > 0; i--) {
sum = a[i];
maxi = a[i];
for (j = 1; j < 61 && i + j <= n; j++) {
maxi = max(maxi, a[i + j]);
sum += a[i + j];
if (2 * maxi > sum) {
ans -= (sum % 2 == 0);
}
}
ans += suf[i + 1][p[i - 1] % 2];
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
for (long long i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 300005;
int n, A[M], mr[M], sum[M], odd[M];
int main() {
long long x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
A[i] = 0;
while (x) {
A[i] += x & 1;
x >>= 1;
}
sum[i] = sum[i - 1] + A[i];
odd[i] = odd[i - 1] + (sum[i] & 1);
}
for (int i = n; i >= 1; i--) {
int now = i + 1;
while (now <= n && A[i] >= A[now]) now = mr[now];
mr[i] = now;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
int mx = A[i];
int L = i, R = mr[i];
while (1) {
int p = lower_bound(sum + L, sum + n + 1, sum[i - 1] + mx * 2) - sum;
if (R > p) {
if (sum[i - 1] & 1)
ans += odd[R - 1] - odd[p - 1];
else
ans += R - p - (odd[R - 1] - odd[p - 1]);
}
if (R == n + 1) break;
L = R, mx = A[L], R = mr[R];
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long maxn = 300005;
long long n, ans;
long long a[maxn], sum[maxn], cnt[2];
inline long long max(long long a, long long b) { return a > b ? a : b; }
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
long long x;
for (scanf("%lld", &x); x; x >>= 1) a[i] += (x & 1);
}
cnt[0]++;
for (long long i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
ans += cnt[sum[i] & 1];
long long maxx = a[i];
for (long long j = i - 1; j >= i - 65 && j >= 0; j--) {
if ((sum[i] - sum[j]) % 2 == 0 && sum[i] - sum[j] < 2 * maxx) ans--;
maxx = max(maxx, a[j]);
}
cnt[sum[i] & 1]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 10;
const long long INF = 1e18 + 10;
long long n, i, j, ans, now, x, a[N], sy[N][2];
int main() {
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> x;
a[i] = __builtin_popcountll(x);
}
sy[n + 1][0] = 1;
for (i = n; i >= 1; --i) {
long long sum = 0, mx = 0;
for (j = i; j <= n && j - i <= 70; ++j) {
sum += a[j];
mx = max(mx, a[j]);
if (sum % 2 == 0 && mx * 2 > sum) ans--;
}
now = now + a[i];
ans += sy[i + 1][now % 2];
sy[i][0] = sy[i + 1][0];
sy[i][1] = sy[i + 1][1];
sy[i][now % 2]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ans = 0;
long long a[300005], pre[300005], precnt[300005][2], dp[300005][2];
long long query(long long l, long long r, long long x) {
if (l > r) return 0;
return precnt[r][x] - precnt[l - 1][x];
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
long long x, cnt = 0;
cin >> x;
while (x) cnt += (x & 1ll), x >>= 1ll;
a[i] = cnt;
}
for (long long i = 1; i <= n; i++) pre[i] = (pre[i - 1] + a[i]) & 1ll;
precnt[0][0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 2; j++) precnt[i][j] = precnt[i - 1][j];
precnt[i][pre[i]]++;
}
for (long long i = 1; i <= n; i++) {
long long maxv = a[i], sumv = a[i];
for (long long j = i + 1; j <= min(i + 80, n); j++) {
sumv += a[j];
maxv = max(maxv, a[j]);
if (sumv % 2 == 0 && maxv <= sumv / 2) ans++;
}
long long x = pre[i - 1] & 1;
ans += query(i + 81, n, x);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, Bit[N], S[2];
long long A[N];
int bc(long long x) {
int res = 0;
for (; x; x >>= 1) {
if (x & 1) ++res;
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%lld", &A[i]), Bit[i] = bc(A[i]);
S[0] = 1;
int now = 0;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
now = (now + Bit[i]) & 1;
ans += S[now];
++S[now];
}
for (int i = 1; i <= n; ++i) {
int now = 0, MAX = 0;
for (int j = i; j <= min(n, i + 64); ++j) {
MAX = max(MAX, Bit[j]);
now += Bit[j];
if (now & 1)
continue;
else {
if (MAX * 2 > now) --ans;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int mod = 1e9 + 7;
const long long inf = 1e14;
const int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
long long a[maxn], b[maxn], pr[maxn], ans, mx;
int n;
int main() {
cin >> n;
long long x;
for (int i = 1; i <= n; ++i) {
cin >> x;
a[i] = __builtin_popcountll(x * 1ll);
pr[i] = a[i] + pr[i - 1];
b[i] = b[i - 1] + (pr[i] & 1);
}
for (int i = 1; i <= n; ++i) {
mx = a[i];
if (pr[i - 1] & 1)
ans += b[n] - b[i];
else
ans += (n - b[n]) - (i - b[i]);
for (int j = i + 1; j <= min(i + 61, n); ++j) {
mx = max(mx, a[j]);
if ((pr[j] - pr[i - 1]) % 2 == 0 && (pr[j] - pr[i - 1]) < mx * 2) ans--;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[300010], bit[300010], memo[300010][2], pot[70];
void precalc() {
pot[0] = 1;
for (long long i = 1; i <= 62; i++) pot[i] = pot[i - 1] * 2;
}
void solve() {
precalc();
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
for (long long j = 0; j < 62; j++) {
long long x = pot[j];
if (x & a[i]) bit[i]++;
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (bit[i] % 2 == 0) {
memo[i][0] = memo[i - 1][0] + 1;
memo[i][1] = memo[i - 1][1];
} else {
memo[i][0] = memo[i - 1][1];
memo[i][1] = memo[i - 1][0] + 1;
}
ans += memo[i][0];
long long maior = 0, tot = 0;
for (long long j = i; j >= 1 and j >= i - 62; j--) {
maior = max(maior, bit[j]);
tot += bit[j];
if (tot % 2 == 0 and tot < 2 * maior) ans--;
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000;
long long prost1 = 36028797018963913;
long long prost2 = 35184372088777;
long long scal_prod(pair<long long, long long> l,
pair<long long, long long> r) {
return l.first * r.first + l.second * r.second;
}
long long vec_prod(pair<long long, long long> l, pair<long long, long long> r) {
return l.first * r.second - l.second * r.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long kol_vo;
cin >> kol_vo;
vector<long long> v(kol_vo);
for (long long c = 0; c < kol_vo; c++) cin >> v[c];
vector<long long> dop(kol_vo);
for (long long c = 0; c < kol_vo; c++) {
for (int i = 0; i < 63; i++)
if ((v[c] >> i) & 1) dop[c]++;
}
pair<long long, long long> answ;
answ.first = 1;
answ.second = 0;
long long bit = 0, an = 0;
for (long long c = 0; c < kol_vo; c++) {
bit += dop[c];
if (bit % 2) {
an += answ.second;
answ.second++;
} else {
an += answ.first;
answ.first++;
}
}
long long mmax = -1, all;
for (long long c = 0; c < kol_vo; c++) {
mmax = -1, all = 0;
for (long long i = c; i < c + 63 && i < kol_vo; i++) {
mmax = max(mmax, dop[i]);
all += dop[i];
if (mmax * 2 > all && all % 2 == 0) an--;
}
}
cout << an;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int magic = 70;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n), pref(n);
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
a[i] = __builtin_popcountll(x);
pref[i] = a[i];
if (i != 0) pref[i] += pref[i - 1];
}
long long ans = 0;
int even = 0;
int odd = 0;
for (int i = 0; i < n; ++i) {
if (pref[i] & 1)
++odd;
else
++even;
}
++even;
auto f = [&](int x) { return (long long)x * (x - 1) / 2; };
ans = f(even) + f(odd);
for (int i = 0; i < n; ++i) {
int mx = 0;
int sum = 0;
for (int j = i; j < min(n, i + magic); ++j) {
sum += a[j];
mx = max(mx, a[j]);
if (sum % 2 == 0 && !(mx <= sum - mx)) --ans;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_BIT = 60;
int main() {
int n;
cin >> n;
vector<int> a(n), prefixSum(n);
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
a[i] = __builtin_popcountll(x);
prefixSum[i] = a[i];
if (i) prefixSum[i] += prefixSum[i - 1];
}
vector<int> evenSums(n);
for (int i = 0; i < n; ++i) {
if (i) evenSums[i] = evenSums[i - 1];
if (!(prefixSum[i] & 1)) ++evenSums[i];
}
long long ans = 0;
int nextOccurrence[MAX_BIT];
for (int i = 0; i < MAX_BIT; ++i) nextOccurrence[i] = n;
for (int i = n - 1; i >= 0; --i) {
int sumBefore = (i ? prefixSum[i - 1] : 0);
nextOccurrence[a[i]] = i;
int minBigBitOccurrence = n;
for (int bit = MAX_BIT - 1; bit >= 0; --bit) {
int left = nextOccurrence[bit] - 1, right = n;
while (right - left > 1) {
int mid = (left + right) / 2;
if (prefixSum[mid] - sumBefore >= 2 * bit)
right = mid;
else
left = mid;
}
int minRangeEnd = right;
int maxRangeEnd;
if (bit == MAX_BIT - 1)
maxRangeEnd = n - 1;
else
maxRangeEnd = minBigBitOccurrence - 1;
minBigBitOccurrence = min(minBigBitOccurrence, nextOccurrence[bit]);
if (minRangeEnd > maxRangeEnd) continue;
int cnt = ans;
if (sumBefore & 1)
ans += (maxRangeEnd + 1 - evenSums[maxRangeEnd]) -
(minRangeEnd - evenSums[minRangeEnd - 1]);
else
ans += evenSums[maxRangeEnd] - evenSums[minRangeEnd - 1];
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1LL << 62;
const int iinf = 1000000009;
const double dinf = 1e17;
const int Mod = 1e9 + 9;
const int maxn = 1000005;
int n;
long long a, b[maxn];
long long dp[3][maxn];
void solve() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a, b[i] = __builtin_popcountll(a);
long long suf = 0;
dp[0][n + 1] = 1;
long long res = 0;
for (int i = n; i >= 1; i--) {
long long sum = 0, mx = 0, ret = 0;
for (int j = i; j <= min(n, i + 64); j++) {
sum += b[j];
mx = max(b[j], mx);
if (mx > sum - mx && sum % 2 == 0) ret--;
}
suf += b[i];
if (suf & 1)
ret += dp[1][i + 1];
else
ret += dp[0][i + 1];
res += ret;
dp[0][i] = dp[0][i + 1];
dp[1][i] = dp[1][i + 1];
if (suf & 1)
dp[1][i]++;
else
dp[0][i]++;
}
cout << res << endl;
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, b[N];
long long ans = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
for (; x; x -= x & -x) b[i]++;
}
int c0 = 1, c1 = 0;
long long s = 0;
for (int i = n; i >= 1; i--) {
int mx = 0, ts = 0;
for (int j = i; j <= n && j <= i + 62; j++) {
mx = max(mx, b[j]);
ts += b[j];
if (ts % 2 == 0 && mx > ts - mx) ans--;
}
s += b[i];
ans += (s & 1) ? c1 : c0;
((s & 1) ? c1 : c0)++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 3e5 + 100;
int n, b[MAXN], cnt[2][MAXN];
long long a[MAXN];
int main() {
int tt = 1;
while (tt--) {
long long res = 0;
int suff = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = __builtin_popcountll(a[i]);
}
cnt[0][n] = 1;
for (int i = n - 1; i >= 0; i--) {
int sum = 0, mx = 0, k = i, ad = 0;
for (int j = i; j < n and j - i < 65; j++) {
sum += b[j];
mx = max(mx, b[j]);
if (mx > sum - mx and sum % 2 == 0) --ad;
k = j;
}
suff += b[i];
ad += cnt[suff & 1][i + 1];
res += ad;
cnt[0][i] = cnt[0][i + 1];
cnt[1][i] = cnt[1][i + 1];
if (suff & 1)
++cnt[1][i];
else
++cnt[0][i];
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[300005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long x;
scanf("%I64d", &x);
for (int k = 0; k < 64; k++) a[i] += (x & (1LL << k)) != 0;
}
long long res = 0;
int d[2] = {0, 0};
for (int i = n - 1; i > 0; i--) {
if (a[i] % 2 == 1) swap(d[0], d[1]);
d[(a[i] + a[i + 1]) % 2]++;
int tmp = a[i], amax = a[i];
for (int j = i + 1; j <= min(n, i + 64); j++) {
amax = max(amax, a[j]);
if ((tmp + a[j]) % 2 == 0 && amax > tmp - amax + a[j]) res--;
tmp += a[j];
}
res += d[0];
}
printf("%I64d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ile(long long int a) {
int ans = 0;
while (a) {
if (a % 2 == 1) ans++;
a /= 2;
}
return ans;
}
int main() {
int n;
cin >> n;
long long int* a;
a = new long long int[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int* b;
b = new int[n];
for (int i = 0; i < n; i++) {
b[i] = ile(a[i]);
}
int* pre;
pre = new int[n];
pre[0] = b[0] % 2;
for (int i = 1; i < n; i++) {
pre[i] = (pre[i - 1] + b[i]) % 2;
}
int ile0 = 0;
int ile1 = 0;
for (int i = 0; i < n; i++) {
if (pre[i] == 0)
ile0++;
else
ile1++;
}
long long int ans = 0;
ans += ile0;
for (int i = 1; i < n; i++) {
if (pre[i - 1] == 0)
ile0--;
else
ile1--;
if (pre[i - 1] == 0)
ans += ile0;
else
ans += ile1;
}
for (int i = 0; i < n; i++) {
int j = i;
int naj = 0;
int sum = 0;
while (j < n && sum <= 128) {
naj = max(naj, b[j]);
sum += b[j];
if (naj > (sum - naj)) {
if (i == 0) {
if (pre[j] == 0) ans--;
} else {
if (pre[j] - pre[i - 1] == 0) ans--;
}
}
j++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
inline bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> pct(N);
for (long long a, i = 0; i < N; ++i) {
cin >> a;
pct[i] = __builtin_popcountll(a);
}
int odd = 0, even = 1, sum = 0;
long long ans = 0;
for (int i = N - 1; i >= 0; --i) {
int cur_sum = 0, max_pct = 0, cur_ans = 0;
for (int j = i; j < min(i + 61, N); ++j) {
cur_sum += pct[j];
uax(max_pct, pct[j]);
if (max_pct > cur_sum - max_pct && cur_sum % 2 == 0) --cur_ans;
}
sum += pct[i];
if (sum % 2 == 1) {
cur_ans += odd;
++odd;
} else {
cur_ans += even;
++even;
}
ans += cur_ans;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 400005;
int n;
int a[N];
int ss[N][2];
int s0[N];
void solv() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
long long x;
scanf("%lld", &x);
while (x) {
if (x % 2 == 1) ++a[i];
x /= 2;
}
}
long long ans = 0;
ss[n + 1][0] = 1;
for (int i = n; i >= 1; --i) {
s0[i] = s0[i + 1] + a[i];
ss[i][0] = ss[i + 1][0];
ss[i][1] = ss[i + 1][1];
++ss[i][s0[i] % 2];
int s = 0;
int maxu = 0;
for (int j = i; j <= min(n, i + 70); ++j) {
s += a[j];
maxu = max(maxu, a[j]);
if (s - maxu >= maxu && s % 2 == 0) ++ans;
}
ans += (ss[i + 72][s0[i] % 2]);
}
printf("%lld\n", ans);
}
int main() {
solv();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[1000000];
int b[1000000];
int cnt[2][1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = __builtin_popcountll(a[i]);
}
long long ans = 0;
int ss = 0;
cnt[0][n] = 1;
for (int i = n - 1; i >= 0; --i) {
int sum = 0, mx = 0;
int lst = i;
int add = 0;
for (int j = i; j < n && j - i < 65; ++j) {
sum += b[j];
mx = max(mx, b[j]);
if (mx > sum - mx && sum % 2 == 0) --add;
lst = j;
}
ss += b[i];
add += cnt[ss & 1][i + 1];
ans += add;
cnt[0][i] = cnt[0][i + 1];
cnt[1][i] = cnt[1][i + 1];
if (ss & 1)
++cnt[1][i];
else
++cnt[0][i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int amount;
int numbers[300005];
int parity[300005][2], sums[300005];
void solve() {
parity[0][0] = 1;
long long total = 0;
for (int i = 1; i <= amount; i++) {
sums[i] = sums[i - 1] + numbers[i];
int max_num = 0;
int run = min(i, 120);
for (int j = 1; j <= run; j++) {
max_num = max(max_num, numbers[i - j + 1]);
if ((sums[i] - sums[i - j]) % 2 == 0)
total += (2 * max_num <= sums[i] - sums[i - j]);
}
parity[i][0] = parity[i - 1][0], parity[i][1] = parity[i - 1][1];
parity[i][sums[i] & 1]++;
if (i != run) total += parity[i - run - 1][sums[i] & 1];
}
printf("%lld", total);
}
int main() {
scanf("%d", &amount);
for (int i = 1; i <= amount; i++) {
long long num;
scanf("%lld", &num);
while (num) numbers[i] += num & 1, num >>= 1;
}
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int a[N], suff[N], c[N], nc[N];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
long long c;
cin >> c;
int j = 0;
while ((1LL << j) <= c) {
if (c & (1LL << j)) {
a[i]++;
}
j++;
}
}
int cur = 0;
c[n + 1] = 1;
for (int i = n; i > 0; i--) {
c[i] = c[i + 1];
nc[i] = nc[i + 1];
cur += a[i];
if (cur & 1) {
nc[i]++;
} else {
c[i]++;
}
suff[i] = cur;
}
long long ans = 0;
for (int l = 1; l < n; l++) {
if (suff[l] & 1) {
ans += nc[l + 2];
} else {
ans += c[l + 2];
}
cur = a[l];
int max1 = a[l];
for (int r = l + 1; r <= min(l + 61, n); r++) {
cur += a[r];
max1 = max(max1, a[r]);
if (!(cur & 1) && max1 * 2 > cur) {
ans--;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mult(long long a, long long b, long long p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = 1000000007) {
return (a % p + b % p) % p;
}
long long fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
long long a[300005];
long long ev[300005];
long long odd[300005];
long long sum[300005];
int main() {
ios::sync_with_stdio(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long p;
cin >> p;
a[i] = __builtin_popcountll(p);
}
for (long long i = n - 1; i >= 0; i--) {
sum[i] = sum[i + 1] + a[i];
odd[i] += odd[i + 1];
ev[i] += ev[i + 1];
if (sum[i] & 1) {
odd[i - 1]++;
} else {
ev[i - 1]++;
}
}
long long ans = 0;
for (long long i = n - 2; i >= 0; i--) {
if (sum[i] & 1) {
ans += odd[i];
} else {
ans += ev[i];
ans++;
}
long long sm = 0;
long long maxx = 0;
for (long long j = i; j < min((long long)100 + i, n); j++) {
sm += a[j];
maxx = max(maxx, a[j]);
if (sm % 2 == 0 && 2 * maxx > sm) {
ans--;
}
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int64_t n, e, o, ans, a[300001], sm[300001], cnt[300001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int64_t i = 1; i <= n; ++i) {
cin >> a[i];
sm[i] = (sm[i - 1] ^ a[i]);
if (__builtin_popcountll(sm[i]) % 2 == 0)
++e;
else
++o;
}
for (int64_t i = 1; i <= n; ++i) {
cnt[i] = __builtin_popcountll(a[i]);
ans += e;
if (cnt[i] & 1) swap(e, o);
--e;
}
for (int64_t i = 1; i <= n; ++i) {
int64_t sm = 0, mx = 0, temp;
for (int64_t j = i; j <= n; ++j) {
mx = max(mx, cnt[j]);
sm += cnt[j];
if (sm % 2 == 0 && 2 * mx > sm) --ans;
if (sm > 125) break;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000;
long long prost1 = 36028797018963913;
long long prost2 = 35184372088777;
long long scal_prod(pair<long long, long long> l,
pair<long long, long long> r) {
return l.first * r.first + l.second * r.second;
}
long long vec_prod(pair<long long, long long> l, pair<long long, long long> r) {
return l.first * r.second - l.second * r.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long kol_vo;
cin >> kol_vo;
vector<long long> v(kol_vo);
for (long long c = 0; c < kol_vo; c++) cin >> v[c];
vector<long long> dop(kol_vo);
for (long long c = 0; c < kol_vo; c++) {
dop[c] = __builtin_popcountll(v[c]);
}
pair<long long, long long> answ;
answ.first = 1;
answ.second = 0;
long long bit = 0, an = 0;
for (long long c = 0; c < kol_vo; c++) {
bit += dop[c];
if (bit % 2) {
an += answ.second;
answ.second++;
} else {
an += answ.first;
answ.first++;
}
}
long long mmax = -1, all;
for (long long c = 0; c < kol_vo; c++) {
mmax = -1, all = 0;
for (long long i = c; i < c + 63 && i < kol_vo; i++) {
mmax = max(mmax, dop[i]);
all += dop[i];
if (mmax * 2 > all && all % 2 == 0) an--;
}
}
cout << an;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int maxn = 3e5 + 10;
const long long INF = 1e9;
const int logmaxn = 22;
int n;
long long a[maxn];
int b[maxn];
int dp[maxn];
int sum[maxn][2];
int si[maxn];
int cntbit(long long x) {
int cnt = 0;
for (int t = (0); t < (62); ++t) {
if (x & (1ll << t)) ++cnt;
}
return cnt;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
si[0] = 0;
for (int t = (1); t < (n + 1); ++t)
cin >> a[t], b[t] = cntbit(a[t]), si[t] = si[t - 1] + b[t];
sum[0][0] = 1, sum[0][1] = 0;
for (int t = (1); t < (n + 1); ++t) {
for (int i = (0); i < (2); ++i) sum[t][i] = sum[t - 1][i];
++sum[t][si[t] % 2];
}
memset(dp, 0, sizeof(dp));
for (int i = (1); i < (n + 1); ++i) {
int cntbit = b[i];
int curmax = b[i];
for (int j = i - 1; j >= i - 62 && j; --j) {
cntbit += b[j];
curmax = max(curmax, b[j]);
if (cntbit - curmax >= curmax && (cntbit) % 2 == 0) ++dp[i];
}
if (i - 64 >= 0) dp[i] += sum[i - 64][si[i] % 2];
}
long long ans = 0;
for (int t = (1); t < (n + 1); ++t) ans += dp[t];
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, odd[maxn], sum[maxn];
long long a, ans, cnt[2][maxn];
inline long long rd() {
long long res = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) res = (res << 3) + (res << 1) + ch - 48;
return res * f;
}
int main() {
n = rd();
for (register int i = 1; i <= n; ++i) {
scanf("%lld", &a);
while (a) {
odd[i] += a & 1;
a >>= 1;
}
sum[i] = sum[i - 1] + odd[i];
}
for (register int i = 1; i <= n; ++i) {
if (odd[i] & 1) {
cnt[0][i] = cnt[1][i - 1];
cnt[1][i] = cnt[0][i - 1] + 1;
} else {
cnt[0][i] = cnt[0][i - 1] + 1;
cnt[1][i] = cnt[1][i - 1];
}
int maxx = -1, p;
ans += cnt[0][i];
for (register int l = 1; l <= 64; ++l) {
p = i - l + 1;
if (p < 1) break;
maxx = max(maxx, odd[p]);
if (2 * maxx > sum[i] - sum[p - 1] && !((sum[i] - sum[p - 1]) & 1)) --ans;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[300010], b[300010], bc[2];
long long ans, x;
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
scanf("%lld", &x);
for (; x; x -= x & (-x)) ++a[i];
}
for (int i = (1); i <= (n); ++i) {
b[i] = b[i - 1] + a[i];
int t = 0, fxk = 0;
for (int j = (i - 1); j >= (max(0, i - 128)); --j) {
t += a[j + 1];
fxk = max(fxk, a[j + 1]);
if (!(t & 1) && (fxk * 2 <= t)) ++ans;
}
ans += bc[b[i] & 1];
if (i >= 128) bc[b[i - 128] & 1]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, anss[300010], num[300010], cnt[2] = {1};
long long ans = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
while (x > 0) {
num[i] += (x % 2);
x /= 2;
}
anss[i] = anss[i - 1] + num[i];
ans += cnt[anss[i] % 2];
for (int j = i, k = i + 1, maxn = 0; j >= 1 && j >= i - 64; --j) {
while (k > j) maxn = max(maxn, num[--k]);
if (maxn * 2 > anss[i] - anss[j - 1] && anss[i] % 2 == anss[j - 1] % 2)
--ans;
}
++cnt[anss[i] % 2];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n = 0, ans = 0;
long long oddCnt = 0, evenCnt = 0;
long long s[300005] = {};
bool sumEven[300005] = {};
long long bitCnt(long long ori) {
long long cnt = 0;
while (ori) {
cnt += ori & 1;
ori >>= 1;
}
return cnt;
}
int main() {
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> s[i];
s[i] = bitCnt(s[i]);
}
long long sum = 0;
oddCnt = 0, evenCnt = 1, sumEven[n] = true;
for (long long i = n - 1; i >= 0; --i) {
sum += s[i];
if (sum & 1) {
ans += oddCnt;
oddCnt++;
} else {
ans += evenCnt;
sumEven[i] = true;
evenCnt++;
}
}
for (long long i = 0; i < n; ++i) {
long long sumx = 0, maxi = 0;
for (long long j = i; j < min(n, i + 64LL); ++j) {
if (s[j] > maxi) {
sumx += maxi;
maxi = s[j];
} else {
sumx += s[j];
}
if (sumx < maxi && sumEven[i] == sumEven[j + 1]) {
ans--;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 9;
int n, c[N], sum[N];
long long a[N], cnt[2];
long long lowbit(long long x) { return x & (-x); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
while (a[i]) {
a[i] -= lowbit(a[i]), c[i]++;
}
}
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + c[i];
long long ans = 0;
cnt[0] = 1, cnt[1] = 0;
for (int r = 1; r <= n; r++) {
int l = max(r - 128, 1), mx = c[r];
ans += cnt[sum[r] % 2];
for (int i = r; i >= l; i--) {
mx = max(c[i], mx);
if ((sum[r] - sum[i - 1]) % 2 == 0 && mx > (sum[r] - sum[i - 1] - mx))
ans--;
}
cnt[sum[r] % 2]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5;
inline long long read() {
register long long s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
return (neg ? -s : s);
}
long long a, s[N + 10], sum[N + 10], cnt[2];
inline long long f(long long n) {
long long res = 0;
while (n) res++, n -= n & -n;
return res;
}
signed main() {
a = read();
long long x;
for (long long i = 1; i <= a; i++) {
x = read();
s[i] = f(x);
sum[i] = s[i] + sum[i - 1];
}
long long ans = 0;
cnt[0] = 1;
for (long long i = 1; i <= a; i++) {
ans += cnt[sum[i] & 1];
long long mx = 0;
for (long long j = i, k = 0; j >= 1 && k <= 128; j--) {
mx = max(mx, s[j]);
k += s[j];
if (k < mx * 2 && (sum[j - 1] & 1) == (sum[i] & 1)) ans--;
}
cnt[sum[i] & 1]++;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LEN = (int)3e5;
int n;
int b[LEN];
int cnt[2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
for (int j = 0; j < 61; j++)
if (x & (1LL << j)) b[i]++;
}
cnt[0] = 1;
int sum = 0;
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
sum += b[i];
ans += cnt[sum & 1];
cnt[sum & 1]++;
for (int j = i, lsum = 0, mx = 0; j < min(n, i + 61); j++) {
mx = max(mx, b[j]);
lsum += b[j];
if (mx > lsum - mx && (lsum & 1) == 0) ans--;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long ans = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) ans = (ans << 3) + (ans << 1) + (ch ^ 48), ch = getchar();
return ans;
}
int n;
long long a[300005], sum[300005], sum1[300005], sum2[300005], ans = 0;
inline long long lowbit(long long x) { return x & -x; }
inline int calc(long long x) {
int ret = 0;
while (x) x -= lowbit(x), ++ret;
return ret;
}
int main() {
n = read(), sum2[0] = 1;
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + (a[i] = calc(read()));
for (int i = 1; i <= n; ++i) sum1[i] = sum1[i - 1] + (sum[i] & 1);
for (int i = 1; i <= n; ++i) sum2[i] = sum2[i - 1] + ((sum[i] & 1) ^ 1);
for (int r = 1; r <= n; ++r) {
long long maxn = a[r];
int low = max(1, r - 64);
for (int l = r; l >= low; --l) {
maxn = max(maxn, a[l]);
if ((maxn << 1) <= (sum[r] - sum[l - 1]) &&
(sum[r] & 1) == (sum[l - 1] & 1))
++ans;
}
if (low == 1) continue;
ans += sum[r] & 1 ? sum1[low - 2] : sum2[low - 2];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int inf = 1e18;
const long long int N = 3e5 + 5;
long long int mask[N];
long long int sum[N];
void HyperBeast() {
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i++) {
long long int x;
cin >> x;
mask[i] = __builtin_popcountll(x);
sum[i] = sum[i - 1] + mask[i];
sum[i] %= 2;
}
long long int odd = 0, even = 1;
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
if (sum[i] % 2 == 0) {
ans += even;
even++;
} else {
ans += odd;
odd++;
}
}
for (long long int i = 1; i <= n; i++) {
long long int g = 0, mx = 0;
for (long long int j = i; j <= min(n, i + 100); j++) {
g += mask[j];
mx = max(mx, mask[j]);
if (g % 2 == 0 and 2 * mx > g) {
ans--;
}
}
}
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
HyperBeast();
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300300;
int n, a[N], b[N], c[N * 64], l[N * 64], r[N * 64], st[N][25], lg[N];
long long ans;
int rmq(int i, int j) {
int k = lg[j - i + 1];
return max(st[i][k], st[j - (1 << k) + 1][k]);
}
int main() {
if (fopen("E.in", "r")) freopen("E.in", "r", stdin);
scanf("%d\n", &n);
for (int i = 1; (1 << i) <= n; i++) {
lg[1 << i] = i;
}
for (int i = 1; i <= n; i++) {
if (lg[i] == 0) {
lg[i] = lg[i - 1];
}
long long x;
scanf("%lld ", &x);
a[i] = __builtin_popcountll(x);
st[i][0] = a[i];
b[i] = a[i] + b[i - 1];
if (l[b[i]] == 0) {
l[b[i]] = i;
}
r[b[i]] = i;
}
for (int i = N * 64 - 3; i >= 0; i--) {
c[i] = c[i + 2];
if (l[i] == 0) continue;
c[i] += r[i] - l[i] + 1;
}
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
st[i][j] = max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 128; j += 2) {
int x = l[b[i] + j];
int y = r[b[i] + j];
if (x == 0) continue;
if (b[y] != b[i] + j) {
cout << "wtf";
return 0;
}
if (j >= 2 * rmq(i + 1, y)) {
ans += y - max(x, i) + 1;
}
}
ans += c[b[i] + 130];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline long long read() {
long long x = 0, f = 1;
char c =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
for (; !isdigit(c);
c = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
if (c == '-') f = -1;
for (; isdigit(c);
c = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
x = (x + (x << 2) << 1) + c - 48;
return x * f;
}
int a[N], s[N], s1, s2, n;
long long ans;
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
long long x = read();
while (x) a[i] += x & 1, x >>= 1;
s[i] = s[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
if (s[i] & 1)
ans += s1++;
else
ans += ++s2;
ans -= (a[i] % 2 == 0);
}
for (int i = 1, mx; i <= n; ++i) {
mx = a[i];
for (int j = i + 1; j <= min(i + 60, n); ++j) {
mx = max(mx, a[j]);
if ((s[j] - s[i - 1]) % 2 == 0 && mx > s[j] - s[i - 1] - mx) --ans;
}
}
return !printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
int c = 0;
while (x > 0) {
c += x & 1;
x >>= 1;
}
v[i] = c;
}
vector<vector<int>> dp(n, vector<int>(2, 0));
int s = 0;
for (int i = 0; i < n; i++) {
s += v[i];
dp[i][s & 1] = 1;
if (i) {
dp[i][0] += dp[i - 1][0];
dp[i][1] += dp[i - 1][1];
} else {
dp[i][0]++;
}
}
ll ans = 0;
s = 0;
for (int i = 0; i < n; i++) {
s += v[i];
if (i >= 151) {
ans += i == 151 ? ((s & 1) == 0) : dp[i - 152][s & 1];
}
int cur = v[i];
int mx = v[i];
for (int j = i - 1; j >= max(0, i - 150); j--) {
cur += v[j];
mx = max(mx, v[j]);
if (2 * mx <= cur && cur % 2 == 0) ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 666;
long long saveori[maxn];
long long save[maxn];
long long getcnt(long long x) {
long long cnt = 0;
while (x) {
if (x & 1) cnt++;
x = x >> 1;
}
return cnt;
}
long long cnt[maxn][2];
long long pre[maxn];
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &saveori[i]);
save[i] = getcnt(saveori[i]);
}
long long sum = 0;
for (long long i = 1; i <= n; i++) {
cnt[i][0] = cnt[i - 1][0];
cnt[i][1] = cnt[i - 1][1];
cnt[i][sum % 2]++;
sum += save[i];
pre[i] = sum;
}
long long ans = 0;
for (long long i = n; i >= 1; i--) {
long long maxval = -1;
sum = 0;
for (long long j = i; j >= i - 64 && j > 0; j--) {
sum += save[j];
maxval = max(maxval, save[j]);
if (maxval * 2 <= sum && sum % 2 == 0) {
ans++;
}
}
if (i - 65 >= 1) {
ans += cnt[i - 65][pre[i] % 2];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, odd[maxn], sum[maxn];
long long a, ans, cnt[2][maxn];
inline long long rd() {
long long res = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) res = (res << 3) + (res << 1) + ch - 48;
return res * f;
}
int main() {
n = rd();
for (register int i = 1; i <= n; ++i) {
scanf("%lld", &a);
while (a) {
odd[i] += a & 1;
a >>= 1;
}
sum[i] = sum[i - 1] + odd[i];
}
for (register int i = 1; i <= n; ++i) {
if (odd[i] & 1) {
cnt[0][i] = cnt[1][i - 1];
cnt[1][i] = cnt[0][i - 1] + 1;
} else {
cnt[0][i] = cnt[0][i - 1] + 1;
cnt[1][i] = cnt[1][i - 1];
}
int maxx = -1, p;
ans += cnt[0][i];
for (register int l = 1; l <= 64; ++l) {
p = i - l + 1;
if (p < 1) break;
maxx = max(maxx, odd[p]);
if ((maxx << 1) > sum[i] - sum[p - 1] && !((sum[i] - sum[p - 1]) & 1))
--ans;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> a, pre, ev;
vector<vector<long long>> nxt;
long long n;
long long c2(long long n) { return n * (n - 1) / 2; }
int32_t main() {
cin >> n;
a.resize(n);
pre.assign(n + 1, 0);
ev.assign(2, 0);
ev[0] = 1;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
a[i] = __builtin_popcountll(a[i]);
pre[i + 1] = pre[i] + a[i];
ev[pre[i + 1] % 2]++;
}
nxt.resize(n, vector<long long>(64, n));
long long cnt = c2(ev[1]) + c2(ev[0]);
for (long long l = 0; l < n; ++l) {
long long su = 0, mx = 0;
for (long long r = l; r < min(n, l + 125); ++r) {
su += a[r];
mx = max(mx, a[r]);
if (su < 2LL * mx && su % 2 == 0) cnt--;
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 64;
long long a[400100];
long long Prefix[400100];
long long PreOdd[400100];
long long PreEven[400100];
long long PopCount(long long x) {
long long Res = 0;
for (long long i = 0; i < 64; i++) Res += ((x & (1LL << i)) != 0);
return Res;
}
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
a[i] = PopCount(a[i]);
Prefix[i] = a[i] + Prefix[i - 1];
PreOdd[i] = (Prefix[i] & 1) + PreOdd[i - 1];
PreEven[i] = !(Prefix[i] & 1) + PreEven[i - 1];
}
long long Answer = 0;
for (long long i = 1; i <= n; i++) {
long long Max = 0;
long long Sum = 0;
for (long long j = i; j <= n; j++) {
Sum += a[j];
Max = max(Max, a[j]);
if (Sum - M >= M) {
if (Prefix[i - 1] & 1)
Answer += PreOdd[n] - PreOdd[j - 1];
else
Answer += PreEven[n] - PreEven[j - 1];
break;
}
if (Sum - Max >= Max && (!(Sum & 1))) Answer++;
}
}
cout << Answer;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[300005], s[300005], od[2], mx;
long long x, ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
for (; x; x >>= 1) a[i] += (x & 1);
}
for (int i = 1, j = 0; i <= n; i++) {
s[i] = s[i - 1] + a[i];
mx = 0;
for (int k = i; k && k > i - 130; k--) {
mx = max(mx, a[k]);
if ((s[i] - s[k - 1]) % 2 == 0 && mx * 2 <= s[i] - s[k - 1]) ans++;
}
if (i > 130) {
od[s[j] & 1]++;
ans += od[s[i] & 1];
j++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
vector<ll> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i];
v[i] = __builtin_popcountll(v[i]);
}
ll ans = 0, sum = 0;
vector<vector<ll>> dp(n + 1, vector<ll>(2));
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
ll tmp = 0, sub = 0, hi = 0;
for (int j = i; j > 0 && j >= i - 64; j--) {
tmp += v[j];
hi = max(hi, v[j]);
if (hi > tmp - hi && (tmp & 1LL) == 0) sub++;
}
sum += v[i];
dp[i][0] = dp[i - 1][0];
dp[i][1] = dp[i - 1][1];
dp[i][sum & 1LL]++;
ans += dp[i - 1][sum & 1LL];
ans -= sub;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MAXN = (int)3e5 + 5;
const int MOD = (int)998244353;
int n;
ll a[MAXN], sol;
int oddcnt[MAXN], evencnt[MAXN];
int cnt_bits(ll x) {
int ret = 0;
for (int i = 0; i < 63; ++i)
if (x & (1LL << i)) ret++;
return ret;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
a[i] = cnt_bits(a[i]);
}
int odd_cnt = 0, even_cnt = 0, sum = 0;
for (int i = 1; i <= n; ++i) {
ll temp_sum = a[i], temp_max = a[i];
for (int j = i - 1; j >= max(1, i - 130); --j) {
temp_sum += a[j];
temp_max = max(temp_max, a[j]);
if (temp_sum % 2 == 0 && temp_max <= temp_sum / 2) sol++;
}
sum += a[i];
if (sum % 2)
sol += oddcnt[max(1, i - 130) - 1];
else
sol += evencnt[max(1, i - 130) - 1];
sum -= a[i];
if (sum % 2)
odd_cnt++;
else
even_cnt++;
oddcnt[i] = odd_cnt;
evencnt[i] = even_cnt;
sum += a[i];
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAGIC = 70;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
a[i] = __builtin_popcountll(x);
}
long long answer = 0;
vector<int> pref(n);
for (int i = 0; i < n; ++i) {
pref[i] = a[i];
if (i != 0) {
pref[i] += pref[i - 1];
}
}
int even = 0, odd = 0;
for (int i = 0; i < n; ++i) {
if (pref[i] % 2) {
++odd;
} else {
++even;
}
}
++even;
auto f = [&](int x) { return (long long)x * (x - 1) / 2; };
answer = f(even) + f(odd);
for (int L = 0; L < n; ++L) {
int sum = 0;
int big = 0;
for (int R = L; R < min(n, L + MAGIC); ++R) {
sum += a[R];
big = max(big, a[R]);
if (sum % 2 == 0 && 2 * big > sum) {
--answer;
}
}
}
cout << answer << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
inline int readInt() {
int x;
scanf("%d", &x);
return x;
}
const int N = 300003;
long long dp[2][61][61];
int bitcount(long long x) {
int ret = 0;
while (x) {
if (x & 1LL) ret++;
x >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
dp[0][0][0] = 1LL;
long long ret = 0;
for (int i = 0; i < (int)n; ++i) {
memset(dp[(i + 1) & 1], 0, sizeof(dp[(i + 1) & 1]));
dp[(i + 1) & 1][0][0] = 1;
long long x;
cin >> x;
int b = bitcount(x);
for (int j = 0; j < (int)61; ++j) {
for (int k = j; k <= 60; k += 2) {
int y;
if (j - b <= 0 && k - b >= 0)
y = (j + b) % 2;
else
y = min(abs(j - b), abs(k - b));
dp[(i + 1) & 1][y][min(b + k, 60 - (b + k) % 2)] += dp[i & 1][j][k];
}
}
for (int j = 1; j < (int)61; ++j) ret += dp[(i + 1) & 1][0][j];
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long a[N];
int32_t tree[N << 2], bit_cnt[N];
struct seg_tree {
long long combine(long long x, long long y) { return max(x, y); }
void build(long long l, long long r, long long node) {
if (l == r) {
tree[node] = bit_cnt[l];
return;
}
long long mid = (l + r) >> 1, lc = node + node, rc = 1 + lc;
build(l, mid, lc);
build(mid + 1, r, rc);
tree[node] = combine(tree[lc], tree[rc]);
}
long long query(long long l, long long r, long long ql, long long qr,
long long node) {
if (qr < l || r < ql) return 0;
if (ql <= l and r <= qr) {
return tree[node];
}
long long mid = (l + r) >> 1, lc = node + node, rc = 1 + lc;
return combine(query(l, mid, ql, qr, lc), query(mid + 1, r, ql, qr, rc));
}
};
long long dp[N][2];
long long prefix_sum[N];
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
bit_cnt[i] = __builtin_popcountll(a[i]);
}
seg_tree ins;
ins.build(1, n, 1);
for (long long i = 1; i <= n; ++i) {
prefix_sum[i] = bit_cnt[i] + prefix_sum[i - 1];
}
dp[0][0] = 1;
map<long long, long long> mp;
mp[0] = 1;
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
long long c = prefix_sum[i] & 1LL;
dp[i][0] = dp[i - 1][0];
dp[i][1] = dp[i - 1][1];
dp[i][c] += 1;
ans += dp[i - 1][c];
long long res = -1, mx = bit_cnt[i];
long long sum = 0;
for (long long j = i; i - j <= 62 && j > 0; --j) {
mx = max(mx, (long long)bit_cnt[j]);
sum += bit_cnt[j];
if ((sum - mx < mx) && (sum & 1) == 0) {
--ans;
}
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 1; i <= t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3e5 + 5;
long long a[M], b[M], f[2], res;
int n;
int cal(long long x) {
int cnt = 0;
while (x) {
cnt += (x & 1);
x >>= 1;
}
return cnt;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = cal(a[i]);
}
f[0] = 1;
for (int i = 1; i <= n; i++) {
b[i] += b[i - 1];
res += f[b[i] & 1];
long long mx = b[i] - b[i - 1];
for (int j = i; j >= 1 && j >= i - 62; j--) {
mx = max(mx, b[j] - b[j - 1]);
if (mx > b[i] - b[j - 1] - mx && (b[i] & 1) == (b[j - 1] & 1)) {
res--;
}
}
f[b[i] & 1]++;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
int nn;
int *arra, *arrw;
long long int *suml, *sumr, *sum;
long long int mod = 1E9 + 7;
int mx;
long sm;
bool TEST = 0;
void read() {
cin >> n >> q;
nn = ceil(log2(n)) * n - 1;
if (nn < 5) nn = 5;
arra = new int[n];
arrw = new int[n];
suml = new long long int[nn];
sumr = new long long int[nn];
sum = new long long int[nn];
sm = 0;
for (int i = 0; i < n; i++) {
cin >> arra[i];
arra[i]--;
}
for (int i = 0; i < n; i++) {
cin >> arrw[i];
sm += arrw[i];
}
mx = arra[n - 1];
}
long long int getValLeft(int ind) {
long long int w = arrw[ind];
w *= arra[ind] - ((long long int)ind);
w %= mod;
return w;
}
long long int getVal(int ind) { return arrw[ind]; }
long long int getValRight(int ind) {
long long int w = arrw[ind];
w *= ((long long int)mx) - ((long long int)arra[ind]) -
((long long int)(n - ind - 1));
w %= mod;
return w;
}
long long int buildSeg(long long int *arr, long long int (*val)(int), int s,
int e, int i, bool ismod = true) {
if (s == e) {
arr[i] = val(s);
if (ismod) arr[i] %= mod;
return arr[i];
}
int m = (s + e) / 2;
arr[i] = (buildSeg(arr, val, s, m, i * 2 + 1, ismod) +
buildSeg(arr, val, m + 1, e, i * 2 + 2, ismod));
if (ismod) arr[i] %= mod;
return arr[i];
}
long long int sumSeg(long long int *arr, int s, int e, int i, int rs, int re,
bool ismod = true) {
if (s >= rs && e <= re) return arr[i];
if (e < rs || s > re) return 0;
int m = (s + e) / 2;
long long int res = sumSeg(arr, s, m, i * 2 + 1, rs, re, ismod);
res += sumSeg(arr, m + 1, e, i * 2 + 2, rs, re, ismod);
if (ismod) res %= mod;
return res;
}
void updateSeg(long long int *arr, int s, int e, int i, int ind,
long long int diff, bool ismod = true) {
if (ind < s || ind > e) return;
arr[i] = (arr[i] + diff);
if (ismod) arr[i] %= mod;
if (s == e) return;
int m = (s + e) / 2;
updateSeg(arr, s, m, i * 2 + 1, ind, diff, ismod);
updateSeg(arr, m + 1, e, i * 2 + 2, ind, diff, ismod);
}
int segIndex(long long int *arr, int s, int e, int i, long long int sml) {
if (s == e) return s;
int m = (s + e) / 2;
if (arr[i * 2 + 1] > sml) return segIndex(arr, s, m, i * 2 + 1, sml);
return segIndex(arr, m + 1, e, i * 2 + 2, sml - arr[i * 2 + 1]);
}
int getMedian(int s, int e) {
long long int sml = sumSeg(sum, 0, n - 1, 0, s, e, false);
long long int smlb = 0;
if (s > 0) smlb = sumSeg(sum, 0, n - 1, 0, 0, s - 1, false);
int ind = segIndex(sum, 0, n - 1, 0, smlb + sml / 2);
return ind;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
buildSeg(suml, getValLeft, 0, n - 1, 0);
buildSeg(sumr, getValRight, 0, n - 1, 0);
buildSeg(sum, getVal, 0, n - 1, 0, false);
if (TEST) {
cout << endl << "--------------" << endl;
for (int i = 0; i < nn; i++) cout << sum[i] << " ";
cout << endl;
for (int i = 0; i < n; i++) cout << getVal(i) << " ";
cout << endl;
for (int i = 0; i < n; i++) cout << getValLeft(i) << " ";
cout << endl;
for (int i = 0; i < n; i++) cout << getValRight(i) << " ";
cout << endl;
cout << "--------------" << endl;
}
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
x--;
int vl = getValLeft(x);
int vr = getValRight(x);
int vm = getVal(x);
arrw[x] = y;
int nl = getValLeft(x);
int nr = getValRight(x);
int nm = y;
int dl = ((nl - vl) + mod * 2) % mod;
int dr = ((nr - vr) + mod * 2) % mod;
int dm = nm - vm;
updateSeg(suml, 0, n - 1, 0, x, dl);
updateSeg(sumr, 0, n - 1, 0, x, dr);
updateSeg(sum, 0, n - 1, 0, x, dm, false);
} else {
x--;
y--;
int med = getMedian(x, y);
long long int need = 0;
int pb, pa, tb, ta;
pa = med + 1;
pb = med;
long long int smm = sumSeg(sum, 0, n - 1, 0, x, y, false);
if (TEST) {
cout << "-------------" << endl;
cout << smm << " " << med << endl;
}
if (smm % 2) {
pb--;
tb = arra[med] - 1;
ta = arra[med] + 1;
} else {
long long int sb = 0;
if (med > x) sb = sumSeg(sum, 0, n - 1, 0, x, med - 1, false);
if (sb == smm / 2) {
pa = pb;
pb = pb - 1;
tb = (arra[pb] + arra[pa]) / 2;
ta = tb + 1;
} else {
pb--;
tb = arra[med] - 1;
ta = arra[med] + 1;
}
}
if (TEST) {
cout << pb << " " << pa << endl;
cout << tb << " " << ta << endl;
}
if (pb >= x) {
if (TEST)
cout << "L: " << (sumSeg(sumr, 0, n - 1, 0, x, pb) % mod) << " - "
<< (sumSeg(sum, 0, n - 1, 0, x, pb)) << " * "
<< (((mx - tb - (n - pb)) + 1) % mod) << endl;
need = ((need + sumSeg(sumr, 0, n - 1, 0, x, pb) % mod -
(sumSeg(sum, 0, n - 1, 0, x, pb) *
(((mx - tb - (n - pb)) + 1) % mod)) %
mod) +
mod) %
mod;
}
if (pa <= y) {
if (TEST)
cout << "R: " << (sumSeg(suml, 0, n - 1, 0, pa, y) % mod) << " - "
<< (sumSeg(sum, 0, n - 1, 0, pa, y)) << " * " << (ta - pa)
<< endl;
need = ((need + sumSeg(suml, 0, n - 1, 0, pa, y) % mod -
(sumSeg(sum, 0, n - 1, 0, pa, y) * (ta - pa)) % mod) +
mod) %
mod;
}
if (TEST) cout << "-------------" << endl;
cout << need << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long ans = 0, w = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') w = -1, c = getchar();
while (isdigit(c)) ans = (ans << 1) + (ans << 3) + c - '0', c = getchar();
return ans * w;
}
long long sum1[300010 << 2], sum2[300010 << 2];
int a[300010], w[300010];
int n, q;
long long mod(long long a) {
a %= 1000000007;
if (a < 0) a += 1000000007;
return a;
}
long long add(long long a, long long b) { return mod(a + b); }
long long mul(long long a, long long b) { return mod(a * b); }
void pushup1(int t) { sum1[t] = sum1[(t << 1)] + sum1[(t << 1 | 1)]; }
void pushup2(int t) { sum2[t] = add(sum2[(t << 1)], sum2[(t << 1 | 1)]); }
void modify1(int t, int l, int r, int pos, long long vl) {
if (l == r) {
sum1[t] = vl;
return;
}
if (pos <= ((l + r) >> 1))
modify1((t << 1), l, ((l + r) >> 1), pos, vl);
else
modify1((t << 1 | 1), ((l + r) >> 1) + 1, r, pos, vl);
pushup1(t);
}
void modify2(int t, int l, int r, int pos, long long vl) {
if (l == r) {
sum2[t] = vl;
return;
}
if (pos <= ((l + r) >> 1))
modify2((t << 1), l, ((l + r) >> 1), pos, vl);
else
modify2((t << 1 | 1), ((l + r) >> 1) + 1, r, pos, vl);
pushup2(t);
}
long long qry1(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum1[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans += qry1((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
ans += qry1(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
return ans;
}
long long qry2(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum2[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans = qry2((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
(ans += qry2(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr)) %= 1000000007;
return ans;
}
int query1_pos(int t, int l, int r, int L, int R, long long vl) {
if (l == r) return l;
if (R <= ((l + r) >> 1))
return query1_pos((t << 1), l, ((l + r) >> 1), L, R, vl);
if (L > ((l + r) >> 1))
return query1_pos((t << 1 | 1), ((l + r) >> 1) + 1, r, L, R, vl);
long long suml = qry1((t << 1), l, ((l + r) >> 1), L, ((l + r) >> 1));
if (suml >= vl)
return query1_pos((t << 1), l, ((l + r) >> 1), L, ((l + r) >> 1), vl);
else
return query1_pos((t << 1 | 1), ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1,
R, vl - suml);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), a[i] -= i;
for (int i = 1; i <= n; ++i) scanf("%d", w + i);
for (int i = 1; i <= n; ++i) {
modify1(1, 1, n, i, w[i]);
modify2(1, 1, n, i, mul(a[i], w[i]));
}
while (q--) {
int first = read(), second = read();
if (first < 0) {
first = -first;
w[first] = second;
modify1(1, 1, n, first, w[first]);
modify2(1, 1, n, first, mul(a[first], w[first]));
} else {
long long sum = qry1(1, 1, n, first, second);
int l = first, r = second, pos = -1;
while (l <= r) {
if (2 * qry1(1, 1, n, first, ((l + r) >> 1)) >= sum)
pos = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
long long ans = 0;
ans = add(ans, mul(a[pos], add(qry1(1, 1, n, first, pos),
-qry1(1, 1, n, pos, second))));
ans =
add(ans, add(-qry2(1, 1, n, first, pos), qry2(1, 1, n, pos, second)));
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
const int MOD = 1E9 + 7;
int Add(int a, int b, int m = MOD) {
a += b;
if (a >= m) a -= m;
return a;
}
int Sub(int a, int b, int m = MOD) {
a -= b;
if (a < 0) a += m;
return a;
}
int AddTo(int& to, int w, int m = MOD) {
to += w;
if (to >= m) to -= m;
return to;
}
int SubTo(int& to, int w, int m = MOD) {
to -= w;
if (to < 0) to += m;
return to;
}
int Mult(int a, int b, int m = MOD) { return (a * 1LL * b) % m; }
struct Bit {
vector<int> sum;
Bit() { sum.resize(MAXN, 0); }
void BitAdd(int pos, int w) {
for (++pos; pos < MAXN; pos += (pos & (-pos))) AddTo(sum[pos], w);
}
void BitSub(int pos, int w) {
for (++pos; pos < MAXN; pos += (pos & (-pos))) SubTo(sum[pos], w);
}
int BitGet(int l, int r) {
int res = 0;
for (++r; r > 0; r -= (r & (-r))) AddTo(res, sum[r]);
for (; l > 0; l -= (l & (-l))) SubTo(res, sum[l]);
return res;
}
};
struct BitReg {
vector<long long> sum;
BitReg() { sum.resize(MAXN, 0); }
void BitAdd(int pos, int w) {
for (++pos; pos < MAXN; pos += (pos & (-pos))) sum[pos] += w;
}
void BitSub(int pos, int w) {
for (++pos; pos < MAXN; pos += (pos & (-pos))) sum[pos] -= w;
}
long long BitGet(int l, int r) {
long long res = 0;
for (++r; r > 0; r -= (r & (-r))) res += sum[r];
for (; l > 0; l -= (l & (-l))) res -= sum[l];
return res;
}
};
int n, q;
int a_[MAXN], w_[MAXN];
int a[MAXN], w[MAXN];
Bit lr, rl;
BitReg sumw;
void Update(int i, int na, int nw) {
sumw.BitSub(i, w[i]);
lr.BitSub(i, Mult(Sub(i, a[i]), w[i]));
rl.BitSub(i, Mult(Sub(a[i], i), w[i]));
a[i] = na;
w[i] = nw;
sumw.BitAdd(i, w[i]);
lr.BitAdd(i, Mult(Sub(i, a[i]), w[i]));
rl.BitAdd(i, Mult(Sub(a[i], i), w[i]));
}
int Eval(int l, int r, int mid, int start) {
int ans = 0;
if (l <= mid) {
int koef = Sub(start, l);
AddTo(ans, lr.BitGet(l, mid));
AddTo(ans, Mult(koef, sumw.BitGet(l, mid) % MOD));
}
if (mid + 1 <= r) {
int pos = start + mid + 1 - l;
int koef = Sub(mid + 1, pos);
AddTo(ans, rl.BitGet(mid + 1, r));
AddTo(ans, Mult(koef, sumw.BitGet(mid + 1, r) % MOD));
}
return ans;
}
int GetMid(int l, int r, int start) {
if (a[l] > start) return l - 1;
int lo = l, hi = r, mid;
for (;;) {
if (lo + 1 >= hi) {
if (a[hi] <= start + hi - l)
return hi;
else
return lo;
}
mid = (lo + hi) >> 1;
if (a[mid] <= start + mid - l)
lo = mid;
else
hi = mid;
}
}
int EvalAtStart(int l, int r, int start) {
int mid = GetMid(l, r, start);
return Eval(l, r, mid, start);
}
int Solve(int l, int r) {
long long total = sumw.BitGet(l, r);
int lo = l, hi = r, mid;
for (;;) {
if (lo + 1 >= hi) {
if (2 * sumw.BitGet(l, lo) >= total)
mid = lo;
else
mid = hi;
break;
}
mid = (lo + hi) >> 1;
if (2 * sumw.BitGet(l, mid) <= total)
lo = mid;
else
hi = mid;
}
return EvalAtStart(l, r, a[mid] - (mid - l));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) scanf("%d", &a_[i]);
for (int i = 0; i < n; ++i) scanf("%d", &w_[i]);
for (int i = 0; i < n; ++i) Update(i, a_[i], w_[i]);
for (int i = 0; i < q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x > 0) {
--x, --y;
printf("%d\n", Solve(x, y));
} else {
x = -x - 1;
Update(x, a[x], y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
const long long M = 1e9 + 7;
struct BIT {
int n;
long long b[N];
void init(int _n) {
n = _n;
fill(b, b + n + 1, 0);
}
void add(int i, long long x) {
for (; i <= n; i += i & -i) {
b[i] += x;
}
}
long long sum(int i) {
long long s = 0;
for (; i > 0; i -= i & -i) {
s += b[i];
}
return s;
}
} B, B2;
int n, q, x, y, a[N], w[N];
bool check(int L, int R, int p) {
long long sl = B.sum(p) - B.sum(L - 1);
long long sr = B.sum(R) - B.sum(p);
return sl >= sr;
}
int get_pos(int L, int R) {
int l = L, r = R, mid, res;
while (l <= r) {
mid = (l + r) / 2;
if (check(L, R, mid)) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
return res;
}
int main() {
scanf("%d %d", &n, &q);
B.init(n);
B2.init(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
B.add(i, w[i]);
long long val = (long long)(a[i] - i) * w[i] % M;
B2.add(i, val);
}
while (q--) {
scanf("%d %d", &x, &y);
if (x < 0) {
x = -x;
B.add(x, y - w[x]);
long long det = (long long)(a[x] - x) * (y - w[x] + M) % M;
B2.add(x, det);
w[x] = y;
} else {
int p = get_pos(x, y);
long long ans = 0;
ans += (a[p] - p) * ((B.sum(p) - B.sum(x - 1)) % M) % M;
ans += M - (B2.sum(p) % M - B2.sum(x - 1) % M + M) % M;
ans += B2.sum(y) % M - B2.sum(p) % M + M;
ans += M - (a[p] - p) * ((B.sum(y) - B.sum(p)) % M) % M;
ans %= M;
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 5;
const int mod = 1000000007;
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
int f = 1;
static char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
inline void write(long long x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
int n, Q;
long long a[N], w[N], b[N];
struct Tree {
int l, r;
long long sum, s;
} tree[4 * N];
inline void pushup(int now) {
tree[now].sum = tree[now << 1].sum + tree[now << 1 | 1].sum;
tree[now].s = (tree[now << 1].s + tree[now << 1 | 1].s) % mod;
}
inline void build(int now, int l, int r) {
tree[now].l = l, tree[now].r = r;
if (l == r) {
tree[now].sum = w[l];
tree[now].s = b[l] * w[l] % mod;
return;
}
int m = (l + r) >> 1;
build(now << 1, l, m);
build(now << 1 | 1, m + 1, r);
pushup(now);
}
inline long long query(int now, int l, int r) {
if (l <= tree[now].l && tree[now].r <= r) return tree[now].sum;
int m = (tree[now].l + tree[now].r) >> 1;
long long ans = 0;
if (l <= m) ans += query(now << 1, l, r);
if (r > m) ans += query(now << 1 | 1, l, r);
return ans;
}
inline void update(int now, int pos, int x) {
if (tree[now].l == tree[now].r) {
tree[now].sum = x;
tree[now].s = b[pos] * x % mod;
return;
}
int m = (tree[now].l + tree[now].r) >> 1;
if (pos <= m)
update(now << 1, pos, x);
else
update(now << 1 | 1, pos, x);
pushup(now);
}
inline long long ask(int now, int l, int r) {
if (l <= tree[now].l && tree[now].r <= r) return tree[now].s;
int m = (tree[now].l + tree[now].r) >> 1;
long long ans = 0;
if (l <= m) ans = (ans + ask(now << 1, l, r)) % mod;
if (r > m) ans = (ans + ask(now << 1 | 1, l, r)) % mod;
return ans;
}
inline void Solve(int l, int r) {
int L = l, R = r, ans = l;
while (L <= R) {
int mid = (L + R) >> 1;
long long QL = query(1, l, mid), QR = query(1, mid + 1, r);
if (QL >= QR)
ans = mid, R = mid - 1;
else
L = mid + 1;
}
long long t1 = (query(1, l, ans - 1) % mod * (a[ans] - ans) % mod -
ask(1, l, ans - 1) + mod) %
mod;
long long t2 = (query(1, ans + 1, r) % mod * (ans - a[ans] + mod) % mod +
ask(1, ans + 1, r) % mod) %
mod;
write((t1 + t2) % mod);
putchar('\n');
}
int main() {
read(n), read(Q);
for (int i = 1; i <= n; i++) read(a[i]), b[i] = a[i] - i;
for (int i = 1; i <= n; i++) read(w[i]);
build(1, 1, n);
int l, r;
while (Q--) {
read(l), read(r);
if (l < 0) update(1, -l, r);
if (l > 0) Solve(l, r);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inline read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const long long maxn = 200010, mod = 1e9 + 7, M = 1e9;
long long n, q, a[maxn], w[maxn];
struct BIT {
long long sum[maxn];
void update(long long x, long long k, long long op) {
for (long long i = x; i <= n; i += i & (-i)) {
sum[i] = sum[i] + k;
if (op) sum[i] %= mod;
}
}
long long Query(long long x, long long op) {
long long ans = 0;
for (long long i = x; i; i -= i & (-i)) {
ans = ans + sum[i];
if (op) ans %= mod;
}
return ans;
}
long long Q(long long l, long long r, long long op) {
long long ans = Query(r, op) - Query(l - 1, op);
if (op) ans = (ans + mod) % mod;
return ans;
}
} sum, cnt;
signed main() {
n = read();
q = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) w[i] = read();
for (long long i = 1; i <= n; i++)
sum.update(i, w[i], 0), cnt.update(i, (a[i] - i) * w[i], 1);
for (long long i = 1; i <= q; i++) {
long long l = read(), r = read();
if (l <= 0) {
l = -l;
sum.update(l, -w[l], 0);
cnt.update(l, -(a[l] - l) * w[l], 1);
w[l] = r;
sum.update(l, w[l], 0);
cnt.update(l, (a[l] - l) * w[l], 1);
} else {
if (l == r) {
cout << 0 << endl;
continue;
}
long long L = l, R = r, ans = 0, res;
while (L <= R) {
long long mid = L + R >> 1;
if (sum.Q(l, mid, 0) >= sum.Q(mid + 1, r, 0))
res = mid, R = mid - 1;
else
L = mid + 1;
}
L = res;
ans = (sum.Q(l, L, 1) % mod * (a[L] - L) % mod - cnt.Q(l, L, 1) % mod +
mod) %
mod;
ans = ((ans + cnt.Q(L, r, 1) % mod) % mod -
sum.Q(L, r, 1) % mod * (a[L] - L) % mod + mod) %
mod;
cout << (ans + mod) % mod << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int BUFFER_SIZE = 4096;
char input_buffer[BUFFER_SIZE];
int input_pos = BUFFER_SIZE;
int input_read = BUFFER_SIZE;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
uint8_t lookup[100];
void _update_input_buffer() {
if (input_pos >= input_read && input_read == BUFFER_SIZE) {
input_read = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
}
}
char next_char(bool advance = true) {
_update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
template <typename T>
void read_int(T &number) {
while (isspace(next_char(false))) next_char();
bool negative = next_char(false) == '-';
if (negative) next_char();
number = 0;
while (isdigit(next_char(false))) number = 10 * number + (next_char() - '0');
if (negative) number = -number;
}
void flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
void write_char(char c) {
if (output_pos == BUFFER_SIZE) flush_output();
output_buffer[output_pos++] = c;
}
template <typename T>
void write_int(T number, char after = 0) {
if (number < 0) {
write_char('-');
number = -number;
}
static char number_buffer[100];
int length = 0;
do {
if (number < 10) {
number_buffer[length++] = number + '0';
number = 0;
} else {
uint8_t lookup_value = lookup[number % 100];
number /= 100;
number_buffer[length++] = (lookup_value & 15) + '0';
number_buffer[length++] = (lookup_value >> 4) + '0';
}
} while (number > 0);
for (int i = length - 1; i >= 0; i--) write_char(number_buffer[i]);
if (after) write_char(after);
}
void init() {
bool exit_success = atexit(flush_output) == 0;
assert(exit_success);
for (int i = 0; i < 100; i++) lookup[i] = (i / 10 << 4) + i % 10;
}
} // namespace IO
const int MOD = 1e9 + 7;
template <typename T1, typename T2>
void mod_add(T1 &a, T2 b) {
a += b;
if (a >= MOD) a -= MOD;
}
struct tree_node {
long long w_sum;
int aw_sum;
tree_node() : w_sum(0), aw_sum(0) {}
void join(const tree_node &other) {
w_sum += other.w_sum;
mod_add(aw_sum, other.aw_sum);
}
};
int N, LOG, Q;
vector<int> A, W;
vector<tree_node> tree;
void build_tree() {
for (int i = 1; i <= N; i++) {
for (int k = (i & -i) >> 1; k > 0; k >>= 1) tree[i].join(tree[i - k]);
tree[i].w_sum += W[i - 1];
tree[i].aw_sum = (tree[i].aw_sum + (long long)W[i - 1] * A[i - 1]) % MOD;
}
}
void tree_update(int index, long long w_change, int a) {
int aw_change = (MOD + w_change) * a % MOD;
for (int i = index + 1; i <= N; i += i & -i) {
tree[i].w_sum += w_change;
mod_add(tree[i].aw_sum, aw_change);
}
}
tree_node tree_query(int count) {
tree_node answer;
for (int i = count; i > 0; i -= i & -i) answer.join(tree[i]);
return answer;
}
int solve(int start, int end) {
tree_node tree_end = tree_query(end);
tree_node tree_start = tree_query(start);
long long search = (tree_end.w_sum + tree_start.w_sum + 1) / 2;
int goal = 0;
long long w_sum = 0, aw_sum = 0;
for (int k = LOG - 1; k >= 0; k--)
if (goal + (1 << k) <= N && search > w_sum + tree[goal + (1 << k)].w_sum) {
goal += 1 << k;
w_sum += tree[goal].w_sum;
aw_sum += tree[goal].aw_sum;
}
assert(start <= goal && goal < end);
long long result =
((w_sum - tree_start.w_sum) - (tree_end.w_sum - w_sum)) % MOD * A[goal] +
(tree_end.aw_sum - aw_sum) - (aw_sum - tree_start.aw_sum);
result %= MOD;
mod_add(result, MOD);
return result;
}
int main() {
IO::init();
IO::read_int(N);
IO::read_int(Q);
A.resize(N);
W.resize(N);
LOG = 32 - __builtin_clz(N);
assert(1 << LOG > N);
tree.resize(N + 1);
for (int i = 0; i < N; i++) {
IO::read_int(A[i]);
A[i] -= i;
}
for (int i = 0; i < N; i++) IO::read_int(W[i]);
build_tree();
for (int q = 0; q < Q; q++) {
int x, y;
IO::read_int(x);
IO::read_int(y);
if (x < 0) {
x = -x - 1;
tree_update(x, y - W[x], A[x]);
W[x] = y;
} else {
IO::write_int(solve(x - 1, y), '\n');
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int mod = 1000000007;
long long a[maxn], w[maxn];
long long pos[maxn];
int n, q;
struct Bit {
long long sum[maxn];
int n;
bool mod_flag;
Bit(int n_) {
n = n_;
mod_flag = true;
memset(sum, 0, sizeof sum);
}
void init(int n_, bool flag = true) {
n = n_;
mod_flag = flag;
}
void add(int x, long long val) {
while (x <= n) {
sum[x] += val;
if (mod_flag) {
if (sum[x] < 0) sum[x] += mod;
if (sum[x] >= mod) sum[x] %= mod;
}
x += x & -x;
}
}
long long get(int x) {
long long res = 0;
while (x) {
res += sum[x];
if (mod_flag) {
if (res >= mod) res %= mod;
}
x -= x & -x;
}
return res;
}
long long query(int l, int r) {
long long res = get(r) - get(l - 1);
if (mod_flag) {
res = (res + mod) % mod;
}
return res;
}
};
Bit bit1(maxn), bit2(maxn), bit3(maxn);
int main() {
cin >> n >> q;
int m = 1e9;
bit1.init(n, false);
bit2.init(n);
bit3.init(n);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
cin >> w[i];
pos[i] = m - (n - i);
bit1.add(i, w[i]);
bit2.add(i, w[i] * (a[i] - i));
bit3.add(i, w[i] * (pos[i] - a[i]));
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
int id = -x;
bit1.add(id, -w[id]);
bit2.add(id, (a[id] - id) * (mod - w[id]));
bit3.add(id, (pos[id] - a[id]) * (mod - w[id]));
w[id] = y;
bit1.add(id, w[id]);
bit2.add(id, (a[id] - id) * w[id]);
bit3.add(id, (pos[id] - a[id]) * w[id]);
} else {
long long res = bit1.get(y) - bit1.get(x - 1);
long long middlesum = res / 2;
int l = x, r = y, opt = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (bit1.get(m) - bit1.get(x - 1) > middlesum)
r = m - 1, opt = m;
else
l = m + 1;
}
long long ans = 0;
if (opt < y) {
long long diff = a[opt] - opt;
long long rsum = bit1.query(opt + 1, y) % mod;
ans = (ans + bit2.query(opt + 1, y) - rsum * diff % mod + mod) % mod;
}
if (opt > x) {
long long diff = pos[opt] - a[opt];
long long lsum = bit1.query(x, opt - 1) % mod;
ans = (ans + bit3.query(x, opt - 1) - lsum * diff % mod + mod) % mod;
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
long long mod(long long a) {
a %= P;
if (a < 0) a += P;
return a;
}
long long add(long long a, long long b) { return mod(a + b); }
long long mul(long long a, long long b) { return mod(a * b); }
const long long N = 1e6 + 10;
long long n, q, pos;
long long a[N], w[N];
long long s1[N << 2], s2[N << 2], sum;
void pu(long long o) {
s1[o] = s1[(o << 1)] + s1[((o << 1) | 1)];
s2[o] = (s2[(o << 1)] + s2[((o << 1) | 1)]) % P;
}
void update(long long o, long long l, long long r, long long first,
long long v) {
if (l == r) {
s1[o] = v;
s2[o] = (long long)v * a[l] % P;
return;
}
if (((l + r) >> 1) >= first)
update((o << 1), l, ((l + r) >> 1), first, v);
else
update(((o << 1) | 1), ((l + r) >> 1) + 1, r, first, v);
pu(o);
}
long long qry1(long long o, long long l, long long r, long long ql,
long long qr) {
if (ql <= l && r <= qr) return s1[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans += qry1((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
ans += qry1(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
return ans;
}
long long qry2(long long o, long long l, long long r, long long ql,
long long qr) {
if (ql <= l && r <= qr) return s2[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans = qry2((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
(ans += qry2(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr)) %= P;
return ans;
}
void find(long long o, long long l, long long r, long long ql, long long qr) {
if (ql <= l && r <= qr) {
if (l == r || sum == s1[o]) pos = r;
if (sum >= s1[o])
sum -= s1[o];
else
find((o << 1), l, ((l + r) >> 1), ql, qr);
return;
}
if (((l + r) >> 1) >= ql) find((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr) find(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
}
void build(long long o, long long l, long long r) {
if (l == r) {
s1[o] = w[l], s2[o] = (long long)a[l] * w[l] % P;
return;
}
build((o << 1), l, ((l + r) >> 1)),
build(((o << 1) | 1), ((l + r) >> 1) + 1, r);
pu(o);
}
long long qry(long long l, long long r) {
return add(qry2(1, 1, n, l, r), -mul(qry1(1, 1, n, l, r), a[pos]));
}
signed main() {
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; ++i) scanf("%lld", a + i), a[i] -= i;
for (long long i = 1; i <= n; ++i) scanf("%lld", w + i);
build(1, 1, n);
for (long long i = 1; i <= q; ++i) {
long long first, second;
scanf("%lld%lld", &first, &second);
if (first < 0)
update(1, 1, n, -first, second);
else {
long long sum = qry1(1, 1, n, first, second);
long long l = first, r = second, ans = -1;
while (l <= r) {
if (2 * qry1(1, 1, n, first, ((l + r) >> 1)) >= sum)
ans = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
pos = ans;
{
long long ans = 0;
ans = add(ans, mul(a[pos], add(qry1(1, 1, n, first, pos),
-qry1(1, 1, n, pos, second))));
ans = add(ans,
add(-qry2(1, 1, n, first, pos), qry2(1, 1, n, pos, second)));
printf("%lld\n", ans);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Box {
long long w, x;
};
struct Fenwick {
vector<long long> V;
Fenwick(int N) : V(N + 10) {}
void add(int x, long long v) {
for (int i = x + 1; i < V.size(); i += (i & -i)) {
V[i] += v;
}
}
long long get(int x) {
long long r = 0;
for (int i = x + 1; i > 0; i -= (i & -i)) {
r += V[i];
}
return r;
}
long long segSum(int i, int j) { return get(j) - get(i - 1); }
};
template <class T, class U>
struct SegmentTree {
struct Node {
bool hasCarry = 0;
int b = 0, e = 0;
U carry = U();
T val = T();
Node() {}
void join(const Node &l, const Node &r) {
val = l.val + r.val;
b = l.b;
e = r.e;
}
void update(const U &u) {
carry += u;
u(val);
hasCarry = 1;
}
void pushDown(Node &l, Node &r) {
if (!hasCarry) return;
l.update(carry.trim(0, r.e - r.b + 1));
r.update(carry.trim(l.e - l.b + 1, 0));
carry = U();
hasCarry = 0;
}
};
vector<Node> V;
int N;
SegmentTree(int N) : V(2 * N), N(N) {}
template <class I>
void create(const vector<I> &VEC, int b = 0, int e = -1) {
if (e == -1) e = N - 1;
int n = (((b) + (e)) | ((b) != (e)));
if (b == e) {
V[n].val = T(VEC[b]), V[n].b = b, V[n].e = e;
} else {
int m = (b + e) / 2;
create(VEC, b, m);
create(VEC, m + 1, e);
V[n].join(V[(((b) + (m)) | ((b) != (m)))],
V[(((m + 1) + (e)) | ((m + 1) != (e)))]);
}
}
T query(int i, int j, int b = 0, int e = -1) {
if (e == -1) e = N - 1;
int n = (((b) + (e)) | ((b) != (e)));
if (i <= b && e <= j) {
return V[n].val;
} else {
int m = (b + e) / 2;
V[n].pushDown(V[(((b) + (m)) | ((b) != (m)))],
V[(((m + 1) + (e)) | ((m + 1) != (e)))]);
if (i > m) return query(i, j, m + 1, e);
if (j <= m) return query(i, j, b, m);
return query(i, j, b, m) + query(i, j, m + 1, e);
}
}
int findOkPrefix(int i, const function<bool(T)> &isOk) {
vector<int> stk;
stk.reserve(20);
stk.push_back((((0) + (N - 1)) | ((0) != (N - 1))));
T acum;
int sz = 0;
while (stk.size()) {
int t = stk.back();
stk.pop_back();
Node &n = V[t];
int m = (n.b + n.e) / 2;
if (n.e < i) continue;
T newAcum = sz == 0 ? n.val : (acum + n.val);
if (i <= n.b) {
if (isOk(newAcum)) {
sz += n.e - n.b + 1;
acum = newAcum;
} else {
if (n.b == n.e) return sz;
stk.push_back((((m + 1) + (n.e)) | ((m + 1) != (n.e))));
stk.push_back((((n.b) + (m)) | ((n.b) != (m))));
}
} else {
if (n.b == n.e) continue;
stk.push_back((((m + 1) + (n.e)) | ((m + 1) != (n.e))));
stk.push_back((((n.b) + (m)) | ((n.b) != (m))));
}
}
return sz;
}
void update(int i, int j, const U &v, int b = 0, int e = -1) {
if (e == -1) e = N - 1;
int n = (((b) + (e)) | ((b) != (e)));
if (i <= b && e <= j) {
V[n].update(v.trim(max(b - i, 0), max(j - e, 0)));
} else if (i > e || j < b)
return;
else {
int m = (b + e) / 2;
int l = (((b) + (m)) | ((b) != (m))),
r = (((m + 1) + (e)) | ((m + 1) != (e)));
V[n].pushDown(V[l], V[r]);
update(i, j, v, b, m);
update(i, j, v, m + 1, e);
V[n].join(V[l], V[r]);
}
}
};
struct Sum {
long long s;
Sum(long long w) { s = w; }
Sum operator+(const Sum &o) const { return Sum(s + o.s); }
};
struct ToSides {
int toL, toR, pl, pr, w;
ToSides(Box b = (Box){0, 0}) {
toL = 0;
toR = 0;
pl = b.x;
pr = b.x;
w = b.w;
}
ToSides operator+(const ToSides &a) const {
ToSides r = a;
r.toL = (toL + a.toL + (1LL * (a.pl - pl) * a.w)) % 1000000007;
r.toR = (toR + a.toR + (1LL * (a.pr - pr) * w)) % 1000000007;
r.pl = pl;
r.pr = a.pr;
r.w = (a.w + w) % 1000000007;
return r;
}
};
struct Replace {
long long w;
Replace(long long w = 0) { this->w = w; }
Replace trim(int l, int r) const { return *this; }
void operator+=(const Replace &a) { w = a.w; }
void operator()(ToSides &a) const { a.w = w; }
};
int main() {
int N, Q;
cin >> N >> Q;
vector<Box> V(N);
Fenwick FX(N);
for (int i = 0; i < N; ++i) {
scanf("%lld", &V[i].x);
V[i].x -= i;
FX.add(i, V[i].x);
}
Fenwick F(N);
for (int i = 0; i < N; ++i) {
scanf("%lld", &V[i].w);
F.add(i, V[i].w);
}
SegmentTree<ToSides, Replace> ST(N);
ST.create(V);
for (int i = 0; i < Q; ++i) {
long long l, r;
scanf("%lld%lld", &l, &r);
if (l < 0) {
long long id = (-l) - 1, nw = r;
F.add(id, -V[id].w + nw);
ST.update(id, id, Replace(nw));
V[id].w = nw;
} else {
l--;
r--;
long long tots = F.segSum(l, r);
int m = -1, lo = l, hi = r;
while (lo <= hi) {
int mi = (lo + hi) / 2;
long long t = F.segSum(l, mi);
if (t * 2 < tots) {
lo = mi + 1;
} else {
m = mi;
hi = mi - 1;
}
}
long long a = ST.query(l, m).toR;
long long b = ST.query(m, r).toL;
printf("%d\n", (a + b) % 1000000007);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
long long n, q, a[200005], p[200005];
long long _mod(long long x) { return x >= 1000000007 ? x - 1000000007 : x; }
struct segtree {
long long sum[4 * 200005];
long long sum2[4 * 200005], sum3[4 * 200005];
void pushup(long long k) {
sum[k] = sum[k * 2] + sum[k * 2 + 1];
sum2[k] = _mod(sum2[k * 2] + sum2[k * 2 + 1]);
sum3[k] = _mod(sum3[k * 2] + sum3[k * 2 + 1]);
}
void build(long long k, long long l, long long r) {
if (l == r) {
sum[k] = a[l];
sum2[k] = 1LL * a[l] * p[l] % 1000000007;
sum3[k] = 1LL * l * a[l] % 1000000007;
return;
}
long long mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void update(long long k, long long l, long long r, long long pos,
long long v) {
if (l == r) {
sum[k] = v;
sum2[k] = 1LL * v * p[l] % 1000000007;
sum3[k] = 1LL * v * l % 1000000007;
return;
}
long long mid = (l + r) / 2;
if (pos <= mid)
update(k * 2, l, mid, pos, v);
else
update(k * 2 + 1, mid + 1, r, pos, v);
pushup(k);
}
long long query1(long long k, long long l, long long r, long long x,
long long y) {
if (x > r || l > y) return 0;
if (l >= x && r <= y) return sum[k];
long long mid = (l + r) / 2;
return query1(k * 2, l, mid, x, y) + query1(k * 2 + 1, mid + 1, r, x, y);
}
long long find(long long k, long long l, long long r, long long s) {
if (l == r) return l;
long long mid = (l + r) / 2;
if (sum[k * 2] <= s) return find(k * 2 + 1, mid + 1, r, s - sum[k * 2]);
return find(k * 2, l, mid, s);
}
long long query2(long long k, long long l, long long r, long long x,
long long y) {
if (x > r || l > y) return 0;
if (l >= x && r <= y) return sum2[k];
long long mid = (l + r) / 2;
return _mod(query2(k * 2, l, mid, x, y) +
query2(k * 2 + 1, mid + 1, r, x, y));
}
long long query3(long long k, long long l, long long r, long long x,
long long y) {
if (x > r || l > y) return 0;
if (l >= x && r <= y) return sum3[k];
long long mid = (l + r) / 2;
return _mod(query3(k * 2, l, mid, x, y) +
query3(k * 2 + 1, mid + 1, r, x, y));
}
} seg;
int main() {
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; i++) scanf("%lld", &p[i]);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
seg.build(1, 1, n);
long long l, r;
for (long long i = 0; i < q; i++) {
scanf("%lld%lld", &l, &r);
if (l < 0)
seg.update(1, 1, n, -l, r);
else {
long long A = seg.query1(1, 1, n, 1, l - 1),
B = seg.query1(1, 1, n, l, r), s = A + B / 2;
long long pos = seg.find(1, 1, n, s);
long long ans = 0;
ans = (1LL * (p[pos] - pos) *
(seg.query1(1, 1, n, l, pos - 1) % 1000000007) +
seg.query3(1, 1, n, l, pos - 1) - seg.query2(1, 1, n, l, pos - 1) +
1000000007) %
1000000007;
ans = (ans + seg.query2(1, 1, n, pos + 1, r) +
1LL * (pos - p[pos]) *
(seg.query1(1, 1, n, pos + 1, r) % 1000000007) % 1000000007 -
seg.query3(1, 1, n, pos + 1, r) + 1000000007) %
1000000007;
if (ans < 0) ans += 1000000007;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void qmax(long long &x, long long y) {
if (x < y) x = y;
}
void qmin(long long &x, long long y) {
if (x > y) x = y;
}
inline long long read() {
char s;
long long k = 0, base = 1;
while ((s = getchar()) != '-' && s != EOF && !(isdigit(s)))
;
if (s == EOF) exit(0);
if (s == '-') base = -1, s = getchar();
while (isdigit(s)) k = k * 10 + (s ^ '0'), s = getchar();
return k * base;
}
inline void write(long long x) {
static char cnt, num[15];
cnt = 0;
if (!x) {
putchar('0');
return;
}
for (; x; x /= 10) num[++cnt] = x % 10;
for (; cnt; putchar(num[cnt--] + 48))
;
}
const long long mod = 1e9 + 7;
const long long maxn = 4e5 + 100;
long long a[maxn], w[maxn];
long long n, q;
long long h[maxn << 2];
long long dis[2][maxn << 2];
void Mod(long long &x) { x %= mod; }
void bt(long long x, long long y, long long d) {
if (x == y) {
dis[0][d] = w[x] * (a[x] - x) % mod;
dis[1][d] = w[x] * (a[n] - (n - x) - a[x]) % mod;
h[d] = w[x];
return;
}
long long mid = (x + y) / 2;
bt(x, mid, d * 2);
bt(mid + 1, y, d * 2 + 1);
h[d] = h[d * 2] + h[d * 2 + 1];
dis[0][d] = dis[0][d * 2] + dis[0][d * 2 + 1];
Mod(dis[0][d]);
dis[1][d] = dis[1][d * 2] + dis[1][d * 2 + 1];
Mod(dis[1][d]);
}
long long qsum(long long x, long long y, long long d, long long l,
long long r) {
if (x == l && y == r) return h[d];
long long mid = (x + y) / 2;
if (r <= mid) return qsum(x, mid, d * 2, l, r);
if (l > mid) return qsum(mid + 1, y, d * 2 + 1, l, r);
return qsum(x, mid, d * 2, l, mid) + qsum(mid + 1, y, d * 2 + 1, mid + 1, r);
}
long long kth(long long x, long long y, long long d, long long k) {
if (x == y) return x;
long long mid = (x + y) / 2;
if (h[d * 2] >= k) return kth(x, mid, d * 2, k);
return kth(mid + 1, y, d * 2 + 1, k - h[d * 2]);
}
long long qdis(long long x, long long y, long long d, long long l, long long r,
long long flag) {
if (l == x && y == r) return dis[flag][d];
long long mid = (x + y) / 2;
if (r <= mid) return qdis(x, mid, d * 2, l, r, flag);
if (l > mid) return qdis(mid + 1, y, d * 2 + 1, l, r, flag);
return (qdis(x, mid, d * 2, l, mid, flag) +
qdis(mid + 1, y, d * 2 + 1, mid + 1, r, flag)) %
mod;
}
void xg(long long x, long long y, long long d, long long p) {
if (x == y) {
dis[0][d] = w[x] * (a[x] - x) % mod;
dis[1][d] = w[x] * (a[n] - (n - x) - a[x]) % mod;
h[d] = w[x];
return;
}
long long mid = (x + y) / 2;
if (p <= mid)
xg(x, mid, d * 2, p);
else
xg(mid + 1, y, d * 2 + 1, p);
h[d] = h[d * 2] + h[d * 2 + 1];
dis[0][d] = dis[0][d * 2] + dis[0][d * 2 + 1];
Mod(dis[0][d]);
dis[1][d] = dis[1][d * 2] + dis[1][d * 2 + 1];
Mod(dis[1][d]);
}
signed main() {
n = read(), q = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) w[i] = read();
bt(1, n, 1);
long long x, y, p;
long long s, s1;
long long ans;
while (q--) {
x = read(), y = read();
if (x < 0) {
x = -x;
w[x] = y;
xg(1, n, 1, x);
} else {
if (x == y) {
printf("0\n");
continue;
}
s = qsum(1, n, 1, x, y);
s = (s + 1) / 2;
if (x == 1)
s1 = 0;
else
s1 = qsum(1, n, 1, 1, x - 1);
p = kth(1, n, 1, s1 + s);
ans = 0;
if (p != x) {
ans = qdis(1, n, 1, x, p - 1, 1);
ans -= (long long)(qsum(1, n, 1, x, p - 1)) % mod *
(a[n] - (n - p) - a[p]) % mod;
ans %= mod;
}
if (p != y) {
ans += qdis(1, n, 1, p + 1, y, 0);
ans -= (long long)(qsum(1, n, 1, p + 1, y)) % mod * (a[p] - p) % mod;
ans %= mod;
}
ans = (ans % mod + mod) % mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int add(int x, int y) { return ((x + y) % mod + mod) % mod; }
int mul(int x, int y) { return (long long)x * y % mod; }
int mypow(int x, int c) {
int ret = 1;
while (c > 0) {
if (c & 1) {
ret = mul(ret, x);
}
c /= 2;
x = mul(x, x);
}
return ret;
}
long long pen[200005];
void update(int ind, int add) {
while (ind < 200005) {
pen[ind] += add;
ind += ind & (-ind);
}
}
long long query(int ind) {
long long ret = 0;
while (ind > 0) {
ret = ret + pen[ind];
ind = ind & (ind - 1);
}
return ret;
}
int a[200005], w[200005];
int pen2[200005];
int pen3[200005];
void update2(int *pp, int ind, int ad) {
while (ind < 200005) {
pp[ind] = add(pp[ind], ad);
ind += ind & (-ind);
}
}
int query2(int *pp, int ind) {
int ret = 0;
while (ind > 0) {
ret = add(ret, pp[ind]);
ind = ind & (ind - 1);
}
return ret;
}
int getS(int x, int y, int wei) {
long long s = query(y) - query(x - 1);
int sum = s % mod;
int r = add(add(query2(pen3, y), -query2(pen3, x - 1)), -mul(sum, x));
return add(r, mul(sum, wei));
}
void solve() {
int n, q;
scanf("%d %d ", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d ", &a[i]);
}
for (int i = 1; i <= n; ++i) {
scanf("%d ", &w[i]);
update(i, w[i]);
update2(pen2, i, mul(w[i], a[i]));
update2(pen3, i, mul(i, w[i]));
}
while (q--) {
int x, y;
scanf("%d %d ", &x, &y);
if (x < 0) {
int id = -x;
update(id, -w[id]);
update2(pen2, id, -mul(w[id], a[id]));
update2(pen3, id, -mul(id, w[id]));
w[id] = y;
update(id, w[id]);
update2(pen2, id, mul(w[id], a[id]));
update2(pen3, id, mul(id, w[id]));
} else {
long long pre = query(x - 1);
long long sum = query(y) - pre;
int l = x, r = y, mid;
while (l < r) {
mid = (l + r) / 2;
if ((query(mid) - pre) * 2 > sum) {
r = mid;
} else {
l = mid + 1;
}
}
int ind = l;
int ret = 0;
if (x <= ind - 1) {
int wei = a[ind] - ind + x;
ret = add(ret, add(getS(x, ind - 1, wei),
-add(query2(pen2, ind - 1), -query2(pen2, x - 1))));
}
if (ind + 1 <= y) {
int wei = a[ind] + 1;
ret = add(ret, add(-getS(ind + 1, y, wei),
add(query2(pen2, y), -query2(pen2, ind))));
}
printf("%d\n", ret);
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
const long long mod = 1e9 + 7;
struct Bit {
long long a[N];
int vis[N], cur;
Bit() {
cur = 1;
memset(vis, 0, sizeof vis);
}
inline void Init() { cur++; }
inline void Add(int p, long long v) {
for (; p < N; p += (p & (-p))) {
if (vis[p] == cur)
a[p] += v;
else
vis[p] = cur, a[p] = v;
}
}
inline long long Sum(int p) {
long long res = 0;
for (; p > 0; p -= (p & (-p)))
if (vis[p] == cur) res += a[p];
return res;
}
inline long long Sum(int l, int r) {
if (l > r) return 0;
return Sum(r) - Sum(l - 1);
}
} prefix, wei;
int n, q, a[N], p[N], tab[N], w[N], sumx[N];
inline long long mov(int L, int R, int mid) {
long long ans = 0;
ans = (1ll * a[mid] * (prefix.Sum(L, mid) % mod) % mod -
wei.Sum(L, mid) % mod) %
mod;
ans += (wei.Sum(mid + 1, R) -
1ll * a[mid] * (prefix.Sum(mid + 1, R) % mod) % mod) %
mod;
return (ans % mod + mod) % mod;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
tab[i] = a[i];
}
sort(tab + 1, tab + n + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
p[i] = lower_bound(tab + 1, tab + n + 1, a[i]) - tab;
prefix.Add(p[i], w[i]);
a[i] -= i - 1;
wei.Add(p[i], 1ll * w[i] * a[i] % mod);
}
for (int x, y; q; q--) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
prefix.Add(p[x], y - w[x]);
wei.Add(p[x], 1ll * (y - w[x]) * a[x] % mod);
w[x] = y;
} else {
int L = x, R = y, mid, res = L;
long long tot = prefix.Sum(x, y);
while (L <= R) {
mid = (L + R) >> 1;
if (prefix.Sum(x, mid) * 2 >= tot)
R = mid - 1, res = mid;
else
L = mid + 1;
}
printf("%lld\n", mov(x, y, res));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int a[200005], w[200005];
const int N = 2e5;
struct ft {
long long ft[N + 5];
void update(int i, int v) {
for (; i <= N; i += (i & -i)) {
ft[i] += v;
}
}
long long query(int i) {
long long res = 0;
for (; i > 0; i -= (i & -i)) res += ft[i];
return res;
}
} ft;
struct ft2 {
long long ft[N + 5];
void update(int i, int v) {
for (; i <= N; i += (i & -i)) {
ft[i] = (ft[i] + v + mod) % mod;
}
}
long long query(int i) {
long long res = 0;
for (; i > 0; i -= (i & -i)) res = (res + ft[i]) % mod;
return res;
}
} ft2;
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
ft.update(i, w[i]);
ft2.update(i, (long long)a[i] * w[i] % mod);
}
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0) {
l = -l;
ft.update(l, -w[l]);
ft2.update(l, -((long long)w[l] * a[l] % mod));
w[l] = r;
ft.update(l, w[l]);
ft2.update(l, (long long)w[l] * a[l] % mod);
} else {
long long Q = ft.query(r) - ft.query(l - 1);
int lo = l, hi = r, res = l;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (2 * (ft.query(mid) - ft.query(l - 1)) >= Q)
res = mid, hi = mid - 1;
else
lo = mid + 1;
}
long long res1 = 0, res2 = 0;
res1 = ((ft.query(res) - ft.query(l - 1) + mod) % mod * a[res] % mod -
(ft2.query(res) - ft2.query(l - 1) + mod) % mod + mod) %
mod;
res2 = ((ft2.query(r) - ft2.query(res) + mod) % mod -
(ft.query(r) - ft.query(res) + mod) % mod * a[res] % mod + mod) %
mod;
long long ans = (res1 + res2) % mod;
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
const int N = 200010, MO = 1e9 + 7;
long long sum[N << 2], tr[N << 2], tl[N << 2], w[N];
int X[N], xx, a[N], n;
inline void Add(int &a, const int &b) {
a += b;
if (a >= MO) a -= MO;
if (a < 0) a += MO;
return;
}
struct TA {
int ta[N];
inline void add(int i, int v) {
for (; i <= n; i += i & (-i)) {
Add(ta[i], v);
}
return;
}
inline int ask(int i) {
int ans = 0;
for (; i; i -= i & (-i)) {
Add(ans, ta[i]);
}
return ans;
}
inline int getSum(int l, int r) { return (ask(r) - ask(l - 1) + MO) % MO; }
} ta1, ta2, ta3, ta4;
inline void pushup(int l, int r, int o) {
int ls = o << 1, rs = ls | 1, mid = (l + r) >> 1;
sum[o] = sum[ls] + sum[rs];
tl[o] = tl[ls] + tl[rs] + sum[rs] * (X[mid + 1] - X[l] - (mid - l + 1));
tr[o] = tr[ls] + tr[rs] + sum[ls] * (X[r] - X[mid] - (r - mid));
return;
}
void build(int l, int r, int o) {
if (l == r) {
sum[o] = w[r];
return;
}
int mid = (l + r) >> 1;
build(l, mid, o << 1);
build(mid + 1, r, o << 1 | 1);
pushup(l, r, o);
return;
}
void change(int p, int v, int l, int r, int o) {
if (l == r) {
sum[o] = v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid) {
change(p, v, l, mid, o << 1);
} else {
change(p, v, mid + 1, r, o << 1 | 1);
}
pushup(l, r, o);
return;
}
long long getSum(int L, int R, int l, int r, int o) {
if (L <= l && r <= R) {
return sum[o];
}
int mid = (l + r) >> 1;
long long ans = 0;
if (L <= mid) {
ans = getSum(L, R, l, mid, o << 1);
}
if (mid < R) {
ans += getSum(L, R, mid + 1, r, o << 1 | 1);
}
return ans;
}
int getPos(long long k, int l, int r, int o) {
if (l == r) {
return r;
}
int mid = (l + r) >> 1;
if (k <= sum[o << 1]) {
return getPos(k, l, mid, o << 1);
} else {
return getPos(k - sum[o << 1], mid + 1, r, o << 1 | 1);
}
}
int Ask(int x, int y) {
long long sum = getSum(x, y, 1, n, 1);
long long sum2 = 0;
if (x > 1) sum2 = getSum(1, x - 1, 1, n, 1);
long long delta = sum2 + ((sum + 1) >> 1);
int p = getPos(delta, 1, n, 1);
int ans = 0;
if (x < p) {
long long Sum = getSum(x, p - 1, 1, n, 1) % MO;
Add(ans, ((long long)ta3.getSum(x, p - 1) - ta4.getSum(x, p - 1) -
Sum * (X[n] - X[p] - (n - p)) % MO) %
MO);
}
if (p < y) {
long long Sum = getSum(p + 1, y, 1, n, 1) % MO;
Add(ans, ((long long)ta1.getSum(p + 1, y) - ta2.getSum(p + 1, y) -
Sum * (X[p] - X[1] - (p - 1))) %
MO);
}
return ans;
}
int main() {
int q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &X[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
}
build(1, n, 1);
for (int i = 1; i <= n; i++) {
long long c = w[i];
ta1.add(i, c * (X[i] - X[1]) % MO);
ta2.add(i, c * (i - 1) % MO);
ta3.add(i, c * (X[n] - X[i]) % MO);
ta4.add(i, c * (n - i) % MO);
}
int x, y;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
change(x, y, 1, n, 1);
int dt = (y - w[x] + MO) % MO;
ta1.add(x, (long long)dt * (X[x] - X[1]) % MO);
ta2.add(x, (long long)dt * (x - 1) % MO);
ta3.add(x, (long long)dt * (X[n] - X[x]) % MO);
ta4.add(x, (long long)dt * (n - x) % MO);
w[x] = y;
} else {
int ans = Ask(x, y);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
long long mod(long long a) {
a %= P;
if (a < 0) a += P;
return a;
}
long long add(long long a, long long b) { return mod(a + b); }
long long mul(long long a, long long b) { return mod(a * b); }
const long long N = 1e6 + 10;
long long n, q, pos;
long long a[N], w[N];
long long s1[N << 2], s2[N << 2], sum;
void pu(long long o) {
s1[o] = s1[(o << 1)] + s1[((o << 1) | 1)];
s2[o] = (s2[(o << 1)] + s2[((o << 1) | 1)]) % P;
}
void update(long long o, long long l, long long r, long long first,
long long v) {
if (l == r) {
s1[o] = v;
s2[o] = (long long)v * a[l] % P;
return;
}
if (((l + r) >> 1) >= first)
update((o << 1), l, ((l + r) >> 1), first, v);
else
update(((o << 1) | 1), ((l + r) >> 1) + 1, r, first, v);
pu(o);
}
long long qry1(long long o, long long l, long long r, long long ql,
long long qr) {
if (ql <= l && r <= qr) return s1[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans += qry1((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
ans += qry1(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
return ans;
}
long long qry2(long long o, long long l, long long r, long long ql,
long long qr) {
if (ql <= l && r <= qr) return s2[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans = qry2((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
(ans += qry2(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr)) %= P;
return ans;
}
void find(long long o, long long l, long long r, long long ql, long long qr) {
if (ql <= l && r <= qr) {
if (l == r || sum == s1[o]) pos = r;
if (sum >= s1[o])
sum -= s1[o];
else
find((o << 1), l, ((l + r) >> 1), ql, qr);
return;
}
if (((l + r) >> 1) >= ql) find((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr) find(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
}
void build(long long o, long long l, long long r) {
if (l == r) {
s1[o] = w[l], s2[o] = (long long)a[l] * w[l] % P;
return;
}
build((o << 1), l, ((l + r) >> 1)),
build(((o << 1) | 1), ((l + r) >> 1) + 1, r);
pu(o);
}
long long qry(long long l, long long r) {
return add(qry2(1, 1, n, l, r), -mul(qry1(1, 1, n, l, r) % P, a[pos]));
}
signed main() {
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; ++i) scanf("%lld", a + i), a[i] -= i;
for (long long i = 1; i <= n; ++i) scanf("%lld", w + i);
build(1, 1, n);
for (long long i = 1; i <= q; ++i) {
long long first, second;
scanf("%lld%lld", &first, &second);
if (first < 0)
update(1, 1, n, -first, second);
else {
long long sum = qry1(1, 1, n, first, second);
long long l = first, r = second, ans = -1;
while (l <= r) {
if (2 * qry1(1, 1, n, first, ((l + r) >> 1)) >= sum)
ans = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
pos = ans;
printf("%lld\n", ((qry(ans, second) - qry(first, ans)) % P + P) % P);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
template <typename T>
struct edge {
int from, to;
T w;
edge(int from, int to, T w) : from(from), to(to), w(w) {}
edge() {}
};
const long double EPS = 1e-9;
template <class T>
void show(T a) {
for (auto x : a) cout << x << " ";
cout << endl;
}
const int N = 2e5 + 1;
const int M = 1e9 + 7;
long double pw_double[N], pa_double[N];
long double tw_double[N], ta_double[N];
inline void upd_double(int i, long double w, long double a) {
long double tmp = w;
w -= pw_double[i];
pw_double[i] = tmp;
tmp = a;
a -= pa_double[i];
pa_double[i] = tmp;
for (++i; i < N; i += i & -i) tw_double[i] += w, ta_double[i] += a;
}
inline void get_double(int l, int r, long double &w, long double &a) {
if (l > r) return;
for (++r; r > 0; r -= r & -r) w += tw_double[r], a += ta_double[r];
for (; l > 0; l -= l & -l) w -= tw_double[l], a -= ta_double[l];
}
int pw[N], pa[N];
int tw[N], ta[N];
inline void upd(int i, int w, int a) {
int tmp = w;
w = ((w) - (pw[i]) < 0 ? (w) - (pw[i]) + M : (w) - (pw[i]));
pw[i] = tmp;
tmp = a;
a = ((a) - (pa[i]) < 0 ? (a) - (pa[i]) + M : (a) - (pa[i]));
pa[i] = tmp;
for (++i; i < N; i += i & -i)
tw[i] = ((tw[i]) + (w) >= M ? (tw[i]) + (w)-M : (tw[i]) + (w)),
ta[i] = ((ta[i]) + (a) >= M ? (ta[i]) + (a)-M : (ta[i]) + (a));
}
inline void get(int l, int r, int &w, int &a) {
if (l > r) return;
for (++r; r > 0; r -= r & -r)
w = ((w) + (tw[r]) >= M ? (w) + (tw[r]) - M : (w) + (tw[r])),
a = ((a) + (ta[r]) >= M ? (a) + (ta[r]) - M : (a) + (ta[r]));
for (; l > 0; l -= l & -l)
w = ((w) - (tw[l]) < 0 ? (w) - (tw[l]) + M : (w) - (tw[l])),
a = ((a) - (ta[l]) < 0 ? (a) - (ta[l]) + M : (a) - (ta[l]));
}
int a[N];
int n, q;
inline int bins(long long xl) {
int l = -1, r = n;
while (r - l > 1) {
int m = (l + r) >> 1;
if (xl + m - a[m] >= 0)
l = m;
else
r = m;
}
return r;
}
inline long double get_double(int xx, int l, int r) {
int pos = bins(xx - l);
long double x = xx;
long double w = 0, a = 0, w1 = 0, a1 = 0;
get_double(l, min(pos - 1, r), w, a);
get_double(max(l, pos), r, w1, a1);
return (w - w1) * (x - l) + a - a1;
}
inline int get(int x, int l, int r) {
int pos = bins(x - l);
int w = 0, a = 0, w1 = 0, a1 = 0;
get(l, min(pos - 1, r), w, a);
get(max(l, pos), r, w1, a1);
return ((((((long long)((w) - (w1) < 0 ? (w) - (w1) + M : (w) - (w1))) *
(((x) - (l) < 0 ? (x) - (l) + M : (x) - (l)))) %
M)) + (((a) - (a1) < 0 ? (a) - (a1) + M : (a) - (a1))) >=
M
? (((((long long)((w) - (w1) < 0 ? (w) - (w1) + M : (w) - (w1))) *
(((x) - (l) < 0 ? (x) - (l) + M : (x) - (l)))) %
M)) +
(((a) - (a1) < 0 ? (a) - (a1) + M : (a) - (a1))) - M
: (((((long long)((w) - (w1) < 0 ? (w) - (w1) + M : (w) - (w1))) *
(((x) - (l) < 0 ? (x) - (l) + M : (x) - (l)))) %
M)) +
(((a) - (a1) < 0 ? (a) - (a1) + M : (a) - (a1))));
}
inline bool check(int x, int l, int r) {
long double a = get_double(x, l, r), b = get_double(x + 1, l, r);
return a > b || abs(a - b) < EPS;
}
int solve(int L, int R) {
int l = -1, r = 1e9 + 9;
while (r - l > 1) {
int m = (l + r) >> 1;
if (check(m, L, R))
l = m;
else
r = m;
}
return get(r, L, R);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 0; i < (int)(n); ++i) cin >> a[i];
int w;
for (int i = 0; i < (int)(n); ++i) {
cin >> w;
upd(i, w,
((((long long)w) *
(((i) - (a[i]) < 0 ? (i) - (a[i]) + M : (i) - (a[i])))) %
M));
upd_double(i, w, (long double)w * (i - a[i]));
}
int x, y;
while (q--) {
cin >> x >> y;
if (x < 0) {
x = -x - 1;
upd(x, y,
((((long long)y) *
(((x) - (a[x]) < 0 ? (x) - (a[x]) + M : (x) - (a[x])))) %
M));
upd_double(x, y, (long double)y * (x - a[x]));
} else {
cout << solve(--x, --y) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
class fenwicktree {
private:
int sz, realsz;
vector<long long> val;
public:
fenwicktree() : sz(0), val(vector<long long>(1, 0)){};
fenwicktree(int sz_) : realsz(sz_) {
sz = 1;
while (sz <= sz_) sz *= 2;
val = vector<long long>(sz + 1, 0);
}
void add(int pos, long long delta) {
for (int i = pos + 1; i <= sz; i += i & (-i)) {
val[i] += delta;
}
}
long long sum(int pos) {
long long ans = 0;
for (int i = pos; i >= 1; i -= i & (-i)) {
ans += val[i];
}
return ans;
}
int bsearch(long long x) {
if (x == 0) return 0;
int ans = 0;
for (int i = sz / 2; i >= 1; i >>= 1) {
if (val[ans + i] < x) {
ans += i;
x -= val[ans];
}
}
if (ans > realsz) ans = realsz;
return ans + 1;
}
};
class fenwicktree_mod {
private:
int sz, realsz;
vector<int> val;
public:
fenwicktree_mod() : sz(0), val(vector<int>(1, 0)){};
fenwicktree_mod(int sz_) : sz(sz_) { val = vector<int>(sz + 1, 0); }
void add(int pos, long long delta) {
if (delta < 0) delta = (mod - (-delta) % mod);
delta %= mod;
for (int i = pos + 1; i <= sz; i += i & (-i)) {
val[i] += delta;
if (val[i] >= mod) val[i] -= mod;
}
}
int sum(int pos) {
int ans = 0;
for (int i = pos; i >= 1; i -= i & (-i)) {
ans += val[i];
if (ans >= mod) ans -= mod;
}
return ans;
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, Q;
cin >> N >> Q;
vector<int> A(N), W(N);
for (int i = 0; i < N; ++i) cin >> A[i], A[i] -= i;
for (int i = 0; i < N; ++i) cin >> W[i];
fenwicktree seg(N);
fenwicktree_mod sum(N);
for (int i = 0; i < N; ++i) {
seg.add(i, W[i]);
sum.add(i, 1LL * W[i] * A[i]);
}
for (int i = 0; i < Q; ++i) {
int x, y;
cin >> x >> y;
if (x < 0) {
x *= -1;
--x;
seg.add(x, -W[x]);
sum.add(x, -1LL * W[x] * A[x]);
W[x] = y;
seg.add(x, W[x]);
sum.add(x, 1LL * W[x] * A[x]);
} else {
--x;
long long sl = seg.sum(x);
long long sr = seg.sum(y);
int med = seg.bsearch((sl + sr + 1) / 2);
int suml = sum.sum(x);
int summ = sum.sum(med);
int sumr = sum.sum(y);
long long sm = seg.sum(med);
int lcost =
(1LL * (sm - sl) % mod * A[med - 1] - (summ - suml) + mod) % mod;
int rcost = ((sumr - summ) - 1LL * (sr - sm) % mod * A[med - 1] % mod +
2LL * mod) %
mod;
cout << (lcost + rcost) % mod << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getchar();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getchar();
}
while (c <= 57 && c >= 48) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
x *= fu;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putchar(45), x = -x;
if (x > 9) fprint(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void fprint(T x, char ch) {
fprint(x);
putchar(ch);
}
inline char next_char() {
char ch = getchar();
while (ch == 9 || ch == 10 || ch == 32) ch = getchar();
return ch;
}
const long long MOD = 1000000007;
int n, m;
long long a[200005], w[200005];
long long c1[200005], c2[200005];
inline int lowbit(int x) { return x & -x; }
inline long long query(long long c[], int x, bool type) {
long long ret = 0;
for (; x; x -= lowbit(x)) ret += c[x], (type) && (ret = (ret + MOD) % MOD);
return ret;
}
inline void modify(long long c[], int x, long long y, bool type) {
for (; x <= n; x += lowbit(x))
c[x] += y, (type) && (c[x] = (c[x] + MOD) % MOD);
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= n; i++) read(a[i]);
for (register int i = 1; i <= n; i++)
read(w[i]), modify(c1, i, w[i], 0),
modify(c2, i, (a[i] - i) * w[i] % MOD, 1);
while (m--) {
int l, r;
read(l);
read(r);
if (l < 0) {
l = -l;
modify(c1, l, -w[l], 0);
modify(c2, l, ((r - w[l]) * (a[l] - l) % MOD + MOD) % MOD, 1);
w[l] = r;
modify(c1, l, r, 0);
} else {
int L = l, R = r, pos = l;
long long ll = query(c1, l - 1, 0), rr = query(c1, r, 0);
long long tot = rr - ll;
tot = (tot >> 1) + 1;
while (L <= R) {
int mid = (L + R) >> 1;
if (query(c1, mid, 0) - ll >= tot)
pos = mid, R = mid - 1;
else
L = mid + 1;
}
long long res1 = query(c1, pos, 0), res2 = query(c1, pos - 1, 0);
rr %= MOD, ll %= MOD, res1 %= MOD, res2 %= MOD;
long long num = (a[pos] - (pos - l + 1) + MOD) % MOD;
long long ans = num * (res2 - ll) % MOD;
ans =
((ans + 1ll * (l - 1) * (rr - res1 - (res2 - ll))) % MOD + MOD) % MOD;
ans = ((ans - query(c2, pos - 1, 1) + query(c2, l - 1, 1)) % MOD + MOD) %
MOD;
ans = (ans + query(c2, r, 1) - query(c2, pos, 1) + MOD) % MOD;
ans = (ans - ((rr - res1) * num % MOD) + MOD) % MOD;
fprint(ans, 10);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.