text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
inline void P(int& x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
int n, q;
int a[200001], w[200001];
long long b1[200001];
int b2[200001];
void Add1(int i, int x) {
for (; i <= n; i += i & -i) b1[i] += x;
}
void Add2(int i, int x) {
for (; i <= n; i += i & -i) P(b2[i], x);
}
long long Qur1(int i) {
long long A = 0;
for (; i; i -= i & -i) A += b1[i];
return A;
}
int Qur2(int i) {
int A = 0;
for (; i; i -= i & -i) P(A, b2[i]);
return A;
}
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)
Add2(i, (long long)a[i] * w[i] % 1000000007), Add1(i, w[i]);
for (int i = 1; i <= (q); ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
Add1(-x, y - w[-x]);
Add2(-x, (long long)a[-x] * (y - w[-x] + 1000000007) % 1000000007);
w[-x] = y;
} else {
int l = x, r = y, mid, ans = -1;
long long Left = Qur1(x - 1), Sum = Qur1(r) - Left;
while (l <= r) {
mid = l + r >> 1;
if (Qur1(mid - 1) - Left << 1 <= Sum)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", (((Qur1(ans - 1) - Left - Qur1(y) + Qur1(ans)) %
1000000007 * a[ans] % 1000000007 -
(Qur2(ans - 1) - Qur2(x - 1)) + (Qur2(y) - Qur2(ans))) %
1000000007 +
1000000007) %
1000000007);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, a[1000005];
long long int w[1000005];
long long int bit1[1000005];
long long int bit2[1000005];
void upd(long long int idx, long long int val, long long int bit[]) {
for (; idx < 1000005; idx += idx & -idx) bit[idx] += val;
}
long long int qry(long long int idx, long long int bit[]) {
long long int ans = 0;
for (; idx > 0; idx -= idx & -idx) ans += bit[idx];
return ans;
}
long long int inline mul(long long int a, long long int b) {
a %= 1000000007;
b %= 1000000007;
if (a < 0) a += 1000000007;
if (b < 0) b += 1000000007;
a *= b;
a %= 1000000007;
return a;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int q;
cin >> n >> q;
for (long long int i = 1; i <= n; i++) cin >> a[i], a[i] -= i;
for (long long int i = 1; i <= n; i++) cin >> w[i];
for (long long int i = 1; i <= n; i++) {
upd(i, mul(w[i], a[i]), bit1);
upd(i, w[i], bit2);
}
for (long long int i = 1; i <= q; i++) {
long long int l, r;
cin >> l >> r;
if (l < 0) {
l = -l;
upd(l, -1LL * mul(w[l], a[l]), bit1);
upd(l, -1LL * w[l], bit2);
w[l] = r;
upd(l, mul(w[l], a[l]), bit1);
upd(l, w[l], bit2);
} else {
long long int lo = l;
long long int hi = r;
long long int mid = l;
long long int sm = qry(r, bit2) - qry(l - 1, bit2);
while (lo <= hi) {
long long int m = (lo + hi) / 2;
if (2 * (qry(m - 1, bit2) - qry(l - 1, bit2)) <= sm)
lo = m + 1, mid = m;
else
hi = m - 1;
}
long long int ans = mul((qry(mid, bit2) - qry(l - 1, bit2)), a[mid]) -
(qry(mid, bit1) - qry(l - 1, bit1)) % 1000000007;
ans %= 1000000007;
if (ans < 0) ans += 1000000007;
long long int ans2 = mul((qry(r, bit2) - qry(mid, bit2)), a[mid]) -
(qry(r, bit1) - qry(mid, bit1)) % 1000000007;
ans2 %= 1000000007;
ans2 += 1000000007;
ans2 %= 1000000007;
ans -= ans2;
ans %= 1000000007;
ans += 1000000007;
ans %= 1000000007;
cout << ans << '\n';
}
}
return 0;
}
|
#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;
cout << (a + b) % 1000000007 << endl;
}
}
}
|
#include <bits/stdc++.h>
using i64 = long long;
template <class T = long long int>
class Bit {
private:
unsigned len;
T init;
std::vector<T> arr;
public:
Bit(unsigned length, T initialValue = 0)
: len(length), init(initialValue), arr(len + 1, init) {}
void update(unsigned a, T newval) {
for (unsigned x = a; x <= len; x += x & -x) arr[x] += newval;
}
T query(unsigned a) const {
T ret = init;
for (unsigned x = a; x > 0; x -= x & -x) ret += arr[x];
return ret;
}
};
int main() {
constexpr i64 mod = 1000000007;
int n, q;
scanf("%d%d", &n, &q);
std::vector<i64> a(n), w(n);
for (auto &e : a) scanf("%lld", &e);
for (int i = 0; i < n; i++) a[i] -= i;
for (auto &e : w) scanf("%lld", &e);
Bit<> ss(n + 10), pr(n + 10);
for (int i = 0; i < n; i++) {
ss.update(i + 1, w[i]);
pr.update(i + 1, w[i] * a[i] % mod);
}
while (q--) {
i64 x, y;
scanf("%lld%lld", &x, &y);
if (x < 0) {
const int i = -x - 1;
ss.update(i + 1, y - w[i]);
pr.update(i + 1, y * a[i] % mod - w[i] * a[i] % mod);
w[i] = y;
} else {
if (x == y) {
printf("0\n");
continue;
}
int l = x - 1, r = y;
const i64 lb = ss.query(x - 1), sum = ss.query(y) - lb;
while (r - l > 1) {
const int k = (l + r) / 2;
const i64 s = ss.query(k) - lb;
if (2 * s <= sum)
l = k;
else
r = k;
}
const i64 lss = (ss.query(l) % mod + mod - lb % mod) % mod * a[l] % mod,
rss = (ss.query(y) % mod + mod - ss.query(l) % mod) % mod *
a[l] % mod,
lpr = (pr.query(l) % mod + mod - pr.query(x - 1) % mod) % mod,
rpr = (pr.query(y) % mod + mod - pr.query(l) % mod) % mod;
const i64 ret = (lss - lpr + 2 * mod + rpr - rss) % mod;
printf("%lld\n", ret);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Input {
const int BUF = 65536;
char buf[BUF + 1];
char *head = buf, *tail = buf;
inline char inputchar() {
if (head == tail) *(tail = (head = buf) + fread(buf, 1, BUF, stdin)) = 0;
return *head++;
}
inline void inputnum(int &ret) {
char ch = inputchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = inputchar();
int sgn = (ch == '-' ? ch = inputchar(), -1 : 1);
for (ret = 0; ch >= '0' && ch <= '9'; ch = inputchar())
ret = ret * 10 + ch - '0';
ret *= sgn;
}
} // namespace Input
using Input::inputnum;
const int MAXN = 200005;
const int S = 450;
const int MOD = 1e9 + 7;
const int INF = 1 << 30;
inline void add(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline void mul(int &a, int b) { a = (long long)a * b % MOD; }
struct Block {
int sum, movel, mover, l, r;
} b[S + 10];
int a[MAXN], w[MAXN];
int n, q, x, y;
long long bit[MAXN];
inline int lowbit(int x) { return x & -x; }
inline void bit_add(int x, long long v) {
++x;
for (int i = x; i <= n; i += lowbit(i)) bit[i] += v;
}
inline long long SUM(int x) {
++x;
if (x <= 0) return 0;
long long ret = 0;
for (int i = x; i > 0; i ^= lowbit(i)) ret += bit[i];
return ret;
}
int calc(int l, int r) {
long long sum_d = SUM(l - 1), sum_u = SUM(r);
while (l < r) {
int mid = (l + r) >> 1;
if (SUM(mid) - sum_d >= sum_u - SUM(mid))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
inputnum(n), inputnum(q);
for (int i = 0; i < n; i++) inputnum(a[i]);
for (int i = 0; i < n; i++) inputnum(w[i]);
for (int i = 0; i < n; i++) bit_add(i, w[i]);
for (int i = 0; i < n; i++) add(b[i / S].sum, w[i]);
for (int i = 0; i < n; i++) {
int l = i, r = i, id = i / S;
while (id == (r + 1) / S && r + 1 < n) ++r;
for (int j = l; j <= r; j++)
add(b[id].movel, (long long)(a[j] - a[l] - (j - l)) * w[j] % MOD);
for (int j = r; j >= l; j--)
add(b[id].mover, (long long)(a[r] - a[j] - (r - j)) * w[j] % MOD);
b[id].l = l, b[id].r = r;
i = r;
}
for (int i = 1; i <= q; i++) {
inputnum(x), inputnum(y);
if (x < 0) {
x = -x;
--x;
int id = x / S, l = b[id].l, r = b[id].r;
bit_add(x, y - w[x]);
add(b[id].sum, (y - w[x] + MOD) % MOD);
add(b[id].movel, MOD - (long long)(a[x] - a[l] - (x - l)) * w[x] % MOD);
add(b[id].movel, (long long)(a[x] - a[l] - (x - l)) * y % MOD);
add(b[id].mover, MOD - (long long)(a[r] - a[x] - (r - x)) * w[x] % MOD);
add(b[id].mover, (long long)(a[r] - a[x] - (r - x)) * y % MOD);
w[x] = y;
} else {
if (x == y) {
printf("0\n");
continue;
}
--x, --y;
int L = x, R = y, M = calc(L, R);
int idl = L / S, idm = M / S, idr = R / S, res = 0, d = max(L, b[idm].l),
u = min(R, b[idm].r);
for (int j = M - 1; j >= d; j--)
add(res, (long long)(a[M] - a[j] - (M - j)) * w[j] % MOD);
for (int j = M + 1; j <= u; j++)
add(res, (long long)(a[j] - a[M] - (j - M)) * w[j] % MOD);
for (int j = idm - 1; j > idl; j--) {
int x = b[j].r;
add(res, ((long long)((a[M] - M) - (a[x] - x)) * b[j].sum % MOD +
b[j].mover) %
MOD);
}
for (int j = idm + 1; j < idr; j++) {
int x = b[j].l;
add(res, ((long long)((a[x] - x) - (a[M] - M)) * b[j].sum % MOD +
b[j].movel) %
MOD);
}
if (idl != idm)
for (int j = b[idl].r; j >= L; j--)
add(res, (long long)((a[M] - M) - (a[j] - j)) * w[j] % MOD);
if (idr != idm)
for (int j = b[idr].l; j <= R; j++)
add(res, (long long)((a[j] - j) - (a[M] - M)) * w[j] % MOD);
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
FILE *in, *out;
const int md = 1000000007;
inline int add(int a, int b) {
a += b;
if (a >= md) a -= md;
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += md;
return a;
}
inline void addf(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
inline void subf(int &a, int b) {
a -= b;
if (a < 0) a += md;
}
inline int mul(int a, int b) { return (int)((long long)a * b % md); }
inline int power(int a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) { return power(a, md - 2); }
int Linf = 1000000005;
int N, M, K;
pair<int, int> initx[200100];
int pos[200100];
struct node {
int total;
long long simplell;
int simple;
int L_inc;
int R_inc;
int L_sum;
int R_sum;
node() {
total = 0;
simple = 0;
simplell = 0;
L_inc = 0;
R_inc = 0;
L_sum = 0;
R_sum = 0;
}
node(int posx, int val) {
total = 1;
simplell = val;
simple = val;
L_inc = val;
R_inc = val;
L_sum = mul((Linf - posx), val);
R_sum = mul((posx), val);
}
};
node comb(node a, node b) {
node res;
res.total = a.total + b.total;
res.simplell = a.simplell + b.simplell;
res.simple = (a.simple + b.simple) % 1000000007;
res.L_inc = (a.L_inc + add(b.L_inc, mul(b.simple, a.total))) % 1000000007;
res.R_inc = (b.R_inc + add(a.R_inc, mul(a.simple, b.total))) % 1000000007;
res.L_sum = (a.L_sum + b.L_sum) % 1000000007;
res.R_sum = (a.R_sum + b.R_sum) % 1000000007;
return res;
}
template <class T, int SZ>
struct Seg {
T seg[2 * SZ], MN = T();
Seg() {
for (int i = 0; i < 2 * SZ; i++) seg[i] = T();
}
void upd(int p, T value) {
p += SZ;
seg[p] = value;
for (; p > 1; p >>= 1) seg[p >> 1] = comb(seg[(p | 1) ^ 1], seg[p | 1]);
}
void build() {
for (int i = (SZ)-1; i >= 0; i--) seg[i] = comb(seg[2 * i], seg[2 * i + 1]);
}
T query(int l, int r) {
T res1 = MN, res2 = MN;
r++;
for (l += SZ, r += SZ; l < r; l >>= 1, r >>= 1) {
if (l & 1) res1 = comb(res1, seg[l++]);
if (r & 1) res2 = comb(seg[--r], res2);
}
return comb(res1, res2);
}
long long query2(int l, int r) {
long long res1 = 0, res2 = 0;
r++;
for (l += SZ, r += SZ; l < r; l >>= 1, r >>= 1) {
if (l & 1) res1 += seg[l++].simplell;
if (r & 1) res2 += seg[--r].simplell;
}
return res1 + res2;
}
};
Seg<node, 200100> S;
int DEBUG(node p) {
printf("total:%d L_sum:%d R_sum:%d L_inc:%d R_inc:%d\n", p.total, p.L_sum,
p.R_sum, p.L_inc, p.R_inc);
return 0;
}
int id[200100];
int solve(int l, int r) {
int i, j, k;
int minx, maxx, midx;
l = id[l - 1];
r = id[r - 1];
int indl = lower_bound(pos, pos + M, l) - pos;
int indr = lower_bound(pos, pos + M, r) - pos;
int indm;
int x1, x2, n1, n2;
int res;
if (indl < indr) {
minx = indl;
maxx = indr - 1;
node temp, temp2;
long long sum = S.query2(indl, indr);
long long templl;
int bestx = -1;
while (minx <= maxx) {
midx = (minx + maxx) / 2;
templl = S.query2(indl, midx);
if (templl * 2 <= sum) {
bestx = max(bestx, midx);
minx = midx + 1;
} else
maxx = midx - 1;
}
if (bestx == -1) bestx = indl - 1;
indm = bestx + 1;
x1 = pos[bestx + 1] - (indm - indl);
x2 = pos[bestx + 1];
n1 = (indm - indl);
n2 = (indr - indl + 1) - (indm - indl);
res = 0;
if (n1 > 0) {
temp = S.query(indl, indl + n1 - 1);
k = sub(add(sub(temp.L_sum, mul(temp.simple, (Linf - x1))), temp.L_inc),
temp.simple);
addf(res, k);
}
if (n2 > 0) {
temp = S.query(indl + n1, indr);
k = sub(add(sub(temp.R_sum, mul(temp.simple, (x2 + n2 - 1))), temp.R_inc),
temp.simple);
addf(res, k);
}
cout << res << "\n";
} else {
cout << "0\n";
}
return 0;
}
int read() {
int i, j, k;
int x, y;
cin >> N >> K;
for (i = 0; i < N; i++) {
cin >> initx[i].first;
pos[i] = initx[i].first;
id[i] = initx[i].first;
}
for (i = 0; i < N; i++) {
cin >> initx[i].second;
}
sort(pos, pos + N);
M = unique(pos, pos + N) - pos;
int ind;
for (i = 0; i < N; i++) {
ind = lower_bound(pos, pos + M, initx[i].first) - pos;
S.upd(ind, node(initx[i].first, initx[i].second));
}
for (i = 0; i < K; i++) {
cin >> x >> y;
if (x > 0) {
solve(x, y);
} else {
x = -x;
ind = lower_bound(pos, pos + M, id[x - 1]) - pos;
S.upd(ind, node(id[x - 1], y));
}
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
in = stdin;
out = stdout;
read();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <int sz>
struct FT {
array<long long, sz + 1> v;
FT() { fill(v.begin(), v.end(), 0); }
void update(int i, const long long a) {
for (++i; i < (int)v.size(); i += i & -i) {
v[i] += a;
}
}
long long query(int i) const {
assert(i >= -1 && i < (int)v.size() - 1);
long long sum = 0;
for (++i; i; i -= i & -i) {
sum += v[i];
}
return sum;
}
long long query(int i, int j) const { return query(j) - query(i - 1); }
};
const int mod = 1e9 + 7;
const int MaxN = (int)2e5;
int n, q;
int a[MaxN];
long long w[MaxN];
FT<MaxN> ftw;
FT<MaxN> ftp;
void setW(const int i, const long long val) {
assert(0 <= i && i < n);
w[i] = val;
ftw.update(i, (-ftw.query(i, i) + val));
ftp.update(i, (-ftp.query(i, i) + val * (a[i] - i)) % mod);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
setW(i, x);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0)
setW(-x - 1, y);
else {
--x, --y;
int lo = x;
int hi = y;
const long long total = ftw.query(x, y);
while (lo < hi) {
const int mid = (lo + hi) >> 1;
if (ftw.query(x, mid) >= ((total + 1) >> 1))
hi = mid;
else
lo = mid + 1;
}
assert(lo == hi);
const int k = lo;
const long long sumL = ftw.query(x, k - 1);
const long long sumR = ftw.query(k + 1, y);
long long ans = 0;
ans += sumL % mod * (a[k] - k) % mod - ftp.query(x, k - 1);
ans += sumR % mod * (k - a[k]) % mod + ftp.query(k + 1, y);
((ans %= mod) += mod) %= mod;
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 2e5 + 10;
template <class T>
struct range_bit {
T B1[N];
T query(int b) {
T sum = 0;
for (; b; b -= (b & (-b))) sum += B1[b];
return sum;
}
T range_query(int i, int j) { return query(j) - query(i - 1); }
void update(int k, T v) {
for (; k < N; k += (k & (-k))) B1[k] += v;
}
};
range_bit<long long> bit1, bit2;
range_bit<long double> bit3;
const int mod = 1e9 + 7;
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int powr(int a, long long b) {
int x = 1 % mod;
while (b) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
int a[N], w[N];
long double get(int l, int r, int pos) {
return bit3.range_query(pos + 1, r) - bit3.range_query(l, pos) +
a[pos] * (long double)(bit1.range_query(l, pos) -
bit1.range_query(pos + 1, r));
}
int get_mod(int l, int r, int pos) {
long long x1 = bit2.range_query(pos + 1, r) - bit2.range_query(l, pos);
x1 %= mod;
x1 += mod;
x1 %= mod;
long long x2 = bit1.range_query(l, pos) - bit1.range_query(pos + 1, r);
x2 %= mod;
x2 += mod;
x2 %= mod;
return add(x1, mul(a[pos], x2));
}
int main() {
int n, q;
scanf("%d", &(n));
scanf("%d", &(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]));
bit1.update(i, w[i]);
bit2.update(i, mul(w[i], a[i]));
bit3.update(i, a[i] * (long long)w[i]);
}
while (q--) {
int x, y;
scanf("%d", &(x));
scanf("%d", &(y));
if (x < 0) {
x *= -1;
bit1.update(x, y - w[x]);
bit2.update(x, mul(y, a[x]) - mul(w[x], a[x]));
bit3.update(x, (y - w[x]) * (long long)a[x]);
w[x] = y;
} else {
int lo = x, hi = y;
long long total_sum = bit1.range_query(x, y);
while (lo < hi) {
int mid = (lo + hi) >> 1;
if (2 * bit1.range_query(x, mid) >= total_sum) {
hi = mid;
} else
lo = mid + 1;
}
if (x == lo) {
printf("%d\n", get_mod(x, y, x));
} else if (get(x, y, lo) > get(x, y, lo - 1)) {
printf("%d\n", get_mod(x, y, lo - 1));
} else
printf("%d\n", get_mod(x, y, lo));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const int MAX_N = (int)3e5 + 17;
const int mod = (int)1e9 + 7;
int N, M, S, T, K;
int a[MAX_N], w[MAX_N];
struct Fenwick_0 {
long long bt[MAX_N];
void init() {
for (int i = 0; i <= N; i++) bt[i] = 0;
}
void add(int idx, int w) {
for (; idx <= N; idx += idx & -idx) bt[idx] += w;
}
long long sum(int idx) {
long long ans = 0;
for (; idx > 0; idx -= idx & -idx) ans += bt[idx];
return ans;
}
} W;
struct Fenwick_1 {
int bt[MAX_N];
void init() {
for (int i = 0; i <= N; i++) bt[i] = 0;
}
void add(int idx, int w) {
for (; idx <= N; idx += idx & -idx) (bt[idx] += w) %= mod;
}
int sum(int idx) {
int ans = 0;
for (; idx > 0; idx -= idx & -idx) (ans += bt[idx]) %= mod;
return ans;
}
} F;
int main() {
while (~scanf("%d %d", &N, &M)) {
W.init();
F.init();
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]);
W.add(i, w[i]);
F.add(i, 1LL * a[i] * w[i] % mod);
}
while (M--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x *= -1;
W.add(x, y - w[x]);
F.add(x, 1LL * (y - w[x]) * a[x] % mod);
w[x] = y;
} else {
long long sl = W.sum(x - 1), sr = W.sum(y);
sr = (sr - sl + 1) / 2;
int l = x, r = y;
while (l <= r) {
int mid = (l + r) >> 1;
if (W.sum(mid) - sl >= sr)
r = mid - 1;
else
l = mid + 1;
}
long long ans = (F.sum(y) - F.sum(l)) -
(W.sum(y) - W.sum(l)) % mod * 1LL * a[l] % mod -
((F.sum(l) - F.sum(x - 1)) -
(W.sum(l) - W.sum(x - 1)) % mod * 1LL * a[l] % mod);
printf("%lld\n", (ans % mod + mod) % mod);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000020;
const int maxm = 1000020;
const int MOd = 1e9 + 7;
int a, ar[maxn], w[maxn], q;
long long fw[maxn];
int val[maxn][2];
int mul(int x, int y) { return (long long)x * y % MOd; }
int add(int a, int b) {
a += b;
a %= MOd;
if (a < 0) a += MOd;
return a;
}
void uval(int x, int y, int tp) {
for (int i = x; i <= a; i += i & (-i)) val[i][tp] = add(val[i][tp], y);
}
long long fval(int l, int r, int tp) {
long long ret = 0;
for (int i = r; i > 0; i -= i & (-i)) ret = add(ret, val[i][tp]);
for (int i = l - 1; i > 0; i -= i & (-i)) ret = add(ret, -val[i][tp]);
return ret;
}
void up(int x, int y) {
for (int i = x; i <= a; i += i & (-i)) fw[i] += y;
}
long long f(int l, int r) {
long long ret = 0;
for (int i = r; i > 0; i -= i & (-i)) ret += fw[i];
for (int i = l - 1; i > 0; i -= i & (-i)) ret -= fw[i];
return ret;
}
int main() {
scanf("%d %d", &a, &q);
for (int i = 1; i <= a; i++) {
scanf("%d", &ar[i]);
}
for (int i = 1; i <= a; i++) {
scanf("%d", &w[i]), up(i, w[i]);
uval(i, mul(w[i], ar[i]), 0);
uval(i, mul(w[i], i), 1);
}
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x > 0) {
int l = x, r = y, ans = 0;
long long tot = f(x, y) / 2;
while (l < r) {
int m = (l + r) / 2;
if (f(x, m) > tot)
r = m;
else
l = m + 1;
}
ans = add(ans, add(mul(f(x, r) % MOd, ar[r]), -fval(x, r, 0)));
ans = add(ans, -add(mul(f(x, r) % MOd, r), -fval(x, r, 1)));
ans = add(ans, add(fval(r, y, 0), -mul(f(r, y) % MOd, ar[r])));
ans = add(ans, -add(fval(r, y, 1), -mul(f(r, y) % MOd, r)));
cout << ans << endl;
} else {
x = -x;
up(x, y - w[x]);
uval(x, mul(y - w[x], ar[x]), 0);
uval(x, mul(y - w[x], x), 1);
w[x] = y;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using lld = long double;
using ulli = unsigned long long int;
using pll = pair<lli, lli>;
using ttt = pair<lli, pll>;
using vttt = vector<ttt>;
using vll = vector<pll>;
using vl = vector<lli>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using cd = complex<lld>;
const double PI = acos(-1);
lli pref[200010], lcol[200010], rcol[200010];
lli arr[200010], wrr[200010];
void add(lli tre[], int x, lli val, bool fl) {
for (x += 2; x < 200010; x += (x & -x)) {
tre[x] += val;
if (fl) tre[x] %= 1000000007;
}
}
lli get(lli tre[], int x, bool fl) {
lli res = 0;
for (x += 2; x > 0; x -= (x & -x)) res += tre[x];
if (fl) res %= 1000000007;
return res;
}
lli get(lli tre[], int l, int r, bool fl) {
if (!fl)
return get(tre, r, fl) - get(tre, l - 1, fl);
else
return (get(tre, r, fl) - get(tre, l - 1, fl) + 1000000007) % 1000000007;
}
lli fin(int pos, int l, int r) {
lli move = (get(rcol, pos + 1, r, 1) - get(rcol, l, pos, 1)) % 1000000007;
lli del1 = ((arr[pos] - pos) * get(pref, pos + 1, r, 1)) % 1000000007;
lli add1 = ((arr[pos] - pos) * get(pref, l, pos, 1)) % 1000000007;
return ((move - del1 + add1) % 1000000007 + 1000000007) % 1000000007;
}
int tejas_919(int kkkk) {
lli n, m, k, q, u, v, temp = 0, ans = 0;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
cin >> wrr[i];
add(pref, i, wrr[i], 0);
}
for (int i = 0; i < n; i++) add(rcol, i, wrr[i] * (arr[i] - i), 1);
for (int i = 1; i < q + 1; i++) {
cin >> u >> v;
if (u < 0) {
u = -u - 1;
temp = v - wrr[u];
add(pref, u, temp, 0);
add(rcol, u, temp * (arr[u] - u), 1);
wrr[u] = v;
} else {
if (u == v) {
cout << 0 << '\n';
continue;
} else {
u--;
v--;
lli f = get(pref, u, u, 0);
lli s = get(pref, u + 1, v, 0);
if (f >= s) {
cout << fin(u, u, v) << '\n';
continue;
}
int l = u, r = v;
f += s;
f /= 2;
while (r - l > 1) {
int mid = (l + r) / 2;
if (get(pref, u, mid, 0) <= f)
l = mid;
else
r = mid;
}
cout << fin(l + 1, u, v) << '\n';
}
}
}
return 0;
}
signed main() {
if (!0) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
cout << fixed << setprecision(10);
int t = 1;
for (int i = 0; i < t; i++) {
tejas_919(i + 1);
}
{};
if (0) system("pause");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5000;
const long double eps = (1e-12);
const int logn = 21;
const double Pi = acos(-1.0);
const long long pp = 1000000000 + 7;
int lowbit(int x) { return x & (-x); }
const long long INF = 1e9;
long long nums[MAXN];
long long w[MAXN];
long long n, q;
struct node {
long long sum;
long long l;
long long r;
};
node tree[(MAXN << 2) + 5];
inline long long lk(long long p) { return p << 1; }
inline long long rk(long long p) { return (p << 1) | 1; }
long long tag[(MAXN << 2) + 5];
inline void push_up(long long p) {
tree[p].sum = tree[lk(p)].sum + tree[rk(p)].sum;
}
inline void build(long long p, long long l, long long r) {
tag[p] = 0;
tree[p].l = l;
tree[p].r = r;
if (l == r) {
tree[p].sum = w[l];
return;
}
long long mid = (l + r) >> 1;
build(lk(p), l, mid);
build(rk(p), mid + 1, r);
push_up(p);
}
inline void f(long long p, long long l, long long r, long long k) {
tag[p] = tag[p] + k;
tree[p].sum = tree[p].sum + k * (r - l + 1);
}
inline void push_down(long long p, long long l, long long r) {
long long mid = (l + r) >> 1;
f(lk(p), l, mid, tag[p]);
f(rk(p), mid + 1, r, tag[p]);
tag[p] = 0;
}
inline void update(long long nl, long long nr, long long l, long long r,
long long p, long long k) {
if (nl <= l && r <= nr) {
f(p, l, r, k);
return;
}
push_down(p, l, r);
long long mid = (l + r) >> 1;
if (nl <= mid) update(nl, nr, l, mid, lk(p), k);
if (nr > mid) update(nl, nr, mid + 1, r, rk(p), k);
push_up(p);
}
inline long long querySum(long long nl, long long nr, long long l, long long r,
long long p) {
if (nr < nl) return 0;
long long ans = 0;
if (nl <= l && r <= nr) return tree[p].sum;
long long mid = (l + r) >> 1;
push_down(p, l, r);
if (nl <= mid) ans += querySum(nl, nr, l, mid, lk(p));
if (nr > mid) ans += querySum(nl, nr, mid + 1, r, rk(p));
return ans;
}
inline long long queryIdx(long long l, long long r, long long p, long long &tar,
long long liml, long long limr) {
if (liml <= l && r <= limr) {
if (tree[p].sum < tar) {
tar -= tree[p].sum;
return -1;
}
}
if (l == r) {
if (tree[p].sum >= tar)
return l;
else
tar -= tree[p].sum;
return -1;
}
long long mid = (l + r) >> 1;
push_down(p, l, r);
long long ans = -1;
if (mid < liml) {
ans = queryIdx(mid + 1, r, rk(p), tar, liml, limr);
} else if (mid >= limr) {
ans = queryIdx(l, mid, lk(p), tar, liml, limr);
} else {
ans = queryIdx(l, mid, lk(p), tar, liml, limr);
if (ans == -1) {
ans = queryIdx(mid + 1, r, rk(p), tar, liml, limr);
}
}
return ans;
}
struct BIT {
long long S[MAXN] = {}, n = 0;
void init(long long x) {
this->n = x;
for (long long i = 0; i <= n; i++) S[i] = 0;
}
void del(long long x) {
for (long long i = x; i <= n; i += (i & -i)) S[i] = 0;
}
void add(long long x, long long v) {
for (long long i = x; i <= n; i += (i & -i)) {
S[i] += v;
S[i] = ((((S[i]) % pp) + pp) % pp);
}
return;
}
long long ask(long long x) {
if (x == 0) return 0;
long long res = 0;
for (long long i = x; i >= 1; i -= (i & -i)) {
res += S[i];
res %= pp;
}
return res;
}
};
BIT bits[3];
signed main() {
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &nums[i]);
}
bits[0].init(n);
bits[1].init(n);
bits[2].init(n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
bits[0].add(i, w[i]);
bits[1].add(i, w[i] * nums[i]);
bits[2].add(i, w[i] * i);
}
build(1, 1, n);
while (q--) {
long long x, y;
scanf("%lld%lld", &x, &y);
if (x > 0) {
long long sum = querySum(x, y, 1, n, 1);
sum = (sum + 1) / 2;
long long ans = queryIdx(1, n, 1, sum, x, y);
long long l = x;
long long anss = 0;
if (l < ans) {
long long tmp1 =
((((bits[0].ask(ans - 1) - bits[0].ask(l - 1)) % pp) + pp) % pp);
long long tmp2 =
((((bits[1].ask(ans - 1) - bits[1].ask(l - 1)) % pp) + pp) % pp);
long long tmp3 =
((((bits[2].ask(ans - 1) - bits[2].ask(l - 1)) % pp) + pp) % pp);
anss +=
((((((((nums[ans] * tmp1) % pp) + pp) % pp) - tmp2) % pp) + pp) %
pp);
anss -= (((((((((ans)*tmp1) % pp) + pp) % pp) - tmp3) % pp) + pp) % pp);
}
long long r = y;
anss = ((((anss) % pp) + pp) % pp);
if (y > ans) {
anss +=
(((((bits[1].ask(r) - bits[1].ask(ans)) -
((((nums[ans] *
((((bits[0].ask(r) - bits[0].ask(ans)) % pp) + pp) % pp)) %
pp) +
pp) %
pp)) %
pp) +
pp) %
pp);
anss -=
(((((bits[2].ask(r) - bits[2].ask(ans)) -
(((((ans) *
((((bits[0].ask(r) - bits[0].ask(ans)) % pp) + pp) % pp)) %
pp) +
pp) %
pp)) %
pp) +
pp) %
pp);
}
anss = ((((anss) % pp) + pp) % pp);
printf("%lld\n", anss);
} else {
x = -x;
update(x, x, 1, n, 1, y - w[x]);
bits[0].add(x, y - w[x]);
bits[1].add(x, nums[x] * (y - w[x]));
bits[2].add(x, x * (y - w[x]));
w[x] = y;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
template <typename T>
ostream& operator+(ostream& out, const vector<T>& vec) {
for (const auto& x : vec) {
out << x << " ";
}
out << "\n";
return out;
}
template <typename T>
ostream& operator*(ostream& out, const vector<T>& vec) {
for (const auto& x : vec) {
out + x;
}
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& vec) {
for (auto& x : vec) {
in >> x;
}
return in;
}
template <typename T>
struct segment_tree {
int n;
vector<T> segtree;
function<T(const T&, const T&)> join;
T base = T();
segment_tree(int n, function<T(const T&, const T&)> join, T base = T())
: n(n), join(join), base(base) {
segtree.resize(n << 1, base);
}
void build() {
for (int i = n - 1; i > 0; --i) {
segtree[i] = join(segtree[(i << 1)], segtree[(i << 1) | 1]);
}
}
segment_tree(vector<T> seq, function<T(const T&, const T&)> join,
T base = T())
: n(seq.size()), join(join), base(base) {
segtree.resize(n << 1, base);
for (int i = 0; i < n; i++) {
segtree[n + i] = seq[i];
}
build();
}
void calc(int pos) {
pos >>= 1;
while (pos) {
segtree[pos] = join(segtree[pos << 1], segtree[(pos << 1) | 1]);
pos >>= 1;
}
}
void set(int pos, T val) {
pos += n;
segtree[pos] = val;
calc(pos);
}
void increment(int pos, T val) {
pos += n;
segtree[pos] = join(segtree[pos], val);
calc(pos);
}
T query(int l, int r) {
T ansl = base;
T ansr = base;
l += n;
r += n + 1;
while (l < r) {
if (l & 1) {
ansl = join(ansl, segtree[l++]);
}
if (r & 1) {
ansr = join(segtree[--r], ansr);
}
l >>= 1;
r >>= 1;
}
return join(ansl, ansr);
}
T search(T val) {
assert(__builtin_popcount(n) == 1);
int idx = 1;
T curr = base;
while (idx < n) {
idx <<= 1;
if (join(curr, segtree[idx]) < val) {
curr = join(curr, segtree[idx]);
++idx;
}
}
if (join(curr, segtree[idx]) < val) {
curr = join(curr, segtree[idx]);
++idx;
}
return idx - n;
}
};
const int p = 1e9 + 7;
void solve() {
int n, q;
cin >> n >> q;
vector<ll> a(n), w(n);
cin >> a >> w;
for (int i = 0; i < n; i++) a[i] -= i;
vector<ll> aw(n);
for (int i = 0; i < n; i++) aw[i] = a[i] * w[i], aw[i] %= p;
int pn = 1;
while (pn < n) {
pn <<= 1;
}
w.resize(pn);
aw.resize(pn);
segment_tree<ll> segtree1(
w, [&](ll x, ll y) { return x + y; }, 0ll);
segment_tree<ll> segtree2(
aw,
[&](ll x, ll y) {
ll ans = x + y;
if (ans >= p) ans -= p;
return ans;
},
0ll);
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
if (l > 0) {
--l;
--r;
ll sum = (segtree1.query(l, r) + 1) / 2;
if (l != 0) sum += segtree1.query(0, l - 1);
int idx = segtree1.search(sum);
ll x = a[idx];
ll ans =
segtree2.query(idx, r) - segtree2.query(l, idx) +
(((segtree1.query(l, idx) - segtree1.query(idx, r)) % p) * x) % p;
ans %= p;
if (ans < 0) ans += p;
cout << ans << "\n";
} else {
l = -l;
--l;
segtree1.set(l, r);
segtree2.set(l, r * a[l] % p);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int mod = 1e9 + 7;
const int maxn = 200200;
int n, q, a[maxn];
struct Node {
int l, r;
long long val;
} tr[maxn * 4];
long long w[maxn];
struct BIT {
long long a[maxn * 2];
void add(int x, long long k) {
while (x <= 400000) {
a[x] += k;
x += (x & -x);
}
}
long long ask(int x) {
long long ret = 0;
while (x) {
ret += a[x];
x -= (x & -x);
}
return ret;
}
long long sum(int l, int r) { return ask(r) - ask(l - 1); }
} lzt1, lzt2;
void build(int i, int l, int r) {
tr[i].l = l, tr[i].r = r;
if (l == r) {
tr[i].val = w[tr[i].l];
return;
}
int md = (l + r) >> 1;
build((i << 1), l, md);
build((i << 1 | 1), md + 1, r);
tr[i].val = tr[(i << 1)].val + tr[(i << 1 | 1)].val;
}
void update(int i, int l, int r) {
if (tr[i].l == tr[i].r) {
tr[i].val = r;
return;
}
int md = (tr[i].l + tr[i].r) >> 1;
if (md >= l)
update((i << 1), l, r);
else
update((i << 1 | 1), l, r);
tr[i].val = tr[(i << 1)].val + tr[(i << 1 | 1)].val;
}
int fnd(int i, long long o) {
if (tr[i].l == tr[i].r) {
return tr[i].l;
}
if (tr[(i << 1)].val >= o)
return fnd((i << 1), o);
else
return fnd((i << 1 | 1), o - tr[(i << 1)].val);
}
int main() {
n = read(), q = read();
for (register int i = (int)(1); i <= (int)(n); i++) a[i] = read() - i + 1;
for (register int i = (int)(1); i <= (int)(n); i++) {
w[i] = read();
lzt1.add(i, w[i]);
lzt2.add(i, w[i] * 1ll * a[i] % mod);
}
build(1, 1, n);
while (q--) {
int l = read(), r = read();
if (l < 0) {
l = -l;
lzt1.add(l, -w[l]);
lzt2.add(l, -(w[l] * 1ll * a[l]) % mod);
w[l] = r;
lzt1.add(l, w[l]);
lzt2.add(l, w[l] * 1ll * a[l] % mod);
update(1, l, r);
} else {
long long L = lzt1.ask(l - 1), R = lzt1.ask(r);
int k = fnd(1, (L + R + 1) >> 1ll);
long long ans = a[k] * 1ll * (lzt1.sum(l, k - 1) % mod) % mod -
lzt2.sum(l, k - 1) % mod + lzt2.sum(k + 1, r) % mod -
a[k] * 1ll * (lzt1.sum(k + 1, r) % mod) % mod;
ans = (ans % mod + mod) % mod;
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int data = 0, w = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
data = (data << 1) + (data << 3) + (ch ^ 48), ch = getchar();
return data * w;
}
const int mod = 1e9 + 7;
int n;
namespace SUM {
long long c[1000005];
void add(int x, long long v) {
for (int i = x; i <= n; i += i & -i) c[i] += v;
}
long long ask(int x) {
long long ans = 0;
for (int i = x; i; i -= i & -i) ans += c[i];
return ans;
}
long long Query(int l, int r) { return ask(r) - ask(l - 1); }
}; // namespace SUM
void fix(int &x) {
x -= mod;
x += x >> 31 & mod;
}
namespace Mul {
int c[1000005];
void add(int x, int v) {
for (int i = x; i <= n; i += i & -i) fix(c[i] += v);
}
int ask(int x) {
int ans = 0;
for (int i = x; i; i -= i & -i) fix(ans += c[i]);
return ans;
}
int Query(int l, int r) { return (ask(r) - ask(l - 1) + mod) % mod; }
}; // namespace Mul
int q, a[1000005], w[1000005];
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++)
w[i] = read(), SUM::add(i, w[i]),
Mul::add(i, 1ll * w[i] * (a[i] - i) % mod);
while (q--) {
int x = read(), y = read();
if (x < 0) {
x = -x;
SUM::add(x, -w[x] + y),
Mul::add(x, 1ll * (-w[x] + y + mod) * (a[x] - x) % mod);
w[x] = y;
} else {
int l = x, r = y, pos = 0;
while (l <= r) {
int mid = l + r >> 1;
if (SUM::Query(x, mid) >= SUM::Query(mid + 1, y))
pos = mid, r = mid - 1;
else
l = mid + 1;
}
int Ans = (-Mul::Query(x, pos) +
1ll * (a[pos] - pos) * (SUM::Query(x, pos) % mod) % mod + mod -
1ll * (a[pos] - pos) * (SUM::Query(pos, y) % mod) % mod +
Mul::Query(pos, y) + mod) %
mod;
cout << Ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0LL) return b;
if (b == 0LL) return a;
return gcd(b, a % b);
}
const int N = 200005;
long long A[N], W[N];
pair<long long, long long> tree[N << 2];
pair<long long, long long> temp[N << 2];
void build(int node, int l, int r) {
if (l == r) {
tree[node] = make_pair(W[l], (A[l] * W[l]) % 1000000007LL);
return;
}
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
build(left, l, mid);
build(right, mid + 1, r);
tree[node].first = tree[left].first + tree[right].first;
tree[node].second = (tree[left].second + tree[right].second) % 1000000007LL;
return;
}
void update(int node, int l, int r, int idx) {
if (l == r) {
tree[node] = make_pair(W[idx], (A[idx] * W[idx]) % 1000000007LL);
return;
}
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
if (idx <= mid)
update(left, l, mid, idx);
else
update(right, mid + 1, r, idx);
tree[node].first = tree[left].first + tree[right].first;
tree[node].second = (tree[left].second + tree[right].second) % 1000000007LL;
return;
}
pair<long long, long long> query(int node, int l, int r, int a, int b) {
if (l == a && r == b) {
temp[node] = tree[node];
return tree[node];
}
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
if (b <= mid) {
temp[node] = query(left, l, mid, a, b);
return temp[node];
} else if (a > mid) {
temp[node] = query(right, mid + 1, r, a, b);
return temp[node];
}
pair<long long, long long> L = query(left, l, mid, a, mid);
pair<long long, long long> R = query(right, mid + 1, r, mid + 1, b);
pair<long long, long long> ans =
make_pair(L.first + R.first, (L.second + R.second) % 1000000007LL);
temp[node] = ans;
return ans;
}
int query1(int node, int l, int r, int a, int b, long long val) {
int mid = (l + r) >> 1;
int left = node << 1;
int right = left + 1;
if (l == a && r == b) {
if (l == r) return l;
if (2LL * tree[left].first < val)
return query1(right, mid + 1, r, mid + 1, r,
val - 2LL * tree[left].first);
return query1(left, l, mid, l, mid, val);
}
if (b <= mid)
return query1(left, l, mid, a, b, val);
else if (a > mid)
return query1(right, mid + 1, r, a, b, val);
long long val1 = temp[left].first;
if (2LL * val1 < val)
return query1(right, mid + 1, r, mid + 1, b, val - 2LL * val1);
return query1(left, l, mid, a, mid, val);
}
long long getAns(int n, int L, int R, int ind) {
long long X = A[ind];
long long ans = 0LL;
pair<long long, long long> val = query(1, 1, n, L, ind);
val.first = val.first % 1000000007LL;
ans = (ans + ((X * val.first) % 1000000007LL) - val.second +
2LL * 1000000007LL) %
1000000007LL;
val = query(1, 1, n, ind, R);
val.first = val.first % 1000000007LL;
ans = (ans + val.second - ((X * val.first) % 1000000007LL) +
2LL * 1000000007LL) %
1000000007LL;
return ans;
}
void solve1(int n, int L, int R) {
pair<long long, long long> val = query(1, 1, n, L, R);
int ind = query1(1, 1, n, L, R, val.first);
cout << getAns(n, L, R, ind) << "\n";
return;
}
void solve() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> A[i];
A[i] = A[i] - i;
}
for (int i = 1; i <= n; i++) cin >> W[i];
build(1, 1, n);
int L, R;
while (q--) {
cin >> L >> R;
if (L < 0) {
L = -1 * L;
W[L] = R;
update(1, 1, n, L);
continue;
}
solve1(n, L, R);
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clock_t clk = clock();
int t = 1;
for (int tests = 1; tests <= t; tests++) {
solve();
}
clk = clock() - clk;
cerr << "Time Elapsed: " << fixed << setprecision(10)
<< ((long double)clk) / CLOCKS_PER_SEC << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace whatever {
int readu() {
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
int value = ch - '0';
ch = getchar();
while (isdigit(ch)) {
value = value * 10 + ch - '0';
ch = getchar();
}
return value;
}
int reads() {
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
int sign = 1;
if (ch == '-') {
sign = -1;
ch = getchar();
}
int value = ch - '0';
ch = getchar();
while (isdigit(ch)) {
value = value * 10 + ch - '0';
ch = getchar();
}
return value * sign;
}
void writeu(int n) {
if (n < 10)
putchar(n + '0');
else {
writeu(n / 10);
putchar(n % 10 + '0');
}
}
const int mod = 1000000007;
int n;
void add(int &a, int b) {
a += b;
a %= mod;
}
void add(long long &a, long long b) { a += b; }
int low_bit(int a) { return a & -a; }
template <typename type>
void add(type *bit, int index, long long value) {
while (index <= n) {
add(bit[index], value);
index += (index & -index);
}
}
template <typename type>
type sum(type *bit, int index) {
type result = 0;
while (index != 0) {
add(result, bit[index]);
index -= (index & -index);
}
return result;
}
pair<int, long long> lower_bound(long long *bit, long long value) {
int index = (1 << 18);
for (int i = 17; i >= 0; --i)
if (index - (1 << i) <= n && bit[index - (1 << i)] < value)
value -= bit[index - (1 << i)];
else
index -= (1 << i);
return make_pair(index, value);
}
void run() {
n = readu();
int q = readu();
static int a[200000 + 1];
static int w[200000 + 1];
static long long bit_weight[200000 + 1];
static int bit_prod[200000 + 1];
for (int i = 1; i <= n; ++i) a[i] = readu();
for (int i = 1; i <= n; ++i) {
w[i] = readu();
add(bit_weight, i, w[i]);
add(bit_prod, i, (long long)(a[i] - i) * w[i] % mod);
}
while (--q != -1) {
int x = reads();
int y = readu();
if (x < 0) {
int index = -x;
int new_w = y;
add(bit_weight, index, new_w - w[index]);
add(bit_prod, index,
(long long)(a[index] - index) * (new_w - w[index] + mod) % mod);
w[index] = new_w;
} else {
int l = x;
int r = y;
long long sum_before_l = sum(bit_weight, l - 1);
long long sum_until_r = sum(bit_weight, r);
long long sum_between = sum_until_r - sum_before_l;
long long sum_half_way = sum_before_l + (sum_between + 1) / 2;
auto [m, remain] = lower_bound(bit_weight, sum_half_way);
assert(sum(bit_weight, m - 1) + remain == sum_half_way);
int coeff = (a[m] - m + mod) % mod;
long long sum_until_m = sum(bit_weight, m);
int result =
(sum_until_m * 2 - sum_before_l - sum_until_r) % mod * coeff % mod;
sum_before_l = sum(bit_prod, l - 1);
sum_until_m = sum(bit_prod, m);
sum_until_r = sum(bit_prod, r);
result = (result - (sum_until_m - sum_before_l) +
(sum_until_r - sum_until_m)) %
mod;
result %= mod;
result += mod;
result %= mod;
writeu(result);
putchar('\n');
}
}
}
} // namespace whatever
int main() { whatever::run(); }
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int a[200010], w[200010];
long long B[200010], Bv[200010];
void update(int u, long long x) {
while (u < 200010) {
B[u] += x;
u += u & (-u);
}
}
long long calc(int u) {
long long ss = 0;
while (u > 0) {
ss += B[u];
u -= u & (-u);
}
return ss;
}
void update1(int u, long long x) {
while (u < 200010) {
Bv[u] += x;
u += u & (-u);
}
}
long long calc1(int u) {
long long ss = 0;
while (u > 0) {
ss += Bv[u];
u -= u & (-u);
}
return ss % mod;
}
long long calc(int L, int R) { return (calc(R) - calc(L - 1)); }
long long calc1(int L, int R) {
return ((calc1(R) - calc1(L - 1)) % mod + mod) % mod;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
cin >> w[i];
update(i, w[i]);
update1(i, 1LL * w[i] * a[i] % mod);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
int id = -x, nw = y;
update(id, -w[id]);
update1(id, -(1LL * w[id] * a[id] % mod));
w[id] = nw;
update(id, w[id]);
update1(id, (1LL * w[id] * a[id] % mod));
} else {
int L = x, R = y;
long long C = calc(L, R);
int st = L - 1, ed = R;
while (st + 1 < ed) {
int mid = (st + ed) >> 1;
if (calc(L, mid) * 2 > C)
ed = mid;
else
st = mid;
}
int k = ed;
long long ans = 1LL * a[k] * (calc(L, k - 1) % mod) - calc1(L, k - 1);
ans += calc1(k + 1, R) - 1LL * a[k] * (calc(k + 1, R) % mod);
cout << (ans % mod + mod) % mod << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
const int maxn = 200111;
int n, q;
long long pos[maxn];
struct SGT {
long long a[maxn << 4], b[maxn << 4];
void modify(int x, long long v, int l, int r, int p) {
if (l == r) {
a[p] = v;
b[p] = pos[l] * v % mod;
return;
}
int m = l + r >> 1;
if (x <= m)
modify(x, v, l, m, p << 1);
else
modify(x, v, m + 1, r, p << 1 | 1);
a[p] = a[p << 1] + a[p << 1 | 1];
b[p] = (b[p << 1] + b[p << 1 | 1]) % mod;
}
long long query(int x, int y, int l, int r, int p) {
if (x > y) return 0;
if (x <= l && r <= y) return a[p];
int m = l + r >> 1;
long long ret = 0;
if (x <= m) ret += query(x, y, l, m, p << 1);
if (m < y) ret += query(x, y, m + 1, r, p << 1 | 1);
return ret;
}
long long queryb(int x, int y, int l, int r, int p) {
if (x > y) return 0;
if (x <= l && r <= y) return b[p];
int m = l + r >> 1;
long long ret = 0;
if (x <= m) ret += queryb(x, y, l, m, p << 1);
if (m < y) ret += queryb(x, y, m + 1, r, p << 1 | 1);
return ret % mod;
}
int querylft(int x, int y, long long &v, int l, int r, int p) {
if (x <= l && r <= y) {
if (v > a[p]) {
v -= a[p];
return r + 1;
} else {
if (l == r) return l;
int m = l + r >> 1;
if (v <= a[p << 1])
return querylft(x, y, v, l, m, p << 1);
else {
v -= a[p << 1];
return querylft(x, y, v, m + 1, r, p << 1 | 1);
}
}
}
int m = l + r >> 1;
if (x <= m && m < y) {
int t = querylft(x, y, v, l, m, p << 1);
if (t == m + 1)
return querylft(x, y, v, m + 1, r, p << 1 | 1);
else
return t;
} else if (x <= m)
return querylft(x, y, v, l, m, p << 1);
else
return querylft(x, y, v, m + 1, r, p << 1 | 1);
}
} sgt;
long long w[maxn], w2[maxn];
long long solve(int l, int r) {
long long sum = sgt.query(l, r, 1, n, 1);
long long cur = (sum + 1) / 2;
int p = sgt.querylft(l, r, cur, 1, n, 1);
assert(p >= l && p <= r);
long long ANS = sgt.queryb(p + 1, r, 1, n, 1) - sgt.queryb(l, p, 1, n, 1);
long long cnt =
(-sgt.query(p + 1, r, 1, n, 1) + sgt.query(l, p, 1, n, 1)) % mod;
return ((ANS + cnt * pos[p] % mod) % mod + mod) % mod;
}
int main() {
n = getnum(), q = getnum();
for (int i = 1; i <= n; i++) {
pos[i] = getnum();
pos[i] -= i;
}
for (int i = 1; i <= n; i++) {
w[i] = getnum();
sgt.modify(i, w[i], 1, n, 1);
}
for (int i = 1; i <= q; i++) {
long long x, y;
x = getnum(), y = getnum();
if (x > 0) {
putnum(solve(x, y)), putchar('\n');
} else {
x = -x;
w[x] = y;
sgt.modify(x, y, 1, n, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 212345;
const int MOD = 1e9 + 7;
const int L = 1;
const int R = 1e9;
struct Tree {
void Clear(int n, long long *base, bool mod) {
n_ = n;
mod_ = mod;
memset(s_, 0, sizeof(s_));
Build(base, 1, n, 1);
}
void Update(int rt) {
s_[rt] = s_[rt << 1] + s_[rt << 1 | 1];
if (mod_ && s_[rt] >= MOD) {
s_[rt] -= MOD;
}
}
void Build(long long *base, int l, int r, int rt) {
if (l == r) {
s_[rt] = base[l];
assert(base[l] < MOD);
return;
}
int m = l + r >> 1;
Build(base, l, m, rt << 1);
Build(base, m + 1, r, rt << 1 | 1);
Update(rt);
}
long long RangeSum(int l, int r) { return RangeSum(l, r, 1, n_, 1); }
long long RangeSum(int xl, int xr, int l, int r, int rt) {
if (xl <= l && r <= xr) {
return s_[rt];
}
long long sum = 0;
int m = l + r >> 1;
if (xl <= m) {
sum += RangeSum(xl, xr, l, m, rt << 1);
}
if (m < xr) {
sum += RangeSum(xl, xr, m + 1, r, rt << 1 | 1);
}
if (mod_ && sum >= MOD) {
sum -= MOD;
}
return sum;
}
void SetValue(int x, long long v) { SetValue(x, v, 1, n_, 1); }
void SetValue(int x, long long v, int l, int r, int rt) {
if (l == r) {
s_[rt] = v;
return;
}
int m = l + r >> 1;
if (x <= m) {
SetValue(x, v, l, m, rt << 1);
} else {
SetValue(x, v, m + 1, r, rt << 1 | 1);
}
Update(rt);
}
int n_;
long long s_[N << 2];
bool mod_;
} sum_left, sum_right, sum_ori;
long long a[N], w[N];
long long wl[N], wr[N];
int Anchor(const int ml, const int mr, const long long sum) {
int l = ml, r = mr;
while (l != r) {
int m = l + r >> 1;
long long msum = sum_ori.RangeSum(ml, m);
if (msum * 2 >= sum) {
r = m;
} else {
l = m + 1;
}
}
return l;
}
int GetLeft(int p, int r) {
if (p >= r) {
return 0;
}
long long lsum = sum_left.RangeSum(p + 1, r);
long long dist = a[p] - (L + p - 1);
long long sum = sum_ori.RangeSum(p + 1, r) % MOD;
return (lsum - dist * sum % MOD + MOD) % MOD;
}
int GetRight(int l, int p, int n) {
if (l >= p) {
return 0;
}
long long rsum = sum_right.RangeSum(l, p - 1);
long long dist = R - (n - p) - a[p];
long long sum = sum_ori.RangeSum(l, p - 1) % MOD;
return (rsum - dist * sum % MOD + MOD) % MOD;
}
int main() {
int n, q;
while (~scanf("%d%d", &n, &q)) {
for (int i = 1; i <= n; ++i) scanf("%I64d", a + i);
for (int i = 1; i <= n; ++i) scanf("%I64d", w + i);
sum_ori.Clear(n, w, false);
for (int i = 1; i <= n; ++i) {
wl[i] = w[i] * (a[i] - (L + i - 1)) % MOD;
wr[i] = w[i] * ((R - (n - i)) - a[i]) % MOD;
}
sum_left.Clear(n, wl, true);
sum_right.Clear(n, wr, true);
for (int i = 0; i < q; ++i) {
long long l, r;
scanf("%I64d%I64d", &l, &r);
if (l < 0) {
int x = -l;
w[x] = r;
sum_ori.SetValue(x, w[x]);
wl[x] = w[x] * (a[x] - (L + x - 1)) % MOD;
sum_left.SetValue(x, wl[x]);
wr[x] = w[x] * ((R - (n - x)) - a[x]) % MOD;
sum_right.SetValue(x, wr[x]);
} else if (l > 0) {
int len = r - l + 1;
long long sum = sum_ori.RangeSum(l, r);
int pivot = Anchor(l, r, sum);
int ans = 0;
ans += GetRight(l, pivot, n);
ans += GetLeft(pivot, r);
printf("%d\n", ans % MOD);
} else {
assert(false);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 50;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
long long a[maxn];
long long w[maxn];
struct node {
int l, r;
long long sum, tot;
} tree[maxn << 2];
void push_up(int i) {
tree[i].sum = tree[i << 1].sum + tree[i << 1 | 1].sum;
tree[i].tot = (tree[i << 1].tot + tree[i << 1 | 1].tot) % mod;
}
void build(int i, int l, int r) {
tree[i].l = l;
tree[i].r = r;
if (l == r) {
tree[i].sum = w[l];
tree[i].tot = (a[l] - 1ll * l) % mod * w[l] % mod;
return;
}
int mid = (tree[i].l + tree[i].r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
push_up(i);
}
void updata(int i, int x, int k) {
if (tree[i].l == tree[i].r && tree[i].l == x) {
tree[i].sum = k;
tree[i].tot = (a[tree[i].l] - 1ll * tree[i].l) % mod * k % mod;
return;
}
int mid = (tree[i].l + tree[i].r) >> 1;
if (x <= mid)
updata(i << 1, x, k);
else
updata(i << 1 | 1, x, k);
push_up(i);
}
long long querytot(int i, int x, int y) {
if (tree[i].l >= x && tree[i].r <= y) return tree[i].tot % mod;
int mid = (tree[i].l + tree[i].r) >> 1;
if (y <= mid)
return querytot(i << 1, x, y);
else if (x > mid)
return querytot(i << 1 | 1, x, y);
else
return (querytot(i << 1, x, mid) % mod +
querytot(i << 1 | 1, mid + 1, y) % mod + mod) %
mod;
}
long long querysum(int i, int x, int y) {
if (tree[i].l >= x && tree[i].r <= y) return tree[i].sum;
int mid = (tree[i].l + tree[i].r) >> 1;
if (y <= mid)
return querysum(i << 1, x, y);
else if (x > mid)
return querysum(i << 1 | 1, x, y);
else
return querysum(i << 1, x, mid) + querysum(i << 1 | 1, mid + 1, y);
}
pair<long long, long long> query(int i, int x, int y, long long k) {
int mid = (tree[i].l + tree[i].r) >> 1;
if (tree[i].l >= x && tree[i].r <= y) {
if (tree[i].sum < k) return {tree[i].sum, inf};
if (tree[i].l == tree[i].r) return {tree[i].sum, tree[i].l};
if (tree[i << 1].sum >= k)
return query(i << 1, x, mid, k);
else
return query(i << 1 | 1, mid + 1, y, k - tree[i << 1].sum);
}
if (y <= mid)
return query(i << 1, x, y, k);
else if (x > mid)
return query(i << 1 | 1, x, y, k);
else {
pair<long long, long long> lt = query(i << 1, x, mid, k);
pair<long long, long long> rt;
long long sum = querysum(1, x, mid);
if (lt.second == inf)
rt = query(i << 1 | 1, mid + 1, y, k - sum);
else
return lt;
return rt;
}
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &w[i]);
build(1, 1, n);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = abs(x);
updata(1, x, y);
} else {
long long sum = querysum(1, x, y);
pair<long long, long long> pr = query(1, x, y, (sum + 1) / 2);
int pos = pr.second;
long long tot1 = 0, tot2 = 0;
long long sum1 = 0, sum2 = 0;
if (x <= pos - 1) {
sum1 = querysum(1, x, pos - 1);
tot1 = querytot(1, x, pos - 1);
}
tot1 = -tot1;
if (y >= pos + 1) {
sum2 = querysum(1, pos + 1, y);
tot2 = querytot(1, pos + 1, y);
}
sum1 %= mod;
sum2 %= mod;
long long ans1 = (a[pos] - pos + mod) % mod * sum1 % mod;
ans1 = (ans1 + tot1 + mod) % mod;
long long ans2 = (pos - a[pos] + mod) % mod * sum2 % mod;
ans2 = (ans2 + tot2 + mod) % mod;
printf("%lld\n", (ans1 + ans2) % mod);
}
}
}
|
#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) {
static int stk[50];
int ssz = 0;
stk[ssz++] = ((((0) + (N - 1)) | ((0) != (N - 1))));
T acum;
int sz = 0;
while (ssz > 0) {
int t = stk[--ssz];
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[ssz++] = ((((m + 1) + (n.e)) | ((m + 1) != (n.e))));
stk[ssz++] = ((((n.b) + (m)) | ((n.b) != (m))));
}
} else {
if (n.b == n.e) continue;
stk[ssz++] = ((((m + 1) + (n.e)) | ((m + 1) != (n.e))));
stk[ssz++] = ((((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 = 0) { s = w; }
Sum operator+(const Sum &o) const {
Sum r;
r.s = (s + o.s);
return r;
}
};
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; }
void operator()(Sum &a) const { a.s = 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);
SegmentTree<Sum, Replace> SU(N);
ST.create(V);
{
vector<long long> WW(N);
for (int i = 0; i < N; ++i) {
WW[i] = V[i].w;
}
SU.create(WW);
}
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;
ST.update(id, id, Replace(nw));
SU.update(id, id, Replace(nw));
} else {
l--;
r--;
long long tots = SU.query(l, r).s;
int sz = SU.findOkPrefix(l, [tots](Sum s) { return s.s * 2 < tots; });
int m = l + sz;
long long a = ST.query(l, m).toR;
long long b = ST.query(m, r).toL;
printf("%d\n", (int)((a + b) % 1000000007));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000 + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 300000 + 7;
template <typename T>
inline void addmod(T& a, const long long& b, const int& MOD = INF) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
int n, q;
int a[MAX_N], w[MAX_N];
class FenWickTree {
public:
void update(int x, int val) {
for (int t = x; t < MAX_N; t += t & -t) {
L[t] += val;
addmod(sum_weight[t], 1ll * val * a[x]);
addmod(sum_level[t], 1ll * val * x);
}
addmod(::w[x], val);
}
long long get(int x) {
long long res = 0;
for (int t = x; t > 0; t -= t & -t) {
res += L[t];
}
return res;
}
int get_sum_weight(int x) {
int res = 0;
for (int t = x; t > 0; t -= t & -t) {
addmod(res, sum_weight[t]);
}
return res;
}
int get_weight_range(int u, int v) {
int res = get_sum_weight(v);
addmod(res, -get_sum_weight(u - 1));
return res;
}
int get_sum_level(int u, int v) {
int res = 0;
for (int t = v; t > 0; t -= t & -t) {
addmod(res, sum_level[t]);
}
for (int t = u - 1; t > 0; t -= t & -t) {
addmod(res, -sum_level[t]);
}
return res;
}
long long get_range(int u, int v) { return get(v) - get(u - 1); }
private:
static const int MAX_N = ::MAX_N;
long long L[MAX_N];
int sum_weight[MAX_N];
int sum_level[MAX_N];
} fenwickTree;
int get_cost_left(int u, int v) {
if (u > v) return 0;
int res = (fenwickTree.get_weight_range(u, v) -
fenwickTree.get_range(u, v) % INF * a[u]) %
INF;
addmod(res, (fenwickTree.get_range(u, v) * 1ll * u -
fenwickTree.get_sum_level(u, v)));
return res;
}
int get_cost_right(int u, int v) {
if (u > v) return 0;
int res = (fenwickTree.get_range(u, v) % INF * a[v] -
fenwickTree.get_weight_range(u, v)) %
INF;
addmod(res, -((fenwickTree.get_range(u, v) * 1ll * v -
fenwickTree.get_sum_level(u, v))));
return res;
}
int calc(int u, int v) {
if (u == v) return 0;
long long total_sum = fenwickTree.get_range(u, v);
int lo = u, hi = v - 1, res = u;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
long long tmp = fenwickTree.get_range(u, mid);
if (tmp <= total_sum - tmp) {
res = mid + 1;
lo = mid + 1;
} else
hi = mid - 1;
}
int found = res;
static const int range = 2;
for (int j = -range; j <= range; ++j) {
int cur = res + j;
if (cur >= u && cur <= v) {
bool check = true;
if (cur - 1 >= u)
check &=
fenwickTree.get_range(u, cur - 1) <= fenwickTree.get_range(cur, v);
if (cur + 1 <= v)
check &=
fenwickTree.get_range(u, cur) >= fenwickTree.get_range(cur + 1, v);
if (check) {
found = cur;
}
}
}
return found;
}
int calc_cost(int u, int v) {
if (u == v) return 0;
int found = calc(u, v);
int ans = get_cost_right(u, found);
addmod(ans, get_cost_left(found, v));
return ans;
}
void solve() {
cin >> n >> q;
for (int i = (1), _b = (n + 1); i < _b; ++i) cin >> a[i];
for (int i = (1), _b = (n + 1); i < _b; ++i) {
int tmp;
cin >> tmp;
fenwickTree.update(i, tmp);
assert(w[i] == tmp);
}
while (q-- > 0) {
int u, v;
cin >> u >> v;
if (u < 0) {
u = -u;
fenwickTree.update(u, v - w[u]);
} else {
cout << calc_cost(u, v) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
long long w[N], sum[N], a[N], weg[N], pos[N];
long long ck(long long x, long long mod) {
x %= mod;
if (x < 0) x += mod;
return x;
}
struct BIT {
long long sum[N], mod;
void init(long long m) { mod = m; }
BIT() {
for (int i = 0; i < N; i++) sum[i] = 0;
}
void Set(int i, long long f) {
f = ck(f, mod);
for (; i < N; i += i & -i) sum[i] += f, sum[i] = ck(sum[i], mod);
}
long long Get(int i) {
long long ans = 0;
for (; i; i -= i & -i) ans += sum[i], ans = ck(ans, mod);
return ans;
}
long long Get(int l, int r) { return ck(Get(r) - Get(l - 1), mod); }
} WTree, STree;
int main() {
int n, q, l, r, i, j, k;
scanf("%i %i", &n, &q);
WTree.init(3e18);
STree.init(1e9 + 7);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]), a[i] -= i - n;
for (i = 1; i <= n; i++) scanf("%lld", &w[i]), WTree.Set(i, w[i]);
for (i = 1; i <= n; i++) STree.Set(i, a[i] * w[i]);
int mod = 1e9 + 7;
while (q--) {
scanf("%i %i", &l, &r);
if (l < 0) {
l = -l;
WTree.Set(l, r - w[l]);
STree.Set(l, -a[l] * w[l]);
w[l] = r;
STree.Set(l, a[l] * w[l]);
} else {
int top = r, bot = l, mid;
long long all = WTree.Get(l, r);
while (top >= bot) {
mid = top + bot >> 1;
long long lo = WTree.Get(l, mid - 1);
long long hi = WTree.Get(mid + 1, r);
if (lo > all / 2)
top = mid - 1;
else if (hi > all / 2)
bot = mid + 1;
else
break;
}
long long fin = a[mid];
long long lo = STree.Get(l, mid - 1), hi = STree.Get(mid + 1, r);
long long ow = WTree.Get(l, mid - 1) % mod,
up = WTree.Get(mid + 1, r) % mod;
long long ans = (fin * ow % mod - lo + mod) % mod;
ans += (hi - fin * up % mod + mod) % mod;
ans %= mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
int a[200020], w[200020];
const long long mod = 1e9 + 7;
long long sw[200020], s[200020];
void add(int pos, int val) {
int x = a[pos];
for (; pos <= n; pos += pos & -pos) {
sw[pos] += val;
s[pos] = (s[pos] + 1ll * x * val) % mod;
}
}
long long query_sw(int x) {
long long sum = 0;
for (; x; x -= x & -x) sum += sw[x];
return sum;
}
long long query_s(int x) {
long long sum = 0;
for (; x; x -= x & -x) sum = (sum + s[x]) % mod;
return sum;
}
int main() {
cin >> 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++) {
sw[i] = sw[i - 1] + w[i];
s[i] = (s[i - 1] + 1ll * w[i] * a[i]) % mod;
}
for (int i = n; i >= 1; i--) {
sw[i] -= sw[i - (i & -i)];
s[i] = (s[i] - s[i - (i & -i)] + mod) % mod;
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
add(x, y - w[x]);
w[x] = y;
} else {
int l = x - 1, r = y - 1;
long long L = query_sw(x - 1), R = query_sw(y);
while (l < r) {
int m = l + r + 1 >> 1;
long long cur = query_sw(m);
if (2 * cur < L + R)
l = m;
else
r = m - 1;
}
assert(x <= l + 1 && l + 1 <= y);
long long ans = (2 * query_sw(l) - L - R) % mod * a[l + 1] % mod;
ans = (ans + query_s(y) + query_s(x - 1) - 2 * query_s(l)) % mod;
if (ans < 0) ans += mod;
cout << ans << endl;
}
}
}
|
#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 = 8e5 + 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 long long mod = 1LL * 1000 * 1000 * 1000 + 7;
long long ftree_S[200005];
long long ftree_wa[200005];
long long a[200005], w[200005];
void upd(long long *ftree, long long x, long long d) {
for (int i = x; i < 200005; i |= i + 1) ftree[i] = ftree[i] + d;
}
long long normm(long long a) {
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
long long norm(long long a) { return normm((a % mod)); }
long long mul(long long a, long long b) { return ((a * 1ll * b) % mod); }
long long second(long long *ftree, long long x) {
long long res = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1) res += ftree[i];
return res;
}
long long second(long long *ftree, long long l, long long r) {
return second(ftree, r - 1) - second(ftree, l - 1);
}
int n, q;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
cin >> w[i];
upd(ftree_S, i, w[i]);
upd(ftree_wa, i, mul(w[i], a[i]));
}
for (int i = 0; i < q; i++) {
long long x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
upd(ftree_S, x, -w[x]);
upd(ftree_wa, x, -mul(w[x], a[x]));
w[x] = y;
upd(ftree_S, x, w[x]);
upd(ftree_wa, x, mul(w[x], a[x]));
} else {
long long l = x, r = y + 1;
while (r - l > 1) {
long long mid = (r + l) / 2;
if (2 * second(ftree_S, x, mid) > second(ftree_S, x, y + 1))
r = mid;
else
l = mid;
}
long long res = 0;
res = norm(mul(norm(second(ftree_S, x, l)), a[l]) -
norm(second(ftree_wa, x, l)));
res = norm(res + norm(second(ftree_wa, l, y + 1)) -
mul(norm(second(ftree_S, l, y + 1)), a[l]));
cout << res << endl;
}
}
}
|
#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 (register int i = 1; i <= n; i++) read(a[i]), b[i] = a[i] - i;
for (register 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;
int n, q, a[200005], w[200005], t1[200005];
long long t[200005];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = (x + (x << 2) << 1) + (ch ^ 48);
return x * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 ^ 48);
}
void add(int x, int y) {
while (x <= n) t[x] += y, x += x & -x;
}
long long query(int x) {
long long ans = 0;
while (x) ans += t[x], x &= x - 1;
return ans;
}
void Add(int x, int y) {
while (x <= n) t1[x] = (t1[x] + y) % 1000000007, x += x & -x;
}
int Query(int x) {
int ans = 0;
while (x) ans = (ans + t1[x]) % 1000000007, x &= x - 1;
return ans;
}
int main() {
n = read(), q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++)
w[i] = read(), add(i, w[i]),
Add(i, (long long)w[i] * (a[i] - i) % 1000000007);
while (q--) {
int x = read(), y = read();
if (x > 0) {
int l = x, r = y;
long long b = query(l - 1), c = query(r);
while (l < r) {
int mid = l + r >> 1;
long long d = query(mid);
if (d - b < c - d)
l = mid + 1;
else
r = mid;
}
write((((query(l - 1) - b) % 1000000007 * (a[l] - l) - Query(l - 1) +
Query(x - 1) + (c - query(l)) % 1000000007 * (l - a[l]) +
Query(y) - Query(l)) %
1000000007 +
1000000007) %
1000000007),
putchar('\n');
} else
x = -x, add(x, y - w[x]),
Add(x, (long long)(y - w[x]) * (a[x] - x) % 1000000007), w[x] = y;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100, mod = 1000000007;
inline void reduce(int& x) { x += x >> 31 & mod; }
long long sum[N];
int sum2[N];
int n, q, a[N], b[N], mx;
long long qry(int x) {
long long ret = 0;
for (; x; x -= x & -x) ret += sum[x];
return ret;
}
int qry2(int x) {
int ret = 0;
for (; x; x -= x & -x) reduce(ret += sum2[x] - mod);
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (; (1 << mx) <= n; ++mx)
;
--mx;
for (int i = 1; i <= n; ++i) cin >> a[i], a[i] -= i;
for (int i = 1; i <= n; ++i) cin >> b[i];
for (int i = 1; i <= n; ++i) {
sum[i] += b[i];
sum2[i] = (sum2[i] + (long long)a[i] * b[i]) % mod;
if (i + (i & -i) <= n)
sum[i + (i & -i)] += sum[i], reduce(sum2[i + (i & -i)] += sum2[i] - mod);
}
for (; q-- > 0;) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
int delta = (long long)(y - b[x] - mod) * a[x] % mod;
for (int j = x; j <= n; j += j & -j)
sum[j] += y - b[x], reduce(sum2[j] += delta);
b[x] = y;
} else {
long long w = qry(x - 1) + qry(y);
int now = 0;
for (int j = mx; ~j; --j)
if (now + (1 << j) <= n && w >= 2 * sum[now + (1 << j)])
w -= 2 * sum[now += 1 << j];
int ans = (qry2(y) + qry2(x - 1) - 2 * qry2(now) - w * a[now + 1]) % mod;
reduce(ans);
cout << ans << '\n';
}
}
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 X = qry2(1, 1, n, ans, second);
long long Y = qry2(1, 1, n, first, ans);
long long A = qry1(1, 1, n, ans, second);
long long B = qry1(1, 1, n, first, ans);
(X += P) %= P, (Y += P) %= P, (A += P) %= P, (B += P) %= P;
printf(
"%lld\n",
(((X - Y + P) % P - A * a[pos] % P + P) % P + B * a[pos] % P) % P);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
const int INF = (long long)1e9 + 5;
const long long MOD = (long long)1e9 + 7;
int N;
long long pos[MAXN + 5], w[MAXN + 5];
struct Segment_tree {
long long sum0[4 * MAXN + 5], sum1[4 * MAXN + 5], psum[4 * MAXN + 5];
void update(int p, int l, int r, int idx) {
if (l == p && r == p) {
sum0[idx] = w[p];
sum1[idx] = w[p] * p % MOD;
psum[idx] = pos[p] * w[p] % MOD;
return;
}
int m = (l + r) >> 1;
if (p <= m)
update(p, l, m, idx << 1);
else
update(p, m + 1, r, idx << 1 | 1);
sum0[idx] = (sum0[idx << 1] + sum0[idx << 1 | 1]);
sum1[idx] = (sum1[idx << 1] + sum1[idx << 1 | 1]) % MOD;
psum[idx] = (psum[idx << 1] + psum[idx << 1 | 1]) % MOD;
}
long long RSQ(long long *tar, int ql, int qr, int l, int r, int idx,
bool mod) {
if (qr < l || r < ql) return 0;
if (ql <= l && r <= qr) return tar[idx];
int m = (l + r) >> 1;
long long ans = RSQ(tar, ql, qr, l, m, idx << 1, mod) +
RSQ(tar, ql, qr, m + 1, r, idx << 1 | 1, mod);
if (mod) ans %= MOD;
return ans;
}
int search(long long x, int l, int r, int idx) {
if (l == r) return l;
int m = (l + r) >> 1;
if (sum0[idx << 1] > x) return search(x, l, m, idx << 1);
return search(x - sum0[idx << 1], m + 1, r, idx << 1 | 1);
}
} tree;
long long query(int l, int r) {
long long sum = tree.RSQ(tree.sum0, l, r, 0, N, 1, false);
long long pref = tree.RSQ(tree.sum0, 0, l - 1, 0, N, 1, false);
int tar = tree.search(pref + sum / 2, 0, N, 1);
assert(l <= tar && tar <= r);
long long lpsum = tree.RSQ(tree.psum, l, tar, 0, N, 1, 1),
rpsum = tree.RSQ(tree.psum, tar, r, 0, N, 1, 1);
long long lsum0 = tree.RSQ(tree.sum0, l, tar, 0, N, 1, 1),
rsum0 = tree.RSQ(tree.sum0, tar, r, 0, N, 1, 1);
long long lsum1 = tree.RSQ(tree.sum1, l, tar, 0, N, 1, 1),
rsum1 = tree.RSQ(tree.sum1, tar, r, 0, N, 1, 1);
long long lans =
(pos[tar] * lsum0 % MOD - lpsum - tar * lsum0 % MOD + lsum1) % MOD;
long long rans =
(rpsum - pos[tar] * rsum0 % MOD - rsum1 + tar * rsum0 % MOD) % MOD;
return (lans + rans) % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int Q;
cin >> N >> Q;
for (int i = 1; i <= N; i++) {
cin >> pos[i];
}
for (int i = 1; i <= N; i++) {
cin >> w[i];
tree.update(i, 0, N, 1);
}
for (int i = 0; i < Q; i++) {
int a, b;
cin >> a >> b;
if (a < 0) {
w[-a] = b;
tree.update(-a, 0, N, 1);
} else {
cout << (query(a, b) + MOD) % MOD << "\n";
}
}
}
|
#include <bits/stdc++.h>
int inp() {
char c = getchar();
int neg = 1;
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * neg;
}
struct SEG {
int l;
int r;
long long sum;
long long ls;
long long rs;
};
long long s[200010], dis[200010];
SEG operator+(SEG a, SEG b) {
SEG ret;
if (a.l == -1) return b;
if (b.l == -1) return a;
ret.sum = a.sum + b.sum;
a.sum %= 1000000007;
b.sum %= 1000000007;
ret.ls = a.ls + b.ls + b.sum * (dis[a.r] - dis[a.l - 1]);
ret.rs = b.rs + a.rs + a.sum * (dis[b.r + 1] - dis[b.l]);
ret.ls %= 1000000007;
ret.rs %= 1000000007;
ret.l = a.l;
ret.r = b.r;
return ret;
}
struct SEG_Tree {
SEG t[800010];
void push_up(int cur) { t[cur] = t[((cur) << 1)] + t[((cur) << 1 | 1)]; }
void build(int cur, int l, int r) {
t[cur].l = l;
t[cur].r = r;
if (l == r) {
t[cur].sum = s[l];
t[cur].ls = s[l] * (dis[l] - dis[l - 1]);
t[cur].rs = s[l] * (dis[l + 1] - dis[l]);
return;
}
int mid = (l + r) >> 1;
build(((cur) << 1), l, mid);
build(((cur) << 1 | 1), mid + 1, r);
push_up(cur);
}
long long query2(int cur, int l, int r) {
if (t[cur].l > r || t[cur].r < l) return 0;
if (t[cur].l >= l && t[cur].r <= r) return t[cur].sum;
return query2(((cur) << 1), l, r) + query2(((cur) << 1 | 1), l, r);
}
SEG query(int cur, int l, int r) {
if (l > r) return (SEG){0, 0, 0, 0, 0};
if (t[cur].l > r || t[cur].r < l) return (SEG){-1, -1, -1, -1, -1};
if (t[cur].l >= l && t[cur].r <= r) return t[cur];
return query(((cur) << 1), l, r) + query(((cur) << 1 | 1), l, r);
}
void modify(int cur, int x, int c) {
if (t[cur].l == t[cur].r) {
t[cur].sum = c;
t[cur].ls = c * (dis[t[cur].l] - dis[t[cur].l - 1]);
t[cur].rs = c * (dis[t[cur].l + 1] - dis[t[cur].l]);
return;
}
if (x <= t[((cur) << 1)].r)
modify(((cur) << 1), x, c);
else
modify(((cur) << 1 | 1), x, c);
push_up(cur);
}
} t;
int solve(int lb, int rb) {
int l = lb;
int r = rb;
while (l < r) {
int mid = (l + r) >> 1;
if (t.query2(1, lb, mid) >= t.query2(1, mid + 1, rb))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
int n = inp();
int q = inp();
for (int i = 1; i <= n; i++) dis[i] = inp() - i;
for (int i = 1; i <= n; i++) s[i] = inp();
t.build(1, 1, n);
while (q--) {
int id = inp();
int c = inp();
if (id < 0) {
t.modify(1, -id, c);
} else {
int pos = solve(id, c);
long long ans = 0;
if (id <= pos - 1) ans += t.query(1, id, pos - 1).rs;
if (pos + 1 <= c) ans += t.query(1, pos + 1, c).ls;
ans %= 1000000007;
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using int64 = long long;
constexpr int Maxn = 200000;
constexpr int p = 1000000007;
template <class _Tp1, class _Tp2>
inline void inc(_Tp1& x, const _Tp2& y) {
x += y;
(p <= x) && (x -= p);
}
template <class _Tp1, class _Tp2>
inline void dec(_Tp1& x, const _Tp2& y) {
x -= y;
(x < 0) && (x += p);
}
template <class _Tp>
inline int md(const _Tp& v) {
return v < 0 ? ((0 <= p + v) ? (p + v) : (v % p + p)) : (v < p) ? v : (v % p);
}
namespace IOManager {
constexpr int FILESZ(131072);
unsigned char buf[FILESZ];
const unsigned char *ibuf = buf, *tbuf = buf;
struct IOManager {
inline unsigned char gc() {
return (ibuf == tbuf) &&
(tbuf = (ibuf = buf) + fread(buf, 1, FILESZ, stdin),
ibuf == tbuf)
? EOF
: *ibuf++;
}
template <class _Tp>
inline operator _Tp() {
_Tp s = 0u;
unsigned char c = gc(), w = 0;
for (; c < 48; c = gc()) (c == 45) && (w = 1);
for (; c > 47; c = gc()) s = (_Tp)(s * 10u + c - 48u);
return w ? -s : s;
}
};
} // namespace IOManager
IOManager::IOManager io;
const int n = io;
int64 bit[Maxn + 1];
inline void update(const int& x, const int& d) {
for (int i = x; i <= n; i += i & -i) bit[i] += d;
}
inline int64 sum(const int& x) {
int64 s = 0;
for (int i = x; i; i -= i & -i) s += bit[i];
return s;
}
int bitp[Maxn + 1];
inline void updatep(const int& x, const int& d) {
for (int i = x; i <= n; i += i & -i) inc(bitp[i], d);
}
inline int sump(const int& x) {
int64 s = 0;
for (int i = x; i; i -= i & -i) s += bitp[i];
return s % p;
}
int a[Maxn + 1], w[Maxn + 1];
int main() {
int q = io;
for (int i = 1; i <= n; ++i) a[i] = (int)io - i;
for (int i = 1; i <= n; ++i)
w[i] = io, update(i, w[i]), updatep(i, (int64)w[i] * a[i] % p);
int64 sl, sm, sr;
for (int x, y, l, m, r; q; --q)
if (x = io, y = io, x < 0) {
int d = y - w[x = -x];
w[x] = y;
update(x, d);
updatep(x, md((int64)d * a[x]));
} else {
l = x;
r = y;
sl = sum(l - 1);
sr = sum(r) - sl;
for (; l < r;)
((sum(m = (l + r) >> 1) - sl) * 2 < sr) ? (l = m + 1) : (r = m);
sm = sum(m = l);
sr += sl;
printf("%d\n", md((int64)(sump(y) - sump(m) * 2ll +
(int64)(sm - sr + sm - sl) % p * a[m] % p +
sump(x - 1))));
}
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 = 2e5 + 123;
const int M = mod;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, q;
long long a[N], w[N];
long long f_w[N];
long long f_aw[N];
void inc_w(int x, int y) {
for (; x < N; x = (x | (x + 1))) {
f_w[x] += y;
}
}
void inc_aw(int x, long long y) {
if (y < 0) y += mod;
for (; x < N; x = (x | (x + 1))) {
f_aw[x] += y;
if (f_aw[x] >= mod) f_aw[x] -= mod;
}
}
long long get_w(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += f_w[x];
}
return res;
}
int get_aw(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += f_aw[x];
if (res >= M) res -= M;
}
return res;
}
long long get_w(int l, int r) { return get_w(r) - get_w(l - 1); }
int get_aw(int l, int r) {
int res = get_aw(r);
res -= get_aw(l - 1);
if (res < 0) res += M;
return res;
}
int main() {
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
a[i] -= i;
cin >> w[i];
inc_w(i, w[i]);
inc_aw(i, a[i] * w[i] % mod);
}
for (long long i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
inc_w(x, -w[x]);
inc_aw(x, -((a[x] * w[x]) % mod));
w[x] = y;
inc_w(x, w[x]);
inc_aw(x, (a[x] * w[x]) % mod);
} else {
long long sum = get_w(x, y) / 2;
int l = x - 1, r = y - 1, p = x;
while (l <= r) {
int mid = (l + r) / 2;
if (get_w(x, mid) <= sum) {
l = p = mid + 1;
} else {
r = mid - 1;
}
}
long long ans = get_aw(p + 1, y) - get_aw(x, p);
if (ans < 0) ans += mod;
ans += get_w(x, p) % mod * a[p] % mod;
ans %= mod;
ans -= (get_w(p + 1, y) % mod * a[p]) % mod;
if (ans < 0) ans += mod;
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int INF = 1000000001;
int n, q;
long long segSum[800005], segMult[800005], w[200005], a[200005];
void update(long long seg[], int v, int l, int r, int index, long long x);
long long get(long long seg[], int v, int l, int r, int cl, int cr);
pair<int, long long> find(long long seg[], int v, int l, int r, int cl, int cr,
long long s);
long long norm(long long a) {
a %= mod;
if (a > mod) a -= mod;
if (a < 0) a += mod;
return a;
}
long long mult(long long a, long long b) { return norm(norm(a) * norm(b)); }
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] = norm(a[i] - i);
}
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) {
update(segSum, 1, 1, n, i, w[i]);
update(segMult, 1, 1, n, i, mult(w[i], a[i]));
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x *= -1;
w[x] = y;
update(segSum, 1, 1, n, x, w[x]);
update(segMult, 1, 1, n, x, mult(w[x], a[x]));
} else {
long long result = 0;
auto pos = find(segSum, 1, 1, n, x, y, get(segSum, 1, 1, n, x, y) / 2);
assert((pos.first >= x) && (pos.first <= y));
result = norm(mult(a[pos.first], get(segSum, 1, 1, n, x, pos.first)) -
norm(get(segMult, 1, 1, n, x, pos.first)));
result = norm(result + norm(get(segMult, 1, 1, n, pos.first, y)) -
mult(a[pos.first], get(segSum, 1, 1, n, pos.first, y)));
cout << result << "\n";
}
}
cout << "\n"
<< "\n";
return 0;
}
void update(long long seg[], int v, int l, int r, int index, long long x) {
if (l == r) {
seg[v] = x;
return;
}
int mid = (l + r) >> 1;
if (index <= mid)
update(seg, v * 2, l, mid, index, x);
else
update(seg, v * 2 + 1, mid + 1, r, index, x);
seg[v] = seg[v * 2] + seg[v * 2 + 1];
}
long long get(long long seg[], int v, int l, int r, int cl, int cr) {
if ((l == cl) && (r == cr)) return seg[v];
int mid = (l + r) >> 1;
long long result = 0;
if (cl <= mid) result = get(seg, v * 2, l, mid, cl, min(cr, mid));
if (cr > mid) result += get(seg, v * 2 + 1, mid + 1, r, max(cl, mid + 1), cr);
return result;
}
pair<int, long long> find(long long seg[], int v, int l, int r, int cl, int cr,
long long s) {
if ((l == cl) && (r == cr)) {
if (seg[v] <= s) return {INF, seg[v]};
if (l == r) return {l, 0};
}
int mid = (l + r) >> 1;
pair<int, long long> result = {INF, 0};
if (cl <= mid) result = find(seg, v * 2, l, mid, cl, min(mid, cr), s);
if ((cr > mid) && (result.first == INF)) {
auto res = find(seg, v * 2 + 1, mid + 1, r, max(mid + 1, cl), cr,
s - result.second);
result.first = res.first;
result.second += res.second;
}
return result;
}
|
#include <bits/stdc++.h>
int t1, t2, t3, t4;
int n, q;
int q1, q2;
long long pos[262144];
int w[262144];
int seg1[524288];
int seg2[524288];
long long segw[524288];
long long segc1[524288];
long long segc2[524288];
long long getsegw(int u) {
if (u < 0) return 0;
long long out = 0;
u += 262144;
while (u & (u + 1)) {
if (u & 1)
u /= 2;
else {
out += segw[u];
u = u / 2 - 1;
}
}
return out;
}
int best;
long long ans;
void segmove1(int u) {
if (seg2[u] < q1 || best < seg1[u]) return;
if (q1 <= seg1[u] && seg2[u] <= best) {
ans += segc2[u];
ans += (segw[u] % 1000000007) * (pos[best] - pos[seg2[u]]);
ans %= 1000000007;
return;
}
segmove1(u * 2);
segmove1(u * 2 + 1);
}
void segmove2(int u) {
if (seg2[u] < best || q2 < seg1[u]) return;
if (best <= seg1[u] && seg2[u] <= q2) {
ans += segc1[u];
ans += (segw[u] % 1000000007) * (pos[seg1[u]] - pos[best]);
ans %= 1000000007;
return;
}
segmove2(u * 2);
segmove2(u * 2 + 1);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%I64d", pos + i);
pos[i] -= i;
}
for (int i = 0; i < n; i++) {
scanf("%d", w + i);
}
for (int i = 0; i < 262144; i++) {
seg1[i + 262144] = seg2[i + 262144] = i;
}
for (int i = 262144 - 1; i > 0; i--) {
seg1[i] = seg1[i * 2];
seg2[i] = seg2[i * 2 + 1];
}
for (int i = 0; i < n; i++) {
t1 = i + 262144;
t2 = w[i];
do {
segw[t1] += t2;
segc1[t1] += t2 * (pos[i] - pos[seg1[t1]]);
segc1[t1] %= 1000000007;
segc2[t1] += t2 * (pos[seg2[t1]] - pos[i]);
segc2[t1] %= 1000000007;
} while (t1 /= 2);
}
while (q--) {
scanf("%d%d", &q1, &q2);
if (q1 < 0) {
int i = -q1 - 1;
t1 = 262144 + i;
t2 = q2 - w[i];
do {
segw[t1] += t2;
} while (t1 /= 2);
t1 = 262144 + i;
t2 = (q2 + 1000000007 - w[i]) % 1000000007;
do {
segc1[t1] += t2 * (pos[i] - pos[seg1[t1]]);
segc1[t1] %= 1000000007;
segc2[t1] += t2 * (pos[seg2[t1]] - pos[i]);
segc2[t1] %= 1000000007;
} while (t1 /= 2);
w[i] = q2;
} else {
q1--;
q2--;
long long w1 = getsegw(q1 - 1);
long long w2 = getsegw(q2);
long long remain = w2 + w1;
t1 = 1;
while (t1 < 262144) {
if (remain > segw[t1 * 2] * 2) {
remain -= segw[t1 * 2] * 2;
t1 = t1 * 2 + 1;
} else
t1 *= 2;
}
best = t1 - 262144;
ans = 0;
segmove1(1);
segmove2(1);
printf("%I64d\n", (ans % 1000000007 + 1000000007) % 1000000007);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
using namespace std;
const int N = 3e5 + 10;
const int MOD = 1e9 + 7;
int a[N], w[N], n;
struct BIT {
long long bit[N];
int ty;
void add(int x, long long a) {
while (x <= n) {
if (ty == 0)
bit[x] = (bit[x] + a) % MOD;
else
bit[x] = bit[x] + a;
x += x & -x;
}
}
long long sum(int x) {
long long res = 0;
while (x) {
if (ty == 0)
res = (res + bit[x]) % MOD;
else
res = res + bit[x];
x -= x & -x;
}
return res;
}
} b1, b2;
void solve(int x, int y) {
if (x == y) {
printf("0\n");
return;
}
int l = x, r = y, m = l + r >> 1;
long long tot = b1.sum(r) - b1.sum(l - 1);
long long sub = b1.sum(l - 1);
while (l < r) {
if ((b1.sum(m) - sub) * 2 >= tot)
r = m;
else
l = m + 1;
m = l + r >> 1;
}
long long ans = 0, cnt = a[m] - m;
cnt %= MOD;
ans = (ans + cnt * ((b1.sum(m) - b1.sum(x - 1)) % MOD) % MOD -
(b2.sum(m) - b2.sum(x - 1))) %
MOD;
ans = (ans - cnt * ((b1.sum(y) - b1.sum(m)) % MOD) % MOD +
(b2.sum(y) - b2.sum(m))) %
MOD;
ans = (ans + MOD) % MOD;
printf("%lld\n", ans);
}
int main() {
int q, x, y;
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]);
b1.ty = 1;
b2.ty = 0;
for (int i = 1; i <= n; i++) {
b1.add(i, w[i]);
b2.add(i, 1LL * w[i] * (a[i] - i));
}
while (q--) {
scanf("%d %d", &x, &y);
if (x < 0) {
x = -x;
b1.add(x, -w[x]);
b2.add(x, -1LL * w[x] * (a[x] - x));
w[x] = y;
b1.add(x, w[x]);
b2.add(x, 1LL * w[x] * (a[x] - x));
} else
solve(x, y);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(228);
const int N = 2e5 + 7;
const int M = 1e9 + 7;
long long f_w[N];
long long f_aw[N];
void inc_w(int x, int y) {
for (; x < N; x = (x | (x + 1))) {
f_w[x] += y;
}
}
void inc_aw(int x, long long y) {
y %= M;
if (y < 0) y += M;
for (; x < N; x = (x | (x + 1))) {
f_aw[x] += y;
if (f_aw[x] >= M) {
f_aw[x] -= M;
}
}
}
long long get_w(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += f_w[x];
}
return res;
}
int get_aw(int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += f_aw[x];
if (res >= M) res -= M;
}
return res;
}
long long get_w(int l, int r) { return get_w(r) - get_w(l - 1); }
int get_aw(int l, int r) {
int res = get_aw(r);
res -= get_aw(l - 1);
if (res < 0) res += M;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= i;
}
vector<int> w(n);
for (int i = 0; i < n; i++) {
cin >> w[i];
inc_w(i, w[i]);
inc_aw(i, a[i] * (long long)w[i]);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
x--;
inc_w(x, -w[x]);
inc_aw(x, -(a[x] * (long long)w[x]));
w[x] = y;
inc_w(x, w[x]);
inc_aw(x, (a[x] * (long long)w[x]));
} else {
x--, y--;
long long sum = get_w(x, y);
long long need = sum / 2 + get_w(x - 1);
int l = x - 1, r = y;
while (l < r - 1) {
int m = (l + r) / 2;
if (get_w(m) <= need) {
l = m;
} else {
r = m;
}
}
int p = l + 1;
long long ans = -get_aw(x, p) + get_aw(p + 1, y);
if (ans < 0) ans += M;
ans += (get_w(x, p) % M * (long long)a[p]) % M;
if (ans >= M) ans -= M;
ans -= (get_w(p + 1, y) % M * (long long)a[p]) % M;
if (ans < 0) ans += M;
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long mod = (long long)1e9 + 7;
vector<long long> a, w;
vector<long long> segTreeW, segTreeAW;
void build(int id, int l, int r) {
if (l == r) {
segTreeW[id] = w[l];
segTreeAW[id] = w[l] * a[l] % mod;
} else {
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
segTreeW[id] = segTreeW[id * 2] + segTreeW[id * 2 + 1];
segTreeAW[id] = (segTreeAW[id * 2] + segTreeAW[id * 2 + 1]) % mod;
}
}
void build() {
segTreeW.resize(n * 4 + 2517);
segTreeAW.resize(n * 4 + 2517);
build(1, 0, n - 1);
}
long long sumW(int id, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return segTreeW[id];
int mid = (tl + tr) / 2;
return sumW(id * 2, tl, mid, l, min(r, mid)) +
sumW(id * 2 + 1, mid + 1, tr, max(l, mid + 1), r);
}
long long sumW(int l, int r) { return sumW(1, 0, n - 1, l, r); }
long long sumAW(int id, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return segTreeAW[id];
int mid = (tl + tr) / 2;
return (sumAW(id * 2, tl, mid, l, min(r, mid)) +
sumAW(id * 2 + 1, mid + 1, tr, max(l, mid + 1), r)) %
mod;
}
long long sumAW(int l, int r) { return sumAW(1, 0, n - 1, l, r); }
void upd(int id, int tl, int tr, int pos, long long nv) {
if (tl == tr) {
segTreeW[id] = w[pos] = nv;
segTreeAW[id] = w[pos] * a[pos] % mod;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
upd(id * 2, tl, tm, pos, nv);
else
upd(id * 2 + 1, tm + 1, tr, pos, nv);
segTreeW[id] = segTreeW[id * 2] + segTreeW[id * 2 + 1];
segTreeAW[id] = (segTreeAW[id * 2] + segTreeAW[id * 2 + 1]) % mod;
}
}
void upd(int pos, long long nv) { upd(1, 0, n - 1, pos, nv); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int q;
cin >> n >> q;
a.resize(n);
for (int(i) = 0; (i) < (n); (i)++) cin >> a[i], a[i] -= i;
w.resize(n);
for (int(i) = 0; (i) < (n); (i)++) cin >> w[i];
build();
for (int l, r; q-- > 0;) {
cin >> l >> r;
if (l < 0) {
upd(-l - 1, r);
continue;
}
long long sW = sumW(--l, --r);
int lk = l - 1, mk, rk = r;
while (lk + 1 < rk) {
mk = (lk + rk) / 2;
if (sumW(l, mk) * 2 >= sW)
rk = mk;
else
lk = mk;
}
cout << (((sumW(l, rk - 1) % mod * a[rk] % mod + mod - sumAW(l, rk - 1)) %
mod +
(sumAW(rk, r) + mod - sumW(rk, r) % mod * a[rk] % mod) % mod) %
mod)
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
int n, Q;
long long a[N], w[N], Tree[N * 4], sum[N * 4];
void up(int x) {
Tree[x] = Tree[x << 1] + Tree[x << 1 | 1];
sum[x] = (sum[x << 1] + sum[x << 1 | 1]) % 1000000007;
}
void build(int l, int r, int id) {
if (l == r) {
Tree[id] = w[l];
sum[id] = (long long)(a[l] - l) * w[l] % 1000000007;
return;
}
int mid = (l + r) >> 1;
build(l, mid, id << 1);
build(mid + 1, r, id << 1 | 1);
up(id);
}
void change(int l, int r, int id, int x, int y) {
if (l == r) {
Tree[id] = y;
sum[id] = (long long)(a[l] - l) * y % 1000000007;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
change(l, mid, id << 1, x, y);
else
change(mid + 1, r, id << 1 | 1, x, y);
up(id);
}
long long query_sum(int l, int r, int id, int x, int y) {
if (l > y || r < x || Tree[id] == 0) return 0;
if (x <= l && r <= y) return Tree[id];
int mid = (l + r) >> 1;
return query_sum(l, mid, id << 1, x, y) +
query_sum(mid + 1, r, id << 1 | 1, x, y);
}
long long query(int l, int r, int id, int x, int y) {
if (l > y || r < x) return 0;
if (x <= l && r <= y) return sum[id];
int mid = (l + r) >> 1;
return (query(l, mid, id << 1, x, y) + query(mid + 1, r, id << 1 | 1, x, y)) %
1000000007;
}
int erfen(int l, int r) {
int L = l;
long long sum = query_sum(1, n, 1, l, r);
while (l < r) {
int mid = (l + r) >> 1;
if (query_sum(1, n, 1, L, mid) * 2 >= sum)
r = mid;
else
l = mid + 1;
}
return r;
}
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%I64d", &w[i]);
build(1, n, 1);
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
change(1, n, 1, x, y);
} else {
int p = erfen(x, y);
long long cnt1 = query_sum(1, n, 1, x, p) % 1000000007,
cnt2 = query_sum(1, n, 1, p, y) % 1000000007;
long long s1 =
((long long)(a[p] - p) * cnt1 % 1000000007 - query(1, n, 1, x, p)) %
1000000007;
long long s2 =
(query(1, n, 1, p, y) - (long long)(a[p] - p) * cnt2 % 1000000007) %
1000000007;
printf("%I64d\n", ((s1 + s2) % 1000000007 + 1000000007) % 1000000007);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long MAX = 200007;
long long sum(long long a, long long b) {
return a + b >= MOD ? a + b - MOD : a + b;
}
long long sub(long long a, long long b) {
return a - b < 0 ? a - b + MOD : a - b;
}
long long mul(long long a, long long b) { return (a * b) % MOD; }
long long ps[MAX];
long long ar[MAX];
long long tr[4 * MAX];
long long tr2[4 * MAX];
long long tr3[4 * MAX];
void init(long long u, long long l, long long r) {
if (l == r) {
tr[u] = ar[l];
tr2[u] = mul(ar[l], ps[l]);
tr3[u] = mul(ar[l], l);
return;
}
long long mid = (l + r) / 2;
init(u * 2, l, mid);
init(u * 2 + 1, mid + 1, r);
tr[u] = tr[u * 2] + tr[u * 2 + 1];
tr2[u] = sum(tr2[u * 2], tr2[u * 2 + 1]);
tr3[u] = sum(tr3[u * 2], tr3[u * 2 + 1]);
}
void update(long long u, long long l, long long r, long long idx, long long v) {
if (l == r) {
ar[l] = v;
tr[u] = ar[l];
tr2[u] = mul(ar[l], ps[l]);
tr3[u] = mul(ar[l], l);
return;
}
long long mid = (l + r) / 2;
if (idx <= mid)
update(u * 2, l, mid, idx, v);
else
update(u * 2 + 1, mid + 1, r, idx, v);
tr[u] = tr[u * 2] + tr[u * 2 + 1];
tr2[u] = sum(tr2[u * 2], tr2[u * 2 + 1]);
tr3[u] = sum(tr3[u * 2], tr3[u * 2 + 1]);
}
pair<long long, long long> binSearch(long long u, long long l, long long r,
long long x, long long y, long long sm,
long long lft = 0) {
if (r < x || y < l) return pair<long long, long long>(0, 0);
if (x <= l && r <= y) {
if (lft + tr[u] <= sm / 2 || l == r)
return pair<long long, long long>(r, lft + tr[u]);
}
long long mid = (l + r) / 2;
pair<long long, long long> _l = binSearch(u * 2, l, mid, x, y, sm, lft);
if (_l.second <= sm / 2)
return binSearch(u * 2 + 1, mid + 1, r, x, y, sm, _l.second);
else
return _l;
}
long long query(long long u, long long l, long long r, long long x,
long long y) {
if (x > y) return 0;
if (r < x || y < l) return 0;
if (x <= l && r <= y) return tr[u];
long long mid = (l + r) / 2;
return query(u * 2, l, mid, x, y) + query(u * 2 + 1, mid + 1, r, x, y);
}
long long query2(long long u, long long l, long long r, long long x,
long long y) {
if (x > y) return 0;
if (r < x || y < l) return 0;
if (x <= l && r <= y) return tr2[u];
long long mid = (l + r) / 2;
return sum(query2(u * 2, l, mid, x, y), query2(u * 2 + 1, mid + 1, r, x, y));
}
long long query3(long long u, long long l, long long r, long long x,
long long y) {
if (x > y) return 0;
if (r < x || y < l) return 0;
if (x <= l && r <= y) return tr3[u];
long long mid = (l + r) / 2;
return sum(query3(u * 2, l, mid, x, y), query3(u * 2 + 1, mid + 1, r, x, y));
}
long long n;
long long wut(long long l, long long r, long long x) {
long long ans = 0;
long long leftsum = query(1, 1, n, l, x) % MOD;
long long rightsum = query(1, 1, n, x, r) % MOD;
long long leftsum2 = query2(1, 1, n, l, x);
long long rightsum2 = query2(1, 1, n, x, r);
long long leftsum3 = query3(1, 1, n, l, x);
long long rightsum3 = query3(1, 1, n, x, r);
ans = sum(ans, sub(mul(ps[x], leftsum), leftsum2));
ans = sub(ans, sub(mul(x, leftsum), leftsum3));
ans = sum(ans, sub(rightsum2, mul(ps[x], rightsum)));
ans = sub(ans, sub(rightsum3, mul(x, rightsum)));
return ans;
}
long long solve(long long l, long long r) {
if (l == r) return 0;
long long sm = query(1, 1, n, l, r);
long long y = binSearch(1, 1, n, l, r, sm).first;
long long x = y - 1;
long long leftsum = query(1, 1, n, l, x);
long long rightsum = query(1, 1, n, y, r);
if (leftsum <= rightsum) return wut(l, r, y);
return wut(l, r, x);
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
long long q;
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> ps[i];
for (long long i = 1; i <= n; i++) cin >> ar[i];
init(1, 1, n);
while (q--) {
long long a, b;
cin >> a >> b;
if (a < 0)
update(1, 1, n, -a, b);
else
cout << solve(a, b) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
#pragma GCC target("avx,avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
int n;
int q;
vector<long long int> v;
vector<long long int> w;
long long int bit[200012];
void add(int i, long long int x) {
i++;
while (i < 200012) {
bit[i] += x;
i += i & -i;
}
}
long long int sum(int i) {
i++;
long long int r = 0;
while (i) {
r += bit[i];
i -= i & -i;
}
return r;
}
long long int rng(int l, int r) {
long long int sm = sum(r);
if (l) sm -= sum(l - 1);
return sm;
}
long long int pf[200012];
void pf_add(int i, long long int x) {
x %= 1000000007;
x += 1000000007;
x %= 1000000007;
i++;
while (i < 200012) {
pf[i] += x;
if (pf[i] >= 1000000007) pf[i] %= 1000000007;
i += i & -i;
}
}
long long int pf_sum(int i) {
i++;
long long int r = 0;
while (i) {
r += pf[i];
if (r >= 1000000007) r %= 1000000007;
i -= i & -i;
}
return r;
}
long long int sf[200012];
void sf_add(int i, long long int x) {
i++;
x %= 1000000007;
x += 1000000007;
x %= 1000000007;
while (i < 200012) {
sf[i] += x;
if (sf[i] >= 1000000007) sf[i] %= 1000000007;
i += i & -i;
}
}
long long int sf_sum(int i) {
i++;
long long int r = 0;
while (i) {
r += sf[i];
if (r >= 1000000007) r %= 1000000007;
i -= i & -i;
}
return r;
}
int main() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
v.push_back(a);
}
int rngg = n;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
w.push_back(a);
add(i, a);
pf_add(i, -(v[i] + rngg) * a);
sf_add(i, (v[i] - i) * a);
rngg--;
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x *= -1;
x--;
add(x, -w[x]);
pf_add(x, (v[x] + (n - x)) * w[x]);
sf_add(x, -(v[x] - x) * w[x]);
w[x] = y;
add(x, w[x]);
pf_add(x, -(v[x] + (n - x)) * w[x]);
sf_add(x, (v[x] - x) * w[x]);
} else {
int l = x;
int r = y;
l--;
r--;
int mint = l;
int maxt = r;
long long int ALL = (rng(l, r) + 1LL) / 2LL;
while (mint + 1 < maxt) {
int mid = (mint + maxt) / 2;
if (rng(l, mid) >= ALL) {
maxt = mid;
} else {
mint = mid;
}
}
if (rng(l, mint) >= ALL) {
maxt = mint;
} else {
mint = maxt;
}
long long int act = n - mint;
long long int cs1 =
((((sum(mint) - sum(l - 1)) % 1000000007 + 1000000007) % 1000000007) *
(v[mint] + act) % 1000000007) +
((((pf_sum(mint) - pf_sum(l - 1)) % 1000000007) + 1000000007) %
1000000007);
act = mint;
cs1 %= 1000000007;
long long int cs2 =
((sf_sum(r) - sf_sum(mint - 1) % 1000000007 + 1000000007) %
1000000007) -
((((sum(r) - sum(mint - 1)) % 1000000007 + 1000000007) % 1000000007) *
(v[mint] - act) % 1000000007);
cs2 %= 1000000007;
cs1 += cs2;
cs1 %= 1000000007;
cs1 += 1000000007;
cs1 %= 1000000007;
printf("%lld\n", cs1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, X[201000], w[201000], Q;
long long BIT[201000], SS[201000], BIT2[201000], Mod = 1000000007, BIT3[201000];
void Add(int a, long long x) {
while (a <= n) {
BIT[a] += x;
a += (a & -a);
}
}
long long Sum(int a) {
long long r = 0;
while (a) {
r += BIT[a];
a -= (a & -a);
}
return r;
}
void Add2(int a, long long x) {
while (a <= n) {
BIT2[a] = (BIT2[a] + x) % Mod;
a += (a & -a);
}
}
long long Sum2(int a) {
long long r = 0;
while (a) {
r += BIT2[a];
a -= (a & -a);
}
return r % Mod;
}
void Add3(int a, long long x) {
while (a <= n) {
BIT3[a] = (BIT3[a] + x) % Mod;
a += (a & -a);
}
}
long long Sum3(int a) {
long long r = 0;
while (a) {
r += BIT3[a];
a -= (a & -a);
}
return r % Mod;
}
void Go(int b, int e) {
long long G = Sum(e) - Sum(b - 1);
long long BS = Sum(b - 1);
int bb = b - 1, ee = e, mid, r = 0;
while (bb <= ee) {
mid = (bb + ee) >> 1;
if ((Sum(mid) - BS) * 2 <= G)
r = mid, bb = mid + 1;
else
ee = mid - 1;
}
r++;
long long bs = Sum(r) - Sum(b - 1);
long long es = Sum(e) - Sum(r);
long long res = bs % Mod * X[r] - (Sum2(r) - Sum2(b - 1));
res += (Sum2(e) - Sum2(r)) - es % Mod * X[r] % Mod;
res -= bs % Mod * r % Mod - (Sum3(r) - Sum3(b - 1));
res -= (Sum3(e) - Sum3(r)) - es % Mod * r % Mod;
res = (res + Mod * 100) % Mod;
printf("%lld\n", res);
}
int main() {
int i;
scanf("%d%d", &n, &Q);
for (i = 1; i <= n; i++) {
scanf("%d", &X[i]);
SS[i] = SS[i - 1] + X[i];
}
for (i = 1; i <= n; i++) {
scanf("%d", &w[i]);
Add(i, w[i]);
Add2(i, 1ll * w[i] * X[i] % Mod);
Add3(i, 1ll * w[i] * i % Mod);
}
while (Q--) {
int a, b;
scanf("%d%d", &a, &b);
if (a < 0) {
a = -a;
Add(a, b - w[a]);
Add2(a, 1ll * (b - w[a] + Mod) * X[a] % Mod);
Add3(a, 1ll * (b - w[a] + Mod) * a % Mod);
w[a] = b;
continue;
}
Go(a, b);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
long long a[maxn], w[maxn];
long long lowbit(long long x) { return x & -x; }
void add(long long t[], long long x, long long d, int typ) {
for (; x < maxn; x += lowbit(x)) {
t[x] += d;
if (typ) t[x] = (t[x] + mod) % mod;
}
}
long long ask(long long t[], long long x, int typ) {
long long ret = 0;
for (; x; x -= lowbit(x)) {
ret += t[x];
if (typ) ret %= mod;
}
return ret;
}
long long sum[maxn];
long long t[maxn];
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", w + i);
add(t, i, w[i], 0);
add(sum, i, w[i] * a[i] % mod, 1);
}
while (q--) {
long long l, r;
scanf("%lld%lld", &l, &r);
if (l < 0) {
add(t, -l, r - w[-l], 0);
add(sum, -l, a[-l] * (r - w[-l] + mod) % mod, 1);
w[-l] = r;
} else {
long long L = l, R = r;
long long all = ask(t, r, 0) - ask(t, l - 1, 0);
while (L < R) {
long long mid = (L + R) / 2;
if (ask(t, mid, 0) - ask(t, l - 1, 0) > all / 2)
R = mid;
else
L = mid + 1;
}
long long k = R;
long long ans = a[k] * (ask(t, k - 1, 1) - ask(t, l - 1, 1) + mod) % mod;
ans -= (ask(sum, k - 1, 1) - ask(sum, l - 1, 1) + mod) % mod;
ans = (ans + mod) % mod;
(ans += (ask(sum, r, 1) - ask(sum, k, 1) + mod)) %= mod;
ans -= a[k] * (ask(t, r, 1) - ask(t, k, 1) + mod) % mod;
ans = (ans + mod) % mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int maxn = 2e5 + 7;
int n, q, a[maxn], w[maxn];
struct Fenwick1 {
long long bs[maxn];
void add(int x, long long y) {
for (; x <= n; x += x & -x) bs[x] += y;
}
long long sum(int x) {
long long s = 0;
for (; x >= 1; x -= x & -x) s += bs[x];
return s;
}
} B0;
struct Fenwick {
int bs[maxn];
void add(int x, int y) {
for (; x <= n; x += x & -x) (bs[x] += y) %= mod;
}
long long sum(int x) {
int s = 0;
for (; x >= 1; x -= x & -x) (s += bs[x]) %= mod;
return s;
}
} B1;
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)
B0.add(i, w[i]), B1.add(i, w[i] * 1ll * a[i] % mod);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
int dt = y - w[x];
w[x] = y;
B0.add(x, dt);
B1.add(x, dt * 1ll * a[x] % mod);
} else {
long long sl = B0.sum(x - 1), su = B0.sum(y) - sl;
su = (su + 1) / 2;
int l = x, r = y;
while (l < r) {
int m = (l + r) >> 1;
if (B0.sum(m) - sl >= su)
r = m;
else
l = m + 1;
}
int m = l;
long long ans = (B1.sum(y) - B1.sum(m)) -
(B0.sum(y) - B0.sum(m)) % mod * 1ll * (a[m]) % mod -
(B1.sum(m) - B1.sum(x - 1)) +
(B0.sum(m) - B0.sum(x - 1)) % mod * (a[m]) % mod;
ans = (ans % mod + mod) % mod;
printf("%d\n", int(ans));
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int mod = 1000000007;
const double dancila = 3.14159265359;
const double eps = 1e-9;
int n, q;
int a[200002], w[200002];
struct seg {
long long sum, costr, costl;
};
seg aint[800002];
void build(int nod, int st, int dr) {
if (st == dr) {
aint[nod].sum = w[st];
if (st != 1) aint[nod].costr = 1LL * w[st] * (a[st] - a[st - 1] - 1);
if (st != n) aint[nod].costl = 1LL * w[st] * (a[dr + 1] - a[dr] - 1);
aint[nod].costr %= mod;
aint[nod].costl %= mod;
return;
}
int mid = (st + dr) / 2;
build(nod << 1, st, mid);
build(nod << 1 | 1, mid + 1, dr);
aint[nod].sum = aint[nod << 1].sum + aint[nod << 1 | 1].sum;
int lenB = dr - mid;
int lenA = mid - st + 1;
if (st != 1) {
aint[nod].costr = aint[nod << 1].costr + aint[nod << 1 | 1].costr;
aint[nod].costr += 1LL * (aint[nod << 1 | 1].sum % mod) *
((a[mid] + 1) - (a[st - 1] + lenA) - 1);
}
if (dr != n) {
aint[nod].costl = aint[nod << 1].costl + aint[nod << 1 | 1].costl;
aint[nod].costl += 1LL * (aint[nod << 1].sum % mod) *
((a[dr + 1] - lenB) - (a[mid + 1] - 1) - 1);
}
aint[nod].costr %= mod;
aint[nod].costl %= mod;
}
void update(int nod, int st, int dr, int poz, int val) {
if (st == dr) {
w[st] = val;
aint[nod].sum = w[st];
if (st != 1) aint[nod].costr = 1LL * w[st] * (a[st] - a[st - 1] - 1);
if (dr != n) aint[nod].costl = 1LL * w[st] * (a[dr + 1] - a[dr] - 1);
aint[nod].sum %= mod;
aint[nod].costr %= mod;
aint[nod].costl %= mod;
return;
}
int mid = (st + dr) / 2;
if (poz <= mid)
update(nod << 1, st, mid, poz, val);
else
update(nod << 1 | 1, mid + 1, dr, poz, val);
aint[nod].sum = aint[nod << 1].sum + aint[nod << 1 | 1].sum;
int lenB = dr - mid;
int lenA = mid - st + 1;
if (st != 1) {
aint[nod].costr = aint[nod << 1].costr + aint[nod << 1 | 1].costr;
aint[nod].costr += 1LL * (aint[nod << 1 | 1].sum % mod) *
((a[mid] + 1) - (a[st - 1] + lenA) - 1);
}
if (dr != n) {
aint[nod].costl = aint[nod << 1].costl + aint[nod << 1 | 1].costl;
aint[nod].costl += 1LL * (aint[nod << 1].sum % mod) *
((a[dr + 1] - lenB) - (a[mid + 1] - 1) - 1);
}
aint[nod].costr %= mod;
aint[nod].costl %= mod;
}
long long query2(int nod, int st, int dr, int L, int R) {
if (dr < L || st > R) return 0;
if (L <= st && dr <= R) return aint[nod].sum;
int mid = (st + dr) / 2;
return query2(nod << 1, st, mid, L, R) +
query2(nod << 1 | 1, mid + 1, dr, L, R);
}
seg query(int nod, int st, int dr, int L, int R) {
if (L <= st && dr <= R) return aint[nod];
int mid = (st + dr) / 2;
seg ans = {0, 0, 0};
if (mid >= L) {
seg ans2 = query(nod << 1, st, mid, L, R);
ans = ans2;
}
int lenA = mid - max(st, L) + 1;
int lenB = min(dr, R) - mid;
if (mid < R && mid >= L) {
seg ans2 = query(nod << 1 | 1, mid + 1, dr, L, R);
ans.costr += ans2.costr;
ans.costr +=
(ans2.sum % mod) * ((a[mid] + 1) - (a[max(L - 1, st - 1)] + lenA) - 1);
ans.costl += ans2.costl;
ans.costl +=
(ans.sum % mod) * ((a[min(R, dr) + 1] - lenB) - (a[mid + 1] - 1) - 1);
ans.costl %= mod;
ans.costr %= mod;
ans.sum += ans2.sum;
} else if (mid < R) {
seg ans2 = query(nod << 1 | 1, mid + 1, dr, L, R);
ans = ans2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> w[i];
build(1, 1, n);
for (; q; --q) {
int poz;
cin >> poz;
if (poz < 0) {
poz = -poz;
int val;
cin >> val;
update(1, 1, n, poz, val);
} else {
int xd;
cin >> xd;
long long x = query2(1, 1, n, poz, xd);
int st = poz;
int dr = xd;
int ans = -1;
while (st <= dr) {
int mid = (st + dr) / 2;
long long y = query2(1, 1, n, poz, mid);
if (y * 2 >= x)
ans = mid, dr = mid - 1;
else
st = mid + 1;
}
seg y = {0, 0, 0};
seg z = {0, 0, 0};
if (ans > poz) y = query(1, 1, n, poz, ans - 1);
if (ans < xd) z = query(1, 1, n, ans + 1, xd);
cout << (y.costl + z.costr) % mod << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
void add(int& x, int y) {
x += y;
if (x >= mod) {
x -= mod;
}
}
void sub(int& x, int y) {
x -= y;
if (x < 0) {
x += mod;
}
}
int mul(int x, int y) { return (long long)x * y % mod; }
int n, q, a[N], value[N];
long long sum[N << 2];
void build(int l, int r, int o) {
if (l == r) {
sum[o] = value[l];
} else {
int mid = l + r >> 1;
build(l, mid, (o << 1));
build(mid + 1, r, (o << 1 | 1));
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
}
void modify(int l, int r, int o, int p) {
if (l == r) {
sum[o] = value[l];
} else {
int mid = l + r >> 1;
if (p <= mid) {
modify(l, mid, (o << 1), p);
} else {
modify(mid + 1, r, (o << 1 | 1), p);
}
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
}
long long query(int l, int r, int o, int ql, int qr) {
if (ql <= l && r <= qr) {
return sum[o];
} else {
int mid = l + r >> 1;
long long result = 0;
if (ql <= mid) {
result += query(l, mid, (o << 1), ql, qr);
}
if (qr > mid) {
result += query(mid + 1, r, (o << 1 | 1), ql, qr);
}
return result;
}
}
int query(int l, int r, int o, long long x) {
if (l == r) {
return l;
} else {
int mid = l + r >> 1;
if (sum[(o << 1)] > x) {
return query(l, mid, (o << 1), x);
} else {
return query(mid + 1, r, (o << 1 | 1), x - sum[(o << 1)]);
}
}
}
struct state {
int a, b, c;
state() {}
state(int a, int b, int c) : a(a), b(b), c(c) {}
state operator+(const state& other) const {
state result = *this;
add(result.a, other.a);
add(result.b, other.b);
add(result.c, other.c);
return result;
}
state operator-(const state& other) const {
state result = *this;
sub(result.a, other.a);
sub(result.b, other.b);
sub(result.c, other.c);
return result;
}
} c[N];
void modify(int p, state x) {
for (; p <= n; p += p & -p) {
c[p] = c[p] + x;
}
}
state query(int p) {
state result(0, 0, 0);
for (; p; p -= p & -p) {
result = result + c[p];
}
return result;
}
state query(int l, int r) { return query(r) - query(l - 1); }
int main() {
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", &value[i]);
modify(i, state(value[i], mul(value[i], i), mul(value[i], a[i])));
}
build(1, n, 1);
for (int i = 1; i <= q; ++i) {
int p, x;
scanf("%d%d", &p, &x);
if (p < 0) {
p = -p;
modify(p, state((mod - value[p]) % mod, (mod - mul(value[p], p)) % mod,
(mod - mul(value[p], a[p])) % mod));
value[p] = x;
modify(p, state(value[p], mul(value[p], p), mul(value[p], a[p])));
modify(1, n, 1, p);
} else {
long long sumv = query(1, n, 1, p, x) >> 1;
if (p ^ 1) {
sumv += query(1, n, 1, 1, p - 1);
}
int static_pos = query(1, n, 1, sumv), ans = 0;
if (p ^ static_pos) {
int l = p, r = static_pos - 1;
state result = query(l, r);
add(ans,
((result.b + (long long)result.a * (a[static_pos] - static_pos) -
result.c) %
mod +
mod) %
mod);
}
if (x ^ static_pos) {
int l = static_pos + 1, r = x;
state result = query(l, r);
add(ans,
((result.c - (long long)result.a * (a[static_pos] - static_pos) -
result.b) %
mod +
mod) %
mod);
}
printf("%d\n", ans);
}
}
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() {
n = read();
q = read();
for (int i = 1; i <= n; ++i) a[i] = read(), a[i] -= i;
;
for (int i = 1; i <= n; ++i) w[i] = read();
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;
void add(long long &a, long long b) {
a += b;
if (a > 1000000007) a -= 1000000007;
}
int N, Q, a[200200];
long long w[200200];
struct modtree {
long long t[200200];
void u(int i, long long v) {
i++;
v %= 1000000007;
for (; i <= N; i += (i & -i)) add(t[i], v);
}
long long gtv(int i) {
i++;
long long res = 0;
for (; i > 0; i -= (i & -i)) add(res, t[i]);
return res;
}
long long q(int l, int r) {
return (gtv(r) - gtv(l - 1) + 1000000007) % 1000000007;
}
} awt, wit;
struct tree {
long long t[200200];
void u(int i, long long v) {
i++;
for (; i <= N; i += (i & -i)) t[i] += v;
}
long long gtv(int i) {
i++;
long long res = 0;
for (; i > 0; i -= (i & -i)) res += t[i];
return res;
}
long long q(int l, int r) { return gtv(r) - gtv(l - 1); }
} wt;
long long dif(int l, int r, int s) {
if (l > r) return 0ll;
long long wi_tot = wit.q(l, r);
long long wt_tot = wt.q(l, r) % 1000000007;
wi_tot = (wi_tot + wt_tot * s) % 1000000007;
long long aw_tot = awt.q(l, r);
return (wi_tot - aw_tot + 1000000007) % 1000000007;
}
long long delta(int l, int r, int s) {
int lo = l, hi = r, split = l - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] <= s + mid)
lo = mid + 1, split = mid;
else
hi = mid - 1;
}
long long d = 0;
if (l <= split) d += wt.q(l, split);
if (split + 1 <= r) d -= wt.q(split + 1, r);
return d;
}
long long dis(int l, int r, int s) {
int lo = l, hi = r, split = l - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] <= s + mid)
lo = mid + 1, split = mid;
else
hi = mid - 1;
}
long long lft = dif(l, split, s);
long long rgt = dif(split + 1, r, s);
return (lft - rgt + 1000000007) % 1000000007;
}
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("%lld", &w[i]);
wt.u(i, w[i]);
awt.u(i, w[i] * a[i] % 1000000007);
wit.u(i, w[i] * i % 1000000007);
}
for (int i = (0); i < (Q); i++) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x = -x - 1;
wt.u(x, y - w[x]);
long long dif = ((long long)y - w[x] + 1000000007) % 1000000007;
w[x] = (long long)y;
awt.u(x, dif * a[x] % 1000000007);
wit.u(x, dif * x % 1000000007);
} else {
x--, y--;
int lo = 1, hi = (int)1e9, ans = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
long long res = delta(x, y, mid);
if (res >= 0) {
hi = mid - 1;
ans = mid;
} else
lo = mid + 1;
}
long long u = dis(x, y, ans);
printf("%lld\n", u);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const long long mod = 1000000007;
class BIT {
public:
vector<long long> bit;
int size_ = 0;
long long MD;
void init(int sz) {
size_ = sz + 2;
bit.resize(size_ + 2, 0);
}
void add(int pos, long long x) {
pos++;
x %= MD;
while (pos <= size_) {
bit[pos] += x;
bit[pos] %= MD;
pos += (pos & -pos);
}
}
long long sum(int pos) {
long long x = 0;
pos++;
while (pos >= 1) {
x += bit[pos];
x %= MD;
pos -= (pos & -pos);
}
return x % MD;
}
};
long long N, Q, A[1 << 18], W[1 << 18];
BIT Z1, Z2;
int main() {
scanf("%lld%lld", &N, &Q);
Z1.init(N + 2);
Z2.init(N + 2);
Z1.MD = (1LL << 60);
Z2.MD = mod;
for (int i = 1; i <= N; i++) {
scanf("%lld", &A[i]);
A[i] -= i;
}
for (int i = 1; i <= N; i++) scanf("%lld", &W[i]);
for (int i = 1; i <= N; i++) {
Z1.add(i, W[i]);
Z2.add(i, A[i] * W[i] % mod);
}
for (int i = 1; i <= Q; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
if (a < 0) {
a *= -1;
Z1.add(a, 1LL * b - W[a]);
Z2.add(a, 1LL * A[a] * (b - W[a]));
W[a] = b;
} else {
int l = a, r = b;
int cl = a, cr = b + 1, mid, minx = b;
for (int t = 1; t <= 30; t++) {
mid = (cl + cr) / 2;
long long V1 = (Z1.sum(mid) - Z1.sum(a - 1));
long long V2 = (Z1.sum(b) - Z1.sum(mid));
if (V1 < V2) {
cl = mid;
} else {
cr = mid;
minx = min(minx, mid);
}
}
mid = minx;
long long wl = (Z1.sum(mid) - Z1.sum(l - 1)) % mod,
wr = (Z1.sum(r) - Z1.sum(mid)) % mod;
long long xl = (Z2.sum(mid) - Z2.sum(l - 1)) % mod,
xr = (Z2.sum(r) - Z2.sum(mid)) % mod;
long long al = 1LL * A[mid] * wl - xl, ar = xr - 1LL * A[mid] * wr;
al += mod * mod;
al %= mod;
ar += mod * mod;
ar %= mod;
printf("%lld\n", (al + ar) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 2e5 + 10;
long long a[MAXN], w[MAXN], conv[MAXN];
struct BIT {
long long b[MAXN];
bool mod;
void upd(int p, long long v) {
for (; p < MAXN; p += (p & -p)) {
b[p] += v;
if (mod) b[p] %= MOD;
}
}
long long sum(int p) {
long long res = 0;
for (; p; p -= (p & -p)) {
res += b[p];
if (res >= MOD && mod) res -= MOD;
}
return res;
}
long long sum(int l, int r) {
if (l > r) return 0;
return sum(r) - sum(l - 1);
}
};
BIT wBIT, convBIT, progBIT;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
convBIT.mod = true;
progBIT.mod = true;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
cin >> w[i];
wBIT.upd(i, w[i]);
progBIT.upd(i, (long long)i * w[i]);
convBIT.upd(i, w[i] * a[i]);
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x *= -1;
long long d = (long long)y - w[x];
wBIT.upd(x, d);
progBIT.upd(x, d * x);
convBIT.upd(x, d * a[x]);
w[x] = y;
} else {
if (x == y) {
cout << "0\n";
continue;
}
int lo = x, hi = y;
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
if (wBIT.sum(mi + 1, y) >= wBIT.sum(x, mi))
lo = mi;
else
hi = mi - 1;
}
lo++;
if (wBIT.sum(x + 1, y) < w[x]) lo = x;
long long ans = 0;
ans += convBIT.sum(lo + 1, y);
ans -= progBIT.sum(lo + 1, y);
ans += (long long)(lo - a[lo]) * (wBIT.sum(lo + 1, y) % MOD);
ans %= MOD;
ans -= convBIT.sum(x, lo - 1);
ans += progBIT.sum(x, lo - 1);
ans += (long long)(a[lo] - lo) * (wBIT.sum(x, lo - 1) % MOD);
ans %= MOD;
cout << (ans + MOD) % MOD << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long dr[800000];
long long pr[800000];
long long sf[800000];
long long w[800000];
long long a[800000];
void bl(long long v, long long l, long long r) {
if (r == l + 1) {
dr[v] = w[l];
pr[v] = 0;
sf[v] = 0;
return;
}
bl(2 * v + 1, l, (l + r) / 2);
bl(2 * v + 2, (l + r) / 2, r);
dr[v] = dr[2 * v + 1] + dr[2 * v + 2];
pr[v] = pr[2 * v + 1] + pr[2 * v + 2] +
(a[r - 1] - (r - (l + r) / 2) - a[(r + l) / 2 - 1]) *
(dr[2 * v + 1] % MOD);
sf[v] = sf[2 * v + 1] + sf[2 * v + 2] +
(a[(r + l) / 2] - a[l] - ((r + l) / 2 - l)) * (dr[2 * v + 2] % MOD);
sf[v] %= MOD;
pr[v] %= MOD;
}
void ch(long long v, long long l, long long r, long long id, long long x) {
if (r == l + 1 && l == id) {
dr[v] = x;
pr[v] = 0;
sf[v] = 0;
return;
}
if (r <= id || l > id) {
return;
}
ch(2 * v + 1, l, (l + r) / 2, id, x);
ch(2 * v + 2, (l + r) / 2, r, id, x);
dr[v] = dr[2 * v + 1] + dr[2 * v + 2];
pr[v] = pr[2 * v + 1] + pr[2 * v + 2] +
(a[r - 1] - (r - (l + r) / 2) - a[(r + l) / 2 - 1]) *
(dr[2 * v + 1] % MOD);
sf[v] = sf[2 * v + 1] + sf[2 * v + 2] +
(a[(r + l) / 2] - a[l] - ((r + l) / 2 - l)) * (dr[2 * v + 2] % MOD);
sf[v] %= MOD;
pr[v] %= MOD;
}
long long sm(long long v, long long l, long long r, long long ln,
long long rn) {
if (ln >= r || rn <= l) {
return 0;
}
if (ln <= l && r <= rn) {
return dr[v];
}
return sm(2 * v + 1, l, (l + r) / 2, ln, rn) +
sm(2 * v + 2, (l + r) / 2, r, ln, rn);
}
pair<long long, long long> indd(long long v, long long l, long long r,
long long k, long long ln, long long rn) {
if (ln >= r || rn <= l) {
return {0, -1};
}
if (l == r - 1) {
return {dr[v], l};
}
if (ln <= l && r <= rn) {
if (dr[v] < k) return {dr[v], r};
}
pair<long long, long long> cr =
indd(2 * v + 1, l, (l + r) / 2, k, ln, min(rn, (l + r) / 2));
if (cr.first < k) {
pair<long long, long long> cr2 =
indd(2 * v + 2, (l + r) / 2, r, k - cr.first, max(ln, (l + r) / 2), rn);
return {cr2.first + cr.first, cr2.second};
} else {
return cr;
}
}
long long prr(long long v, long long l, long long r, long long ln,
long long k) {
if (ln >= r || k <= l) {
return 0;
}
if (ln <= l && r <= k) {
return (pr[v] + (a[k - 1] - (k - r) - a[r - 1]) * (dr[v] % MOD)) % MOD;
}
return (prr(2 * v + 1, l, (l + r) / 2, ln, k) +
prr(2 * v + 2, (l + r) / 2, r, ln, k)) %
MOD;
}
long long sff(long long v, long long l, long long r, long long k,
long long rn) {
if (k >= r || rn <= l) {
return 0;
}
if (k <= l && r <= rn) {
return (sf[v] + (a[l] - a[k] - (l - k)) * (dr[v] % MOD)) % MOD;
}
return (sff(2 * v + 1, l, (l + r) / 2, k, rn) +
sff(2 * v + 2, (l + r) / 2, r, k, rn)) %
MOD;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> w[i];
}
bl(0, 0, n);
for (int i = 0; i < q; i++) {
long long x, y;
cin >> x >> y;
if (x < 0) {
ch(0, 0, n, -x - 1, y);
} else {
x--;
long long aaa = (sm(0, 0, n, x, y) + 1) / 2;
long long L = indd(0, 0, n, aaa, x, y).second;
cout << (prr(0, 0, n, x, L + 1) + sff(0, 0, n, L, y)) % MOD << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e5, M = 1e9 + 7;
int n, q, x, y;
long long a[mxN], w[mxN], ft[mxN + 1][2];
void upd(int i, long long x, int j) {
for (++i; i <= n; i += i & -i) {
ft[i][j] += x;
if (j) ft[i][j] %= M;
}
}
long long qry(int i, int j) {
long long r = 0;
for (; i; i -= i & -i) {
r += ft[i][j];
if (j) r %= M;
}
return r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
cin >> w[i];
upd(i, w[i], 0);
upd(i, (a[i] - i) * w[i], 1);
}
while (q--) {
cin >> x >> y;
if (x < 0) {
x = -x - 1;
upd(x, y - w[x], 0);
upd(x, (a[x] - x) * (y - w[x]), 1);
w[x] = y;
} else {
--x;
--y;
long long s1 = qry(x, 0), s2 = qry(y + 1, 0), lb = 0, c = 0;
for (int i = 17; i >= 0; --i) {
if ((lb + (1 << i)) < n && 2 * (c + ft[lb + (1 << i)][0]) < s2 + s1) {
lb += 1 << i;
c += ft[lb][0];
}
}
cout << ((qry(y + 1, 1) - 2 * qry(lb, 1) + qry(x, 1)) % M -
(qry(y + 1, 0) - 2 * qry(lb, 0) + qry(x, 0)) % M * (a[lb] - lb) %
M +
2 * M) %
M
<< "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
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 segment_change {
int new_w;
int a;
segment_change(int _new_w = 0, int _a = 0) : new_w(_new_w), a(_a) {}
};
struct segment {
long long w_sum;
int aw_sum;
segment() : w_sum(0), aw_sum(0) {}
void apply(int start, int end, const segment_change &change) {
assert(end - start == 1);
w_sum = change.new_w;
aw_sum = (long long)change.a * change.new_w % MOD;
}
void join(const segment &other) {
w_sum += other.w_sum;
mod_add(aw_sum, other.aw_sum);
}
void join(const segment &a, const segment &b) {
*this = a;
join(b);
}
};
struct seg_tree {
int tree_n;
vector<segment> tree;
seg_tree(int n = 0) {
tree_n = 0;
if (n > 0) init(n);
}
void init(int n) {
tree_n = 1;
while (tree_n < n) tree_n *= 2;
tree.assign(2 * tree_n, segment());
}
void build(const vector<segment_change> &initial) {
int n = initial.size();
assert(n <= tree_n);
for (int i = 0; i < n; i++) tree[tree_n + i].apply(i, i + 1, initial[i]);
for (int position = tree_n - 1; position > 0; position--)
tree[position].join(tree[2 * position], tree[2 * position + 1]);
}
template <typename T_range_op, typename T_join_op>
void process_range(int position, int start, int end, int a, int b,
T_range_op &&range_op, T_join_op &&join_op) {
if (a <= start && end <= b) {
range_op(position, start, end);
return;
}
if (position >= tree_n) return;
int mid = (start + end) / 2;
if (a < mid)
process_range(2 * position, start, mid, a, b, range_op, join_op);
if (b > mid)
process_range(2 * position + 1, mid, end, a, b, range_op, join_op);
join_op(position);
}
segment query(int a, int b) {
segment answer;
process_range(
1, 0, tree_n, a, b,
[&](int position, int, int) { answer.join(tree[position]); },
[&](int) {});
return answer;
}
void update(int a, int b, const segment_change &change) {
process_range(
1, 0, tree_n, a, b,
[&](int position, int start, int end) {
tree[position].apply(start, end, change);
},
[&](int position) {
tree[position].join(tree[2 * position], tree[2 * position + 1]);
});
}
int lower_bound(long long w_sum) {
int position = 1;
while (position < tree_n)
if (w_sum <= tree[2 * position].w_sum) {
position = 2 * position;
} else {
w_sum -= tree[2 * position].w_sum;
position = 2 * position + 1;
}
return position - tree_n + 1;
}
};
int N, Q;
vector<int> A, W;
seg_tree tree;
int solve(int start, int end) {
long long total_w = tree.query(start, end).w_sum;
long long start_w = tree.query(0, start).w_sum;
int goal = tree.lower_bound((total_w + 1) / 2 + start_w) - 1;
assert(start <= goal && goal < end);
segment left = tree.query(start, goal);
segment right = tree.query(goal, end);
long long result = (left.w_sum - right.w_sum) % MOD * (long long)A[goal] +
right.aw_sum - left.aw_sum;
return (result % MOD + MOD) % MOD;
}
int main() {
scanf("%d %d", &N, &Q);
A.resize(N);
W.resize(N);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
A[i] -= i;
}
vector<segment_change> initial(N);
for (int i = 0; i < N; i++) {
scanf("%d", &W[i]);
initial[i] = segment_change(W[i], A[i]);
}
tree.init(N);
tree.build(initial);
for (int q = 0; q < Q; q++) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x = -x - 1;
tree.update(x, x + 1, segment_change(y, A[x]));
} else {
printf("%d\n", solve(x - 1, y));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
class SegmentTree {
private:
vector<T> tree;
vector<T> data;
int N;
inline T OP(T x, T y) { return x + y; }
T count_sum(int tv, int tl, int tr, int l, int r) {
if (tl >= tr) return T();
l = max(l, tl);
r = min(r, tr);
if (l >= r) return T();
if (l == tl && r == tr) return tree[tv];
int tm = (tl + tr) / 2;
return OP(count_sum(2 * tv, tl, tm, l, r),
count_sum(2 * tv + 1, tm, tr, l, r));
}
void update_value(int tv, int tl, int tr, int idx, T new_val) {
if (tl >= tr) return;
if (tl == idx && tr == idx + 1) {
tree[tv] = new_val;
return;
}
int tm = (tl + tr) / 2;
if (idx < tm)
update_value(2 * tv, tl, tm, idx, new_val);
else
update_value(2 * tv + 1, tm, tr, idx, new_val);
tree[tv] = OP(tree[2 * tv], tree[2 * tv + 1]);
}
T build(int tv, int tl, int tr) {
if (tl >= tr) return T();
if (tl + 1 == tr) return tree[tv] = data[tl];
int tm = (tl + tr) / 2;
return tree[tv] = OP(build(2 * tv, tl, tm), build(2 * tv + 1, tm, tr));
}
public:
SegmentTree() : SegmentTree(vector<T>()) {}
SegmentTree(int n) : SegmentTree(vector<T>(n)) {}
SegmentTree(vector<T> data_) {
data = data_;
N = data.size();
tree = vector<T>(4 * N);
if (N > 0) build(1, 0, N);
}
void set(int idx, T new_value) {
data[idx] = new_value;
int tv = 1, tl = 0, tr = N;
while (tl != tr - 1) {
int tm = (tl + tr) / 2;
tv *= 2;
if (idx < tm)
tr = tm;
else {
tv++;
tl = tm;
}
}
tree[tv] = new_value;
tv /= 2;
while (tv != 0) {
tree[tv] = tree[2 * tv] + tree[2 * tv + 1];
tv /= 2;
}
}
T get(int idx) { return data[idx]; }
T sum(int l, int r) { return count_sum(1, 0, N, max(0, l), min(N, r)); }
};
vector<int64_t> a, b;
SegmentTree<int64_t> w, wb;
int64_t find_ans(int l, int r) {
int zl = l, zr = r, zm;
while (zl + 1 != zr) {
int zm = (zl + zr) / 2;
int64_t SL = w.sum(l, zm);
int64_t SR = w.sum(zm, r);
if (SL - SR <= 0)
zl = zm;
else
zr = zm;
}
int z = zl;
int64_t s1 = (b[z] * (w.sum(l, z) - w.sum(z, r))) % 1000000007;
int64_t s2 = (wb.sum(l, z) - wb.sum(z, r)) % 1000000007;
return ((s1 - s2) % 1000000007 + 1000000007) % 1000000007;
}
vector<int64_t> read_vector(int n) {
vector<int64_t> ans(n);
for (int i = 0; i < n; i++) cin >> ans[i];
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
a = read_vector(n);
w = SegmentTree<int64_t>(read_vector(n));
b = vector<int64_t>(n);
wb = SegmentTree<int64_t>(n);
for (int i = 0; i < n; i++) {
b[i] = a[i] - i;
wb.set(i, (w.get(i) * b[i]) % 1000000007);
}
for (int i = 0; i < q; i++) {
int64_t x, y;
cin >> x >> y;
if (x < 0) {
int idx = (-x) - 1;
w.set(idx, y);
wb.set(idx, (y * b[idx]) % 1000000007);
} else {
cout << find_ans(x - 1, y) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 2e5 + 5;
int pos[MAX], w[MAX], wa_bit[MAX];
long long w_bit[MAX];
int n, q;
inline int add(int a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
return a;
}
inline int sub(int a, int b) {
a -= b;
if (0 > a) {
a += MOD;
}
return a;
}
inline int mult(int a, int b) { return (1LL * a * b) % MOD; }
void update(int idx, int val, int bit[]) {
while (idx < MAX) {
bit[idx] = add(bit[idx], val);
idx += idx & -idx;
}
}
int query(int idx, int bit[]) {
int total = 0;
while (idx) {
total = add(total, bit[idx]);
idx -= idx & -idx;
}
return total;
}
int query(int left, int right, int bit[]) {
if (left > right) {
return 0;
}
return sub(query(right, bit), query(left - 1, bit));
}
void ll_update(int idx, long long val, long long bit[]) {
while (idx < MAX) {
bit[idx] += val;
idx += idx & -idx;
}
}
long long ll_query(int idx, long long bit[]) {
long long total = 0;
while (idx) {
total += bit[idx];
idx -= idx & -idx;
}
return total;
}
long long ll_query(int left, int right, long long bit[]) {
if (left > right) {
return 0;
}
return ll_query(right, bit) - ll_query(left - 1, bit);
}
int main() {
scanf("%d %d", &n, &q);
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", pos + i);
pos[i] -= i;
}
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", w + i);
ll_update(i, w[i], w_bit);
update(i, mult(w[i], pos[i]), wa_bit);
}
for (int t = int(0); t < int(q); t++) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
int id = -x;
int nw = y;
ll_update(id, -w[id], w_bit);
update(id, (-mult(w[id], pos[id])) + MOD, wa_bit);
w[id] = nw;
ll_update(id, w[id], w_bit);
update(id, mult(w[id], pos[id]), wa_bit);
} else {
int l = x;
int r = y;
int left = l, right = r;
int k = -1;
long long total_sum = ll_query(l, r, w_bit);
while (left <= right) {
int mid = (left + right) / 2;
long long cur_sum = ll_query(l, mid, w_bit);
if (2 * cur_sum >= total_sum) {
k = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
int ans = mult(ll_query(l, k - 1, w_bit) % MOD, pos[k]);
ans = sub(ans, query(l, k - 1, wa_bit));
ans = add(ans, query(k + 1, r, wa_bit));
ans = sub(ans, mult(ll_query(k + 1, r, w_bit) % MOD, pos[k]));
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
T s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = (s << 3) + (s << 1) + ch - 48;
ch = getchar();
}
return s * f;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 2e5 + 100;
const int mod = 1e9 + 7;
long long w[N], a[N];
struct Segment {
static const int MAX = 2e5 + 100;
long long sum[MAX << 2];
void pushup(int node, int l, int r) {
sum[node] = sum[node << 1] + sum[node << 1 | 1];
}
void build(int node, int l, int r) {
if (l == r) {
sum[node] = w[l];
return;
}
int mid = l + r >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
pushup(node, l, r);
}
void change(int node, int l, int r, int idx, int val) {
if (l == r) {
sum[node] = val;
return;
}
int mid = l + r >> 1;
if (idx <= mid)
change(node << 1, l, mid, idx, val);
else
change(node << 1 | 1, mid + 1, r, idx, val);
pushup(node, l, r);
}
int queryid(int node, int l, int r, int L, int R, long long val) {
if (l == r) return l;
int mid = l + r >> 1;
if (R <= mid)
return queryid(node << 1, l, mid, L, R, val);
else if (L > mid)
return queryid(node << 1 | 1, mid + 1, r, L, R, val);
else {
long long lsum = querysum(node << 1, l, mid, L, mid);
if (lsum >= val)
return queryid(node << 1, l, mid, L, mid, val);
else
return queryid(node << 1 | 1, mid + 1, r, mid + 1, R, val - lsum);
}
}
long long querysum(int node, int l, int r, int L, int R) {
if (L <= l && R >= r) {
return sum[node];
}
int mid = l + r >> 1;
long long val = 0;
if (L <= mid) val += querysum(node << 1, l, mid, L, R);
if (R > mid) val += querysum(node << 1 | 1, mid + 1, r, L, R);
return val;
}
} treeans;
struct SegmentTree {
static const int MAX = 2e5 + 100;
long long sum[MAX << 2];
void pushup(int node, int l, int r) {
sum[node] = sum[node << 1] + sum[node << 1 | 1] % mod;
}
void build(int node, int l, int r) {
if (l == r) {
sum[node] = w[l] * (a[l] - l) % mod;
return;
}
int mid = l + r >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
pushup(node, l, r);
}
void change(int node, int l, int r, int idx, long long val) {
if (l == r) {
sum[node] = val * (a[l] - l) % mod;
return;
}
int mid = l + r >> 1;
if (idx <= mid)
change(node << 1, l, mid, idx, val);
else
change(node << 1 | 1, mid + 1, r, idx, val);
pushup(node, l, r);
}
long long querysum(int node, int l, int r, int L, int R) {
if (L <= l && R >= r) {
return sum[node] % mod;
}
int mid = l + r >> 1;
long long val = 0;
if (L <= mid) val += querysum(node << 1, l, mid, L, R), val %= mod;
if (R > mid) val += querysum(node << 1 | 1, mid + 1, r, L, R), val %= mod;
return val % mod;
}
} tree;
int main() {
int n = read<int>(), m = read<int>();
for (int i = 1; i <= n; ++i) {
a[i] = read<long long>();
}
for (int i = 1; i <= n; ++i) {
w[i] = read<long long>();
}
tree.build(1, 1, n);
treeans.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
long long l = read<long long>(), r = read<long long>();
if (l < 0) {
l = -l;
tree.change(1, 1, n, l, r);
treeans.change(1, 1, n, l, r);
w[l] = r;
} else {
long long k = treeans.querysum(1, 1, n, l, r);
if (k & 1) {
k = (k + 1) / 2;
long long id = treeans.queryid(1, 1, n, l, r, k);
unsigned long long ans = 0;
ans = ((1LL * ((a[id] - id) % mod) *
(treeans.querysum(1, 1, n, l, id) % mod)) %
mod -
1LL * tree.querysum(1, 1, n, l, id) % mod + mod) %
mod;
ans = (ans + 1LL * tree.querysum(1, 1, n, id, r) % mod -
1LL *
((a[id] - id) % mod *
(treeans.querysum(1, 1, n, id, r) % mod)) %
mod +
mod) %
mod;
printf("%lld\n", (long long)ans % mod);
} else {
k /= 2;
int idone = treeans.queryid(1, 1, n, l, r, k);
int idtwo = treeans.queryid(1, 1, n, l, r, k + 1);
long long valmidlf = (a[idone] + a[idtwo]) / 2;
long long valmidrt = valmidlf;
if (idone != idtwo) valmidrt += 1;
unsigned long long ans = 0;
ans = (1LL * (valmidlf - idone) % mod *
(treeans.querysum(1, 1, n, l, idone) % mod) % mod -
1LL * tree.querysum(1, 1, n, l, idone) % mod + mod) %
mod;
ans = (ans + 1LL * tree.querysum(1, 1, n, idtwo, r) % mod -
1LL * (valmidrt - idtwo) % mod *
(treeans.querysum(1, 1, n, idtwo, r) % mod) % mod +
mod) %
mod;
printf("%lld\n", (long long)ans % mod);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - 48;
ch = getchar();
}
return x * f;
}
template <typename T>
inline bool Max(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool Min(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 2e5 + 7, mod = 1e9 + 7;
int n, q;
LL w[N], p[N];
void add(LL &a, LL b) {
a += b;
if (a >= mod) a -= mod;
}
LL s[N << 2];
void modify(int p, int l, int r, int o, LL v) {
s[o] += v;
if (l == r) return;
int mid = l + r >> 1;
if (p <= mid)
modify(p, l, mid, o << 1, v);
else
modify(p, mid + 1, r, o << 1 | 1, v);
}
int query(int l, int r, int o, LL sum) {
if (l == r) return l;
int mid = l + r >> 1;
if (s[o << 1] >= sum) return query(l, mid, o << 1, sum);
return query(mid + 1, r, o << 1 | 1, sum - s[o << 1]);
}
LL querys(int L, int R, int l, int r, int o) {
if (L > R) return 0;
if (L <= l && r <= R) return s[o];
int mid = l + r >> 1;
if (R <= mid) return querys(L, R, l, mid, o << 1);
if (L > mid) return querys(L, R, mid + 1, r, o << 1 | 1);
return querys(L, R, l, mid, o << 1) + querys(L, R, mid + 1, r, o << 1 | 1);
}
struct BIT {
LL tr[N];
int lowbit(int x) { return x & -x; }
void modify(int x, LL y) {
for (int i = x; i <= n; i += lowbit(i)) add(tr[i], y);
}
LL query(int x) {
LL res = 0ll;
for (int i = x; i; i -= lowbit(i)) add(res, tr[i]);
return res;
}
LL q(int l, int r) { return query(r) - query(l - 1); }
} t[2];
int main() {
n = gi(), q = gi();
for (int i = 1; i <= n; ++i) p[i] = gi();
for (int i = 1; i <= n; ++i) w[i] = gi() % mod;
for (int i = 1; i <= n; ++i) {
t[0].modify(i, p[i] * w[i] % mod);
t[1].modify(i, i * w[i] % mod);
modify(i, 1, n, 1, w[i]);
}
while (q--) {
int x = gi(), y = gi();
if (x < 0) {
x = -x;
LL tt = y - w[x];
modify(x, 1, n, 1, tt);
t[0].modify(x, p[x] * tt % mod);
t[1].modify(x, x * tt % mod);
w[x] = y;
} else {
LL ans = 0;
int l = x, r = y;
int pos =
query(1, n, 1, querys(1, y, 1, n, 1) - (querys(x, y, 1, n, 1) / 2));
add(ans, ((-t[0].q(l, pos) +
querys(l, pos, 1, n, 1) % mod * (p[pos] - pos) % mod +
t[1].q(l, pos)) %
mod +
mod) %
mod);
add(ans, ((t[0].q(pos + 1, r) -
querys(pos + 1, r, 1, n, 1) % mod * (p[pos] - pos) % mod -
t[1].q(pos + 1, r)) %
mod +
mod) %
mod);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
int n, q;
long long a[N], w[N], c[N << 1][2];
inline void add(int x, long long v, int id) {
if (!id)
for (; x <= n; x += x & -x) c[x][id] += v;
else
for (; x <= n; x += x & -x) c[x][id] = (c[x][id] + v + mod) % mod;
}
inline long long ask(int x, int id) {
long long ret = 0;
if (!id)
for (; x; x -= x & -x) ret += c[x][id];
else
for (; x; x -= x & -x) ret = (ret + c[x][id] + mod) % mod;
return ret;
}
inline long long gets(int x, int y, int id) {
if (!id)
return y >= x ? ask(y, id) - ask(x - 1, id) : 0;
else
return (ask(y, id) - ask(x - 1, id) + mod) % mod;
}
inline int bsearch(int x, int y) {
int l = x, r = y, mid;
while (l < r) {
mid = (l + r) / 2;
if (gets(x, mid, 0) >= gets(mid + 1, y, 0))
r = mid;
else
l = mid + 1;
}
return r;
}
int main() {
scanf("%d%d", &n, &q);
for (register int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (register int i = 1; i <= n; i++)
scanf("%lld", &w[i]), add(i, w[i], 0), add(i, w[i] * (a[i] - i), 1);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
add(x, -w[x], 0);
add(x, -w[x] * (a[x] - x), 1);
w[x] = y;
add(x, w[x], 0);
add(x, w[x] * (a[x] - x), 1);
} else {
if (x == y) {
puts("0");
continue;
}
long long pos = bsearch(x, y), ans = 0;
ans = (ans + (gets(x, pos, 0) % mod) * (int)abs(a[pos] - pos) % mod -
gets(x, pos, 1) + mod) %
mod;
ans = (ans - (gets(pos, y, 0) % mod) * (int)abs(a[pos] - pos) % mod +
gets(pos, y, 1) + mod) %
mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 7;
const long long ABS = 1e9 + 7;
struct Fenv {
vector<long long> T;
void init(int n) { T.resize(n); }
void add(int i, long long v, bool f) {
for (; i < T.size(); i = (i | (i + 1)))
if (f)
T[i] = (T[i] + v) % ABS;
else
T[i] = T[i] + v;
}
long long sum(int r) {
long long res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res = res + T[r];
return res;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
long long fi(int i) { return sum(i, i); }
};
long long posn(long long x) {
if (x >= ABS) x -= ABS;
if (x < 0) x += ABS;
return x;
}
int main() {
int n, q;
cin >> n >> q;
Fenv Fwa, S;
vector<long long> a(n), w(n);
Fwa.init(n), S.init(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= i;
}
for (int i = 0; i < n; i++) {
cin >> w[i];
S.add(i, w[i], 0);
Fwa.add(i, w[i] * a[i], 1);
}
for (; q > 0; --q) {
int l, r;
cin >> l >> r;
if (l < 0) {
l *= -1;
l--;
long long cw = S.fi(l);
S.add(l, r - cw, 0);
cw = Fwa.fi(l);
Fwa.add(l, r * a[l] - cw, 1);
} else {
l--, r--;
if (l == r) {
cout << 0 << endl;
continue;
}
long long SM = S.sum(l, r);
int L = l, R = r + 1;
while (L + 1 < R) {
int m = (L + R) / 2;
if (2 * S.sum(l, m) > SM)
R = m;
else
L = m;
}
int k;
if (2 * S.sum(l, L) < SM)
k = R;
else
k = L;
long long ans = 0;
ans = posn(a[k] * S.sum(l, k) - Fwa.sum(l, k));
ans = posn(ans + Fwa.sum(k, r) - a[k] * S.sum(k, r));
ans = posn(ans % ABS);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& prnt(ostream& out, T v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
return prnt(out, v);
}
template <class T>
ostream& operator<<(ostream& out, set<T> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, map<T1, T2> v) {
return prnt(out, v);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ' ' << p.second << ')';
}
const long long N = 200100;
const long long MARGIN = 1e9;
const long long MOD = 1e9 + 7;
long long n, k, m, a[N], w[N], x, y;
struct first {
long long val[4 * N];
first() { memset(val, 0, sizeof val); };
void upd(long long nod, long long l, long long r, long long pos,
long long value) {
if (l == r) {
val[nod] = value % MOD;
return;
}
long long mid = (l + r) / 2, ans = 0;
if (pos <= mid)
upd(2 * nod, l, mid, pos, value);
else
upd(2 * nod + 1, mid + 1, r, pos, value);
val[nod] = val[2 * nod] + val[2 * nod + 1];
if (val[nod] >= MOD) val[nod] -= MOD;
}
long long que(long long nod, long long l, long long r, long long x,
long long y) {
if (x <= l && r <= y) return val[nod];
long long mid = (l + r) / 2, ans = 0;
if (x <= mid) ans += que(2 * nod, l, mid, x, y), ans %= MOD;
if (y > mid) ans += que(2 * nod + 1, mid + 1, r, x, y), ans %= MOD;
return ans;
}
void update(long long pos, long long val) { upd(1, 1, n, pos, val); }
long long query(long long x, long long y) {
if (x > y) return 0;
return que(1, 1, n, x, y);
}
} stl, str;
long long aib[N];
long long lsb(long long x) { return x & (-x); }
long long que(long long pos) {
long long ret = 0;
for (; pos; pos -= lsb(pos)) ret += aib[pos];
return ret;
}
long long query(long long l, long long r) { return que(r) - que(l - 1); }
void update(long long pos, long long val) {
long long prev = query(pos, pos);
val = val - prev;
for (; pos < N; pos += lsb(pos)) aib[pos] += val;
}
long long vv(long long mid, long long l, long long r) {
return query(l, mid - 1) - query(mid, r);
}
long long cb(long long l, long long r, long long x, long long y) {
if (l == r) return l;
long long mid = (l + r + 1) / 2;
if (vv(mid, x, y) <= 0) return cb(mid, r, x, y);
return cb(l, mid - 1, x, y);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
cin >> w[i];
stl.update(i, (w[i] * (a[i] - i)) % MOD);
str.update(i, (w[i] * ((long long)MARGIN - n + i - a[i])) % MOD);
update(i, w[i]);
}
for (long long i = 1; i <= m; i++) {
cin >> x >> y;
if (x < 0) {
x = -x;
stl.update(x, (y * (a[x] - x)) % MOD);
str.update(x, (y * ((long long)MARGIN - n + x - a[x])) % MOD);
update(x, y);
} else {
long long l = x, r = y;
long long fix = cb(l, r, l, r);
long long ans = 0;
ans +=
(str.query(l, fix) -
(((query(l, fix) % MOD) * ((long long)MARGIN - n + fix - a[fix])) %
MOD)) %
MOD;
ans += (stl.query(fix + 1, r) -
(((query(fix + 1, r) % MOD) * (a[fix] + 1 - fix - 1)) % MOD)) %
MOD;
cout << (ans % MOD + MOD) % MOD << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
string print_iterable(T1 begin_iter, T2 end_iter, int counter) {
bool done_something = false;
stringstream res;
res << "[";
for (; begin_iter != end_iter and counter; ++begin_iter) {
done_something = true;
counter--;
res << *begin_iter << ", ";
}
string str = res.str();
if (done_something) {
str.pop_back();
str.pop_back();
}
str += "]";
return str;
}
vector<int> SortIndex(int size, std::function<bool(int, int)> compare) {
vector<int> ord(size);
for (int i = 0; i < size; i++) ord[i] = i;
sort(ord.begin(), ord.end(), compare);
return ord;
}
template <typename T>
bool MinPlace(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename Container>
int SZ(const Container& S) {
return S.size();
}
template <typename S, typename T>
ostream& operator<<(ostream& out, const pair<S, T>& p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
out << "[";
for (int i = 0; i < (int)v.size(); i++) {
out << v[i];
if (i != (int)v.size() - 1) out << ", ";
}
out << "]";
return out;
}
using namespace std;
template <typename Value>
class Fenwick {
public:
Fenwick(int N) : size(N), max_pow2(log2(N)), container(N, 0) {}
Fenwick(const vector<Value>& initial_values)
: Fenwick(initial_values.size()) {
for (int p = 0; p < size; p++) {
int q = p | (p + 1);
container[p] += initial_values[p];
if (q < size) container[q] += container[p];
}
}
void Add(int p, Value x) {
for (; p < size; p |= (p + 1)) container[p] += x;
}
Value GetRange(int l, int r) {
if (l > 0) return GetRange(0, r) - GetRange(0, l - 1);
Value res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res += container[r];
return res;
}
private:
int size;
int max_pow2;
vector<Value> container;
};
const long long mod = 1e9 + 7;
template <typename Value>
class FenwickMod {
public:
FenwickMod(int N) : size(N), max_pow2(log2(N)), container(N, 0) {}
FenwickMod(const vector<Value>& initial_values)
: FenwickMod(initial_values.size()) {
for (int p = 0; p < size; p++) {
int q = p | (p + 1);
container[p] += initial_values[p];
container[p] %= mod;
if (q < size) {
container[q] += container[p];
container[q] %= mod;
}
}
}
void Add(int p, Value x) {
for (; p < size; p |= (p + 1)) {
container[p] += x;
container[p] %= mod;
}
}
Value GetRange(int l, int r) {
if (l > 0) return (GetRange(0, r) - GetRange(0, l - 1)) % mod;
Value res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res += container[r];
res %= mod;
return res;
}
private:
int size;
int max_pow2;
vector<Value> container;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, Q;
cin >> N >> Q;
vector<long long> A(N + 10, 0), W(N + 10, 0), AW(N + 10, 0);
for (int i = 1; i <= N; i++) cin >> A[i], A[i] -= i;
for (int i = 1; i <= N; i++) cin >> W[i];
for (int i = 1; i <= N; i++) AW[i] = A[i] * W[i] % mod;
Fenwick<long long> fenw(W);
FenwickMod<long long> fenaw(AW);
for (int q = 0; q < Q; q++) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
fenw.Add(x, y - W[x]);
fenaw.Add(x, (A[x] * y - A[x] * W[x]) % mod);
W[x] = y;
} else {
int l = x, r = y;
while (l < r) {
int m = (l + r) / 2;
if (fenw.GetRange(x, m) < fenw.GetRange(m + 1, y))
l = m + 1;
else
r = m;
}
int m = l;
l = x, r = y;
long long res1 = A[m] * (fenw.GetRange(l, m) % mod) % mod;
long long res2 = fenaw.GetRange(l, m);
long long res3 = A[m] * (fenw.GetRange(m, r) % mod) % mod;
long long res4 = fenaw.GetRange(m, r);
long long res = res1 - res2 - res3 + res4;
res %= mod;
if (res < 0) res += mod;
cout << res << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const double eps = 1e-10;
const double pi = acos(-1.0);
inline int read() {
int x = 0, f = 1;
char ch;
ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch & 15);
ch = getchar();
}
if (f)
return x;
else
return -x;
}
const int N = 2e5 + 10;
const long long mod = 1e9 + 7;
int n, q, w[N], a[N], x, y;
struct BIT1 {
long long sum[N];
void add(int i, long long c) {
for (; i <= n; i += (i & (-i))) sum[i] = sum[i] + c;
}
long long query(int i) {
long long ret = 0;
for (; i >= 1; i -= (i & (-i))) ret = ret + sum[i];
return ret;
}
} bit1;
struct BIT2 {
long long sum[N];
void add(int i, long long c) {
for (; i <= n; i += (i & (-i))) sum[i] = ((sum[i] + c) % mod + mod) % mod;
}
long long query(int i) {
long long ret = 0;
for (; i >= 1; i -= (i & (-i))) ret = (ret + sum[i]) % mod;
return ret;
}
} bit2;
void update(int i, int c) {
int ls = c - w[i];
bit1.add(i, 1ll * ls);
bit2.add(i, 1ll * ls * a[i] % mod);
w[i] = c;
}
int query(int L, int R) {
long long ls = bit1.query(x - 1);
ls = ((bit1.query(y) - ls + 1) >> 1) + ls;
int l = L, r = R;
while (l < r) {
int mid = (l + r) >> 1;
if (bit1.query(mid) >= ls)
r = mid;
else
l = mid + 1;
}
return (int)(((bit2.query(R) + bit2.query(L - 1) - bit2.query(l) -
bit2.query(l) + 2 * mod) %
mod +
(bit1.query(l) + bit1.query(l) - bit1.query(L - 1) -
bit1.query(R) + 2 * mod) %
mod * a[l] % mod) %
mod);
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read() - i;
for (int i = 1; i <= n; i++) w[i] = read();
for (int i = 1; i <= n; ++i)
bit1.add(i, 1ll * w[i]), bit2.add(i, 1ll * w[i] * a[i] % mod);
while (q--) {
x = read();
y = read();
if (x < 0)
update(-x, y);
else
printf("%d\n", query(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1000000007, N = 200005;
int n, m;
int a[N], w[N], caw[4 * N], Ans;
long long cw[4 * N], Sum;
long long queryw(int p, int l, int r, int x, int y) {
if (x > y) return 0;
if (l == x && r == y) return cw[p];
int mid = (l + r) >> 1, ll = p << 1;
if (y <= mid)
return queryw(ll, l, mid, x, y);
else if (x >= mid + 1)
return queryw(ll | 1, mid + 1, r, x, y);
else
return queryw(ll, l, mid, x, mid) + queryw(ll | 1, mid + 1, r, mid + 1, y);
}
int queryaw(int p, int l, int r, int x, int y) {
if (x > y) return 0;
if (l == x && r == y) return caw[p];
int mid = (l + r) >> 1, ll = p << 1;
if (y <= mid)
return queryaw(ll, l, mid, x, y);
else if (x >= mid + 1)
return queryaw(ll | 1, mid + 1, r, x, y);
else
return (queryaw(ll, l, mid, x, mid) +
queryaw(ll | 1, mid + 1, r, mid + 1, y)) %
P;
}
void build(int p, int l, int r) {
if (l == r) {
caw[p] = 1ll * (a[l] + P - l) * w[l] % P;
cw[p] = w[l];
return;
}
int mid = (l + r) >> 1, ll = p << 1;
build(ll, l, mid);
build(ll | 1, mid + 1, r);
cw[p] = cw[ll] + cw[ll | 1];
caw[p] = (caw[ll] + caw[ll | 1]) % P;
}
void change(int p, int l, int r, int x) {
if (l == r) {
caw[p] = 1ll * (a[l] + P - l) * w[l] % P;
cw[p] = w[l];
return;
}
int mid = (l + r) >> 1, ll = p << 1;
if (x <= mid)
change(ll, l, mid, x);
else
change(ll | 1, mid + 1, r, x);
cw[p] = cw[ll] + cw[ll | 1];
caw[p] = (caw[ll] + caw[ll | 1]) % P;
}
int findKth(int p, int l, int r) {
if (l == r) return l;
int mid = (l + r) >> 1, ll = p << 1;
if (cw[ll] >= Sum - cw[ll])
return findKth(ll, l, mid);
else {
Sum -= 2 * cw[ll];
return findKth(ll | 1, mid + 1, r);
}
}
int find(int p, int l, int r, int x, int y) {
if (l == x && r == y) {
if (cw[p] >= Sum - cw[p])
return findKth(p, l, r);
else {
Sum -= 2 * cw[p];
return -1;
}
}
int mid = (l + r) >> 1, ll = p << 1;
if (y <= mid)
return find(ll, l, mid, x, y);
else if (x >= mid + 1)
return find(ll | 1, mid + 1, r, x, y);
else {
int tmp = find(ll, l, mid, x, mid);
if (tmp != -1) return tmp;
return find(ll | 1, mid + 1, r, mid + 1, y);
}
}
void upd(int &x, long long y) { x = (x + y) % P; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
w[-x] = y;
change(1, 1, n, -x);
} else {
Sum = queryw(1, 1, n, x, y);
int K = find(1, 1, n, x, y);
Ans = 0;
upd(Ans, 1ll * (a[K] + P - K) * (queryw(1, 1, n, x, K) % P));
upd(Ans, P - queryaw(1, 1, n, x, K));
upd(Ans, 1ll * (K + P - a[K]) * (queryw(1, 1, n, K + 1, y) % P));
upd(Ans, queryaw(1, 1, n, K + 1, y));
printf("%d\n", Ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void getre() {
int x = 0;
printf("%d\n", 1 / x);
}
void gettle() {
int res = 1;
while (1) res <<= 1;
printf("%d\n", res);
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
template <typename N>
inline int sgn(N a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
inline void gn(double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gs(char *s) { scanf("%s", s); }
inline void gc(char &c) {
while ((c = getchar()) > 126 || c < 33)
;
}
inline void pc(char c) { putchar(c); }
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double pi = 3.14159265358979323846264338327950288L;
const double eps = 1e-6;
const int mo = 1e9 + 7;
int n, q;
long long bit[222222];
int bit2[222222];
long long bitque(int x) {
long long su = 0;
for (; x; x -= x & -x) su += bit[x];
return su;
}
int bit2que(int x) {
int su = 0;
for (; x; x -= x & -x)
(((su) = ((su) + (bit2[x])) % mo) < 0 ? (su) += mo : (su));
return su;
}
void bitupd(int x, long long del) {
for (; x <= n; x += x & -x) bit[x] += del;
}
void bit2upd(int x, int del) {
for (; x <= n; x += x & -x)
(((bit2[x]) = ((bit2[x]) + (del)) % mo) < 0 ? (bit2[x]) += mo : (bit2[x]));
}
int a[222222], w[222222];
int main() {
gn(n);
gn(q);
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
gn(a[i]);
a[i] += n - i;
}
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
gn(w[i]);
bitupd(i, w[i]);
bit2upd(i, 1ll * a[i] * w[i] % mo);
}
while (q--) {
int x, y;
gn(x);
gn(y);
if (x < 0) {
x = -x;
int del = y - w[x];
w[x] = y;
bitupd(x, del);
bit2upd(x, 1ll * a[x] * del % mo);
} else {
long long fa = bitque(y);
long long left = bitque(x - 1);
long long su = fa - left;
long long th = (su + 1) / 2;
long long want = th + left;
int l = x, r = y;
while (l <= r) {
int mid = l + r >> 1;
long long has = bitque(mid);
if (has >= want)
r = mid - 1;
else
l = mid + 1;
}
int rigsum = ((bit2que(y) - bit2que(l - 1)) -
1ll * (bitque(y) - bitque(l - 1)) % mo * a[l]) %
mo;
int lefsum = (-(bit2que(l - 1) - bit2que(x - 1)) +
1ll * (bitque(l - 1) - bitque(x - 1)) % mo * a[l]) %
mo;
int ret = ((0ll + rigsum + lefsum) % mo + mo) % mo;
printf("%d\n", ret);
}
}
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 double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
int n, q;
long long a[200015], w[200015];
long long c1[200015], c2[200015];
inline int lb(int x) { return x & -x; }
void add1(int p, long long x) {
for (; p <= n; p += lb(p)) c1[p] += x;
}
long long query1(int p) {
long long res = 0;
for (; p; p -= lb(p)) res += c1[p];
return res;
}
void add2(int p, long long x) {
for (; p <= n; p += lb(p)) {
c2[p] += x;
if (c2[p] >= MOD) c2[p] -= MOD;
}
}
long long query2(int p) {
long long res = 0;
for (; p; p -= lb(p)) res += c2[p];
return res % MOD;
}
int get_p(int l, int r) {
long long r1 = query1(l - 1);
long long r2 = query1(r) - r1;
int mi, res = l;
while (l <= r) {
mi = l + r >> 1;
if ((query1(mi) - r1) * 2 >= r2) {
r = (res = mi) - 1;
} else {
l = mi + 1;
}
}
return res;
}
long long cal(int l, int r, int p) {
long long res1 =
query2(r) - query2(p - 1) - (query1(r) - query1(p - 1)) % MOD * a[p];
long long res2 =
(query1(p) - query1(l - 1)) % MOD * a[p] - (query2(p) - query2(l - 1));
return ((res1 + res2) % MOD + MOD) % MOD;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
a[i] -= i;
}
for (int i = 1; i <= n; ++i) {
scanf("%lld", &w[i]);
}
for (int i = 1; i <= n; ++i) {
add1(i, w[i]);
add2(i, w[i] * a[i] % MOD);
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0) {
add1(-l, r - w[-l]);
add2(-l, (r - w[-l]) * a[-l] % MOD);
w[-l] = r;
} else {
int p = get_p(l, r);
printf("%lld\n", cal(l, r, p));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int a[400020], w[400020];
int tot, ls[400020], rs[400020];
long long sumw[400020], sum[400020];
int n, q, rt;
inline void update(int x) {
sum[x] = (sum[ls[x]] + sum[rs[x]]) % mod;
sumw[x] = sumw[ls[x]] + sumw[rs[x]];
}
void build(int &x, int l, int r) {
x = ++tot;
if (l == r) {
sumw[x] = w[l], sum[x] = (long long)a[l] * w[l] % mod;
return;
}
int mid = (l + r) >> 1;
build(ls[x], l, mid), build(rs[x], mid + 1, r);
update(x);
}
void modify(int x, int l, int r, int id, int d) {
if (l == r) {
sumw[x] = d, sum[x] = (long long)a[l] * d % mod;
return;
}
int mid = (l + r) >> 1;
if (id <= mid)
modify(ls[x], l, mid, id, d);
else
modify(rs[x], mid + 1, r, id, d);
update(x);
}
long long queryw(int x, int l, int r, int L, int R) {
if (L <= l && R >= r) return sumw[x];
int mid = (l + r) >> 1;
long long res = 0;
if (L <= mid) res = queryw(ls[x], l, mid, L, R);
if (R > mid) res += queryw(rs[x], mid + 1, r, L, R);
return res;
}
long long querys(int x, int l, int r, int L, int R) {
if (L <= l && R >= r) return sum[x];
int mid = (l + r) >> 1;
long long res = 0;
if (L <= mid) res = querys(ls[x], l, mid, L, R);
if (R > mid) res += querys(rs[x], mid + 1, r, L, R);
return res % mod;
}
int queryid(int x, int l, int r, int L, int R, long long &D) {
if (l == r) {
D -= sumw[x];
return D <= 0 ? l : 0;
}
int mid = (l + r) >> 1, res = 0;
if (L <= l && R >= r) {
if (D > sumw[x]) {
D -= sumw[x];
return 0;
}
if (D <= sumw[ls[x]]) return queryid(ls[x], l, mid, L, R, D);
D -= sumw[ls[x]];
return queryid(rs[x], mid + 1, r, L, R, D);
}
if (L <= mid) res = queryid(ls[x], l, mid, L, R, D);
if (res || R <= mid) return res;
return queryid(rs[x], mid + 1, r, L, R, D);
}
int main() {
scanf("%d %d", &n, &q);
for (register int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] = a[i] - i;
for (register int i = 1; i <= n; i++) scanf("%d", &w[i]);
build(rt, 1, n);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
modify(rt, 1, n, -x, y);
} else {
long long sumw = queryw(rt, 1, n, x, y), tmp = (sumw + 1) / 2;
int id = queryid(rt, 1, n, x, y, tmp);
long long w1 = queryw(rt, 1, n, x, id), w2 = sumw - w1;
long long ans = (((long long)a[id] * w1 - querys(rt, 1, n, x, id) +
querys(rt, 1, n, id + 1, y) - (long long)a[id] * w2) %
mod +
mod) %
mod;
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, P = 1000000007;
using ll = long long;
int n, q, a[N];
ll w[N];
struct BIT {
ll c[N];
bool mod;
inline static int lowbit(int x) { return x & -x; }
void add(int x, ll val) {
while (x <= n) {
c[x] += val;
if (mod) c[x] %= P;
x += lowbit(x);
}
}
ll query(int x) {
ll ret = 0;
while (x) ret += c[x], x -= lowbit(x);
return mod ? ret % P : ret;
}
inline ll query(int x, int y) { return query(y) - query(x - 1); }
} ta, tb;
int getpos(int l, int r) {
int ans = l, lp = l;
ll t = ta.query(l, r);
while (l <= r) {
int mid = (l + r) >> 1;
if (ta.query(lp, mid) > t / 2)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> w[i];
ta.mod = 0;
tb.mod = 1;
for (int i = 1; i <= n; i++) {
a[i] -= i;
ta.add(i, w[i]);
tb.add(i, a[i] * w[i] % P);
}
for (int _ = 0; _ < q; _++) {
int t1, t2;
cin >> t1 >> t2;
if (t1 < 0) {
t1 = -t1;
ta.add(t1, -w[t1]);
tb.add(t1, a[t1] * -w[t1] % P);
ta.add(t1, w[t1] = t2);
tb.add(t1, a[t1] * w[t1] % P);
} else {
int k = getpos(t1, t2);
ll ans = (ta.query(t1, k) % P * a[k] % P - tb.query(t1, k)) % P +
(tb.query(k, t2) - ta.query(k, t2) % P * a[k] % P) % P;
ans = (ans % P + P) % P;
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const long long mod = 1e9 + 7;
int n, q;
long long a[maxn], w[maxn];
long long sum[2][maxn];
void update(int rt, int x, long long val) {
while (x <= n) {
sum[rt][x] += val;
if (rt) sum[rt][x] %= mod;
x += x & (-x);
}
}
long long query(int rt, int x) {
long long ret = 0;
while (x) {
ret += sum[rt][x];
if (rt) ret %= mod;
x -= x & (-x);
}
return ret;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]), a[i] -= i - 1;
for (int i = 1; i <= n; i++) scanf("%lld", &w[i]);
for (int i = 1; i <= n; i++)
update(0, i, w[i]), update(1, i, w[i] * a[i] % mod);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
update(0, x, -w[x]);
update(1, x, mod - w[x] * a[x] % mod);
w[x] = y;
update(0, x, w[x]);
update(1, x, w[x] * a[x] % mod);
} else {
int l = x, r = y, t = y;
long long sum = query(0, y) - query(0, x - 1);
while (l <= r) {
int mid = (l + r) >> 1;
if ((query(0, mid) - query(0, x - 1)) * 2 >= sum)
r = mid - 1, t = mid;
else
l = mid + 1;
}
long long ans = (a[t] * ((query(0, t) - query(0, x - 1)) % mod) % mod -
(query(1, t) - query(1, x - 1) + mod) % mod + mod) %
mod;
ans = (ans + (query(1, y) - query(1, t) + mod) % mod -
a[t] * ((query(0, y) - query(0, t)) % mod) % mod + mod) %
mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 2;
long long a[maxi], w[maxi];
int n, q;
long long mo = 1e9 + 7;
long long bit[maxi];
long long bit1[maxi];
long long bit2[maxi];
void update(long long *bit, int x, long long val) {
for (int i = x; i < maxi; i += i & (-i)) bit[i] += val;
return;
}
long long get(long long *bit, int x) {
long long ans = 0;
for (int i = x; i > 0; i -= i & (-i)) ans += bit[i];
return ans;
}
void update2(long long *bit2, int x, long long val) {
for (int i = x; i < maxi; i += i & (-i)) {
bit2[i] = (bit2[i] + val) % mo;
if (bit2[i] < 0) bit2[i] += mo;
}
return;
}
long long get2(long long *bit2, int x) {
long long ans = 0;
for (int i = x; i > 0; i -= i & (-i)) {
ans += bit2[i];
ans %= mo;
}
return ans;
}
long long sredi(long long x) {
x %= mo;
if (x < 0) x += mo;
return x;
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &w[i]);
for (int i = 1; i <= n; i++) update2(bit2, i, w[i] * a[i]);
for (int i = 1; i <= n; i++) update(bit, i, w[i]);
for (int i = 1; i <= n; i++) update2(bit1, i, 1ll * i * w[i]);
while (q--) {
int tip;
int idx, l;
scanf("%d", &tip);
if (tip < 0) {
idx = -tip;
tip = 1;
} else {
l = tip;
tip = 2;
}
if (tip == 1) {
long long val;
scanf("%lld", &val);
update(bit, idx, -w[idx]);
update2(bit1, idx, -1ll * idx * w[idx]);
update2(bit2, idx, -1ll * a[idx] * w[idx]);
w[idx] = val;
update(bit, idx, w[idx]);
update2(bit1, idx, 1ll * idx * w[idx]);
update2(bit2, idx, 1ll * a[idx] * w[idx]);
} else {
int r;
scanf("%d", &r);
if (l == r)
printf("0\n");
else {
int li = -1;
int ri = r - l + 1;
long long sum = get(bit, r) - get(bit, l - 1);
long long pola = (sum + 1) / 2;
while (li < ri - 1) {
int mid = li + ri >> 1;
long long val = get(bit, l + mid) - get(bit, l - 1);
if (val >= pola)
ri = mid;
else
li = mid;
}
int poz = l + ri;
long long ans = 0;
if (poz - 1 >= l) {
long long x = a[poz] - poz;
long long sumWi = get(bit, poz - 1) - get(bit, l - 1);
sumWi %= mo;
ans += sumWi * x;
ans = sredi(ans);
ans += get2(bit1, poz - 1) - get2(bit1, l - 1);
ans = sredi(ans);
if (ans < 0) ans += mo;
ans -= (get2(bit2, poz - 1) - get2(bit2, l - 1));
ans = sredi(ans);
}
if (poz + 1 <= r) {
long long x = a[poz] - poz;
ans += get2(bit2, r) - get2(bit2, poz);
ans = sredi(ans);
ans -= get2(bit1, r) - get2(bit1, poz);
ans = sredi(ans);
long long sumWi = get(bit, r) - get(bit, poz);
sumWi %= mo;
ans -= sumWi * x;
ans = sredi(ans);
}
printf("%lld\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using vull = std::vector<ull>;
using vul = std::vector<ul>;
const ul sz = 1 << 18;
const ul base = 1e9 + 7;
class scaler {
public:
ul v = 0;
scaler() = default;
scaler(ul x) : v(x) {}
};
scaler operator+(scaler a, scaler b) {
return scaler(a.v + b.v < base ? a.v + b.v : a.v + b.v - base);
}
scaler operator-(scaler a, scaler b) {
return scaler(a.v < b.v ? a.v + base - b.v : a.v - b.v);
}
scaler operator*(scaler a, scaler b) { return scaler(ull(a.v) * b.v % base); }
template <typename T>
void change(ul pos, const T& v, std::vector<T>& tree) {
for (tree[pos |= sz] = v, pos >>= 1; pos; pos >>= 1) {
tree[pos] = tree[pos << 1] + tree[pos << 1 | 1];
}
}
template <typename T>
T query(ul l, ul r, const std::vector<T>& tree) {
T ret = 0;
for (l = l - 1 | sz, r = r + 1 | sz; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) {
ret = ret + tree[l ^ 1];
}
if (r & 1) {
ret = ret + tree[r ^ 1];
}
}
return ret;
}
std::vector<scaler> atree(sz << 1, ul(0));
vull tree(sz << 1, ul(0));
ul n, q;
vul a(2e5 + 1);
scaler compute(ul l, ul r, ul cut) {
return scaler(query(l, cut - 1, tree) % base) * scaler(a[cut]) -
query(l, cut - 1, atree) + query(cut + 1, r, atree) -
scaler(query(cut + 1, r, tree) % base) * scaler(a[cut]);
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> q;
for (ul i = 1; i <= n; ++i) {
std::cin >> a[i];
a[i] -= i;
}
for (ul i = 1; i <= n; ++i) {
ul w;
std::cin >> w;
change(i, ull(w), tree);
change(i, scaler(a[i]) * scaler(w), atree);
}
for (ul i = 0; i != q; ++i) {
li x, y;
std::cin >> x >> y;
if (x < 0) {
ul id = -x;
ul w = y;
change(id, ull(w), tree);
change(id, scaler(a[id]) * scaler(w), atree);
} else {
ul l = x, r = y;
ull temp = query(l, r, tree);
ul lans = l, rans = r + 1;
while (lans + 1 != rans) {
ul mid = lans + rans >> 1;
if ((query(mid, r, tree) << 1) < temp) {
rans = mid;
} else {
lans = mid;
}
}
std::cout << compute(l, r, lans).v << std::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];
void pu(int o) {
sum1[o] = sum1[(o << 1)] + sum1[((o << 1) | 1)];
sum2[o] = (sum2[(o << 1)] + sum2[((o << 1) | 1)]) % 1000000007;
}
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);
}
void build(int o, int l, int r) {
if (l == r) {
sum1[o] = w[l], sum2[o] = (long long)a[l] * w[l] % 1000000007;
return;
}
build((o << 1), l, ((l + r) >> 1)),
build(((o << 1) | 1), ((l + r) >> 1) + 1, r);
pu(o);
}
void update(int o, int l, int r, int first, int v) {
if (l == r) {
sum1[o] = v;
sum2[o] = (long long)v * a[l] % 1000000007;
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);
}
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);
build(1, 1, n);
while (q--) {
int first = read(), second = read();
if (first < 0)
update(1, 1, n, -first, second);
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 N = 210005, p = 1000000007;
int read() {
int f = 1, g = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) g = g * 10 + ch - '0';
return f * g;
}
int n, q;
long long a[N], w[N];
struct node {
int l, r;
long long s, sl, sr;
};
node operator+(node x, node y) {
node z;
z.l = x.l;
z.r = y.r;
z.s = x.s + y.s;
z.sl = (x.sl + y.sl + y.s % p * (a[y.l] - a[x.l] - x.r + x.l - 1) % p) % p;
z.sr = (x.sr + y.sr + x.s % p * (a[y.r] - y.r + y.l - 1 - a[x.r]) % p) % p;
return z;
}
struct segment_tree {
node a[N << 2];
void build(int x, int fl, int fr) {
if (fl == fr) {
a[x] = (node){fl, fr, w[fl], 0, 0};
return;
}
int mid = (fl + fr) >> 1;
build(x * 2, fl, mid);
build(x * 2 + 1, mid + 1, fr);
a[x] = a[x * 2] + a[x * 2 + 1];
}
void modify(int x, int k, long long w) {
if (a[x].l == a[x].r) {
a[x].s = w;
return;
}
int mid = (a[x].l + a[x].r) >> 1;
modify(x * 2 + (k > mid), k, w);
a[x] = a[x * 2] + a[x * 2 + 1];
}
long long getsum(int x, int k) {
if (a[x].r <= k) return a[x].s;
int mid = (a[x].l + a[x].r) >> 1;
long long s = getsum(x * 2, k);
if (mid < k) s += getsum(x * 2 + 1, k);
return s;
}
int find(int x, long long k) {
if (a[x].l == a[x].r) return a[x].l;
int mid = (a[x].l + a[x].r) >> 1;
if (k <= a[x * 2].s)
return find(x * 2, k);
else
return find(x * 2 + 1, k - a[x * 2].s);
}
int lower_bound(long long k) { return find(1, k); }
node query(int x, int l, int r) {
if ((l <= a[x].l) && (a[x].r <= r)) return a[x];
int mid = (a[x].l + a[x].r) >> 1;
if (r <= mid)
return query(x * 2, l, r);
else if (mid < l)
return query(x * 2 + 1, l, r);
else
return query(x * 2, l, r) + query(x * 2 + 1, l, r);
}
long long calc(int l, int r) {
int t = lower_bound((getsum(1, l - 1) + getsum(1, r) + 1) >> 1);
return (query(1, l, t).sr + query(1, t, r).sl) % p;
}
} f;
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) w[i] = read();
a[0] = 0;
a[n + 1] = 0x3f3f3f3f;
f.build(1, 0, n + 1);
while (q--) {
int x = read(), y = read();
if (x < 0)
f.modify(1, -x, y);
else
printf("%d\n", f.calc(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
long long a[maxn], w[maxn];
long long lowbit(long long x) { return x & -x; }
void add(long long t[], long long x, long long d, int typ) {
for (; x < maxn; x += lowbit(x)) {
t[x] += d;
if (typ) t[x] = (t[x] + mod) % mod;
}
}
long long ask(long long t[], long long x, int typ) {
long long ret = 0;
for (; x; x -= lowbit(x)) {
ret += t[x];
if (typ) ret %= mod;
}
return ret;
}
long long sum[maxn];
long long t[maxn];
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", w + i);
add(t, i, w[i], 0);
add(sum, i, w[i] * a[i] % mod, 1);
}
while (q--) {
long long l, r;
scanf("%lld%lld", &l, &r);
if (l < 0) {
add(t, -l, r - w[-l], 0);
add(sum, -l, a[-l] * (r - w[-l] + mod) % mod, 1);
w[-l] = r;
} else {
long long L = l - 1, R = r;
long long all = ask(t, r, 0) - ask(t, l - 1, 0);
while (L + 1 < R) {
long long mid = (L + R) / 2;
if (ask(t, mid, 0) - ask(t, l - 1, 0) > all / 2)
R = mid;
else
L = mid;
}
long long k = R;
long long ans = a[k] * (ask(t, k - 1, 1) - ask(t, l - 1, 1) + mod) % mod;
ans -= (ask(sum, k - 1, 1) - ask(sum, l - 1, 1) + mod) % mod;
ans = (ans + mod) % mod;
(ans += (ask(sum, r, 1) - ask(sum, k, 1) + mod)) %= mod;
ans -= a[k] * (ask(t, r, 1) - ask(t, k, 1) + mod) % mod;
ans = (ans + mod) % mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)2e5 + 3;
const int MOD = (int)1e9 + 7;
const int infint = (int)1e9;
const long long inf = (long long)1e15;
long long n, a[MAXN], q, w[MAXN];
long long mul(long long a, long long b) {
a %= MOD, b %= MOD;
long long c = 1LL * a * b;
c %= MOD;
return c;
}
long long add(long long a, long long b) {
a %= MOD, b %= MOD;
long long c = a + b;
if (c < 0) c += MOD;
if (c >= MOD) c -= MOD;
return c;
}
struct segment {
long long seg[2 * MAXN];
void build(bool toMOD) {
for (int i = n - 1; i > 0; i--) {
if (toMOD == 0)
seg[i] = seg[i << 1] + seg[i << 1 | 1];
else
seg[i] = add(seg[i << 1], seg[i << 1 | 1]);
}
}
void update(int idx, long long v, bool toMOD) {
for (seg[idx += n] = v; idx > 0; idx >>= 1) {
if (toMOD == 0)
seg[idx >> 1] = seg[idx] + seg[idx ^ 1];
else
seg[idx >> 1] = add(seg[idx], seg[idx ^ 1]);
}
}
long long get(int l, int r, bool toMOD) {
long long sum = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
if (toMOD == 0)
sum += seg[l++];
else
sum = add(sum, seg[l++]);
}
if (r & 1) {
if (toMOD == 0)
sum += seg[--r];
else
sum = add(sum, seg[--r]);
}
}
return sum;
}
} sum, wei;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> w[i];
sum.seg[i + n] = w[i];
wei.seg[i + n] = mul(w[i], add(a[i], -i));
}
sum.build(0), wei.build(1);
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type < 0) {
long long idx, val;
idx = -type;
idx--;
cin >> val;
sum.update(idx, val, 0);
wei.update(idx, mul(val, add(a[idx], -idx)), 1);
} else {
long long l, r;
l = type;
l--;
cin >> r;
int L = l - 1, R = r - 1;
while (R - L > 1) {
int mid = (L + R) >> 1;
if (sum.get(l, mid + 1, 0) >= sum.get(mid + 1, r, 0))
R = mid;
else
L = mid;
}
long long ans = 0;
ans = add(mul(sum.get(l, R, 1), add(a[R], -R)), -wei.get(l, R, 1));
ans = add(ans,
add(wei.get(R, r, 1), -mul(sum.get(R, r, 1), add(a[R], -R))));
cout << ans << "\n";
}
}
}
|
#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;
}
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] - 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] - 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) {
long long L = qry2(1, 1, n, l, r) % P, R = qry1(1, 1, n, l, r) % P;
(L += P) %= P, (R += P) %= P;
return ((L + R * (pos - a[pos]) % P) % P + P) % P;
}
signed main() {
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; ++i) scanf("%lld", a + 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 int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 3e5 + 7;
const double pi = acos(-1.0);
const double eps = 0.0000000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline void pr2(T x, int k = 64) {
long long i;
for (i = 0; i < k; i++) fprintf(stderr, "%d", (x >> i) & 1);
putchar(' ');
}
template <typename T>
inline void add_(T &A, int B, long long MOD = M) {
A += B;
(A >= MOD) && (A -= MOD);
}
template <typename T>
inline void mul_(T &A, long long B, long long MOD = M) {
A = (A * B) % MOD;
}
template <typename T>
inline void mod_(T &A, long long MOD = M) {
A %= MOD;
A += MOD;
A %= MOD;
}
template <typename T>
inline void max_(T &A, T B) {
(A < B) && (A = B);
}
template <typename T>
inline void min_(T &A, T B) {
(A > B) && (A = B);
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
int n, m, q;
char str[maxn];
int startTime;
void startTimer() { startTime = clock(); }
void printTimer() {
fprintf(stderr, "/--- Time: %ld milliseconds ---/\n", clock() - startTime);
}
inline int lowbit(int x) { return x & -x; }
int A[maxn], w[maxn];
long long sumw[maxn], sumaw[maxn];
inline void update(long long A[], int x, long long val) {
for (; x <= n; x += lowbit(x)) A[x] += val;
}
inline void update(int x, int val) {
update(sumw, x, val - w[x]);
update(sumaw, x, M + (long long)(val - w[x]) * A[x] % M);
w[x] = val;
}
inline long long query(long long A[], int x) {
long long ret = 0;
for (; x; x -= lowbit(x)) ret += A[x];
return ret;
}
inline long long query(long long A[], int l, int r) {
return query(A, r) - query(A, l - 1);
}
inline long long query(int l, int x, int r) {
long long ret = 0;
ret += query(sumw, l, x) % M * A[x] % M - query(sumaw, l, x) % M;
ret += -query(sumw, x, r) % M * A[x] % M + query(sumaw, x, r) % M;
return ret;
}
int main() {
int i, k;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i++) scanf("%d", &A[i]), A[i] -= i;
for (i = 1; i <= n; i++) scanf("%d", &k), update(i, k);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0)
update(-l, r);
else {
int L = l, R = r;
r++;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (query(sumw, L, mid - 1) - query(sumw, mid, R) < 0)
l = mid;
else
r = mid;
}
printf("%I64d\n", (query(L, l, R) % M + M) % M);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline unsigned long long icbrt(unsigned long long k) {
unsigned long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
const int maxn = 2e5 + 5;
int n, q;
int a[maxn];
int w[maxn];
long long fen[maxn];
void upd(int p, int val) {
p++;
for (; p < maxn; p += p & -p) {
fen[p] += val;
}
}
long long query(int p) {
p++;
long long res = 0;
for (; p > 0; p -= p & -p) {
res += fen[p];
}
return res;
}
int fen2[2][maxn];
void upd(int p, int fen[], int val) {
p++;
for (; p < maxn; p += p & -p) {
addmod(fen[p], val);
}
}
int query(int fen[], int p) {
p++;
int res = 0;
for (; p > 0; p -= p & -p) {
addmod(res, fen[p]);
}
return res;
}
int query(int fen[], int l, int r) {
int res = query(fen, r);
submod(res, query(fen, l - 1));
return res;
}
void volamtruyenkyii() {
cin >> n >> q;
for (int i = (0); i < (n); ++i) cin >> a[i], submod(a[i], i);
for (int i = (0); i < (n); ++i) {
cin >> w[i];
upd(i, w[i]);
upd(i, fen2[0], w[i]);
upd(i, fen2[1], mult(a[i], w[i]));
}
while (q--) {
int u, v;
cin >> u >> v;
if (u < 0) {
u = -u - 1;
upd(u, -w[u]);
upd(u, fen2[0], (MOD - w[u]) % MOD);
upd(u, fen2[1], (MOD - mult(a[u], w[u])) % MOD);
w[u] = v;
upd(u, w[u]);
upd(u, fen2[0], w[u]);
upd(u, fen2[1], mult(a[u], w[u]));
} else {
u--, v--;
long long sum = query(v) - query(u - 1);
int l = u, r = v;
while (l < r) {
int m = l + r >> 1;
if (2 * (query(m) - query(u - 1)) < sum) {
l = m + 1;
} else {
r = m;
}
}
int m = l + r >> 1;
int x = a[m];
int res = 0;
addmod(res, mult(x, query(fen2[0], u, m)));
submod(res, query(fen2[1], u, m));
addmod(res, query(fen2[1], m + 1, v));
submod(res, mult(x, query(fen2[0], m + 1, v)));
cout << res << "\n";
}
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
volamtruyenkyii();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int n, q, tmp[N], a[N], b[N], w[N], val[N];
int lowbit(int x) { return x & -x; }
struct BITs {
long long c[N];
void ins(int x, int v) {
for (; x <= n; x += lowbit(x)) c[x] += v;
}
long long query(int x) {
long long ret = 0;
for (; x; x -= lowbit(x)) ret += c[x];
return ret;
}
long long calc(int l, int r) { return query(r) - query(l - 1); }
} tr1;
struct BITssum {
int c[N];
void ins(int x, int v) {
for (; x <= n; x += lowbit(x)) c[x] = (c[x] + v) % mod;
}
int query(int x) {
int ret = 0;
for (; x; x -= lowbit(x)) ret = (ret + c[x]) % mod;
return ret;
}
int calc(int l, int r) { return (query(r) - query(l - 1)) % mod; }
} tr2;
bool check(int x, int l, int r, int mid, long long sum) {
if (tr1.query(mid) - tr1.query(l - 1) >= (sum + 1) / 2) return 1;
return 0;
}
int solve(int L, int R) {
long long cnt = tr1.calc(L, R);
int l = 1, r = n, best = n;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid, L, R, mid, cnt))
best = mid, r = mid - 1;
else
l = mid + 1;
}
int ans = 0;
ans = (ans + (1ll * tr1.calc(L, best - 1) % mod * val[best] % mod -
tr2.calc(L, best - 1)) %
mod) %
mod;
ans = (ans + (tr2.calc(best + 1, R) -
1ll * tr1.calc(best + 1, R) % mod * val[best] % mod) %
mod) %
mod;
return (ans + mod) % mod;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), tmp[i] = a[i];
sort(tmp + 1, tmp + n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= n; i++) {
b[i] = lower_bound(tmp + 1, tmp + n + 1, a[i]) - tmp, val[i] = a[i] - i;
tr1.ins(b[i], w[i]);
tr2.ins(b[i], 1ll * w[i] * val[i] % mod);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
tr1.ins(b[x], -w[x]), tr2.ins(b[x], -1ll * w[x] * val[x] % mod);
w[x] = y;
tr1.ins(b[x], w[x]), tr2.ins(b[x], 1ll * w[x] * val[x] % mod);
} else
printf("%d\n", solve(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n, q, a[300001];
const int MAX = 1 << 18;
struct sum_seg {
long long tr[MAX << 1];
void upd(int cur, long long val) {
tr[cur += MAX] = val;
cur >>= 1;
while (cur) {
tr[cur] = tr[cur << 1] + tr[cur << 1 | 1];
cur >>= 1;
}
}
long long sum(int l, int r) {
long long res = 0;
l += MAX;
r += MAX;
while (l <= r) {
if (l & 1) res += tr[l++];
if (!(r & 1)) res += tr[r--];
l >>= 1;
r >>= 1;
}
return res;
}
} sum;
struct td {
long long lsum, rsum, lwsum, rwsum;
td() {}
td(long long a, long long b, long long c, long long d)
: lsum(a), rsum(b), lwsum(c), rwsum(d) {}
};
struct wsum_seg {
long long ltr[MAX << 1], rtr[MAX << 1];
pair<long long, long long> upd(int cur, int s, int f, int idx) {
if (f < idx || s > idx)
return pair<long long, long long>(ltr[cur], rtr[cur]);
else if (s == f)
return pair<long long, long long>(0, 0);
else {
int nx = cur << 1, md = (s + f) >> 1, l = f - md;
pair<long long, long long> lv = upd(nx, s, md, idx),
rv = upd(nx + 1, md + 1, f, idx);
ltr[cur] = ((lv.first + rv.first) % mod +
sum.tr[nx] % mod * (a[f] - l - a[md]) % mod) %
mod;
rtr[cur] = ((lv.second + rv.second) % mod +
sum.tr[nx + 1] % mod * (a[md + 1] - (a[s] + l)) % mod) %
mod;
return pair<long long, long long>(ltr[cur], rtr[cur]);
}
}
td find(int cur, int s, int f, int l, int r) {
if (f < l || s > r)
return td(0, 0, 0, 0);
else if (l <= s && f <= r)
return td(sum.tr[cur] % mod, sum.tr[cur] % mod, ltr[cur], rtr[cur]);
else {
int nx = cur << 1, md = (s + f) >> 1, len = min(r, f) - md;
if (r <= md)
return find(nx, s, md, l, r);
else if (l >= md + 1)
return find(nx + 1, md + 1, f, l, r);
td lv = find(nx, s, md, l, r), rv = find(nx + 1, md + 1, f, l, r);
td res;
res.lwsum = ((lv.lwsum + rv.lwsum) % mod +
lv.lsum % mod * (a[min(r, f)] - len - a[md]) % mod) %
mod;
len = md - max(l, s) + 1;
res.rwsum = ((lv.rwsum + rv.rwsum) % mod +
rv.rsum % mod * (a[md + 1] - (a[max(l, s)] + len)) % mod) %
mod;
res.lsum = (lv.lsum + rv.lsum) % mod;
res.rsum = (lv.rsum + rv.rsum) % mod;
return res;
}
}
} wsum;
int get_point(int s, int l, int r) {
int lo = l - 1, up = r + 1;
while (up - lo > 1) {
int md = (lo + up) >> 1;
if (a[md] <= s + (md - l))
lo = md;
else
up = md;
}
return lo;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = n + 1; i < MAX; i++) a[i] = a[i - 1] + 1;
for (int i = 1; i <= n; i++) {
long long val;
scanf("%lld", &val);
sum.upd(i, val);
wsum.upd(1, 0, MAX - 1, i);
}
int x, y;
while (q--) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
sum.upd(x, y);
wsum.upd(1, 0, MAX - 1, x);
} else {
int lo = a[x - 1], up = a[y + 1];
while (up - lo > 1) {
int md = (lo + up) >> 1;
int j = get_point(md, x, y);
if (sum.sum(x, j) <= sum.sum(j + 1, y))
lo = md;
else
up = md;
}
int i = up, j = get_point(up, x, y);
long long ans = 0;
if (j >= x) {
td val = wsum.find(1, 0, MAX - 1, x, j);
ans = (ans + val.lwsum % mod +
val.lsum % mod * (i + j - x - a[j]) % mod) %
mod;
}
if (j + 1 <= y) {
td val = wsum.find(1, 0, MAX - 1, j + 1, y);
ans = (ans + val.rwsum % mod +
val.rsum % mod * (a[j + 1] - (i + j - x + 1)) % mod) %
mod;
}
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7, nax = 2e5 + 10;
void plusle(int &a, int b) {
if ((a += b) >= mod) a -= mod;
}
void minun(int &a, int b) {
if ((a -= b) < 0) a += mod;
}
int add(int a, int b) { return ((a += b) >= mod) ? a - mod : a; }
int sub(int a, int b) { return ((a -= b) < 0) ? a + mod : a; }
int mul(int a, int b) { return (1LL * a * b) % mod; }
template <class T = ll>
struct fenwick {
T bit[nax];
T get(int idx) {
T res = 0;
for (; idx > 0; idx -= idx & -idx) res += bit[idx];
return res;
}
void update(int idx, int val) {
for (; idx < nax; idx += idx & -idx) bit[idx] += val;
}
T get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
};
struct modfenwick {
int bit[nax];
modfenwick() { memset(bit, 0, sizeof(bit)); }
int get(int idx) {
int res = 0;
for (; idx > 0; idx -= idx & -idx) plusle(res, bit[idx]);
return res;
}
void update(int idx, int val) {
for (; idx < nax; idx += idx & -idx) plusle(bit[idx], val);
}
int get(int l, int r) {
if (l > r) return 0;
return sub(get(r), get(l - 1));
}
};
int n, q, a[nax], w[nax];
modfenwick fm;
fenwick<ll> f1;
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);
f1.update(i, w[i]);
fm.update(i, mul(a[i], w[i]));
}
42;
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x = -x;
int res = ((-mul(a[x], w[x])) + mod) % mod;
fm.update(x, res);
f1.update(x, -w[x]);
w[x] = y;
f1.update(x, y);
fm.update(x, mul(a[x], y));
} else {
int l = x, r = y, ans = x;
ll sum = f1.get(l, r);
while (l <= r) {
int mid = l + r >> 1;
if (f1.get(x, mid) * 2 >= sum) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
42;
ll res = 0;
int c = ans;
if (x < c) {
res = (1LL * a[c] * (f1.get(x, c) % mod)) % mod;
42;
res -= fm.get(x, c);
42;
}
if (y > c) {
res -= (1LL * a[c] * (f1.get(c + 1, y) % mod)) % mod;
42;
res += fm.get(c + 1, y);
42;
res %= mod;
}
if (res < 0) res += mod;
42;
printf("%lld\n", res);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
const int Mod = 1e9 + 7;
void add_self(int& x, int y) {
if ((x += y) >= Mod) x -= Mod;
}
void sub_self(int& x, int y) {
if ((x -= y) < 0) x += Mod;
}
int add(int x, int y) { return add_self(x, y), x; }
int sub(int x, int y) { return sub_self(x, y), x; }
int mul(int x, int y) { return (long long)x * y % Mod; }
template <typename type>
struct SegmentTreeWithoutLazyPropagation {
private:
const type E = 0;
private:
static const int Nax = 4 * N;
private:
int n;
private:
type Tree[Nax];
public:
SegmentTreeWithoutLazyPropagation(int n = 0) : n(n) {
for (int Node = 0; Node < Nax; Node++) Tree[Node] = E;
}
private:
virtual type Unite(type x, type y) = 0;
private:
void Merge(int Node) {
Tree[Node] = Unite(Tree[(Node << 1)], Tree[(Node << 1 | 1)]);
}
public:
void Build(const vector<type>& a) {
Clear();
n = a.size();
Build(a, 1, 0, n - 1);
}
private:
void Build(const vector<type>& a, int Node, int L, int R) {
Tree[Node] = E;
if (L == R) return void(Tree[Node] = a[L]);
Build(a, (Node << 1), L, ((L + R) >> 1));
Build(a, (Node << 1 | 1), ((L + R) >> 1) + 1, R);
Merge(Node);
}
public:
void Update(int i, type x) {
if (n <= 0) return;
Update(i, x, 1, 0, n - 1);
}
private:
void Update(int i, type x, int Node, int L, int R) {
if (i < L || R < i) return;
if (L == R) return void(Tree[Node] = x);
Update(i, x, (Node << 1), L, ((L + R) >> 1));
Update(i, x, (Node << 1 | 1), ((L + R) >> 1) + 1, R);
Merge(Node);
}
public:
type Query(int i, int j) {
if (n <= 0 || i > j) return E;
return Query(i, j, 1, 0, n - 1);
}
private:
type Query(int i, int j, int Node, int L, int R) {
if (j < L || R < i) return E;
if (i <= L && R <= j) return Tree[Node];
return Unite(Query(i, j, (Node << 1), L, ((L + R) >> 1)),
Query(i, j, (Node << 1 | 1), ((L + R) >> 1) + 1, R));
}
public:
void Clear() {
for (int Node = 0; Node <= 4 * n; Node++) Tree[Node] = E;
n = 0;
}
};
template <typename type>
struct SegmentTreeSum : public SegmentTreeWithoutLazyPropagation<type> {
private:
type Unite(type x, type y) { return x + y; };
};
template <typename type>
struct SegmentTreeSumMod : public SegmentTreeWithoutLazyPropagation<type> {
private:
type Unite(type x, type y) { return add(x, y); };
};
SegmentTreeSum<long long> MyTreeW;
SegmentTreeSumMod<int> MyTreeWA;
int main() {
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int& x : a) scanf("%d", &x);
vector<long long> w(n);
for (long long& x : w) scanf("%I64d", &x);
vector<int> WA(n);
for (int i = 0; i < n; i++) WA[i] = mul(w[i], sub(a[i], i));
MyTreeW.Build(w);
MyTreeWA.Build(WA);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
int i = -x - 1, nw = y;
w[i] = nw;
MyTreeW.Update(i, nw);
MyTreeWA.Update(i, mul(nw, sub(a[i], i)));
} else {
int L = x - 1, R = y - 1;
int i = L - 1;
int Low = L, High = R - 1;
long long Sum = MyTreeW.Query(L, R);
while (Low <= High) {
int Mid = Low + (High - Low) / 2;
long long S = MyTreeW.Query(L, Mid);
if (2 * S <= Sum) {
i = Mid;
Low = Mid + 1;
} else {
High = Mid - 1;
}
}
i++;
int Ans = 0;
add_self(Ans, mul(a[i] - i, MyTreeW.Query(L, i - 1) % Mod));
sub_self(Ans, MyTreeWA.Query(L, i - 1));
sub_self(Ans, mul(a[i] - i, MyTreeW.Query(i + 1, R) % Mod));
add_self(Ans, MyTreeWA.Query(i + 1, R));
printf("%d\n", Ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
long long c[N], sum[N << 2], w[N], sum_fn[N << 2];
int n, a[N];
int lowbit(int x) { return x & -x; }
void upd(int x, int val) {
for (; x <= n; x += lowbit(x)) c[x] += val;
}
long long get_sum(int x) {
long long ans = 0;
for (; x; x -= lowbit(x)) ans += c[x];
return ans;
}
void build(int l, int r, int rt) {
if (l == r) {
sum[rt] = w[l] * l % mod;
sum_fn[rt] = w[l] * a[l] % mod;
return;
}
int mid = l + r >> 1;
build(l, mid, (rt << 1));
build(mid + 1, r, (rt << 1 | 1));
sum[rt] = (sum[(rt << 1)] + sum[(rt << 1 | 1)]) % mod;
sum_fn[rt] = (sum_fn[(rt << 1)] + sum_fn[(rt << 1 | 1)]) % mod;
}
void update(int l, int r, int x, int val, int rt) {
if (l == r) {
sum[rt] = val * 1ll * l % mod;
sum_fn[rt] = val * 1ll * a[l] % mod;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(l, mid, x, val, (rt << 1));
else
update(mid + 1, r, x, val, (rt << 1 | 1));
sum[rt] = (sum[(rt << 1)] + sum[(rt << 1 | 1)]) % mod;
sum_fn[rt] = (sum_fn[(rt << 1)] + sum_fn[(rt << 1 | 1)]) % mod;
}
pair<long long, long long> query(int l, int r, int L, int R, int rt) {
if (L <= l && r <= R) return make_pair(sum[rt], sum_fn[rt]);
int mid = l + r >> 1;
pair<long long, long long> ans = make_pair(0ll, 0ll);
if (L <= mid) {
pair<long long, long long> res = query(l, mid, L, R, (rt << 1));
ans.first = (ans.first + res.first) % mod;
ans.second = (ans.second + res.second) % mod;
}
if (mid < R) {
pair<long long, long long> res = query(mid + 1, r, L, R, (rt << 1 | 1));
ans.first = (ans.first + res.first) % mod;
ans.second = (ans.second + res.second) % mod;
}
return ans;
}
int main() {
int 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("%lld", &w[i]), upd(i, w[i]);
build(1, n, 1);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x = -x;
update(1, n, x, y, 1);
upd(x, y - w[x]);
w[x] = y;
} else {
long long pr = get_sum(x - 1), sb = get_sum(y);
int l = x, r = y, ans = -1;
while (l <= r) {
int mid = l + r >> 1;
long long res = get_sum(mid);
if (res - pr >= sb - res) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
long long su = 0;
long long w_ans = get_sum(ans);
if (ans < y) {
pair<long long, long long> p = query(1, n, ans + 1, y, 1);
su += (p.second - p.first -
(sb - w_ans) % mod * 1ll * (a[ans] - ans) % mod) %
mod;
}
if (ans >= x) {
pair<long long, long long> p = query(1, n, x, ans, 1);
su += (p.first - p.second +
(w_ans - pr) % mod * 1ll * (a[ans] - ans) % mod) %
mod;
}
su %= mod;
su = (su + mod) % mod;
printf("%lld\n", su);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
struct SegtreeMOD {
vector<long long> t;
int n, h;
SegtreeMOD() {}
SegtreeMOD(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<long long>(n << 1);
}
void assign(int x, long long v) {
x += n;
t[x] = v % MOD;
for (x /= 2; x; x /= 2) {
t[x] = (t[x << 1] + t[x << 1 | 1]) % MOD;
}
}
long long query(int l, int r) {
long long ans = 0;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2) {
ans += t[l++];
}
if (r % 2) {
ans += t[--r];
}
}
return ans % MOD;
}
};
struct Segtree {
vector<long long> t;
int n, h;
Segtree() {}
Segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<long long>(n << 1);
}
void assign(int x, long long v) {
x += n;
t[x] = v;
for (x /= 2; x; x /= 2) {
t[x] = t[x << 1] + t[x << 1 | 1];
}
}
long long query(int l, int r) {
long long ans = 0;
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2) {
ans += t[l++];
}
if (r % 2) {
ans += t[--r];
}
}
return ans;
}
pair<long long, int> bs(int l, int r, long long goal, int x, int lv, int rv) {
if (rv <= l || r <= lv) {
return {0, -1};
}
if (l <= lv && rv <= r) {
if (t[x] < goal) {
return {t[x], -1};
}
if (rv - lv == 1) {
return {t[x], lv};
}
}
int mv = (lv + rv) / 2;
auto res1 = bs(l, r, goal, x * 2, lv, mv);
if (res1.second != -1) {
return res1;
}
auto res2 = bs(l, r, goal - res1.first, x * 2 + 1, mv, rv);
return {res2.first + res1.first, res2.second};
}
int bs(int l, int r, long long goal) {
return bs(l, r, goal, 1, 0, n).second;
}
};
Segtree weights;
SegtreeMOD wx;
int n, q;
long long a[200200];
long long query(int l, int r) {
long long wtot = weights.query(l, r + 1);
int med = weights.bs(l, r + 1, (wtot + 1) / 2);
long long ans = (weights.query(l, med) % MOD) * a[med] - wx.query(l, med) +
wx.query(med, r + 1) -
(weights.query(med, r + 1) % MOD) * a[med];
ans = (ans % MOD + MOD) % MOD;
return ans % MOD;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
weights = Segtree(n + 1);
wx = SegtreeMOD(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; ++i) {
long long w;
cin >> w;
weights.assign(i, w);
wx.assign(i, w * a[i]);
}
while (q--) {
int _a, b;
cin >> _a >> b;
if (_a > 0) {
cout << query(_a, b) << "\n";
} else {
int id = -_a, nw = b;
weights.assign(id, nw);
wx.assign(id, nw * a[id]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
const int N = 201000;
const long long MOD = 1e9 + 7;
int n, q;
long long t1[N << 2], t2[N << 2], a[N], t, w[N];
void modify(int u, int l, int r, int p, long long v) {
if (l == r) {
t1[u] = v;
t2[u] = v * (a[p] - p) % MOD;
return;
}
int mid = l + r >> 1;
if (p <= mid)
modify(u << 1, l, mid, p, v);
else
modify(u << 1 | 1, mid + 1, r, p, v);
t1[u] = t1[u << 1] + t1[u << 1 | 1];
t2[u] = (t2[u << 1] + t2[u << 1 | 1]) % MOD;
}
long long query(int u, int l, int r, int L, int R) {
if (L > R) return 0;
if (L <= l && r <= R) return t1[u];
int mid = l + r >> 1;
long long re = 0;
if (L <= mid) re += query(u << 1, l, mid, L, R);
if (mid < R) re += query(u << 1 | 1, mid + 1, r, L, R);
return re;
}
long long query2(int u, int l, int r, int L, int R) {
if (L > R) return 0;
if (L <= l && r <= R) return t2[u];
int mid = l + r >> 1;
long long re = 0;
if (L <= mid) re += query2(u << 1, l, mid, L, R);
if (mid < R) re += query2(u << 1 | 1, mid + 1, r, L, R);
return re % MOD;
}
int find2(int u, int l, int r) {
if (l == r) return l;
int mid = l + r >> 1;
if (t - t1[u << 1] > 0) {
t -= t1[u << 1];
return find2(u << 1 | 1, mid + 1, r);
} else {
return find2(u << 1, l, mid);
}
}
int find(int u, int l, int r, int L, int R) {
if (L <= l && r <= R) {
if (t - t1[u] > 0)
t -= t1[u];
else
return find2(u, l, r);
return 0;
}
int mid = l + r >> 1;
if (L <= mid) {
int tmp = find(u << 1, l, mid, L, R);
if (tmp) return tmp;
}
if (mid < R) {
int tmp = find(u << 1 | 1, mid + 1, r, L, R);
if (tmp) return tmp;
}
}
int main() {
n = read(), q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) w[i] = read();
for (int i = 1; i <= n; i++) modify(1, 1, n, i, w[i]);
while (q--) {
int u = read(), v = read();
if (u < 0) {
u = -u;
modify(1, 1, n, u, v);
} else {
t = query(1, 1, n, u, v);
t = (t + 1) / 2;
int p = find(1, 1, n, u, v);
long long x = (a[p] - p) % MOD;
printf("%lld\n",
(query(1, 1, n, u, p) % MOD * x % MOD - query2(1, 1, n, u, p) -
query(1, 1, n, p + 1, v) % MOD * x % MOD +
query2(1, 1, n, p + 1, v) + MOD + MOD) %
MOD);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream in;
ofstream out;
const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = ml * ml * ml + 7;
struct triple {
long long l, r, v;
};
long long lt[ml], rt[ml];
long long t[ml];
long long n, i, j, s, q;
vector<long long> x, w;
vector<triple> seg;
bool viv = false;
void change(long long v, long long tl, long long tr, long long num,
long long nw) {
if (tl <= num && num <= tr) {
t[v] += nw;
lt[v] += (x[num] - x[tl] - num + tl) * nw;
long long real_tr = min(tr, n - 1);
rt[v] += (x[real_tr] - x[num] - real_tr + num) * nw;
lt[v] %= mod;
rt[v] %= mod;
long long tm = tl + tr >> 1;
if (tl < tr) {
change(2 * v, tl, tm, num, nw);
change(2 * v + 1, tm + 1, tr, num, nw);
}
}
}
long long getr(long long l, long long r, long long v, long long tl,
long long tr, long long num) {
if (r < tl || tr < l) return 0;
if (l <= tl && tr <= r) {
long long ret = rt[v];
long long real_tr = min(tr, n - 1);
ret += ((t[v] % mod) * (x[num] - x[real_tr] - num + real_tr));
ret %= mod;
return ret;
}
long long tm = tl + tr >> 1;
return (getr(l, r, 2 * v, tl, tm, num) +
getr(l, r, 2 * v + 1, tm + 1, tr, num)) %
mod;
}
long long getl(long long l, long long r, long long v, long long tl,
long long tr, long long num) {
if (r < tl || tr < l) return 0;
if (l <= tl && tr <= r) {
long long ret = lt[v];
ret += ((t[v] % mod) * (x[tl] - x[num] - tl + num));
ret %= mod;
return ret;
}
long long tm = tl + tr >> 1;
return (getl(l, r, 2 * v, tl, tm, num) +
getl(l, r, 2 * v + 1, tm + 1, tr, num)) %
mod;
}
long long sum(long long l, long long r, long long v, long long tl,
long long tr) {
if (r < tl || tr < l) return 0;
if (l <= tl && tr <= r) return t[v];
long long tm = tl + tr >> 1;
return sum(l, r, 2 * v, tl, tm) + sum(l, r, 2 * v + 1, tm + 1, tr);
}
long long found(long long a, long long b) {
long long l = a, r = b + 1;
long long locs = sum(a, b, 1, 0, s - 1);
long long tol = 0;
while (l + 1 != r) {
long long mi = l + r >> 1;
long long ls = tol + sum(l, mi - 1, 1, 0, s - 1);
if (2 * ls <= locs)
l = mi, tol = ls;
else
r = mi;
}
return l;
}
void get(long long l, long long r, long long v, long long tl, long long tr) {
if (r < tl || tr < l) return;
if (l <= tl && tr <= r) {
seg.push_back({tl, tr, t[v]});
return;
}
long long tm = tr + tl >> 1;
get(l, r, 2 * v, tl, tm);
get(l, r, 2 * v + 1, tm + 1, tr);
}
long long ver(long long l, long long r, long long v, long long tl,
long long tr) {
if (l == tl && r == tr) return v;
long long tm = tl + tr >> 1;
if (tm >= r)
return ver(l, r, 2 * v, tl, tm);
else
return ver(l, r, 2 * v + 1, tm + 1, tr);
}
long long gran(long long v, long long l, long long r, long long want) {
if (l == r) return l;
if (t[v] == want) return r + 1;
long long tm = l + r >> 1;
if (t[2 * v] > want) return gran(2 * v, l, tm, want);
return gran(2 * v + 1, tm + 1, r, want - t[2 * v]);
}
long long found_new(long long a, long long b) {
long long locs = sum(a, b, 1, 0, s - 1);
seg.clear();
get(a, b, 1, 0, s - 1);
vector<long long> pr;
pr.push_back(seg[0].v);
for (long long i = 1; i < seg.size(); i++) pr.push_back(pr.back() + seg[i].v);
j = 0;
while (pr[j] * 2 < locs) j++;
if (pr[j] * 2 == locs) return seg[j].r + 1;
long long l = seg[j].l;
long long r = seg[j].r;
long long want = locs / 2;
if (j != 0) want -= pr[j - 1];
long long v = ver(l, r, 1, 0, s - 1);
return gran(v, l, r, want);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
x.resize(n);
w.resize(n);
for (auto &i : x) cin >> i;
for (auto &i : w) cin >> i;
s = 1;
while (s < n) s *= 2;
for (i = 0; i < n; i++) change(1, 0, s - 1, i, w[i]);
if (viv) {
for (i = 1; i < n + s; i++) cout << t[i] << ' ';
cout << endl;
for (i = 1; i < n + s; i++) cout << lt[i] << ' ';
cout << endl;
for (i = 1; i < n + s; i++) cout << rt[i] << ' ';
cout << endl;
}
for (i = 0; i < q; i++) {
long long a, b;
cin >> a >> b;
if (a < 0) {
a = -a;
a--;
change(1, 0, s - 1, a, b - w[a]);
w[a] = b;
} else {
a--;
b--;
long long mi = found_new(a, b);
long long lans = 0;
lans += getr(a, mi - 1, 1, 0, s - 1, mi);
lans += getl(mi + 1, b, 1, 0, s - 1, mi);
lans %= mod;
lans += mod;
lans %= mod;
cout << lans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 100;
int n;
struct Tree {
long long tree[MAX_N];
void update(int k, long long val) {
while (k <= n) {
tree[k] += val;
k += (k & -k);
}
}
long long sum(int k) {
long long res = 0;
while (k > 0) {
res += tree[k];
k -= (k & -k);
}
return res;
}
} t1, t2;
long long a[MAX_N], w[MAX_N];
int BIS(int ql, int qr) {
int l = ql, r = qr, mid, res;
while (l <= r) {
mid = (l + r) >> 1;
if (t1.sum(mid) - t1.sum(ql - 1) < t1.sum(qr) - t1.sum(mid)) {
l = mid + 1;
} else {
res = mid;
r = mid - 1;
}
}
return res;
}
int main() {
int q;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
}
for (int i = 1; i <= n; i++) {
t1.update(i, w[i]);
t2.update(i, w[i] * (a[i] - i) % 1000000007);
}
int x, y;
for (int i = 1; i <= q; i++) {
scanf("%d %d", &x, &y);
if (x < 0) {
t1.update(-x, y - w[-x]);
t2.update(-x, (y - w[-x]) * (a[-x] + x) % 1000000007);
w[-x] = y;
} else {
int r = y, l = x;
int pos = BIS(x, y);
long long res = 0;
res = (res +
(t1.sum(pos - 1) - t1.sum(l - 1)) % 1000000007 * (a[pos] - pos)) %
1000000007;
res = (res - (t2.sum(pos - 1) - t2.sum(l - 1))) % 1000000007;
res = (res - (t1.sum(r) - t1.sum(pos)) % 1000000007 * (a[pos] - pos)) %
1000000007;
res = (res + t2.sum(r) - t2.sum(pos)) % 1000000007;
res = (res + 1000000007) % 1000000007;
printf("%lld\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int norm(int a) {
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
int norm(const long long &a) { return norm(int(a % mod)); }
long long mul(long long a, long long n) { return ((a * n) % mod); }
void inc(vector<long long> &f, int pos, long long val) {
int N = (int)f.size();
for (; pos < N; pos |= pos + 1) f[pos] += val;
}
long long sum(vector<long long> &f, int pos) {
long long ans = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) ans += f[pos];
return ans;
}
long long getSum(vector<long long> &f, int l, int r) {
return sum(f, r - 1) - sum(f, l - 1);
}
long long getNSum(vector<long long> &f, int l, int r) {
return norm(sum(f, r - 1) - sum(f, l - 1));
}
int main() {
int n, q;
cin >> n >> q;
vector<long long> a(n), w(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> w[i];
vector<long long> fn(n + 1), fnW(n + 1);
for (int i = 0; i < n; i++) {
a[i] -= i;
inc(fn, i, w[i]);
inc(fnW, i, mul(a[i], w[i]));
}
for (int t = 0; t < q; t++) {
int first, second;
cin >> first >> second;
if (first < 0) {
first = -first - 1;
inc(fn, first, -w[first]);
inc(fnW, first, -mul(a[first], w[first]));
w[first] = second;
inc(fn, first, w[first]);
inc(fnW, first, mul(a[first], w[first]));
continue;
}
first--;
long long sum = getSum(fn, first, second);
int left = first, right = second;
while (right - left > 1) {
int mid = left + (right - left) / 2;
if (2 * getSum(fn, first, mid) > sum)
right = mid;
else
left = mid;
}
int ans = norm(mul(a[left], getNSum(fn, first, left)) -
getNSum(fnW, first, left));
ans = norm(ans + norm(getNSum(fnW, left, second) -
mul(a[left], getNSum(fn, left, second))));
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
const int P = (1 << 18);
const int MAXP = 2 * P + 10;
const int MOD = 1e9 + 7;
namespace IO {
const int BUFFER_SIZE = 4096;
const int NUMBER_BUFFER = 100;
FILE *input_stream = stdin;
FILE *output_stream = stdout;
char input_buffer[BUFFER_SIZE];
int input_pos = BUFFER_SIZE;
int input_read = BUFFER_SIZE;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
char number_buffer[NUMBER_BUFFER];
void init(const char *input_file, const char *output_file) {
input_stream = fopen(input_file, "r");
output_stream = fopen(output_file, "w");
}
void _update_input_buffer() {
if (input_pos >= input_read && input_read == BUFFER_SIZE) {
input_read = fread(input_buffer, sizeof(char), BUFFER_SIZE, input_stream);
input_pos = 0;
}
}
char next_char(bool advance = true) {
_update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
bool on_whitespace() { return isspace(next_char(false)); }
bool on_digit() { return isdigit(next_char(false)); }
void skip_whitespace() {
while (on_whitespace()) next_char();
}
bool input_finished() {
skip_whitespace();
return input_pos >= input_read && input_read < BUFFER_SIZE;
}
template <typename T>
void read_int(T &number) {
skip_whitespace();
bool negative = next_char(false) == '-';
if (negative) next_char();
number = 0;
while (on_digit()) number = 10 * number + (next_char() - '0');
if (negative) number = -number;
}
void flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, output_stream);
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;
}
int length = 0;
do {
number_buffer[length++] = number % 10 + '0';
number /= 10;
} while (number > 0);
for (int i = length - 1; i >= 0; i--) write_char(number_buffer[i]);
if (after) write_char(after);
}
struct Dummy {
~Dummy() { flush_output(); }
} dummy;
} // namespace IO
int N, Q;
long long a[MAXN];
long long w[MAXN];
long long wseg[MAXP], waseg[MAXP];
void upd(long long *seg, int cloc, long long cdiff, bool mmod) {
cloc += P;
while (cloc) {
seg[cloc] += cdiff;
if (mmod && seg[cloc] >= MOD) seg[cloc] -= MOD;
cloc /= 2;
}
}
long long add(long long *seg, int cloc, bool mmod) {
long long res = 0;
cloc += P;
while (cloc > 1) {
if (cloc & 1) res += seg[cloc - 1];
cloc /= 2;
}
if (mmod) res %= MOD;
return res;
}
int wsearch(long long sgoal) {
int cloc = 1;
while (cloc < P) {
if (wseg[2 * cloc] >= sgoal)
cloc *= 2;
else {
sgoal -= wseg[2 * cloc];
cloc *= 2;
cloc++;
}
}
return cloc - P;
}
int findm(int lo, int hi) {
long long sleft = add(wseg, lo, 0), sright = add(wseg, hi + 1, 0);
long long sgoal = (sleft + sright + 1) / 2;
return wsearch(sgoal);
}
int main() {
IO::read_int(N);
IO::read_int(Q);
for (int i = 0; i < N; i++) {
int x;
IO::read_int(x);
a[i] = x;
}
for (int i = 0; i < N; i++) {
int x;
IO::read_int(x);
w[i] = x;
}
for (int i = 0; i < N; i++) {
upd(wseg, i, w[i], 0);
upd(waseg, i, ((a[i] - i) * w[i]) % MOD, 1);
}
for (int i = 0; i < Q; i++) {
int l, r;
IO::read_int(l);
IO::read_int(r);
if (l < 0) {
int cloc = -l - 1;
long long cdiff = r - w[cloc];
upd(wseg, cloc, cdiff, 0);
upd(waseg, cloc, ((a[cloc] - cloc) * cdiff) % MOD, 1);
w[cloc] = r;
} else {
l--, r--;
int mm = findm(l, r);
long long ws = add(wseg, mm, 1) - add(wseg, l, 1);
long long was = add(waseg, mm, 1) - add(waseg, l, 1);
long long res = ws * (a[mm] - mm) - was;
r++;
ws = add(wseg, r, 1) - add(wseg, mm, 1);
was = add(waseg, r, 1) - add(waseg, mm, 1);
long long bres = ws * (mm - a[mm]) + was;
res = ((res + bres) % MOD + MOD) % MOD;
IO::write_int((int)res, '\n');
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &first, T2 second) {
if (first > second) first = second;
}
template <typename T1, typename T2>
inline void chkmax(T1 &first, T2 second) {
if (first < second) first = second;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << ' ' << _p.second;
return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) {
return _out;
}
_out << _v.front();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
const int N = 1 << 19;
const int p = 1e9 + 7;
struct seg_tree_no_mod {
long long t[N * 2 + 1];
void change(int i, long long v) {
i += N;
while (i > 0) {
t[i] += v;
i >>= 1;
}
}
long long k;
long long gets(int i, int L, int R, int Ln, int Rn) {
if (Ln <= L && R <= Rn) {
return t[i];
}
if (Rn <= L || R <= Ln) {
return 0;
}
int M = (L + R) >> 1;
return gets(i * 2, L, M, Ln, Rn) + gets(i * 2 + 1, M, R, Ln, Rn);
}
int get(int i, int L, int R, int Ln, int Rn) {
if (R <= Ln || Rn <= L) return -1;
if (Ln <= L && R <= Rn) {
if (k > t[i]) {
k -= t[i];
return -1;
}
}
if (L + 1 == R) {
return i - N;
}
int M = (L + R) >> 1;
int ans = get(i * 2, L, M, Ln, Rn);
if (ans != -1) return ans;
return get(i * 2 + 1, M, R, Ln, Rn);
}
int get(int L, int R, long long _k) {
k = _k;
return get(1, 0, N, L, R);
}
} box;
int sum(int a, int b) {
a += b;
return a < p ? a : a - p;
}
int mul(long long a, int b) { return a * b % p; }
struct seg_tree_with_mod {
int t[N * 2 + 1];
void change(int i, int v) {
i += N;
while (i > 0) {
t[i] = sum(t[i], v);
i >>= 1;
}
}
int gets(int i, int L, int R, int Ln, int Rn) {
if (Ln <= L && R <= Rn) {
return t[i];
}
if (Rn <= L || R <= Ln) {
return 0;
}
int M = (L + R) >> 1;
return sum(gets(i * 2, L, M, Ln, Rn), gets(i * 2 + 1, M, R, Ln, Rn));
}
} sumx[2];
const int RN = 1e9;
int n, m;
int a[N];
int w[N];
int main() {
ios::sync_with_stdio(0);
srand(time(0));
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> w[i];
box.change(i, w[i]);
sumx[0].change(i, mul(a[i] - i, w[i]));
sumx[1].change(i, mul(RN + i + 1 - n - a[i], w[i]));
}
for (int i = 0; i < m; ++i) {
int L, R;
cin >> L >> R;
if (L < 0) {
L = -L - 1;
int k = sum(R, p - w[L]);
box.change(L, R - w[L]);
sumx[0].change(L, mul(a[L] - L, k));
sumx[1].change(L, mul(RN + L + 1 - n - a[L], k));
w[L] = R;
} else {
--L;
long long s = box.gets(1, 0, N, L, R);
long long half = (s + 1) / 2;
int M = box.get(L, R, half);
long long sumL = half - box.k;
long long sumR = s - sumL - w[M];
long long wL = M - L >= 1 ? sumx[0].gets(1, 0, N, L, M) : 0;
long long wR = R - M - 1 >= 1 ? sumx[1].gets(1, 0, N, M + 1, R) : 0;
int coorL = a[M] + L - M, coorR = a[M] + R - M - 1;
int curL = L, curR = RN + R + 1 - n - 1;
int ans = sum(mul(sumL % p, sum(coorL, p - curL)), p - wL);
if (M - L < 1) ans = 0;
auto last = ans;
if (R - M - 1 >= 1)
ans = sum(ans, sum(mul(sumR % p, sum(curR, p - coorR)), p - wR));
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, mod = 1e9 + 7;
int n, m, k, t, a[maxn], w[maxn], lg[maxn];
long long d[2][maxn];
void add(long long d[], int x, int y, bool isMOD) {
if (isMOD && y >= mod) y -= mod;
while (x <= n) {
d[x] += y;
if (isMOD && d[x] >= mod) d[x] -= mod;
x += x & (-x);
}
}
long long get(long long d[], int x, bool isMOD) {
long long ret = 0;
while (x) {
ret += d[x];
if (isMOD && d[x] >= mod) d[x] -= mod;
x -= x & (-x);
}
return ret;
}
int main() {
int i, j;
int q;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] -= i;
lg[i] = 1 + lg[i >> 1];
}
for (i = 1; i <= n; i++) {
scanf("%d", &w[i]);
add(d[0], i, w[i], false);
add(d[1], i, 1LL * a[i] * w[i] % mod, true);
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0) {
l *= -1;
add(d[0], l, -w[l] + r, false);
add(d[1], l, 1LL * a[l] * (r - w[l]) % mod + mod, true);
w[l] = r;
} else {
int pos = 0;
long long now = 0;
long long sum = (get(d[0], r, false) + get(d[0], l - 1, false)) / 2;
for (i = lg[r] - 1; i >= 0; i--) {
if (pos + (1 << i) <= n && now + d[0][pos + (1 << i)] <= sum)
pos += (1 << i), now += d[0][pos];
}
pos = max(l, min(pos + 1, r));
long long ret = 0;
ret += (get(d[0], pos, false) - get(d[0], l - 1, false)) % mod * a[pos] %
mod;
ret -= get(d[1], pos, true) - get(d[1], l - 1, true);
ret += get(d[1], r, true) - get(d[1], pos - 1, true);
ret -= (get(d[0], r, false) - get(d[0], pos - 1, false)) % mod * a[pos] %
mod;
ret = (ret % mod + mod) % mod;
printf("%lld\n", ret);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void addm(long long& a, const long long& b, const long long& mod) {
a += b;
while (a < 0) a += mod;
while (a >= mod) a -= mod;
}
const long long mod = 1e9 + 7;
class fenwick_tree {
long long mymod;
int n;
vector<long long> v;
public:
fenwick_tree(int _n, long long _mod)
: n(_n), mymod(_mod), v(vector<long long>(n + 2, 0)) {}
void add(int in, long long val) {
for (; in < n; in = in | (in + 1)) addm(v[in], val, mymod);
}
long long sum(int r) {
long long rval = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) addm(rval, v[r], mymod);
return rval;
}
long long sum(int l, int r) {
if (r < l) return 0;
long long res = sum(r);
addm(res, -(!l ? 0 : sum(l - 1)), mymod);
return res;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<long long> a(n), w(n);
for (int i = 0; i < n; i++) cin >> a[i];
fenwick_tree sum(n, 1e18), wa(n, mod), wi(n, mod);
for (int i = 0; i < n; i++) {
cin >> w[i];
sum.add(i, w[i]);
wa.add(i, (a[i] * w[i]) % mod);
wi.add(i, (i * 1ll * w[i]) % mod);
}
while (q--) {
long long x, y;
cin >> x >> y;
if (x < 0) {
x = -x - 1;
sum.add(x, y - w[x]);
wa.add(x, (((mod + y - w[x]) % mod) * a[x]) % mod);
wi.add(x, (((mod + y - w[x]) % mod) * 1ll * x) % mod);
w[x] = y;
} else {
long long s = sum.sum(--x, --y);
int lo = x, hi = y;
while (lo != hi) {
int mid = (lo + hi) / 2 + 1;
if (sum.sum(x, mid - 1) * 2 <= s)
lo = mid;
else
hi = mid - 1;
}
long long sumwleft = sum.sum(x, lo) % mod;
long long numleft = lo - x + 1;
long long sumawleft = wa.sum(x, lo) % mod;
long long sumwileft = wi.sum(x, lo) % mod;
long long totalsumleft = (a[lo] * sumwleft) % mod - sumawleft -
(((sumwleft * lo) % mod) - sumwileft) % mod;
addm(totalsumleft, 0, mod);
long long sumwright = sum.sum(lo, y) % mod;
long long numright = y - lo + 1;
long long sumawright = wa.sum(lo, y) % mod;
long long sumwiright = wi.sum(lo, y) % mod;
long long totalsumright = sumawright - (a[lo] * sumwright) % mod -
(sumwiright - ((sumwright * lo) % mod)) % mod;
addm(totalsumright, 0, mod);
cout << (totalsumleft + totalsumright) % mod << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1000000007;
struct Segment_Tree {
long long val, s;
} tree[1000100];
int w[200100], a[200100], n, Q, x, y;
void build(int t, int l, int r) {
if (l == r) {
tree[t].val = w[l];
tree[t].s = 1ll * a[l] * w[l] % mod;
return;
}
int mid = (l + r) / 2;
build(t * 2, l, mid);
build(t * 2 + 1, mid + 1, r);
tree[t].val = tree[t * 2].val + tree[t * 2 + 1].val;
tree[t].s = (tree[t * 2].s + tree[t * 2 + 1].s) % mod;
}
void modify(int t, int l, int r, int pos, int val) {
if (l == r) {
w[l] = val;
tree[t].val = w[l];
tree[t].s = 1ll * a[l] * w[l] % mod;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
modify(t * 2, l, mid, pos, val);
else
modify(t * 2 + 1, mid + 1, r, pos, val);
tree[t].val = tree[t * 2].val + tree[t * 2 + 1].val;
tree[t].s = (tree[t * 2].s + tree[t * 2 + 1].s) % mod;
}
long long queryval(int t, int l, int r, int L, int R) {
if (L > r || l > R) return 0ll;
if (L <= l && r <= R) return tree[t].val;
int mid = (l + r) / 2;
return queryval(t * 2, l, mid, L, R) + queryval(t * 2 + 1, mid + 1, r, L, R);
}
long long querys(int t, int l, int r, int L, int R) {
if (L > r || l > R) return 0ll;
if (L <= l && r <= R) return tree[t].s;
int mid = (l + r) / 2;
return (querys(t * 2, l, mid, L, R) + querys(t * 2 + 1, mid + 1, r, L, R)) %
mod;
}
void solve(int l, int r) {
int L = l, R = r, pos;
while (L <= R) {
int mid = (L + R) / 2;
if (queryval(1, 1, n, l, mid) >= queryval(1, 1, n, mid + 1, r))
R = mid - 1, pos = mid;
else
L = mid + 1;
}
long long res = 0;
res = (-1ll * querys(1, 1, n, l, pos) +
queryval(1, 1, n, l, pos) % mod * a[pos] % mod + mod) %
mod;
res = (res - queryval(1, 1, n, pos, r) % mod * a[pos] % mod +
querys(1, 1, n, pos, r) + mod) %
mod;
printf("%lld\n", res);
}
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]);
build(1, 1, n);
while (Q--) {
scanf("%d%d", &x, &y);
if (x < 0)
modify(1, 1, n, -x, y);
else
solve(x, y);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, a[200005], w[200005], t1[200005];
long long t[200005];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = (x + (x << 2) << 1) + (ch ^ 48);
return x * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 ^ 48);
}
void add(int x, int y) {
while (x <= n) t[x] += y, x += x & -x;
}
long long query(int x) {
long long ans = 0;
while (x) ans += t[x], x &= x - 1;
return ans;
}
void Add(int x, int y) {
while (x <= n) t1[x] = (t1[x] + y) % 1000000007, x += x & -x;
}
int Query(int x) {
int ans = 0;
while (x) ans = (ans + t1[x]) % 1000000007, x &= x - 1;
return ans;
}
int main() {
n = read(), q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++)
w[i] = read(), add(i, w[i]),
Add(i, (long long)w[i] * (a[i] - i) % 1000000007);
while (q--) {
int x = read(), y = read();
if (x > 0) {
int l = x, r = y;
long long b = query(l - 1), c = query(r);
while (l < r) {
int mid = l + r >> 1;
long long d = query(mid);
if (d - b < c - d)
l = mid + 1;
else
r = mid;
}
write((((query(l) - b) % 1000000007 * (a[l] - l) - Query(l) +
Query(x - 1) + (c - query(l - 1)) % 1000000007 * (l - a[l]) +
Query(y) - Query(l - 1)) %
1000000007 +
1000000007) %
1000000007),
putchar('\n');
} else
add(-x, y - w[-x]),
Add(-x, (long long)(y - w[-x]) * (a[-x] + x) % 1000000007), w[-x] = y;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
#pragma GCC target("avx,avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
int n;
int q;
vector<long long int> v;
vector<long long int> w;
long long int bit[300002];
void add(int i, long long int x) {
i++;
while (i < 300002) {
bit[i] += x;
i += i & -i;
}
}
long long int sum(int i) {
i++;
long long int r = 0;
while (i) {
r += bit[i];
i -= i & -i;
}
return r;
}
long long int rng(int l, int r) {
long long int sm = sum(r);
if (l) sm -= sum(l - 1);
return sm;
}
long long int pf[300002];
void pf_add(int i, long long int x) {
x %= 1000000007;
x += 1000000007;
x %= 1000000007;
i++;
while (i < 300002) {
pf[i] += x;
if (pf[i] >= 1000000007) pf[i] %= 1000000007;
i += i & -i;
}
}
long long int pf_sum(int i) {
i++;
long long int r = 0;
while (i) {
r += pf[i];
if (r >= 1000000007) r %= 1000000007;
i -= i & -i;
}
return r;
}
long long int sf[300002];
void sf_add(int i, long long int x) {
i++;
x %= 1000000007;
x += 1000000007;
x %= 1000000007;
while (i < 300002) {
sf[i] += x;
if (sf[i] >= 1000000007) sf[i] %= 1000000007;
i += i & -i;
}
}
long long int sf_sum(int i) {
i++;
long long int r = 0;
while (i) {
r += sf[i];
if (r >= 1000000007) r %= 1000000007;
i -= i & -i;
}
return r;
}
int main() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
v.push_back(a);
}
int rngg = n;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
w.push_back(a);
add(i, a);
pf_add(i, -(v[i] + rngg) * a);
sf_add(i, (v[i] - i) * a);
rngg--;
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x *= -1;
x--;
add(x, -w[x]);
pf_add(x, (v[x] + (n - x)) * w[x]);
sf_add(x, -(v[x] - x) * w[x]);
w[x] = y;
add(x, w[x]);
pf_add(x, -(v[x] + (n - x)) * w[x]);
sf_add(x, (v[x] - x) * w[x]);
} else {
int l = x;
int r = y;
l--;
r--;
int mint = l;
int maxt = r;
long long int ALL = (rng(l, r) + 1LL) / 2LL;
while (mint + 1 < maxt) {
int mid = (mint + maxt) / 2;
if (rng(l, mid) >= ALL) {
maxt = mid;
} else {
mint = mid;
}
}
if (rng(l, mint) >= ALL) {
maxt = mint;
} else {
mint = maxt;
}
long long int act = n - mint;
long long int cs1 = (((sum(mint) - sum(l - 1)) % 1000000007) *
(v[mint] + act) % 1000000007) +
((pf_sum(mint) - pf_sum(l - 1)) % 1000000007);
act = mint;
cs1 %= 1000000007;
long long int cs2 = ((sf_sum(r) - sf_sum(mint - 1) % 1000000007)) -
(((sum(r) - sum(mint - 1)) % 1000000007) *
(v[mint] - act) % 1000000007);
cs2 %= 1000000007;
cs1 += cs2;
cs1 %= 1000000007;
cs1 += 1000000007;
cs1 %= 1000000007;
printf("%lld\n", cs1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const int N = 2e5 + 5, MOD = 1e9 + 7;
struct Nod {
i64 sum, st, dr;
int cnt;
};
Nod pom[N * 4];
i64 w[N], pos[N], aib[N];
i64 qval;
int ql, qr, qpos;
int n, q;
static inline int lsb(const int &x) { return x & -x; }
static void aib_update(int pos, i64 val) {
for (; pos < N; pos += lsb(pos)) aib[pos] += val;
}
static i64 aib_query(int pos) {
i64 ant = 0;
for (; pos > 0; pos -= lsb(pos)) ant += aib[pos];
return ant;
}
static int cbin(int l, int r) {
i64 targ = (aib_query(r) - aib_query(l - 1) + 1) / 2 + aib_query(l - 1);
i64 tsum = 0;
int pos = 0;
for (int msk = 1 << 20; msk > 0; msk /= 2)
if (pos + msk < N && tsum + aib[pos + msk] < targ) {
pos += msk;
tsum += aib[pos];
}
return pos + 1;
}
static void update(int nod, int st, int dr) {
if (st == dr) {
pom[nod] = {qval, 0, 0, 1};
return;
}
int mid = (st + dr) / 2;
if (qpos <= mid)
update(2 * nod, st, mid);
else
update(2 * nod + 1, mid + 1, dr);
pom[nod].sum = (pom[2 * nod].sum + pom[2 * nod + 1].sum) % MOD;
pom[nod].cnt = pom[2 * nod].cnt + pom[2 * nod + 1].cnt;
pom[nod].st = pom[2 * nod].st + pom[2 * nod + 1].st;
pom[nod].st +=
(pos[mid + 1] - pos[st] - pom[2 * nod].cnt) * pom[2 * nod + 1].sum;
pom[nod].dr = pom[2 * nod].dr + pom[2 * nod + 1].dr;
pom[nod].dr += (pos[dr] - pos[mid] - pom[2 * nod + 1].cnt) * pom[2 * nod].sum;
pom[nod].st %= MOD, pom[nod].dr %= MOD;
}
static Nod query(int nod, int st, int dr) {
if (ql <= st && dr <= qr) return pom[nod];
Nod me, l = {0, 0, 0, 0}, r = {0, 0, 0, 0};
int mid = (st + dr) / 2, bl = max(ql, st), br = min(qr, dr);
bool fl = false, fr = false;
if (ql <= mid) {
l = query(2 * nod, st, mid);
fl = true;
}
if (mid < qr) {
r = query(2 * nod + 1, mid + 1, dr);
fr = true;
}
if (fl && !fr) return l;
if (fr && !fl) return r;
me.sum = l.sum + r.sum;
me.cnt = l.cnt + r.cnt;
me.st = (l.st + r.st) + r.sum * (pos[mid + 1] - pos[bl] - l.cnt);
me.dr = (l.dr + r.dr) + l.sum * (pos[br] - pos[mid] - r.cnt);
me.st %= MOD, me.dr %= MOD;
return me;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
i64 a, b, ant;
cin >> n >> q;
for (int i = 1; i <= n; ++i) cin >> pos[i];
for (qpos = 1; qpos <= n; ++qpos) {
cin >> w[qpos];
qval = w[qpos];
update(1, 1, n);
aib_update(qpos, qval);
}
while (q--) {
cin >> a >> b;
if (a > 0) {
int p = cbin(a, b);
ql = a, qr = p;
ant = query(1, 1, n).dr;
ql = p, qr = b;
ant += query(1, 1, n).st;
cout << (ant % MOD + MOD) % MOD << '\n';
} else {
a *= -1;
qpos = a;
qval = b;
aib_update(qpos, qval - w[qpos]);
w[qpos] = qval;
update(1, 1, n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
int inp() {
char c = getchar();
int neg = 1;
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * neg;
}
struct SEG {
int l;
int r;
long long sum;
long long ls;
long long rs;
};
long long s[200010], dis[200010];
SEG operator+(SEG a, SEG b) {
SEG ret;
if (a.l == -1) return b;
if (b.l == -1) return a;
ret.sum = a.sum + b.sum;
a.sum %= 1000000007;
b.sum %= 1000000007;
ret.ls = a.ls + b.ls + b.sum * (dis[a.r] - dis[a.l - 1]);
ret.rs = b.rs + a.rs + a.sum * (dis[b.r + 1] - dis[b.l]);
ret.ls %= 1000000007;
ret.rs %= 1000000007;
ret.l = a.l;
ret.r = b.r;
return ret;
}
struct SEG_Tree {
SEG t[800010];
void push_up(int cur) { t[cur] = t[((cur) << 1)] + t[((cur) << 1 | 1)]; }
void build(int cur, int l, int r) {
t[cur].l = l;
t[cur].r = r;
if (l == r) {
t[cur].sum = s[l];
t[cur].ls = s[l] * (dis[l] - dis[l - 1]);
t[cur].rs = s[l] * (dis[l + 1] - dis[l]);
return;
}
int mid = (l + r) >> 1;
build(((cur) << 1), l, mid);
build(((cur) << 1 | 1), mid + 1, r);
push_up(cur);
}
long long query2(int cur, int l, int r) {
if (t[cur].l > r || t[cur].r < l) return 0;
if (t[cur].l >= l && t[cur].r <= r) return t[cur].sum;
return query2(((cur) << 1), l, r) + query2(((cur) << 1 | 1), l, r);
}
SEG query(int cur, int l, int r) {
if (l > r) return (SEG){0, 0, 0, 0, 0};
if (t[cur].l > r || t[cur].r < l) return (SEG){-1, -1, -1, -1, -1};
if (t[cur].l >= l && t[cur].r <= r) return t[cur];
return query(((cur) << 1), l, r) + query(((cur) << 1 | 1), l, r);
}
void modify(int cur, int x, int c) {
if (t[cur].l == t[cur].r) {
t[cur].sum = c;
t[cur].ls = c * (dis[t[cur].l] - dis[t[cur].l - 1]);
t[cur].rs = c * (dis[t[cur].l + 1] - dis[t[cur].l]);
return;
}
if (x <= t[((cur) << 1)].r)
modify(((cur) << 1), x, c);
else
modify(((cur) << 1 | 1), x, c);
push_up(cur);
}
} t;
int solve(int lb, int rb) {
int l = lb;
int r = rb;
while (l < r) {
int mid = (l + r) >> 1;
if (t.query2(1, lb, mid) >= t.query2(1, mid + 1, rb))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
int n = inp();
int q = inp();
for (int i = 1; i <= n; i++) dis[i] = inp() - i;
for (int i = 1; i <= n; i++) s[i] = inp();
t.build(1, 1, n);
while (q--) {
int id = inp();
int c = inp();
if (id < 0) {
t.modify(1, -id, c);
} else {
int pos = solve(id, c);
long long ans = 0;
if (id <= pos - 1) ans += t.query(1, id, pos - 1).rs;
if (pos + 1 <= c) ans += t.query(1, pos + 1, c).ls;
ans %= 1000000007;
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct _Box {
int pos, weight;
} Box;
Box arr[200010];
long long int bit1[200010], bit2[200010];
const int mod = 1e9 + 7;
int num;
int getLowbit(int n) { return n & (-n); }
void add(long long int* bitArr, int pos, long long int val, bool shouldMod) {
if (shouldMod) val = (val + mod) % mod;
for (int i = pos; i <= num; i += getLowbit(i)) {
bitArr[i] += val;
if (shouldMod) bitArr[i] = (bitArr[i] + mod) % mod;
}
}
long long int getPrefixSum(long long int* bitArr, int pos, bool shouldMod) {
long long int ans = 0;
for (int i = pos; i > 0; i -= getLowbit(i)) {
ans += bitArr[i];
if (shouldMod) ans = (ans + mod) % mod;
}
return ans;
}
long long int getRangeSum(long long int* bitArr, int qLeftPt, int qRightPt,
bool shouldMod) {
if (qRightPt < qLeftPt) return 0;
long long int ans = getPrefixSum(bitArr, qRightPt, shouldMod) -
getPrefixSum(bitArr, qLeftPt - 1, shouldMod);
if (shouldMod) ans = (ans + mod) % mod;
return ans;
}
int getMidPos(int qLeftPt, int qRightPt) {
int leftPt = qLeftPt, rightPt = qRightPt;
int ans = rightPt;
while (leftPt <= rightPt) {
int midPt = (leftPt + rightPt) >> 1;
if (getRangeSum(bit1, qLeftPt, midPt, false) >=
getRangeSum(bit1, midPt + 1, qRightPt, false)) {
ans = midPt;
rightPt = midPt - 1;
} else {
leftPt = midPt + 1;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(bit1, 0, sizeof(bit1));
memset(bit2, 0, sizeof(bit2));
int qNum;
cin >> num >> qNum;
for (int i = 1; i <= num; i++) {
cin >> arr[i].pos;
}
for (int i = 1; i <= num; i++) {
cin >> arr[i].weight;
add(bit1, i, arr[i].weight, false);
add(bit2, i, (long long int)arr[i].weight * (arr[i].pos - i), true);
}
while (qNum--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
add(bit1, x, y - arr[x].weight, false);
add(bit2, x, ((long long int)y - arr[x].weight) * (arr[x].pos - x), true);
arr[x].weight = y;
} else {
if (x == y) {
cout << 0 << endl;
continue;
}
int midPos = getMidPos(x, y);
long long int leftAns = (getRangeSum(bit1, x, midPos, true) *
abs(arr[midPos].pos - midPos) % mod -
getRangeSum(bit2, x, midPos, true) + mod) %
mod;
long long int rightAns = (getRangeSum(bit1, midPos, y, true) *
abs(arr[midPos].pos - midPos) % mod -
getRangeSum(bit2, midPos, y, true) + mod) %
mod;
long long int ans = (leftAns - rightAns + mod) % mod;
cout << ans << endl;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.