text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 7;
const long long MOD = 1000 * 1000 * 1000 + 7;
long long mod(long long n) { return (n % MOD + MOD) % MOD; }
long long n, q;
long long a[MAXN], w[MAXN];
void read() {
cin >> n >> q;
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) cin >> w[i];
}
long long f[MAXN], f1[MAXN];
void add_(long long i, long long x) {
for (; i < MAXN; i |= (i + 1)) {
f[i] += x;
}
}
long long getpr_(long long i) {
long long ans = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
ans += f[i];
}
return ans;
}
long long get_(long long l, long long r) { return getpr_(r) - getpr_(l - 1); }
void add1_(long long i, long long x) {
long long t = x * (i - a[i]);
for (; i < MAXN; i |= (i + 1)) {
f1[i] += t;
f1[i] = mod(f1[i]);
}
}
long long getpr1_(long long i) {
long long ans = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
ans += f1[i];
}
return ans;
}
long long get1_(long long l, long long r) {
return mod(getpr1_(r) - getpr1_(l - 1));
}
long long p[MAXN];
void solve() {
for (long long i = 0; i < n; ++i) add_(i, w[i]);
for (long long i = 0; i < n; ++i) add1_(i, w[i]);
for (long long i = 0; i < n; ++i) p[i] = a[i] - i;
}
void upd(long long i, long long x) {
long long delt = x - w[i];
add_(i, delt);
add1_(i, delt);
w[i] = x;
}
long long getl(long long l, long long r) {
long long bl = a[l] - 1;
long long br = a[r] - (r - l) + 1;
long long sum = get_(l, r);
while (bl < br - 1) {
long long bm = (bl + br) / 2;
auto t = upper_bound(p + l, p + r + 1, bm - l);
long long sum1 = get_(t - p, r);
if (sum < sum1 * 2)
bl = bm;
else
br = bm;
}
return br;
}
long long getans(long long l, long long r, long long tl) {
auto t = upper_bound(p + l, p + r + 1, tl - l);
long long bl = t - p - 1;
long long ans = 0;
ans += mod(mod(get_(l, bl)) * (tl - l)) + get1_(l, bl);
ans -= mod(mod(get_(bl + 1, r)) * (tl - l)) + get1_(bl + 1, r);
return mod(ans);
}
long long get(long long l, long long r) {
long long tl = getl(l, r);
return getans(l, r, tl);
}
void print() {
for (long long i = 0; i < q; ++i) {
long long x, y;
cin >> x >> y;
if (x < 0) {
upd(-x - 1, y);
} else {
cout << get(x - 1, y - 1) << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
read();
solve();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long tx[1 << 19], t[1 << 19];
struct SegtreeMOD {
int n, h;
SegtreeMOD() {}
SegtreeMOD(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
}
void assign(int x, long long v) {
x += n;
tx[x] = v % MOD;
for (x /= 2; x; x /= 2) {
tx[x] = (tx[x << 1] + tx[x << 1 | 1]);
if (tx[x] >= MOD) {
tx[x] -= 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 += tx[l++];
}
if (r % 2) {
ans += tx[--r];
}
}
return ans % MOD;
}
};
struct Segtree {
int n, h;
Segtree() {}
Segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
}
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) * 2 - wtot) % MOD) * a[med] -
wx.query(l, med) + wx.query(med, r + 1);
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;
template <int MOD_>
struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0) v += MOD;
}
explicit operator int() const { return v; }
friend std::ostream& operator<<(std::ostream& out, const modnum& n) {
return out << int(n);
}
friend bool operator==(const modnum& a, const modnum& b) {
return a.v == b.v;
}
friend bool operator!=(const modnum& a, const modnum& b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return modnum(*this); }
modnum& operator++() {
v++;
if (v == MOD) v = 0;
return *this;
}
modnum& operator--() {
if (v == 0) v = MOD;
v--;
return *this;
}
modnum& operator+=(const modnum& o) {
v += o.v;
if (v >= MOD) v -= MOD;
return *this;
}
modnum& operator-=(const modnum& o) {
v -= o.v;
if (v < 0) v += MOD;
return *this;
}
modnum& operator*=(const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum& operator/=(const modnum& o) { return *this *= o.inv(); }
friend modnum operator++(modnum& a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum& a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum& a, const modnum& b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum& a, const modnum& b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum& a, const modnum& b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum& a, const modnum& b) {
return modnum(a) /= b;
}
};
using num = modnum<int(1e9) + 7>;
using ll = long long;
const int S = (1 << 18);
struct seg_node {
ll sum_w;
num sum_aw;
} seg[2 * S];
const int MAXN = 2.1e5;
int N;
int A[MAXN];
void recalc(int i) {
assert(1 <= i && i < S);
int l = 2 * i, r = 2 * i + 1;
seg[i].sum_w = seg[l].sum_w + seg[r].sum_w;
seg[i].sum_aw = seg[l].sum_aw + seg[r].sum_aw;
}
void update(int i, int nw) {
assert(0 <= i && i <= N - 1);
seg[S + i].sum_w = nw;
seg[S + i].sum_aw = num(ll(A[i]) * nw);
for (int a = (S + i) / 2; a; a /= 2) {
recalc(a);
}
}
seg_node get_sum(int l, int r) {
seg_node res{0, 0};
for (l += S, r += S; l < r; l /= 2, r /= 2) {
if (l & 1) {
res.sum_w += seg[l].sum_w;
res.sum_aw += seg[l].sum_aw;
l++;
}
if (r & 1) {
r--;
res.sum_w += seg[r].sum_w;
res.sum_aw += seg[r].sum_aw;
}
}
return res;
}
num solve(int l, int r) {
assert(0 <= l && l <= r && r <= N - 1);
r++;
assert(0 <= l && l < r && r <= N);
ll pl = get_sum(0, l).sum_w;
ll pr = get_sum(0, r).sum_w;
assert(pl < pr);
ll pm = (pl + pr) / 2;
assert(pl <= pm && pm < pr);
int m = 1;
while (m < S) {
assert(seg[m].sum_w > pm);
int ml = 2 * m;
if (seg[ml].sum_w > pm) {
m = ml;
} else {
pm -= seg[ml].sum_w;
m = ml + 1;
}
}
m -= S;
assert(l <= m && m < r);
seg_node sl = get_sum(l, m);
seg_node sr = get_sum(m, r);
return (num(A[m]) * num(sl.sum_w) - sl.sum_aw) +
(sr.sum_aw - num(A[m]) * num(sr.sum_w));
}
int Q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> Q;
for (int i = 0; i < N; i++) {
cin >> A[i];
A[i] -= i;
}
for (int i = 0; i < N; i++) {
int w;
cin >> w;
seg[S + i].sum_w = w;
seg[S + i].sum_aw = num(ll(A[i]) * w);
}
for (int i = S - 1; i > 0; i--) {
recalc(i);
}
for (int q = 0; q < Q; q++) {
int x, y;
cin >> x >> y;
if (x < 0) {
int i = abs(x);
i--;
int nw = y;
update(i, nw);
} else {
x--, y--;
cout << solve(x, 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;
}
}
if (k > left) {
cout << "OI" << endl;
k--;
}
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;
const int N = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double PI = acos(-1);
template <class T, class S>
inline void add(T& a, S b) {
a += b;
if (a >= mod) a -= mod;
}
template <class T, class S>
inline void sub(T& a, S b) {
a -= b;
if (a < 0) a += mod;
}
template <class T, class S>
inline bool chkmax(T& a, S b) {
return a < b ? a = b, true : false;
}
template <class T, class S>
inline bool chkmin(T& a, S b) {
return a > b ? a = b, true : false;
}
int n, q, a[N], w[N];
struct Bit {
long long a[N];
void modify(int x, int v) {
for (int i = x; i <= n; i += i & -i) a[i] += v;
}
long long sum(int x) {
long long ans = 0;
for (int i = x; i; i -= i & -i) ans += a[i];
return ans;
}
long long query(int L, int R) {
if (L > R) return 0;
return sum(R) - sum(L - 1);
}
} bit;
struct Bit2 {
int a[N];
void modify(int x, int v) {
for (int i = x; i <= n; i += i & -i) add(a[i], v);
}
int sum(int x) {
long long ans = 0;
for (int i = x; i; i -= i & -i) add(ans, a[i]);
return ans;
}
int query(int L, int R) {
if (L > R) return 0;
return (sum(R) - sum(L - 1) + mod) % mod;
}
} prefix, suffix;
int main() {
long long ret = 0;
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]);
for (int i = 1; i <= n; i++) {
bit.modify(i, w[i]);
prefix.modify(i, 1LL * abs(a[i] - a[1] - i + 1) * w[i] % mod);
}
for (int i = n; i >= 1; i--)
suffix.modify(i, 1LL * abs(a[n] - a[i] - n + i) * w[i] % mod);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
bit.modify(x, -w[x]);
prefix.modify(x, mod - (1LL * abs(a[x] - a[1] - x + 1) * w[x] % mod));
suffix.modify(x, mod - (1LL * abs(a[n] - a[x] - n + x) * w[x] % mod));
w[x] = y;
bit.modify(x, w[x]);
prefix.modify(x, 1LL * abs(a[x] - a[1] - x + 1) * w[x] % mod);
suffix.modify(x, 1LL * abs(a[n] - a[x] - n + x) * w[x] % mod);
} else {
int len = y - x + 1;
int low = a[x], high = a[y], p = low, low2, high2, p2, fen;
while (low <= high) {
int mid = low + high >> 1;
low2 = x, high2 = y, p2 = y + 1;
while (low2 <= high2) {
int mid2 = low2 + high2 >> 1;
if (a[mid2] > mid + mid2 - x)
p2 = mid2, high2 = mid2 - 1;
else
low2 = mid2 + 1;
}
long long valL = bit.query(x, p2 - 1);
long long valR = bit.query(p2, y);
if (valL > valR)
p = mid, high = mid - 1, fen = p2;
else
low = mid + 1;
}
long long ans = 0;
if (fen <= y) {
add(ans, prefix.query(fen, y));
sub(ans, bit.query(fen, y) % mod * (p - (a[1] + x - 1)) % mod);
}
if (fen - 1 >= x) {
add(ans, suffix.query(x, fen - 1));
sub(ans, bit.query(x, fen - 1) % mod * (a[n] - (n - x) - p) % mod);
}
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const long long maxn = 200005, mod = 1e9 + 7;
long long n, m, a[maxn], w[maxn], x, y;
namespace {
inline long long Add(const long long &x, const long long &y) {
return (x + y) % mod;
}
inline long long Sub(const long long &x, const long long &y) {
return ((x - y) % mod + mod) % mod;
}
inline long long Mul(const long long &x, const long long &y) {
return 1ll * x * y % mod;
}
} // namespace
namespace Segtree {
long long sq[maxn << 2];
long long sum[maxn << 2];
inline void Build(long long o, long long l, long long r) {
if (l == r) {
sq[o] = Mul(a[l], w[l]), sum[o] = w[l];
return;
}
Build(o << 1, l, ((l + r) >> 1)), Build(o << 1 | 1, ((l + r) >> 1) + 1, r);
sq[o] = Add(sq[o << 1], sq[o << 1 | 1]),
sum[o] = sum[o << 1] + sum[o << 1 | 1];
}
inline void Modify(long long o, long long l, long long r, long long x,
long long y) {
if (l == r) {
sq[o] = Mul(a[l], y), sum[o] = y;
return;
}
if (x <= ((l + r) >> 1))
Modify(o << 1, l, ((l + r) >> 1), x, y);
else
Modify(o << 1 | 1, ((l + r) >> 1) + 1, r, x, y);
sq[o] = Add(sq[o << 1], sq[o << 1 | 1]),
sum[o] = sum[o << 1] + sum[o << 1 | 1];
}
inline long long Querys(long long o, long long l, long long r, long long ql,
long long qr) {
if (ql <= l && r <= qr) return sq[o];
long long res = 0;
if (ql <= ((l + r) >> 1))
res = Add(res, Querys(o << 1, l, ((l + r) >> 1), ql, qr));
if (qr > ((l + r) >> 1))
res = Add(res, Querys(o << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr));
return res;
}
inline long long Querya(long long o, long long l, long long r, long long ql,
long long qr) {
if (ql <= l && r <= qr) return sum[o];
long long res = 0;
if (ql <= ((l + r) >> 1)) res += Querya(o << 1, l, ((l + r) >> 1), ql, qr);
if (qr > ((l + r) >> 1))
res += Querya(o << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr);
return res;
}
inline void Printa(long long o, long long l, long long r) {
cout << "Interval:" << l << " -> " << r << " Sum:" << sum[o] << endl;
if (l == r) return;
Printa(o << 1, l, ((l + r) >> 1)), Printa(o << 1 | 1, ((l + r) >> 1) + 1, r);
}
} // namespace Segtree
signed main() {
read(n), read(m);
for (long long i = 1; i <= n; ++i) read(a[i]), a[i] -= i;
for (long long i = 1; i <= n; ++i) read(w[i]);
Segtree::Build(1, 1, n);
while (m--) {
read(x), read(y);
if (x < 0)
Segtree::Modify(1, 1, n, -x, y);
else {
long long tot = Segtree::Querya(1, 1, n, x, y);
tot = (tot + 1) >> 1;
long long l = x, r = n, md;
while (l < r) {
md = (l + r) >> 1;
if (Segtree::Querya(1, 1, n, x, md) < tot)
l = md + 1;
else
r = md;
}
long long p = l;
printf("%lld\n",
Add(Sub(Mul(Segtree::Querya(1, 1, n, x, p) % mod, a[p]),
Segtree::Querys(1, 1, n, x, p)),
Sub(Segtree::Querys(1, 1, n, p + 1, y),
Mul(Segtree::Querya(1, 1, n, p + 1, y) % mod, a[p]))));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int P = 1e9 + 7;
int n, m, a[maxn], w[maxn];
inline int read() {
char ch = getchar();
int u = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
u = u * 10 + ch - 48;
ch = getchar();
}
return u * f;
}
inline int pls(int x, int y) {
x += y;
return x >= P ? x - P : x;
}
inline int dec(int x, int y) {
x -= y;
return x < 0 ? x + P : x;
}
inline int mul(int x, int y) {
long long rnt = 1ll * x * y;
return (int)(rnt >= P ? rnt % P : rnt);
}
struct BIT {
long long C[maxn];
inline void modify(int p, int x) {
while (p <= n) {
C[p] += x;
p += (-p & p);
}
}
inline long long query(int p) {
long long rnt = 0;
while (p) {
rnt += C[p];
p -= (-p & p);
}
return rnt;
}
} T;
struct _BIT {
int C[maxn];
inline void modify(int p, int x) {
while (p <= n) {
C[p] = pls(C[p], x);
p += (-p & p);
}
}
inline int query(int p) {
int rnt = 0;
while (p) {
rnt = pls(rnt, C[p]);
p -= (-p & p);
}
return rnt;
}
} T0;
inline int getpos(int l, int r) {
long long S = T.query(r) - T.query(l - 1), tmp = 0;
int mid = (l + r) / 2, ans = 0, L = l;
while (l <= r) {
mid = (l + r) / 2;
tmp = T.query(mid) - T.query(L - 1);
if (tmp * 2 >= S)
r = mid - 1, ans = mid;
else
l = mid + 1;
}
return ans;
}
int main() {
n = read();
m = read();
for (register int i = 1; i <= n; i++) a[i] = read() - i;
for (register int i = 1; i <= n; i++) {
w[i] = read();
T.modify(i, w[i]);
T0.modify(i, mul(a[i], w[i]));
}
for (register int i = 1; i <= m; i++) {
int l = read(), r = read();
if (l < 0) {
T.modify(-l, r - w[-l]);
T0.modify(-l, dec(mul(a[-l], r), mul(a[-l], w[-l])));
w[-l] = r;
} else {
int pos = getpos(l, r);
int S0 = (T.query(pos) - T.query(l - 1) + P) % P;
int S1 = (T.query(r) - T.query(pos) + P) % P;
int P1 = dec(mul(S0, a[pos]), dec(T0.query(pos), T0.query(l - 1)));
int P2 = dec(dec(T0.query(r), T0.query(pos)), mul(S1, a[pos]));
printf("%d\n", pls(P1, P2));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
inline long long read() {
long long t = 0, dp = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') dp = -1;
c = getchar();
}
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
return t * dp;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void write_p(long long x) {
write(x);
putchar(' ');
}
long long mo = 1e9 + 7;
const int N = 200005;
long long n, que, a[N], w[N], tr1[N], tr2[N];
inline long long Ask1(long long x) {
long long sum = 0;
for (; x; x -= x & -x) sum = (sum + tr1[x] + mo) % mo;
return sum;
}
inline long long Ask2(long long x) {
long long sum = 0;
for (; x; x -= x & -x) sum += tr2[x];
return sum;
}
inline void Insert1(long long x, long long v) {
for (; x <= n; x += x & -x) tr1[x] = (tr1[x] + v % mo + mo) % mo;
}
inline void Insert2(long long x, long long v) {
for (; x <= n; x += x & -x) tr2[x] += v;
}
inline long long Query1(long long l, long long r) {
return (Ask1(r) - Ask1(l - 1) + mo) % mo;
}
inline long long Query2(long long l, long long r) {
return Ask2(r) - Ask2(l - 1);
}
inline bool check(long long l, long long r, long long mid) {
long long t1 = Query2(l, mid), t2 = Query2(mid + 1, r);
return t1 >= t2;
}
int main() {
n = read();
que = read();
for (int i = 1; i <= n; ++i) a[i] = read() - i + 1;
for (int i = 1; i <= n; ++i) w[i] = read();
for (int i = 1; i <= n; ++i) Insert1(i, a[i] * w[i] % mo), Insert2(i, w[i]);
for (int i = 1; i <= que; ++i) {
long long ql = read(), qr = read();
if (ql > 0) {
long long l = ql, r = qr, ans = r;
while (l <= r) {
long long mid = l + r >> 1;
if (check(ql, qr, mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
long long ANS =
(Query2(ql, ans) % mo * a[ans] % mo - Query1(ql, ans)) % mo;
ANS +=
(-Query2(ans + 1, qr) % mo * a[ans] % mo + Query1(ans + 1, qr) % mo) %
mo;
ANS = (ANS % mo + mo) % mo;
writeln(ANS);
} else {
ql = -ql;
Insert1(ql, a[ql] * (qr - w[ql]) % mo);
Insert2(ql, (qr - w[ql]));
w[ql] = qr;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int read() {
char ch;
bool flag = 0;
int res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10 + ch - '0')
;
(flag) && (res = -res);
return res;
}
char sr[1 << 21], z[20];
int C = -1, Z;
inline void Ot() { fwrite(sr, 1, C + 1, stdout), C = -1; }
inline void print(int x) {
if (C > 1 << 20) Ot();
if (x < 0) sr[++C] = 45, x = -x;
while (z[++Z] = x % 10 + 48, x /= 10)
;
while (sr[++C] = z[Z], --Z)
;
sr[++C] = '\n';
}
const int N = 2e5 + 5;
const long long P = 1e9 + 7;
int n, q;
long long a[N], w[N];
namespace SUM {
long long c[N];
inline void add(int x, long long y) {
for (; x <= n; x += x & -x) c[x] += y;
}
inline long long que(int x) {
long long res = 0;
for (; x; x -= x & -x) res += c[x];
return res;
}
inline long long query(int l, int r) {
if (r < l) return 0;
return que(r) - que(l - 1);
}
} // namespace SUM
namespace MUL {
long long c[N];
inline void add(int x, long long y) {
y %= P;
for (; x <= n; x += x & -x) (c[x] += y + P) %= P;
}
inline long long que(int x) {
long long res = 0;
for (; x; x -= x & -x) (res += c[x]) %= P;
return res;
}
inline long long query(int l, int r) {
if (r < l) return 0;
return (que(r) - que(l - 1) + P) % P;
}
} // namespace MUL
inline int getpos(int ql, int qr) {
int l = ql, r = qr, mid, res;
while (l <= r) {
mid = (l + r) >> 1;
if (SUM::query(ql, mid) >= SUM::query(mid + 1, qr))
res = mid, r = mid - 1;
else
l = mid + 1;
}
return res;
}
void solve(int l, int r) {
if (l == r) return (void)(print(0));
int pos = getpos(l, r);
long long res = 0;
res = (-MUL::query(l, pos) + (SUM::query(l, pos) % P) * (a[pos] - pos) % P +
P) %
P;
res = (res + MUL::query(pos, r) -
SUM::query(pos, r) % P * (a[pos] - pos) % P + P) %
P;
print(res);
}
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, w[i] * (a[i] - i));
}
while (q--) {
int x = read(), y = read();
if (x < 0) {
x = -x, SUM::add(x, -w[x]), MUL::add(x, -w[x] * (a[x] - x));
w[x] = y, SUM::add(x, y), MUL::add(x, y * (a[x] - x));
} else
solve(x, y);
}
Ot();
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], 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>
using namespace std;
long long inline read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const long long maxn = 200010, mod = 1e9 + 7, M = 1e9;
long long n, q, a[maxn], w[maxn];
struct BIT {
long long sum[maxn];
void update(long long x, long long k, long long op) {
for (long long i = x; i <= n; i += i & (-i)) {
sum[i] = sum[i] + k;
if (op) sum[i] %= mod;
}
}
long long Query(long long x, long long op) {
long long ans = 0;
for (long long i = x; i; i -= i & (-i)) {
ans = ans + sum[i];
if (op) ans %= mod;
}
return ans;
}
long long Q(long long l, long long r, long long op) {
long long ans = Query(r, op) - Query(l - 1, op);
if (op) ans = (ans + mod) % mod;
return ans;
}
} sum, cnt;
signed main() {
n = read();
q = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) w[i] = read();
for (long long i = 1; i <= n; i++)
sum.update(i, w[i], 0), cnt.update(i, (a[i] - i) * w[i], 1);
for (long long i = 1; i <= q; i++) {
long long l = read(), r = read();
if (l <= 0) {
l = -l;
sum.update(l, -w[l], 0);
cnt.update(l, -(a[l] - l) * w[l], 1);
w[l] = r;
sum.update(l, w[l], 0);
cnt.update(l, (a[l] - l) * w[l], 1);
} else {
if (l == r) {
cout << 0 << endl;
continue;
}
long long L = l, R = r, ans = 0, res;
while (L <= R) {
long long mid = L + R >> 1;
if (sum.Q(l, mid, 0) >= sum.Q(mid + 1, r, 0))
res = mid, R = mid - 1;
else
L = mid + 1;
}
L = res;
ans = (sum.Q(l, L, 1) % mod * (a[L] - L) % mod - cnt.Q(l, L, 1) % mod +
mod) %
mod;
ans = ((ans + cnt.Q(L, r, 1) % mod) % mod -
sum.Q(L, r, 1) % mod * (a[L] - L) % mod + mod) %
mod;
cout << (ans + mod) % mod << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
const int maxn = 2e5 + 5, md = 1e9 + 7;
int pos[maxn], wei[maxn];
struct Fenwick_Tree {
long long c[maxn];
void add(int p, int x) {
for (; p <= n; p += p & (-p)) c[p] = (c[p] + x);
}
long long s(int p) {
long long result = 0;
for (; p; p -= p & (-p)) result = (result + c[p]);
return result;
}
long long s2(int p) {
long long result = 0;
for (; p; p -= p & (-p)) result = (result + c[p]) % md;
return result;
}
} tr, tr2;
signed main() {
scanf("%d%d", &n, &q);
for (int i = (1); i <= (n); ++i) scanf("%d", pos + i), pos[i] = (pos[i] - i);
for (int i = (1); i <= (n); ++i) {
scanf("%d", wei + i);
tr.add(i, wei[i]);
tr2.add(i, 1ll * wei[i] * pos[i] % md);
}
long long ans = 0;
for (int i = (1); i <= (q); ++i) {
int a, b;
scanf("%d%d", &a, &b);
if (a < 0) {
a = -a;
tr.add(a, -wei[a]);
tr2.add(a, -1ll * wei[a] * pos[a] % md);
tr.add(a, b);
tr2.add(a, b * 1ll * pos[a] % md);
wei[a] = b;
} else {
int l = a - 1, r = b, mid;
while (r - l > 1) {
mid = (l + r) >> 1;
if (tr.s(mid) - tr.s(a - 1) < tr.s(b) - tr.s(mid)) {
l = mid;
} else {
r = mid;
}
}
ans = 1ll * (tr.s2(r) - tr.s2(a - 1) - (tr.s2(b) - tr.s2(r - 1))) % md *
pos[r] % md;
ans %= md;
ans +=
(tr2.s2(b) - tr2.s2(r - 1)) % md - (tr2.s2(r) - tr2.s2(a - 1)) % md;
ans %= md;
ans = (ans + md) % md;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, q, t1[800000];
long long w[800000], a[800000], t2[800000];
void build(int left, int right, int p) {
if (left == right) {
t1[p] = w[left];
t2[p] = w[left] * (left - a[left]);
t2[p] %= 1000000007;
return;
}
int mid = (left + right) >> 1;
build(left, mid, p * 2);
build(mid + 1, right, p * 2 + 1);
t1[p] = t1[p * 2] + t1[p * 2 + 1];
t2[p] = t2[p * 2] + t2[p * 2 + 1];
t2[p] %= 1000000007;
}
void update1(int left, int right, int q, int p, long long c) {
if (left > q || right < q) {
return;
}
if (left == right) {
t1[p] += c;
return;
}
int mid = (left + right) >> 1;
update1(left, mid, q, p * 2, c);
update1(mid + 1, right, q, p * 2 + 1, c);
t1[p] = t1[p * 2] + t1[p * 2 + 1];
}
void update2(int left, int right, long long q, int p, long long c) {
if (left > q || right < q) {
return;
}
if (left == right) {
t2[p] += c * (q - a[q]);
t2[p] %= 1000000007;
return;
}
int mid = (left + right) >> 1;
update2(left, mid, q, p * 2, c);
update2(mid + 1, right, q, p * 2 + 1, c);
t2[p] = t2[p * 2] + t2[p * 2 + 1];
t2[p] %= 1000000007;
}
long long query1(int left, int right, int ql, int qr, int p) {
if (left >= ql && right <= qr) {
return t1[p];
}
if (left > qr || right < ql) {
return 0;
}
long long mid = (left + right) >> 1;
return query1(left, mid, ql, qr, p * 2) +
query1(mid + 1, right, ql, qr, p * 2 + 1);
}
long long query2(int left, int right, int ql, int qr, int p) {
if (left >= ql && right <= qr) {
return t2[p];
}
if (left > qr || right < ql) {
return 0;
}
int mid = (left + right) >> 1;
return (query2(left, mid, ql, qr, p * 2) +
query2(mid + 1, right, ql, qr, p * 2 + 1)) %
1000000007;
}
int main() {
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, n, 1);
while (q--) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
if (x < 0) {
x = -x;
update1(1, n, x, 1, y - w[x]);
update2(1, n, x, 1, y - w[x]);
w[x] = y;
} else {
long long l = 1, r = n, res = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (query1(1, n, x, mid, 1) < query1(1, n, mid + 1, y, 1)) {
l = mid + 1;
} else {
res = mid;
r = mid - 1;
}
}
long long ans =
(query1(1, n, x, res - 1, 1) % 1000000007 * (a[res] - res)) %
1000000007 +
query2(1, n, x, res - 1, 1) +
(query1(1, n, res + 1, y, 1) % 1000000007 * (res - a[res])) %
1000000007 -
query2(1, n, res + 1, y, 1);
while (ans < 0) ans += 1000000007;
printf("%I64d\n", ans % 1000000007);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long BIG = 1e9 + 5;
int n, q;
long long A[200003], W[200003];
long long ft[200003];
long long sum(int a) { return (a) ? ft[a] + sum(a - (a & -a)) : 0; }
long long sum(int a, int b) { return (a > b) ? 0 : sum(b) - sum(a - 1); }
void update(int a, long long val) {
for (; a <= n; a += (a & -a)) ft[a] += val;
}
long long ftk[200003][2];
long long sumk(int a, int tipe) {
return (a) ? (ftk[a][tipe] + sumk(a - (a & -a), tipe)) % MOD : 0;
}
long long sumk(int a, int b, int tipe) {
return (a > b) ? 0 : sumk(b, tipe) - sumk(a - 1, tipe);
}
void updatek(int a, long long val, int tipe) {
for (; a <= n; a += (a & -a)) ftk[a][tipe] = (ftk[a][tipe] + val) % MOD;
}
int binser(int l, int r, int x) {
int iki = l, ika = r;
while (iki < ika) {
int imi = (1 + iki + ika) / 2;
if (A[imi] > x)
ika = imi - 1;
else
iki = imi;
}
return iki;
}
bool cek(int l, int r, int x) {
int idx = binser(l, r, x);
return sum(l, idx) <= sum(idx + 1, r);
}
int main() {
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++) {
update(i, W[i]);
updatek(i, ((A[i] - i) * W[i]) % MOD, 0);
updatek(i, ((-A[i] + i + BIG) * W[i]) % MOD, 1);
}
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
if (l < 0) {
l = -l;
update(l, -W[l]);
updatek(l, -((A[l] - l) * W[l]) % MOD, 0);
updatek(l, -((-A[l] + l + BIG) * W[l]) % MOD, 1);
W[l] = r;
update(l, W[l]);
updatek(l, ((A[l] - l) * W[l]) % MOD, 0);
updatek(l, ((-A[l] + l + BIG) * W[l]) % MOD, 1);
} else {
long long kir = A[l], kan = A[r];
while (kir < kan) {
long long mid = (1 + kir + kan) / 2;
if (!cek(l, r, mid))
kan = mid - 1;
else
kir = mid;
}
int idx = binser(l, r, kir);
long long res = 0;
res +=
(sumk(l, idx, 1) - ((BIG + idx - kir) * (sum(l, idx) % MOD)) % MOD) %
MOD;
res += (sumk(idx + 1, r, 0) -
((kir - idx) * (sum(idx + 1, r) % MOD)) % MOD) %
MOD;
res %= MOD;
printf("%lld\n", (res % MOD + MOD) % MOD);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
int read() {
int x = 0, w = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x * w;
}
const int N = 2e5 + 10, Mod = 1e9 + 7;
int n, q, a[N], w[N], c2[N];
long long c1[N];
void add1(int x, long long val) {
for (; x <= n; x += ((x) & (-x))) c1[x] += val;
}
void add2(int x, int val) {
for (; x <= n; x += ((x) & (-x))) (c2[x] += val) %= Mod;
}
long long query1(int x) {
long long res = 0;
for (; x; x -= ((x) & (-x))) res += c1[x];
return res;
}
int query2(int x) {
int res = 0;
for (; x; x -= ((x) & (-x))) (res += c2[x]) %= Mod;
return res;
}
int main() {
memset(c1, 0, sizeof(c1));
memset(c2, 0, sizeof(c2));
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read() - i + n;
for (int i = 1; i <= n; i++) {
w[i] = read();
add1(i, w[i]);
add2(i, 1ll * w[i] * a[i] % Mod);
}
while (q--) {
int x = read(), y = read();
if (x < 0) {
x = -x;
add1(x, -w[x]);
add2(x, (-1ll * w[x] * a[x] % Mod + Mod) % Mod);
w[x] = y;
add1(x, w[x]);
add2(x, 1ll * w[x] * a[x] % Mod);
} else {
long long s1 = query1(x - 1), s2 = query1(y) - s1;
int l = x, r = y, pos = y;
while (l <= r) {
int mid = (l + r) >> 1;
long long now = query1(mid) - s1;
if (now * 2 >= s2)
r = mid - 1, pos = mid;
else
l = mid + 1;
}
l = x;
r = y;
long long t1 = query2(pos) - query2(l - 1);
long long t2 = -1ll * a[pos] * ((query1(pos) - s1) % Mod) % Mod;
long long t3 = query2(r) - query2(pos);
long long t4 = -1ll * a[pos] * ((query1(r) - query1(pos)) % Mod) % Mod;
long long ans = (t3 + t4 - t1 - t2) % Mod;
ans = (ans + Mod) % Mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 200010;
int _w;
void add_mod(int &a, int b) {
a += b;
a -= a >= MOD ? MOD : 0;
}
int lowb(int x) { return x & (-x); }
int n, q, a[N], w[N];
struct BIT {
long long c[N];
void init() { memset(c, 0, sizeof c); }
void add(int p, int v) {
for (; p <= n; p += lowb(p)) c[p] += v;
}
long long sum(int p) {
long long s = 0;
for (; p; p -= lowb(p)) s += c[p];
return s;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
};
BIT bitw;
struct MODBIT {
int c[N];
void init() { memset(c, 0, sizeof c); }
void add(int p, int v) {
for (; p <= n; p += lowb(p)) add_mod(c[p], v);
}
int sum(int p) {
int s = 0;
for (; p; p -= lowb(p)) add_mod(s, c[p]);
return s;
}
int sum(int l, int r) { return (sum(r) - sum(l - 1) + MOD) % MOD; }
};
MODBIT bitaw;
int _calc(int l, int r, int x) {
x = a[x];
int sub = bitaw.sum(l, r);
int plus = int(bitw.sum(l, r) % MOD);
x = int(1LL * x * plus % MOD);
return (x - sub + MOD) % MOD;
}
int calc(int l, int r, int x) {
int t1 = _calc(l, x, x);
int t2 = _calc(x, r, x);
t2 = (MOD - t2) % MOD;
return (t1 + t2) % MOD;
}
void solve(int l, int r) {
int low = l - 1, high = r;
while (low < high) {
int mid = (low + high + 1) / 2;
long long lsum = bitw.sum(l, mid);
long long rsum = bitw.sum(mid + 1, r);
if (lsum <= rsum) {
low = mid;
} else {
high = mid - 1;
}
}
printf("%d\n", calc(l, r, low + 1));
}
int main() {
_w = scanf("%d%d", &n, &q);
bitaw.init();
bitw.init();
for (int i = 1; i <= n; ++i) {
_w = scanf("%d", a + i);
a[i] = (a[i] - i + MOD) % MOD;
}
for (int i = 1; i <= n; ++i) {
_w = scanf("%d", w + i);
bitw.add(i, w[i]);
int tmp = int(1LL * a[i] * w[i] % MOD);
bitaw.add(i, tmp);
}
while (q--) {
int x, y;
_w = scanf("%d%d", &x, &y);
if (x < 0) {
int id = -x;
int delta = y - w[id];
w[id] += delta;
bitw.add(id, delta);
delta = (delta + MOD) % MOD;
int tmp = int(1LL * a[id] * delta % MOD);
bitaw.add(id, tmp);
} else {
solve(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int read() {
char ch;
bool flag = 0;
int res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10 + ch - '0')
;
(flag) && (res = -res);
return res;
}
char sr[1 << 21], z[20];
int C = -1, Z;
inline void Ot() { fwrite(sr, 1, C + 1, stdout), C = -1; }
inline void print(int x) {
if (C > 1 << 20) Ot();
if (x < 0) sr[++C] = 45, x = -x;
while (z[++Z] = x % 10 + 48, x /= 10)
;
while (sr[++C] = z[Z], --Z)
;
sr[++C] = '\n';
}
const int N = 2e5 + 5;
const long long P = 1e9 + 7;
int n, q;
long long a[N], w[N];
namespace SUM {
long long c[N];
inline void add(int x, long long y) {
for (; x <= n; x += x & -x) c[x] += y;
}
inline long long que(int x) {
long long res = 0;
for (; x; x -= x & -x) res += c[x];
return res;
}
inline long long query(int l, int r) {
if (r < l) return 0;
return que(r) - que(l - 1);
}
} // namespace SUM
namespace MUL {
long long c[N];
inline void add(int x, long long y) {
y %= P;
for (; x <= n; x += x & -x) (c[x] += y + P) %= P;
}
inline long long que(int x) {
long long res = 0;
for (; x; x -= x & -x) (res += c[x]) %= P;
return res;
}
inline long long query(int l, int r) {
if (r < l) return 0;
return (que(r) - que(l - 1) + P) % P;
}
} // namespace MUL
inline int getpos(int ql, int qr) {
int l = ql, r = qr, mid, res;
while (l <= r) {
mid = (l + r) >> 1;
if (SUM::query(ql, mid) >= SUM::query(mid + 1, qr))
res = mid, r = mid - 1;
else
l = mid + 1;
}
return res;
}
void solve(int l, int r) {
if (l == r) return (void)(print(0));
int pos = getpos(l, r);
long long res = 0;
res = (-MUL::query(l, pos) +
(SUM::query(l, pos) % P) * (long long)abs(a[pos] - pos) % P + P) %
P;
res = (res + MUL::query(pos, r) -
SUM::query(pos, r) % P * (a[pos] - pos) % P + P) %
P;
print(res);
}
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, w[i] * (a[i] - i));
}
while (q--) {
int x = read(), y = read();
if (x < 0) {
x = -x, SUM::add(x, -w[x]), MUL::add(x, -w[x] * (a[x] - x));
w[x] = y, SUM::add(x, y), MUL::add(x, y * (a[x] - x));
} else
solve(x, y);
}
Ot();
return 0;
}
|
#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;
}
tree.init(N);
for (int i = 0; i < N; i++) {
scanf("%d", &W[i]);
tree.update(i, i + 1, segment_change(W[i], A[i]));
}
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;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int mod = 1e9 + 7;
const int N = 2e5 + 5;
struct segT {
int n;
long long *seg;
bool f;
segT() {}
segT(const vector<int> &v, bool f) : f(f) {
n = v.size();
seg = new long long[4 * N + 1];
build(1, 0, n - 1, v);
}
void build(int r, int i, int j, const vector<int> &v) {
if (i == j) {
seg[r] = v[i];
} else {
int mid = (i + j) >> 1;
build(2 * r, i, mid, v);
build(2 * r + 1, mid + 1, j, v);
seg[r] = seg[2 * r] + seg[2 * r + 1];
if (f and seg[r] >= mod) seg[r] -= mod;
}
}
int a, b;
long long query(int r, int i, int j, long long val) {
if (j < a or i > b) return 0;
if (i >= a and j <= b) {
if (val != -1) seg[r] = val;
return seg[r];
} else {
int mid = (i + j) >> 1;
long long L = query(2 * r, i, mid, val);
long long R = query(2 * r + 1, mid + 1, j, val);
if (f) {
seg[r] = seg[2 * r] + seg[2 * r + 1];
if (seg[r] >= mod) seg[r] -= mod;
if (L + R >= mod) return L + R - mod;
return L + R;
} else {
seg[r] = seg[2 * r] + seg[2 * r + 1];
return L + R;
}
}
}
long long query(int l, int r) {
a = l;
b = r;
return query(1, 0, n - 1, -1);
}
void update(int p, long long val) {
a = b = p;
query(1, 0, n - 1, val);
}
} segw, segaw, segiw;
int n, q;
int a[N], w[N];
int get(int a, int b, long long l, long long beg) {
long long ret = ((segw.query(a, b) % mod) * beg) % mod;
ret = (ret + segiw.query(a, b));
ret = (ret - segaw.query(a, b));
ret = (ret - (segw.query(a, b) % mod) * l) % mod;
return ret;
}
int go(int l, int r) {
l--;
r--;
long long sum = segw.query(l, r);
int bot = l, top = r;
int center = 0;
while (bot <= top) {
int mid = (bot + top) >> 1;
if (segw.query(l, mid) * 2LL >= sum) {
center = mid;
top = mid - 1;
} else {
bot = mid + 1;
}
}
int beg = a[center] - (center - l);
int L = get(l, center, l, beg);
int R = -get(center + 1, r, l, beg);
int ret = (L + R) % mod;
if (ret < 0) ret += mod;
return ret;
}
int main(void) {
vector<int> vw, vaw, viw;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) {
scanf("%d", w + i);
vw.push_back(w[i]);
vaw.push_back((1LL * w[i] * a[i]) % mod);
viw.push_back((1LL * w[i] * i) % mod);
}
segw = segT(vw, false);
segaw = segT(vaw, true);
segiw = segT(viw, true);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
if (x > 0) {
printf("%d\n", go(x, y));
} else {
x *= -1;
x--;
segw.update(x, y);
segaw.update(x, (1LL * a[x] * y) % mod);
segiw.update(x, (1LL * y * x) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long double PI = acosl(-1);
const long long infl = 1e18 + 0;
const int inf = 1e9;
const int nmax = 2e5 + 5;
const int MAXLG = log2(nmax) + 1;
long long koi[nmax];
long long w[nmax];
long long n;
long long bst[4 * nmax];
long long wkoi[4 * nmax];
void bild(long long a, long long L, long long R) {
if (L == R) {
bst[a] = w[L];
wkoi[a] = koi[L] * w[L] % mod;
return;
}
long long mid = (L + R) / 2;
bild(2 * a, L, mid);
bild(2 * a + 1, mid + 1, R);
bst[a] = bst[a * 2] + bst[a * 2 + 1];
wkoi[a] = (wkoi[a * 2] + wkoi[a * 2 + 1]) % mod;
}
long long getpos(long long a, long long L, long long R, long long dorkar) {
if (L == R) return L;
long long mid = (L + R) / 2;
if (bst[2 * a] >= dorkar) return getpos(2 * a, L, mid, dorkar);
return getpos(2 * a + 1, mid + 1, R, dorkar - bst[2 * a]);
}
void update(long long a, long long L, long long R, long long pos) {
if (L == R) {
bst[a] = w[L];
wkoi[a] = koi[L] * w[L] % mod;
return;
}
long long mid = (L + R) / 2;
if (pos <= mid)
update(2 * a, L, mid, pos);
else
update(2 * a + 1, mid + 1, R, pos);
bst[a] = bst[a * 2] + bst[a * 2 + 1];
wkoi[a] = (wkoi[a * 2] + wkoi[a * 2 + 1]) % mod;
}
long long getsum(long long a, long long L, long long R, long long l,
long long r) {
if (l > R or L > r or l > r) return 0;
if (l <= L and R <= r) return bst[a];
long long mid = (L + R) / 2;
return getsum(2 * a, L, mid, l, r) + getsum(2 * a + 1, mid + 1, R, l, r);
}
long long getwkoi(long long a, long long L, long long R, long long l,
long long r) {
if (l > R or L > r or l > r) return 0;
if (l <= L and R <= r) return wkoi[a];
long long mid = (L + R) / 2;
return (getwkoi(2 * a, L, mid, l, r) + getwkoi(2 * a + 1, mid + 1, R, l, r)) %
mod;
}
void updeet(long long pos, long long niuw) {
w[pos] = niuw;
update(1, 1, n, pos);
}
long long bamcost(long long L, long long R) {
long long renj = R - L + 1;
long long W = getsum(1, 1, n, L, R) % mod;
long long W_koi = getwkoi(1, 1, n, L, R);
long long costo = (W * koi[R] % mod - W_koi + mod) % mod;
return costo;
}
long long dancost(long long L, long long R) {
long long renj = R - L + 1;
long long W = getsum(1, 1, n, L, R) % mod;
long long W_koi = getwkoi(1, 1, n, L, R);
long long costo = (-W * koi[L] % mod + W_koi + mod) % mod;
return costo;
}
long long kuery(long long L, long long R) {
long long sam = getsum(1, 1, n, L, R);
long long pos = getpos(1, 1, n, (sam + 1) / 2 + getsum(1, 1, n, 1, L - 1));
long long b = bamcost(L, pos), d = dancost(pos, R);
return (b + d) % mod;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> koi[i], koi[i] -= i;
for (long long i = 1; i <= n; i++) cin >> w[i];
bild(1, 1, n);
while (q--) {
long long x, y;
cin >> x >> y;
if (x < 0) {
updeet(-x, y);
} else {
cout << kuery(x, y) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2 * 1e5 + 1;
const long long INF = 1e9 + 1;
const long long MOD = 1e9 + 7;
const long long BITS = 64;
const long long PRIME = 31;
const long double EPS = 1e-12;
void bye() {
cout << "\n";
exit(0);
}
long long FW[MAXN], FAW[MAXN];
long long g[MAXN], w[MAXN];
long long norm(long long a) {
if (a >= MOD) {
a %= MOD;
} else if (a < 0) {
a += MOD;
}
return a;
}
long long mult(long long a, long long b) { return (a * b) % MOD; }
void inc(bool f, long long pos, long long val) {
if (f) {
for (; pos < MAXN; pos |= (pos + 1)) {
FW[pos] += val;
}
} else {
for (; pos < MAXN; pos |= (pos + 1)) {
FAW[pos] += val;
}
}
}
long long sum(bool f, long long pos) {
long long ans = 0;
if (f) {
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ans += FW[pos];
}
} else {
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ans += FAW[pos];
}
}
return ans;
}
long long get_sum(bool f, long long l, long long r) {
return sum(f, r - 1) - sum(f, l - 1);
}
long long getMsum(bool f, long long l, long long r) {
return norm(sum(f, r - 1) - sum(f, l - 1));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, q;
cin >> n >> q;
for (long long i = 0; i < n; i++) {
cin >> g[i];
}
for (long long i = 0; i < n; i++) {
cin >> w[i];
}
for (long long i = 0; i < n; i++) {
g[i] -= i;
inc(1, i, w[i]);
inc(0, i, mult(g[i], w[i]));
}
while (q--) {
long long x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
x--;
inc(1, x, -w[x]);
inc(0, x, -mult(g[x], w[x]));
w[x] = y;
inc(1, x, w[x]);
inc(0, x, mult(g[x], w[x]));
} else {
x--;
long long l = x, r = y;
long long sum = get_sum(1, l, r);
while (r - l > 1) {
long long mid = (r + l) / 2;
if (2 * get_sum(1, x, mid) > sum) {
r = mid;
} else {
l = mid;
}
}
long long ans = norm(mult(g[l], getMsum(1, x, l)) - getMsum(0, x, l));
ans = norm(ans + norm(getMsum(0, l, y) - mult(g[l], getMsum(1, l, y))));
cout << ans << "\n";
}
}
bye();
}
|
#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[left] = query(left, l, mid, a, b);
return temp[left];
} else if (a > mid) {
temp[right] = query(right, mid + 1, r, a, b);
return temp[right];
}
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 = query(left, l, mid, a, mid).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;
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) {
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;
update_value(1, 0, N, idx, new_value);
}
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;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
struct greateri {
template <class T>
bool operator()(T const &a, T const &b) const {
return a > b;
}
};
bool ka;
void setIO(string s) {
ios_base::sync_with_stdio(0);
cin.tie(0);
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
long long seg[1800001], seg1[1800001];
long long seg2[1800001], seg3[1800001];
long long cura[200001];
vector<long long> initial, fat, nowi, nowi1;
long long n;
long long BIT[1800001];
long long curi[1800001], casi[1800001];
void build(long long p, long long l, long long r, long long yo) {
if (l == r) {
if (!yo) {
if (!l)
seg[p] = 0;
else
seg[p] = (nowi[l] *
((fat[l] - (fat[l - 1] + 1) + 1000000007) % 1000000007)) %
1000000007;
} else {
if (l == (n - 1))
seg1[p] = 0;
else
seg1[p] = (nowi1[l] *
((fat[l + 1] - (fat[l] + 1) + 1000000007) % 1000000007)) %
1000000007;
}
return;
}
long long med = (l + r) / 2;
build(p * 2, l, med, yo);
build(p * 2 + 1, med + 1, r, yo);
if (!yo) {
seg[p] = (seg[p * 2] + seg[p * 2 + 1]) % 1000000007;
} else
seg1[p] = (seg1[p * 2] + seg1[p * 2 + 1]) % 1000000007;
}
void build3(long long p, long long l, long long r) {
if (l == r) {
if (!l)
seg2[p] = 0;
else
seg2[p] = (fat[l] - (fat[l - 1] + 1) + 1000000007) % 1000000007;
if (l == (n - 1))
seg3[p] = 0;
else
seg3[p] = (fat[l + 1] - (fat[l] + 1) + 1000000007) % 1000000007;
cura[l] = seg2[p];
casi[l] = seg3[p];
return;
}
long long med = (l + r) / 2;
build3(p * 2, l, med);
build3(p * 2 + 1, med + 1, r);
seg2[p] = (seg2[p * 2] + seg2[p * 2 + 1]);
seg3[p] = (seg3[p * 2] + seg3[p * 2 + 1]);
}
pair<long long, long long> queri(long long p, long long l, long long r,
long long l1, long long r1) {
if (l > r1 || l1 > r) return {0, 0};
if (l >= l1 && r <= r1) return {seg2[p], seg3[p]};
long long med = (l + r) / 2;
auto u = queri(p * 2, l, med, l1, r1);
auto v = queri(p * 2 + 1, med + 1, r, l1, r1);
return {(u.first + v.first), (u.second + v.second)};
}
vector<long long> bos, fos;
long long lazy[1800001], lazy1[1800001];
long long l;
void prop(long long node, long long l, long long r, long long in) {
if (l != r) {
long long med = (l + r) / 2;
auto u = 0;
auto v = 0;
if (!in) {
if (!l)
u = fos[med];
else
u = (fos[med] - fos[l - 1] + 1000000007) % 1000000007;
if (!(med + 1))
v = fos[r];
else
v = (fos[r] - fos[med] + 1000000007) % 1000000007;
long long soli = (((u)*lazy[node]) % 1000000007);
long long koli = (((v)*lazy[node]) % 1000000007);
seg[node * 2] = (seg[node * 2] + soli + 1000000007) % 1000000007;
seg[node * 2 + 1] = (seg[node * 2 + 1] + koli + 1000000007) % 1000000007;
lazy[node * 2] = (lazy[node * 2] + lazy[node]) % 1000000007;
lazy[node * 2 + 1] = (lazy[node] + lazy[node * 2 + 1]) % 1000000007;
lazy[node] = 0;
} else {
if (!l)
u = bos[med];
else
u = (bos[med] - bos[l - 1] + 1000000007) % 1000000007;
if (!(med + 1))
v = bos[r];
else
v = (bos[r] - bos[med] + 1000000007) % 1000000007;
long long soli = (((u)*lazy1[node]) % 1000000007);
long long koli = (((v)*lazy1[node]) % 1000000007);
seg1[node * 2] = (seg1[node * 2] + soli + 1000000007) % 1000000007;
seg1[node * 2 + 1] =
(seg1[node * 2 + 1] + koli + 1000000007) % 1000000007;
lazy1[node * 2] = (lazy1[node * 2] + lazy1[node]) % 1000000007;
lazy1[node * 2 + 1] = (lazy1[node * 2 + 1] + lazy1[node]) % 1000000007;
lazy1[node] = 0;
}
}
}
void badel(long long p, long long l, long long r, long long l1, long long r1,
long long val, long long sasy) {
if (l1 > r1) return;
if (l > r1 || r < l1) return;
if (l >= l1 && r <= r1) {
auto cur = 0;
if (!sasy) {
if (!l)
cur = fos[r];
else
cur = (fos[r] - fos[l - 1] + 1000000007) % 1000000007;
long long dal = (cur * val) % 1000000007;
seg[p] = (seg[p] + dal + 1000000007) % 1000000007;
lazy[p] = (lazy[p] + val) % 1000000007;
} else {
if (!l)
cur = bos[r];
else
cur = (bos[r] - bos[l - 1] + 1000000007) % 1000000007;
long long dal = (cur * val) % 1000000007;
seg1[p] = (seg1[p] + dal + 1000000007) % 1000000007;
lazy1[p] = (lazy1[p] + val) % 1000000007;
}
prop(p, l, r, sasy);
return;
}
prop(p, l, r, sasy);
long long med = (l + r) / 2;
badel(p * 2, l, med, l1, r1, val, sasy);
badel(p * 2 + 1, med + 1, r, l1, r1, val, sasy);
if (!sasy) {
seg[p] = (seg[p * 2] + seg[p * 2 + 1] + 1000000007) % 1000000007;
} else
seg1[p] = (seg1[p * 2] + seg1[p * 2 + 1] + 1000000007) % 1000000007;
}
long long lawej(long long p, long long l, long long r, long long l1,
long long r1, long long sasy) {
if (l1 > r1) return 0;
if (l > r1 || r < l1) return 0;
if (l >= l1 && r <= r1) {
if (!sasy) return seg[p] % 1000000007;
return seg1[p] % 1000000007;
}
prop(p, l, r, sasy);
long long med = (l + r) / 2;
return (lawej(p * 2, l, med, l1, r1, sasy) +
lawej(p * 2 + 1, med + 1, r, l1, r1, sasy) + 1000000007) %
1000000007;
}
void update(long long index, long long val) {
for (index++; index <= n; index += (index & (-index))) {
BIT[index] += val;
}
}
long long query(long long index) {
long long result = 0;
for (index++; index > 0; index -= (index & (-index))) {
result = (result + BIT[index]);
}
return result;
}
long long range(long long l, long long r) {
if (l > r) return 0;
return ((query(r) - query(l - 1)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
cin >> n >> q;
if (n == 200000) ka = true;
l = log2(n);
int index = 0;
for (long long i = 0; i < n; ++i) {
long long xo;
cin >> xo;
fat.push_back(xo);
}
for (long long i = 0; i < n; ++i) {
long long yo;
cin >> yo;
initial.push_back(yo);
curi[i] = yo;
update(i, yo);
}
long long cumi = 0;
vector<long long> useful;
for (long long i = 0; i < n; ++i) {
nowi.push_back(cumi);
cumi = (cumi + initial[i]) % 1000000007;
useful.push_back(cumi);
}
cumi = 0;
for (long long i = n - 1; i >= 0; --i) {
nowi1.push_back(cumi);
cumi = (cumi + initial[i]) % 1000000007;
}
reverse(nowi1.begin(), nowi1.end());
build(1, 0, n - 1, 0);
build(1, 0, n - 1, 1);
build3(1, 0, n - 1);
cumi = 0;
for (int i = 0; i < n; ++i) {
cumi = (cumi + cura[i]) % 1000000007;
fos.push_back(cumi);
}
cumi = 0;
for (int i = 0; i < n; ++i) {
cumi = (cumi + casi[i]) % 1000000007;
bos.push_back(cumi);
}
while (q--) {
long long x;
cin >> x;
index++;
if (x < 0) {
x = -x - 1;
long long newi;
long long lasti = curi[x];
cin >> newi;
update(x, newi - lasti);
badel(1, 0, n - 1, x + 1, n - 1, newi - lasti, 0);
badel(1, 0, n - 1, 0, x - 1, newi - lasti, 1);
curi[x] = newi;
} else {
long long r;
cin >> r;
long long l = x;
l--, r--;
long long low = l;
long long high = r;
long long besti = l;
while (low <= high) {
long long med = (low + high) / 2;
long long k = range(l, med - 1);
long long f = range(med, r);
if ((k - f) < 0) {
besti = med;
low = med + 1;
} else {
high = med - 1;
}
}
long long fol = 0;
if (!l)
fol = fos[besti] % 1000000007;
else
fol = (fos[besti] - fos[l - 1] + 1000000007) % 1000000007;
long long sol = 0;
if (!besti)
sol = bos[r] % 1000000007;
else
sol = (bos[r] - bos[besti - 1] + 1000000007) % 1000000007;
auto kal = range(0, l - 1) % 1000000007;
auto nal = range(r + 1, n - 1) % 1000000007;
auto fin1 = lawej(1, 0, n - 1, l, besti, 0) % 1000000007;
auto fin2 = lawej(1, 0, n - 1, besti, r, 1) % 1000000007;
fin1 = ((fin1 - ((fol * kal) % 1000000007)) + 1000000007) % 1000000007;
fin2 = ((fin2 - ((sol * nal) % 1000000007)) + 1000000007) % 1000000007;
cout << (fin1 + fin2) % 1000000007 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
const int MO = 1e9 + 7;
int n, a[N], w[N];
long long t[N << 2], e[N << 2];
void build(int k = 1, int l = 1, int r = n) {
if (l == r) {
t[k] = w[l];
e[k] = (long long)a[l] * w[l] % MO;
return;
}
int h = l + r >> 1;
build(k << 1, l, h);
build(k << 1 | 1, h + 1, r);
t[k] = t[k << 1] + t[k << 1 | 1];
e[k] = (e[k << 1] + e[k << 1 | 1]) % MO;
}
void modify(int x, int y, int k = 1, int l = 1, int r = n) {
if (l == r) {
t[k] = w[x];
e[k] = (long long)a[x] * w[x] % MO;
return;
}
int h = l + r >> 1;
if (x <= h)
modify(x, y, k << 1, l, h);
else
modify(x, y, k << 1 | 1, h + 1, r);
t[k] = t[k << 1] + t[k << 1 | 1];
e[k] = (e[k << 1] + e[k << 1 | 1]) % MO;
}
int query1(long long s, int k = 1, int l = 1, int r = n) {
if (l == r) return l;
int h = l + r >> 1;
if (s <= t[k << 1] * 2) return query1(s, k << 1, l, h);
return query1(s - t[k << 1] * 2, k << 1 | 1, h + 1, r);
}
long long query2(int L, int R, int k = 1, int l = 1, int r = n) {
if (L > R) return 0;
if (L <= l && r <= R) return t[k];
int h = l + r >> 1;
long long s = 0;
if (L <= h) s += query2(L, R, k << 1, l, h);
if (h < R) s += query2(L, R, k << 1 | 1, h + 1, r);
return s;
}
long long query3(int L, int R, int k = 1, int l = 1, int r = n) {
if (L > R) return 0;
if (L <= l && r <= R) return e[k];
int h = l + r >> 1;
long long s = 0;
if (L <= h) s += query3(L, R, k << 1, l, h);
if (h < R) s += query3(L, R, k << 1 | 1, h + 1, r);
return s % MO;
}
int main() {
int i, q, x, y;
long long s, r;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i = i + 1) scanf("%d", a + i), a[i] -= i;
for (i = 1; i <= n; i = i + 1) scanf("%d", w + i);
build();
while (q--) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
w[x] = y;
modify(x, y);
} else {
s = query2(1, x - 1) * 2 + query2(x, y);
i = query1(s);
s = query3(i, y) - query2(i, y) % MO * a[i] % MO;
r = query2(x, i) % MO * a[i] % MO - query3(x, i);
cout << (s + r + (long long)MO * 10) % MO << 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) {
cloc += P;
while (cloc) {
seg[cloc] += cdiff;
cloc /= 2;
}
}
long long ctot, dtot;
long long add(int cloc) {
long long res = 0;
cloc += P;
for (int i = 0; i < 18; i++) {
if (cloc & 1) {
res += wseg[cloc - 1];
dtot -= waseg[cloc - 1];
}
cloc /= 2;
}
return res;
}
int wsearch(long long sgoal) {
int cloc = 1;
ctot = 0;
for (int i = 0; i < 18; i++) {
cloc *= 2;
if (wseg[cloc] + ctot < sgoal) {
ctot += wseg[cloc];
dtot += waseg[cloc] << 1;
cloc++;
}
}
return cloc - P;
}
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++) {
wseg[i + P] = w[i];
waseg[i + P] = (a[i] - i) * w[i] % MOD;
}
for (int i = P - 1; i >= 0; i--) {
wseg[i] = wseg[2 * i] + wseg[2 * i + 1];
waseg[i] = waseg[2 * i] + waseg[2 * i + 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);
upd(waseg, cloc, ((a[cloc] - cloc) * cdiff) % MOD);
w[cloc] = r;
} else {
l--;
dtot = 0;
long long sleft = add(l), sright = add(r);
long long sgoal = (sleft + sright + 1) / 2;
int mm = wsearch(sgoal);
long long ws = 2 * ctot - sleft - sright;
long long res = ws * (a[mm] - mm) - dtot;
res = res % MOD + MOD;
if (res >= MOD) res -= MOD;
IO::write_int((int)res, '\n');
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
const int maxn = 2e5;
const int maxnode = maxn << 2;
int n, q;
long long p[maxn + 5], ai[maxn + 5], si[maxn + 5];
long long tr[maxnode + 5], lz[maxnode + 5];
void Add(int x, long long v) {
for (; x <= n; x += x & (-x)) si[x] += v;
}
long long Sum(int x) {
long long r = 0;
for (; x; x -= x & (-x)) r += si[x];
return r;
}
void Build(int x, int l, int r) {
if (l == r)
tr[x] = Sum(l) % P * (p[l + 1] - p[l] - 1) % P;
else {
Build((x << 1), l, ((l + r) >> 1));
Build(((x << 1) | 1), ((l + r) >> 1) + 1, r);
tr[x] = (tr[(x << 1)] + tr[((x << 1) | 1)]) % P;
}
}
void PushDown(int x, int l, int r) {
lz[(x << 1)] = (lz[(x << 1)] + lz[x]) % P;
lz[((x << 1) | 1)] = (lz[((x << 1) | 1)] + lz[x]) % P;
tr[(x << 1)] =
(tr[(x << 1)] +
(p[((l + r) >> 1) + 1] - p[l] - (((l + r) >> 1) + 1 - l)) * lz[x]) %
P;
tr[((x << 1) | 1)] =
(tr[((x << 1) | 1)] +
(p[r + 1] - p[((l + r) >> 1) + 1] - (r - ((l + r) >> 1))) * lz[x]) %
P;
lz[x] = 0;
}
void Upd(int x, int l, int r, int ll, int rr, long long v) {
if (ll <= l && r <= rr) {
lz[x] = (lz[x] + v) % P;
tr[x] = (tr[x] + (p[r + 1] - p[l] - (r + 1 - l)) * v) % P;
} else {
PushDown(x, l, r);
if (ll <= ((l + r) >> 1)) Upd((x << 1), l, ((l + r) >> 1), ll, rr, v);
if (((l + r) >> 1) < rr)
Upd(((x << 1) | 1), ((l + r) >> 1) + 1, r, ll, rr, v);
tr[x] = (tr[(x << 1)] + tr[((x << 1) | 1)]) % P;
}
}
long long Query(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return tr[x];
PushDown(x, l, r);
long long ret = 0;
if (ll <= ((l + r) >> 1)) ret = Query((x << 1), l, ((l + r) >> 1), ll, rr);
if (((l + r) >> 1) < rr)
ret = (ret + Query(((x << 1) | 1), ((l + r) >> 1) + 1, r, ll, rr)) % P;
return ret;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%lld", p + i);
for (int i = 1; i <= n; ++i) scanf("%lld", ai + i), Add(i, ai[i]);
Build(1, 0, n - 1);
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
if (a < 0) {
a = -a;
long long da = b - ai[a];
ai[a] = b;
Add(a, da);
if (a <= n - 1) Upd(1, 0, n - 1, a, n - 1, (da + P) % P);
} else {
long long sl = Sum(a - 1), sr = Sum(b);
int l = a, r = b - 1, pt = a - 1;
while (l <= r) {
long long sm = Sum(((l + r) >> 1));
if (sm - sl < sr - sm)
pt = ((l + r) >> 1), l = ((l + r) >> 1) + 1;
else
r = ((l + r) >> 1) - 1;
}
long long ans = 0;
if (pt >= a) {
ans = (ans + Query(1, 0, n - 1, a, pt)) % P;
ans = (ans - sl % P * (p[pt + 1] - p[a] - (pt - a + 1)) % P + P) % P;
}
if (pt + 1 <= b - 1) {
ans = (ans - Query(1, 0, n - 1, pt + 1, b - 1) + P) % P;
ans = (ans + sr % P * (p[b] - p[pt + 1] - (b - 1 - pt))) % P;
}
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 200005;
const long long mod = 1000 * 1000 * 1000 + 7;
long long aib[nmax], fft[nmax], a[nmax], w[nmax];
int n, i, j, q, tip;
long long l, r, poz, val, opt, ans, aa, b, tot;
inline int lbit(int x) { return (((x ^ (x - 1)) & x)); }
void update(long long poz, long long val) {
long long vv = ((1LL * a[poz] * val) % mod + mod) % mod;
for (int idx = poz; idx <= n; idx += lbit(idx)) {
aib[idx] = aib[idx] + val;
fft[idx] = (fft[idx] + vv);
fft[idx] = fft[idx] - mod * (fft[idx] >= mod);
}
}
long long compute(int poz, int p) {
long long ret1 = 0, ret2 = 0;
for (int idx = poz; idx > 0; idx -= lbit(idx)) {
ret1 += aib[idx];
ret2 = (ret2 + fft[idx]);
ret2 = ret2 - mod * (ret2 >= mod);
}
if (!p) return ret1;
return ret2;
}
int find_kth(long long x) {
int ret = 0;
long long avem = 0;
for (int p = 17; p >= 0; p--)
if (ret + (1 << p) < n && avem + aib[ret + (1 << p)] <= x) {
ret += (1 << p);
avem += aib[ret];
}
ret++;
return ret;
}
bool chk(int val) { return (compute(val - 1, 0) - compute(l - 1, 0) <= tot); }
long long cc(long long x) { return ((1LL * x * (x + 1)) / 2) % mod; }
long long calc(long long opt) {
ans =
compute(l - 1, 1) - compute(opt - 1, 1) - compute(opt, 1) + compute(r, 1);
ans = (ans + 2 * mod) % mod;
ans = (1LL * ans +
1LL * ((compute(opt - 1, 0) - compute(l - 1, 0)) % mod) * a[opt] -
1LL * ((compute(r, 0) - compute(opt, 0)) % mod) * a[opt]) %
mod;
ans = (ans + mod) % mod;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> q;
for (i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
}
for (i = 1; i <= n; i++) {
cin >> w[i];
update(i, w[i]);
}
long long ret = 0;
for (i = 1; i <= q; i++) {
cin >> aa >> b;
if (aa < 0)
tip = 1, aa *= -1;
else
tip = 2;
if (tip == 1) {
poz = aa;
val = b;
update(poz, val - w[poz]);
w[poz] = val;
} else {
l = aa;
r = b;
ans = 0;
opt = l;
opt = find_kth((-compute(l - 1, 0) + compute(r, 0)) / 2);
tot = (-compute(l - 1, 0) + compute(r, 0)) / 2;
for (int p = 17; p >= 0; p--)
if (opt + (1 << p) <= r && chk(opt + (1 << p))) opt += (1 << p);
ret = calc(opt);
cout << ret << '\n';
}
}
return 0;
}
|
#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;
update_value(1, 0, N, idx, new_value);
}
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;
int a[200005], w[200005];
long long pen[200005];
int add(int x, int y) { return ((x + y) % mod + mod) % mod; }
int mul(long long x, long long y) {
x %= mod;
y %= mod;
return (long long)x * y % mod;
}
int mypow(int x, int c) {
int ret = 1;
while (c > 0) {
if (c & 1) {
ret = mul(ret, x);
}
c /= 2;
x = mul(x, x);
}
return ret;
}
void update(int ind, long long ad) {
while (ind < 200005) {
pen[ind] += ad;
ind += ind & (-ind);
}
}
long long query(int ind) {
long long ret = 0;
while (ind > 0) {
ret += pen[ind];
ind = ind & (ind - 1);
}
return ret;
}
int seg[200005 * 4];
void init(int pos, int l, int r) {
if (l == r) {
seg[pos] = mul(a[l], w[l]);
return;
}
int mid = (l + r) / 2;
init(pos * 2, l, mid);
init(pos * 2 + 1, mid + 1, r);
seg[pos] = add(seg[pos * 2], seg[pos * 2 + 1]);
}
void update(int pos, int l, int r, int ind) {
if (l == r) {
assert(l == ind);
seg[pos] = mul(a[l], w[l]);
return;
}
int mid = (l + r) / 2;
if (ind <= mid)
update(pos * 2, l, mid, ind);
else
update(pos * 2 + 1, mid + 1, r, ind);
seg[pos] = add(seg[pos * 2], seg[pos * 2 + 1]);
}
int query(int pos, int l, int r, int ql, int qr) {
if (r < ql || qr < l) {
return 0;
}
if (ql <= l && r <= qr) {
return seg[pos];
}
int mid = (l + r) / 2;
return add(query(pos * 2, l, mid, ql, qr),
query(pos * 2 + 1, mid + 1, r, ql, qr));
}
long long sum(int x, int y) { return query(y) - query(x - 1); }
int pre[200005];
void solve() {
int n, q;
scanf("%d %d ", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d ", &a[i]);
a[i] = a[i] - i;
pre[i] = add(pre[i - 1], a[i]);
}
for (int i = 1; i <= n; ++i) {
scanf("%d ", &w[i]);
update(i, w[i]);
}
init(1, 1, n);
while (q--) {
int x, y;
scanf("%d %d ", &x, &y);
if (x < 0) {
int ind = -x;
update(ind, -w[ind] + y);
w[ind] = y;
update(1, 1, n, ind);
} else {
if (y - x == 0) {
printf("0\n");
} else {
int l = x, r = y, mid;
long long total = sum(x, y);
while (l < r) {
mid = (l + r) / 2;
if (sum(x, mid) * 2 > total) {
r = mid;
} else {
l = mid + 1;
}
}
assert(sum(x, l - 1) * 2 <= total);
int ret = ret = add(mul(sum(x, l), a[l]), -query(1, 1, n, x, l));
ret = add(ret, query(1, 1, n, l, y));
ret = add(ret, -mul(sum(l, y), a[l]));
printf("%d\n", ret);
}
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MOD = 1000000007;
int N, Q;
long long A[MAXN];
long long W[MAXN];
long long BIT[3][MAXN];
long long get(int t, int idx) {
long long ret = 0;
for (; idx > 0; idx -= idx & -idx) {
ret += BIT[t][idx];
if (t != 0) ret %= MOD;
}
return ret;
}
void add(int t, int idx, long long val) {
for (; idx < MAXN; idx += idx & -idx) {
BIT[t][idx] += val;
if (t != 0) BIT[t][idx] %= MOD;
}
}
int get_median(int left, int right) {
long long pre_left = get(0, left - 1);
long long pre_right = get(0, right);
long long sum = pre_right - pre_left;
int lo = left, hi = right;
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (2 * (get(0, mid) - pre_left) >= sum)
hi = mid;
else
lo = mid + 1;
}
return lo;
}
int main() {
ios::sync_with_stdio(0);
cin >> N >> Q;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 1; i <= N; i++) {
cin >> W[i];
add(0, i, W[i]);
add(1, i, W[i] * i % MOD);
add(2, i, A[i] * W[i] % MOD);
}
for (int i = 0, x, y; i < Q; i++) {
cin >> x >> y;
if (x < 0) {
x *= -1;
add(0, x, y - W[x]);
add(1, x, x * (y - W[x]) % MOD);
add(2, x, A[x] * (y - W[x]) % MOD);
W[x] = y;
} else {
int mid = get_median(x, y);
long long left_sum[3] = {get(0, x - 1), get(1, x - 1), get(2, x - 1)};
long long mid_sum[3] = {get(0, mid), get(1, mid), get(2, mid)};
long long right_sum[3] = {get(0, y), get(1, y), get(2, y)};
long long ans = (mid_sum[1] - left_sum[1]) % MOD;
ans = (ans + ((A[mid] - mid) % MOD) * ((mid_sum[0] - left_sum[0]) % MOD) %
MOD) %
MOD;
ans = (ans - mid_sum[2] + left_sum[2]) % MOD;
ans = (ans - right_sum[1] + mid_sum[1]) % MOD;
ans = (ans - ((A[mid] - mid) % MOD) *
((right_sum[0] - mid_sum[0]) % MOD) % MOD) %
MOD;
ans = (ans + right_sum[2] - mid_sum[2]) % MOD;
if (ans < 0) ans += MOD;
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 1000000007;
struct fenwick {
int n;
vector<ll> tree;
bool modOut;
fenwick(int n) : n(n), tree(n + 1) {}
fenwick(vector<ll> init, bool modOut)
: n(init.size()), tree(init.size() + 1), modOut(modOut) {
for (int i = 0; i < n; ++i) add(i, init[i]);
}
int LSB(int i) { return (i & (-i)); }
void add(int i, ll v) {
for (int ci = i + 1; ci <= n; ci += LSB(ci)) {
tree[ci] = (tree[ci] + v);
if (modOut) tree[ci] %= MOD;
}
}
ll getPrefix(int i) {
ll ans = 0;
for (int ci = i + 1; ci > 0; ci -= LSB(ci)) {
ans += tree[ci];
if (modOut) ans %= MOD;
}
return ans;
}
ll getRange(int i, int j) {
ll ans = getPrefix(j) - getPrefix(i - 1);
if (modOut) ans = (ans + MOD) % MOD;
return ans;
}
};
int main() {
int n, q;
scanf("%d %d", &n, &q);
vector<ll> boxPos(n);
for (int i = 0; i < n; ++i) scanf("%lld", &boxPos[i]);
for (int i = 0; i < n; ++i) boxPos[i] -= i;
vector<ll> weights(n);
for (int i = 0; i < n; ++i) scanf("%lld", &weights[i]);
vector<ll> weightedSum(n);
for (int i = 0; i < n; ++i) {
weightedSum[i] = (boxPos[i] * weights[i]) % MOD;
}
fenwick sWeights(weights, false), wbProd(weightedSum, true);
for (int qta = 0; qta < q; ++qta) {
int x, y;
scanf("%d %d", &x, &y);
if (x < 0) {
x = -(x + 1);
sWeights.add(x, -weights[x]);
wbProd.add(x, (MOD - boxPos[x] * weights[x] % MOD) % MOD);
weights[x] = y;
sWeights.add(x, weights[x]);
wbProd.add(x, boxPos[x] * weights[x] % MOD);
} else {
--x;
--y;
int lo = x, hi = y;
ll rangewSum = sWeights.getRange(x, y);
while (lo < hi) {
int mid = (lo + hi) / 2;
if (sWeights.getRange(x, mid) * 2 >= rangewSum)
hi = mid;
else
lo = mid + 1;
}
ll centerPoint = boxPos[lo];
ll ans = (sWeights.getRange(x, lo) % MOD * centerPoint % MOD -
wbProd.getRange(x, lo) + MOD) %
MOD;
if (lo < y) {
ans = (ans +
(wbProd.getRange(lo + 1, y) -
sWeights.getRange(lo + 1, y) % MOD * centerPoint % MOD + MOD) %
MOD) %
MOD;
}
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acosl(-1.), eps = 1e-9;
inline int power(int a, int b, int m = mod, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int NN = 202020;
long long a[NN], w[NN];
int aw[NN];
int sw[NN];
long long W[NN];
void upaw(int u, int d) {
if (d < 0) d += mod;
for (; u < NN; u += u & -u) {
aw[u] += d;
if (aw[u] >= mod) aw[u] -= mod;
}
}
void upsw(int u, int d) {
if (d < 0) d += mod;
for (; u < NN; u += u & -u) {
sw[u] += d;
if (sw[u] >= mod) sw[u] -= mod;
}
}
void upW(int u, long long d) {
for (; u < NN; u += u & -u) W[u] += d;
}
int caaw(int u, int ans = 0) {
for (; u; u -= u & -u) {
ans += aw[u];
if (ans >= mod) ans -= mod;
}
return ans;
}
int casw(int u, int ans = 0) {
for (; u; u -= u & -u) {
ans += sw[u];
if (ans >= mod) ans -= mod;
}
return ans;
}
long long caW(int u, long long ans = 0) {
for (; u; u -= u & -u) ans += W[u];
return ans;
}
int nam(int L, int R, int id) {
long long lft = caW(id - 1) - caW(L - 1);
long long rgt = caW(R) - caW(id);
if (lft == rgt) return 0;
if (lft < rgt) return -1;
if (lft > rgt) return 1;
}
inline void sum(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline void sub(int &a, int b) {
a += b;
if (a < 0) a += mod;
}
int calc(int L, int R, int id) {
long long ans = 0;
ans += caaw(R) - caaw(id - 1);
ans += (id - a[id]) * ((caW(R) - caW(id - 1)) % mod) % mod;
ans -= casw(R) - casw(id - 1);
ans += (a[id] - id) * ((caW(id) - caW(L - 1)) % mod) % mod;
ans -= caaw(id) - caaw(L - 1);
ans += casw(id) - casw(L - 1);
ans %= mod;
if (ans < 0) ans += mod;
return ans;
}
int main() {
int n, T;
cin >> n >> T;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
scanf("%d", w + i);
upaw(i, (int)((long long)a[i] * w[i] % mod));
upsw(i, (int)((long long)i * w[i] % mod));
upW(i, w[i]);
}
int L, R;
while (T--) {
scanf("%d%d", &L, &R);
if (L < 0) {
L = -L;
upaw(L, (int)(((long long)a[L] * R - (long long)a[L] * w[L]) % mod));
upsw(L, ((long long)L * R - (long long)L * w[L]) % mod);
upW(L, R - w[L]);
w[L] = R;
continue;
}
int st = L, ed = R + 1, md1, md2;
int d, d0;
while (st + 2 < ed) {
md1 = ((st << 1) + ed) / 3;
md2 = (st + (ed << 1)) / 3;
d = nam(L, R, md1);
if (d < 0) {
st = md1;
continue;
}
if (d > 0) {
ed = md2;
continue;
}
d = nam(L, R, md2);
if (d < 0) {
st = md1;
continue;
}
if (d > 0) {
ed = md2;
continue;
}
ed = md2;
}
long long lft = caW(st - 1) - caW(L - 1);
long long rgt = caW(R) - caW(st);
if (lft + w[st] - rgt < 0) st++;
printf("%d\n", calc(L, R, st));
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
const int MOD = 1e9 + 7;
const int MAXN = 1 << 18;
int a[MAXN];
long long w[MAXN + MAXN];
int wa[MAXN + MAXN];
void add(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int sum(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
int mul(long long a, long long b) { return (a * b) % (long long)MOD; }
void Init() {
for (int i = MAXN - 1; i; --i) {
wa[i] = sum(wa[2 * i], wa[2 * i + 1]);
w[i] = w[2 * i] + w[2 * i + 1];
}
}
void ChWA(int v, int d) {
wa[v] = d;
for (v /= 2; v; v /= 2) wa[v] = sum(wa[2 * v], wa[2 * v + 1]);
}
int GetWA(int v, int l, int r, int L, int R) {
if (r <= L || R <= l) return 0;
if (L <= l && r <= R) return wa[v];
int m = (l + r) / 2;
return sum(GetWA(2 * v, l, m, L, R), GetWA(2 * v + 1, m, r, L, R));
}
void ChW(int v, long long d) {
w[v] = d;
for (v /= 2; v; v /= 2) w[v] = w[2 * v] + w[2 * v + 1];
}
long long GetW(int v, int l, int r, int L, int R) {
if (r <= L || R <= l) return 0;
if (L <= l && r <= R) return w[v];
int m = (l + r) / 2;
return GetW(2 * v, l, m, L, R) + GetW(2 * v + 1, m, r, L, R);
}
int CalcRes(int i, int L, int R) {
int res = mul(a[i], GetW(1, 0, MAXN, L, i) % (long long)MOD);
add(res, -GetWA(1, 0, MAXN, L, i) + MOD);
add(res, GetWA(1, 0, MAXN, i + 1, R));
add(res, -mul(a[i], GetW(1, 0, MAXN, i + 1, R) % (long long)MOD) + MOD);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] -= i;
}
for (int i = 0; i < n; ++i) {
cin >> w[MAXN + i];
wa[MAXN + i] = mul(a[i], w[MAXN + i]);
}
Init();
for (int qq = 0; qq < q; ++qq) {
int L;
cin >> L;
if (L > 0) {
--L;
int R;
cin >> R;
int l = L, r = R;
while (r - l > 1) {
int m = (l + r) / 2;
if (GetW(1, 0, MAXN, L, m + 1) <= GetW(1, 0, MAXN, m + 1, R))
l = m;
else
r = m;
}
if (GetW(1, 0, MAXN, L, r) < GetW(1, 0, MAXN, r, R))
cout << CalcRes(r, L, R) << '\n';
else
cout << CalcRes(l, L, R) << '\n';
} else {
L = -L;
--L;
int nw;
cin >> nw;
ChW(MAXN + L, nw);
ChWA(MAXN + L, mul(nw, a[L]));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace mine {
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3fll;
long long qread() {
long long ans = 0;
char c = getchar();
int f = 1;
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) {
num = -num;
putchar('-');
}
if (num > 9) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
puts("");
}
void chmax(long long &x, const long long y) { x = x > y ? x : y; }
void chmin(long long &x, const long long y) { x = x < y ? x : y; }
const int MAX_N = 2e5 + 10;
const long long MOD = 1e9 + 7;
void add(long long &x, long long y) {
x += y;
if (x >= MOD) x -= MOD;
if (x < 0) x += MOD;
}
struct BIT {
long long bit[MAX_N];
BIT() { memset(bit, 0, sizeof bit); }
int lowbit(int x) { return x & -x; }
void add(int x, int c) {
while (x < MAX_N) bit[x] += c, x += lowbit(x);
}
long long sum(int x) {
long long ans = 0;
while (x >= 1) ans += bit[x], x -= lowbit(x);
return ans;
}
long long ask(int l, int r) { return (l > r) ? 0 : sum(r) - sum(l - 1); }
} bit, bit2;
long long a[MAX_N], b[MAX_N], w[MAX_N];
void main() {
int n = qread(), q = qread();
for (int i = 1; i <= n; i++) a[i] = qread(), b[i] = a[i] - i;
for (int i = 1; i <= n; i++) {
w[i] = qread(), bit.add(i, w[i]);
bit2.add(i, w[i] * b[i] % MOD);
}
while (q--) {
int x = qread(), y = qread();
if (x < 0) {
int id = -x, c = y;
bit.add(id, -w[id]);
bit2.add(id, -w[id] * b[id] % MOD);
w[id] = c;
bit.add(id, w[id]);
bit2.add(id, w[id] * b[id] % MOD);
} else {
int l = x, r = y;
long long now = 0;
int T0 = a[l] - l;
int mid = lower_bound(b + l, b + r + 1, T0) - b - 1;
now -= bit2.ask(l, mid) % MOD - bit.ask(l, mid) % MOD * T0 % MOD;
now += bit2.ask(mid + 1, r) % MOD - bit.ask(mid + 1, r) % MOD * T0 % MOD;
now %= MOD;
int fl = b[l], fr = b[r] - 1, T = -1;
while (fl <= fr) {
int mid = (fl + fr) >> 1;
int tt = upper_bound(b + 1, b + n + 1, mid) - b - 1;
if (bit.ask(l, tt) < bit.ask(tt + 1, r))
T = mid, fl = mid + 1;
else
fr = mid - 1;
}
if (T >= 0) {
int tt = upper_bound(b + 1, b + n + 1, T) - b - 1;
now += -bit2.ask(l, tt) * 2 % MOD +
bit.ask(l, tt) % MOD * (T + b[l] + 1) % MOD;
now -= bit.ask(tt + 1, r) % MOD * (T - b[l] + 1) % MOD;
}
write2((now % MOD + MOD) % MOD);
}
}
}
}; // namespace mine
int main() {
srand(time(0));
mine::main();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long tx[1 << 19], t[1 << 19];
struct SegtreeMOD {
int n, h;
SegtreeMOD() {}
SegtreeMOD(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
}
void aset(int x, long long v) { tx[x + n] = v % MOD; }
void build() {
for (int x = n - 1; x; --x) {
tx[x] = tx[x << 1] + tx[x << 1 | 1];
if (tx[x] >= MOD) {
tx[x] -= MOD;
}
}
}
void assign(int x, long long v) {
x += n;
tx[x] = v % MOD;
for (x /= 2; x; x /= 2) {
tx[x] = (tx[x << 1] + tx[x << 1 | 1]);
if (tx[x] >= MOD) {
tx[x] -= 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 += tx[l++];
}
if (r % 2) {
ans += tx[--r];
}
}
return ans % MOD;
}
};
struct Segtree {
int n, h;
Segtree() {}
Segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
}
void aset(int x, long long v) { t[x + n] = v; }
void build() {
for (int i = n - 1; i; --i) {
t[i] = t[i << 1] + t[i << 1 | 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) * 2 - wtot) % MOD) * a[med] -
wx.query(l, med) + wx.query(med, r + 1);
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.aset(i, w);
wx.aset(i, w * a[i]);
}
weights.build();
wx.build();
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 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], 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), 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 (2ll * (ask(t, mid, 0) - ask(t, l - 1, 0)) >= all)
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>
using namespace std;
const int MAXN = 220000;
const int P = 1E9 + 7;
int a[MAXN], w[MAXN], s[MAXN];
struct SegmentTree {
struct Node {
int l, r;
long long sum1;
int sum2;
} tr[4 * MAXN];
void pushup(int o) {
tr[o].sum1 = tr[(o << 1)].sum1 + tr[(o << 1 | 1)].sum1;
tr[o].sum2 = (tr[(o << 1)].sum2 + tr[(o << 1 | 1)].sum2) % P;
}
void build(int o, int l, int r, int* w) {
tr[o].l = l;
tr[o].r = r;
if (l == r) {
tr[o].sum1 = w[l];
tr[o].sum2 = 1ll * (l - ::a[l] + P) * w[l] % P;
return;
}
int mid = (l + r) >> 1;
build((o << 1), l, mid, w);
build((o << 1 | 1), mid + 1, r, w);
pushup(o);
}
void update(int o, int p, int k) {
if (tr[o].l == tr[o].r) {
tr[o].sum1 = k;
tr[o].sum2 = 1ll * (p - ::a[p] + P) * k % P;
return;
}
int mid = (tr[o].l + tr[o].r) >> 1;
if (p <= mid)
update((o << 1), p, k);
else
update((o << 1 | 1), p, k);
pushup(o);
}
long long query1(int o, int l, int r) {
if (tr[o].l > r || tr[o].r < l) return 0;
if (l <= tr[o].l && tr[o].r <= r) return tr[o].sum1;
return query1((o << 1), l, r) + query1((o << 1 | 1), l, r);
}
int query2(int o, int l, int r) {
if (tr[o].l > r || tr[o].r < l) return 0;
if (l <= tr[o].l && tr[o].r <= r) return tr[o].sum2;
return (query2((o << 1), l, r) + query2((o << 1 | 1), l, r)) % P;
}
int find(int o, int l, int r, long long k, long long s = 0) {
if (tr[o].l == tr[o].r) return tr[o].l;
int mid = (tr[o].l + tr[o].r) >> 1;
if (mid >= l && s + tr[(o << 1)].sum1 >= k)
return find((o << 1), l, r, k, s);
else
return find((o << 1 | 1), l, r, k, s + tr[(o << 1)].sum1);
}
} st;
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
st.build(1, 1, n, w);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0)
st.update(1, -x, y);
else {
int p = st.find(1, x, y,
st.query1(1, 1, x - 1) + (st.query1(1, x, y) + 1) / 2);
int r1 = (st.query2(1, x, p - 1) +
st.query1(1, x, p - 1) % P * (a[p] - p + P)) %
P;
int r2 = (st.query1(1, p + 1, y) % P * (p - a[p] + P) -
st.query2(1, p + 1, y) + P) %
P;
printf("%d\n", (r1 + r2) % P);
}
}
return 0;
}
|
#include <bits/stdc++.h>
class mint {
public:
unsigned int v;
static unsigned int _addu(unsigned int a, unsigned int b) {
return (a + b) % ((int)1e9 + 7);
}
static unsigned int _mulu(unsigned int a, unsigned int b) {
return (unsigned long long int)a * b % ((int)1e9 + 7);
}
mint() {}
mint(unsigned int _v) : v(_v) {}
mint(int _v) : v((_v % ((int)1e9 + 7) + ((int)1e9 + 7)) % ((int)1e9 + 7)) {}
mint(unsigned long long int _v) : v(_v % ((int)1e9 + 7)) {}
mint(long long int _v)
: v((_v % ((int)1e9 + 7) + ((int)1e9 + 7)) % ((int)1e9 + 7)) {}
mint &operator+=(const mint &x) {
v = _addu(v, x.v);
return *this;
}
mint &operator-=(const mint &x) {
v = _addu(v, ((int)1e9 + 7) - x.v);
return *this;
}
mint &operator*=(const mint &x) {
v = _mulu(v, x.v);
return *this;
}
mint operator+(const mint &x) { return mint(_addu(v, x.v)); }
mint operator-(const mint &x) { return mint(_addu(v, ((int)1e9 + 7) - x.v)); }
mint operator*(const mint &x) { return mint(_mulu(v, x.v)); }
operator unsigned int() const { return v; }
operator int() const { return v; }
operator unsigned long long int() const { return v; }
operator long long int() const { return v; }
};
template <class T>
class bit {
public:
T a[262144];
void add(int x, T k) {
while (x < 262144) {
a[x] += k;
x |= x + 1;
}
}
T qry(int x) {
T ans = 0;
while (x >= 0) {
ans += a[x];
x -= x + 1 & ~x;
}
return ans;
}
int lbd(T k) {
if (a[262144 - 1] < k) return 262144;
T ans = -1;
int x = 262144 >> 1;
while (x) {
if (a[ans + x] < k) k -= a[ans += x];
x >>= 1;
}
return ans + 1;
}
int ubd(T k) {
if (a[262144 - 1] <= k) return 262144;
T ans = -1;
int x = 262144 >> 1;
while (x) {
if (a[ans + x] <= k) k -= a[ans += x];
x >>= 1;
}
return ans + 1;
}
};
int a[262144], w[262144];
bit<long long int> pw;
bit<mint> pc;
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) scanf("%d", a + i), a[i] -= i;
for (int i = 0; i < n; ++i) scanf("%d", w + i);
for (int i = 0; i < n; ++i) pw.add(i, w[i]);
for (int i = 0; i < n; ++i) pc.add(i, mint(w[i]) * mint(a[i]));
while (q--) {
int ins, ex;
scanf("%d%d", &ins, &ex);
if (ins < 0) {
int id = -ins - 1, d = ex - w[id];
pw.add(id, d), pc.add(id, mint(d) * mint(a[id])), w[id] += d;
} else {
int l = ins - 1, r = ex - 1;
int x = pw.lbd((pw.qry(l - 1) + pw.qry(r) + 1) / 2);
0;
mint tx(a[x]);
mint cl = (tx * mint(pw.qry(x - 1) - pw.qry(l - 1)) -
(pc.qry(x - 1) - pc.qry(l - 1)));
mint cr = ((pc.qry(r) - pc.qry(x)) - tx * mint(pw.qry(r) - pw.qry(x)));
printf("%d\n", (int)(cl + cr));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n, q, a[200005];
long long t[524333], w[200005];
struct T {
long long t[200005];
void add(int x, long long k) {
while (x <= n) t[x] += k, x += (x & -x);
}
long long sum(int x) {
long long s = 0;
while (x) s += t[x], x -= (x & -x);
return s;
}
long long get(int l, int r) { return sum(r) - sum(l - 1); }
} f1, f2;
int fnd(int k, long long o) {
if (k > 262143) return k - 262143;
int lc = k << 1;
if (t[lc] >= o) return fnd(lc, o);
return fnd(lc ^ 1, o - t[lc]);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), a[i] = a[i] - i + 1;
for (int i = 1; i <= n; ++i) {
scanf("%I64d", w + i);
t[262143 + i] = w[i];
f1.add(i, w[i]);
f2.add(i, w[i] * 1ll * a[i] % 1000000007ll);
}
for (int i = 262143; i; --i) t[i] = t[i << 1] + t[(i << 1) ^ 1];
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0) {
l = -l;
f1.add(l, -w[l]);
f2.add(l, -(w[l] * 1ll * a[l] % 1000000007ll));
w[l] = r;
f1.add(l, w[l]);
f2.add(l, w[l] * 1ll * a[l] % 1000000007ll);
int k = l + 262143;
t[k] = r;
do {
k >>= 1;
t[k] = t[k << 1] + t[(k << 1) ^ 1];
} while (k > 1);
continue;
}
long long L = f1.sum(l - 1), R = f1.sum(r), O = R - L;
int k = fnd(1, L + (O + 1ll) / 2ll);
long long ans =
a[k] * 1ll * (f1.get(l, k - 1) % 1000000007ll) % 1000000007ll -
f2.get(l, k - 1) % 1000000007ll + f2.get(k + 1, r) % 1000000007ll -
a[k] * 1ll * (f1.get(k + 1, r) % 1000000007ll) % 1000000007ll;
ans = (ans % 1000000007ll + 1000000007ll) % 1000000007ll;
printf("%I64d\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);
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;
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;
const int maxn = (int)2e5 + 1, mod = (int)1e9 + 7;
int n, m, a[maxn];
struct Segment {
long long cnt;
int sum;
} seg[maxn << 1 | 1];
inline int seg_idx(int L, int R) { return (L + R) | (L < R); }
inline void seg_merge(Segment &rt, Segment &lch, Segment &rch) {
rt.cnt = lch.cnt + rch.cnt;
(rt.sum = lch.sum + rch.sum) >= mod && (rt.sum -= mod);
}
void seg_build(int L, int R) {
int rt = seg_idx(L, R);
if (L == R) {
int v;
scanf("%d", &v);
seg[rt] = (Segment){(long long)v, (int)((long long)a[L] * v % mod)};
return;
}
int M = (L + R) >> 1, lch = seg_idx(L, M), rch = seg_idx(M + 1, R);
seg_build(L, M);
seg_build(M + 1, R);
seg_merge(seg[rt], seg[lch], seg[rch]);
}
void seg_upd(int L, int R, int x, int v) {
int rt = seg_idx(L, R);
if (L == R) {
seg[rt] = (Segment){(long long)v, (int)((long long)a[L] * v % mod)};
return;
}
int M = (L + R) >> 1, lch = seg_idx(L, M), rch = seg_idx(M + 1, R);
if (x <= M)
seg_upd(L, M, x, v);
else
seg_upd(M + 1, R, x, v);
seg_merge(seg[rt], seg[lch], seg[rch]);
}
Segment seg_que(int L, int R, int x) {
if (R <= x) return seg[seg_idx(L, R)];
int M = (L + R) >> 1;
if (x <= M) return seg_que(L, M, x);
Segment ret = seg_que(M + 1, R, x);
seg_merge(ret, seg[seg_idx(L, M)], ret);
return ret;
}
int seg_find(int L, int R, long long v) {
while (L < R) {
int M = (L + R) >> 1;
if (seg[seg_idx(L, M)].cnt >= v) {
R = M;
} else {
v -= seg[seg_idx(L, M)].cnt;
L = M + 1;
}
}
return L;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
a[i] -= i;
}
seg_build(1, n);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
seg_upd(1, n, -x, y);
} else {
Segment lft = x > 1 ? seg_que(1, n, x - 1) : (Segment){0LL, 0};
Segment rht = seg_que(1, n, y);
int M = seg_find(1, n, (lft.cnt + rht.cnt + 1) >> 1);
Segment mid = seg_que(1, n, M);
int res =
((mid.cnt - lft.cnt) % mod * a[M] - (long long)(mid.sum - lft.sum) +
(long long)(rht.sum - mid.sum) - (rht.cnt - mid.cnt) % mod * a[M]) %
mod;
printf("%d\n", res < 0 ? res + mod : res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
const int MD = 1000000007;
int a[MX];
int w[MX];
struct {
int L, R;
int pl, pr;
long long sum, sum2;
} T[2 * MX];
int buildTree(int L, int R) {
static int tsz = 0;
int cur = tsz++;
T[cur].L = L;
T[cur].R = R;
if (L < R) {
T[cur].pl = buildTree(L, (L + R) / 2);
T[cur].pr = buildTree((L + R) / 2 + 1, R);
T[cur].sum = T[T[cur].pl].sum + T[T[cur].pr].sum;
T[cur].sum2 = T[T[cur].pl].sum2 + T[T[cur].pr].sum2;
T[cur].sum2 %= MD;
} else {
T[cur].sum = w[L];
T[cur].sum2 = (w[L] * 1LL * a[L]) % MD;
}
return cur;
}
long long st_S;
int get(int cur, int L) {
if (L > T[cur].R) return -1;
if (T[cur].L == T[cur].R) {
st_S -= T[cur].sum;
if (st_S <= 0) {
return T[cur].L;
}
return -1;
}
if (L >= T[T[cur].pr].L) return get(T[cur].pr, L);
if (L >= T[cur].L) {
int tmp = get(T[cur].pl, L);
if (tmp != -1) return tmp;
return get(T[cur].pr, L);
}
if (T[cur].sum < st_S) {
st_S -= T[cur].sum;
return -1;
}
int tmp = get(T[cur].pl, L);
if (tmp != -1) return tmp;
return get(T[cur].pr, L);
}
long long getSum(int cur, int L, int R) {
if (L > R) return 0;
if (L <= T[cur].L && R >= T[cur].R) return T[cur].sum;
long long sum = 0;
if (L <= T[T[cur].pl].R && T[T[cur].pl].L <= R) {
sum += getSum(T[cur].pl, L, R);
}
if (L <= T[T[cur].pr].R && T[T[cur].pr].L <= R) {
sum += getSum(T[cur].pr, L, R);
}
return sum;
}
long long getSum2(int cur, int L, int R) {
if (L > R) return 0;
if (L <= T[cur].L && R >= T[cur].R) return T[cur].sum2;
long long sum2 = 0;
if (L <= T[T[cur].pl].R && T[T[cur].pl].L <= R) {
sum2 += getSum2(T[cur].pl, L, R);
}
if (L <= T[T[cur].pr].R && T[T[cur].pr].L <= R) {
sum2 += getSum2(T[cur].pr, L, R);
}
sum2 %= MD;
return sum2;
}
void upd(int cur, int i) {
if (T[cur].L == T[cur].R) {
T[cur].sum = w[i];
T[cur].sum2 = (w[i] * 1LL * a[i]) % MD;
return;
}
if (i <= T[T[cur].pl].R)
upd(T[cur].pl, i);
else
upd(T[cur].pr, i);
T[cur].sum = T[T[cur].pl].sum + T[T[cur].pr].sum;
T[cur].sum2 = T[T[cur].pl].sum2 + T[T[cur].pr].sum2;
T[cur].sum2 %= MD;
}
int main() {
int n, q;
ignore = scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
ignore = scanf("%d", a + i);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
ignore = scanf("%d", w + i);
}
int root = buildTree(1, n);
while (q--) {
int x, y;
ignore = scanf("%d %d", &x, &y);
if (x < 0) {
x *= -1;
w[x] = y;
upd(root, x);
} else {
long long S = getSum(root, x, y);
st_S = (S + 1) / 2;
int k = get(root, x);
long long ans = 0;
ans = getSum(root, x, k - 1) - getSum(root, k + 1, y) + MD;
ans %= MD;
ans *= 1LL * a[k];
ans %= MD;
ans += getSum2(root, k + 1, y) - getSum2(root, x, k - 1) + MD;
ans %= MD;
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
constexpr ll mod = 1000000007;
struct modft {
vector<ll> tree;
void update(int i, ll val) {
i++;
while (i < (int)(tree).size()) {
tree[i] += val;
tree[i] %= mod;
i += (i & (-i));
}
}
modft(int n) { tree.assign(n + 1, 0); }
ll prefix_sum(int i) {
if (i >= (int)(tree).size()) i = (int)(tree).size() - 1;
ll sum = 0;
i++;
while (i > 0) {
sum += tree[i];
sum %= mod;
i -= (i & (-i));
}
return sum;
}
ll query(int l, int r) {
--r;
--l;
ll res = prefix_sum(r);
res -= prefix_sum(l);
return ((res % mod) + mod) % mod;
}
void set(int i, ll val) {
ll cur = query(i, i + 1);
update(i, (((val - cur) % mod) + mod) % mod);
}
};
struct ft {
vector<ll> tree;
void update(int i, ll val) {
i++;
while (i < (int)(tree).size()) {
tree[i] += val;
i += (i & (-i));
}
}
ft(int n) { tree.assign(n + 1, 0); }
ll prefix_sum(int i) {
if (i >= (int)(tree).size()) i = (int)(tree).size() - 1;
ll sum = 0;
i++;
while (i > 0) {
sum += tree[i];
i -= (i & (-i));
}
return sum;
}
ll query(int l, int r) {
--r;
--l;
ll res = prefix_sum(r);
res -= prefix_sum(l);
return res;
}
void set(int i, ll val) {
ll cur = query(i, i + 1);
update(i, val - cur);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
vector<ll> a(n), w(n);
ft raw(n);
modft lin(n), space(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> w[i];
raw.update(i, w[i]);
lin.update(i, (i * w[i]) % mod);
space.update(i, (a[i] * w[i]) % mod);
}
for (int _ = 0; _ < q; _++) {
ll x, y;
cin >> x >> y;
if (x < 0) {
int i = (int)(-x - 1);
w[i] = y;
raw.set(i, w[i]);
lin.set(i, (i * w[i]) % mod);
space.set(i, (a[i] * w[i]) % mod);
} else {
--x;
int lo = (int)x;
int hi = (int)y;
ll sum = raw.query(lo, hi);
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (raw.query((int)x, mid) > sum / 2) {
hi = mid;
} else {
lo = mid;
}
}
int _x = (int)x;
int _y = (int)y;
int k = lo;
if (raw.query(_x, k + 1) <= sum / 2) cout << "?" << endl;
if (raw.query(_x, k) > sum / 2) cout << "?" << endl;
ll left = (((a[k] - k) % mod) * (raw.query(_x, k) % mod)) % mod;
left = (left - space.query(_x, k)) % mod;
left = (left + lin.query(_x, k)) % mod;
ll right = (((k - a[k]) % mod) * (raw.query(k + 1, _y) % mod)) % mod;
right = (right + space.query(k + 1, _y)) % mod;
right = (right - lin.query(k + 1, _y)) % mod;
ll ans = (((left + right) % mod) + mod) % mod;
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
const int MOD = 1000000007;
int le[N], ri[N], a[N];
long long sw[N], swa[N], w[N];
void init(int x, int l, int r) {
le[x] = l;
ri[x] = r;
if (l == r) {
sw[x] = w[l];
swa[x] = w[l] * a[l] % MOD;
return;
}
int m = (l + r) >> 1;
init(x * 2, l, m);
init(x * 2 + 1, m + 1, r);
sw[x] = sw[x * 2] + sw[x * 2 + 1];
swa[x] = (swa[x * 2] + swa[x * 2 + 1]) % MOD;
}
void update(int x, int id, long long nw) {
if (le[x] == ri[x]) {
sw[x] = nw;
swa[x] = nw * a[id] % MOD;
return;
}
int m = (le[x] + ri[x]) >> 1;
if (id <= m)
update(x * 2, id, nw);
else
update(x * 2 + 1, id, nw);
sw[x] = sw[x * 2] + sw[x * 2 + 1];
swa[x] = (swa[x * 2] + swa[x * 2 + 1]) % MOD;
}
long long getsw(int x, int l, int r) {
if (le[x] >= l && ri[x] <= r) return sw[x];
int m = (le[x] + ri[x]) >> 1;
long long tmp = 0;
if (l <= m) tmp += getsw(x * 2, l, r);
if (r > m) tmp += getsw(x * 2 + 1, l, r);
return tmp;
}
int find(int x, int l, int r, long long goalsw, long long &cursw) {
if (le[x] > r || ri[x] < l) return 0;
if (le[x] >= l && ri[x] <= r) {
if (cursw + sw[x] <= goalsw) {
cursw += sw[x];
return 0;
} else if (le[x] == ri[x])
return le[x];
}
int ans = find(x * 2, l, r, goalsw, cursw);
if (ans) return ans;
return find(x * 2 + 1, l, r, goalsw, cursw);
}
long long solve(int x, int l, int r, int k) {
if (le[x] >= l && ri[x] <= r)
return (sw[x] % MOD * a[k] % MOD - swa[x]) % MOD;
int m = (le[x] + ri[x]) >> 1;
long long ret = 0;
if (l <= m) ret += solve(x * 2, l, r, k);
if (r > m) ret += solve(x * 2 + 1, l, r, k);
return ret % MOD;
}
int main() {
ios::sync_with_stdio(false);
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];
init(1, 1, n);
while (q--) {
int x;
cin >> x;
if (x < 0) {
int id = -x;
long long nw;
cin >> nw;
update(1, id, nw);
} else {
int l = x, r;
cin >> r;
long long sumw = getsw(1, l, r), cursw = 0;
int k = find(1, l, r, sumw / 2, cursw);
long long ans = 0;
if (l < k) ans += solve(1, l, k - 1, k);
if (r > k) ans -= solve(1, k + 1, r, k);
cout << (ans % MOD + MOD) % MOD << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
int n, l, r;
long long S[maxn << 1], wp[maxn << 1], owp[maxn], os[maxn], ps[maxn];
long long add(long long a, long long b) {
if (a + b > mod)
return a + b - mod;
else
return a + b;
}
int lowbit(int x) { return x & (-x); }
void change1(int p, int x) {
while (p <= n) {
S[p] += x;
p += lowbit(p);
}
}
void change2(int p, int x) {
while (p <= n) {
wp[p] = add(x, wp[p]);
p += lowbit(p);
}
}
long long ssum(int k) {
long long ans = 0;
while (k > 0) {
ans += S[k];
k -= lowbit(k);
}
return ans;
}
long long wpsum(int k) {
long long ans = 0;
while (k > 0) {
ans = add(ans, wp[k]);
k -= lowbit(k);
}
if (ans > mod)
return ans % mod;
else
return ans;
}
long long ask(int l, int r, int op) {
if (op == 1)
return ssum(r) - ssum(l - 1);
else
return wpsum(r) - wpsum(l - 1);
}
int findk(int l, int r) {
int L = l, R = r, mid;
double al = 1.0 * (ask(l, r, 1)) / 2;
while (L < R) {
mid = (L + R) >> 1;
if (ask(l, mid, 1) >= al)
R = mid;
else
L = mid + 1;
}
return L;
}
int main() {
int q, a, b, pos;
long long nw, n1, n2;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &ps[i]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &os[i]);
owp[i] = (ps[i] - i) * os[i];
if (owp[i] > mod) owp[i] %= mod;
change1(i, os[i]);
change2(i, owp[i]);
}
while (q--) {
scanf("%d%d", &a, &b);
if (a < 0) {
pos = -a, nw = b;
n1 = nw - os[pos], n2 = (nw * (ps[pos] - pos) - owp[pos]) % mod;
os[pos] = b;
owp[pos] = nw * (ps[pos] - pos);
change1(pos, n1);
change2(pos, n2);
} else {
int k = findk(a, b);
l = a, r = b;
long long ans = ((ask(l, k, 1) - ask(k, r, 1)) * (ps[k] - k) -
(ask(l, k, 2) - ask(k, r, 2))) %
mod;
printf("%lld\n", (ans % mod + mod) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
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;
aw_sum = (aw_sum + other.aw_sum) % MOD;
}
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());
}
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 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;
int low = start, high = end - 1;
while (low < high) {
int mid = (low + high) / 2;
if (2 * tree.query(start, mid + 1).w_sum >= total_w)
high = mid;
else
low = mid + 1;
}
segment left = tree.query(start, low);
segment right = tree.query(low, end);
long long result = (left.w_sum - right.w_sum) % MOD * (long long)A[low] +
right.aw_sum - left.aw_sum;
return (result % MOD + MOD) % MOD;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> Q;
A.resize(N);
W.resize(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
A[i] -= i;
}
tree.init(N);
for (int i = 0; i < N; i++) {
cin >> W[i];
tree.update(i, i + 1, segment_change(W[i], A[i]));
}
for (int q = 0; q < Q; q++) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x - 1;
tree.update(x, x + 1, segment_change(y, A[x]));
} else {
cout << solve(x - 1, y) << '\n';
}
}
}
|
#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(lli pos, int l, int r) {
lli move = (get(lcol, pos + 1, r, 1) + get(rcol, l, pos - 1, 1)) % 1000000007;
lli del1 =
((pos - arr[pos]) * (get(pref, l, pos - 1, 0) % 1000000007)) % 1000000007;
lli del2 =
((arr[pos] - pos) * (get(pref, pos + 1, r, 0) % 1000000007)) % 1000000007;
move = move - del1 - del2 + 1000000007 + 1000000007;
return move % 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++) {
temp = (i - arr[i]);
temp *= wrr[i];
add(rcol, i, temp, 1);
}
for (int i = 0; i < n; i++) {
temp = (arr[i] - i);
temp *= wrr[i];
add(lcol, i, temp, 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);
lli t1 = (temp * (u - arr[u]));
add(rcol, u, t1, 1);
t1 = (temp * (arr[u] - u));
add(lcol, u, t1, 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;
#pragma GCC optimize("Ofast")
const int MAXN = 2e5 + 20;
int a[MAXN], w[MAXN], n;
const int P = 1e9 + 7;
inline void MOD(int& p) {
while (p < 0) p += P;
while (p >= P) p -= P;
}
struct BIT1 {
long long bit[MAXN];
inline void modify(int w, long long v) {
while (w <= n) {
bit[w] += v;
w += (w & (-w));
}
}
inline long long sum(int w) {
long long res = 0;
while (w) {
res += bit[w];
w -= (w & (-w));
}
return res;
}
inline long long query(int l, int r) { return sum(r) - sum(l - 1); }
} BitW;
struct BIT2 {
int bit[MAXN];
inline void modify(int w, int v) {
while (w <= n) {
MOD(bit[w] += v);
w += (w & (-w));
}
}
inline int sum(int w) {
MOD(w);
long long res = 0;
while (w) {
res += bit[w];
w -= (w & (-w));
}
return res % P;
}
inline int query(int l, int r) { return (sum(r) - sum(l - 1) + P) % P; }
} BitS;
inline int getAns(int l, int r) {
int L = l, R = r;
while (L <= R) {
int mid = (L + R) >> 1;
if (BitW.query(l, mid) >= BitW.query(mid + 1, r)) {
R = mid - 1;
} else {
L = mid + 1;
}
}
++R;
long long res = 0;
res = -BitS.query(l, R) + BitW.query(l, R) % P * abs(a[R] - R) % P;
res = (res % P + P) % P;
res -= -BitS.query(R, r) + BitW.query(R, r) % P * abs(a[R] - R) % P;
res = (res % P + P) % P;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int q;
cin >> n >> q;
for (register int i = (1); i <= (n); ++i) {
cin >> a[i];
}
for (register int i = (1); i <= (n); ++i) {
cin >> w[i];
BitW.modify(i, w[i]);
BitS.modify(i, 1ll * w[i] * (a[i] - i) % P);
}
while (q--) {
int l, r;
cin >> l >> r;
if (l < 0) {
l = -l;
BitW.modify(l, -w[l]);
BitS.modify(l, -1ll * w[l] * (a[l] - l) % P);
w[l] = r;
BitW.modify(l, w[l]);
BitS.modify(l, 1ll * w[l] * (a[l] - l) % P);
} else {
cout << getAns(l, r) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 2e5 + 10, MXM = 5010;
long long MOD = 1e9 + 7;
int N, Q;
long long a[MXN], w[MXN];
template <typename T>
struct fenwick {
T f[MXN] = {};
void update(int x, T val) {
for (; x <= N; x += x & -x) (f[x] = f[x] + val);
}
T get(int x) {
T res = 0;
for (; x; x -= x & -x) {
(res = res + f[x]);
}
return res;
}
T get(int x1, int x2) {
x1 = max(x1 - 1, 0);
x2 = min(x2, N);
return get(x2) - get(x1);
}
T findmid(int x1, int x2) {
long long s1, s2, goal, res = 0;
int x = 0;
x1 = max(x1 - 1, 0);
x2 = min(x2, N);
s1 = get(x1);
s2 = get(x2);
goal = (s1 + s2 + 1) >> 1;
for (int k = 20; k >= 0; --k) {
if (x + (1 << k) <= N)
if (res + f[x + (1 << k)] < goal) {
res += f[x + (1 << k)];
x += 1 << k;
}
}
return x + 1;
}
};
template <typename T>
struct fenwickMOD {
T f[MXN] = {};
void update(int x, T val) {
for (; x <= N; x += x & -x) (f[x] = f[x] + val) %= MOD;
}
T get(int x) {
T res = 0;
for (; x; x -= x & -x) {
(res = res + f[x]) %= MOD;
}
return res;
}
T get(int x1, int x2) {
x1 = max(x1 - 1, 0);
x2 = min(x2, N);
return (get(x2) - get(x1) + MOD) % MOD;
}
};
fenwick<long long> F;
fenwickMOD<long long> F2;
void upd(int x, int y) {
int d = y - w[x];
F.update(x, d);
F2.update(x, (a[x] - x) * d);
w[x] = y;
}
void init() {
cin >> N >> Q;
for (int i = 1; i <= N; i++) {
cin >> a[i];
}
for (int i = 1; i <= N; i++) {
int x;
cin >> x;
upd(i, x);
}
}
namespace solve {
void solve() {
for (int t = 0; t < Q; t++) {
int x, y;
cin >> x >> y;
if (x > 0) {
long long ans = 1e18;
int m = F.findmid(x, y);
{
long long t =
(F.get(x, m - 1) - F.get(m + 1, y)) % MOD * (a[m] - m) % MOD;
long long t2 = F2.get(m + 1, y) - F2.get(x, m - 1);
ans = min(ans, t + t2);
}
cout << (ans % MOD + MOD) % MOD << endl;
} else {
x = -x;
upd(x, y);
}
}
}
} // namespace solve
int main() {
init();
solve::solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
const long long mod = 1e9 + 7;
struct segt {
long long wt, d;
segt operator+(segt other) const {
segt ret;
ret.wt = this->wt + other.wt;
ret.d = (this->d + other.d) % mod;
return ret;
}
};
segt tree[524292];
long long x[524292], w[524292];
int n, q;
void build(int l, int r, int index) {
if (l > r) return;
if (l == r) {
tree[index].wt = w[l];
tree[index].d = w[l] * (x[l] - l);
return;
}
build(l, ((l + r) >> 1), (index << 1));
build(((l + r) >> 1) + 1, r, (index << 1 | 1));
tree[index] = tree[(index << 1)] + tree[(index << 1 | 1)];
}
void update(int pt, int l, int r, int index, long long val) {
if (l > r || pt < l || pt > r) return;
if (l == r) {
w[pt] = val;
tree[index].wt = w[pt];
tree[index].d = w[pt] * (x[pt] - l);
return;
}
if (pt <= ((l + r) >> 1)) {
update(pt, l, ((l + r) >> 1), (index << 1), val);
} else {
update(pt, ((l + r) >> 1) + 1, r, (index << 1 | 1), val);
}
tree[index] = tree[(index << 1)] + tree[(index << 1 | 1)];
}
segt query(int start, int end, int l, int r, int index) {
if (start > end || l > r || start > r || l > end) return tree[0];
if (start <= l && r <= end) return tree[index];
if (end <= ((l + r) >> 1)) {
return query(start, end, l, ((l + r) >> 1), (index << 1));
}
if (start >= ((l + r) >> 1) + 1) {
return query(start, end, ((l + r) >> 1) + 1, r, (index << 1 | 1));
}
return query(start, end, l, ((l + r) >> 1), (index << 1)) +
query(start, end, ((l + r) >> 1) + 1, r, (index << 1 | 1));
}
int main() {
int i;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; ++i) {
scanf("%I64d", &x[i]);
}
for (i = 1; i <= n; ++i) {
scanf("%I64d", &w[i]);
}
build(1, n, 1);
while (q-- > 0) {
long long L, R;
scanf("%I64d%I64d", &L, &R);
if (L < 0) {
update(-L, 1, n, 1, R);
} else {
if (L == R) {
printf("0\n");
continue;
}
int low = L, high = R;
int pivot = low;
auto W = query(L, R, 1, n, 1).wt;
while (low <= high) {
int mid = (low + high) >> 1;
auto ret1 = query(L, mid, 1, n, 1);
if (ret1.wt >= W - ret1.wt) {
pivot = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
auto ret1 = query(L, pivot, 1, n, 1);
auto ret2 = query(pivot + 1, R, 1, n, 1);
long long cost1 = (x[pivot] - pivot) * (ret1.wt % mod) - ret1.d;
long long cost2 = ret2.d + (ret2.wt % mod) * (pivot - x[pivot]);
long long ans = (cost1 + cost2) % mod;
if (ans < 0) ans += mod;
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
class FenwickTree {
public:
FenwickTree(int _n) : n(_n), data(n, 0) {}
void add(int x, long long v) {
for (; x < n; x |= x + 1) {
data[x] += v;
}
}
long long get(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += data[x];
}
return res;
}
int search(long long tar, int upper) {
int res = 0;
int LOG = 1;
while (1 << LOG < upper) {
++LOG;
}
long long sum = 0;
for (int i = LOG; i >= 0; --i) {
if (res + (1 << i) - 1 < upper) {
if (2LL * (sum + data[res + (1 << i) - 1]) <= tar) {
sum += data[res + (1 << i) - 1];
res |= 1 << i;
}
}
}
return res;
}
private:
int n;
vector<long long> data;
};
class Solution {
public:
Solution(vector<int>& _pos, vector<int>& _cost, int _n)
: n(_n), pos(_pos), cost(_cost), cft(n + 10), pcft(n + 10) {
for (int i = 0; i < n; ++i) {
pos[i] -= i + 1;
cft.add(i, cost[i]);
pcft.add(i, mulM(cost[i], pos[i]));
}
}
void update(int x, long long v) {
cft.add(x, v - cost[x]);
pcft.add(x, mulM(v - cost[x], pos[x]));
cost[x] = v;
}
long long query(int l, int r) {
long long res = 0;
int lo = l, hi = r;
long long sum = cft.get(r) - cft.get(l - 1);
lo = cft.search(cft.get(r) + cft.get(l - 1), r);
res = subM(mulM(pos[lo], subM(cft.get(lo - 1), cft.get(l - 1))),
subM(pcft.get(lo - 1), pcft.get(l - 1)));
res = addM(res, subM(subM(pcft.get(r), pcft.get(lo - 1)),
mulM(pos[lo], subM(cft.get(r), cft.get(lo - 1)))));
return res;
}
private:
int n;
FenwickTree cft;
FenwickTree pcft;
vector<int> pos;
vector<int> cost;
long long addM(long long a, long long b) {
a += b;
a %= M;
while (a >= M) {
a -= M;
}
while (a < 0) {
a += M;
}
return a;
}
long long subM(long long a, long long b) {
a -= b;
a %= M;
while (a >= M) {
a -= M;
}
while (a < 0) {
a += M;
}
return a;
}
long long mulM(long long a, long long b) {
a *= b;
a %= M;
while (a >= M) {
a -= M;
}
while (a < 0) {
a += M;
}
return a;
}
long long powM(long long x, long long e) {
long long res = 1;
while (e > 0) {
if (e & 0x1) {
res = mulM(res, x);
}
x = mulM(x, x);
e >>= 1;
}
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> pos(n);
vector<int> cost(n);
for (int i = 0; i < n; ++i) {
cin >> pos[i];
}
for (int i = 0; i < n; ++i) {
cin >> cost[i];
}
Solution sol(pos, cost, n);
for (int i = 0, x = 0, y = 0; i < q; ++i) {
cin >> x >> y;
if (x < 0) {
x = -x;
--x;
sol.update(x, y);
} else {
--x;
--y;
cout << sol.query(x, y) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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
const int MOD = 1e9 + 7;
template <typename T1, typename T2>
void mod_add(T1 &a, T2 b) {
a += b;
if (a >= MOD) a -= MOD;
}
struct tree_node {
long long w_sum;
int aw_sum;
tree_node() : w_sum(0), aw_sum(0) {}
void join(const tree_node &other) {
w_sum += other.w_sum;
mod_add(aw_sum, other.aw_sum);
}
};
int N, LOG, Q;
vector<int> A, W;
vector<tree_node> tree;
void build_tree() {
for (int i = 1; i < 1 << LOG; i++) {
int bit = i & -i;
int position = i - bit;
for (int k = bit >> 1; k > 0; k >>= 1) {
position += k;
tree[i].join(tree[position]);
}
if (i <= N) {
tree[i].w_sum += W[i - 1];
tree[i].aw_sum = (tree[i].aw_sum + (long long)W[i - 1] * A[i - 1]) % MOD;
}
}
}
void tree_update(int index, long long w_change, int a) {
int aw_change = (MOD + w_change) * a % MOD;
for (int i = index + 1; i < 1 << LOG; i += i & -i) {
tree[i].w_sum += w_change;
mod_add(tree[i].aw_sum, aw_change);
}
}
tree_node tree_query(int count) {
tree_node answer;
for (int i = count; i > 0; i -= i & -i) answer.join(tree[i]);
return answer;
}
int solve(int start, int end) {
tree_node tree_end = tree_query(end);
tree_node tree_start = tree_query(start);
long long search = (tree_end.w_sum + tree_start.w_sum + 1) / 2;
int goal = 0;
long long w_sum = 0, aw_sum = 0;
for (int k = LOG - 1; k >= 0; k--)
if (search > w_sum + tree[goal + (1 << k)].w_sum) {
goal += 1 << k;
w_sum += tree[goal].w_sum;
aw_sum += tree[goal].aw_sum;
}
assert(start <= goal && goal < end);
long long result =
((w_sum - tree_start.w_sum) - (tree_end.w_sum - w_sum)) % MOD * A[goal] +
(tree_end.aw_sum - aw_sum) - (aw_sum - tree_start.aw_sum);
result %= MOD;
mod_add(result, MOD);
return result;
}
int main() {
IO::read_int(N);
IO::read_int(Q);
A.resize(N);
W.resize(N);
LOG = 32 - __builtin_clz(N);
assert(1 << LOG > N);
tree.resize(1 << LOG);
for (int i = 0; i < N; i++) {
IO::read_int(A[i]);
A[i] -= i;
}
for (int i = 0; i < N; i++) IO::read_int(W[i]);
build_tree();
for (int q = 0; q < Q; q++) {
int x, y;
IO::read_int(x);
IO::read_int(y);
if (x < 0) {
x = -x - 1;
tree_update(x, y - W[x], A[x]);
W[x] = y;
} else {
IO::write_int(solve(x - 1, y), '\n');
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
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
const int MOD = 1e9 + 7;
template <typename T1, typename T2>
void mod_add(T1 &a, T2 b) {
a += b;
if (a >= MOD) a -= MOD;
}
struct tree_node {
long long w_sum;
int aw_sum;
tree_node() : w_sum(0), aw_sum(0) {}
void join(const tree_node &other) {
w_sum += other.w_sum;
mod_add(aw_sum, other.aw_sum);
}
};
int N, LOG, Q;
vector<int> A, W;
vector<tree_node> tree;
void build_tree() {
for (int i = 1; i <= N; i++) {
int bit = i & -i;
int position = i - bit;
for (int k = bit >> 1; k > 0; k >>= 1) {
position += k;
tree[i].join(tree[position]);
}
tree[i].w_sum += W[i - 1];
tree[i].aw_sum = (tree[i].aw_sum + (long long)W[i - 1] * A[i - 1]) % MOD;
}
}
void tree_update(int index, long long w_change, int a) {
int aw_change = (MOD + w_change) * a % MOD;
for (int i = index + 1; i <= N; i += i & -i) {
tree[i].w_sum += w_change;
mod_add(tree[i].aw_sum, aw_change);
}
}
tree_node tree_query(int count) {
tree_node answer;
for (int i = count; i > 0; i -= i & -i) answer.join(tree[i]);
return answer;
}
int solve(int start, int end) {
tree_node tree_end = tree_query(end);
tree_node tree_start = tree_query(start);
long long search = (tree_end.w_sum + tree_start.w_sum + 1) / 2;
int goal = 0;
long long w_sum = 0, aw_sum = 0;
for (int k = LOG - 1; k >= 0; k--)
if (goal + (1 << k) <= N && search > w_sum + tree[goal + (1 << k)].w_sum) {
goal += 1 << k;
w_sum += tree[goal].w_sum;
aw_sum += tree[goal].aw_sum;
}
assert(start <= goal && goal < end);
long long result =
((w_sum - tree_start.w_sum) - (tree_end.w_sum - w_sum)) % MOD * A[goal] +
(tree_end.aw_sum - aw_sum) - (aw_sum - tree_start.aw_sum);
result %= MOD;
mod_add(result, MOD);
return result;
}
int main() {
IO::read_int(N);
IO::read_int(Q);
A.resize(N);
W.resize(N);
LOG = 32 - __builtin_clz(N);
assert(1 << LOG > N);
tree.resize(N + 1);
for (int i = 0; i < N; i++) {
IO::read_int(A[i]);
A[i] -= i;
}
for (int i = 0; i < N; i++) IO::read_int(W[i]);
build_tree();
for (int q = 0; q < Q; q++) {
int x, y;
IO::read_int(x);
IO::read_int(y);
if (x < 0) {
x = -x - 1;
tree_update(x, y - W[x], A[x]);
W[x] = y;
} else {
IO::write_int(solve(x - 1, y), '\n');
}
}
}
|
#include <bits/stdc++.h>
#pragma optimise("O3")
using namespace std;
mt19937 rnumber((long long)new char);
typedef struct Treap* Arbore;
Arbore NIL;
struct Treap {
int move_st, move_dr;
int poz, poz_min, poz_max, w, g;
int prio;
long long suma;
Arbore st, dr;
Treap(int g, int poz)
: move_st(0),
move_dr(0),
poz(poz),
poz_min(poz),
poz_max(poz),
suma(g),
w(g),
prio(rnumber()),
st(NIL),
dr(NIL),
g(1) {}
inline void recalc() {
g = 1 + st->g + dr->g;
suma = w + st->suma + dr->suma;
poz_min = min(poz, st->poz_min);
poz_max = max(poz, dr->poz_max);
move_st =
(1LL * (poz - poz_min - st->g) * w +
1LL * (dr->poz_min - poz_min - st->g - 1) * (dr->suma % 1000000007) +
st->move_st + dr->move_st) %
1000000007;
move_dr =
(1LL * (poz_max - poz - dr->g) * w +
1LL * (poz_max - st->poz_max - dr->g - 1) * (st->suma % 1000000007) +
st->move_dr + dr->move_dr) %
1000000007;
}
};
Arbore join(Arbore a, Arbore b) {
if (a == NIL) return b;
if (b == NIL) return a;
if (a->prio >= b->prio) {
a->dr = join(a->dr, b);
a->recalc();
return a;
}
b->st = join(a, b->st);
b->recalc();
return b;
}
pair<Arbore, Arbore> split_by_number(Arbore a, int nr) {
if (a == NIL) return {NIL, NIL};
if (a->st->g >= nr) {
pair<Arbore, Arbore> s = split_by_number(a->st, nr);
a->st = NIL;
a->recalc();
return {s.first, join(s.second, a)};
}
pair<Arbore, Arbore> s = split_by_number(a->dr, nr - a->st->g - 1);
a->dr = NIL;
a->recalc();
return {join(a, s.first), s.second};
}
pair<Arbore, Arbore> split_by_value(Arbore a, long long nr) {
if (a == NIL) return {NIL, NIL};
if (a->st->suma >= nr) {
pair<Arbore, Arbore> s = split_by_value(a->st, nr);
a->st = NIL;
a->recalc();
return {s.first, join(s.second, a)};
}
pair<Arbore, Arbore> s = split_by_value(a->dr, nr - a->st->suma - a->w);
a->dr = NIL;
a->recalc();
return {join(a, s.first), s.second};
}
Arbore update(Arbore a, int poz, int w) {
pair<Arbore, Arbore> s1 = split_by_number(a, poz);
pair<Arbore, Arbore> s2 = split_by_number(s1.first, poz - 1);
s2.second->w = w;
s2.second->recalc();
return join(s2.first, join(s2.second, s1.second));
}
inline Arbore query(Arbore a, int st, int dr) {
pair<Arbore, Arbore> s1 = split_by_number(a, dr);
pair<Arbore, Arbore> s2 = split_by_number(s1.first, st - 1);
Arbore partea_st = s2.first, partea_dr = s1.second;
a = s2.second;
long long w = a->suma / 2;
pair<Arbore, Arbore> s = split_by_value(a, w);
long long ans = s.first->move_dr + s.second->move_st;
if (s.first == NIL || s.second == NIL)
;
else if (s.first->suma <= s.second->suma)
ans += (s.second->poz_min - s.first->poz_max - 1) *
(s.first->suma % 1000000007);
else
ans += (s.second->poz_min - s.first->poz_max - 1) *
(s.second->suma % 1000000007);
printf("%d\n", ans % 1000000007);
return join(join(partea_st, s.first), join(s.second, partea_dr));
}
int main() {
NIL = new Treap(0, 0);
NIL->g = 0;
NIL->poz_min = 1e9, NIL->poz_max = -1e9;
Arbore k = NIL;
int n, q;
scanf("%d%d", &n, &q);
vector<int> a(n), w(n);
for (auto& i : a) scanf("%d", &i);
for (auto& i : w) scanf("%d", &i);
for (int i = 0; i < n; i++) k = join(k, new Treap(w[i], a[i]));
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
if (a < 0)
k = update(k, -a, b);
else
k = query(k, a, b);
}
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;
}
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 %= mo;
ans += get2(bit1, poz - 1) - get2(bit1, l - 1);
ans %= mo;
if (ans < 0) ans += mo;
ans -= (get2(bit2, poz - 1) - get2(bit2, l - 1));
ans %= mo;
if (ans < 0) ans += mo;
}
if (poz + 1 <= r) {
long long x = a[poz] - poz;
ans += get2(bit2, r) - get2(bit2, poz);
ans %= mo;
if (ans < 0) ans += mo;
ans -= get2(bit1, r) - get2(bit1, poz);
ans %= mo;
if (ans < 0) ans += mo;
long long sumWi = get(bit, r) - get(bit, poz);
sumWi %= mo;
ans -= sumWi * x;
ans %= mo;
if (ans < 0) ans += mo;
}
printf("%lld\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1000000007;
int n, a[200001], x, y, T[200001], q, l, r, mid, ans, Ans, w[200001],
t1[200001], t2[200001];
long long t[200001];
int plus(int x, int y) { return (x + y >= mod) ? (x + y - mod) : (x + y); }
void add(int x, long long val) {
for (; x <= n; x += (x & -x)) t[x] += val;
}
long long query(int x) {
long long ans = 0;
for (; x; x -= (x & -x)) ans += t[x];
return ans;
}
void Add(int x, int val) {
for (; x <= n; x += (x & -x)) T[x] = plus(T[x], val);
}
int Query(int x) {
int ans = 0;
for (; x; x -= (x & -x)) ans = plus(ans, T[x]);
return ans;
}
long long calc(int l, int r) {
if (l > r) return 0;
return query(r) - query(l - 1);
}
int Calc(int l, int r) {
if (l > r) return 0;
return (Query(r) - Query(l - 1) + mod) % mod;
}
void add1(int x, int val) {
for (; x <= n; x += (x & -x)) t1[x] = plus(t1[x], val);
}
int query1(int x) {
int ans = 0;
for (; x; x -= (x & -x)) ans = plus(t1[x], ans);
return ans;
}
void add2(int x, int val) {
for (; x <= n; x += (x & -x)) t2[x] = plus(t2[x], val);
}
int query2(int x) {
int ans = 0;
for (; x; x -= (x & -x)) ans = plus(t2[x], ans);
return ans;
}
int calc1(int l, int r) {
if (l > r) return 0;
return (query1(r) - query1(l - 1) + mod) % mod;
}
int calc2(int l, int r) {
if (l > r) return 0;
return (query2(r) - query2(l - 1) + mod) % mod;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(t, 0, sizeof(t));
memset(T, 0, sizeof(T));
memset(t1, 0, sizeof(t1));
memset(t2, 0, sizeof(t2));
for (int i = 1; i <= n; i++)
scanf("%d", &x), add(i, x), Add(i, 1ll * x * a[i] % mod),
w[i] = x, add1(i, 1ll * i * x % mod),
add2(i, 1ll * (n - i + 1) * x % mod);
while (q--) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
add(x, y - w[x]);
Add(x, 1ll * (y - w[x] + mod) * a[x] % mod);
add1(x, 1ll * (y - w[x] + mod) * x % mod);
add2(x, 1ll * (y - w[x] + mod) * (n - x + 1) % mod);
w[x] = y;
} else {
l = x;
r = y;
ans = y + 1;
while (l <= r) {
mid = (l + r) >> 1;
if (calc(x, mid - 1) >= calc(mid, y))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
ans--;
Ans = (calc(x, ans - 1) % mod * a[ans] - Calc(x, ans - 1)) % mod;
Ans = (-calc(ans + 1, y) % mod * a[ans] + Ans + Calc(ans + 1, y)) % mod;
Ans = (Ans - calc2(x, ans - 1) + calc(x, ans - 1) % mod * (n - ans + 1)) %
mod;
Ans = (Ans - calc1(ans + 1, y) + calc(ans + 1, y) % mod * ans) % mod;
printf("%d\n", (Ans + mod) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const int maxn = 200005, mod = 1e9 + 7;
int n, m, a[maxn], w[maxn], x, y;
namespace {
inline int Add(const int &x, const int &y) {
int res = x + y;
return res >= mod ? res - mod : res;
}
inline int Sub(const int &x, const int &y) {
int res = x - y;
return res < 0 ? res + mod : res;
}
inline int Mul(const int &x, const int &y) { return 1ll * x * y % mod; }
} // namespace
namespace Segtree {
int sq[maxn << 2];
long long sum[maxn << 2];
inline void Build(int o, int l, int r) {
if (l == r) {
sq[o] = Mul(a[l], w[l]), sum[o] = w[l];
return;
}
Build(o << 1, l, ((l + r) >> 1)), Build(o << 1 | 1, ((l + r) >> 1) + 1, r);
sq[o] = Add(sq[o << 1], sq[o << 1 | 1]),
sum[o] = sum[o << 1] + sum[o << 1 | 1];
}
inline void Modify(int o, int l, int r, int x, int y) {
if (l == r) {
sq[o] = Mul(a[l], y), sum[o] = y;
return;
}
if (x <= ((l + r) >> 1))
Modify(o << 1, l, ((l + r) >> 1), x, y);
else
Modify(o << 1 | 1, ((l + r) >> 1) + 1, r, x, y);
sq[o] = Add(sq[o << 1], sq[o << 1 | 1]),
sum[o] = sum[o << 1] + sum[o << 1 | 1];
}
inline int Querys(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sq[o];
int res = 0;
if (ql <= ((l + r) >> 1))
res = Add(res, Querys(o << 1, l, ((l + r) >> 1), ql, qr));
if (qr > ((l + r) >> 1))
res = Add(res, Querys(o << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr));
return res;
}
inline long long Querya(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum[o];
long long res = 0;
if (ql <= ((l + r) >> 1)) res += Querya(o << 1, l, ((l + r) >> 1), ql, qr);
if (qr > ((l + r) >> 1))
res += Querya(o << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr);
return res;
}
inline void Printa(int o, int l, int r) {
cout << "Interval:" << l << " -> " << r << " Sum:" << sum[o] << endl;
if (l == r) return;
Printa(o << 1, l, ((l + r) >> 1)), Printa(o << 1 | 1, ((l + r) >> 1) + 1, r);
}
} // namespace Segtree
int main() {
read(n), read(m);
for (int i = 1; i <= n; ++i) read(a[i]), a[i] -= i;
for (int i = 1; i <= n; ++i) read(w[i]);
Segtree::Build(1, 1, n);
while (m--) {
read(x), read(y);
if (x < 0)
Segtree::Modify(1, 1, n, -x, y);
else {
long long tot = Segtree::Querya(1, 1, n, x, y);
tot = (tot + 1) >> 1;
int l = x, r = n, md;
while (l < r) {
md = (l + r) >> 1;
if (Segtree::Querya(1, 1, n, x, md) < tot)
l = md + 1;
else
r = md;
}
int p = l;
printf("%d\n",
Add(Sub(Mul(Segtree::Querya(1, 1, n, x, p) % mod, a[p]),
Segtree::Querys(1, 1, n, x, p)),
Sub(Segtree::Querys(1, 1, n, p + 1, y),
Mul(Segtree::Querya(1, 1, n, p + 1, y) % mod, a[p]))));
}
}
}
|
#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 + 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;
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);
long long o_sum = ll_query(mid + 1, r, w_bit);
if (cur_sum <= o_sum) {
left = mid + 1;
} else {
k = mid;
right = 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;
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, tot;
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 (sum <= 0) return;
if (ql <= l && r <= qr) {
if (l == r) {
sum -= s1[o];
pos = r;
return;
}
if (sum > s1[(o << 1)])
sum -= s1[(o << 1)], find(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
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 qry2(1, 1, n, l, r) - qry1(1, 1, n, l, r) % P * a[pos] % P;
}
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 {
sum = (1 + qry1(1, 1, n, first, second)) / 2, pos = 0;
find(1, 1, n, first, second);
printf("%lld\n", ((qry(pos, second) - qry(first, pos)) % P + P) % P);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 5;
const int MOD = 1E9 + 7;
int n, m, a[N], w[N], x, y, l, r, mid, p[N], pre[N], ne[N];
long long f[N], tr[2][N], ans, s0, s1, s2, s3, s4;
void add(int k, int x, long long w) {
for (; x <= n; x += x & -x) {
tr[k][x] += w;
if (!k) tr[k][x] %= MOD;
}
}
long long get(int k, int x) {
long long sum = 0;
for (; x; x -= x & -x) {
sum += tr[k][x];
if (!k) sum %= MOD;
}
return sum;
}
void work(int x, long long k) {
add(0, x, k * w[x] * a[x] % MOD);
add(1, x, k * w[x]);
f[p[x]] += k * w[x];
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] -= i;
p[i] = p[i - 1];
if (i == 1 || a[i] != a[i - 1]) p[i] = p[i - 1] + 1;
if (p[i] == p[i - 1])
pre[i] = pre[i - 1];
else
pre[i] = i - 1;
}
for (int i = n; i; i--)
if (p[i] == p[i + 1])
ne[i] = ne[i + 1];
else
ne[i] = i + 1;
for (int i = 1; i <= n; i++) scanf("%d", &w[i]), work(i, 1);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
work(x, -1);
w[x] = y;
work(x, 1);
} else {
l = x;
r = y;
s0 = get(1, x - 1);
s1 = get(1, y);
while (l <= r) {
mid = (l + r) / 2;
if (pre[mid] >= x)
s2 = get(1, pre[mid]) - s0;
else
s2 = 0;
if (ne[mid] <= y)
s3 = s1 - get(1, ne[mid] - 1);
else
s3 = 0;
if (ne[mid] - 1 <= y)
s4 = get(1, ne[mid] - 1);
else
s4 = s1;
if (pre[mid] >= x)
s4 -= get(1, pre[mid]);
else
s4 -= s0;
if (abs(s2 - s3) <= s4) break;
if (s2 < s3)
l = mid + 1;
else
r = mid - 1;
if (l > r)
for (;;)
;
}
ans = get(0, y) - get(0, mid) * 2 + get(0, x - 1) -
(get(1, y) - get(1, mid) * 2 + get(1, x - 1)) % MOD * a[mid] % MOD;
ans = (ans % MOD + MOD) % MOD;
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
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 string FILENAME = "input";
const int MAXN = 200228;
const int M = 1000000007;
const long long base = 1000000000000000000LL;
struct fenwick {
vector<long long> f;
int nn;
void init(int n) {
f.resize(n, 0);
nn = n;
}
void inc(int i, long long val) {
for (int j = i; j < nn; j = (j | (j + 1))) {
f[j] += val;
}
}
long long getsum(int l) {
if (l < 0) {
return 0;
}
long long t = 0;
for (int j = l; j >= 0; j = (j & (j + 1)) - 1) {
t += f[j];
}
return t;
}
long long get(int l, int r) { return getsum(r) - getsum(l - 1); }
};
struct fenwick1 {
vector<long long> f;
int nn;
void init(int n) {
f.resize(n, 0);
nn = n;
}
void inc(int i, long long val) {
for (int j = i; j < nn; j = (j | (j + 1))) {
f[j] += val;
f[j] %= M;
}
}
long long getsum(int l) {
if (l < 0) {
return 0;
}
long long t = 0;
for (int j = l; j >= 0; j = (j & (j + 1)) - 1) {
t += f[j];
t %= M;
}
return t;
}
long long get(int l, int r) { return (getsum(r) - getsum(l - 1)) % M; }
};
int n, q;
int a[MAXN];
int w[MAXN];
fenwick wss;
fenwick1 wss1;
fenwick1 pref;
fenwick1 suff;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
wss.init(n);
wss1.init(n);
pref.init(n);
suff.init(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> w[i];
wss.inc(i, w[i]);
wss1.inc(i, 1LL * w[i] * a[i] % M);
}
for (int i = 0; i < n; i++) {
pref.inc(i, 1LL * w[i] * (i + 1) % M);
}
for (int i = 0; i < n; i++) {
suff.inc(i, 1LL * w[i] * (n - i) % M);
}
for (int it = 0; it < q; it++) {
int first;
cin >> first;
if (first < 0) {
int second;
cin >> second;
first *= -1;
first--;
wss.inc(first, second - w[first]);
wss1.inc(first,
(1LL * second * a[first]) % M - (1LL * w[first] * a[first]) % M);
pref.inc(first, (1LL * second * (first + 1)) % M -
1LL * w[first] * (first + 1) % M);
suff.inc(first, (1LL * second * (n - first)) % M -
1LL * w[first] * (n - first) % M);
w[first] = second;
} else {
int second;
cin >> second;
first--, second--;
int l = first;
int r = second;
long long f = wss.get(first, second);
while (l != r) {
int mid = (l + r) >> 1;
long long k = wss.get(first, mid);
if (k >= f - k) {
r = mid;
} else {
l = mid + 1;
}
}
long long ans = 0;
if (first < l) {
long long t = wss1.get(first, l - 1);
long long f = 1LL * a[l] * (wss.get(first, l - 1) % M) % M;
f -= suff.get(first, l - 1);
f += (wss.get(first, l - 1) * (n - l)) % M;
f -= t;
f %= M;
if (f < 0) {
f += M;
}
ans += f;
ans %= M;
}
if (l + 1 <= second) {
long long t = wss1.get(l + 1, second);
long long f = 1LL * a[l] * (wss.get(l + 1, second) % M) % M;
f += pref.get(l + 1, second);
f -= (wss.get(l + 1, second) * (l + 1)) % M;
t -= f;
t %= M;
if (t < 0) {
t += M;
}
ans += t;
ans %= M;
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
struct fw1 {
long long b[200105];
void update(int x, long long val) {
for (int i = x; i <= n; i += i & -i) {
b[i] += val;
}
}
long long query(int x) {
long long ret = 0;
for (; x > 0; ret += b[x], x -= x & -x)
;
return ret;
}
long long qy(int l, int r) {
if (r < l) return 0;
return query(r) - query(l - 1);
}
} pw;
struct fw {
int b[200105];
void update(int x, int val) {
for (int i = x; i <= n; i += i & -i) {
addmod(b[i], val);
}
}
int query(int x) {
int ret = 0;
for (; x > 0; addmod(ret, b[x]), x -= x & -x)
;
return ret;
}
int qy(int l, int r) {
if (r < l) return 0;
return (query(r) - query(l - 1) + 1000000007) % 1000000007;
}
} pwa;
int a[200105], w[200105], aw[200105];
void upt(int id, int nw) {
pw.update(id, nw - w[id]);
w[id] = nw;
int naw = (long long)a[id] * nw % 1000000007;
pwa.update(id, (naw + 1000000007 - aw[id]) % 1000000007);
aw[id] = naw;
}
int cal(int l, int r) {
if (l == r) return 0;
long long S = pw.qy(l, r);
int L = l, R = r;
while (L + 1 < R) {
int mid = (L + R) / 2;
long long z = pw.qy(l, mid);
if (z + z < S)
L = mid + 1;
else
R = mid;
}
long long z = pw.qy(l, L);
int pos;
if (z + z < S)
pos = R;
else
pos = L;
int ans = pw.qy(l, pos - 1) % 1000000007 * a[pos] % 1000000007;
addmod(ans, 1000000007 - pwa.qy(l, pos - 1));
addmod(ans, pwa.qy(pos + 1, r));
addmod(ans,
1000000007 - pw.qy(pos + 1, r) % 1000000007 * a[pos] % 1000000007);
return ans;
}
void fmain(int ID) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", w + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) pw.update(i, w[i]);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
addmod(a[i], 1000000007 - i);
aw[i] = (long long)a[i] * w[i] % 1000000007;
pwa.update(i, aw[i]);
}
for (int(i) = 1; (i) <= (int)(m); (i)++) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
upt(-x, y);
} else {
printf("%d\n", cal(x, y));
}
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 444444, mo = 1e9 + 7;
int n, q, a[N], w[N];
long long v1[N], v2[N], v3[N];
void add(int p, long long v) {
v3[0] += v;
while (p <= n) v3[p] += v, p += p & -p;
}
long long query(int p) {
long long res = 0;
while (p) res += v3[p], p -= p & -p;
return res;
}
inline void add(long long *a, int p, long long v) {
a[0] = (a[0] + v) % mo;
while (p <= n) a[p] = (a[p] + v) % mo, p += p & -p;
}
inline long long query(long long *a, int p) {
long long res = 0;
while (p) res += a[p], p -= p & -p;
return res % mo;
}
long long getval(long long *a, int l, int r) {
l = max(l, 1);
r = min(r, n);
if (l > r) return 0;
if (l == 1) return query(a, r);
return (a[0] - query(a, l - 1) + mo) % mo;
}
long long getans(int x, int p) {
return (query(v1, x) + 1LL * query(v2, x) * (a[p] - p)) % mo;
}
int main() {
read(n);
read(q);
for (register int i = 1; i <= n; i++) read(a[i]);
for (register int i = 1; i <= n; i++)
read(w[i]), add(v1, i, 1LL * (i - a[i]) * w[i] % mo), add(v2, i, w[i]),
add(i, w[i]);
while (q--) {
int u, v;
read(u);
read(v);
if (u < 0) {
u = -u;
add(v1, u, 1LL * (u - a[u]) * (v - w[u] + mo) % mo);
add(v2, u, v - w[u]);
add(u, v - w[u]);
w[u] = v;
} else {
int l = u, r = v, p = l, L = l, R = r;
while (L <= R) {
int mid = (L + R) >> 1;
long long x = query(mid) - query(l - 1) - (query(r) - query(mid));
if (x == 0) {
p = mid;
break;
}
if (x < 0) p = mid;
if (x > 0)
R = mid - 1;
else
L = mid + 1;
}
if (p + 1 <= r && query(p) - query(l - 1) < query(r) - query(p)) p++;
long long res =
getans(p - 1, p) - getans(l - 1, p) - (getans(r, p) - getans(p, p));
printf("%lld\n", (res % mo + mo) % mo);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline void writeln(long long a) {
write(a);
puts("");
}
const long long N = 1000005, mod = 1e9 + 7;
long long n, m, tree[N], sum[N], a[N], w[N];
inline void push_up(long long nod) {
tree[nod] = (tree[nod << 1] + tree[nod << 1 | 1]) % mod;
sum[nod] = sum[nod << 1] + sum[nod << 1 | 1];
}
void build(long long l, long long r, long long nod) {
if (l == r) {
tree[nod] = a[l] * w[l] % mod;
sum[nod] = w[l];
return;
}
long long mid = (l + r) >> 1;
build(l, mid, nod << 1);
build(mid + 1, r, nod << 1 | 1);
push_up(nod);
}
void insert(long long l, long long r, long long pos, long long nod) {
if (l == r) {
tree[nod] = a[l] * w[l] % mod;
sum[nod] = w[l];
return;
}
long long mid = (l + r) >> 1;
if (pos <= mid)
insert(l, mid, pos, nod << 1);
else
insert(mid + 1, r, pos, nod << 1 | 1);
push_up(nod);
}
long long find(long long l, long long r, long long dq, long long nod) {
if (sum[nod] < dq) return 0;
if (l == r) return l;
long long mid = (l + r) >> 1;
if (sum[nod << 1] >= dq)
return find(l, mid, dq, nod << 1);
else
return find(mid + 1, r, dq - sum[nod << 1], nod << 1 | 1);
}
long long ask(long long l, long long r, long long i, long long j,
long long nod) {
if (i > j) return 0;
if (l == i && r == j) return sum[nod];
long long mid = (l + r) >> 1;
if (j <= mid)
return ask(l, mid, i, j, nod << 1);
else if (i > mid)
return ask(mid + 1, r, i, j, nod << 1 | 1);
else
return ask(l, mid, i, mid, nod << 1) +
ask(mid + 1, r, mid + 1, j, nod << 1 | 1);
}
long long Ask(long long l, long long r, long long i, long long j,
long long nod) {
if (i > j) return 0;
if (l == i && r == j) return tree[nod];
long long mid = (l + r) >> 1;
if (j <= mid)
return Ask(l, mid, i, j, nod << 1);
else if (i > mid)
return Ask(mid + 1, r, i, j, nod << 1 | 1);
else
return (Ask(l, mid, i, mid, nod << 1) +
Ask(mid + 1, r, mid + 1, j, nod << 1 | 1)) %
mod;
}
signed main() {
n = read();
m = read();
for (long long i = 1; i <= n; i++) a[i] = read() - i;
for (long long i = 1; i <= n; i++) w[i] = read();
build(1, n, 1);
for (long long i = 1; i <= m; i++) {
long long x = read(), y = read();
if (x > 0) {
long long t1 = ask(1, n, 1, x - 1, 1), t2 = ask(1, n, 1, y, 1);
long long t = find(1, n, (t2 + t1 + 1) / 2, 1);
writeln(
(((ask(1, n, x, t, 1) % mod * a[t] - Ask(1, n, x, t, 1)) +
(Ask(1, n, t + 1, y, 1) - ask(1, n, t + 1, y, 1) % mod * a[t])) %
mod +
mod) %
mod);
} else {
x = -x;
w[x] = y;
insert(1, n, x, 1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const int N = 2e5 + 5;
const int mod = 1000000007;
int n, q;
long long a[N], w[N], c1[N], c2[N];
void mdf1(int k, long long v) {
while (k <= n) c1[k] += v, k += k & -k;
}
long long qry1(int k) {
long long res = 0;
while (k) res += c1[k], k ^= k & -k;
return res;
}
void mdf2(int k, long long v) {
while (k <= n) c2[k] = (c2[k] + v) % mod, k += k & -k;
}
long long qry2(int k) {
long long res = 0;
while (k) res = (res + c2[k]) % mod, k ^= k & -k;
return res;
}
long long cal(int l, int r, int p, int op) {
long long s = (qry1(r) - qry1(l - 1)) % mod,
ss = (qry2(r) - qry2(l - 1) + mod) % mod;
if (!op)
return (ss + s * (p - r + mod)) % mod;
else
return (s * (l - p + mod) - ss + mod) % mod;
}
int main() {
n = gi();
q = gi();
for (int i = 1; i <= n; ++i) a[i] = gi();
for (int i = 1; i <= n; ++i) w[i] = gi();
for (int i = 1; i <= n; ++i)
mdf1(i, w[i]), mdf2(i, w[i] * (i - a[i] + mod) % mod);
while (q--) {
int x = gi(), y = gi();
if (x < 0)
x = -x, mdf1(x, y - w[x]),
mdf2(x, (y - w[x] + mod) * (x - a[x] + mod) % mod), w[x] = y;
else {
int l = x, r = y, res = x;
long long sum1 = qry1(x - 1), sum2 = qry1(y) - sum1;
while (l <= r) {
int mid = l + r >> 1;
if ((qry1(mid) - sum1) * 2 >= sum2)
res = mid, r = mid - 1;
else
l = mid + 1;
}
long long ans = cal(x, res, a[res], 0) + cal(res + 1, y, a[res] + 1, 1);
ans %= mod;
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
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 string FILENAME = "input";
const int MAXN = 200228;
const int M = 1000000007;
const long long base = 1000000000000000000LL;
struct fenwick {
vector<long long> f;
int nn;
void init(int n) {
f.resize(n, 0);
nn = n;
}
void inc(int i, long long val) {
for (int j = i; j < nn; j = (j | (j + 1))) {
f[j] += val;
}
}
long long getsum(int l) {
if (l < 0) {
return 0;
}
long long t = 0;
for (int j = l; j >= 0; j = (j & (j + 1)) - 1) {
t += f[j];
}
return t;
}
long long get(int l, int r) { return getsum(r) - getsum(l - 1); }
};
struct fenwick1 {
vector<long long> f;
int nn;
void init(int n) {
f.resize(n, 0);
nn = n;
}
void inc(int i, long long val) {
for (int j = i; j < nn; j = (j | (j + 1))) {
f[j] += val;
f[j] %= M;
}
}
long long getsum(int l) {
if (l < 0) {
return 0;
}
long long t = 0;
for (int j = l; j >= 0; j = (j & (j + 1)) - 1) {
t += f[j];
t %= M;
}
return t;
}
long long get(int l, int r) { return (getsum(r) - getsum(l - 1)) % M; }
};
int n, q;
int a[MAXN];
int w[MAXN];
fenwick wss;
fenwick1 wss1;
fenwick1 pref;
fenwick1 suff;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
wss.init(n);
wss1.init(n);
pref.init(n);
suff.init(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> w[i];
wss.inc(i, w[i]);
wss1.inc(i, 1LL * w[i] * a[i] % M);
}
for (int i = 0; i < n; i++) {
pref.inc(i, 1LL * w[i] * (i + 1) % M);
}
for (int i = 0; i < n; i++) {
suff.inc(i, 1LL * w[i] * (n - i) % M);
}
for (int it = 0; it < q; it++) {
int first;
cin >> first;
if (first < 0) {
int second;
cin >> second;
first *= -1;
first--;
wss.inc(first, second - w[first]);
wss1.inc(first,
(1LL * second * a[first]) % M - (1LL * w[first] * a[first]) % M);
pref.inc(first, (1LL * second * (first + 1)) % M -
1LL * w[first] * (first + 1) % M);
suff.inc(first, (1LL * second * (n - first)) % M -
1LL * w[first] * (n - first) % M);
w[first] = second;
} else {
int second;
cin >> second;
first--, second--;
int l = first;
int r = second;
long long f = wss.get(first, second);
while (l != r) {
int mid = (l + r) >> 1;
long long k = wss.get(first, mid);
if (k >= f - k) {
r = mid;
} else {
l = mid + 1;
}
}
long long ans = 0;
if (first < l) {
long long t = wss1.get(first, l - 1);
long long f = 1LL * a[l] * (wss.get(first, l - 1) % M) % M;
f -= suff.get(first, l - 1);
f += (wss.get(first, l - 1) * (n - l)) % M;
f -= t;
f %= M;
if (f < 0) {
f += M;
}
ans += f;
ans %= M;
}
if (l + 1 <= second) {
long long t = wss1.get(l + 1, second);
long long f = 1LL * a[l] * (wss.get(l + 1, second) % M) % M;
f += pref.get(l + 1, second);
f -= (wss.get(l + 1, second) * (l + 1)) % M;
t -= f;
t %= M;
if (t < 0) {
t += M;
}
ans += t;
ans %= M;
}
cout << ans << '\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("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
class FenwickTree {
public:
FenwickTree(int _n) : n(_n), data(n, 0) {}
void add(int x, long long v) {
for (; x < n; x |= x + 1) {
data[x] += v;
}
}
long long get(int x) {
long long res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
res += data[x];
}
return res;
}
private:
int n;
vector<long long> data;
};
class Solution {
public:
Solution(vector<int>& _pos, vector<int>& _cost, int _n)
: n(_n), pos(_pos), cost(_cost), cft(n + 10), pcft(n + 10) {
for (int i = 0; i < n; ++i) {
pos[i] -= i + 1;
cft.add(i, cost[i]);
pcft.add(i, mulM(cost[i], pos[i]));
}
}
void update(int x, long long v) {
cft.add(x, v - cost[x]);
pcft.add(x, mulM(v - cost[x], pos[x]));
cost[x] = v;
}
long long query(int l, int r) {
long long res = 0;
int lo = l, hi = r;
long long sum = cft.get(r) - cft.get(l - 1);
while (lo <= hi) {
int mi = lo + (hi - lo) / 2;
long long sum1 = cft.get(mi) - cft.get(l - 1);
if (sum1 * 2LL < sum) {
lo = mi + 1;
} else {
hi = mi - 1;
}
}
res = subM(mulM(pos[lo], subM(cft.get(lo - 1), cft.get(l - 1))),
subM(pcft.get(lo - 1), pcft.get(l - 1)));
res = addM(res, subM(subM(pcft.get(r), pcft.get(lo - 1)),
mulM(pos[lo], subM(cft.get(r), cft.get(lo - 1)))));
return res;
}
private:
int n;
FenwickTree cft;
FenwickTree pcft;
vector<int> pos;
vector<int> cost;
long long addM(long long a, long long b) {
a += b;
a %= M;
while (a >= M) {
a -= M;
}
while (a < 0) {
a += M;
}
return a;
}
long long subM(long long a, long long b) {
a -= b;
a %= M;
while (a >= M) {
a -= M;
}
while (a < 0) {
a += M;
}
return a;
}
long long mulM(long long a, long long b) {
a *= b;
a %= M;
while (a >= M) {
a -= M;
}
while (a < 0) {
a += M;
}
return a;
}
long long powM(long long x, long long e) {
long long res = 1;
while (e > 0) {
if (e & 0x1) {
res = mulM(res, x);
}
x = mulM(x, x);
e >>= 1;
}
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> pos(n);
vector<int> cost(n);
for (int i = 0; i < n; ++i) {
cin >> pos[i];
}
for (int i = 0; i < n; ++i) {
cin >> cost[i];
}
Solution sol(pos, cost, n);
for (int i = 0, x = 0, y = 0; i < q; ++i) {
cin >> x >> y;
if (x < 0) {
x = -x;
--x;
sol.update(x, y);
} else {
--x;
--y;
cout << sol.query(x, y) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
const int M = 1e9 + 7;
int a[N];
int w[N];
int add(int a, int b) { return (a += b) < M ? a : a - M; }
int sub(int a, int b) { return (a -= b) < 0 ? a + M : a; }
int mul(int a, int b) { return 1LL * a * b % M; }
template <class T>
struct fenwick_tree {
T tree[N];
void update(int a, T val) {
for (; a < N; a += a & -a) {
tree[a] += val;
}
}
T query(int a) {
T res = 0;
for (; a > 0; a -= a & -a) {
res += tree[a];
}
return res;
}
T query(int a, int b) { return query(b) - query(a - 1); }
};
struct mint {
int val;
mint() {}
mint(int _val) : val(_val) {}
void operator+=(mint oth) { val = add(val, oth.val); }
int operator-(mint oth) { return sub(val, oth.val); }
};
fenwick_tree<long long> ft_cnt;
fenwick_tree<mint> ft_sum;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
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];
ft_cnt.update(i, w[i]);
ft_sum.update(i, mul(w[i], a[i]));
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
ft_cnt.update(x, y - w[x]);
ft_sum.update(x, mul(sub(y, w[x]), a[x]));
w[x] = y;
} else {
long long target = (ft_cnt.query(x, y) + 1) / 2;
int lo = x;
int hi = y;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (ft_cnt.query(x, mid) < target) {
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << add(sub(mul(a[lo], ft_cnt.query(x, lo) % M),
ft_sum.query(x, lo).val),
sub(ft_sum.query(lo + 1, y).val,
mul(a[lo], ft_cnt.query(lo + 1, y) % M)))
<< "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
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;
}
int mid = (l + r) >> 1;
if (pos <= mid)
modify1((t << 1), l, mid, pos, vl);
else
modify1((t << 1 | 1), mid + 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;
}
int mid = (l + r) >> 1;
if (pos <= mid)
modify2((t << 1), l, mid, pos, vl);
else
modify2((t << 1 | 1), mid + 1, r, pos, vl);
pushup2(t);
}
long long query1_sum(int t, int l, int r, int L, int R) {
if (L <= l && r <= R) return sum1[t];
int mid = (l + r) >> 1;
if (R <= mid) return query1_sum((t << 1), l, mid, L, R);
if (L > mid) return query1_sum((t << 1 | 1), mid + 1, r, L, R);
return query1_sum((t << 1), l, mid, L, mid) +
query1_sum((t << 1 | 1), mid + 1, r, mid + 1, R);
}
int query1_pos(int t, int l, int r, int L, int R, long long vl) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (R <= mid) return query1_pos((t << 1), l, mid, L, R, vl);
if (L > mid) return query1_pos((t << 1 | 1), mid + 1, r, L, R, vl);
long long suml = query1_sum((t << 1), l, mid, L, mid);
if (suml >= vl)
return query1_pos((t << 1), l, mid, L, mid, vl);
else
return query1_pos((t << 1 | 1), mid + 1, r, mid + 1, R, vl - suml);
}
long long query2_sum(int t, int l, int r, int L, int R) {
if (L <= l && r <= R) return sum2[t];
int mid = (l + r) >> 1;
if (R <= mid) return query2_sum((t << 1), l, mid, L, R);
if (L > mid) return query2_sum((t << 1 | 1), mid + 1, r, L, R);
return add(query2_sum((t << 1), l, mid, L, mid),
query2_sum((t << 1 | 1), mid + 1, r, mid + 1, R));
}
int main() {
int i;
int n, q;
cin >> n >> q;
for (i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
}
for (i = 1; i <= n; i++) cin >> w[i];
for (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 x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
w[x] = y;
modify1(1, 1, n, x, w[x]);
modify2(1, 1, n, x, mul(a[x], w[x]));
} else {
long long sum = query1_sum(1, 1, n, x, y);
int pos = query1_pos(1, 1, n, x, y, (sum + 1) >> 1);
long long ans = 0;
ans = add(ans, mul(a[pos], add(query1_sum(1, 1, n, x, pos),
-query1_sum(1, 1, n, pos, y))));
ans = add(ans,
add(-query2_sum(1, 1, n, x, pos), query2_sum(1, 1, n, pos, y)));
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int BUFFER_SIZE = 4096;
char input_buffer[BUFFER_SIZE];
int input_pos = BUFFER_SIZE;
int input_read = BUFFER_SIZE;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
void _update_input_buffer() {
if (input_pos >= input_read && input_read == BUFFER_SIZE) {
input_read = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
}
}
char next_char(bool advance = true) {
_update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
void skip_whitespace() {
while (isspace(next_char(false))) 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 (isdigit(next_char(false))) number = 10 * number + (next_char() - '0');
if (negative) number = -number;
}
void flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
void write_char(char c) {
if (output_pos == BUFFER_SIZE) flush_output();
output_buffer[output_pos++] = c;
}
template <typename T>
void write_int(T number, char after = 0) {
if (number < 0) {
write_char('-');
number = -number;
}
static char number_buffer[100];
int length = 0;
do {
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);
}
bool exit_success = atexit(flush_output) == 0;
} // namespace IO
const int MOD = 1e9 + 7;
template <typename T1, typename T2>
void mod_add(T1 &a, T2 b) {
a += b;
if (a >= MOD) a -= MOD;
}
struct tree_node {
long long w_sum;
int aw_sum;
tree_node() : w_sum(0), aw_sum(0) {}
void join(const tree_node &other) {
w_sum += other.w_sum;
mod_add(aw_sum, other.aw_sum);
}
};
int N, LOG, Q;
vector<int> A, W;
vector<tree_node> tree;
void build_tree() {
for (int i = 1; i <= N; i++) {
for (int k = (i & -i) >> 1; k > 0; k >>= 1) tree[i].join(tree[i - k]);
tree[i].w_sum += W[i - 1];
tree[i].aw_sum = (tree[i].aw_sum + (long long)W[i - 1] * A[i - 1]) % MOD;
}
}
void tree_update(int index, long long w_change, int a) {
int aw_change = (MOD + w_change) * a % MOD;
for (int i = index + 1; i <= N; i += i & -i) {
tree[i].w_sum += w_change;
mod_add(tree[i].aw_sum, aw_change);
}
}
tree_node tree_query(int count) {
tree_node answer;
for (int i = count; i > 0; i -= i & -i) answer.join(tree[i]);
return answer;
}
int solve(int start, int end) {
tree_node tree_end = tree_query(end);
tree_node tree_start = tree_query(start);
long long search = (tree_end.w_sum + tree_start.w_sum + 1) / 2;
int goal = 0;
long long w_sum = 0, aw_sum = 0;
for (int k = LOG - 1; k >= 0; k--)
if (goal + (1 << k) <= N && search > w_sum + tree[goal + (1 << k)].w_sum) {
goal += 1 << k;
w_sum += tree[goal].w_sum;
aw_sum += tree[goal].aw_sum;
}
assert(start <= goal && goal < end);
long long result =
((w_sum - tree_start.w_sum) - (tree_end.w_sum - w_sum)) % MOD * A[goal] +
(tree_end.aw_sum - aw_sum) - (aw_sum - tree_start.aw_sum);
result %= MOD;
mod_add(result, MOD);
return result;
}
int main() {
assert(IO::exit_success);
IO::read_int(N);
IO::read_int(Q);
A.resize(N);
W.resize(N);
LOG = 32 - __builtin_clz(N);
assert(1 << LOG > N);
tree.resize(N + 1);
for (int i = 0; i < N; i++) {
IO::read_int(A[i]);
A[i] -= i;
}
for (int i = 0; i < N; i++) IO::read_int(W[i]);
build_tree();
for (int q = 0; q < Q; q++) {
int x, y;
IO::read_int(x);
IO::read_int(y);
if (x < 0) {
x = -x - 1;
tree_update(x, y - W[x], A[x]);
W[x] = y;
} else {
IO::write_int(solve(x - 1, y), '\n');
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long aw[200001], w[200001], p[200001], st[200001], sumst[200001],
sumaw[200001], sumw[200001], cd, mod = 1e9 + 7, q, x, y;
void update(long long a[], long long x, long long val, int type) {
while (x <= cd) {
a[x] += val;
if (type == 0) a[x] %= mod;
x += (x & -x);
}
}
void inp() {
cin >> cd >> q;
for (long long i = 1; i <= cd; i++) cin >> p[i];
for (long long i = 1; i <= cd; i++) cin >> w[i];
for (long long i = 1; i <= cd; i++) {
update(sumaw, i, w[i] * p[i], 0);
aw[i] = w[i] * p[i];
update(sumw, i, w[i], 1);
update(sumst, i, w[i] * i, 0);
st[i] = w[i] * i;
}
}
long long get(long long a[], long long x, long long type) {
long long k = 0;
while (x > 0) {
k += a[x];
if (type == 0) k %= mod;
x -= (x & -x);
}
return k;
}
long long getaw(long long l, long long r) {
if (l > r) return 0;
return (get(sumaw, r, 0) - get(sumaw, l - 1, 0) + mod * 5) % mod;
}
long long getw(long long l, long long r) {
if (l > r) return 0;
return (get(sumw, r, 1) - get(sumw, l - 1, 1));
}
long long getst(long long l, long long r, long long st) {
if (l > r) return 0;
return (get(sumst, r, 0) - get(sumst, l - 1, 0) -
(l - st) * (getw(l, r) % mod) % mod + mod * 10) %
mod;
}
void do_it() {
for (long long i = 1; i <= q; i++) {
cin >> x >> y;
if (x < 0) {
x = -x;
update(sumw, x, y - w[x], 1);
w[x] = y;
update(sumaw, x, y * p[x] - aw[x], 0);
aw[x] = y * p[x];
update(sumst, x, y * x - st[x], 0);
st[x] = y * x;
} else {
long long l = x, r = y, pos, need = (getw(l, r) + 1) / 2;
while (r >= l) {
long long mid = (l + r) / 2;
if (getw(x, mid) >= need)
pos = mid, r = mid - 1;
else
l = mid + 1;
}
long long t = pos;
pos = p[pos] - (pos - x);
cout << (-(getaw(x, t) - getw(x, t) % mod * pos % mod - getst(x, t, 0) +
mod * 5) +
(getaw(t + 1, y) - getw(t + 1, y) % mod * pos % mod -
getst(t + 1, y, t - x + 1)) +
mod * 1000) %
mod
<< '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
inp(), do_it();
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast", "unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = numeric_limits<long long>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
inline void solve(), read();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read();
solve();
return 0;
}
const long long R = 1e9 + 7;
struct fenwick {
long long n;
vector<long long> t;
long long r = 0;
fenwick() {}
fenwick(long long n_) {
n = n_;
t.resize(n);
}
long long f(long long i) { return i & (i + 1); }
long long h(long long i) { return i | (i + 1); }
void inc(long long ind, long long d) {
if (r) {
d %= R;
d += R;
d %= R;
}
for (long long i = ind; i < n; i = h(i)) {
t[i] += d;
if (r) {
t[i] %= R;
}
}
}
long long sum(long long ind) {
long long ans = 0;
for (long long i = ind; i >= 0; i = f(i) - 1) {
ans += t[i];
if (r) {
ans %= R;
}
}
return ans;
}
long long sum(long long l, long long r) {
if (!this->r) {
return sum(r) - sum(l - 1);
} else {
return (sum(r) - sum(l - 1) + R) % R;
}
}
};
long long n, q;
vector<long long> a, w;
fenwick f, g;
long long binsearch(long long L, long long R) {
long long l = L, r = R;
long long s = f.sum(l, r);
while (r - l > 1) {
long long m = (l + r) / 2;
if (2 * f.sum(L, m) > s) {
r = m;
} else {
l = m;
}
}
if (2 * f.sum(L, l) >= s) {
return l;
} else {
return r;
}
}
inline void query1(long long x, long long w) {
f.inc(x, -f.sum(x, x));
f.inc(x, w);
g.inc(x, -g.sum(x, x));
g.inc(x, a[x] * w);
}
inline long long query2(long long l, long long r) {
long long k = binsearch(l, r);
long long ansl =
(f.sum(l, k - 1) % R * a[k] % R - g.sum(l, k - 1) % R + R) % R;
long long ansr =
(g.sum(k + 1, r) % R - f.sum(k + 1, r) % R * a[k] % R + R) % R;
long long ans = (ansl + ansr) % R;
return ans;
}
inline void solve() {
f = fenwick(n + 1), g = fenwick(n + 1);
g.r = 1;
for (long long i = 1; i <= n; i++) {
f.inc(i, w[i]);
g.inc(i, w[i] * a[i]);
}
for (long long i = 0; i < q; i++) {
long long x, y;
cin >> x >> y;
if (x < 0) {
query1(-x, y);
} else {
long long ans = query2(x, y);
cout << ans << "\n";
}
}
}
inline void read() {
cin >> n >> q;
a.resize(n + 1), w.resize(n + 1);
for (long long i = 1; i <= n; i++) {
cin >> a[i];
a[i] -= i;
}
for (long long i = 1; i <= n; i++) {
cin >> w[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {-1, -2, 1, -2, 2, -1, 2, 1}, ddy[] = {-2, -1, -2, 1, -1, 2, 1, 2};
long long a[200001], b[200001];
long long tree1[524288], tree2[524288];
void init(int node, int S, int E) {
if (S == E) {
tree1[node] = (a[S] * b[S]) % MOD;
tree2[node] = b[S];
return;
}
init(2 * node, S, (S + E) / 2);
init(2 * node + 1, (S + E) / 2 + 1, E);
tree1[node] = (tree1[node * 2] + tree1[node * 2 + 1]) % MOD;
tree2[node] = tree2[node * 2] + tree2[node * 2 + 1];
}
void upd(int node, int S, int E, int k) {
if (S == E) {
tree1[node] = (a[S] * b[S]) % MOD;
tree2[node] = b[S];
return;
}
if (k <= (S + E) / 2)
upd(node * 2, S, (S + E) / 2, k);
else
upd(node * 2 + 1, (S + E) / 2 + 1, E, k);
tree1[node] = (tree1[node * 2] + tree1[node * 2 + 1]) % MOD;
tree2[node] = tree2[node * 2] + tree2[node * 2 + 1];
}
pair<long long, long long> operator+(const pair<long long, long long> &p1,
const pair<long long, long long> &p2) {
return make_pair((p1.first + p2.first) % MOD, p1.second + p2.second);
}
pair<long long, long long> find(int node, int S, int E, int i, int j) {
if (i > E || j < S) return {0, 0};
if (i <= S && j >= E) return {tree1[node], tree2[node]};
return find(node * 2, S, (S + E) / 2, i, j) +
find(node * 2 + 1, (S + E) / 2 + 1, E, i, j);
}
int findK(int node, int S, int E, long long k) {
if (S == E) return S;
if (k <= tree2[node * 2]) return findK(node * 2, S, (S + E) / 2, k);
return findK(node * 2 + 1, (S + E) / 2 + 1, E, k - tree2[node * 2]);
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int(i) = (1); (i) <= (n); (i) += (1)) {
scanf("%lld", a + i);
a[i] -= i;
}
for (int(i) = (1); (i) <= (n); (i) += (1)) scanf("%lld", b + i);
init(1, 1, n);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x > 0) {
long long k = (find(1, 1, n, x, y).second + 1) / 2;
int i = findK(1, 1, n, k + find(1, 1, n, 1, x - 1).second);
pair<long long, long long> s1 = find(1, 1, n, x, i - 1),
s2 = find(1, 1, n, i + 1, y);
long long ans =
((s1.second * a[i] - s1.first) + (s2.first - s2.second * a[i])) % MOD;
if (ans < 0) ans += MOD;
printf("%lld\n", ans);
} else {
x = -x;
b[x] = y;
upd(1, 1, n, x);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int MOD = 1e9 + 7;
struct mint {
int x;
mint(long long arg) {
x = arg % MOD;
if (x < 0) x += MOD;
}
mint() : x(0) {}
void operator+=(const mint &rhs) {
x += rhs.x;
if (x >= MOD) x -= MOD;
}
void operator-=(const mint &rhs) {
x -= rhs.x;
if (x < 0) x += MOD;
}
mint operator+(const mint &rhs) const {
mint tmp = *this;
tmp += rhs;
return tmp;
}
mint operator-(const mint &rhs) const {
mint tmp = *this;
tmp -= rhs;
return tmp;
}
mint operator*(const mint &rhs) const { return (long long)x * rhs.x % MOD; }
};
template <typename T>
struct fenwick {
T f[MAXN];
fenwick() {
for (int i = 0; i < MAXN; i++) f[i] = 0;
}
void update(int x, T val) {
for (; x < MAXN; x += x & -x) f[x] += val;
}
T get(int x) {
T res = 0;
for (; x; x -= x & -x) res += f[x];
return res;
}
};
int N, Q;
int a[MAXN], w[MAXN];
fenwick<long long> sum;
fenwick<mint> weight;
void load() {
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);
}
mint query(int l, int r) {
int lo = l, hi = r + 1;
long long pref = sum.get(l - 1);
long long tot = sum.get(r) - pref;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (2 * (sum.get(mid) - pref) >= tot)
hi = mid;
else
lo = mid + 1;
}
return mint(a[lo]) * mint(2 * sum.get(lo) - sum.get(l - 1) - sum.get(r)) +
weight.get(l - 1) + weight.get(r) - mint(2) * weight.get(lo);
}
void solve() {
for (int i = 1; i <= N; i++) {
a[i] -= i;
sum.update(i, w[i]);
weight.update(i, mint(a[i]) * mint(w[i]));
}
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
sum.update(x, y - w[x]);
weight.update(x, mint(a[x]) * mint(y - w[x]));
w[x] = y;
} else
printf("%d\n", query(x, y).x);
}
}
int main() {
load();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200005, mod = 1000000007;
int n, q, a[N], b[N], w[N];
void up(long long &x, int y) { x += y - mod, x += x >> 63 & mod; }
void up(long long &x, int y, int z) { x = (x + (long long)y * z) % mod; }
long long bit0[N], bit1[N];
void modify(int x, int d) {
int y = (long long)(d + mod) * (b[x] + mod) % mod;
for (; x <= n; x += x & -x) bit0[x] += d, up(bit1[x], y);
}
long long query(long long *bit, int l, int r) {
long long ans = 0;
for (; r; r &= r - 1) ans += bit[r];
for (--l; l; l &= l - 1) ans -= bit[l];
return ans;
}
int query(int l, int r) {
int L = l, R = r, ans = -1;
long long sum = query(bit0, l, r);
while (L <= R) {
int mid = L + R >> 1;
if (2 * query(bit0, l, mid) >= sum)
ans = mid, R = mid - 1;
else
L = mid + 1;
}
int x = (b[ans] + mod) % mod;
int left = query(bit0, l, ans - 1) % mod;
int right = query(bit0, ans + 1, r) % mod;
int _left = query(bit1, l, ans - 1) % mod;
int _right = query(bit1, ans + 1, r) % mod;
return (mod - _left + (long long)x * left + (long long)(mod - x) * right +
_right) %
mod;
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> q;
for (int i = 1; i <= n; ++i) std::cin >> a[i], b[i] = a[i] - i;
for (int i = 1; i <= n; ++i) std::cin >> w[i];
for (int i = 1; i <= n; ++i)
bit0[i] = w[i], bit1[i] = (long long)w[i] * (a[i] - i + mod) % mod;
for (int i = 1; i <= n; ++i) {
int j = i + (i & -i);
if (j <= n) bit0[j] += bit0[i], up(bit1[j], bit1[i]);
}
while (q--) {
int x, y;
std::cin >> x >> y;
if (x < 0)
modify(-x, y - w[-x]), w[-x] = y;
else
std::cout << query(x, y) << '\n';
}
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 lw = weights.query(l, med);
long long ans = ((weights.query(l, med) * 2 - wtot) % MOD) * a[med] -
wx.query(l, med) + wx.query(med, r + 1);
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;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
int a[maxn], w[maxn], sm[maxn << 2], sm2[maxn << 2], n;
long long t[maxn << 2];
void pushup(int rt) {
t[rt] = t[rt << 1] + t[rt << 1 | 1];
sm[rt] = (sm[rt << 1] + sm[rt << 1 | 1]) % mod;
sm2[rt] = (sm2[rt << 1] + sm2[rt << 1 | 1]) % mod;
}
void build(int rt, int l, int r) {
if (l == r) {
t[rt] = w[l];
sm[rt] = 1ll * w[l] * (a[n] - a[l] - (n - l)) % mod;
sm2[rt] = 1ll * w[l] * (a[l] - a[1] - (l - 1)) % mod;
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void cg(int rt, int l, int r, int x, int v) {
if (l == r) {
t[rt] = v;
sm[rt] = 1ll * v * (a[n] - a[l] - (n - l)) % mod;
sm2[rt] = 1ll * v * (a[l] - a[1] - (l - 1)) % mod;
return;
}
int mid = l + r >> 1;
if (x <= mid)
cg(rt << 1, l, mid, x, v);
else
cg(rt << 1 | 1, mid + 1, r, x, v);
pushup(rt);
}
long long qry(int rt, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) return t[rt];
int mid = l + r >> 1;
long long ans = 0;
if (ql <= mid) ans += qry(rt << 1, l, mid, ql, qr);
if (qr >= mid + 1) ans += qry(rt << 1 | 1, mid + 1, r, ql, qr);
return ans;
}
int qrysm(int rt, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) return sm[rt];
int mid = l + r >> 1;
int ans = 0;
if (ql <= mid) ans = (ans + qrysm(rt << 1, l, mid, ql, qr)) % mod;
if (qr >= mid + 1) ans = (ans + qrysm(rt << 1 | 1, mid + 1, r, ql, qr)) % mod;
return ans;
}
int qrysm2(int rt, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) return sm2[rt];
int mid = l + r >> 1;
int ans = 0;
if (ql <= mid) ans = (ans + qrysm2(rt << 1, l, mid, ql, qr)) % mod;
if (qr >= mid + 1)
ans = (ans + qrysm2(rt << 1 | 1, mid + 1, r, ql, qr)) % mod;
return ans;
}
int fd(int rt, int l, int r, int ql, int qr, long long &val) {
int mid = l + r >> 1;
if (l >= ql && r <= qr) {
if (t[rt] == val) {
val -= t[rt];
return r;
} else if (t[rt] < val) {
val -= t[rt];
return r + 1;
} else if (t[rt] > val) {
if (l == r) {
val -= t[rt];
return l;
}
int ans = fd(rt << 1, l, mid, ql, qr, val);
if (val <= 0) return ans;
ans = fd(rt << 1 | 1, mid + 1, r, ql, qr, val);
return ans;
}
} else {
int ans = 0;
if (ql <= mid) {
ans = fd(rt << 1, l, mid, ql, qr, val);
if (val <= 0) return ans;
}
if (qr >= mid + 1) {
ans = fd(rt << 1 | 1, mid + 1, r, ql, qr, val);
if (val <= 0) return ans;
}
}
return r + 1;
}
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("%d", &w[i]);
build(1, 1, n);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
cg(1, 1, n, x, y);
} else {
long long sum = qry(1, 1, n, x, y);
sum = (sum + 1) / 2;
int id = fd(1, 1, n, x, y, sum);
int ans = qrysm(1, 1, n, x, id);
ans = (ans - 1ll * qry(1, 1, n, x, id) % mod * (a[n] - a[id] - (n - id)) %
mod) %
mod;
ans = (ans + qrysm2(1, 1, n, id, y)) % mod;
ans = (ans - 1ll * qry(1, 1, n, id, y) % mod * (a[id] - a[1] - (id - 1)) %
mod) %
mod;
ans = (ans + mod) % mod;
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(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)); }
int mul(int a, int b) { return int((a * 1ll * b) % MOD); }
const int N = 200 * 1000 + 555;
int n, q;
int a[N], w[N];
inline bool read() {
if (!(cin >> n >> q)) return false;
for (int i = int(0); i < int(n); i++) assert(scanf("%d", &a[i]) == 1);
for (int i = int(0); i < int(n); i++) assert(scanf("%d", &w[i]) == 1);
return true;
}
long long fW[N], fAW[N];
void inc(long long f[N], int pos, long long val) {
for (; pos < N; pos |= pos + 1) f[pos] += val;
}
long long sum(long long f[N], int pos) {
long long ans = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) ans += f[pos];
return ans;
}
long long getSum(long long f[N], int l, int r) {
return sum(f, r - 1) - sum(f, l - 1);
}
int getNSum(long long f[N], int l, int r) {
return norm(sum(f, r - 1) - sum(f, l - 1));
}
inline void solve() {
for (int i = int(0); i < int(n); i++) {
a[i] -= i;
inc(fW, i, w[i]);
inc(fAW, i, mul(a[i], w[i]));
}
for (int _ = int(0); _ < int(q); _++) {
int x, y;
assert(scanf("%d%d", &x, &y) == 2);
if (x < 0) {
x = -x - 1;
inc(fW, x, -w[x]);
inc(fAW, x, -mul(a[x], w[x]));
w[x] = y;
inc(fW, x, w[x]);
inc(fAW, x, mul(a[x], w[x]));
} else {
x--;
long long sum = getSum(fW, x, y);
int lf = x, rg = y;
while (rg - lf > 1) {
int mid = (lf + rg) >> 1;
if (2 * getSum(fW, x, mid) > sum)
rg = mid;
else
lf = mid;
}
assert(x <= lf && lf < y);
int ans = norm(mul(a[lf], getNSum(fW, x, lf)) - getNSum(fAW, x, lf));
ans = norm(ans +
norm(getNSum(fAW, lf, y) - mul(a[lf], getNSum(fW, lf, y))));
printf("%d\n", ans);
}
}
}
int main() {
cout << fixed << setprecision(15);
if (read()) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
long long MOD = 1e9 + 7;
long long arr[200005];
long long wt[200005];
long long BIT[2][200005];
void upd(int p, long long v, int t) {
for (int i = p; i <= N; i += i & -i) {
BIT[t][i] += v;
if (t) {
BIT[t][i] %= MOD;
if (BIT[t][i] < 0) {
BIT[t][i] += MOD;
}
}
}
}
long long query(int p, int t) {
long long ret = 0;
for (int i = p; i; i -= i & -i) {
ret += BIT[t][i];
if (t) {
ret %= MOD;
if (ret < 0) {
ret += MOD;
}
}
}
return ret;
}
int binlft(long long t, int s) {
t += query(s - 1, 0);
int idx = 0;
long long sum = 0;
for (int i = 18; i >= 0; i--) {
if (idx + (1 << i) <= N && BIT[0][idx + (1 << i)] + sum < t) {
idx += (1 << i);
sum += BIT[0][idx];
}
}
return idx + 1;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> Q;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
arr[i] -= i;
}
for (int i = 1; i <= N; i++) {
cin >> wt[i];
upd(i, wt[i], 0);
upd(i, wt[i] * arr[i], 1);
}
while (Q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x = -x;
upd(x, -wt[x], 0);
upd(x, -wt[x] * arr[x], 1);
wt[x] = y;
upd(x, wt[x], 0);
upd(x, wt[x] * arr[x], 1);
} else {
long long rng = query(y, 0) - query(x - 1, 0);
int idx = binlft((rng + 1) / 2, x);
long long ans = (query(idx, 0) - query(x - 1, 0)) * arr[idx] -
(query(idx, 1) - query(x - 1, 1));
ans += query(y, 1) - query(idx, 1) -
(query(y, 0) - query(idx, 0)) * arr[idx];
ans %= MOD;
if (ans < 0) {
ans += MOD;
}
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 100;
const int MOD = 1e9 + 7;
const long long MODM = static_cast<long long>(MOD) * 100;
int w[MAXN], x[MAXN];
int N, Q;
int prod(int a, int b) {
if (a > 0 xor b > 0)
return -static_cast<int>((static_cast<long long>(-a) * b) % MOD);
return static_cast<int>((static_cast<long long>(a) * b) % MOD);
}
int sum(int a, int b) {
return static_cast<int>((static_cast<long long>(a) + b + MODM) % MOD);
}
int dif(int a, int b) {
return static_cast<int>((static_cast<long long>(a) - b + MODM) % MOD);
}
struct NODE {
public:
int wl, wr;
int ws;
NODE* l;
NODE* r;
NODE() {
l = nullptr;
r = nullptr;
}
};
struct ST {
public:
NODE* h;
int s;
ST() { h = nullptr; }
ST(int v) {
s = v;
h = new NODE();
init(h, 0, s);
}
void init(NODE* n, int nl, int nr) {
n->wl = n->wr = n->ws = 0;
for (int i = nl; i < nr; i++) {
n->ws = sum(n->ws, w[i]);
n->wl = sum(n->wl, prod(w[i], x[i] - x[nl] - (i - nl)));
n->wr = sum(n->wr, prod(w[i], x[nr - 1] - x[i] - (nr - 1 - i)));
}
if (nr - nl > 1) {
int m = nl + (nr - nl) / 2;
n->l = new NODE();
init(n->l, nl, m);
n->r = new NODE();
init(n->r, m, nr);
}
}
void upd(int id, int nw) { upd(h, 0, s, id, nw); }
void upd(NODE* n, int nl, int nr, int id, int nw) {
assert(nl <= id and id < nr);
n->ws = sum(n->ws, dif(nw, w[id]));
n->wl = sum(n->wl, prod(x[id] - x[nl] - (id - nl), dif(nw, w[id])));
n->wr = sum(n->wr, prod(x[nr - 1] - x[id] - (nr - 1 - id), dif(nw, w[id])));
if (nr - nl > 1) {
int m = nl + (nr - nl) / 2;
if (id < m) upd(n->l, nl, m, id, nw);
if (id >= m) upd(n->r, m, nr, id, nw);
}
}
int ql(int gl, int gr, int g) { return ql(h, 0, s, gl, gr, g); }
int ql(NODE* n, int nl, int nr, int gl, int gr, int g) {
if (gl >= gr or gr <= nl or nr <= gl) return 0;
assert(g < nr);
if (g <= nl and gl <= nl and gr >= nr)
return sum(n->wl, prod(n->ws, x[nl] - x[g] - (nl - g)));
int ret = 0;
if (nr - nl > 1) {
int m = nl + (nr - nl) / 2;
if (nr > m) ret = ql(n->r, m, nr, gl, gr, g);
if (nl < m and g < m) ret = sum(ret, ql(n->l, nl, m, gl, gr, g));
}
return ret;
}
int qr(int gl, int gr, int g) { return qr(h, 0, s, gl, gr, g); }
int qr(NODE* n, int nl, int nr, int gl, int gr, int g) {
if (gl >= gr or nl >= gr or gl >= nr) return 0;
assert(g >= nl);
if (g >= nr and gl <= nl and gr >= nr)
return sum(n->wr, prod(n->ws, x[g] - x[nr - 1] - (g - nr + 1)));
int ret = 0;
if (nr - nl > 1) {
int m = nl + (nr - nl) / 2;
if (nl < m) ret = qr(n->l, nl, m, gl, gr, g);
if (nr > m and g >= m) ret = sum(ret, qr(n->r, m, nr, gl, gr, g));
}
return ret;
}
} st;
struct BIT {
long long arr[MAXN];
int s, l2s;
BIT() { s = 0; }
BIT(int v) {
s = v;
for (l2s = 1; l2s <= s; l2s <<= 1)
;
for (int i = 1; i <= s; i++) arr[i] = 0;
for (int i = 0; i < s; i++) upd(i, 2 * w[i]);
}
void upd(int id, int nw) {
for (int i = id + 1; i <= s; i += (i & (-i))) arr[i] += nw - w[id];
}
long long qry(int id) {
long long ret = 0;
for (int i = id + 1; i > 0; i -= (i & (-i))) ret += arr[i];
return ret;
}
int srh(long long goal) {
int id = 0;
long long cur = 0;
for (int i = l2s; i > 0; i >>= 1) {
if (id + i > s) continue;
if (cur + arr[id + i] < goal) {
id += i;
cur += arr[id];
}
}
return id;
}
} psm;
int main() {
scanf("%d%d", &N, &Q);
for (int i = 0; i < N; i++) scanf("%d", x + i);
for (int i = 0; i < N; i++) scanf("%d", w + i);
st = ST(N);
psm = BIT(N);
int a, b;
for (int i = 0; i < Q; i++) {
scanf("%d%d", &a, &b);
if (a < 0) {
a = -a - 1;
st.upd(a, b);
psm.upd(a, b);
w[a] = b;
} else {
a--;
long long aw = psm.qry(a - 1);
long long bw = psm.qry(b - 1);
long long md = aw + (bw - aw + 1) / 2;
int m = psm.srh(md);
int ans = sum(st.ql(m, b, m), st.qr(a, m, m));
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 1e9 + 7;
int n, q, a[N], w[N];
long long ans;
void upd(int &x, int y) {
x += y;
x -= x >= mod ? mod : 0;
}
long long t[N];
void add(int x, int y) {
for (; x <= n; x += x & -x) t[x] += y;
}
long long qry(int x) {
long long s = 0;
for (; x; x -= x & -x) s += t[x];
return s;
}
int t2[N];
void add2(int x, int y) {
for (; x <= n; x += x & -x) upd(t2[x], y);
}
int qry2(int x) {
int s = 0;
for (; x; x -= x & -x) upd(s, t2[x]);
return s;
}
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]), add(i, w[i]), add2(i, (long long)w[i] * a[i] % mod);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
add(x, y - w[x]);
add2(x, (long long)(y + mod - w[x]) * a[x] % mod);
w[x] = y;
} else {
int l = x, r = y, mid;
long long tmp1 = qry(x - 1), tmp2 = qry(y);
while (l <= r) {
mid = l + r >> 1;
if (2ll * qry(mid) - tmp1 >= tmp2)
r = mid - 1;
else
l = mid + 1;
}
r++;
ans = (qry(r - 1) % mod - tmp1 % mod) * a[r] % mod -
(qry2(r - 1) - qry2(x - 1));
ans += (qry2(y) - qry2(r)) - (tmp2 % mod - qry(r) % mod) * a[r] % mod;
ans = (ans % mod + mod) % mod;
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
const int MAX = 2 * 1000 * 100 + 47;
const int MOD = 1000 * 1000 * 1000 + 7;
struct Fenvik {
long long T[MAX];
int n;
void init(int n1) { n = n1; }
void add(int i, int delta) {
for (; i < n; i = i | (i + 1)) {
T[i] += delta;
}
}
long long get(int i) {
long long res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
res = res + T[i];
}
return res;
}
long long get(int l, int r) {
long long res = get(r);
if (l) {
res -= get(l - 1);
}
return res;
}
int getNorm(int l, int r) {
long long res = get(l, r) % MOD;
if (res < 0) res += MOD;
if (res >= MOD) res -= MOD;
return res;
}
} F1, F2;
long long A[MAX];
long long W[MAX];
int n;
void upd(int pos, int val) {
long long delta = val - W[pos];
F1.add(pos, val - W[pos]);
F2.add(pos, delta * (pos - A[pos]) % MOD);
W[pos] = val;
}
int get(int x, int y) {
int l = x - 1, r = y;
long long s = F1.get(x, y);
while (r - l > 1) {
int c = (r + l) / 2;
if (2 * F1.get(x, c) >= s) {
r = c;
} else {
l = c;
}
}
int k = r;
l = x;
r = y;
long long dod1 = (A[k] - k) * F1.getNorm(l, k - 1) + F2.get(l, k - 1);
long long dod2 = (k - A[k]) * F1.getNorm(k + 1, r) - F2.get(k + 1, r);
long long res = (dod1 + dod2) % MOD;
if (res < 0) res += MOD;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> n >> q;
for (int i = (0); i < (n); i++) cin >> A[i];
for (int i = (0); i < (n); i++) cin >> W[i];
F1.init(n);
F2.init(n);
for (int i = (0); i < (n); i++) {
F1.add(i, W[i]);
F2.add(i, (i - A[i]) * W[i] % MOD);
}
for (int i = (0); i < (q); i++) {
int x, y;
cin >> x >> y;
if (x < 0) {
upd(-x - 1, y);
} else {
x--;
y--;
int res = get(x, y);
cout << res << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int MOD = (int)1e9 + 7;
int n, q;
int a[N], w[N];
inline void Add(int &a, int b) {
if ((a += b) >= MOD) a -= MOD;
if (a < 0) a += MOD;
}
namespace TR {
int taw[N];
long long tw[N];
void Ad(int x, int v1, int v2) {
for (; x <= n; x += x & -x) {
Add(taw[x], v2);
tw[x] += v1;
}
}
long long Qr_w(int x) {
long long re = 0;
for (; x; x -= x & -x) re += tw[x];
return re;
}
int Qr_a(int x) {
int re = 0;
for (; x; x -= x & -x) Add(re, taw[x]);
return re;
}
}; // namespace TR
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]);
TR::Ad(i, w[i], (long long)a[i] * w[i] % MOD);
}
for (int x, y; q; --q) {
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
TR::Ad(x, -w[x], -(long long)a[x] * w[x] % MOD);
w[x] = y;
TR::Ad(x, w[x], (long long)a[x] * w[x] % MOD);
} else {
long long lf = TR::Qr_w(x - 1), rg = TR::Qr_w(y);
int l = x, r = y;
for (int md; l < r;) {
md = (l + r) >> 1;
if (TR::Qr_w(md) - lf >= (rg - lf + 2) / 2)
r = md;
else
l = md + 1;
}
long long sr = TR::Qr_w(r);
long long ans1 = (sr - lf) % MOD * a[r] - TR::Qr_a(r) + TR::Qr_a(x - 1);
long long ans2 = TR::Qr_a(y) - TR::Qr_a(r) - (rg - sr) % MOD * a[r];
printf("%lld\n", ((ans1 + ans2) % MOD + MOD) % MOD);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int getrnd(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
template <typename T1, typename T2>
bool relax(T1& a, const T2& b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
bool strain(T1& a, const T2& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int MOD = 1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return 1LL * a * b % MOD; }
const int N = 2e5 + 3;
int n;
ll tree[4 * N], mtree[4 * N];
void build(int v, int tl, int tr, vector<ll>& a, vector<ll>& b) {
if (tl == tr) {
tree[v] = a[tl];
mtree[v] = mul(a[tl], b[tl]);
} else {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm, a, b);
build(2 * v + 1, tm + 1, tr, a, b);
tree[v] = tree[2 * v] + tree[2 * v + 1];
mtree[v] = add(mtree[2 * v], mtree[2 * v + 1]);
}
}
void update(int v, int tl, int tr, int pos, ll x, vector<ll>& b) {
if (tl == tr) {
tree[v] = x;
mtree[v] = mul(b[tl], x);
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(2 * v, tl, tm, pos, x, b);
else
update(2 * v + 1, tm + 1, tr, pos, x, b);
tree[v] = tree[2 * v] + tree[2 * v + 1];
mtree[v] = add(mtree[2 * v], mtree[2 * v + 1]);
}
}
ll get(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r)
return tree[v];
else {
int tm = (tl + tr) / 2;
return get(2 * v, tl, tm, l, min(r, tm)) +
get(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
}
ll getm(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r)
return mtree[v];
else {
int tm = (tl + tr) / 2;
return add(getm(2 * v, tl, tm, l, min(r, tm)),
getm(2 * v + 1, tm + 1, tr, max(tm + 1, l), r));
}
}
int find(int v, int tl, int tr, int l, int r, ll x) {
if (l > r) return -1;
if (tl == tr)
return tl;
else {
int tm = (tl + tr) / 2;
ll s = get(1, 0, n - 1, l, tm);
if (s >= x)
return find(2 * v, tl, tm, l, min(r, tm), x);
else
return find(2 * v + 1, tm + 1, tr, max(tm + 1, l), r, x - s);
}
}
void solve() {
int q;
cin >> n >> q;
vector<ll> a(n), w(n), y(n);
for (int i = 0; i < n; ++i) cin >> a[i], y[i] = add(a[i], -i);
for (int i = 0; i < n; ++i) cin >> w[i];
build(1, 0, n - 1, w, y);
while (q--) {
int l, r;
cin >> l >> r;
if (l < 0) {
update(1, 0, n - 1, -l - 1, r, y);
} else {
--l;
--r;
ll s = get(1, 0, n - 1, l, r);
int pos = find(1, 0, n - 1, l, r, (s + 1) / 2);
assert(pos != -1);
ll x = y[pos];
ll res =
add(-getm(1, 0, n - 1, l, pos - 1), getm(1, 0, n - 1, pos + 1, r));
res = add(res, mul(add(get(1, 0, n - 1, l, pos - 1) % MOD,
-(get(1, 0, n - 1, pos + 1, r) % MOD)),
x));
cout << res << '\n';
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
srand(time(0));
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 200000, md = 1e9 + 7;
int a[N + 1], n, q, aw[N + 1];
long long fn[N + 1];
void ad(int &x, int y) {
if ((x += y) >= md) x -= md;
}
void sb(int &x, int y) {
if ((x -= y) < 0) x += md;
}
void adf(int i, int x) {
while (i <= n) fn[i] += x, i += i & -i;
}
long long gt(int i) {
long long an = 0;
while (i) an += fn[i], i ^= i & -i;
return an;
}
long long gt(int l, int r) { return gt(r) - gt(l - 1); }
int bs(long long v) {
int j = 0;
for (int i = 17; i >= 0; --i) {
int nj = j + (1 << i);
if (nj > n) continue;
if (fn[nj] <= v) {
j = nj;
v -= fn[nj];
}
}
return j;
}
void adw(int i, int x) {
while (i <= n) {
if (x < 0)
sb(aw[i], -x);
else
ad(aw[i], x);
i += i & -i;
}
}
int gtw(int i) {
int an = 0;
while (i) ad(an, aw[i]), i ^= i & -i;
return an;
}
int gtw(int l, int r) {
int an = gtw(r);
sb(an, gtw(l - 1));
return an;
}
void an(int l, int r, int m) {
int ds = a[m];
int o = 0;
sb(o, gtw(l, m));
ad(o, gt(l, m) % md * ds % md);
ad(o, gtw(m + 1, r));
sb(o, gt(m + 1, r) % md * ds % md);
printf("%d\n", o);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i < (int)(n + 1); ++i) scanf("%d", a + i);
for (int i = 1; i < (int)(n + 1); ++i) a[i] -= i;
for (int i = 1; i < (int)(n + 1); ++i) {
int t;
scanf("%d", &t);
adw(i, (long long)a[i] * t % md);
adf(i, t);
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (l < 0) {
l = -l;
int t = (long long)a[l] * r % md;
sb(t, gtw(l, l));
adw(l, t);
adf(l, r - gt(l, l));
} else {
if (l == r) {
printf("0\n");
continue;
}
long long sg = gt(l, r) >> 1;
int i = bs(sg + gt(l - 1));
long long a = gt(l, i), b = gt(i + 1, r);
if (a > b)
an(l, r, i);
else
an(l, r, i + 1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10, mod = 1e9 + 7;
pair<long long, long long> p[maxn];
struct Fenwick {
long long sm[maxn];
void add(int ind, long long x, bool is) {
if (is) x %= mod;
while (ind < maxn) {
sm[ind] += x;
if (is) sm[ind] %= mod;
ind += (ind & -ind);
}
}
long long ask(int ind, bool is) {
long long ans = 0;
while (ind > 0) {
ans += sm[ind];
if (is) ans %= mod;
ind -= (ind & -ind);
}
return ans;
}
};
Fenwick fen1, fen2;
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = int(1); i <= int(n); i++) {
scanf("%lld", &p[i].first);
p[i].first -= i;
}
for (int i = int(1); i <= int(n); i++) {
scanf("%lld", &p[i].second);
}
for (int i = int(1); i <= int(n); i++) {
fen1.add(i, p[i].first * p[i].second, 1);
fen2.add(i, p[i].second, 0);
}
while (q--) {
long long a, b;
scanf("%lld%lld", &a, &b);
if (a < 0) {
a = -a;
fen1.add(a, -p[a].first * p[a].second, 1);
fen2.add(a, -p[a].second, 0);
p[a].second = b;
fen1.add(a, p[a].first * p[a].second, 1);
fen2.add(a, p[a].second, 0);
} else {
long long bf = fen2.ask(a - 1, 0);
long long tot = fen2.ask(b, 0) - bf;
long long l = a, r = b, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if ((2 * (fen2.ask(mid, 0) - bf)) >= tot) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
long long BF = fen1.ask(a - 1, 1);
long long ANS =
(p[ans].first * ((2 * (fen2.ask(ans, 0) - bf) - tot) % mod) -
2 * (fen1.ask(ans, 1) - BF) + (fen1.ask(b, 1) - BF)) %
mod;
if (ANS < 0) ANS += mod;
printf("%lld\n", ANS);
}
}
}
|
#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());
}
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 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;
int low = start, high = end - 1;
while (low < high) {
int mid = (low + high) / 2;
if (2 * tree.query(start, mid + 1).w_sum >= total_w)
high = mid;
else
low = mid + 1;
}
segment left = tree.query(start, low);
segment right = tree.query(low, end);
long long result = (left.w_sum - right.w_sum) % MOD * (long long)A[low] +
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;
}
tree.init(N);
for (int i = 0; i < N; i++) {
scanf("%d", &W[i]);
tree.update(i, i + 1, segment_change(W[i], A[i]));
}
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;
long long n, q, A[200010], W[200010], Sm1[800010], Sm2[800010];
void upd(long long x) {
Sm1[x] = (Sm1[x * 2] + Sm2[x * 2 + 1]) % 1000000007;
Sm2[x] = (Sm2[x * 2] + Sm2[x * 2 + 1]) % 1000000007;
}
void add1(long long x, long long v) {
for (long long i = x; i <= n; i += i & -i) Sm1[i] = Sm1[i] + v;
}
void add2(long long x, long long v) {
for (long long i = x; i <= n; i += i & -i) Sm2[i] = (Sm2[i] + v) % 1000000007;
}
long long ask1(long long x) {
long long ans = 0;
for (long long i = x; i; i -= i & -i) ans = ans + Sm1[i];
return ans;
}
long long ask2(long long x) {
long long ans = 0;
for (long long i = x; i; i -= i & -i) ans = (ans + Sm2[i]) % 1000000007;
return ans;
}
int 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]);
for (long long i = 1; i <= n; i++) {
add1(i, W[i]);
add2(i, (A[i] - i) * W[i] % 1000000007);
}
for (long long T = 1; T <= q; T++) {
long long a, b;
scanf("%lld%lld", &a, &b);
if (a > 0) {
long long o = ask1(a - 1), p = ask1(b), v = p - o;
long long ans = a;
for (long long l = a, r = b; l <= r;) {
long long md = (l + r) / 2;
if ((ask1(md) - o) * 2 >= v)
ans = md, r = md - 1;
else
l = md + 1;
}
long long tot =
(A[ans] - ans) * ((ask1(ans) - ask1(a - 1)) % 1000000007) -
(ask2(ans) - ask2(a - 1));
tot = tot + (ask2(b) - ask2(ans)) -
(A[ans] - ans) * ((ask1(b) - ask1(ans)) % 1000000007);
printf("%lld\n", (tot % 1000000007 + 1000000007) % 1000000007);
} else {
a = -a;
add1(a, -W[a]);
add2(a, -(A[a] - a) * W[a] % 1000000007);
W[a] = b;
add1(a, W[a]);
add2(a, (A[a] - a) * W[a] % 1000000007);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
x = (y < x ? y : x);
}
namespace Fread {
const int SIZE = 1 << 21;
char buf[SIZE], *S, *T;
inline char getchar() {
if (S == T) {
T = (S = buf) + fread(buf, 1, SIZE, stdin);
if (S == T) return '\n';
}
return *S++;
}
} // namespace Fread
namespace Fwrite {
const int SIZE = 1 << 21;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush() {
fwrite(buf, 1, S - buf, stdout);
S = buf;
}
inline void putchar(char c) {
*S++ = c;
if (S == T) flush();
}
struct NTR {
~NTR() { flush(); }
} ztr;
} // namespace Fwrite
namespace Fastio {
struct Reader {
template <typename T>
Reader& operator>>(T& x) {
char c = Fread ::getchar();
T f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = Fread ::getchar();
}
x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + (c - '0');
c = Fread ::getchar();
}
x *= f;
return *this;
}
Reader& operator>>(char& c) {
c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
return *this;
}
Reader& operator>>(char* str) {
int len = 0;
char c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
while (c != '\n' && c != ' ') {
str[len++] = c;
c = Fread ::getchar();
}
str[len] = '\0';
return *this;
}
Reader() {}
} cin;
const char endl = '\n';
struct Writer {
template <typename T>
Writer& operator<<(T x) {
if (x == 0) {
Fwrite ::putchar('0');
return *this;
}
if (x < 0) {
Fwrite ::putchar('-');
x = -x;
}
static int sta[45];
int top = 0;
while (x) {
sta[++top] = x % 10;
x /= 10;
}
while (top) {
Fwrite ::putchar(sta[top] + '0');
--top;
}
return *this;
}
Writer& operator<<(char c) {
Fwrite ::putchar(c);
return *this;
}
Writer& operator<<(char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer& operator<<(const char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer() {}
} cout;
} // namespace Fastio
const int MAXN = 2e5;
const int MOD = 1e9 + 7;
int n, q, a[MAXN + 5], w[MAXN + 5];
struct FenwickTree {
__int128 sum[MAXN + 5];
void point_add(int p, __int128 v) {
for (int i = p; i <= n; i += (i & (-i))) {
sum[i] += v;
}
}
__int128 presum_query(int p) {
__int128 res = 0;
for (int i = p; i; i -= (i & (-i))) {
res += sum[i];
}
return res;
}
__int128 range_sum_query(int l, int r) {
if (l > r) {
return 0;
}
return presum_query(r) - presum_query(l - 1);
}
FenwickTree() {}
};
FenwickTree T, T1, T2;
__int128 calc(int l, int r, int i) {
return T1.range_sum_query(l, i - 1) * (a[i] - i) -
T2.range_sum_query(l, i - 1) +
T1.range_sum_query(i + 1, r) * (i - a[i]) +
T2.range_sum_query(i + 1, r);
}
int main() {
Fastio ::cin >> n >> q;
for (int i = 1; i <= n; ++i) {
Fastio ::cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
Fastio ::cin >> w[i];
T1.point_add(i, w[i]);
T2.point_add(i, (__int128)w[i] * (a[i] - i));
}
while (q--) {
int x, y;
Fastio ::cin >> x >> y;
if (x < 0) {
x = -x;
__int128 d = (y - w[x]);
T1.point_add(x, d);
T2.point_add(x, d * (a[x] - x));
w[x] = y;
} else {
int l = x, r = y;
while (l < r) {
int mid = (l + r) >> 1;
if (T1.range_sum_query(x, mid) < T1.range_sum_query(mid + 1, y)) {
l = mid + 1;
} else {
r = mid;
}
}
__int128 ans = calc(x, y, l);
if (l > x) {
ckmin(ans, calc(x, y, l - 1));
}
Fastio ::cout << ans % MOD << Fastio ::endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long p[maxn], w[maxn];
long long c[maxn];
inline int lowbit(int s) { return s & (-s); }
inline void modify(int i, long long x, int n) {
while (i <= n) c[i] += x, i += lowbit(i);
}
inline long long query(int i) {
long long ret = 0;
while (i > 0) ret += c[i], i -= lowbit(i);
return ret;
}
long long C[2][maxn];
const long long mod = 1e9 + 7;
inline void Modify(int op, int i, long long x, int n) {
x = (x % mod + mod) % mod;
while (i <= n) C[op][i] = (C[op][i] + x) % mod, i += lowbit(i);
}
inline long long Query(int op, int i) {
long long ret = 0;
while (i > 0) ret = (ret + C[op][i]) % mod, i -= lowbit(i);
return ret;
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%lld", p + i);
for (int i = 1; i <= n; ++i) {
scanf("%lld", w + i);
modify(i, w[i], n);
Modify(0, i, p[i] * w[i], n);
Modify(1, i, i * w[i], n);
}
while (q--) {
long long x, y;
scanf("%lld %lld", &x, &y);
if (x < 0) {
x = -x;
modify(x, -w[x], n);
Modify(0, x, -p[x] * w[x], n);
Modify(1, x, -x * w[x], n);
w[x] = y;
modify(x, w[x], n);
Modify(0, x, p[x] * w[x], n);
Modify(1, x, x * w[x], n);
} else {
long long tmp = query(x - 1);
long long tot = query(y) - tmp;
int l = x, r = y;
while (l < r) {
int mid = (l + r) / 2;
long long now = query(mid) - tmp;
if (now + now >= tot)
r = mid;
else
l = mid + 1;
}
long long st = p[r] - (r - x);
long long suml1 = (Query(1, r) + mod - Query(1, x - 1)) % mod;
suml1 = (suml1 +
(st - x + mod) % mod * ((query(r) + mod - tmp % mod) % mod)) %
mod;
long long suml2 = (Query(0, x - 1) + mod - Query(0, r)) % mod;
st = p[r] + 1;
long long sumr1 = (Query(0, y) + mod - Query(0, r)) % mod;
long long sumr2 = (Query(1, y) + mod - Query(1, r)) % mod;
sumr2 = (sumr2 + (st - (r + 1) + mod) % mod *
((query(y) + mod - query(r) % mod) % mod)) %
mod;
sumr2 = (mod - sumr2) % mod;
long long ans = (suml1 + suml2 + sumr1 + sumr2) % mod;
printf("%lld\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 pos = query1_pos(1, 1, n, first, second, (sum + 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 = (int)2e5 + 5;
const int MOD = (int)1e9 + 7;
const int inf = 0x3f3f3f3f;
struct Seg {
long long w;
int aw, iw;
};
int w[N], a[N];
Seg seg[N << 2];
inline int addMod(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
inline Seg merge(const Seg& a, const Seg& b) {
Seg ret;
ret.aw = addMod(a.aw, b.aw);
ret.w = a.w + b.w;
ret.iw = addMod(a.iw, b.iw);
return ret;
}
inline void update(int pos, int l, int r, int rt) {
if (l == r) {
seg[rt].aw = (long long)a[pos] * w[pos] % MOD;
seg[rt].w = w[pos];
seg[rt].iw = (long long)pos * w[pos] % MOD;
return;
}
int m = (l + r) >> 1;
if (pos <= m) {
update(pos, l, m, rt << 1);
} else {
update(pos, m + 1, r, rt << 1 | 1);
}
seg[rt] = merge(seg[rt << 1], seg[rt << 1 | 1]);
}
inline int findK(long long w, int l, int r, int rt) {
if (l == r) {
return l;
}
int m = (l + r) >> 1;
if (seg[rt << 1].w > w) {
return findK(w, l, m, rt << 1);
} else {
return findK(w - seg[rt << 1].w, m + 1, r, rt << 1 | 1);
}
}
inline Seg query(int ql, int qr, int l, int r, int rt) {
if (ql <= l && r <= qr) {
return seg[rt];
}
int m = (l + r) >> 1;
Seg ret = Seg{0, 0, 0};
if (ql <= m) {
ret = merge(ret, query(ql, qr, l, m, rt << 1));
}
if (m < qr) {
ret = merge(ret, query(ql, qr, m + 1, r, rt << 1 | 1));
}
return ret;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
update(i, 1, n, 1);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
w[x] = y;
update(x, 1, n, 1);
} else {
long long pref = x == 1 ? 0 : query(1, x - 1, 1, n, 1).w;
pref = pref + query(x, y, 1, n, 1).w / 2;
int k = findK(pref, 1, n, 1);
Seg t1 = query(x, k, 1, n, 1);
Seg t2 = k == y ? Seg{0, 0, 0} : query(k + 1, y, 1, n, 1);
int ans = addMod(t2.aw, MOD - t1.aw);
ans = addMod(
ans, (long long)a[k] * addMod(t1.w % MOD, MOD - t2.w % MOD) % MOD);
ans = addMod(ans,
(long long)k * addMod(t2.w % MOD, MOD - t1.w % MOD) % MOD);
ans = addMod(ans, addMod(t1.iw, MOD - t2.iw));
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, mod = 1e9 + 7;
struct node {
node *ch[2];
long long sw;
int sxw;
node() {
ch[0] = ch[1] = 0;
sw = sxw = 0;
}
void pull() {
sw = ch[0]->sw + ch[1]->sw;
sxw = (ch[0]->sxw + ch[1]->sxw) % mod;
return;
}
} * root;
int n, q, a[maxn], w[maxn];
void B(node *&u = root, int l = 1, int r = n) {
u = new node;
if (l == r) {
u->sw = w[l];
u->sxw = (long long)(a[l] - l) * w[l] % mod;
return;
}
int mid = l + r >> 1;
B(u->ch[0], l, mid);
B(u->ch[1], mid + 1, r);
return u->pull();
}
void M(int i, node *&u = root, int l = 1, int r = n) {
if (l == r) {
u->sw = w[l];
u->sxw = (long long)(a[l] - l) * w[l] % mod;
return;
}
int mid = l + r >> 1;
if (i <= mid)
M(i, u->ch[0], l, mid);
else
M(i, u->ch[1], mid + 1, r);
return u->pull();
}
long long Qsw(int a, int b, node *&u = root, int l = 1, int r = n) {
if (a <= l && r <= b) return u->sw;
int mid = l + r >> 1;
long long t = 0;
if (a <= mid) t += Qsw(a, b, u->ch[0], l, mid);
if (b > mid) t += Qsw(a, b, u->ch[1], mid + 1, r);
return t;
}
int Qsxw(int a, int b, node *&u = root, int l = 1, int r = n) {
if (a <= l && r <= b) return u->sxw;
int mid = l + r >> 1;
int t = 0;
if (a <= mid) t = (t + Qsxw(a, b, u->ch[0], l, mid)) % mod;
if (b > mid) t = (t + Qsxw(a, b, u->ch[1], mid + 1, r)) % mod;
return t;
}
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", w + i);
B();
for (int i = 1; i <= q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
w[x] = y;
M(x);
} else {
int lb = x, rb = y;
long long s = Qsw(lb, rb);
while (lb <= rb) {
int mid = lb + rb >> 1;
long long t = Qsw(x, mid);
if (t > s - t)
rb = mid - 1;
else
lb = mid + 1;
}
int ans = 0;
if (x <= rb) {
int sw = Qsw(x, rb) % mod, sxw = Qsxw(x, rb);
ans = ((long long)(a[lb] - lb) * sw - sxw) % mod;
}
if (lb + 1 <= y) {
int sw = Qsw(lb + 1, y) % mod, sxw = Qsxw(lb + 1, y);
ans = ((long long)(lb - a[lb]) * sw + sxw + ans) % mod;
}
printf("%d\n", (ans + mod) % mod);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 200100;
long long a[N];
template <typename T, bool K>
struct Segtree {
vector<T> t;
int n, h;
Segtree() {}
Segtree(int sz) {
h = 32 - __builtin_clz(sz);
n = 1 << h;
t = vector<T>(n << 1);
}
void assign(int x, T v) {
int y = x;
x += n;
t[x] = v;
for (x /= 2; x; x /= 2) {
t[x] = t[x << 1] + t[x << 1 | 1];
}
if (K) {
for (y += n; y; y /= 2) {
t[y] %= MOD;
}
}
}
T query(int l, int r) {
T 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];
}
}
if (K) {
ans %= MOD;
}
return ans;
}
pair<int, T> bs(int l, int r, T goal, int x, int lv, int rv) {
if (rv <= l || r <= lv) {
return {-1, 0};
}
if (l <= lv && rv <= r && t[x] < goal) {
return {-1, t[x]};
}
if (rv - lv == 1 && t[x] >= goal) {
return {lv, t[x]};
}
int mv = (lv + rv) / 2;
auto res = bs(l, r, goal, x * 2, lv, mv);
if (res.first != -1) {
return res;
}
T ov = res.second;
res = bs(l, r, goal - res.second, x * 2 + 1, mv, rv);
return {res.first, res.second + ov};
}
int bs(int l, int r, T goal) {
auto res = bs(l, r, goal, 1, 0, n);
return res.first;
}
};
Segtree<long long, false> weights;
Segtree<long long, true> modsum;
int n, q;
long long calc(long long x, int l, int r) {
long long* pt = lower_bound(a + 1, a + n + 1, x);
int ind = pt - a;
ind = max(l, min(r + 1, ind));
long long ans =
((weights.query(l, ind) % MOD) * x % MOD) - modsum.query(l, ind);
ans %= MOD;
ans +=
modsum.query(ind, r + 1) - ((weights.query(ind, r + 1) % MOD) * x % MOD);
ans = (ans % MOD + MOD) % MOD;
return ans;
}
long long getDiff(int ind1, int ind2, int l, int r) {
if (ind2 > n) {
return 1e9;
}
long long x = a[ind1];
long long y = a[ind2];
assert(y >= x);
ind1 = max(l, min(r + 1, ind1));
ind2 = max(l, min(r + 1, ind2));
long long ans =
(y - x) * weights.query(l, ind1) + (x - y) * weights.query(ind2, r + 1);
for (int i = ind1; i < ind2; ++i) {
ans += (x + y - 2 * a[i]) * (weights.query(i, i + 1));
}
return ans;
}
long long query(int l, int r) {
long long tot_weight = weights.query(l, r + 1);
int loi = weights.bs(l, r + 1, (tot_weight + 1) / 2);
long long val = calc(a[loi], l, r);
pair<long long, long long> ans = {0, val};
return ans.second;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
weights = Segtree<long long, false>(n + 1);
modsum = Segtree<long long, true>(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] -= i;
}
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
weights.assign(i, x);
modsum.assign(i, x * (a[i]) % MOD);
}
for (int qq = 0; qq < q; ++qq) {
int x, y;
cin >> x >> y;
if (x > 0) {
int l = x, r = y;
cout << query(l, r) << "\n";
} else {
x *= -1;
weights.assign(x, y);
modsum.assign(x, y * (a[x]) % MOD);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long X[200200];
int Xi[200200], xi;
int X2[200200], x2;
int Xm[200200], xm;
int a[200200], w[200200], x, n, q;
inline void update(int u) {
for (; u <= n; u += u & -u) {
X[u] += x;
Xi[u] = (Xi[u] + xi) % 1000000007;
X2[u] = (X2[u] + x2) % 1000000007;
Xm[u] = (Xm[u] + xm) % 1000000007;
}
}
inline long long calc_x(int u, long long ans = 0) {
for (; u; u -= u & -u) ans += X[u];
return ans;
}
inline void calc(int u) {
x = 0, xi = 0, x2 = 0, xm = 0;
for (; u; u -= u & -u) {
x = (x + X[u]) % 1000000007;
xi = (xi + Xi[u]) % 1000000007;
x2 = (x2 + X2[u]) % 1000000007;
xm = (xm + Xm[u]) % 1000000007;
}
}
int collect(int u, int L, int R) {
calc(L - 1);
int tx = x, txi = xi, tx2 = x2, txm = xm;
calc(u - 1);
tx = (x - tx + 1000000007) % 1000000007,
txi = (xi - txi + 1000000007) % 1000000007,
tx2 = (x2 - tx2 + 1000000007) % 1000000007,
txm = (xm - txm + 1000000007) % 1000000007;
long long ans = 0;
if (L < u) {
ans += (long long)a[u] * tx;
ans -= txm;
ans += txi - (long long)u * tx;
}
tx = (x + w[u]) % 1000000007, txi = (xi + (long long)u * w[u]) % 1000000007,
tx2 = (x2 + (long long)w[u] * w[u]) % 1000000007,
txm = (xm + (long long)a[u] * w[u]) % 1000000007;
calc(R);
tx = (x - tx + 1000000007) % 1000000007,
txi = (xi - txi + 1000000007) % 1000000007,
tx2 = (x2 - tx2 + 1000000007) % 1000000007,
txm = (xm - txm + 1000000007) % 1000000007;
if (u < R) {
ans += txm;
ans -= (long long)a[u] * tx;
ans += (long long)u * tx - txi;
}
ans %= 1000000007;
if (ans < 0) ans += 1000000007;
return ans;
}
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", w + i);
x = w[i];
xi = (long long)i * x % 1000000007;
x2 = (long long)x * x % 1000000007;
xm = (long long)a[i] * x % 1000000007;
update(i);
}
while (q--) {
int L, R;
scanf("%d %d", &L, &R);
if (L < 0) {
L = -L;
x = -w[L];
xi = 1000000007 - (long long)L * w[L] % 1000000007;
x2 = 1000000007 - (long long)w[L] * w[L] % 1000000007;
xm = 1000000007 - (long long)a[L] * w[L] % 1000000007;
update(L);
w[L] = R;
x = w[L];
xi = (long long)L * x % 1000000007;
x2 = (long long)x * x % 1000000007;
xm = (long long)a[L] * x % 1000000007;
update(L);
} else if (L == R)
puts("0");
else {
long long L_ = calc_x(L - 1), all = calc_x(R) - L_;
int st = L - 1, ed = R;
while (st + 1 < ed) {
int md = st + ed >> 1;
long long sa = calc_x(md) - L_, sb = all - sa;
if (sa > sb)
ed = md;
else
st = md;
}
printf("%d\n", collect(ed, L, R));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int MOD = 1e9 + 7;
inline void add(long long &a, const long long &b) {
if ((a += b) >= MOD) a -= MOD;
}
int a[N], w[N];
long long c1[N], c2[N];
inline long long sum1(int x) {
long long ret = 0;
while (x) ret += c1[x], x -= (x & -x);
return ret;
}
inline void add1(int x, long long d) {
while (x < N) c1[x] += d, x += (x & -x);
}
inline long long sum2(int x) {
long long ret = 0;
while (x) add(ret, c2[x]), x -= (x & -x);
return ret;
}
inline void add2(int x, long long d) {
while (x < N) add(c2[x], d), x += (x & -x);
}
inline void work() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", w + i);
add1(i, w[i]);
add2(i, 1LL * w[i] * a[i] % MOD);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
add1(-x, -w[-x] + y);
add2(-x, (1LL * (-w[-x] + y) * a[-x] % MOD + MOD) % MOD);
w[-x] = y;
} else {
int L = x, R = y;
long long t = sum1(L - 1), sum = sum1(R) - t;
while (L < R) {
int M = (L + R) >> 1;
if (2 * (sum1(M) - t) < sum)
L = M + 1;
else
R = M;
}
long long t1 =
((sum1(L) - t) % MOD * a[L] % MOD - (sum2(L) - sum2(x - 1)) % MOD) %
MOD;
long long t2 = (-(sum1(y) - sum1(L)) % MOD * a[L] % MOD +
(sum2(y) - sum2(L)) % MOD) %
MOD;
long long ans = (t1 + t2) % MOD;
printf("%lld\n", (ans + MOD) % MOD);
}
}
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T& a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T& a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream& out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << '\n';
}
template <class T>
void output(T x, ostream& out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long MOD = 1e9 + 7;
struct data {
long long val, cnt, sum;
data() : val(0), cnt(0), sum(0) {}
data(long long _x) : val(0), cnt(1), sum(_x) {}
data(long long _val, long long _cnt, long long _sum)
: val(_val), cnt(_cnt), sum(_sum) {}
};
data merge(data a, data b) {
return data((a.val + b.val + b.sum * a.cnt) % MOD, a.cnt + b.cnt,
(a.sum + b.sum) % MOD);
}
struct st {
vector<data> t;
int n;
void init(int _n) {
n = _n;
t.resize(4 * n);
}
void update(int pos, long long val, int v, int tl, int tr) {
if (tl == tr) {
t[v] = data(val);
} else {
int tm = (tl + tr) >> 1;
if (pos <= tm)
update(pos, val, v * 2, tl, tm);
else
update(pos, val, v * 2 + 1, tm + 1, tr);
t[v] = merge(t[v * 2], t[v * 2 + 1]);
}
}
void output(int v, int tl, int tr) {
cerr << tl << ".." << tr << ": " << t[v].val << " " << t[v].cnt << " "
<< t[v].sum << '\n';
if (tl < tr) {
int tm = (tl + tr) >> 1;
output(v * 2, tl, tm);
output(v * 2 + 1, tm + 1, tr);
}
}
data get(int l, int r, int v, int tl, int tr) {
if (l > r) return data();
if (l == tl && r == tr) return t[v];
int tm = (tl + tr) >> 1;
data res_l = get(l, min(r, tm), v * 2, tl, tm);
data res_r = get(max(l, tm + 1), r, v * 2 + 1, tm + 1, tr);
return merge(res_l, res_r);
}
void update(int pos, long long val) { update(pos, val, 1, 0, n - 1); }
long long get(int l, int r) {
data x = get(l, r, 1, 0, n - 1);
return x.val;
}
};
struct fenwick_mod {
vector<long long> t;
int n;
void init(int _n) {
n = _n;
t.resize(n);
}
void update(int pos, long long val) {
while (pos < n) {
t[pos] = (t[pos] + val) % MOD;
pos = (pos | (pos + 1));
}
}
long long get(int r) {
long long res = 0;
while (r >= 0) {
res += t[r];
r = (r & (r + 1)) - 1;
}
return res % MOD;
}
long long get(int l, int r) { return (get(r) - get(l - 1) + MOD) % MOD; }
};
struct fenwick {
vector<long long> t;
int n;
void init(int _n) {
n = _n;
t.resize(n);
}
void update(int pos, long long val) {
while (pos < n) {
t[pos] = (t[pos] + val);
pos = (pos | (pos + 1));
}
}
long long get(int r) {
long long res = 0;
while (r >= 0) {
res += t[r];
r = (r & (r + 1)) - 1;
}
return res;
}
long long get(int l, int r) { return get(r) - get(l - 1); }
};
const int mx = 2e5 + 228;
int n, q;
long long a[mx], w[mx];
fenwick_mod f_aw;
fenwick f_w;
st t, t_rev;
void update_index(int pos, long long new_w, long long old_w) {
long long diff = (new_w - old_w + MOD) % MOD;
f_w.update(pos, new_w - old_w);
f_aw.update(pos, (a[pos] * diff) % MOD);
t.update(pos, new_w);
t_rev.update(n - pos - 1, new_w);
}
void init() {
f_w.init(n);
f_aw.init(n);
t.init(n);
t_rev.init(n);
for (int i = 0; i < n; ++i) {
update_index(i, w[i], 0);
}
}
void update_query(int pos, long long new_w) {
update_index(pos, new_w, w[pos]);
w[pos] = new_w;
}
int get_max_left_pos(int l0, int r0, long long L) {
int l = l0 - 1, r = r0;
while (l != r) {
int mid = (l + r) >> 1;
if (a[mid + 1] < L + (long long)(mid + 1 - l0)) {
l = mid + 1;
} else {
r = mid;
}
}
return l;
}
int get_min_right_pos(int l0, int r0, long long L) {
int l = l0, r = r0 + 1;
while (l != r) {
int mid = (l + r) >> 1;
if (a[mid] > L + (long long)(mid - l0))
r = mid;
else
l = mid + 1;
}
return l;
}
long long to_mod(long long x) { return (x % MOD + MOD) % MOD; }
long long get_l(int l0, int r0, long long R) {
long long res = to_mod(R * (f_w.get(l0, r0) % MOD) - f_aw.get(l0, r0) -
t_rev.get(n - 1 - r0, n - 1 - l0));
return res;
}
long long get_r(int l0, int r0, long long L) {
long long res =
to_mod(f_aw.get(l0, r0) - (f_w.get(l0, r0) % MOD) * L - t.get(l0, r0));
return res;
}
long long get(int l0, int r0, long long L) {
int mid_pos = get_max_left_pos(l0, r0, L);
long long res = to_mod(get_l(l0, mid_pos, L + mid_pos - l0) +
get_r(mid_pos + 1, r0, L + mid_pos + 1 - l0));
return res;
}
long long get_query(int l0, int r0) {
long long len = (long long)(r0 - l0 + 1), L = a[l0], R = a[r0] - len + 1;
while (R > L) {
long long MID = (L + R) >> 1;
int max_left_pos = get_max_left_pos(l0, r0, MID),
min_right_pos = get_min_right_pos(l0, r0, MID);
long long wl = f_w.get(l0, max_left_pos), wr = f_w.get(min_right_pos, r0),
wm = f_w.get(max_left_pos + 1, min_right_pos - 1),
diff_to_next = wl - wr + wm;
if (diff_to_next >= 0)
R = MID;
else
L = MID + 1;
}
long long ans = get(l0, r0, L);
return ans % MOD;
}
signed main() {
fast_io();
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> w[i];
}
init();
for (int i = 0; i < q; ++i) {
int id;
long long val;
cin >> id >> val;
if (id < 0) {
update_query(-id - 1, val);
} else {
cout << get_query(id - 1, (int)val - 1) << '\n';
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.