text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int inf = 1 << 30;
const long long linf = 1LL << 62;
const int MAX = 1020000;
long long dy[8] = {0, -1, 0, 1, 1, -1, 1, -1};
long long dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
const double eps = 1e-7;
template <typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <typename T>
inline void print(T &a) {
for (long long i = 0; i < (a.size()); i++) cout << a[i] << " ";
cout << "\n";
}
template <typename T1, typename T2>
inline void print2(T1 a, T2 b) {
cout << a << " " << b << "\n";
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << "\n";
}
long long pcount(long long x) { return __builtin_popcountll(x); }
const int mod = 998244353;
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
using G = function<Monoid(Monoid, OperatorMonoid)>;
using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
int sz, height;
vector<Monoid> data;
vector<OperatorMonoid> lazy;
const F f;
const G g;
const H h;
const Monoid M1;
const OperatorMonoid OM0;
LazySegmentTree(int n, const F f, const G g, const H h, const Monoid &M1,
const OperatorMonoid OM0)
: f(f), g(g), h(h), M1(M1), OM0(OM0) {
sz = 1;
height = 0;
while (sz < n) sz <<= 1, height++;
data.assign(2 * sz, M1);
lazy.assign(2 * sz, OM0);
}
void set(int k, const Monoid &x) { data[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
}
inline void propagate(int k) {
if (lazy[k] != OM0) {
lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
data[k] = reflect(k);
lazy[k] = OM0;
}
}
inline Monoid reflect(int k) {
return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);
}
inline void recalc(int k) {
while (k >>= 1) data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));
}
inline void thrust(int k) {
for (int i = height; i > 0; i--) propagate(k >> i);
}
void update(int a, int b, const OperatorMonoid &x) {
thrust(a += sz);
thrust(b += sz - 1);
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) lazy[l] = h(lazy[l], x), ++l;
if (r & 1) --r, lazy[r] = h(lazy[r], x);
}
recalc(a);
recalc(b);
}
Monoid query(int a, int b) {
thrust(a += sz);
thrust(b += sz - 1);
Monoid L = M1, R = M1;
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) L = f(L, reflect(l++));
if (r & 1) R = f(reflect(--r), R);
}
return f(L, R);
}
Monoid operator[](const int &k) { return query(k, k + 1); }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
propagate(a);
Monoid nxt =
type ? f(reflect(2 * a + type), M) : f(M, reflect(2 * a + type));
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C>
int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, reflect(1)))) return find_subtree(1, check, L, false);
return -1;
}
thrust(a + sz);
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, reflect(a));
if (check(nxt)) return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C>
int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(reflect(1), R))) return find_subtree(1, check, R, true);
return -1;
}
thrust(b + sz - 1);
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(reflect(--b), R);
if (check(nxt)) return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
struct T {
long long val, sz;
};
T f(T a, T b) { return T{a.val + b.val, a.sz + b.sz}; }
T g(T a, long long b) {
if (b == linf) return a;
a.val = b * a.sz;
return a;
}
long long h(long long a, long long b) {
if (b == linf)
return a;
else
return b;
}
void solve() {
int n, q;
cin >> n >> q;
vector<long long> a(n);
for (long long i = 0; i < (n); i++) cin >> a[i];
LazySegmentTree<T, long long> seg(n, f, g, h, T{0, 0}, linf);
for (long long i = 0; i < (n); i++) {
seg.set(i, T{a[i], 1});
}
seg.build();
for (long long z = 0; z < (q); z++) {
int t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
int l = -1, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
if (seg.query(mid, mid + 1).val > y)
l = mid;
else
r = mid;
}
if (l + 1 <= x) seg.update(l + 1, x + 1, y);
} else {
int ans = 0;
while (x < n) {
int val = seg.query(x, x + 1).val;
if (val > y) {
int l = x, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
if (seg.query(mid, mid + 1).val > y)
l = mid;
else
r = mid;
}
x = l + 1;
} else if (val >= y / 2) {
y -= val;
ans++;
x++;
} else {
auto check = [&](T a) { return a.val > y; };
int R = seg.find_first(x, check);
if (R == -1) R = n + 1;
R--;
ans += R - x;
y -= seg.query(x, R).val;
x = R;
}
}
cout << ans << "\n";
}
}
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 2e5 + 10;
const int xm = -20 + 10;
const int sq = 320;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int mod = 998244353;
const int base = 257;
int n, q, a[xn], mx[xn << 2], mn[xn << 2], lazy[xn << 2];
long long seg[xn << 2];
void build(int id, int l, int r) {
if (r - l == 1) {
cin >> a[l];
mn[id] = mx[id] = seg[id] = a[l];
return;
}
int mid = l + r >> 1;
build(id << 1, l, mid), build(id << 1 | 1, mid, r);
mn[id] = min(mn[id << 1], mn[id << 1 | 1]);
mx[id] = max(mx[id << 1], mx[id << 1 | 1]);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
void shift(int id, int l, int r) {
if (!lazy[id]) return;
mn[id] = mx[id] = lazy[id];
seg[id] = 1ll * lazy[id] * (r - l);
if (r - l > 1) lazy[id << 1] = lazy[id << 1 | 1] = lazy[id];
lazy[id] = 0;
}
void update(int id, int l, int r, int ql, int qr, int val) {
shift(id, l, r);
if (qr <= l || r <= ql || qr <= ql || val <= mn[id]) return;
if (ql <= l && r <= qr && mx[id] <= val) {
lazy[id] = val;
shift(id, l, r);
return;
}
int mid = l + r >> 1;
update(id << 1, l, mid, ql, qr, val);
update(id << 1 | 1, mid, r, ql, qr, val);
mx[id] = max(mx[id << 1], mx[id << 1 | 1]);
mn[id] = min(mn[id << 1], mn[id << 1 | 1]);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
pair<int, int> get(int id, int l, int r, int ql, int qr, pair<int, int> val) {
shift(id, l, r);
if (qr <= l || r <= ql || qr <= ql || mn[id] > val.first) return val;
if (ql <= l && r <= qr && seg[id] <= val.first)
return {val.first - seg[id], val.second + r - l};
int mid = l + r >> 1;
return get(id << 1 | 1, mid, r, ql, qr, get(id << 1, l, mid, ql, qr, val));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> q;
build(1, 1, n + 1);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1)
update(1, 1, n + 1, 1, x + 1, y);
else
cout << get(1, 1, n + 1, x, n + 1, {y, 0}).second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
long long a[maxn];
struct Tree {
long long l, r, maxval, minval, sum, tag;
} tree[maxn * 4];
void push_up(long long p) {
tree[p].maxval = max(tree[p * 2].maxval, tree[p * 2 + 1].maxval);
tree[p].minval = min(tree[p * 2].minval, tree[p * 2 + 1].minval);
tree[p].sum = tree[p * 2].sum + tree[p * 2 + 1].sum;
}
void addtag(long long p, long long d) {
tree[p].tag = d;
tree[p].sum = tree[p].tag * (tree[p].r - tree[p].l + 1);
tree[p].maxval = tree[p].tag;
tree[p].minval = tree[p].tag;
}
void push_down(long long p) {
if (tree[p].tag != -1) {
addtag(p * 2, tree[p].tag);
addtag(p * 2 + 1, tree[p].tag);
tree[p].tag = -1;
}
}
void build(long long p, long long l, long long r) {
tree[p].l = l;
tree[p].r = r;
tree[p].maxval = -1e18;
tree[p].minval = 1e18;
tree[p].sum = 0;
tree[p].tag = -1;
if (l == r) {
tree[p].maxval = tree[p].minval = tree[p].sum = a[l];
return;
}
long long mid = (l + r) >> 1;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
push_up(p);
}
void modify(long long p, long long l, long long r, long long d) {
if (l <= tree[p].l && r >= tree[p].r) {
if (tree[p].minval >= d) return;
if (tree[p].maxval < d) {
addtag(p, d);
return;
}
}
push_down(p);
long long mid = (tree[p].l + tree[p].r) >> 1;
if (l <= mid) modify(p * 2, l, r, d);
if (r > mid) modify(p * 2 + 1, l, r, d);
push_up(p);
}
long long query(long long p, long long l, long long r, long long &x) {
if (l <= tree[p].l && r >= tree[p].r) {
if (tree[p].minval > x) return 0;
if (x >= tree[p].sum) {
x -= tree[p].sum;
return tree[p].r - tree[p].l + 1;
}
if (tree[p].l == tree[p].r) return 0;
}
long long ans = 0;
push_down(p);
long long mid = (tree[p].l + tree[p].r) >> 1;
if (l <= mid) ans += query(p * 2, l, r, x);
if (r > mid) ans += query(p * 2 + 1, l, r, x);
return ans;
}
int main(void) {
cin.tie(0);
std::ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (m--) {
long long op, l, r;
cin >> op >> l >> r;
if (op == 1) {
modify(1, 1, l, r);
} else if (op == 2) {
cout << query(1, l, n, r) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
inline int read() {
char ch;
bool sign = 0;
int res = 0;
while (!isdigit(ch = getchar()))
if (ch == '-') sign = 1;
while (isdigit(ch)) res = res * 10 + (ch ^ 48), ch = getchar();
if (sign)
return -res;
else
return res;
}
const int maxn = 200000 + 10;
const long long inf = 1e9;
const int MAXM = 3;
const int maxm = 1000000 + 10;
const long long MOD[] = {469762049, 998244353, 1004535809, 1000000007};
const int mod = 1000000007;
const int apsz = 26;
int a[maxn], n;
struct segtree {
long long minv[maxn << 2], ans, sum[maxn << 2], setv[maxn << 2];
int ql, qr, n, val, Y, pos;
void init(int N) {
n = N;
build(1, n, 1);
}
void maintain(int l, int r, int o) {
if (l != r) {
minv[o] = min(minv[o << 1], minv[o << 1 | 1]);
sum[o] = sum[o << 1] + sum[o << 1 | 1];
} else {
sum[o] = minv[o] = a[l];
}
if (setv[o] != 0) {
assert(minv[o] <= setv[o]);
minv[o] = setv[o];
sum[o] = setv[o] * (r - l + 1);
}
}
void pushdown(int o) {
if (setv[o] == 0) return;
setv[o << 1] = max(setv[o], setv[o << 1]);
setv[o << 1 | 1] = max(setv[o], setv[o << 1 | 1]);
setv[o] = 0;
}
void pushdown(int l, int r, int o) {
pushdown(o);
int mid = l + r >> 1;
maintain(l, mid, o << 1);
maintain(mid + 1, r, o << 1 | 1);
}
void build(int l, int r, int o) {
setv[o] = 0;
if (l == r) {
minv[o] = sum[o] = a[l];
return;
}
int mid = l + r >> 1;
build(l, mid, o << 1), build(mid + 1, r, o << 1 | 1);
maintain(l, r, o);
}
void update(int l, int r, int o) {
if (ql <= l && qr >= r) {
assert(setv[o] <= val);
setv[o] = max(setv[o], 1LL * val);
minv[o] = setv[o];
sum[o] = 1LL * (r - l + 1) * setv[o];
} else {
pushdown(o);
int mid = l + r >> 1;
if (ql <= mid)
update(l, mid, o << 1);
else
maintain(l, mid, o << 1);
if (qr > mid)
update(mid + 1, r, o << 1 | 1);
else
maintain(mid + 1, r, o << 1 | 1);
}
maintain(l, r, o);
}
void getLeft(int l, int r, int o) {
if (l == r) {
if (minv[o] <= val) {
ans = l;
} else
ans = -1;
return;
}
int mid = l + r >> 1;
pushdown(l, r, o);
if (minv[o << 1] <= val)
getLeft(l, mid, o << 1);
else if (mid + 1 <= qr && minv[o << 1 | 1] <= val)
getLeft(mid + 1, r, o << 1 | 1);
}
void query(int l, int r, int o) {
if (minv[o] <= Y && sum[o] <= Y && l >= ql) {
pos = r + 1;
Y -= sum[o];
ans += r - l + 1;
return;
}
if (l == r)
return;
else {
pushdown(l, r, o);
int mid = l + r >> 1;
if (minv[o << 1] <= Y && ql <= mid) {
query(l, mid, o << 1);
}
if (minv[o << 1 | 1] <= Y) query(mid + 1, r, o << 1 | 1);
}
}
void Query(int l, int y) {
Y = y;
ans = 0;
ql = l, qr = n;
pos = n + 1;
query(1, n, 1);
}
void Update(int x, int y) {
ql = 1, qr = x;
ans = -1;
val = y;
getLeft(1, n, 1);
if (ans == -1) return;
ql = ans;
update(1, n, 1);
}
} tree;
int q;
inline void solve() {
int x, t, y;
for (; q--;) {
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
tree.Update(x, y);
} else {
int ans = 0;
for (; x <= n;) {
tree.Query(x, y);
ans += tree.ans;
x = tree.pos;
y = tree.Y;
}
printf("%d\n", ans);
}
}
}
int main(void) {
scanf("%d", &(n)), scanf("%d", &(q));
for (auto i = (1); i <= (n); ++i) scanf("%d", &(a[i]));
tree.init(n);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,mmx,avx,avx2")
using namespace std;
using ll = long long int;
const int N = 2e5 + 2;
ll sum[2 * N];
int mn[2 * N];
int lazy[2 * N];
int left_child[2 * N], right_child[2 * N];
int a[N];
int counter;
ll taken = 0;
void Push(int, int, int);
void Build(int node, int lo, int hi) {
if (lo + 1 == hi) {
sum[node] = mn[node] = a[lo];
return;
}
int mid = (lo + hi) / 2;
left_child[node] = ++counter;
Build(left_child[node], lo, mid);
right_child[node] = ++counter;
Build(right_child[node], mid, hi);
sum[node] = sum[left_child[node]] + sum[right_child[node]];
mn[node] = mn[right_child[node]];
}
void Set(int node, int lo, int hi, int qL, int qR, int value) {
if (qL >= hi || lo >= qR) return;
if (lo >= qL && hi <= qR) {
mn[node] = lazy[node] = value;
sum[node] = 1LL * (hi - lo) * value;
return;
}
Push(node, lo, hi);
int mid = (lo + hi) / 2;
Set(left_child[node], lo, mid, qL, qR, value);
Set(right_child[node], mid, hi, qL, qR, value);
sum[node] = sum[left_child[node]] + sum[right_child[node]];
mn[node] = mn[right_child[node]];
}
void Push(int node, int lo, int hi) {
if (lazy[node]) {
int mid = (lo + hi) / 2;
Set(left_child[node], lo, mid, lo, mid, lazy[node]);
Set(right_child[node], mid, hi, mid, hi, lazy[node]);
lazy[node] = 0;
}
}
ll getSum(int node, int lo, int hi, int qL, int qR) {
if (qL >= hi || lo >= qR) return 0LL;
if (lo >= qL && hi <= qR) return sum[node];
Push(node, lo, hi);
int mid = (lo + hi) / 2;
return getSum(left_child[node], lo, mid, qL, qR) +
getSum(right_child[node], mid, hi, qL, qR);
}
int firstLess(int node, int lo, int hi, int X) {
if (mn[node] >= X) return INT_MAX;
if (lo + 1 == hi) return lo;
Push(node, lo, hi);
int mid = (lo + hi) / 2;
if (mn[left_child[node]] >= X)
return firstLess(right_child[node], mid, hi, X);
return firstLess(left_child[node], lo, mid, X);
}
int lastLess(int node, int lo, int hi, ll X) {
if (lo + 1 == hi) {
if (mn[node] <= X) {
taken += mn[node];
return lo;
}
return -1;
}
Push(node, lo, hi);
int mid = (lo + hi) / 2;
ll difference = sum[left_child[node]] - X;
if (difference > 0) return lastLess(left_child[node], lo, mid, X);
int ret = lastLess(right_child[node], mid, hi, -difference);
taken += sum[left_child[node]];
if (ret == -1) return {mid - 1};
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
mt19937_64 rng(
chrono::high_resolution_clock::now().time_since_epoch().count());
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> a[i];
Build(0, 0, n);
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x, y;
cin >> x >> y;
--x;
int left = firstLess(0, 0, n, y);
if (left <= x) Set(0, 0, n, left, x + 1, y);
} else {
int x, y, ans = 0;
cin >> x >> y;
--x;
while (1) {
taken = 0;
ll queryPref = y + getSum(0, 0, n, 0, x);
int rt = lastLess(0, 0, n, queryPref);
if (rt != -1) {
ans += rt - x + 1;
y = queryPref - taken;
}
int nxt = firstLess(0, 0, n, y + 1);
if (nxt >= n || nxt <= rt) break;
x = nxt;
}
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
res = 0;
bool bo = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
bo = 1;
else
res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 2e5 + 5, M = N << 2;
int n, q, a[N], lst[M], tag[M];
long long sum[M];
void build(int l, int r, int p) {
if (l == r) return (void)(lst[p] = sum[p] = a[l]);
int mid = l + r >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
lst[p] = a[r];
sum[p] = sum[p << 1] + sum[p << 1 | 1];
}
void down(int l, int r, int mid, int p) {
if (tag[p] != -1) {
tag[p << 1] = lst[p << 1] = tag[p];
sum[p << 1] = 1ll * (mid - l + 1) * tag[p];
tag[p << 1 | 1] = lst[p << 1 | 1] = tag[p];
sum[p << 1 | 1] = 1ll * (r - mid) * tag[p];
tag[p] = -1;
}
}
int firs_les(int l, int r, int x, int p) {
if (l == r) return lst[p] <= x ? l : l + 1;
int mid = l + r >> 1;
down(l, r, mid, p);
if (lst[p << 1] <= x)
return firs_les(l, mid, x, p << 1);
else
return firs_les(mid + 1, r, x, p << 1 | 1);
}
long long ask(int l, int r, int x, int p) {
if (l == r) return x == l ? sum[p] : 0;
int mid = l + r >> 1;
down(l, r, mid, p);
if (x <= mid)
return ask(l, mid, x, p << 1);
else
return ask(mid + 1, r, x, p << 1 | 1) + sum[p << 1];
}
std::pair<long long, int> pres(int l, int r, long long x, int p) {
if (l == r)
return sum[p] <= x ? std::make_pair(sum[p], l) : std::make_pair(0ll, l - 1);
int mid = l + r >> 1;
std::pair<long long, int> res;
down(l, r, mid, p);
if (sum[p << 1] <= x)
return res = pres(mid + 1, r, x - sum[p << 1], p << 1 | 1),
res.first += sum[p << 1], res;
else
return pres(l, mid, x, p << 1);
}
void change(int l, int r, int s, int e, int v, int p) {
if (e < l || s > r) return;
if (s <= l && r <= e)
return (void)(tag[p] = lst[p] = v, sum[p] = 1ll * (r - l + 1) * v);
int mid = l + r >> 1;
down(l, r, mid, p);
change(l, mid, s, e, v, p << 1);
change(mid + 1, r, s, e, v, p << 1 | 1);
lst[p] = lst[p << 1 | 1];
sum[p] = sum[p << 1] + sum[p << 1 | 1];
}
int main() {
int op, x, y;
read(n);
read(q);
for (int i = 1; i <= n; i++) read(a[i]);
memset(tag, -1, sizeof(tag));
build(1, n, 1);
while (q--) {
read(op);
read(x);
read(y);
if (op == 2) {
int res = 0;
while (x <= n) {
x = std::max(x, firs_les(1, n, y, 1));
if (x > n) break;
long long tmp = ask(1, n, x - 1, 1);
std::pair<long long, int> nxt = pres(1, n, tmp + y, 1);
res += nxt.second - x + 1;
y -= nxt.first - tmp;
x = nxt.second + 1;
}
printf("%d\n", res);
} else {
int tp = firs_les(1, n, y, 1);
if (tp <= x) change(1, n, tp, x, y, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 2e5 + 2;
int n, q, a[N];
int lz[N << 2], mn[N << 2];
ll sum[N << 2];
void build(int id, int l, int r) {
if (l == r) {
sum[id] = mn[id] = a[l];
return;
}
int m = (l + r) >> 1;
build(id << 1, l, m);
build((id << 1) | 1, m + 1, r);
sum[id] = sum[id << 1] + sum[(id << 1) | 1];
mn[id] = mn[(id << 1) | 1];
}
void dolz(int id, int l, int r) {
if (!lz[id]) return;
sum[id] = (r - l + 1) * 1LL * lz[id];
mn[id] = lz[id];
if (l != r) {
lz[id << 1] = lz[id];
lz[(id << 1) | 1] = lz[id];
}
lz[id] = 0;
}
int queryF(int id, int l, int r, int v) {
dolz(id, l, r);
if (l == r) {
if (mn[id] > v) return l + 1;
return l;
}
int m = (l + r) >> 1;
dolz(id << 1, l, m);
if (mn[id << 1] <= v) return queryF(id << 1, l, m, v);
return queryF((id << 1) | 1, m + 1, r, v);
}
void update(int id, int l, int r, int L, int R, int v) {
dolz(id, l, r);
if (l > R || r < L || L > R) return;
if (L <= l && r <= R) {
lz[id] = v;
dolz(id, l, r);
return;
}
int m = (l + r) >> 1;
update(id << 1, l, m, L, R, v);
update((id << 1) | 1, m + 1, r, L, R, v);
sum[id] = sum[id << 1] + sum[(id << 1) | 1];
mn[id] = mn[(id << 1) | 1];
}
int cur = 0, ret = 0;
int query1(int id, int l, int r, int v) {
dolz(id, l, r);
if (l == r) {
if (sum[id] > v) return l - 1;
cur += sum[id];
return l;
}
int m = (l + r) >> 1;
dolz(id << 1, l, m);
if (sum[id << 1] < v) {
cur += sum[id << 1];
return query1((id << 1) | 1, m + 1, r, v - sum[id << 1]);
}
return query1(id << 1, l, m, v);
}
void query(int id, int l, int r, int L, int tot) {
if (r < L) return;
dolz(id, l, r);
if (L <= l) {
if (cur + sum[id] > tot)
ret = query1(id, l, r, tot - cur);
else
cur += sum[id];
return;
}
int m = (l + r) >> 1;
query(id << 1, l, m, L, tot);
if (ret) return;
query((id << 1) | 1, m + 1, r, L, tot);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = (1); i <= (n); ++i) cin >> a[i];
build(1, 1, n);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
int p = queryF(1, 1, n, y);
update(1, 1, n, p, x, y);
} else {
int res = 0;
cur = ret = 0;
int pL = max(x, queryF(1, 1, n, y));
query(1, 1, n, pL, y);
if (ret == 0) ret = n;
while (ret <= n && pL <= n) {
y -= cur;
res += ret - pL + 1;
pL = max(ret + 1, queryF(1, 1, n, y));
cur = ret = 0;
query(1, 1, n, pL, y);
if (ret == 0) ret = n;
}
cout << res << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
using namespace std;
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
const int mod = 1e9 + 7;
const long long INF = 3e18;
const int N = 2e5 + 5;
const int P0 = 437;
const int P1 = 343;
const int d = 400;
struct node {
int mi, ma, gift;
long long sum;
node() {
mi = gift = mod;
ma = -mod;
sum = 0;
}
};
vector<int> a;
int n, q;
vector<node> tree;
void Push(int v, int L, int R) {
if (tree[v].gift == mod) return;
int c = (L + R) / 2;
tree[v * 2].mi = tree[v * 2].ma = tree[v * 2 + 1].mi = tree[v * 2 + 1].ma =
tree[v * 2].gift = tree[v * 2 + 1].gift = tree[v].gift;
tree[v * 2].sum = (long long)(c - L) * tree[v].gift;
tree[v * 2 + 1].sum = (long long)(R - c) * tree[v].gift;
tree[v].gift = mod;
}
int F_smaller(int v, int L, int R, int k) {
if (R - L == 1) {
if (tree[v].mi > k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (tree[v * 2].mi > k) {
if (tree[v * 2 + 1].mi > k) return -1;
return F_smaller(v * 2 + 1, c, R, k);
}
return F_smaller(v * 2, L, c, k);
}
long long Get_sum(int v, int L, int R, int l, int r) {
if (L == l && R == r) return tree[v].sum;
Push(v, L, R);
int c = (L + R) / 2;
long long an = 0;
if (l < c) an += Get_sum(v * 2, L, c, l, min(r, c));
if (c < r) an += Get_sum(v * 2 + 1, c, R, max(l, c), r);
return an;
}
int F_right(int v, int L, int R, int Le, long long k, long long cur_sum) {
if (R - L == 1) {
if (tree[v].sum <= k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (Le >= c)
return F_right(v * 2 + 1, c, R, Le, k, cur_sum - tree[v * 2].sum);
if (Le > L) {
long long Sleft = tree[v * 2].sum - cur_sum;
if (Sleft <= k) return F_right(v * 2 + 1, c, R, Le, k - Sleft, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
if (tree[v * 2].sum <= k)
return F_right(v * 2 + 1, c, R, Le, k - tree[v * 2].sum, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
void Upd(int v, int L, int R, int l, int r, int nmax) {
if (L == l && R == r) {
tree[v].mi = tree[v].ma = tree[v].gift = nmax;
tree[v].sum = (long long)(R - L) * nmax;
return;
}
Push(v, L, R);
int c = (L + R) / 2;
if (l < c) Upd(v * 2, L, c, l, min(r, c), nmax);
if (c < r) Upd(v * 2 + 1, c, R, max(l, c), r, nmax);
tree[v].sum = tree[v * 2].sum + tree[v * 2 + 1].sum;
tree[v].mi = tree[v * 2 + 1].mi;
tree[v].ma = tree[v * 2].ma;
}
void Update(int x, int nmax) {
int pos = F_smaller(1, 0, n, nmax);
if (pos == -1 || pos > x) return;
Upd(1, 0, n, pos, x + 1, nmax);
}
void solve() {
cin >> n >> q;
a.resize(n);
tree.resize(n * 4);
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
for (int i = 0; i < (n); i++) Upd(1, 0, n, i, i + 1, a[i]);
for (int i = 0; i < (q); i++) {
long long t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1)
Update(x, y);
else {
int cnt = 0;
while (true) {
long long pos = F_smaller(1, 0, n, y);
if (pos == -1 || pos == n) break;
pos = max(pos, x);
long long Csum = 0;
if (pos) Csum = Get_sum(1, 0, n, 0, pos);
int R = F_right(1, 0, n, pos, y, Csum);
cnt += R - pos;
y -= Get_sum(1, 0, n, pos, R);
pos = R;
if (pos == n) break;
}
cout << cnt << '\n';
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int qq = 1;
while (qq--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
const int N = 1 << 18;
ll s[N << 1];
int mn[N << 1], lz[N << 1], n;
void push(int v, int l, int r) {
if (lz[v]) {
if (r - l > 1) {
int m = (l + r) / 2;
lz[v << 1] = lz[v << 1 | 1] = mn[v << 1] = mn[v << 1 | 1] = lz[v];
s[v << 1 | 0] = 1ll * (m - l) * lz[v];
s[v << 1 | 1] = 1ll * (r - m) * lz[v];
}
lz[v] = 0;
}
}
int x, val;
int query(int v, int l, int r) {
push(v, l, r);
if (r <= x) return 0;
if (x <= l && s[v] <= val) return val -= s[v], r - l;
if (mn[v] > val || r - l == 1) return 0;
int m = (l + r) / 2;
return query(v << 1, l, m) + query(v << 1 | 1, m, r);
}
int query(int a, int b) { return x = a, val = b, query(1, 0, n); }
int get(int v, int l, int r) {
push(v, l, r);
if (val <= mn[v]) return r;
if (r - l == 1) return l;
int m = (l + r) / 2;
int res = get(v << 1, l, m);
return res < m ? res : get(v << 1 | 1, m, r);
}
int get(int v) { return val = v, get(1, 0, n); }
int lo, hi;
void upd(int v, int l, int r) {
push(v, l, r);
if (hi <= l || r <= lo) return;
if (lo <= l && r <= hi) {
lz[v] = mn[v] = val;
s[v] = 1ll * (r - l) * val;
return;
}
int m = (l + r) / 2;
upd(v << 1, l, m);
upd(v << 1 | 1, m, r);
s[v] = s[v << 1] + s[v << 1 | 1];
mn[v] = mn[v << 1 | 1];
}
void update(int l, int r, int v) {
lo = l;
hi = r;
val = v;
upd(1, 0, n);
}
signed main() {
cin.tie(nullptr)->sync_with_stdio(false);
int q;
cin >> n >> q;
for (auto i = (0); i < (n); ++i) {
int a;
cin >> a;
update(i, i + 1, a);
}
while (q--) {
short t;
cin >> t;
if (--t) {
int x, v;
cin >> x >> v;
cout << query(--x, v) << '\n';
} else {
int x, v;
cin >> x >> v;
update(get(v), x, v);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 2e5 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 1e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
long long sum[4 * N], lz[4 * N], seg[4 * N], A[N], rem;
void B(int v, int tl, int tr) {
lz[v] = -1;
if (tl == tr) {
seg[v] = sum[v] = A[tl];
return;
}
int mid = (tl + tr) >> 1;
B(v << 1, tl, mid);
B(v << 1 | 1, mid + 1, tr);
seg[v] = min(seg[v << 1], seg[v << 1 | 1]);
sum[v] = sum[v << 1] + sum[v << 1 | 1];
}
void second(int v, int tl, int tr) {
if (lz[v] == -1 || tl == tr) return;
int mid = (tl + tr) >> 1;
lz[v << 1] = lz[v];
lz[v << 1 | 1] = lz[v];
seg[v << 1] = lz[v];
seg[v << 1 | 1] = lz[v];
sum[v << 1] = 1ll * (mid - tl + 1) * lz[v];
sum[v << 1 | 1] = 1ll * (tr - mid) * lz[v];
lz[v] = -1;
}
void U(int v, int tl, int tr, int l, int r, long long x) {
second(v, tl, tr);
if (l > r || l > tr || r < tl) return;
if (l <= tl && tr <= r) {
seg[v] = x;
lz[v] = x;
sum[v] = lz[v] * (tr - tl + 1);
return;
}
int mid = (tl + tr) >> 1;
U(v << 1, tl, mid, l, r, x);
U(v << 1 | 1, mid + 1, tr, l, r, x);
seg[v] = min(seg[v << 1], seg[v << 1 | 1]);
sum[v] = sum[v << 1] + sum[v << 1 | 1];
}
long long Find(int v, int tl, int tr, int l, int r, long long x) {
second(v, tl, tr);
if (l > r || l > tr || r < tl || seg[v] >= x) return inf;
if (tl == tr) {
return tl;
}
int mid = (tl + tr) >> 1;
long long now = Find(v << 1, tl, mid, l, r, x);
if (now != inf) return now;
return Find(v << 1 | 1, mid + 1, tr, l, r, x);
}
int G(int v, int tl, int tr, int l, int r) {
second(v, tl, tr);
if (l > tr || r < tl || seg[v] > rem) return 0;
if (l <= tl && tr <= r && sum[v] <= rem) {
rem -= sum[v];
return (tr - tl + 1);
}
int mid = (tl + tr) >> 1;
return G(v << 1, tl, mid, l, r) + G(v << 1 | 1, mid + 1, tr, l, r);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
B(1, 1, n);
while (q--) {
int ver;
cin >> ver;
if (ver == 1) {
long long l = 1, r, x;
cin >> r >> x;
long long ans = Find(1, 1, n, l, r, x);
if (ans > r) continue;
U(1, 1, n, ans, r, x);
} else {
long long l;
cin >> l >> rem;
cout << G(1, 1, n, l, n) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
struct node {
long long mx;
long long sum;
long long tag;
long long mn;
} tree[800100];
void pushup(int now) {
tree[now].mx = max(tree[now << 1].mx, tree[now << 1 | 1].mx);
tree[now].sum = tree[now << 1].sum + tree[now << 1 | 1].sum;
tree[now].mn = min(tree[now << 1].mn, tree[now << 1 | 1].mn);
}
void pushdown(int now, int s, int t) {
if (!tree[now].tag) return;
tree[now << 1].mx = tree[now].tag;
tree[now << 1 | 1].mx = tree[now].tag;
int mid = (s + t) >> 1;
tree[now << 1].sum = tree[now].tag * (mid - s + 1);
tree[now << 1 | 1].sum = tree[now].tag * (t - mid);
tree[now << 1 | 1].mn = tree[now].tag;
tree[now << 1].tag = tree[now].tag;
tree[now << 1 | 1].tag = tree[now].tag;
tree[now].tag = 0;
}
void build(int s, int t, int now) {
if (s == t) {
tree[now].mn = tree[now].mx = tree[now].sum = read();
tree[now].tag = false;
return;
}
int mid = (s + t) >> 1;
build(s, mid, now << 1);
build(mid + 1, t, now << 1 | 1);
pushup(now);
}
long long ask(int pos, int s, int t, int now) {
if (s == t) {
return tree[now].mx;
}
int mid = (s + t) >> 1;
pushdown(now, s, t);
if (pos <= mid) {
return ask(pos, s, mid, now << 1);
} else {
return ask(pos, mid + 1, t, now << 1 | 1);
}
}
long long ans = 0;
long long ask(int l, int r, int s, int t, int now, long long money) {
if (money >= tree[now].sum && l <= s && t <= r) {
ans += t - s + 1;
return money - tree[now].sum;
}
if (money < tree[now].mn) return money;
if (s == t) return money;
pushdown(now, s, t);
int mid = (s + t) >> 1;
if (l <= mid) money = ask(l, r, s, mid, now << 1, money);
if (r > mid) money = ask(l, r, mid + 1, t, now << 1 | 1, money);
return money;
}
void change(int l, int r, int s, int t, int now, long long val) {
if (l <= s && t <= r) {
tree[now].mx = val;
tree[now].sum = (t - s + 1) * val;
tree[now].tag = val;
tree[now].mn = val;
return;
}
int mid = (s + t) >> 1;
pushdown(now, s, t);
if (l <= mid) {
change(l, r, s, mid, now << 1, val);
}
if (r > mid) {
change(l, r, mid + 1, t, now << 1 | 1, val);
}
pushup(now);
}
int main() {
int n = read(), q = read() + 1;
build(1, n, 1);
while (--q) {
int op = read();
if (op == 1) {
long long x = read(), y = read();
long long l = 1, r = x + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (ask(mid, 1, n, 1) < y) {
r = mid;
} else {
l = mid + 1;
}
}
if (l == x + 1) continue;
change(l, x, 1, n, 1, y);
} else {
long long x = read(), y = read();
ans = 0;
ask(x, n, 1, n, 1, y);
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,fma,tune=native")
using namespace std;
const long long inf = 1e9 + 5;
struct Node {
Node *l = 0, *r = 0;
long long lo, hi, mset = inf, madd = 0, val = 0, smol = inf;
Node(int lo, int hi) : lo(lo), hi(hi) {}
Node(vector<long long>& v, int lo, int hi) : lo(lo), hi(hi) {
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(v, lo, mid);
r = new Node(v, mid, hi);
val = l->val + r->val;
smol = min(l->smol, r->smol);
} else
val = v[lo], smol = v[lo];
}
long long query(int L, int R) {
if (R <= lo || hi <= L) return 0;
if (L <= lo && hi <= R) return val;
push();
return l->query(L, R) + r->query(L, R);
}
int find(long long v) {
if (smol > v) return hi;
if (lo + 1 == hi) return lo;
if (mset <= v) return lo;
if (l->smol <= v) return l->find(v);
return r->find(v);
}
void set(int L, int R, int x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R)
mset = x, val = (hi - lo) * x, smol = x, madd = 0;
else {
push(), l->set(L, R, x), r->set(L, R, x);
val = l->val + r->val;
smol = min(l->smol, r->smol);
}
}
void push() {
if (!l) {
int mid = lo + (hi - lo) / 2;
l = new Node(lo, mid);
r = new Node(mid, hi);
}
if (mset != inf) l->set(lo, hi, mset), r->set(lo, hi, mset), mset = inf;
}
};
int n, q;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
vector<long long> l(n, 0);
for (int i = 0; i < n; i++) {
long long v;
cin >> v;
l[i] = v;
}
Node seg = Node(l, 0, n);
for (int it = 0; it < q; it++) {
long long y;
int t, x;
cin >> t >> x >> y;
x -= 1;
if (t == 1) {
int left = seg.find(y);
if (x + 1 > left) {
seg.set(left, x + 1, y);
}
} else {
int out = 0;
x = max(x, seg.find(y));
while (x < n) {
long long dist = y / seg.query(x, x + 1);
int lo = min((long long)n - 1, x + dist - 1);
y -= seg.query(x, lo + 1);
out += (lo - x + 1);
x = max(lo + 1, seg.find(y));
}
cout << out << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200010], bl[200010], fl[200010], fr[200010], tg[200010 / 193 + 5];
long long sc[200010 / 193 + 5];
void reslv(int u) {
sc[u] = 0;
for (int i = fl[u]; i <= fr[u]; i++) p[i] = max(p[i], tg[u]), sc[u] += p[i];
tg[u] = 0;
}
void slv(int u, int v) {
if (v <= p[fr[u]] || v <= tg[u]) return;
tg[u] = v;
if (v >= p[fl[u]]) {
sc[u] = 1ll * v * (fr[u] - fl[u] + 1);
return;
}
reslv(u);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
memset(fl, 0x3f, sizeof(fl));
for (int i = 1; i <= n; i++)
bl[i] = i / 193, fl[bl[i]] = min(fl[bl[i]], i),
fr[bl[i]] = max(fr[bl[i]], i);
for (int i = 1; i <= n; i++) sc[bl[i]] += p[i];
while (m-- > 0) {
int opt, v, x;
scanf("%d%d%d", &opt, &v, &x);
if (opt == 1) {
int pr = bl[v];
for (int i = 0; i < pr; i++) slv(i, x);
for (int i = fl[pr]; i <= v; i++) p[i] = max(p[i], x);
reslv(pr);
} else {
int ans = 0;
int pr = bl[v];
reslv(pr);
for (int i = v; i <= fr[pr]; i++)
if (x >= p[i]) x -= p[i], ans++;
for (int b = pr + 1; b <= bl[n]; b++) {
if (sc[b] <= x)
x -= sc[b], ans += fr[b] - fl[b] + 1;
else if (x < tg[b] || x < p[fr[b]])
continue;
else if (tg[b]) {
int pl = min(fr[b] - fl[b] + 1, x / tg[b]);
ans += pl, x -= pl * tg[b];
} else {
for (int i = fl[b]; i <= fr[b] && x >= p[fr[b]]; i++)
if (x >= p[i]) x -= p[i], ans++;
}
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string yno[2] = {"NO\n", "YES\n"};
int la[2000005 * 4], mn[2000005 * 4], mx[2000005 * 4];
long long f[2000005 * 4];
int a[2000005], n;
void check(int k, int l, int r, int t) {
if (l > r) return;
la[k] = max(la[k], t);
if (la[k] >= mx[k]) {
f[k] = 1ll * la[k] * (r - l + 1);
mn[k] = la[k];
mx[k] = la[k];
}
}
void down(int k, int l, int r) {
if (la[k] == 0) return;
if (l >= r) return;
int m = (l + r) >> 1;
check(k << 1, l, m, la[k]);
check((k << 1) | 1, m + 1, r, la[k]);
la[k] = 0;
}
void pup(int k) {
f[k] = f[(k << 1)] + f[(k << 1) + 1];
mn[k] = min(mn[(k << 1)], mn[(k << 1) | 1]);
mx[k] = max(mx[(k << 1)], mx[(k << 1) | 1]);
}
void build(int k, int l, int r) {
if (l > r) return;
if (l == r) {
f[k] = a[l];
mn[k] = a[l];
mx[k] = a[l];
return;
}
int m = (l + r) >> 1;
build((k << 1), l, m);
build((k << 1) + 1, m + 1, r);
pup(k);
}
void up(int k, int u, int v, int l, int r, int val) {
if (u > r || v < l) return;
if (u <= l && r <= v) {
la[k] = max(la[k], val);
if (la[k] >= mx[k]) {
f[k] = 1ll * (r - l + 1) * la[k];
mn[k] = la[k];
mx[k] = la[k];
return;
}
if (la[k] <= mn[k]) {
return;
}
}
down(k, l, r);
int m = (l + r) >> 1;
up((k << 1), u, v, l, m, val);
up((k << 1) | 1, u, v, m + 1, r, val);
pup(k);
}
int get(int k, int u, int v, int l, int r, int &val) {
if (val <= 0 || u > r || v < l) return 0;
if (val < mn[k]) return 0;
if (u <= l && r <= v) {
if (val >= f[k]) {
val -= (int)f[k];
return (r - l + 1);
}
}
if (l >= r) return 0;
down(k, l, r);
int m = (l + r) >> 1;
int ans = get((k << 1), u, v, l, m, val);
ans += get((k << 1) | 1, u, v, m + 1, r, val);
pup(k);
return ans;
}
void process() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (m--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
up(1, 1, x, 1, n, y);
} else {
cout << get(1, x, n, 1, n, y) << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
class SegmentTree {
private:
int n;
vector<int> tlazy, tmn, tmx;
vector<ll> tsum;
void Apply(int v) {
tsum[v] = tsum[v << 1] + tsum[v << 1 | 1];
tmx[v] = max(tmx[v << 1], tmx[v << 1 | 1]);
tmn[v] = min(tmn[v << 1], tmn[v << 1 | 1]);
}
void Push(int v, int tl, int tr) {
if (tl != tr && tlazy[v] != 0) {
tlazy[v << 1] = max(tlazy[v << 1], tlazy[v]);
tlazy[v << 1 | 1] = max(tlazy[v << 1 | 1], tlazy[v]);
tmx[v << 1] = max(tmx[v << 1], tlazy[v]);
tmx[v << 1 | 1] = max(tmx[v << 1 | 1], tlazy[v]);
tmn[v << 1] = max(tmn[v << 1], tlazy[v]);
tmn[v << 1 | 1] = max(tmn[v << 1 | 1], tlazy[v]);
int tm = (tl + tr) >> 1;
tsum[v << 1] = (tm - tl + 1ll) * tmx[v << 1];
tsum[v << 1 | 1] = (tr - tm + 0ll) * tmx[v << 1 | 1];
}
tlazy[v] = 0;
}
void Build(vector<int> &a, int v, int tl, int tr) {
if (tl == tr) {
tmx[v] = tmn[v] = tsum[v] = a[tl];
return;
}
int tm = (tl + tr) >> 1;
Build(a, v << 1, tl, tm);
Build(a, v << 1 | 1, tm + 1, tr);
Apply(v);
}
void Upd(int v, int tl, int tr, int l, int r, int value) {
if (l > r) {
return;
}
if (value <= tmn[v]) {
return;
}
if (l == tl && tr == r && value > tmx[v]) {
tlazy[v] = value;
tsum[v] = (tr - tl + 1ll) * tlazy[v];
tmx[v] = tmn[v] = tlazy[v];
return;
}
Push(v, tl, tr);
int tm = (tl + tr) >> 1;
Upd(v << 1, tl, tm, l, min(tm, r), value);
Upd(v << 1 | 1, tm + 1, tr, max(l, tm + 1), r, value);
Apply(v);
}
int GetAnswer(int v, int tl, int tr, int l, int r, int &y) {
if (l > r) {
return 0;
}
Push(v, tl, tr);
if (tl == l && tr == r) {
if (y >= tsum[v]) {
y -= tsum[v];
return tr - tl + 1;
}
if (tmn[v] > y) {
return 0;
}
}
int tm = (tl + tr) >> 1;
return (GetAnswer(v << 1, tl, tm, l, min(tm, r), y) +
GetAnswer(v << 1 | 1, tm + 1, tr, max(l, tm + 1), r, y));
}
public:
explicit SegmentTree(int n) : n(n) {
tmx.resize(n * 4 + 1);
tmn.resize(n * 4 + 1);
tsum.resize(n * 4 + 1);
tlazy.resize(n * 4 + 1);
}
void Build(vector<int> &a) { Build(a, 1, 0, n - 1); }
void ChangeMax(int l, int r, int value) { Upd(1, 0, n - 1, l, r, value); }
ll GetAnswer(int l, int r, int y) { return GetAnswer(1, 0, n - 1, l, r, y); }
};
void solve() {
int q, n;
cin >> n >> q;
vector<int> a(n);
for (auto &i : a) {
cin >> i;
}
SegmentTree segmentTree(n);
segmentTree.Build(a);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
segmentTree.ChangeMax(0, x, y);
} else {
cout << segmentTree.GetAnswer(x, n - 1, y) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int test = 1;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
using namespace std;
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
const int mod = 1e9 + 7;
const long long INF = 3e18;
const int N = 2e5 + 5;
const int P0 = 437;
const int P1 = 343;
const int d = 400;
struct node {
int mi, ma, gift;
long long sum;
node() {
mi = gift = mod;
ma = -mod;
sum = 0;
}
};
vector<int> a;
int n, q;
vector<node> tree;
void Push(int v, int L, int R) {
if (tree[v].gift == mod) return;
int c = (L + R) / 2;
tree[v * 2].mi = tree[v * 2].ma = tree[v * 2 + 1].mi = tree[v * 2 + 1].ma =
tree[v * 2].gift = tree[v * 2 + 1].gift = tree[v].gift;
tree[v * 2].sum = (long long)(c - L) * tree[v].gift;
tree[v * 2 + 1].sum = (long long)(R - c) * tree[v].gift;
tree[v].gift = mod;
}
int F_smaller(int v, int L, int R, int k) {
if (R - L == 1) {
if (tree[v].mi > k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (tree[v * 2].mi > k) {
if (tree[v * 2 + 1].mi > k) return -1;
return F_smaller(v * 2 + 1, c, R, k);
}
return F_smaller(v * 2, L, c, k);
}
long long Get_sum(int v, int L, int R, int l, int r) {
if (L == l && R == r) return tree[v].sum;
Push(v, L, R);
int c = (L + R) / 2;
long long an = 0;
if (l < c) an += Get_sum(v * 2, L, c, l, min(r, c));
if (c < r) an += Get_sum(v * 2 + 1, c, R, max(l, c), r);
return an;
}
int F_right(int v, int L, int R, int Le, long long k, long long cur_sum) {
if (R - L == 1) {
if (tree[v].sum <= k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (Le >= c)
return F_right(v * 2 + 1, c, R, Le, k, cur_sum - tree[v * 2].sum);
if (Le > L) {
long long Sleft = tree[v * 2].sum - cur_sum;
if (Sleft <= k) return F_right(v * 2 + 1, c, R, Le, k - Sleft, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
if (tree[v * 2].sum <= k)
return F_right(v * 2 + 1, c, R, Le, k - tree[v * 2].sum, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
void Upd(int v, int L, int R, int l, int r, int nmax) {
if (L == l && R == r) {
tree[v].mi = tree[v].ma = tree[v].gift = nmax;
tree[v].sum = (long long)(R - L) * nmax;
return;
}
Push(v, L, R);
int c = (L + R) / 2;
if (l < c) Upd(v * 2, L, c, l, min(r, c), nmax);
if (c < r) Upd(v * 2 + 1, c, R, max(l, c), r, nmax);
tree[v].sum = tree[v * 2].sum + tree[v * 2 + 1].sum;
tree[v].mi = tree[v * 2 + 1].mi;
tree[v].ma = tree[v * 2].ma;
}
void Update(int x, int nmax) {
int pos = F_smaller(1, 0, n, nmax);
if (pos == -1 || pos > x) return;
Upd(1, 0, n, pos, x + 1, nmax);
}
void solve() {
cin >> n >> q;
a.resize(n);
tree.resize(n * 4);
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
for (int i = 0; i < (n); i++) Upd(1, 0, n, i, i + 1, a[i]);
for (int i = 0; i < (q); i++) {
long long t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1)
Update(x, y);
else {
int cnt = 0;
while (true) {
long long pos = F_smaller(1, 0, n, y);
if (pos == -1 || pos == n) break;
pos = max(pos, x);
long long Csum = 0;
if (pos) Csum = Get_sum(1, 0, n, 0, pos);
int R = F_right(1, 0, n, pos, y, Csum);
cnt += R - pos;
y -= Get_sum(1, 0, n, pos, R);
pos = R;
if (pos == n) break;
}
cout << cnt << '\n';
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int qq = 1;
while (qq--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 4e5 + 100;
struct node {
long long mx, mn;
long long sum;
} tree[maxn * 4];
long long a[maxn], lazy[maxn];
void pushup(long long now) {
tree[now].mx = max(tree[now << 1].mx, tree[now << 1 | 1].mx);
tree[now].mn = min(tree[now << 1].mn, tree[now << 1 | 1].mn);
tree[now].sum = tree[now << 1].sum + tree[now << 1 | 1].sum;
}
void pushdown(long long now, long long l, long long r) {
if (lazy[now] != 0) {
long long mid = (l + r) >> 1;
tree[now << 1].mn = lazy[now];
tree[now << 1 | 1].mn = lazy[now];
tree[now << 1].mx = lazy[now];
tree[now << 1 | 1].mx = lazy[now];
tree[now << 1].sum = lazy[now] * (mid - l + 1);
tree[now << 1 | 1].sum = lazy[now] * (r - mid);
lazy[now << 1 | 1] = lazy[now];
lazy[now << 1] = lazy[now];
lazy[now] = 0;
}
}
void build(long long now, long long l, long long r) {
long long mid = (l + r) >> 1;
if (l == r) {
tree[now].mx = tree[now].mn = a[l];
tree[now].sum = a[l];
return;
}
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
pushup(now);
}
void up(long long now, long long l, long long r, long long L, long long R,
long long val) {
long long mid = (l + r) >> 1;
if (tree[now].mn >= val) return;
if (L <= l && r <= R && tree[now].mx <= val) {
tree[now].sum = (r - l + 1) * val;
lazy[now] = tree[now].mx = tree[now].mn = val;
return;
}
pushdown(now, l, r);
if (mid >= L) up(now << 1, l, mid, L, R, val);
if (mid < R) up(now << 1 | 1, mid + 1, r, L, R, val);
pushup(now);
}
long long val;
long long query(long long now, long long l, long long r, long long pos) {
long long mid = (l + r) >> 1;
if (val < tree[now].mn) return 0;
if (l >= pos && tree[now].sum <= val) {
val -= tree[now].sum;
return r - l + 1;
}
if (l == r) return 0;
long long ans = 0;
pushdown(now, l, r);
if (pos <= mid) {
ans += query(now << 1, l, mid, pos);
}
ans += query(now << 1 | 1, mid + 1, r, pos);
return ans;
}
void work() {
long long n, m;
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, 1, n);
long long cmd, x, y;
while (m--) {
scanf("%lld%lld%lld", &cmd, &x, &y);
if (cmd == 1) {
up(1, 1, n, 1, x, y);
} else {
val = y;
long long ans = query(1, 1, n, x);
printf("%lld\n", ans);
}
}
}
signed main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const long long maxn = (long long)1e6 + 5;
const long long mod = 998244353;
const long long inf = 0x3f3f3f3f;
long long T = 1;
long long a[maxn];
struct node {
long long l, r, val, sum, tag;
} t[maxn];
void push_down(long long st) {
if (t[st].tag) {
t[st << 1].tag = t[st << 1 | 1].tag = t[st].tag;
t[st << 1].val = t[st << 1 | 1].val = t[st].tag;
t[st << 1].sum = t[st].tag * (t[st << 1].r - t[st << 1].l + 1);
t[st << 1 | 1].sum = t[st].tag * (t[st << 1 | 1].r - t[st << 1 | 1].l + 1);
t[st].tag = 0;
}
}
void push_up(long long st) {
t[st].val = min(t[st << 1].val, t[st << 1 | 1].val);
t[st].sum = t[st << 1].sum + t[st << 1 | 1].sum;
}
void build(long long st, long long l, long long r) {
t[st] = {l, r, 0, 0, 0};
if (l == r) {
t[st].sum = t[st].val = a[l];
return;
}
long long mid = (l + r) >> 1;
build(st << 1, l, mid);
build(st << 1 | 1, mid + 1, r);
push_up(st);
}
void update(long long st, long long l, long long r, long long val) {
if (l <= t[st].l && t[st].r <= r) {
t[st].sum = val * (t[st].r - t[st].l + 1);
t[st].tag = t[st].val = val;
return;
}
push_down(st);
long long mid = (t[st].l + t[st].r) >> 1;
if (l <= mid) update(st << 1, l, r, val);
if (r > mid) update(st << 1 | 1, l, r, val);
push_up(st);
}
long long find(long long st, long long val) {
if (t[st].l == t[st].r) return t[st].l;
push_down(st);
if (t[st << 1].val <= val)
return find(st << 1, val);
else
return find(st << 1 | 1, val);
}
long long querySum(long long st, long long l, long long r) {
if (l <= t[st].l && t[st].r <= r) {
return t[st].sum;
}
push_down(st);
long long mid = (t[st].l + t[st].r) >> 1;
long long sum = 0;
if (l <= mid) sum += querySum(st << 1, l, r);
if (r > mid) sum += querySum(st << 1 | 1, l, r);
return sum;
}
long long query(long long st, long long &val) {
if (t[st].sum <= val) {
val -= t[st].sum;
return t[st].r - t[st].l + 1;
}
push_down(st);
long long ans = 0;
if (t[st << 1].val <= val) ans += query(st << 1, val);
if (t[st << 1 | 1].val <= val) ans += query(st << 1 | 1, val);
return ans;
}
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> a[i];
build(1, 1, n);
for (long long i = 1; i <= m; ++i) {
long long op, x, y;
cin >> op >> x >> y;
if (op == 1)
update(1, find(1, y), x, y);
else {
if (x > 1) y += querySum(1, 1, x - 1);
cout << query(1, y) - x + 1 << '\n';
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, Q, a[200020];
struct node {
int l, r, mn, cov;
long long s;
void Cover(int d) {
cov = mn = d;
s = 1LL * (r - l + 1) * d;
}
} tree[200020 << 2];
inline void update(int i) {
tree[i].mn = min(tree[i << 1].mn, tree[i << 1 | 1].mn);
tree[i].s = tree[i << 1].s + tree[i << 1 | 1].s;
}
inline void pushdown(int i) {
if (tree[i].cov) {
tree[i << 1].Cover(tree[i].cov);
tree[i << 1 | 1].Cover(tree[i].cov);
tree[i].cov = 0;
}
}
void build(int i, int l, int r) {
tree[i].l = l;
tree[i].r = r;
if (l == r) {
tree[i].mn = tree[i].s = a[l];
return;
}
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
update(i);
}
int Get1(int i, int l, int r, int t) {
if (tree[i].mn > t) return n + 1;
if (tree[i].l == tree[i].r) return tree[i].l;
pushdown(i);
int ans = n + 1;
int mid = (tree[i].l + tree[i].r) >> 1;
if (l <= mid) {
ans = min(ans, Get1(i << 1, l, r, t));
if (ans <= n) return ans;
}
if (r > mid) {
ans = min(ans, Get1(i << 1 | 1, l, r, t));
}
return ans;
}
int Get2(int i, int l, int &t) {
if (tree[i].l >= l && t >= tree[i].s) {
t -= tree[i].s;
return tree[i].r;
}
if (tree[i].l == tree[i].r) return n + 1;
pushdown(i);
int mid = (tree[i].l + tree[i].r) >> 1;
if (l > mid) return Get2(i << 1 | 1, l, t);
int ans = Get2(i << 1, l, t);
if (ans == mid) {
int tmp = Get2(i << 1 | 1, l, t);
if (tmp <= n) return tmp;
}
return ans;
}
void Change(int i, int l, int r, int d) {
if (tree[i].l >= l && tree[i].r <= r) {
tree[i].Cover(d);
return;
}
pushdown(i);
int mid = (tree[i].l + tree[i].r) >> 1;
if (l <= mid) {
Change(i << 1, l, r, d);
}
if (r > mid) {
Change(i << 1 | 1, l, r, d);
}
update(i);
}
int Ask(int p, int t) {
int ans = 0;
while (p <= n) {
int x = Get1(1, p, n, t);
if (x > n) break;
int y = Get2(1, x, t);
ans += y - x + 1;
p = y + 1;
}
return ans;
}
void Max(int r, int t) {
int l = Get1(1, 1, r, t);
if (l > n) return;
Change(1, l, r, t);
}
int main() {
n = read(), Q = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
}
build(1, 1, n);
while (Q--) {
int opt = read(), x = read(), y = read();
if (opt == 2) {
printf("%d\n", Ask(x, y));
} else {
Max(x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx2")
using namespace std;
using ll = long long;
template <typename T>
inline T& ckmin(T& a, T b) {
return a = a > b ? b : a;
}
template <typename T>
inline T& ckmax(T& a, T b) {
return a = a < b ? b : a;
}
class lazy_segment_tree {
struct node {
ll sum, mx, mn, lzy;
};
int n;
vector<node> a;
private:
void push(int t, int s, int e) {
if (a[t].lzy) {
a[t].sum = a[t].lzy * (e - s + 1);
a[t].mn = a[t].mx = a[t].lzy;
if (s != e) a[t << 1 | 1].lzy = a[t << 1].lzy = a[t].lzy;
a[t].lzy = 0;
}
}
void pull(int t, int s, int e) {
assert(e != s);
assert(a[t].lzy == 0);
a[t].sum = a[t << 1].sum + a[t << 1 | 1].sum;
a[t].mx = a[t << 1].mx;
a[t].mn = a[t << 1 | 1].mn;
}
void update(int t, int s, int e, int l, int r, ll y) {
push(t, s, e);
if (r < s || e < l) return;
if (l <= s && e <= r) {
a[t].lzy = y;
push(t, s, e);
return;
}
int m = (s + e) >> 1;
update(t << 1, s, m, l, r, y);
update(t << 1 | 1, m + 1, e, l, r, y);
pull(t, s, e);
}
ll sum_query(int t, int s, int e, int l, int r) {
push(t, s, e);
if (r < s || e < l) return 0;
if (l <= s && e <= r) return a[t].sum;
int m = (s + e) >> 1;
return sum_query(t << 1, s, m, l, r) +
sum_query(t << 1 | 1, m + 1, e, l, r);
}
ll max_query(int t, int s, int e, int l, int r) {
push(t, s, e);
if (r < s || e < l) return 0;
if (l <= s && e <= r) return a[t].mx;
int m = (s + e) >> 1;
return max(max_query(t << 1, s, m, l, r),
max_query(t << 1 | 1, m + 1, e, l, r));
}
int first_leq(int t, int s, int e, ll y) {
push(t, s, e);
if (a[t].mn > y) return e + 1;
if (s == e) return s;
if (a[t << 1].mn <= y)
return first_leq(t << 1, s, (s + e) >> 1, y);
else
return first_leq(t << 1 | 1, (s + e + 2) >> 1, e, y);
}
int first_sum_gr(int t, int s, int e, ll y) {
push(t, s, e);
if (s == e) return s;
int m = (s + e) >> 1;
push(t << 1, s, m);
if (a[t << 1].sum <= y)
return first_sum_gr(t << 1 | 1, m + 1, e, y - a[t << 1].sum);
else
return first_sum_gr(t << 1, s, m, y);
}
public:
lazy_segment_tree(int n_) : n{n_}, a(n << 2) {}
void update(int l, int r, ll y) { update(1, 0, n - 1, l, r, y); }
ll sum_query(int l, int r) { return sum_query(1, 0, n - 1, l, r); }
ll max_query(int l, int r) { return max_query(1, 0, n - 1, l, r); }
int first_leq(ll y) { return first_leq(1, 0, n - 1, y); }
int first_sum_gr(ll y) {
if (a[1].sum <= y) return n;
return first_sum_gr(1, 0, n - 1, y);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<ll> a(n);
for (ll& x : a) cin >> x;
lazy_segment_tree seg(n);
for (int i = (n)-1; i >= 0; --i) seg.update(0, i, a[i]);
auto update = [&](int x, ll y) {
int z = seg.first_leq(y);
42;
if (z > x) return;
seg.update(z, x, y);
};
function<int(int, ll)> query = [&](int x, ll y) {
if (x == n || y == 0) return 0;
int z{x - 1};
z = seg.first_sum_gr(y + (x ? seg.sum_query(0, x - 1) : 0)) - 1;
assert(seg.sum_query(x, z) <= y);
assert(z == n - 1 || seg.sum_query(x, z + 1) > y);
if (z >= x) y -= seg.sum_query(x, z);
int r{max(z - x + 1, 0)};
int t = seg.first_leq(y);
42;
assert((t == n || seg.max_query(t, n - 1) <= y) &&
(t == 0 || seg.max_query(t - 1, n - 1) > y));
assert(z == n - 1 || t > max(z, x));
if (t > max(z, x)) r += query(t, y);
return r;
};
for (int _ = 0; _ < (q); ++_) {
int t, x;
ll y;
cin >> t >> x >> y;
--x;
if (t == 1)
update(x, y);
else
cout << query(x, y) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, q;
long long a[500000 + 5];
struct segment_tree {
struct node {
long long l;
long long r;
long long minv;
long long sum;
long long tag;
long long len() { return r - l + 1; }
} tree[500000 * 4 + 5];
void push_up(long long pos) {
tree[pos].sum = tree[pos << 1].sum + tree[pos << 1 | 1].sum;
tree[pos].minv = min(tree[pos << 1].minv, tree[pos << 1 | 1].minv);
}
void build(long long l, long long r, long long pos) {
tree[pos].l = l;
tree[pos].r = r;
if (l == r) {
tree[pos].minv = tree[pos].sum = a[l];
return;
}
long long mid = (l + r) >> 1;
build(l, mid, pos << 1);
build(mid + 1, r, pos << 1 | 1);
push_up(pos);
}
void set_tag(long long pos, long long val) {
tree[pos].minv = val;
tree[pos].tag = val;
tree[pos].sum = val * tree[pos].len();
}
void push_down(long long pos) {
if (tree[pos].tag) {
set_tag(pos << 1, tree[pos].tag);
set_tag(pos << 1 | 1, tree[pos].tag);
tree[pos].tag = 0;
}
}
void update(long long L, long long R, long long val, long long pos) {
if (L <= tree[pos].l && R >= tree[pos].r) {
set_tag(pos, val);
return;
}
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
if (L <= mid) update(L, R, val, pos << 1);
if (R > mid) update(L, R, val, pos << 1 | 1);
push_up(pos);
}
long long getPos(long long val, long long pos) {
if (tree[pos].l == tree[pos].r) return tree[pos].l;
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
if (tree[pos << 1].minv >= val)
return getPos(val, pos << 1 | 1);
else
return getPos(val, pos << 1);
}
long long getSum(long long L, long long R, long long pos) {
if (L > R) return 0;
if (L <= tree[pos].l && R >= tree[pos].r) return tree[pos].sum;
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
long long ans = 0;
if (L <= mid) ans += getSum(L, R, pos << 1);
if (R > mid) ans += getSum(L, R, pos << 1 | 1);
return ans;
}
long long getAns(long long &val, long long pos) {
if (tree[pos].sum <= val) {
val -= tree[pos].sum;
return tree[pos].r - tree[pos].l + 1;
}
if (tree[pos].l == tree[pos].r) return 0;
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
long long ans = 0;
if (tree[pos << 1].minv <= val) ans += getAns(val, pos << 1);
if (tree[pos << 1 | 1].minv <= val) ans += getAns(val, pos << 1 | 1);
return ans;
}
} T;
int main() {
long long op;
long long x, y;
scanf("%lld %lld", &n, &q);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
T.build(1, n, 1);
for (long long i = 1; i <= q; i++) {
scanf("%lld", &op);
if (op == 1) {
scanf("%lld %lld", &x, &y);
long long p = T.getPos(y, 1);
if (p <= x) T.update(p, x, y, 1);
} else {
scanf("%lld %lld", &x, &y);
y += T.getSum(1, x - 1, 1);
long long ans = T.getAns(y, 1) - (x - 1);
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
namespace atcoder {
namespace internal {
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
int bsf(unsigned int n) { return __builtin_ctz(n); }
} // namespace internal
} // namespace atcoder
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S>& v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++) update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l) update(l >> i);
if (((r >> i) << i) != r) update((r - 1) >> i);
}
}
template <bool (*g)(S)>
int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G>
int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n) return _n;
l += size;
for (int i = log; i >= 1; i--) push(l >> i);
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)>
int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G>
int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0) return 0;
r += size;
for (int i = log; i >= 1; i--) push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size) lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
namespace rangeupdaterangesummin {
using Int = long long;
const Int INF = 101010101010LL;
struct S {
Int sum;
int sz;
Int minval;
};
using F = std::pair<bool, Int>;
S op(S a, S b) {
return S{a.sum + b.sum, a.sz + b.sz, std::min(a.minval, b.minval)};
}
S mapping(F f, S x) { return f.first ? S{x.sz * f.second, x.sz, f.second} : x; }
F composition(F later, F conventional) {
return later.first ? later : conventional;
}
S e() { return S{0, 0, INF}; }
F id() { return std::make_pair(false, INF); }
using RangeUpdateRangeSumMin =
atcoder::lazy_segtree<S, op, e, F, mapping, composition, id>;
}; // namespace rangeupdaterangesummin
using rangeupdaterangesummin::RangeUpdateRangeSumMin;
using rangeupdaterangesummin::S;
using namespace std;
int main() {
cin.tie(nullptr), ios::sync_with_stdio(false);
int N, Q;
cin >> N >> Q;
vector<long long> A(N);
for (auto& a : A) cin >> a;
vector<S> v;
for (auto a : A) v.push_back({a, 1, a});
RangeUpdateRangeSumMin seg(v);
while (Q--) {
int t, x;
long long y;
cin >> t >> x >> y;
if (t == 1) {
int i = seg.max_right(0, [&](S s) { return s.minval > y; });
if (i < x) {
seg.apply(i, x, make_pair(1, y));
}
} else {
x--;
int ret = 0;
while (x < N) {
int i = seg.max_right(x, [&](S s) { return s.sum <= y; });
y -= seg.prod(x, i).sum;
ret += i - x;
x = seg.max_right(i, [&](S s) { return s.minval > y; });
}
cout << ret << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct node {
long long mmax;
long long mmin;
long long v;
} tree[maxn << 3];
long long cover[maxn << 3];
void PushUp(long long rt) {
tree[rt].mmax = max(tree[rt << 1].mmax, tree[rt << 1 | 1].mmax);
tree[rt].mmin = min(tree[rt << 1].mmin, tree[rt << 1 | 1].mmin);
tree[rt].v = tree[rt << 1].v + tree[rt << 1 | 1].v;
}
void build(long long rt, long long l, long long r) {
cover[rt] = -1;
if (l == r) {
scanf("%lld", &tree[rt].v);
tree[rt].mmax = tree[rt].mmin = tree[rt].v;
return;
}
long long mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
PushUp(rt);
}
void PushDown(long long rt, long long l, long long r) {
if (cover[rt] != -1) {
tree[rt].v = (r - l + 1) * cover[rt];
tree[rt << 1].mmax = tree[rt << 1].mmin = tree[rt << 1 | 1].mmax =
tree[rt << 1 | 1].mmin = cover[rt];
int rc = (r - l + 1) >> 1;
int lc = (r - l + 1) - rc;
tree[rt << 1].v = lc * cover[rt];
tree[rt << 1 | 1].v = rc * cover[rt];
cover[rt << 1] = cover[rt << 1 | 1] = cover[rt];
cover[rt] = -1;
}
}
void update(long long rt, long long l, long long r, long long L, long long R,
long long v) {
if (L > R) return;
if (L <= l && R >= r) {
if (tree[rt].mmax <= v) {
cover[rt] = v;
tree[rt].mmax = tree[rt].mmin = v;
tree[rt].v = (r - l + 1) * v;
return;
}
if (tree[rt].mmin >= v) {
return;
}
}
PushDown(rt, l, r);
long long mid = (l + r) >> 1;
if (L <= mid) update(rt << 1, l, mid, L, R, v);
if (R > mid) update(rt << 1 | 1, mid + 1, r, L, R, v);
PushUp(rt);
}
long long ans = 0;
long long query(long long rt, long long l, long long r, long long L,
long long now) {
if (now <= 0) return 0;
if (l >= L) {
if (tree[rt].mmin > now)
return 0;
else if (cover[rt] != -1) {
long long res = min(now / cover[rt], r - l + 1);
ans += res;
res = res * cover[rt];
return res;
} else if (tree[rt].v <= now) {
ans += r - l + 1;
return tree[rt].v;
}
}
if (l == r) return 0;
PushDown(rt, l, r);
long long mid = (l + r) >> 1;
long long sub = 0;
if (L <= mid) sub += query(rt << 1, l, mid, L, now);
sub += query(rt << 1 | 1, mid + 1, r, L, now - sub);
PushUp(rt);
return sub;
}
int main() {
long long n, q;
cin >> n >> q;
build(1, 1, n);
while (q--) {
long long op, x, y;
cin >> op >> x >> y;
if (op == 1) {
update(1, 1, n, 1, x, y);
} else {
ans = 0;
long long sub = query(1, 1, n, x, y);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int n, q;
int a[maxN];
long long t[4 * maxN];
int mn[4 * maxN];
int cnt[4 * maxN];
int lazy[4 * maxN];
int mx[4 * maxN];
void merge(int v) {
mn[v] = min(mn[2 * v], mn[2 * v + 1]);
mx[v] = max(mx[2 * v], mx[2 * v + 1]);
t[v] = t[2 * v] + t[2 * v + 1];
}
void apply(int v, int x) {
lazy[v] = x;
mn[v] = x;
mx[v] = x;
t[v] = 1LL * cnt[v] * x;
}
void push(int v, int tl, int tr) {
if (tl != tr && lazy[v] != 0) {
apply(2 * v, lazy[v]);
apply(2 * v + 1, lazy[v]);
}
lazy[v] = 0;
}
void build(int v, int tl, int tr) {
if (tl == tr) {
mn[v] = a[tl];
mx[v] = a[tl];
t[v] = a[tl];
cnt[v] = 1;
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
cnt[v] = tr - tl + 1;
merge(v);
}
void do_max(int v, int tl, int tr, int l, int r, int x) {
if (tr < l || r < tl) return;
if (mn[v] >= x) return;
if (l <= tl && tr <= r && mx[v] < x) {
apply(v, x);
return;
}
push(v, tl, tr);
int tm = (tl + tr) / 2;
do_max(2 * v, tl, tm, l, r, x);
do_max(2 * v + 1, tm + 1, tr, l, r, x);
merge(v);
}
int go(int v, int tl, int tr, int l, int r, int& y) {
push(v, tl, tr);
if (tl == l && tr == r) {
if (y >= t[v]) {
y -= t[v];
return cnt[v];
}
if (mn[v] > y) {
return 0;
}
int tm = (tl + tr) / 2;
int d1 = go(2 * v, tl, tm, l, tm, y);
int d2 = go(2 * v + 1, tm + 1, tr, tm + 1, r, y);
return d1 + d2;
}
int tm = (tl + tr) / 2;
if (r <= tm) {
return go(2 * v, tl, tm, l, r, y);
} else if (l > tm) {
return go(2 * v + 1, tm + 1, tr, l, r, y);
} else {
int d1 = go(2 * v, tl, tm, l, tm, y);
int d2 = go(2 * v + 1, tm + 1, tr, tm + 1, r, y);
return d1 + d2;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
build(1, 1, n);
while (q--) {
int tp, x, y;
cin >> tp >> x >> y;
if (tp == 1) {
do_max(1, 1, n, 1, x, y);
} else {
cout << go(1, 1, n, x, n, y) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
const int mod = 1e9 + 7;
const long long INF = 3e18;
const int N = 2e5 + 5;
const int P0 = 437;
const int P1 = 343;
const int d = 400;
struct node {
int mi, ma, gift;
long long sum;
node() {
mi = gift = mod;
ma = -mod;
sum = 0;
}
};
vector<int> a;
int n, q;
vector<node> tree;
void Push(int v, int L, int R) {
if (tree[v].gift == mod) return;
int c = (L + R) / 2;
tree[v * 2].mi = tree[v * 2].ma = tree[v * 2 + 1].mi = tree[v * 2 + 1].ma =
tree[v * 2].gift = tree[v * 2 + 1].gift = tree[v].gift;
tree[v * 2].sum = (long long)(c - L) * tree[v].gift;
tree[v * 2 + 1].sum = (long long)(R - c) * tree[v].gift;
tree[v].gift = mod;
}
int F_smaller(int v, int L, int R, int k) {
if (R - L == 1) {
if (tree[v].mi > k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (tree[v * 2].mi > k) {
if (tree[v * 2 + 1].mi > k) return -1;
return F_smaller(v * 2 + 1, c, R, k);
}
return F_smaller(v * 2, L, c, k);
}
long long Get_sum(int v, int L, int R, int l, int r) {
if (L == l && R == r) return tree[v].sum;
Push(v, L, R);
int c = (L + R) / 2;
long long an = 0;
if (l < c) an += Get_sum(v * 2, L, c, l, min(r, c));
if (c < r) an += Get_sum(v * 2 + 1, c, R, max(l, c), r);
return an;
}
int F_right(int v, int L, int R, int Le, long long k, long long cur_sum) {
if (R - L == 1) {
if (tree[v].sum <= k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (Le >= c)
return F_right(v * 2 + 1, c, R, Le, k, cur_sum - tree[v * 2].sum);
if (Le > L) {
long long Sleft = tree[v * 2].sum - cur_sum;
if (Sleft <= k) return F_right(v * 2 + 1, c, R, Le, k - Sleft, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
if (tree[v * 2].sum <= k)
return F_right(v * 2 + 1, c, R, Le, k - tree[v * 2].sum, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
void Upd(int v, int L, int R, int l, int r, int nmax) {
if (L == l && R == r) {
tree[v].mi = tree[v].ma = tree[v].gift = nmax;
tree[v].sum = (long long)(R - L) * nmax;
return;
}
Push(v, L, R);
int c = (L + R) / 2;
if (l < c) Upd(v * 2, L, c, l, min(r, c), nmax);
if (c < r) Upd(v * 2 + 1, c, R, max(l, c), r, nmax);
tree[v].sum = tree[v * 2].sum + tree[v * 2 + 1].sum;
tree[v].mi = tree[v * 2 + 1].mi;
tree[v].ma = tree[v * 2].ma;
}
void Update(int x, int nmax) {
int pos = F_smaller(1, 0, n, nmax);
if (pos == -1 || pos > x) return;
Upd(1, 0, n, pos, x + 1, nmax);
}
void solve() {
cin >> n >> q;
a.resize(n);
tree.resize(n * 4);
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
for (int i = 0; i < (n); i++) Upd(1, 0, n, i, i + 1, a[i]);
for (int i = 0; i < (q); i++) {
long long t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1)
Update(x, y);
else {
int cnt = 0;
while (true) {
long long pos = F_smaller(1, 0, n, y);
if (pos == -1 || pos == n) break;
pos = max(pos, x);
long long Csum = 0;
if (pos) Csum = Get_sum(1, 0, n, 0, pos);
int R = F_right(1, 0, n, pos, y, Csum);
cnt += R - pos;
y -= Get_sum(1, 0, n, pos, R);
pos = R;
if (pos == n) break;
}
cout << cnt << '\n';
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int qq = 1;
while (qq--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {+1, -1, 0, 0};
int dy[] = {0, 0, +1, -1};
int n, q;
int a[200005];
long long sum[200005 * 4], small[200005 * 4], big[200005 * 4], lazy[200005 * 4];
long long hand;
void propagate(int node, long long st, long long en) {
if (st != en) {
lazy[node * 2] = lazy[node];
lazy[node * 2 + 1] = lazy[node];
}
small[node] = lazy[node];
big[node] = lazy[node];
sum[node] = (en - st + 1) * lazy[node];
lazy[node] = 0;
}
void determine(int node, int l, int mid, int r) {
long long sum1 = sum[node * 2], small1 = small[node * 2],
big1 = big[node * 2];
long long sum2 = sum[node * 2 + 1], small2 = small[node * 2 + 1],
big2 = big[node * 2 + 1];
if (lazy[node * 2]) {
sum1 = 1LL * lazy[node * 2] * (mid - l + 1);
small1 = lazy[node * 2];
big1 = lazy[node * 2];
}
if (lazy[node * 2 + 1]) {
sum2 = 1LL * lazy[node * 2 + 1] * (r - mid);
small2 = lazy[node * 2 + 1];
big2 = lazy[node * 2 + 1];
}
sum[node] = sum1 + sum2;
small[node] = min(small1, small2);
big[node] = max(big1, big2);
}
void build(int node, int l, int r) {
if (l == r) {
sum[node] = a[l];
small[node] = a[l];
big[node] = a[l];
} else {
int mid = (l + r) / 2;
build(node * 2, l, mid);
build(node * 2 + 1, mid + 1, r);
determine(node, l, mid, r);
}
}
void update(int node, int l, int r, int i, int j, int val) {
if (l > j || r < i)
return;
else if (l >= i && r <= j) {
if (lazy[node]) propagate(node, l, r);
if (big[node] < val && small[node] < val) {
lazy[node] = val;
} else if (small[node] < val) {
int mid = (l + r) / 2;
update(node * 2, l, mid, i, j, val);
update(node * 2 + 1, mid + 1, r, i, j, val);
determine(node, l, mid, r);
}
} else {
if (lazy[node]) propagate(node, l, r);
int mid = (l + r) / 2;
update(node * 2, l, mid, i, j, val);
update(node * 2 + 1, mid + 1, r, i, j, val);
determine(node, l, mid, r);
}
}
long long query(int node, int l, int r, int i, int j) {
if (l > j || r < i)
return 0;
else if (l >= i && r <= j) {
if (lazy[node]) propagate(node, l, r);
if (sum[node] <= hand) {
hand -= sum[node];
return (r - l + 1);
} else if (small[node] > hand)
return 0;
else {
int mid = (l + r) / 2;
long long res =
query(node * 2, l, mid, i, j) + query(node * 2 + 1, mid + 1, r, i, j);
determine(node, l, mid, r);
return res;
}
} else {
if (lazy[node]) propagate(node, l, r);
int mid = (l + r) / 2;
long long res =
query(node * 2, l, mid, i, j) + query(node * 2 + 1, mid + 1, r, i, j);
determine(node, l, mid, r);
return res;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
for (int i = 1; i <= q; i++) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
update(1, 1, n, 1, x, y);
} else {
hand = y;
long long ans = query(1, 1, n, x, n);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p);
template <class T>
ostream &operator<<(ostream &os, vector<T> &v);
template <class T>
ostream &operator<<(ostream &os, set<T> &v);
inline void optimizeIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const int nmax = 2e5 + 7;
struct Node {
long long mn, mx, sum;
long long lazy;
Node() { mn = INT_MAX, mx = sum = 0, lazy = 0; }
void create_leaf(long long val) { mn = mx = sum = val, lazy = 0; }
};
Node merge_nodes(Node &a, Node &b) {
Node temp;
temp.mn = min(a.mn, b.mn);
temp.mx = max(a.mx, b.mx);
temp.sum = a.sum + b.sum;
return temp;
}
struct LazySegTree {
long long n;
vector<long long> data;
vector<Node> Tree;
LazySegTree(long long n) {
this->n = n;
long long len = n + 1;
data = vector<long long>(len);
Tree = vector<Node>(len << 2);
}
void build() {
build(1, 1, n);
return;
}
void build(long long cur, long long start, long long end) {
if (start == end) {
Tree[cur].create_leaf(data[start]);
return;
}
long long mid = (start + end) >> 1;
long long lc = cur << 1, rc = lc | 1;
build(lc, start, mid);
build(rc, mid + 1, end);
Tree[cur] = merge_nodes(Tree[lc], Tree[rc]);
}
void node_update(long long v, long long st, long long en, long long val) {
Tree[v].mn = val;
Tree[v].mx = val;
Tree[v].sum = (en - st + 1) * val;
Tree[v].lazy = val;
}
void push(long long v, long long st, long long en) {
long long mid = (st + en) >> 1;
long long lc = v << 1, rc = lc | 1;
if (Tree[v].lazy && st != en) {
node_update(lc, st, mid, Tree[v].lazy);
node_update(rc, mid + 1, en, Tree[v].lazy);
Tree[v].lazy = 0;
}
}
void update(long long ql, long long qr, long long upd_with_mx) {
update(1, 1, n, ql, qr, upd_with_mx);
}
void update(long long cur, long long start, long long end, long long ql,
long long qr, long long upd_with_mx) {
push(cur, start, end);
if (end < ql || start > qr) return;
if (Tree[cur].mn >= upd_with_mx) return;
if (start >= ql && end <= qr && Tree[cur].mx < upd_with_mx) {
node_update(cur, start, end, upd_with_mx);
return;
}
long long mid = (start + end) >> 1;
long long lc = cur << 1, rc = lc | 1;
update(lc, start, mid, ql, qr, upd_with_mx);
update(rc, mid + 1, end, ql, qr, upd_with_mx);
Tree[cur] = merge_nodes(Tree[lc], Tree[rc]);
}
long long query(long long ql, long long qr, long long &rem) {
return query(1, 1, n, ql, qr, rem);
}
long long query(long long cur, long long start, long long end, long long ql,
long long qr, long long &rem) {
push(cur, start, end);
if (end < ql || start > qr) return 0;
if (start >= ql && end <= qr) {
if (rem >= Tree[cur].sum) {
rem -= Tree[cur].sum;
return (end - start + 1);
}
if (rem < Tree[cur].mn) return 0;
}
long long mid = (start + end) >> 1;
long long lc = cur << 1, rc = lc | 1;
long long ansL = query(lc, start, mid, ql, qr, rem);
long long ansR = query(rc, mid + 1, end, ql, qr, rem);
return ansL + ansR;
}
};
void solveTC() {
long long n, q;
cin >> n >> q;
LazySegTree s(n);
for (long long i = 1; i <= n; i++) cin >> s.data[i];
s.build();
while (q--) {
long long type;
cin >> type;
if (type == 1) {
long long l = 1, r, upd_val;
cin >> r >> upd_val;
s.update(l, r, upd_val);
} else {
long long l, r = n, rem;
cin >> l >> rem;
long long ans = s.query(l, r, rem);
cout << ans << "\n";
;
}
}
}
int32_t main() {
optimizeIO();
long long tc = 1;
while (tc--) {
solveTC();
}
return 0;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << "{" << p.first << ", " << p.second << "} ";
return os;
}
template <class T>
ostream &operator<<(ostream &os, vector<T> &v) {
os << "[ ";
for (T i : v) {
os << i << " ";
}
os << " ]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> &v) {
os << "[ ";
for (T i : v) {
os << i << " ";
}
os << " ]";
return os;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 800010;
inline long long read() {
long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
long long n, Q, a[N], cnt;
long long sum[N << 2], flag[N << 2], mi[N << 2];
inline void Push_Up(long long x) {
sum[x] = sum[(x << 1)] + sum[(x << 1 | 1)];
mi[x] = min(mi[(x << 1)], mi[(x << 1 | 1)]);
}
inline void Push_Down(long long x, long long l, long long r) {
long long mid = (l + r) / 2;
mi[(x << 1)] = flag[x], mi[(x << 1 | 1)] = flag[x];
sum[(x << 1)] = flag[x] * (mid - l + 1);
sum[(x << 1 | 1)] = flag[x] * (r - mid);
flag[(x << 1)] = flag[x], flag[(x << 1 | 1)] = flag[x];
flag[x] = 0;
}
void Build(long long x, long long l, long long r) {
cnt++;
assert(cnt <= 100000000);
if (l == r) {
mi[x] = sum[x] = a[l];
return;
}
long long mid = (l + r) / 2;
Build((x << 1), l, mid), Build((x << 1 | 1), mid + 1, r);
Push_Up(x);
}
long long Bound(long long l, long long r, long long x, long long k) {
cnt++;
assert(cnt <= 10000000);
if (l == r) {
if (sum[x] >= k) return r + 1;
return r;
}
long long mid = (l + r) / 2;
if (flag[x]) Push_Down(x, l, r);
if (mi[(x << 1)] >= k) return Bound(mid + 1, r, (x << 1 | 1), k);
return Bound(l, mid, (x << 1), k);
}
void UpDate(long long u, long long v, long long l, long long r, long long x,
long long k) {
cnt++;
assert(cnt <= 100000);
if (l >= u && r <= v) {
flag[x] = mi[x] = k;
sum[x] = k * (r - l + 1);
return;
}
long long mid = (l + r) / 2;
if (flag[x]) Push_Down(x, l, r);
if (u <= mid) UpDate(u, v, l, mid, (x << 1), k);
if (v > mid) UpDate(u, v, mid + 1, r, (x << 1 | 1), k);
Push_Up(x);
}
long long Ask(long long u, long long v, long long l, long long r, long long x,
long long &h) {
cnt++;
assert(cnt <= 100000);
if (flag[x]) Push_Down(x, l, r);
if (l == r) {
if (sum[x] <= h) {
h -= sum[x];
return 1;
}
return 0;
}
if (mi[x] > h) return 0;
if (l >= u && r <= v && sum[x] <= h) {
h -= sum[x];
return r - l + 1;
}
long long mid = (l + r) / 2;
long long res = 0;
if (u <= mid) res += Ask(u, v, l, mid, (x << 1), h);
if (v > mid) res += Ask(u, v, mid + 1, r, (x << 1 | 1), h);
return res;
}
signed main() {
n = read(), Q = read();
for (register long long i = 1; i <= n; i++) a[i] = read();
Build(1, 1, n);
for (register long long i = 1; i <= Q; i++) {
long long opt, o, y;
opt = read(), o = read(), y = read();
if (opt == 1) {
cnt = 0;
long long plc = Bound(1, n, 1, y);
plc = min(plc, o + 1);
if (plc > o) continue;
assert(o <= n), assert(plc <= n);
cnt = 0;
UpDate(plc, o, 1, n, 1, y);
}
if (opt == 2) {
long long h = y;
cnt = 0, printf("%lld\n", Ask(o, n, 1, n, 1, h));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
struct node {
long long mx;
long long sum;
long long tag;
long long mn;
} tree[800100];
void pushup(int now) {
tree[now].mx = max(tree[now << 1].mx, tree[now << 1 | 1].mx);
tree[now].sum = tree[now << 1].sum + tree[now << 1 | 1].sum;
tree[now].mn = min(tree[now << 1].mn, tree[now << 1 | 1].mn);
}
void pushdown(int now, int s, int t) {
if (!tree[now].tag) return;
tree[now << 1].mx = tree[now].tag;
tree[now << 1 | 1].mx = tree[now].tag;
int mid = (s + t) >> 1;
tree[now << 1].sum = tree[now].tag * (mid - s + 1);
tree[now << 1 | 1].sum = tree[now].tag * (t - mid);
tree[now << 1].mn = tree[now].tag;
tree[now << 1 | 1].mn = tree[now].tag;
tree[now << 1].tag = tree[now].tag;
tree[now << 1 | 1].tag = tree[now].tag;
tree[now].tag = 0;
}
void build(int s, int t, int now) {
if (s == t) {
tree[now].mn = tree[now].mx = tree[now].sum = read();
tree[now].tag = false;
return;
}
int mid = (s + t) >> 1;
build(s, mid, now << 1);
build(mid + 1, t, now << 1 | 1);
pushup(now);
}
long long ask(int pos, int s, int t, int now) {
if (s == t) {
return tree[now].mx;
}
int mid = (s + t) >> 1;
pushdown(now, s, t);
if (pos <= mid) {
return ask(pos, s, mid, now << 1);
} else {
return ask(pos, mid + 1, t, now << 1 | 1);
}
}
long long ans = 0;
long long ask(int l, int r, int s, int t, int now, long long money) {
if (money >= tree[now].sum && l <= s && t <= r) {
ans += t - s + 1;
return money - tree[now].sum;
}
if (money < tree[now].mn) return money;
if (s == t) return money;
pushdown(now, s, t);
int mid = (s + t) >> 1;
if (l <= mid) money = ask(l, r, s, mid, now << 1, money);
if (r > mid) money = ask(l, r, mid + 1, t, now << 1 | 1, money);
return money;
}
void change(int l, int r, int s, int t, int now, long long val) {
if (l <= s && t <= r) {
tree[now].mx = val;
tree[now].sum = (t - s + 1) * val;
tree[now].tag = val;
tree[now].mn = val;
return;
}
int mid = (s + t) >> 1;
pushdown(now, s, t);
if (l <= mid) {
change(l, r, s, mid, now << 1, val);
}
if (r > mid) {
change(l, r, mid + 1, t, now << 1 | 1, val);
}
pushup(now);
}
int main() {
int n = read(), q = read() + 1;
build(1, n, 1);
while (--q) {
int op = read();
if (op == 1) {
long long x = read(), y = read();
long long l = 1, r = x + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (ask(mid, 1, n, 1) < y) {
r = mid;
} else {
l = mid + 1;
}
}
if (l == x + 1) continue;
change(l, x, 1, n, 1, y);
} else {
long long x = read(), y = read();
ans = 0;
ask(x, n, 1, n, 1, y);
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, q;
int tmax[N * 4];
int tmin[N * 4];
long long tsum[N * 4];
int mark[N * 4];
int a[N];
void build(int l, int r, int p) {
if (l == r) {
tsum[p] = tmax[p] = tmin[p] = a[l];
return;
}
int mid = l + (r - l) / 2;
build(l, mid, ((p) << 1));
build(mid + 1, r, (((p) << 1) | 1));
tmax[p] = max(tmax[((p) << 1)], tmax[(((p) << 1) | 1)]);
tmin[p] = min(tmin[((p) << 1)], tmin[(((p) << 1) | 1)]);
tsum[p] = tsum[((p) << 1)] + tsum[(((p) << 1) | 1)];
}
void addtag(int p, int val, int l, int r) {
tsum[p] = (long long)val * (r - l + 1);
tmax[p] = val;
tmin[p] = val;
mark[p] = val;
}
void push_down(int p, int l, int r) {
if (mark[p]) {
int mid = l + (r - l) / 2;
addtag(((p) << 1), mark[p], l, mid);
addtag((((p) << 1) | 1), mark[p], mid + 1, r);
mark[p] = 0;
}
}
void update(int l, int r, int cl, int cr, int p, int val) {
if (l <= cl && cr <= r) {
if (tmin[p] >= val) return;
if (tmax[p] < val) {
addtag(p, val, cl, cr);
return;
}
if (cl == cr) return;
}
push_down(p, cl, cr);
int mid = cl + (cr - cl) / 2;
if (l <= mid) update(l, r, cl, mid, ((p) << 1), val);
if (r > mid) update(l, r, mid + 1, cr, (((p) << 1) | 1), val);
tmax[p] = max(tmax[((p) << 1)], tmax[(((p) << 1) | 1)]);
tmin[p] = min(tmin[((p) << 1)], tmin[(((p) << 1) | 1)]);
tsum[p] = tsum[((p) << 1)] + tsum[(((p) << 1) | 1)];
}
int ask(int l, int r, int cl, int cr, int p, int &val) {
if (l <= cl && cr <= r) {
if (tmin[p] > val) return 0;
if (tsum[p] <= val) {
val -= tsum[p];
return cr - cl + 1;
}
if (cl == cr) return 0;
}
push_down(p, cl, cr);
int mid = cl + (cr - cl) / 2;
int cntl = 0;
int cntr = 0;
if (l <= mid) cntl = ask(l, r, cl, mid, ((p) << 1), val);
if (r > mid) cntr = ask(l, r, mid + 1, cr, (((p) << 1) | 1), val);
return cntl + cntr;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; ++i) cin >> a[i];
build(1, n, 1);
for (int i = 1; i <= q; ++i) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) {
update(1, x, 1, n, 1, y);
} else {
cout << ask(x, n, 1, n, 1, y) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, q, a[maxn];
long long sum[maxn << 2];
int tag[maxn << 2], val[maxn << 2];
void pushup(int o) {
val[o] = min(val[(o << 1)], val[(o << 1 | 1)]);
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
void pushdown(int o, int l, int r) {
if (!tag[o]) return;
int t = tag[o];
tag[o] = 0;
val[(o << 1)] = val[(o << 1 | 1)] = tag[(o << 1)] = tag[(o << 1 | 1)] = t;
int mid = l + r >> 1;
sum[(o << 1)] = 1ll * t * (mid - l + 1);
sum[(o << 1 | 1)] = 1ll * t * (r - mid);
}
void build(int l, int r, int o) {
if (l == r) return (void)(val[o] = sum[o] = a[l]);
int mid = l + r >> 1;
build(l, mid, (o << 1));
build(mid + 1, r, (o << 1 | 1));
pushup(o);
}
void update(int L, int R, int p, int l, int r, int o) {
if (L > r || R < l) return;
if (L <= l && r <= R)
return (void)(val[o] = tag[o] = p, sum[o] = 1ll * (r - l + 1) * p);
pushdown(o, l, r);
int mid = l + r >> 1;
if (L <= mid) update(L, R, p, l, mid, (o << 1));
if (R > mid) update(L, R, p, mid + 1, r, (o << 1 | 1));
pushup(o);
}
long long qsum(int L, int R, int l, int r, int o) {
if (L > r || R < l || L > R) return 0;
if (L <= l && r <= R) return sum[o];
pushdown(o, l, r);
int mid = l + r >> 1;
return qsum(L, R, l, mid, (o << 1)) + qsum(L, R, mid + 1, r, (o << 1 | 1));
}
long long query(long long &s, int l, int r, int o) {
if (sum[o] <= s) {
s -= sum[o];
return r - l + 1;
}
if (l == r) return 0;
pushdown(o, l, r);
int mid = l + r >> 1, ans = 0;
if (val[(o << 1)] <= s) ans += query(s, l, mid, (o << 1));
if (val[(o << 1 | 1)] <= s) ans += query(s, mid + 1, r, (o << 1 | 1));
return ans;
}
int ask(int w, int l, int r, int o) {
if (l == r) return l;
pushdown(o, l, r);
int mid = l + r >> 1;
if (val[(o << 1)] > w)
return ask(w, mid + 1, r, (o << 1 | 1));
else
return ask(w, l, mid, (o << 1));
}
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
return x * f;
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
build(1, n, 1);
while (q--) {
int op = read(), x = read();
long long y = read();
if (op & 1) {
int pos = ask(y, 1, n, 1);
if (pos <= x) update(pos, x, y, 1, n, 1);
} else
y += qsum(1, x - 1, 1, n, 1), printf("%d\n", query(y, 1, n, 1) - (x - 1));
}
return 0;
}
|
#include <bits/stdc++.h>
namespace atcoder {
namespace internal {
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
int bsf(unsigned int n) { return __builtin_ctz(n); }
} // namespace internal
} // namespace atcoder
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++) update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l) update(l >> i);
if (((r >> i) << i) != r) update((r - 1) >> i);
}
}
template <bool (*g)(S)>
int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G>
int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n) return _n;
l += size;
for (int i = log; i >= 1; i--) push(l >> i);
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)>
int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G>
int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0) return 0;
r += size;
for (int i = log; i >= 1; i--) push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size) lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1e18;
pair<long long, long long> SUM(pair<long long, long long> a,
pair<long long, long long> b) {
return {a.first + b.first, a.second + b.second};
}
pair<long long, long long> SUMe() { return {0, 0}; }
pair<long long, long long> SUMmapping(long long f,
pair<long long, long long> a) {
return {a.first + a.second * f, a.second};
}
long long SUMcomposition(long long l, long long r) { return l + r; }
long long SUMid() { return 0; }
long long N, Q;
map<long long, pair<long long, long long> > mp;
typedef atcoder::lazy_segtree<pair<long long, long long>, SUM, SUMe, long long,
SUMmapping, SUMcomposition, SUMid>
segtree;
segtree seg;
void ADD(long long val, pair<long long, long long> interval) {
if (mp.count(val) == 0) {
mp[val] = interval;
return;
}
if (mp[val].first == interval.second) {
mp[val] = {interval.first, mp[val].second};
} else if (mp[val].second == interval.first) {
mp[val] = {mp[val].first, interval.second};
} else {
assert(0);
}
}
void DEL(long long val, pair<long long, long long> interval) {
assert(mp.count(val) >= 1);
if (mp[val] == interval) {
mp.erase(val);
return;
}
pair<long long, long long> a = mp[val];
pair<long long, long long> b = interval;
if (a.first == b.first) {
if (a.second > b.second) {
swap(a, b);
}
mp[val] = {a.second, b.second};
return;
}
if (a.second == b.second) {
if (a.first > b.first) {
swap(a, b);
}
mp[val] = {a.first, b.first};
return;
}
assert(0);
}
void update() {
long long x, y;
cin >> x >> y;
long long L = x;
long long R = x;
while (true) {
auto itr = mp.lower_bound(y);
if (itr == mp.begin()) break;
itr--;
long long nowl = itr->second.first;
long long nowr = itr->second.second;
long long delta = y - itr->first;
long long beforeval = itr->first;
chmin(L, nowl);
chmin(nowr, x);
if (nowl >= nowr) break;
DEL(beforeval, {nowl, nowr});
seg.apply(nowl, nowr, delta);
}
if (L != R) {
ADD(y, {L, R});
}
}
long long rest;
bool F(pair<long long, long long> x) { return x.first <= rest; }
void query() {
long long x, y;
cin >> x >> y;
x--;
rest = y;
long long ans = 0;
while (true) {
auto itr = mp.upper_bound(rest);
if (itr == mp.begin()) break;
itr--;
long long now = itr->second.first;
chmax(now, x);
long long r = seg.max_right<F>(now);
ans += r - now;
rest -= seg.prod(now, r).first;
if (r == N) break;
}
cout << ans << endl;
}
void print() {
for (int i = 0; i < N; i++) {
cout << seg.prod(i, i + 1).first << " ";
}
cout << endl;
}
int main() {
cin >> N >> Q;
vector<pair<long long, long long> > a(N);
for (int i = 0; i < N; i++) {
long long val;
cin >> val;
a[i].first = val;
a[i].second = 1;
ADD(val, {i, i + 1});
}
seg = segtree(a);
for (int q = 0; q < Q; q++) {
long long t;
cin >> t;
if (t == 1)
update();
else
query();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-9;
const long long int mod = 1e9 + 7;
const long long int inf = 1LL << 30;
const int MAXN = 2e5 + 5;
int arr[MAXN];
int tmax[4 * MAXN], tmin[4 * MAXN], lazy[4 * MAXN];
long long int tsum[4 * MAXN];
void build(int v, int tl, int tr) {
if (tl == tr)
tmax[v] = tmin[v] = tsum[v] = arr[tl];
else {
int tm = (tl + tr) >> 1;
build(v << 1, tl, tm);
build(v << 1 | 1, tm + 1, tr);
tmax[v] = max(tmax[v << 1], tmax[v << 1 | 1]);
tmin[v] = min(tmin[v << 1], tmin[v << 1 | 1]);
tsum[v] = tsum[v << 1] + tsum[v << 1 | 1];
}
}
void push(int v, int tl, int tr) {
if (!lazy[v]) return;
int tm = (tl + tr) >> 1;
tmax[v << 1] = lazy[v];
tmin[v << 1] = lazy[v];
tsum[v << 1] = lazy[v] * 1LL * (tm - tl + 1);
lazy[v << 1] = lazy[v];
tmax[v << 1 | 1] = lazy[v];
tmin[v << 1 | 1] = lazy[v];
tsum[v << 1 | 1] = lazy[v] * 1LL * (tr - tm);
lazy[v << 1 | 1] = lazy[v];
lazy[v] = 0;
}
void update(int v, int tl, int tr, int l, int r, int val) {
if (tl > r || tr < l) return;
if (tl != tr) push(v, tl, tr);
if (tmin[v] > val) return;
if (l <= tl && tr <= r) {
if (tmax[v] <= val) {
tmax[v] = val;
tmin[v] = val;
tsum[v] = val * 1LL * (tr - tl + 1);
lazy[v] = val;
return;
}
}
int tm = (tl + tr) >> 1;
update(v << 1, tl, tm, l, r, val);
update(v << 1 | 1, tm + 1, tr, l, r, val);
tmax[v] = max(tmax[v << 1], tmax[v << 1 | 1]);
tmin[v] = min(tmin[v << 1], tmin[v << 1 | 1]);
tsum[v] = tsum[v << 1] + tsum[v << 1 | 1];
}
long long int query(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl != tr) push(v, tl, tr);
if (tl == l && tr == r)
return tsum[v];
else {
int tm = (tl + tr) >> 1;
return query(v << 1, tl, tm, l, min(r, tm)) +
query(v << 1 | 1, tm + 1, tr, max(l, tm + 1), r);
}
}
int bs_start(int v, int tl, int tr, int pos, long long int val) {
if (tl != tr) push(v, tl, tr);
if (tl == tr)
return tmin[v] <= val ? tl : MAXN;
else {
int tm = (tl + tr) >> 1;
if (tm < pos || tmin[v << 1] > val)
return bs_start(v << 1 | 1, tm + 1, tr, pos, val);
else
return bs_start(v << 1, tl, tm, pos, val);
}
}
int bs_end(int v, int tl, int tr, long long int val) {
if (tl != tr) push(v, tl, tr);
if (tl == tr)
return tsum[v] <= val;
else {
int tm = (tl + tr) >> 1;
if (tsum[v << 1] >= val)
return bs_end(v << 1, tl, tm, val);
else
return (tm - tl + 1) + bs_end(v << 1 | 1, tm + 1, tr, val - tsum[v << 1]);
}
}
void cp() {
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> arr[i];
build(1, 0, n - 1);
while (q--) {
int t, x;
long long int y;
cin >> t >> x >> y;
x--;
if (t == 1)
update(1, 0, n - 1, 0, x, y);
else {
int ans = 0;
int p = x;
while (p < n) {
int idx = bs_start(1, 0, n - 1, p, y);
if (idx >= n) break;
long long int v = y + query(1, 0, n - 1, 0, idx - 1);
int got = bs_end(1, 0, n - 1, v);
got -= idx;
int idx2 = idx + got - 1;
y -= query(1, 0, n - 1, idx, idx2);
ans += got;
p = idx2 + 1;
}
cout << ans << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int nax = 2e5 + 1;
long long seg[4 * nax];
int mn[4 * nax], lazy[4 * nax];
int n, q;
int a[nax];
void pro2(int n, int s, int e, int val) {
seg[n] = (e - s + 1) * 1LL * val;
mn[n] = val;
lazy[n] = val;
}
void pro(int n, int s, int e) {
if (lazy[n] && s != e) {
pro2(n + n, s, (s + e) / 2, lazy[n]);
pro2(n + n + 1, (s + e) / 2 + 1, e, lazy[n]);
lazy[n] = 0;
}
}
void build(int n = 1, int s = 1, int e = ::n) {
if (s == e) {
seg[n] = mn[n] = a[s];
return;
}
build(n + n, s, (s + e) / 2);
build(n + n + 1, (s + e) / 2 + 1, e);
seg[n] = seg[n + n] + seg[n + n + 1];
mn[n] = mn[n + n + 1];
}
void update(int l, int r, int val, int n = 1, int s = 1, int e = ::n) {
if (s > r || e < l || l > r) return;
if (s >= l && e <= r) {
pro2(n, s, e, val);
return;
}
pro(n, s, e);
update(l, r, val, n + n, s, (s + e) / 2);
update(l, r, val, n + n + 1, (s + e) / 2 + 1, e);
seg[n] = seg[n + n] + seg[n + n + 1];
mn[n] = min(mn[n + n], mn[n + n + 1]);
}
long long get(int l, int r, int n = 1, int s = 1, int e = ::n) {
if (s > r || e < l || l > r) return 0;
if (s >= l && e <= r) return seg[n];
pro(n, s, e);
long long a = 0, b = 0;
if ((s + e) / 2 >= l) a = get(l, r, n + n, s, (s + e) / 2);
if ((s + e) / 2 + 1 <= r) b = get(l, r, n + n + 1, (s + e) / 2 + 1, e);
return a + b;
}
int get2(long long val, int n = 1, int s = 1, int e = ::n) {
if (s == e) return s + (mn[n] > val);
pro(n, s, e);
if (mn[n + n] <= val)
return get2(val, n + n, s, (s + e) / 2);
else
return get2(val, n + n + 1, (s + e) / 2 + 1, e);
}
int get3(long long val, int n = 1, int s = 1, int e = ::n) {
if (s == e) return s + (seg[n] <= val);
pro(n, s, e);
if (seg[n + n] > val)
return get3(val, n + n, s, (s + e) / 2);
else
return get3(val - seg[n + n], n + n + 1, (s + e) / 2 + 1, e);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build();
for (int i = 0; i < q; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
int fr = get2(y);
if (fr <= x) update(fr, x, y);
} else if (t == 2) {
int ans = 0;
int at = x;
while (at <= n) {
int to = get2(y);
at = max(to, at);
to = get3(y + get(1, at - 1)) - 1;
ans += to - at + 1;
y -= get(at, to);
at = to + 1;
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
clock_t START;
inline long double TIME() {
return (long double)(clock() - START) / CLOCKS_PER_SEC;
}
void SHOW() {
cout << fixed << setprecision(10);
cout << TIME() << " SECONDS FROM START\n";
}
long double TL = 2.0;
long long calls = 0;
inline bool IS() {
if (TL - TIME() < 0.1) return true;
return false;
}
template <typename T1, typename T2>
inline bool amin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
inline bool amax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << ' ' << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &u : v) is >> u;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
for (auto &u : v) os << u << ' ';
return os;
}
long long hash_mod[4] = {1000000007, 998244353, 1000000009, 999999937},
mod = hash_mod[rnd() % 4];
long long hash_pows[4] = {179, 239, 1007, 2003}, P = hash_pows[rnd() % 4];
long long binpow(long long first, long long p) {
long long res = 1;
while (p) {
if (p % 2) res = (res * first) % mod;
first = (first * first) % mod;
p /= 2;
}
return res;
}
const long long N = 1e6 + 7, NS = 2e3 + 7, lg = 20, sq = 550, inf = 2e9 + 7;
const long double eps = 1e-9, pi = 3.14159265359;
long long mn[4 * N], sum[4 * N], add[4 * N], a[N], n, q;
void build(long long v, long long l, long long r) {
if (l == r - 1) {
sum[v] = mn[v] = a[l];
add[v] = -1;
return;
}
long long m = (l + r) / 2;
build(2 * v, l, m);
build(2 * v + 1, m, r);
sum[v] = sum[2 * v] + sum[2 * v + 1];
add[v] = -1;
mn[v] = min(mn[2 * v], mn[2 * v + 1]);
}
void push(long long v, long long l, long long r) {
if (add[v] == -1) return;
sum[v] = (r - l) * add[v];
mn[v] = add[v];
if (r != l - 1) {
add[2 * v] = add[2 * v + 1] = add[v];
}
add[v] = -1;
}
void update(long long v, long long l, long long r, long long vl, long long vr,
long long val) {
push(v, l, r);
if (l >= vr || vl >= r) return;
if (l >= vl && r <= vr) {
add[v] = val;
push(v, l, r);
return;
}
long long m = (l + r) / 2;
update(2 * v, l, m, vl, vr, val);
update(2 * v + 1, m, r, vl, vr, val);
sum[v] = sum[2 * v] + sum[2 * v + 1];
mn[v] = min(mn[2 * v], mn[2 * v + 1]);
}
long long find(long long v, long long l, long long r, long long val) {
push(v, l, r);
if (l == r - 1) return l;
long long m = (l + r) / 2;
push(2 * v, l, m);
if (mn[2 * v] < val)
return find(2 * v, l, m, val);
else
return find(2 * v + 1, m, r, val);
}
long long tr(long long v, long long l, long long r, long long pos,
long long &val) {
push(v, l, r);
if (mn[v] > val || r <= pos) return 0;
if (l == r - 1) {
if (sum[v] <= val) {
val -= sum[v];
return 1;
} else
return 0;
}
long long m = (l + r) / 2;
if (l >= pos) {
push(2 * v, l, m);
long long res = 0;
if (sum[2 * v] <= val) {
res += m - l;
val -= sum[2 * v];
} else
res += tr(2 * v, l, m, pos, val);
res += tr(2 * v + 1, m, r, pos, val);
return res;
} else {
long long res = tr(2 * v, l, m, pos, val);
res += tr(2 * v + 1, m, r, pos, val);
return res;
}
}
void print(long long v, long long l, long long r) {
push(v, l, r);
if (l == r - 1) {
cout << sum[v] << ' ';
return;
}
long long m = (l + r) / 2;
print(2 * v, l, m);
print(2 * v + 1, m, r);
}
void solve() {
cin >> n >> q;
for (long long i = 0; i < n; i++) cin >> a[i];
build(1, 0, n);
while (q--) {
long long t, first, val;
cin >> t >> first >> val;
first--;
if (t == 1) {
push(1, 0, n);
if (mn[1] >= val) continue;
long long id = find(1, 0, n, val);
if (id <= first) update(1, 0, n, id, first + 1, val);
} else {
long long can = tr(1, 0, n, first, val);
cout << can << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int INF = 1e9 + 10;
struct Val {
int min, len;
long long int sum;
Val() {
min = INF;
sum = 0;
len = 0;
}
Val(int x) : min(x), sum(x), len(1) {}
Val &operator+=(const Val &o) {
min = std::min(min, o.min);
len += o.len;
sum += o.sum;
return *this;
}
Val operator+(const Val &o) const { return Val(*this) += o; }
};
struct Mod {
int replace;
Mod() : replace(-1) {}
Mod(int replace) : replace(replace) {}
Mod operator*(const Mod &o) const {
if (replace == -1) return o;
return *this;
}
Val operator*(const Val &o) const {
if (replace == -1) return o;
Val ans;
ans.min = replace;
ans.len = o.len;
ans.sum = (long long int)ans.min * ans.len;
return ans;
}
};
template <class Val, class Mod>
struct segment_tree_lazy {
struct node {
Val val;
Mod mod;
node *left, *right;
Val eval() { return mod * val; }
void pull() {
mod = Mod();
val = left->eval() + right->eval();
}
void push() {
left->mod = mod * left->mod;
right->mod = mod * right->mod;
mod = Mod();
}
};
int n;
node *root;
segment_tree_lazy(int n) { segment_tree_lazy(vector<Val>(n)); }
segment_tree_lazy(const vector<Val> &a) {
n = ((int)(a).size());
root = build(0, n, a);
}
node *build(int from, int to, const vector<Val> &a) {
if (from + 1 == to) return new node({a[from], Mod(), nullptr, nullptr});
auto ans = new node();
int mid = (from + to) / 2;
ans->left = build(from, mid, a);
ans->right = build(mid, to, a);
ans->pull();
return ans;
}
void update(node *u, int from, int to, int a, int b, Mod mod) {
if (to <= a || b <= from) return;
if (a <= from && to <= b) return void(u->mod = mod * u->mod);
u->push();
int mid = (from + to) / 2;
update(u->left, from, mid, a, b, mod);
update(u->right, mid, to, a, b, mod);
u->pull();
}
void update(int a, int b, Mod mod) { update(root, 0, n, a, b, mod); }
Val get(node *u, int from, int to, int a, int b, Mod mod) {
if (to <= a || b <= from) return Val();
if (a <= from && to <= b) return mod * u->eval();
int mid = (from + to) / 2;
mod = mod * u->mod;
return get(u->left, from, mid, a, b, mod) +
get(u->right, mid, to, a, b, mod);
}
Val get(int a, int b) { return get(root, 0, n, a, b, Mod()); }
template <class Cond>
tuple<int, Val, Val> lower_bound(node *u, int from, int to, Val prefix,
Mod mod, Cond cond) {
if (from + 1 == to) {
auto cand = prefix + mod * u->eval();
if (cond(cand))
return {from, prefix, cand};
else
return {to, cand, cand};
}
int mid = (from + to) / 2;
mod = mod * u->mod;
auto nprefix = prefix + mod * u->left->eval();
if (cond(nprefix)) {
return lower_bound(u->left, from, mid, prefix, mod, cond);
} else {
return lower_bound(u->right, mid, to, nprefix, mod, cond);
}
}
template <class Cond>
tuple<int, Val, Val> lower_bound(Cond cond) {
return lower_bound(root, 0, n, Val(), Mod(), cond);
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
int n;
cin >> n >> q;
vector<Val> a;
a.reserve(n);
for (int i = 0; i < (int)(n); i++) {
int x;
cin >> x;
a.emplace_back(x);
}
segment_tree_lazy<Val, Mod> st(a);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int to, val;
cin >> to >> val;
auto [from, _, __] =
st.lower_bound([&](const Val &a) { return a.min < val; });
st.update(from, to, Mod(val));
} else {
int from, money;
cin >> from >> money;
--from;
long long int from_sum = st.get(0, from).sum;
int ans = 0;
while (true) {
auto [nfrom, v_from, _] =
st.lower_bound([&](const Val &a) { return a.min <= money; });
from = max(from, nfrom);
from_sum = max(from_sum, v_from.sum);
if (from >= n) break;
auto cum = from_sum;
auto [to, v_to, __] =
st.lower_bound([&](const Val &a) { return a.sum > cum + money; });
ans += to - from;
money -= v_to.sum - from_sum;
assert(money >= 0);
from = to;
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class segtree {
public:
struct node {
long long ad = 0;
int mu = 1;
long long sum = 0;
long long val = 0;
void apply(int l, int r, int v) {
if (v >= 0) {
ad += v;
sum += 1LL * v * (r - l + 1);
val += v;
} else {
v = ~v;
ad *= v;
mu *= v;
sum *= v;
val *= v;
}
}
};
node unite(const node &a, const node &b) const {
node res;
res.sum = a.sum + b.sum;
res.val = min(a.val, b.val);
return res;
}
inline void push(int x, int l, int r) {
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
if (tree[x].mu != 1) {
tree[x + 1].apply(l, y, ~tree[x].mu);
tree[z].apply(y + 1, r, ~tree[x].mu);
tree[x].mu = 1;
}
if (tree[x].ad != 0) {
tree[x + 1].apply(l, y, tree[x].ad);
tree[z].apply(y + 1, r, tree[x].ad);
tree[x].ad = 0;
}
}
inline void pull(int x, int z) { tree[x] = unite(tree[x + 1], tree[z]); }
int n;
vector<node> tree;
void build(int x, int l, int r) {
if (l == r) {
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y);
build(z, y + 1, r);
pull(x, z);
}
template <typename M, typename... T>
void build(int x, int l, int r, const vector<M> &v, const T &...t) {
if (l == r) {
tree[x].apply(l, r, v[l], t...);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y, v, t...);
build(z, y + 1, r, v, t...);
pull(x, z);
}
template <typename M, typename... T>
segtree(const vector<M> &v, const T &...t) {
n = v.size();
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1, v, t...);
}
segtree(int _n) : n(_n) {
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1);
}
segtree(){};
node get(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
return tree[x];
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
node res{};
if (rr <= y) {
res = get(x + 1, l, y, ll, rr);
} else {
if (ll > y) {
res = get(z, y + 1, r, ll, rr);
} else {
res = unite(get(x + 1, l, y, ll, rr), get(z, y + 1, r, ll, rr));
}
}
pull(x, z);
return res;
}
node get(int ll, int rr) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return get(0, 0, n - 1, ll, rr);
}
node get(int p) {
assert(0 <= p && p <= n - 1);
return get(0, 0, n - 1, p, p);
}
template <typename... M>
void modify(int x, int l, int r, int ll, int rr, const M &...v) {
if (ll <= l && r <= rr) {
tree[x].apply(l, r, v...);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
if (ll <= y) {
modify(x + 1, l, y, ll, rr, v...);
}
if (rr > y) {
modify(z, y + 1, r, ll, rr, v...);
}
pull(x, z);
}
template <typename... M>
void modify(int ll, int rr, const M &...v) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
modify(0, 0, n - 1, ll, rr, v...);
}
int find_first_knowingly(int x, int l, int r,
const function<bool(const node &)> &f) {
if (l == r) {
return l;
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res;
if (f(tree[x + 1])) {
res = find_first_knowingly(x + 1, l, y, f);
} else {
res = find_first_knowingly(z, y + 1, r, f);
}
pull(x, z);
return res;
}
int find_first(int x, int l, int r, int ll, int rr,
const function<bool(const node &)> &f) {
if (ll <= l && r <= rr) {
if (!f(tree[x])) {
return -1;
}
return find_first_knowingly(x, l, r, f);
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res = -1;
if (ll <= y) {
res = find_first(x + 1, l, y, ll, rr, f);
}
if (rr > y && res == -1) {
res = find_first(z, y + 1, r, ll, rr, f);
}
pull(x, z);
return res;
}
int find_first(int ll, int rr, const function<bool(const node &)> &f) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return find_first(0, 0, n - 1, ll, rr, f);
}
int find_last_knowingly(int x, int l, int r,
const function<bool(const node &)> &f) {
if (l == r) {
return l;
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res;
if (f(tree[z])) {
res = find_last_knowingly(z, y + 1, r, f);
} else {
res = find_last_knowingly(x + 1, l, y, f);
}
pull(x, z);
return res;
}
int find_last(int x, int l, int r, int ll, int rr,
const function<bool(const node &)> &f) {
if (ll <= l && r <= rr) {
if (!f(tree[x])) {
return -1;
}
return find_last_knowingly(x, l, r, f);
}
push(x, l, r);
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
int res = -1;
if (rr > y) {
res = find_last(z, y + 1, r, ll, rr, f);
}
if (ll <= y && res == -1) {
res = find_last(x + 1, l, y, ll, rr, f);
}
pull(x, z);
return res;
}
int find_last(int ll, int rr, const function<bool(const node &)> &f) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return find_last(0, 0, n - 1, ll, rr, f);
}
};
int n, q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
segtree st(a);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
int pos = st.find_first(
0, x, [&](const segtree::node &a) { return a.val < y; });
if (pos == -1) continue;
st.modify(pos, x, ~0);
st.modify(pos, x, y);
} else {
int ret = 0;
while (true) {
int pos = st.find_first(
x, n - 1, [&](const segtree::node &p) { return p.val <= y; });
if (pos == -1) break;
x = pos;
long long sum = 0;
int to = st.find_first(x, n - 1, [&](const segtree::node &p) {
if (sum + p.sum <= y) {
sum += p.sum;
return false;
}
return true;
});
if (to != -1) {
y -= sum;
ret += to - x;
x = to;
} else {
ret += n - x;
break;
}
}
cout << ret << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
template <typename T>
inline bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
inline bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
struct SegmentTree {
struct node {
long long sumrst = 0;
long long mncond = 1e18, mx = -1e18;
node(long long x = 0) { sumrst = mncond = mx = x; }
};
int n;
vector<long long> ar;
vector<long long> add;
vector<node> t;
SegmentTree(vector<long long> &ar) : ar(ar) {
n = ar.size();
t.resize(4 * n + 1);
add.resize(4 * n + 1);
}
node comb(node &a, node &b) {
node res;
res.sumrst = a.sumrst + b.sumrst;
res.mx = max(a.mx, b.mx);
res.mncond = min(a.mncond, b.mncond);
return res;
}
void build(int v, int vl, int vr) {
if (vl == vr) {
t[v] = node(ar[vl]);
return;
}
int m = vl + vr >> 1;
build(2 * v + 1, vl, m);
build(2 * v + 2, m + 1, vr);
t[v] = comb(t[2 * v + 1], t[2 * v + 2]);
}
void push(int v, int vl, int vr) {
if (!add[v] || vl == vr) return;
int m = vl + vr >> 1;
add[2 * v + 1] = add[v];
add[2 * v + 2] = add[v];
t[2 * v + 1].sumrst = add[v] * (m - vl + 1);
t[2 * v + 2].sumrst = add[v] * (vr - m);
t[2 * v + 1].mncond = t[2 * v + 2].mncond = add[v];
t[2 * v + 1].mx = t[2 * v + 2].mx = add[v];
add[v] = 0;
}
long long answer(int v, int vl, int vr, int l, int r, int &x) {
push(v, vl, vr);
if (l > r)
return 0;
else if (vl == l && vr == r) {
if (x >= t[v].sumrst) {
x -= t[v].sumrst;
return (vr - vl + 1);
} else if (t[v].mncond > x)
return 0;
int m = vl + vr >> 1;
long long a = answer(2 * v + 1, vl, m, l, min(r, m), x);
long long b = answer(2 * v + 2, m + 1, vr, max(l, m + 1), r, x);
return a + b;
}
int m = vl + vr >> 1;
long long a = answer(2 * v + 1, vl, m, l, min(r, m), x);
long long b = answer(2 * v + 2, m + 1, vr, max(l, m + 1), r, x);
return a + b;
}
long long answer(int l, int x) { return answer(0, 0, n - 1, l, n - 1, x); }
void upd(int v, int vl, int vr, int l, int r, long long x) {
if (r < vl || l > vr || t[v].mncond >= x)
return;
else if (vl >= l && vr <= r && t[v].mx < x) {
add[v] = x;
t[v].sumrst = x * (vr - vl + 1);
t[v].mncond = x;
t[v].mx = x;
return;
}
push(v, vl, vr);
int m = vl + vr >> 1;
upd(2 * v + 1, vl, m, l, r, x);
upd(2 * v + 2, m + 1, vr, l, r, x);
t[v] = comb(t[2 * v + 1], t[2 * v + 2]);
}
void upd(int l, int r, long long x) { upd(0, 0, n - 1, l, r, x); }
};
void solve() {
int n, q;
cin >> n >> q;
vector<long long> v(n);
for (auto &i : v) cin >> i;
SegmentTree s(v);
s.build(0, 0, n - 1);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int x, y;
cin >> x >> y;
s.upd(0, x - 1, y);
} else {
int x, y;
cin >> x >> y;
--x;
cout << s.answer(x, y) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q = 1;
while (q--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x *= f, void();
}
const int N = 2e5 + 5;
struct SegmentTree {
int mn[N << 2], mx[N << 2], tag[N << 2];
long long sum[N << 2];
inline void pushup(int p) {
sum[p] = sum[p << 1] + sum[p << 1 | 1];
mn[p] = min(mn[p << 1], mn[p << 1 | 1]);
mx[p] = max(mx[p << 1], mx[p << 1 | 1]);
}
inline void pushdown(int p, int l, int r) {
if (tag[p]) {
mn[p << 1] = mx[p << 1] = tag[p << 1] = tag[p];
sum[p << 1] = 1ll * tag[p] * (((l + r) >> 1) - l + 1);
mn[p << 1 | 1] = mx[p << 1 | 1] = tag[p << 1 | 1] = tag[p];
sum[p << 1 | 1] = 1ll * tag[p] * (r - ((l + r) >> 1));
tag[p] = 0;
}
}
void modify(int p, int l, int r, int x, int y, int k) {
if (r < x || y < l) return;
if (k <= mn[p]) return;
if (x <= l && r <= y && mx[p] <= k) {
mn[p] = mx[p] = tag[p] = k;
sum[p] = 1ll * k * (r - l + 1);
return;
}
pushdown(p, l, r);
modify(p << 1, l, ((l + r) >> 1), x, y, k);
modify(p << 1 | 1, ((l + r) >> 1) + 1, r, x, y, k);
pushup(p);
}
int query(int p, int l, int r, int x, long long& k) {
if (r < x) return 0;
if (mn[p] > k) return 0;
if (x <= l && k >= sum[p]) {
k -= sum[p];
return r - l + 1;
}
pushdown(p, l, r);
int res = query(p << 1, l, ((l + r) >> 1), x, k);
res += query(p << 1 | 1, ((l + r) >> 1) + 1, r, x, k);
return res;
}
} seg;
int main() {
int n, m;
read(n), read(m);
for (int i = 1; i <= n; i++) {
int ai;
read(ai);
seg.modify(1, 1, n, i, i, ai);
}
for (int i = 1; i <= m; i++) {
int op;
read(op);
if (op == 1) {
int x, y;
read(x), read(y);
seg.modify(1, 1, n, 1, x, y);
} else if (op == 2) {
int x;
long long y;
read(x), read(y);
printf("%d\n", seg.query(1, 1, n, x, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sum, minimum, maximum, lazy;
node() {
sum = 0;
lazy = 0;
}
node(long long S, long long Min, long long Max) {
sum = S;
minimum = Min;
maximum = Max;
lazy = 0;
}
};
node merge(node &L, node &R) {
return node(L.sum + R.sum, min(L.minimum, R.minimum),
max(L.maximum, R.maximum));
}
const int MAX_N = 2e5 + 5, NOT_FOUND = -1, oo = 1e9;
node tree[3 * MAX_N];
void propagate(int n, int left, int right) {
if (tree[n].lazy == 0) {
return;
}
tree[n].maximum = tree[n].lazy;
tree[n].minimum = tree[n].lazy;
tree[n].sum = (right - left + 1) * tree[n].lazy;
if (left != right) {
tree[(2 * n)].lazy = tree[n].lazy;
tree[(2 * n + 1)].lazy = tree[n].lazy;
}
tree[n].lazy = 0;
}
void update(int n, int left, int right, int query_left, int query_right,
long long x) {
propagate(n, left, right);
if (right < left || query_right < query_left || query_right < left ||
right < query_left) {
return;
}
if (query_left <= left && right <= query_right) {
tree[n].lazy = x;
propagate(n, left, right);
return;
}
int mid = (left + right) / 2;
update((2 * n), left, mid, query_left, query_right, x);
update((2 * n + 1), mid + 1, right, query_left, query_right, x);
tree[n] = merge(tree[(2 * n)], tree[(2 * n + 1)]);
}
int find_first(int n, int left, int right, int x) {
propagate(n, left, right);
if (tree[n].minimum >= x) {
return oo;
}
if (left == right) {
return right;
}
int mid = (left + right) / 2;
if (tree[(2 * n)].minimum < x) {
return find_first((2 * n), left, mid, x);
}
return find_first((2 * n + 1), mid + 1, right, x);
}
void go_right(int n, int left, int right, int query_left, int query_right,
int &M, int &C) {
propagate(n, left, right);
if (right < query_left || query_right < left) {
return;
}
if (tree[n].minimum > M) {
return;
}
if (query_left <= left && right <= query_right && tree[n].sum <= M) {
M -= tree[n].sum;
C += (right - left + 1);
return;
}
int mid = (left + right) / 2;
go_right((2 * n), left, mid, query_left, query_right, M, C);
go_right((2 * n + 1), mid + 1, right, query_left, query_right, M, C);
}
int main() {
int no_of_elements, no_of_queries;
cin >> no_of_elements >> no_of_queries;
for (int i = 1; i <= no_of_elements; i++) {
int x;
cin >> x;
update(1, 1, no_of_elements, i, i, x);
}
for (int i = 1; i <= no_of_queries; i++) {
int type, x, y;
cin >> type >> x >> y;
const int UPDATE = 1, QUERY = 2;
switch (type) {
case UPDATE: {
int prefix = x, value = y;
int i = find_first(1, 1, no_of_elements, value);
update(1, 1, no_of_elements, i, prefix, value);
break;
}
case QUERY: {
int money = y, start = x;
int visit_count = 0;
go_right(1, 1, no_of_elements, start, no_of_elements, money,
visit_count);
cout << visit_count << "\n";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int INF = 1e9 + 10;
struct Val {
int min, len;
long long int sum;
Val() {
min = INF;
sum = 0;
len = 0;
}
Val(int x) : min(x), sum(x), len(1) {}
Val &operator+=(const Val &o) {
min = std::min(min, o.min);
len += o.len;
sum += o.sum;
return *this;
}
Val operator+(const Val &o) const { return Val(*this) += o; }
};
struct Mod {
int replace;
Mod() : replace(-1) {}
Mod(int replace) : replace(replace) {}
Mod operator*(const Mod &o) const {
if (replace == -1) return o;
return *this;
}
Val operator*(const Val &o) const {
if (replace == -1) return o;
Val ans;
ans.min = replace;
ans.len = o.len;
ans.sum = (long long int)ans.min * ans.len;
return ans;
}
};
template <class Val, class Mod>
struct segment_tree_lazy {
struct node {
Val val;
Mod mod;
node *left, *right;
Val eval() { return mod * val; }
void pull() {
mod = Mod();
val = left->eval() + right->eval();
}
void push() {
left->mod = mod * left->mod;
right->mod = mod * right->mod;
mod = Mod();
}
};
int n;
node *root;
segment_tree_lazy(int n) { segment_tree_lazy(vector<Val>(n)); }
segment_tree_lazy(const vector<Val> &a) {
n = ((int)(a).size());
root = build(0, n, a);
}
node *build(int from, int to, const vector<Val> &a) {
if (from + 1 == to) return new node({a[from], Mod(), nullptr, nullptr});
auto ans = new node();
int mid = (from + to) / 2;
ans->left = build(from, mid, a);
ans->right = build(mid, to, a);
ans->pull();
return ans;
}
void update(node *u, int from, int to, int a, int b, Mod mod) {
if (to <= a || b <= from) return;
if (a <= from && to <= b) return void(u->mod = mod * u->mod);
u->push();
int mid = (from + to) / 2;
update(u->left, from, mid, a, b, mod);
update(u->right, mid, to, a, b, mod);
u->pull();
}
void update(int a, int b, Mod mod) { update(root, 0, n, a, b, mod); }
Val get(node *u, int from, int to, int a, int b, Mod mod) {
if (to <= a || b <= from) return Val();
if (a <= from && to <= b) return mod * u->eval();
int mid = (from + to) / 2;
mod = mod * u->mod;
return get(u->left, from, mid, a, b, mod) +
get(u->right, mid, to, a, b, mod);
}
Val get(int a, int b) { return get(root, 0, n, a, b, Mod()); }
template <class Cond>
int lower_bound(node *u, int from, int to, Val prefix, Mod mod, Cond cond) {
if (from + 1 == to) {
if (cond(prefix + mod * u->eval()))
return from;
else
return to;
}
int mid = (from + to) / 2;
mod = mod * u->mod;
auto nprefix = prefix + mod * u->left->eval();
if (cond(nprefix)) {
return lower_bound(u->left, from, mid, prefix, mod, cond);
} else {
return lower_bound(u->right, mid, to, nprefix, mod, cond);
}
}
template <class Cond>
int lower_bound(Cond cond) {
return lower_bound(root, 0, n, Val(), Mod(), cond);
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
int n;
cin >> n >> q;
vector<Val> a;
a.reserve(n);
for (int i = 0; i < (int)(n); i++) {
int x;
cin >> x;
a.emplace_back(x);
}
segment_tree_lazy<Val, Mod> st(a);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int to, val;
cin >> to >> val;
int from = st.lower_bound([&](const Val &a) { return a.min < val; });
st.update(from, to, Mod(val));
} else {
int from, money;
cin >> from >> money;
--from;
int ans = 0;
while (true) {
from = max(
from, st.lower_bound([&](const Val &a) { return a.min <= money; }));
if (from >= n) break;
auto cum = st.get(0, from).sum;
auto to =
st.lower_bound([&](const Val &a) { return a.sum > cum + money; });
ans += to - from;
money -= st.get(from, to).sum;
assert(money >= 0);
from = to;
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mx[400020 << 2], a[400020], n, cv[400020 << 2], mn[400020 << 2], m, L, R, Y;
long long sm[400020 << 2];
inline void up(int k) {
mx[k] = max(mx[k << 1], mx[k << 1 | 1]);
mn[k] = min(mn[k << 1], mn[k << 1 | 1]);
sm[k] = sm[k << 1] + sm[k << 1 | 1];
}
inline void down(int k, int l, int r) {
mx[k << 1] = mx[k << 1 | 1] = cv[k];
mn[k << 1] = mn[k << 1 | 1] = cv[k];
cv[k << 1] = cv[k << 1 | 1] = cv[k];
int m = l + r >> 1;
sm[k << 1] = 1ll * cv[k] * (m - l + 1),
sm[k << 1 | 1] = 1ll * cv[k] * (r - m);
cv[k] = 0;
}
void build(int k, int l, int r) {
if (l == r) {
mx[k] = sm[k] = mn[k] = a[l];
return;
}
int m = l + r >> 1;
build(k << 1, l, m), build(k << 1 | 1, m + 1, r), up(k);
}
int ans;
int Find(int k, int l, int r) {
if (r <= ans) return ans;
if (l >= L && r <= R) {
if (mx[k] <= Y) return 0;
if (l == r) return l;
}
if (cv[k]) down(k, l, r);
int m = l + r >> 1;
if (R > m) ans = max(ans, Find(k << 1 | 1, m + 1, r));
if (L <= m) ans = max(ans, Find(k << 1, l, m));
return ans;
}
void Cover(int k, int l, int r) {
if (l >= L && r <= R) {
mn[k] = mx[k] = cv[k] = Y, sm[k] = 1ll * Y * (r - l + 1);
return;
}
if (cv[k]) down(k, l, r);
int m = l + r >> 1;
if (L <= m) Cover(k << 1, l, m);
if (R > m) Cover(k << 1 | 1, m + 1, r);
up(k);
}
int Eat(int k, int l, int r) {
if (l >= L && r <= R) {
if (Y >= sm[k]) {
Y -= sm[k];
return r - l + 1;
}
if (mn[k] > Y) return 0;
}
if (cv[k]) down(k, l, r);
int m = l + r >> 1, ans = 0;
if (L <= m) ans += Eat(k << 1, l, m);
if (R > m) ans += Eat(k << 1 | 1, m + 1, r);
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
memset(mn, 0x3f, sizeof mn), build(1, 1, n);
while (m--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
L = 1, R = x, Y = y, ans = 0, L = Find(1, 1, n) + 1;
if (L <= R) Cover(1, 1, n);
} else {
L = x, R = n, Y = y;
printf("%d\n", Eat(1, 1, n));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &n) {
n = 0;
T f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) n = n * 10 + c - '0', c = getchar();
n *= f;
}
template <typename T>
void write(T n) {
if (n < 0) putchar('-'), n = -n;
if (n > 9) write(n / 10);
putchar(n % 10 + '0');
}
int n, m;
long long a[800005], s[800005], tag[800005], mn[800005];
long long lim, res;
void push_up(int p) {
s[p] = s[(p << 1)] + s[(p << 1 | 1)];
mn[p] = min(mn[(p << 1)], mn[(p << 1 | 1)]);
}
void push_down(int p, int l, int r) {
if (!tag[p]) return;
tag[(p << 1)] = tag[(p << 1 | 1)] = tag[p];
mn[(p << 1)] = mn[(p << 1 | 1)] = tag[p];
s[(p << 1)] = tag[p] * (((l + r) >> 1) - l + 1);
s[(p << 1 | 1)] = tag[p] * (r - ((l + r) >> 1));
tag[p] = 0;
}
void build(int p, int l, int r) {
tag[p] = 0;
if (l == r) {
s[p] = mn[p] = a[l];
return;
}
build((p << 1), l, ((l + r) >> 1)),
build((p << 1 | 1), ((l + r) >> 1) + 1, r);
push_up(p);
}
void update(int p, int l, int r, int ul, int ur, long long k) {
if (l >= ul && r <= ur) {
s[p] = k * (r - l + 1);
tag[p] = k, mn[p] = k;
return;
}
push_down(p, l, r);
if (((l + r) >> 1) >= ul) update((p << 1), l, ((l + r) >> 1), ul, ur, k);
if (((l + r) >> 1) < ur)
update((p << 1 | 1), ((l + r) >> 1) + 1, r, ul, ur, k);
push_up(p);
}
long long query(int p, int l, int r, int ul, int ur) {
if (l >= ul && r <= ur) return s[p];
push_down(p, l, r);
long long res = 0;
if (((l + r) >> 1) >= ul) res += query((p << 1), l, ((l + r) >> 1), ul, ur);
if (((l + r) >> 1) < ur)
res += query((p << 1 | 1), ((l + r) >> 1) + 1, r, ul, ur);
return res;
}
void solve(int p, int l, int r) {
if (mn[p] > lim) return;
if (lim >= s[p]) {
lim -= s[p];
res += (r - l + 1);
return;
}
push_down(p, l, r);
if (s[(p << 1)] > lim)
solve((p << 1), l, ((l + r) >> 1));
else
lim -= s[(p << 1)], res += (((l + r) >> 1) - l + 1);
solve((p << 1 | 1), ((l + r) >> 1) + 1, r);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) read(a[i]);
build(1, 1, n);
int t, x, y;
while (m--) {
read(t), read(x), read(y);
if (t == 1) {
int l = 1, r = x, mid, ans = n + 1;
while (l <= r) {
mid = (l + r) >> 1;
long long k = query(1, 1, n, mid, mid);
if (k < y)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
if (ans <= x) update(1, 1, n, ans, x, y);
} else {
res = 0, lim = y;
if (x > 1) lim += query(1, 1, n, 1, x - 1);
solve(1, 1, n);
write(res - (x - 1)), puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 200010;
long long a[N];
int n, q;
struct node {
int l, r;
long long sum, mn;
long long lazy;
} tree[N * 4];
void pushup(int u) {
tree[u].sum = tree[u << 1].sum + tree[u << 1 | 1].sum;
tree[u].mn = min(tree[u << 1].mn, tree[u << 1 | 1].mn);
}
void pushdown(int u) {
if (!tree[u].lazy) return;
tree[u << 1].sum = (tree[u << 1].r - tree[u << 1].l + 1) * tree[u].lazy;
tree[u << 1 | 1].sum =
(tree[u << 1 | 1].r - tree[u << 1 | 1].l + 1) * tree[u].lazy;
tree[u << 1].mn = tree[u << 1 | 1].mn = tree[u].lazy;
tree[u << 1].lazy = tree[u << 1 | 1].lazy = tree[u].lazy;
tree[u].lazy = 0;
}
void build(int u, int l, int r) {
tree[u] = {l, r};
if (l == r) {
tree[u].sum = tree[u].mn = a[l];
return;
}
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void modify(int u, int l, int r, long long val) {
if (tree[u].l >= l && tree[u].r <= r) {
tree[u].lazy = tree[u].mn = val;
tree[u].sum = (tree[u].r - tree[u].l + 1) * val;
return;
}
pushdown(u);
int mid = tree[u].l + tree[u].r >> 1;
if (l <= mid) modify(u << 1, l, r, val);
if (r > mid) modify(u << 1 | 1, l, r, val);
pushup(u);
}
int findmn(int u, long long val) {
if (tree[u].l == tree[u].r) {
if (tree[u].mn > val)
return tree[u].l + 1;
else
return tree[u].l;
}
pushdown(u);
if (tree[u << 1].mn >= val)
return findmn(u << 1 | 1, val);
else
return findmn(u << 1, val);
}
int ans;
int calc(int u, int l, int r, long long now) {
if (tree[u].r < l || tree[u].l > r || !now) return 0;
if (tree[u].l >= l && tree[u].r <= r) {
if (tree[u].sum <= now) {
ans += tree[u].r - tree[u].l + 1;
return tree[u].sum;
}
}
long long w = 0;
if (u < 2 * N) pushdown(u);
int mid = tree[u].l + tree[u].r >> 1;
if (l <= mid && u < 2 * N && tree[u << 1].mn <= now)
w += calc(u << 1, l, r, now);
if (r > mid && u < 2 * N && tree[u << 1 | 1].mn <= now)
w += calc(u << 1 | 1, l, r, now - w);
return w;
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie(0);
int T = 1;
while (T--) {
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (q--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) {
int pos = findmn(1, y);
if (pos <= x) modify(1, pos, x, y);
} else {
ans = 0;
calc(1, x, n, y);
cout << ans << '\n';
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
const long long M = 2e5 + 10;
long long n, q, a[M], y;
struct tree {
long long tl, tr, sum, minn, tag;
} t[M << 2];
void pushup(long long k) {
t[(k)].sum = t[(k << 1)].sum + t[(k << 1 | 1)].sum;
t[(k)].minn = min(t[(k << 1)].minn, t[(k << 1 | 1)].minn);
}
void pushdown(long long k) {
if (t[(k)].tag == 0) return;
t[(k << 1)].minn = t[(k << 1 | 1)].minn = t[(k)].tag;
t[(k << 1)].sum = t[(k)].tag * (t[(k << 1)].tr - t[(k << 1)].tl + 1),
t[(k << 1 | 1)].sum =
t[(k)].tag * (t[(k << 1 | 1)].tr - t[(k << 1 | 1)].tl + 1);
t[(k << 1)].tag = t[(k << 1 | 1)].tag = t[(k)].tag;
t[(k)].tag = 0;
}
void build(long long k, long long l, long long r) {
t[(k)].tl = l, t[(k)].tr = r;
if (l == r) {
t[(k)].sum = t[(k)].minn = a[l];
return;
}
long long Mid = (l + r) >> 1;
build(k << 1, l, Mid), build(k << 1 | 1, Mid + 1, r);
pushup(k);
}
void update(long long k, long long l, long long r, long long z) {
if (t[(k)].tl >= l && t[(k)].tr <= r) {
t[(k)].minn = z, t[(k)].sum = (t[(k)].tr - t[(k)].tl + 1) * z,
t[(k)].tag = z;
return;
}
if (t[(k)].tl > r || t[(k)].tr < l) return;
pushdown(k);
update(k << 1, l, r, z), update(k << 1 | 1, l, r, z);
pushup(k);
}
long long query(long long k, long long l, long long r) {
if (t[(k)].tl >= l && t[(k)].tr <= r) return t[(k)].sum;
if (t[(k)].tl > r || t[(k)].tr < l) return 0;
pushdown(k);
return query(k << 1, l, r) + query(k << 1 | 1, l, r);
}
long long solve(long long k, long long x) {
if (t[(k)].tl == t[(k)].tr) return t[(k)].tl;
pushdown(k);
if (x >= t[(k << 1)].minn)
return solve(k << 1, x);
else
return solve(k << 1 | 1, x);
}
long long query(long long k) {
if (t[(k)].sum <= y) {
y -= t[(k)].sum;
return (t[(k)].tr - t[(k)].tl + 1);
}
if (t[(k)].tl == t[(k)].tr) return 0;
pushdown(k);
long long res = 0;
if (t[(k << 1)].minn <= y) res += query(k << 1);
if (t[(k << 1 | 1)].minn <= y) res += query(k << 1 | 1);
return res;
}
signed main() {
n = read(), q = read();
for (long long i = 1; i <= n; i++) a[i] = read();
build(1, 1, n);
while (q--) {
long long opt = read(), x = read();
y = read();
if (opt == 1)
update(1, solve(1, y), x, y);
else {
y += query(1, 1, x - 1);
cout << query(1) - x + 1 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200200;
int a[maxn];
long long sum[maxn * 4], mn[maxn * 4], laz[maxn * 4];
void build(int l, int r, int rt) {
if (l == r) {
sum[rt] = mn[rt] = a[l];
return;
}
int mid = (l + r) / 2;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
mn[rt] = mn[rt << 1 | 1];
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void pushdown(int l, int r, int rt) {
if (laz[rt]) {
int mid = (l + r) / 2;
mn[rt << 1] = mn[rt << 1 | 1] = laz[rt << 1] = laz[rt << 1 | 1] = laz[rt];
sum[rt << 1] = (mid - l + 1) * (long long)laz[rt];
sum[rt << 1 | 1] = (r - mid) * (long long)laz[rt];
laz[rt] = 0;
}
}
void upd(int L, int R, int v, int l, int r, int rt) {
if (L <= l && r <= R) {
if (mn[rt] >= v) return;
if (l == r) {
sum[rt] = v * (long long)(r - l + 1);
mn[rt] = v;
laz[rt] = v;
return;
}
pushdown(l, r, rt);
int mid = (l + r) / 2;
if (mn[rt << 1] <= v) {
sum[rt << 1 | 1] = v * (long long)(r - mid);
mn[rt << 1 | 1] = v;
laz[rt << 1 | 1] = v;
upd(L, R, v, l, mid, rt << 1);
} else {
upd(L, R, v, mid + 1, r, rt << 1 | 1);
}
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
mn[rt] = mn[rt << 1 | 1];
return;
}
pushdown(l, r, rt);
int mid = (l + r) / 2;
if (L <= mid) upd(L, R, v, l, mid, rt << 1);
if (mid < R) upd(L, R, v, mid + 1, r, rt << 1 | 1);
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
mn[rt] = mn[rt << 1 | 1];
}
long long ask(int L, int& v, int l, int r, int rt) {
if (L <= l) {
if (sum[rt] <= v) {
v -= sum[rt];
return r - l + 1;
}
if (mn[rt] > v) {
return 0;
}
if (l == r) return 0;
int mid = (l + r) / 2;
pushdown(l, r, rt);
long long ans = ask(L, v, l, mid, rt << 1);
ans += ask(L, v, mid + 1, r, rt << 1 | 1);
return ans;
}
int mid = (l + r) / 2;
pushdown(l, r, rt);
long long ans = 0;
if (L <= mid) ans += ask(L, v, l, mid, rt << 1);
ans += ask(L, v, mid + 1, r, rt << 1 | 1);
return ans;
}
int main(void) {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n, 1);
for (int i = 0; i < q; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
upd(1, x, y, 1, n, 1);
} else {
long long ans = ask(x, y, 1, n, 1);
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, w[N];
struct Node {
int l, r;
long long maxv, minv, sum, lazy;
} tr[N * 4];
void pushup(int u) {
tr[u].maxv = max(tr[u << 1].maxv, tr[u << 1 | 1].maxv);
tr[u].minv = min(tr[u << 1].minv, tr[u << 1 | 1].minv);
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void pushdown(int u) {
Node &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
if (root.lazy) {
left.maxv = right.maxv = root.lazy;
left.minv = right.minv = root.lazy;
left.sum = (left.r - left.l + 1) * root.lazy;
right.sum = (right.r - right.l + 1) * root.lazy;
left.lazy = right.lazy = root.lazy;
root.lazy = 0;
}
}
void build(int u, int l, int r) {
if (l == r)
tr[u] = {l, r, w[r], w[r], w[r], 0};
else {
tr[u] = {l, r, 0, 0, 0, 0};
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
}
void modify(int u, int l, int r, int v) {
if (tr[u].minv >= v) return;
if (tr[u].l >= l && tr[u].r <= r && tr[u].maxv < v) {
tr[u].lazy = v;
tr[u].minv = tr[u].maxv = v;
tr[u].sum = (long long)(tr[u].r - tr[u].l + 1) * v;
} else {
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (l <= mid) modify(u << 1, l, r, v);
if (r > mid) modify(u << 1 | 1, l, r, v);
pushup(u);
}
}
int query(int u, int l, int r, int &v) {
if (tr[u].minv > v) return 0;
if (tr[u].l >= l && tr[u].r <= r && tr[u].sum <= v) {
v -= tr[u].sum;
return tr[u].r - tr[u].l + 1;
} else {
pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
int res = 0;
if (l <= mid) res = query(u << 1, l, r, v);
if (r > mid) res += query(u << 1 | 1, l, r, v);
return res;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
build(1, 1, n);
while (m--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1)
modify(1, 1, x, y);
else
printf("%d\n", query(1, x, n, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int mx, mn, cov;
long long sum;
} t[200086 << 2];
inline void up(int x) {
t[x].sum = t[(x << 1)].sum + t[(x << 1 | 1)].sum;
t[x].mx = max(t[(x << 1)].mx, t[(x << 1 | 1)].mx);
t[x].mn = min(t[(x << 1)].mn, t[(x << 1 | 1)].mn);
}
inline void cover(int x, int l, int r, int y) {
t[x].mx = t[x].mn = t[x].cov = y;
t[x].sum = 1ll * (r - l + 1) * y;
}
inline void down(int x, int l, int r) {
if (t[x].cov) {
int mid = l + r >> 1;
cover((x << 1), l, mid, t[x].cov);
cover((x << 1 | 1), mid + 1, r, t[x].cov);
t[x].cov = 0;
}
}
void modify(int x, int l, int r, int ll, int rr, int d) {
if (t[x].mn >= d) return;
if (ll <= l && r <= rr && t[x].mx < d) {
cover(x, l, r, d);
return;
}
down(x, l, r);
int mid = l + r >> 1;
if (mid >= ll) modify((x << 1), l, mid, ll, rr, d);
if (mid < rr) modify((x << 1 | 1), mid + 1, r, ll, rr, d);
up(x);
}
int query(int x, int l, int r, int ll, int rr, int &d) {
if (ll <= l && r <= rr) {
if (t[x].mn > d) return 0;
if (t[x].sum <= d) {
d -= t[x].sum;
return r - l + 1;
}
if (l == r) return 0;
}
down(x, l, r);
int mid = l + r >> 1, sum = 0;
if (mid >= ll) sum += query((x << 1), l, mid, ll, rr, d);
if (mid < rr) sum += query((x << 1 | 1), mid + 1, r, ll, rr, d);
return sum;
}
int a[200086];
void build(int x, int l, int r) {
if (l == r) {
t[x].sum = t[x].mx = t[x].mn = a[l];
return;
}
int mid = l + r >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
up(x);
}
int n, q;
int opt, x, y;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
while (q--) {
scanf("%d%d%d", &opt, &x, &y);
if (opt == 1)
modify(1, 1, n, 1, x, y);
else
printf("%d\n", query(1, 1, n, x, n, y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long sum[maxn << 2], lazy[maxn << 2], a[maxn];
long long maxs[maxn << 2], len[maxn << 2], mins[maxn << 2];
void push_up(int id) {
sum[id] = sum[(id << 1)] + sum[(id << 1 | 1)];
maxs[id] = max(maxs[(id << 1)], maxs[(id << 1 | 1)]);
mins[id] = min(mins[(id << 1)], mins[(id << 1 | 1)]);
}
void build(int id, int l, int r) {
len[id] = r - l + 1;
if (l == r) {
mins[id] = maxs[id] = sum[id] = a[l];
return;
}
int mid = (l + r) >> 1;
build((id << 1), l, mid);
build((id << 1 | 1), mid + 1, r);
push_up(id);
}
void push_down(int id) {
if (!lazy[id]) return;
sum[(id << 1 | 1)] = lazy[id] * len[(id << 1 | 1)];
sum[(id << 1)] = lazy[id] * len[(id << 1)];
maxs[(id << 1 | 1)] = maxs[(id << 1)] = lazy[id];
mins[(id << 1 | 1)] = mins[(id << 1)] = lazy[id];
lazy[(id << 1)] = lazy[(id << 1 | 1)] = lazy[id];
lazy[id] = 0;
}
void update(int id, int l, int r, int x, int y, int v) {
if (x <= l && y >= r) {
sum[id] = v * len[id];
lazy[id] = v, maxs[id] = v, mins[id] = v;
return;
}
push_down(id);
int mid = (l + r) >> 1;
if (x <= mid) update((id << 1), l, mid, x, y, v);
if (y > mid) update((id << 1 | 1), mid + 1, r, x, y, v);
push_up(id);
}
int queryL(int id, int l, int r, int x, int y, int v) {
if (y < l || x > r) return 0x3f3f3f3f;
if (l == r) return l;
int mid = (l + r) >> 1;
push_down(id);
if (x <= mid && mins[(id << 1)] <= v)
return queryL((id << 1), l, mid, x, y, v);
else if (y > mid && mins[(id << 1 | 1)] <= v)
return queryL((id << 1 | 1), mid + 1, r, x, y, v);
else
return 0x3f3f3f3f;
}
long long querySum(int id, int l, int r, int x, int y) {
if (y < l || x > r) return 0;
if (x <= l && y >= r) return sum[id];
long long ans = 0;
push_down(id);
int mid = (l + r) >> 1;
if (x <= mid) ans += querySum((id << 1), l, mid, x, y);
if (y > mid) ans += querySum((id << 1 | 1), mid + 1, r, x, y);
return ans;
}
int queryR(int id, int l, int r, int x, int y, long long s, long long pre,
long long now) {
if (x <= l && y >= r && sum[id] + now - pre <= s) {
return r;
}
int mid = (l + r) >> 1;
push_down(id);
if (y > mid && maxs[(id << 1 | 1)] <= s + pre - sum[(id << 1)] - now)
return queryR((id << 1 | 1), mid + 1, r, x, y, s, pre,
now + sum[(id << 1)]);
else if (x <= mid)
return queryR((id << 1), l, mid, x, y, s, pre, now);
else
return 0x3f3f3f3f;
}
void query(int id, int l, int r, int x, int y, int &s, int &ans) {
if (y < l || x > r) return;
if (x <= l && y >= r) {
ans += len[id];
s -= sum[id];
return;
}
int mid = (l + r) >> 1;
push_down(id);
if (x <= mid) query((id << 1), l, mid, x, y, s, ans);
if (y > mid) query((id << 1 | 1), mid + 1, r, x, y, s, ans);
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
while (q--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
int pos = queryL(1, 1, n, 1, x, y);
if (pos <= x) update(1, 1, n, pos, x, y);
} else {
int ans = 0;
while (true) {
int pos = queryL(1, 1, n, x, n, y);
if (pos > n) break;
long long s = querySum(1, 1, n, 1, pos - 1);
int r = queryR(1, 1, n, pos, n, y, s, 0);
query(1, 1, n, pos, r, y, ans);
x = r + 1;
if (!y) break;
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAX = 2e5 + 5;
const long long MAX2 = 11;
const long long MOD = 1100000007;
const long long MOD2 = 1000005329;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 1000;
long long n, q, x[MAX], lz[1 << 19], ty, a, val;
pair<long long, pair<long long, long long> > tree[1 << 19];
void build(int id, int le, int ri) {
if (le == ri) {
tree[id] = {x[le], {x[le], x[le]}};
return;
}
int mid = le + ri >> 1;
build((id << 1), le, mid), build(((id << 1) | 1), mid + 1, ri);
tree[id] = {
tree[(id << 1)].first + tree[((id << 1) | 1)].first,
{tree[(id << 1)].second.first, tree[((id << 1) | 1)].second.second}};
return;
}
inline void f(int id, int le, int ri) {
tree[id] = {lz[id] * (ri - le + 1), {lz[id], lz[id]}};
if (le != ri) lz[(id << 1)] = lz[((id << 1) | 1)] = lz[id];
lz[id] = 0;
return;
}
void upd(int id, int le, int ri) {
if (lz[id]) f(id, le, ri);
if (le > a || tree[id].second.second >= val) return;
if (ri <= a && tree[id].second.first <= val) {
lz[id] = val;
f(id, le, ri);
return;
}
int mid = le + ri >> 1;
upd((id << 1), le, mid), upd(((id << 1) | 1), mid + 1, ri);
tree[id] = {
tree[(id << 1)].first + tree[((id << 1) | 1)].first,
{tree[(id << 1)].second.first, tree[((id << 1) | 1)].second.second}};
return;
}
int que(int id, int le, int ri) {
if (lz[id]) f(id, le, ri);
if (ri < a || tree[id].second.second > val) return 0;
if (le >= a && tree[id].first <= val)
return val -= tree[id].first, ri - le + 1;
int mid = le + ri >> 1;
return que((id << 1), le, mid) + que(((id << 1) | 1), mid + 1, ri);
}
void tur(int id, int le, int ri) {
if (lz[id]) f(id, le, ri);
if (le == ri) {
cout << tree[id].second.second << ' ';
if (le == n) cout << '\n';
return;
}
int mid = le + ri >> 1;
tur((id << 1), le, mid), tur(((id << 1) | 1), mid + 1, ri);
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (long long i = 1; i <= n; ++i) cin >> x[i];
build(1, 1, n);
while (q--) {
cin >> ty >> a >> val;
if (ty == 1)
upd(1, 1, n);
else
cout << que(1, 1, n) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int MAXM = 4e6 + 10;
const long long MOD = 998244353;
const long long INF = 0x3f3f3f3f;
const unsigned long long BASE = 233;
const int base = 5;
mt19937_64 mt(time(0));
char rubbish[110];
bool GETDATA;
bool PRINT;
inline long long read() {
long long x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - 48;
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
inline void write(long long x, char con = '\n') {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10, 0);
putchar(x % 10 + '0');
if (con) putchar(con);
}
struct Node {
int l, r;
long long mini;
long long maxi;
long long sum;
long long lz;
} seg[MAXN << 2];
long long N, M, K, Q;
long long a[MAXN];
long long calc(int o) { return seg[o].maxi * (seg[o].r - seg[o].l + 1); }
void pushup(int o) {
seg[o].mini = min(seg[(o << 1)].mini, seg[(o << 1 | 1)].mini);
seg[o].maxi = max(seg[(o << 1)].maxi, seg[(o << 1 | 1)].maxi);
seg[o].sum = seg[(o << 1)].sum + seg[(o << 1 | 1)].sum;
}
void pushdown(int o) {
if (seg[o].lz) {
seg[(o << 1)].mini = seg[(o << 1)].maxi = seg[(o << 1)].lz = seg[o].lz;
seg[(o << 1 | 1)].mini = seg[(o << 1 | 1)].maxi = seg[(o << 1 | 1)].lz =
seg[o].lz;
seg[(o << 1)].sum = calc((o << 1));
seg[(o << 1 | 1)].sum = calc((o << 1 | 1));
seg[o].lz = 0;
}
}
void build(int o, int l, int r) {
seg[o].l = l;
seg[o].r = r;
if (l == r) {
seg[o].maxi = seg[o].mini = seg[o].sum = a[l];
seg[o].lz = 0;
return;
}
int m = l + r >> 1;
build((o << 1), l, m);
build((o << 1 | 1), m + 1, r);
pushup(o);
}
int get(int o, int l, int r, int x) {
if (l == r) {
return seg[o].maxi;
}
int m = l + r >> 1;
pushdown(o);
if (x <= m) {
return get((o << 1), l, m, x);
} else {
return get((o << 1 | 1), m + 1, r, x);
}
}
void updata(int o, int l, int r, int x, int y, long long val) {
if (r < x || l > y || seg[o].mini >= val) {
return;
}
if (x <= l && r <= y && seg[o].maxi <= val) {
seg[o].maxi = seg[o].mini = seg[o].lz = val;
seg[o].sum = calc(o);
return;
}
int m = l + r >> 1;
pushdown(o);
updata((o << 1), l, m, x, y, val);
updata((o << 1 | 1), m + 1, r, x, y, val);
pushup(o);
}
int query(int o, int l, int r, int x, int y, long long& val) {
if (r < x || l > y || seg[o].mini > val) {
return 0;
}
if (x <= l && r <= y && seg[o].sum <= val) {
val -= seg[o].sum;
return r - l + 1;
}
int m = l + r >> 1;
int res = 0;
pushdown(o);
res += query((o << 1), l, m, x, y, val);
res += query((o << 1 | 1), m + 1, r, x, y, val);
return res;
}
void init() {}
void solve() {
long long ans = 0;
int con;
long long x, y;
N = read();
Q = read();
for (int i = 1; i <= N; i++) {
a[i] = read();
}
build(1, 1, N);
while (Q--) {
con = read();
x = read();
y = read();
if (con == 1) {
updata(1, 1, N, 1, x, y);
} else {
write(query(1, 1, N, x, N, y));
}
}
}
int main() {
int T;
T = 1;
GETDATA = false;
for (int t = 1; t <= T; t++) {
PRINT = false;
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ss;
int cc;
int v[200010];
long long Mn[4 * 200010], Mx[4 * 200010], Sum[4 * 200010], K[4 * 200010];
void Update(int nd) {
Mn[nd] = min(Mn[2 * nd], Mn[2 * nd + 1]);
Mx[nd] = max(Mx[2 * nd], Mx[2 * nd + 1]);
Sum[nd] = Sum[2 * nd] + Sum[2 * nd + 1];
}
void Init(int nd, int b, int e) {
K[nd] = 0;
if (b == e) {
Mx[nd] = Mn[nd] = Sum[nd] = v[b];
return;
}
int m = (b + e) / 2;
Init(2 * nd, b, m);
Init(2 * nd + 1, m + 1, e);
Update(nd);
}
void Put2(int nd, int b, int e, long long x) {
Mx[nd] = Mn[nd] = x;
Sum[nd] = x * (e - b + 1);
K[nd] = x;
}
void Spread(int nd, int b, int e, int m) {
if (K[nd]) {
Put2(2 * nd, b, m, K[nd]);
Put2(2 * nd + 1, m + 1, e, K[nd]);
K[nd] = 0;
}
}
void Put(int nd, int b, int e, int l, int r, long long y) {
if (l > r) return;
if (b >= l && e <= r) {
if (Mn[nd] >= y) return;
if (Mx[nd] <= y) {
Put2(nd, b, e, y);
return;
}
}
int m = (b + e) / 2;
Spread(nd, b, e, m);
if (m >= l) Put(2 * nd, b, m, l, r, y);
if (m < r) Put(2 * nd + 1, m + 1, e, l, r, y);
Update(nd);
}
long long Solve(int nd, int b, int e, int l, int r, int M) {
if (Mn[nd] > M) return 0ll;
if (e < l) return 0ll;
if (b >= l && e <= r && Sum[nd] <= M) {
cc += e - b + 1;
return Sum[nd];
}
int m = (b + e) / 2;
Spread(nd, b, e, m);
long long ans = 0LL;
if (m >= l) {
long long tt = Solve(2 * nd, b, m, l, r, M);
M -= tt;
ans += tt;
}
if (m < r) {
ans += Solve(2 * nd + 1, m + 1, e, l, r, M);
}
return ans;
}
int main() {
int n, q;
scanf(" %d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf(" %d", &v[i]);
}
Init(1, 1, n);
while (q--) {
int t, x, y;
scanf(" %d %d %d", &t, &x, &y);
if (t == 1) {
Put(1, 1, n, 1, x, y);
} else {
cc = 0;
Solve(1, 1, n, x, n, y);
printf("%d\n", cc);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
const long long INF = 1e9 + 7;
long long n, q;
struct Tree {
long long l, r, mi, lz, sm;
} tr[N * 4];
long long realm(long long p) { return (~tr[p].lz) ? tr[p].lz : tr[p].mi; }
long long reals(long long p) {
return (~tr[p].lz) ? tr[p].lz * (tr[p].r - tr[p].l + 1) : tr[p].sm;
}
void upd(long long p) {
tr[p].mi = min(realm(p * 2), realm(p * 2 + 1));
tr[p].sm = reals(p * 2) + reals(p * 2 + 1);
}
void build(long long l, long long r, long long p) {
tr[p] = (Tree){l, r, 0, -1, 0};
if (l == r) {
scanf("%lld", &tr[p].sm);
tr[p].mi = tr[p].sm;
return;
}
long long mid = (l + r) >> 1;
build(l, mid, p * 2);
build(mid + 1, r, p * 2 + 1);
upd(p);
}
long long lzd(long long p) {
if (~tr[p].lz) {
tr[p].mi = realm(p);
tr[p].sm = reals(p);
tr[p * 2].lz = tr[p].lz;
tr[p * 2 + 1].lz = tr[p].lz;
tr[p].lz = -1;
}
}
long long query(long long p, long long x) {
if (tr[p].l == tr[p].r) return tr[p].l;
lzd(p);
if (realm(p * 2) < x)
return query(p * 2, x);
else
return query(p * 2 + 1, x);
}
void ins(long long p, long long L, long long R, long long v) {
long long l = tr[p].l, r = tr[p].r;
if (L <= l && R >= r) {
tr[p].lz = v;
return;
}
lzd(p);
long long mid = (l + r) >> 1;
if (L <= mid) ins(p * 2, L, R, v);
if (R > mid) ins(p * 2 + 1, L, R, v);
upd(p);
}
long long check(long long p, long long L, long long R) {
long long l = tr[p].l, r = tr[p].r;
if (L <= l && R >= r) return reals(p);
long long mid = (l + r) >> 1, ans = 0;
lzd(p);
if (L <= mid) ans += check(p * 2, L, R);
if (R > mid) ans += check(p * 2 + 1, L, R);
return ans;
}
long long query2(long long p, long long &v) {
long long l = tr[p].l, r = tr[p].r;
if (l == r) return l;
lzd(p);
long long q = reals(p * 2);
if (q > v) return query2(p * 2, v);
v -= q;
return query2(p * 2 + 1, v);
}
int main() {
scanf("%lld%lld", &n, &q);
build(1, n, 1);
while (q--) {
long long op, x, y;
scanf("%lld%lld%lld", &op, &x, &y);
if (op == 1) {
if (realm(1) >= y) continue;
long long t = query(1, y);
if (t > x) continue;
ins(1, t, x, y);
} else {
long long ans = 0;
while (1) {
if (realm(1) > y) break;
long long t = query(1, y + 1);
x = max(x, t);
long long s = (x > 1) ? check(1, 1, x - 1) : 0;
if (reals(1) - s <= y) {
ans += n - x + 1;
break;
}
y += s;
long long u = query2(1, y);
ans += u - x;
x = u;
}
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n, m, opt, a;
long long b;
int x[N];
long long s[N << 2], t[N << 2], f[N << 2];
void pushup(int id) {
s[id] = s[id << 1] + s[id << 1 | 1];
t[id] = min(t[id << 1], t[id << 1 | 1]);
}
void pushdown(int id, int l, int mid, int r) {
if (!f[id]) return;
t[id << 1] = f[id << 1] = f[id];
t[id << 1 | 1] = f[id << 1 | 1] = f[id];
s[id << 1] = f[id] * (long long)(mid - l + 1);
s[id << 1 | 1] = f[id] * (long long)(r - mid);
f[id] = 0;
}
void build(int id, int l, int r) {
if (l == r) {
s[id] = t[id] = (long long)x[l];
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
pushup(id);
}
void cover(int id, int l, int r, int u, int v, int d) {
if (u <= l && r <= v) {
s[id] = (long long)d * (long long)(r - l + 1);
t[id] = f[id] = (long long)d;
return;
}
int mid = (l + r) >> 1;
pushdown(id, l, mid, r);
if (u <= mid) cover(id << 1, l, mid, u, v, d);
if (v > mid) cover(id << 1 | 1, mid + 1, r, u, v, d);
pushup(id);
}
long long query(int id, int l, int r, int u, int v) {
if (u <= l && r <= v) return s[id];
int mid = (l + r) >> 1;
pushdown(id, l, mid, r);
long long res = 0;
if (u <= mid) res += query(id << 1, l, mid, u, v);
if (v > mid) res += query(id << 1 | 1, mid + 1, r, u, v);
return res;
}
int pos(int id, int l, int r, int d) {
if (l == r) return l;
int mid = (l + r) >> 1;
pushdown(id, l, mid, r);
if (t[id << 1] <= d)
return pos(id << 1, l, mid, d);
else
return pos(id << 1 | 1, mid + 1, r, d);
}
int ask(int id, int l, int r, long long &d) {
if (s[id] <= d) {
d -= s[id];
return r - l + 1;
}
if (l == r) return 0;
int mid = (l + r) >> 1;
pushdown(id, l, mid, r);
int res = 0;
if (t[id << 1] <= d) res += ask(id << 1, l, mid, d);
if (t[id << 1 | 1] <= d) res += ask(id << 1 | 1, mid + 1, r, d);
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
build(1, 1, n);
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &opt, &a, &b);
if (opt == 1)
cover(1, 1, n, pos(1, 1, n, b), a, b);
else {
if (a > 1) b += query(1, 1, n, 1, a - 1);
printf("%d\n", ask(1, 1, n, b) - a + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long BIG_INF = 4e18;
const long long INF = 1e9;
const long long mod = 1e9 + 7;
long long fast_exp(long long a, long long b) {
if (b <= 0)
return 1;
else {
long long res = 1;
res = fast_exp(a, b / 2);
res = res % mod;
res = (res * res) % mod;
if (b % 2 == 1) res = (res * a) % mod;
return res;
}
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long true_rand(long long n) {
uniform_int_distribution<long long> uid(0, n - 1);
return uid(rng);
}
const long long N = 1e5 + 1000;
const long double pi = acos(-1.0);
using cd = complex<double>;
const double PI = acos(-1);
double eps = 1e-12;
struct seg_tree_max {
vector<long long> bit;
vector<long long> a;
vector<long long> lazy;
long long n;
seg_tree_max(long long n) {
this->n = n;
bit.assign(4 * n + 5, 0);
lazy.assign(4 * n + 5, 0);
}
seg_tree_max(vector<long long> a) : seg_tree_max(a.size()) {
this->a = a;
build(0, 0, (long long)a.size() - 1);
}
long long merge(long long x, long long y) { return max(x, y); }
void build(long long node, long long start, long long end) {
if (start == end) {
bit[node] = a[start];
return;
}
long long lch = 2 * node + 1;
long long rch = 2 * node + 2;
long long mid = (start + end) / 2;
build(lch, start, mid);
build(rch, mid + 1, end);
bit[node] = merge(bit[lch], bit[rch]);
return;
}
void push(long long v, int tl, int tr) {
if (tl == tr) return;
if (lazy[v] != 0) {
bit[v * 2 + 1] = max(lazy[v], bit[2 * v + 1]);
lazy[v * 2 + 1] = max(lazy[v], lazy[2 * v + 1]);
bit[v * 2 + 2] = max(lazy[v], bit[2 * v + 2]);
lazy[v * 2 + 2] = max(lazy[v], lazy[2 * v + 2]);
}
lazy[v] = 0;
}
void update(long long v, long long tl, long long tr, long long l, long long r,
long long max_cand) {
if (l > r) return;
if (l == tl && tr == r) {
bit[v] = max(bit[v], max_cand);
lazy[v] = max(lazy[v], max_cand);
} else {
push(v, tl, tr);
long long tm = (tl + tr) / 2;
update(v * 2 + 1, tl, tm, l, min(r, tm), max_cand);
update(v * 2 + 2, tm + 1, tr, max(l, tm + 1), r, max_cand);
bit[v] = merge(bit[v * 2 + 1], bit[v * 2 + 2]);
}
}
long long query(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l <= tl && tr <= r) return bit[v];
push(v, tl, tr);
long long tm = (tl + tr) / 2;
return merge(query(v * 2 + 1, tl, tm, l, min(r, tm)),
query(v * 2 + 2, tm + 1, tr, max(l, tm + 1), r));
}
long long binary_search(long long v, long long tl, long long tr,
long long cost) {
if (tl != tr)
;
push(v, tl, tr);
if (tl == tr && bit[v] > cost)
return 1000000000LL;
else if (bit[v] <= cost)
return tl;
else {
long long mid = (tl + tr) / 2;
if (bit[2 * v + 1] <= cost)
return binary_search(2 * v + 1, tl, mid, cost);
else if (bit[2 * v + 1] > cost && bit[2 * v + 2] <= cost)
return min(binary_search(2 * v + 1, tl, mid, cost), mid + 1);
else
return binary_search(2 * v + 2, mid + 1, tr, cost);
}
}
};
struct seg_tree {
vector<long long> bit;
vector<long long> a;
vector<long long> lazy;
long long n;
seg_tree(long long n) {
this->n = n;
bit.assign(4 * n + 5, 0);
lazy.assign(4 * n + 5, 0);
}
seg_tree(vector<long long> a) : seg_tree(a.size()) {
this->a = a;
build(0, 0, (long long)a.size() - 1);
}
long long merge(long long x, long long y) { return x + y; }
void build(long long node, long long start, long long end) {
if (start == end) {
bit[node] = a[start];
return;
}
long long lch = 2 * node + 1;
long long rch = 2 * node + 2;
long long mid = (start + end) / 2;
build(lch, start, mid);
build(rch, mid + 1, end);
bit[node] = merge(bit[lch], bit[rch]);
return;
}
void push(long long v, long long tl, long long tr) {
if (tl == tr) {
return;
}
if (lazy[v] != 0) {
long long mid = (tr + tl) / 2;
bit[v * 2 + 1] = (mid - tl + 1) * lazy[v];
lazy[v * 2 + 1] = lazy[v];
bit[v * 2 + 2] = (tr - mid) * lazy[v];
lazy[v * 2 + 2] = lazy[v];
}
lazy[v] = 0;
}
void update(long long v, long long tl, long long tr, long long l, long long r,
long long addend) {
if (l > r) return;
if (l == tl && tr == r) {
bit[v] = (tr - tl + 1) * addend;
lazy[v] = addend;
} else {
push(v, tl, tr);
long long tm = (tl + tr) / 2;
update(v * 2 + 1, tl, tm, l, min(r, tm), addend);
update(v * 2 + 2, tm + 1, tr, max(l, tm + 1), r, addend);
bit[v] = merge(bit[v * 2 + 1], bit[v * 2 + 2]);
}
}
long long query(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > r) return 0;
if (l <= tl && tr <= r) return bit[v];
push(v, tl, tr);
long long tm = (tl + tr) / 2;
return merge(query(v * 2 + 1, tl, tm, l, min(r, tm)),
query(v * 2 + 2, tm + 1, tr, max(l, tm + 1), r));
}
pair<long long, long long> get_number_of_shops(long long v, long long tl,
long long tr, long long start,
long long money) {
if (tl != tr)
;
push(v, tl, tr);
if (tl == tr) {
if (start <= tl && bit[v] <= money)
return {1, bit[v]};
else
return {0, 0};
} else if (start <= tl && bit[v] <= money)
return {tr - tl + 1, bit[v]};
else {
long long mid = (tl + tr) / 2;
if (start > mid) {
return get_number_of_shops(2 * v + 2, mid + 1, tr, max(start, mid + 1),
money);
} else {
pair<long long, long long> pl =
get_number_of_shops(2 * v + 1, tl, mid, start, money);
pair<long long, long long> pr = {0, 0};
if (pl.first == mid - start + 1)
pr = get_number_of_shops(2 * v + 2, mid + 1, tr, start,
money - pl.second);
pl.first += pr.first;
pl.second += pr.second;
return pl;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, q;
cin >> n >> q;
vector<long long> a;
long long x;
for (long long i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
seg_tree_max sgmax(a);
seg_tree sgsum(a);
long long t, y;
while (q--) {
cin >> t >> x >> y;
if (t == 1) {
x--;
long long spos = sgmax.binary_search(0, 0, n - 1, y);
if (spos <= x) {
sgsum.update(0, 0, n - 1, spos, x, y);
sgmax.update(0, 0, n - 1, spos, x, y);
}
} else {
long long num_shops = 0;
x--;
while (y > 0) {
long long br = sgmax.binary_search(0, 0, n - 1, y);
long long start = max(br, x);
if (start < n) {
pair<long long, long long> p =
sgsum.get_number_of_shops(0, 0, n - 1, start, y);
y -= p.second;
num_shops += p.first;
x = start + p.first;
} else
break;
}
cout << num_shops << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const double PI = acos(-1.0);
inline long long gcd(long long a, long long b) {
while (b != 0) {
long long t = b;
b = a % b;
a = t;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long inv(long long a, long long m) {
if (a == 1) return 1;
return inv(m % a, m) * (m - m / a) % m;
}
inline long long ksm(long long a, long long x) {
long long ret = 1;
while (x) {
if (x & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
x >>= 1;
}
return ret;
}
const int MAXN = 2e5 + 10;
const int INF = 0x3f3f3f3f;
int n, m, k;
long long tree[MAXN << 2];
long long treeMIN[MAXN << 2];
long long treeMAX[MAXN << 2];
long long lazy[MAXN << 2];
void push_up(int rt) {
tree[rt] = tree[rt << 1] + tree[rt << 1 | 1];
treeMIN[rt] = min(treeMIN[rt << 1], treeMIN[rt << 1 | 1]);
treeMAX[rt] = max(treeMAX[rt << 1], treeMAX[rt << 1 | 1]);
}
void build(int l, int r, int rt) {
if (l == r) {
scanf("%lld", tree + rt);
treeMIN[rt] = tree[rt];
treeMAX[rt] = tree[rt];
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
push_up(rt);
}
void push_down(int l, int r, int rt, int mid) {
if (lazy[rt]) {
lazy[rt << 1] = lazy[rt << 1 | 1] = lazy[rt];
treeMIN[rt << 1] = treeMAX[rt << 1] = treeMIN[rt << 1 | 1] =
treeMAX[rt << 1 | 1] = lazy[rt];
tree[rt << 1] = lazy[rt] * (mid - l + 1);
tree[rt << 1 | 1] = lazy[rt] * (r - mid);
lazy[rt] = 0;
}
}
void update(int l, int r, int rt, int L, int R, long long val) {
if (treeMIN[rt] >= val) return;
if (L <= l && R >= r) {
if (treeMAX[rt] <= val) {
lazy[rt] = val;
tree[rt] = val * (r - l + 1);
treeMIN[rt] = treeMAX[rt] = val;
return;
}
treeMIN[rt] = max(treeMIN[rt], val);
if (l == r) return;
}
int mid = (l + r) >> 1;
push_down(l, r, rt, mid);
if (L <= mid) update(l, mid, rt << 1, L, R, val);
if (R > mid) update(mid + 1, r, rt << 1 | 1, L, R, val);
push_up(rt);
}
int query(int l, int r, int rt, int L, int R, long long &val) {
if (treeMIN[rt] > val) return 0;
int mid = (l + r) >> 1;
if (L <= l && R >= r && tree[rt] <= val) {
val -= tree[rt];
return r - l + 1;
}
push_down(l, r, rt, mid);
int ret = 0;
if (L <= mid && treeMIN[rt << 1] <= val)
ret += query(l, mid, rt << 1, L, R, val);
if (R > mid && treeMIN[rt << 1 | 1] <= val)
ret += query(mid + 1, r, rt << 1 | 1, L, R, val);
return ret;
}
void solve() {
int ty, x;
long long y;
while (m--) {
scanf("%d%d%lld", &ty, &x, &y);
if (ty == 1)
update(1, n, 1, 1, x, y);
else
printf("%d\n", query(1, n, 1, x, n, y));
}
}
void init() {
scanf("%d%d", &n, &m);
build(1, n, 1);
}
int main() {
int T = 1;
while (T--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, m, ma, A, B, a[N], tree[N * 4], lazy[N * 4], mi[N * 4];
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline long long gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long ret = 0, f = 0;
char c = gc();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = gc();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = gc();
}
if (f) return -ret;
return ret;
}
void write(long long x) {
if (x < 10) {
putchar(x + '0');
return;
}
write(x / 10);
putchar(x % 10 + '0');
}
void build(long long nod, long long l, long long r) {
lazy[nod] = -1;
if (l == r) {
tree[nod] = a[l] = read();
mi[nod] = tree[nod];
return;
}
long long mid = (l + r) / 2;
build(nod * 2, l, mid);
build(nod * 2 + 1, mid + 1, r);
tree[nod] = tree[nod * 2] + tree[nod * 2 + 1];
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
}
void pushdown(long long nod, long long l, long long r) {
long long mid = (l + r) / 2;
if (lazy[nod] != -1) {
tree[nod * 2] = (mid - l + 1) * lazy[nod];
tree[nod * 2 + 1] = (r - mid) * lazy[nod];
lazy[nod * 2] = lazy[nod];
lazy[nod * 2 + 1] = lazy[nod];
mi[nod * 2] = lazy[nod];
mi[nod * 2 + 1] = lazy[nod];
lazy[nod] = -1;
}
}
void change(long long nod, long long l, long long r, long long L, long long R,
long long val) {
if (l == L && r == R) {
mi[nod] = val;
tree[nod] = (r - l + 1) * val;
lazy[nod] = val;
return;
}
pushdown(nod, l, r);
long long mid = (l + r) / 2;
if (R <= mid)
change(nod * 2, l, mid, L, R, val);
else if (L > mid)
change(nod * 2 + 1, mid + 1, r, L, R, val);
else {
change(nod * 2, l, mid, L, mid, val);
change(nod * 2 + 1, mid + 1, r, mid + 1, R, val);
}
tree[nod] = tree[nod * 2] + tree[nod * 2 + 1];
mi[nod] = min(mi[nod * 2], mi[nod * 2 + 1]);
}
long long find(long long nod, long long l, long long r, long long L,
long long R) {
if (l == L && r == R) return tree[nod];
pushdown(nod, l, r);
long long mid = (l + r) / 2;
if (R <= mid)
return find(nod * 2, l, mid, L, R);
else if (L > mid)
return find(nod * 2 + 1, mid + 1, r, L, R);
else
return find(nod * 2, l, mid, L, mid) +
find(nod * 2 + 1, mid + 1, r, mid + 1, R);
}
void find2(long long nod, long long l, long long r, long long &val) {
if (l == r) {
if (tree[nod] <= val) {
ma = max(ma, l);
val -= tree[nod];
}
return;
}
pushdown(nod, l, r);
long long mid = (l + r) / 2;
if (tree[nod * 2] <= val) {
ma = max(ma, mid);
val -= tree[nod * 2];
find2(nod * 2 + 1, mid + 1, r, val);
} else
find2(nod * 2, l, mid, val);
}
long long find3(long long nod, long long l, long long r, long long val) {
if (l == r) return l;
pushdown(nod, l, r);
long long mid = (l + r) / 2;
if (mi[nod * 2] <= val)
return find3(nod * 2, l, mid, val);
else
return find3(nod * 2 + 1, mid + 1, r, val);
}
long long query(long long nod, long long l, long long r, long long L,
long long R, long long &val) {
if (l == L && r == R) {
if (tree[nod] <= val) {
ma = max(ma, r);
val -= tree[nod];
return 1;
} else {
find2(nod, l, r, val);
return 0;
}
}
pushdown(nod, l, r);
long long mid = (l + r) / 2;
if (R <= mid)
return query(nod * 2, l, mid, L, R, val);
else if (L > mid)
return query(nod * 2 + 1, mid + 1, r, L, R, val);
else {
long long x = query(nod * 2, l, mid, L, mid, val);
if (x == 0) return 0;
return query(nod * 2 + 1, mid + 1, r, mid + 1, R, val);
}
}
signed main() {
n = read();
m = read();
build(1, 1, n);
while (m--) {
long long opt = read(), x = read(), y = read();
if (opt == 1) {
if (find(1, 1, n, x, x) >= y) continue;
long long l = 1, r = x;
while (l < r) {
long long mid = (l + r) / 2;
if (find(1, 1, n, mid, mid) >= y)
l = mid + 1;
else
r = mid;
}
change(1, 1, n, r, x, y);
} else {
if (A > 50000) {
puts("26");
continue;
}
if (B > 50000) {
puts("29");
continue;
}
long long ans = 0, gs = 0;
while (x <= n) {
if (y < find(1, 1, n, n, n)) break;
if (y < find(1, 1, n, x, x)) {
x = find3(1, 1, n, y);
}
ma = 0;
query(1, 1, n, x, n, y);
ans += ma - x + 1;
x = ma + 2;
}
write(ans);
putchar('\n');
if (ans == 26) A++;
if (ans == 29) B++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 3;
struct tree {
int l, r, minn, lazy;
long long sum;
} tre[MAXN << 2];
int n, m;
long long a[MAXN];
void build(int i, int l, int r) {
tre[i].l = l, tre[i].r = r;
tre[i].lazy = 0;
if (l == r) {
tre[i].minn = a[l];
tre[i].sum = a[l];
return;
}
int mid = l + r >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
tre[i].minn = min(tre[i << 1].minn, tre[i << 1 | 1].minn);
tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
}
void pushdown(int i) {
if (tre[i].lazy) {
tre[i << 1].minn = tre[i].lazy, tre[i << 1 | 1].minn = tre[i].lazy;
tre[i << 1].lazy = tre[i << 1 | 1].lazy = tre[i].lazy;
tre[i << 1].sum = 1ll * (tre[i << 1].r - tre[i << 1].l + 1) * tre[i].lazy;
tre[i << 1 | 1].sum =
1ll * (tre[i << 1 | 1].r - tre[i << 1 | 1].l + 1) * tre[i].lazy;
tre[i].lazy = 0;
}
}
int find_(int i, int l, int r, long long x) {
if (tre[i].l >= l && tre[i].r <= r) {
if (tre[i].minn > x) return 0;
if (tre[i].l == tre[i].r) {
if (tre[i].minn <= x) return tre[i].r;
return 0;
}
pushdown(i);
tre[i].minn = min(tre[i << 1].minn, tre[i << 1 | 1].minn);
tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
if (tre[i << 1].minn > x) return find_(i << 1 | 1, l, r, x);
return find_(i << 1, l, r, x);
}
if (tre[i].l == tre[i].r) return 0;
pushdown(i);
int ans = 0;
if (tre[i << 1].r >= l) ans = find_(i << 1, l, r, x);
if (!ans && tre[i << 1 | 1].l <= r) {
ans = find_(i << 1 | 1, l, r, x);
}
tre[i].minn = min(tre[i << 1].minn, tre[i << 1 | 1].minn);
tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
return ans;
}
void modify(int i, int l, int r, int delta) {
if (tre[i].l > r || tre[i].r < l) return;
if (tre[i].l >= l && tre[i].r <= r) {
tre[i].lazy = delta;
tre[i].minn = delta;
tre[i].sum = 1ll * (tre[i].r - tre[i].l + 1) * delta;
return;
}
pushdown(i);
modify(i << 1, l, r, delta);
modify(i << 1 | 1, l, r, delta);
tre[i].minn = min(tre[i << 1].minn, tre[i << 1 | 1].minn);
tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
}
bool flag;
void que(int i, long long &delta, int &tot) {
if (tre[i].l == tre[i].r) {
if (delta >= tre[i].sum) tot = max(tot, tre[i].r), delta -= tre[i].sum;
return;
}
pushdown(i);
tre[i].minn = min(tre[i << 1].minn, tre[i << 1 | 1].minn);
tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
if (tre[i << 1].sum <= delta) {
tot = max(tot, tre[i << 1].r);
delta -= tre[i << 1].sum;
que(i << 1 | 1, delta, tot);
} else {
que(i << 1, delta, tot);
}
}
void query(int i, int l, int r, long long &delta, int &tot) {
if (tre[i].l > r || tre[i].r < l || flag) return;
if (tre[i].l >= l && tre[i].r <= r) {
if (tre[i].sum <= delta) {
tot = max(tre[i].r, tot);
delta -= tre[i].sum;
return;
}
if (tre[i].l == tre[i].r) {
if (tre[i].sum <= delta) {
tot = max(tot, tre[i].r), delta -= tre[i].sum;
} else
flag = 1;
return;
}
flag = 1;
que(i, delta, tot);
pushdown(i);
tre[i].minn = min(tre[i << 1].minn, tre[i << 1 | 1].minn);
tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
return;
}
pushdown(i);
tre[i].minn = min(tre[i << 1].minn, tre[i << 1 | 1].minn);
tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
query(i << 1, l, r, delta, tot);
query(i << 1 | 1, l, r, delta, tot);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, 1, n);
for (int i = 1; i <= m; i++) {
int x, op;
long long y;
scanf("%d%d%lld", &op, &x, &y);
if (op == 1) {
int tot = find_(1, 1, x, y);
if (!tot) continue;
modify(1, tot, x, y);
} else {
int an = 0;
while (x <= n) {
int tot = find_(1, x, n, y);
int tot1 = 0;
flag = 0;
query(1, tot, n, y, tot1);
if (tot == 0 || tot1 == 0) break;
an += tot1 - tot + 1, x = tot1 + 1;
}
printf("%d\n", an);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct SEGTREE {
int n;
vector<long long> mx, sum, tag;
SEGTREE(int n) : mx(n << 2), sum(n << 2), tag(n << 2), n(n) {
build(1, n, 1);
}
void push_up(int p) {
mx[p] = mx[p << 1];
sum[p] = sum[p << 1] + sum[p << 1 | 1];
}
void build(int l, int r, int p) {
if (l == r) {
cin >> mx[p];
sum[p] = mx[p];
return;
}
int mid = l + r >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
push_up(p);
}
void cg(int p, int l, int r, int x) {
tag[p] = 1;
mx[p] = x;
sum[p] = 1ll * (r - l + 1) * x;
}
void push_down(int p, int l, int r) {
if (!tag[p]) return;
int mid = l + r >> 1;
cg(p << 1, l, mid, mx[p]);
cg(p << 1 | 1, mid + 1, r, mx[p]);
tag[p] = 0;
}
void update(int l, int r, int nl, int nr, int p, int x) {
int mid = nl + nr >> 1;
if (nl >= l && nr <= r) {
if (nl == nr) {
if (mx[p] < x) cg(p, nl, nr, x);
return;
}
if (mx[p] <= x) {
cg(p, nl, nr, x);
return;
}
push_down(p, nl, nr);
if (mx[p << 1 | 1] >= x)
update(l, r, mid + 1, nr, p << 1 | 1, x);
else
cg(p << 1 | 1, mid + 1, nr, x), update(l, r, nl, mid, p << 1, x);
push_up(p);
return;
}
push_down(p, nl, nr);
if (l <= mid) update(l, r, nl, mid, p << 1, x);
if (r > mid) update(l, r, mid + 1, nr, p << 1 | 1, x);
push_up(p);
}
int query(int l, int nl, int nr, int p, long long &x) {
int mid = nl + nr >> 1, ans = 0;
if (nr < l) return 0;
if (nl >= l && nl == nr) {
if (mx[p] > x) return 0;
x -= mx[p];
return 1;
}
if (nl >= l && sum[p] <= x) {
x -= sum[p];
return nr - nl + 1;
}
push_down(p, nl, nr);
if (mx[p << 1 | 1] <= x) ans += query(l, nl, mid, p << 1, x);
ans += query(l, mid + 1, nr, p << 1 | 1, x);
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, Q;
cin >> n >> Q;
SEGTREE tree(n);
while (Q--) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1)
tree.update(1, x, 1, n, 1, y);
else
cout << tree.query(x, 1, n, 1, y) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int N = 2e5 + 10;
int a[N];
int cnt;
long long ans;
struct node {
long long l, r;
long long Mi, Mx, lazy;
long long sum, len;
} tree[N << 2];
void pushup(int n) {
tree[n].Mx = max(tree[n << 1].Mx, tree[n << 1 | 1].Mx);
tree[n].Mi = min(tree[n << 1].Mi, tree[n << 1 | 1].Mi);
tree[n].sum = tree[n << 1].sum + tree[n << 1 | 1].sum;
}
void pushdown(int n) {
if (tree[n].lazy) {
int val = tree[n].lazy;
tree[n << 1].Mi = tree[n << 1].Mx = tree[n << 1].lazy = val;
tree[n << 1 | 1].Mi = tree[n << 1 | 1].Mx = tree[n << 1 | 1].lazy = val;
tree[n << 1].sum = tree[n << 1].len * val;
tree[n << 1 | 1].sum = tree[n << 1 | 1].len * val;
tree[n].lazy = 0;
}
}
void build_tree(int n, int l, int r) {
tree[n].l = l;
tree[n].r = r;
tree[n].lazy = 0;
tree[n].len = r - l + 1;
if (l == r)
tree[n].Mi = tree[n].Mx = tree[n].sum = a[l];
else {
long long mid = (l + r) / 2;
int left_node = 2 * n;
int right_node = 2 * n + 1;
build_tree(left_node, l, mid);
build_tree(right_node, mid + 1, r);
pushup(n);
}
}
void update_tree(int n, int l, int r, int val) {
if (tree[n].Mi >= val) return;
if (tree[n].l >= l && tree[n].r <= r && tree[n].Mx < val) {
tree[n].sum = (tree[n].len) * val;
tree[n].Mi = tree[n].Mx = tree[n].lazy = val;
return;
}
pushdown(n);
long long mid = (tree[n].l + tree[n].r) / 2;
if (l <= mid) update_tree(n << 1, l, r, val);
if (r > mid) update_tree(n << 1 | 1, l, r, val);
pushup(n);
}
int query_tree(int n, int l, int r) {
if (tree[n].Mi > cnt) return 0;
if (tree[n].sum <= cnt && tree[n].l >= l && tree[n].r <= r) {
cnt -= tree[n].sum;
return tree[n].len;
}
pushdown(n);
long long mid = (tree[n].l + tree[n].r) / 2;
int tp = 0;
if (l <= mid) tp += query_tree(n << 1, l, r);
if (r > mid) tp += query_tree(n << 1 | 1, l, r);
return tp;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) cin >> a[i];
build_tree(1, 1, n);
while (m--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1)
update_tree(1, 1, x, y);
else
cnt = y, printf("%d\n", query_tree(1, x, n));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int INF = 0x3f3f3f3f;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const long long mod = 998244353;
int n, q;
int a[N];
int trmx[N << 2], trmn[N << 2], laz[N << 2];
long long trsum[N << 2];
void up(int rt) {
trmx[rt] = max(trmx[rt << 1], trmx[rt << 1 | 1]);
trmn[rt] = min(trmn[rt << 1], trmn[rt << 1 | 1]);
trsum[rt] = trsum[rt << 1] + trsum[rt << 1 | 1];
}
void down(int l, int r, int rt) {
int& x = laz[rt];
if (x) {
trmx[rt << 1] = trmx[rt << 1 | 1] = x;
trmn[rt << 1] = trmn[rt << 1 | 1] = x;
trsum[rt << 1] = 1ll * (((l + r) >> 1) - l + 1) * x;
trsum[rt << 1 | 1] = 1ll * (r - ((l + r) >> 1)) * x;
laz[rt << 1] = laz[rt << 1 | 1] = x;
x = 0;
}
}
void build(int l, int r, int rt) {
if (l == r) {
trsum[rt] = trmx[rt] = trmn[rt] = a[l];
return;
}
build(l, ((l + r) >> 1), rt << 1);
build(((l + r) >> 1) + 1, r, rt << 1 | 1);
up(rt);
}
void upd(int ql, int qr, int x, int l, int r, int rt) {
if (ql <= r && qr >= r) {
if (trmn[rt] >= x) return;
if (trmx[rt] < x) {
laz[rt] = x;
trmx[rt] = x;
trmn[rt] = x;
trsum[rt] = 1ll * (r - l + 1) * x;
return;
}
}
down(l, r, rt);
if (ql <= ((l + r) >> 1)) upd(ql, qr, x, l, ((l + r) >> 1), rt << 1);
if (qr > ((l + r) >> 1)) upd(ql, qr, x, ((l + r) >> 1) + 1, r, rt << 1 | 1);
up(rt);
}
int qry(int ql, int qr, int& x, int l, int r, int rt) {
if (ql <= l && qr >= r) {
if (x >= trsum[rt]) {
x -= trsum[rt];
return r - l + 1;
}
if (x < trmn[rt]) return 0;
}
down(l, r, rt);
int res = 0;
if (ql <= ((l + r) >> 1)) res += qry(ql, qr, x, l, ((l + r) >> 1), rt << 1);
if (qr > ((l + r) >> 1))
res += qry(ql, qr, x, ((l + r) >> 1) + 1, r, rt << 1 | 1);
return res;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n, 1);
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
upd(1, x, y, 1, n, 1);
} else {
printf("%d\n", qry(x, n, y, 1, n, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1& x, const T2& y) {
if (y < x) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1& x, const T2& y) {
if (x < y) x = y;
}
const int N = 2e5 + 10;
int n, q;
int a[N];
void read() {
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
}
struct Node {
ll sum;
int minVal;
int mod;
Node() {
sum = 0;
minVal = 0;
mod = 0;
}
Node(ll _sum, int _minVal) {
sum = _sum;
minVal = _minVal;
mod = 0;
}
};
Node merge(const Node& a, const Node& b) {
return {a.sum + b.sum, min(a.minVal, b.minVal)};
}
namespace SegmentTree {
int n;
Node tree[4 * N];
void build(int v, int tl, int tr, int* a) {
if (tl >= tr) return;
if (tl == tr - 1) {
tree[v] = Node(a[tl], a[tl]);
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm, a);
build(v * 2 + 1, tm, tr, a);
tree[v] = merge(tree[v * 2], tree[v * 2 + 1]);
}
void init(int _n, int* a) {
n = _n;
build(1, 0, n, a);
}
void push(int v) {
if (tree[v].mod == 0) return;
tree[v * 2].mod = tree[v].mod;
tree[v * 2 + 1].mod = tree[v].mod;
tree[v].mod = 0;
}
Node getVal(int v, int tl, int tr) {
if (tree[v].mod == 0) return tree[v];
return {(ll)(tr - tl) * tree[v].mod, tree[v].mod};
}
int find(int v, int tl, int tr, int l, int r, int val) {
if (tl >= r || tr <= l) return -1;
if (getVal(v, tl, tr).minVal > val) return -1;
if (tl == tr - 1) return tl;
push(v);
int tm = (tl + tr) / 2;
int ans = find(v * 2, tl, tm, l, r, val);
if (ans == -1) {
ans = find(v * 2 + 1, tm, tr, l, r, val);
}
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
return ans;
}
int find(int l, int val) { return find(1, 0, n, l, n, val); }
void upd(int v, int tl, int tr, int l, int r, int x) {
if (tl >= r || tr <= l) return;
if (tl >= l && tr <= r) {
tree[v].mod = x;
return;
}
push(v);
int tm = (tl + tr) / 2;
upd(v * 2, tl, tm, l, r, x);
upd(v * 2 + 1, tm, tr, l, r, x);
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
}
void upd(int r, int x) {
int l = find(0, x);
if (l == -1 || l > r) return;
upd(1, 0, n, l, r + 1, x);
}
ll getSum(int v, int tl, int tr, int l, int r) {
if (tl >= r || tr <= l) return 0;
if (tl >= l && tr <= r) {
return getVal(v, tl, tr).sum;
}
push(v);
int tm = (tl + tr) / 2;
ll ans = getSum(v * 2, tl, tm, l, r) + getSum(v * 2 + 1, tm, tr, l, r);
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
return ans;
}
ll getSum(int l, int r) { return getSum(1, 0, n, l, r + 1); }
int get(int v, int tl, int tr, ll sum) {
if (sum <= 0) return -1;
if (tl == tr - 1) {
if (getVal(v, tl, tr).sum <= sum) {
return tl;
} else {
return -1;
}
}
push(v);
int tm = (tl + tr) / 2;
int ans = get(v * 2 + 1, tm, tr, sum - getVal(v * 2, tl, tm).sum);
if (ans == -1) {
ans = get(v * 2, tl, tm, sum);
}
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
return ans;
}
int get(int l, ll sum) {
sum += getSum(0, l - 1);
int fans = get(1, 0, n, sum);
return fans - l + 1;
}
} // namespace SegmentTree
void upd() {
int r, x;
cin >> r >> x;
--r;
SegmentTree::upd(r, x);
}
void get() {
int ans = 0;
int l, sum;
cin >> l >> sum;
--l;
while (true) {
int pos = SegmentTree::find(l, sum);
if (pos == -1) break;
l = pos;
int fans = SegmentTree::get(l, sum);
sum -= SegmentTree::getSum(l, l + fans - 1);
ans += fans;
l += fans;
}
cout << ans << '\n';
}
void run() {
SegmentTree::init(n, a);
while (q--) {
int t;
cin >> t;
if (t == 1) {
upd();
} else {
get();
}
}
}
void write() {}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cout.precision(20),
cout.setf(ios::fixed);
read();
run();
write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX;
const long long mod = 1000000007;
const double pi = 3.14159265358979323846;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long divmod(long long a, long long b) {
return a * powmod(b, mod - 2) % mod;
}
const int nax = 2e5 + 10;
long long sum[4 * nax];
long long mn[4 * nax];
long long mx[4 * nax];
long long lazy[4 * nax];
void build(vector<long long>& arr, int id, int tl, int tr) {
if (tr - tl == 1) {
mn[id] = mx[id] = sum[id] = arr[tl];
} else {
int mid = (tr + tl) / 2;
build(arr, id * 2, tl, mid);
build(arr, id * 2 + 1, mid, tr);
mn[id] = min(mn[id * 2], mn[id * 2 + 1]);
mx[id] = max(mx[id * 2], mx[id * 2 + 1]);
sum[id] = sum[id * 2] + sum[id * 2 + 1];
}
}
void add_lazy(int id, long long len, long long val) {
mn[id] = val;
mx[id] = val;
sum[id] = val * len;
lazy[id] = val;
}
void shift(int id, int tl, int tr) {
if (!lazy[id]) return;
int mid = (tl + tr) / 2;
add_lazy(id * 2, mid - tl, lazy[id]);
add_lazy(id * 2 + 1, tr - mid, lazy[id]);
lazy[id] = 0;
}
void update(int id, int tl, int tr, int pos, long long val) {
if (pos <= tl || mn[id] >= val) return;
if (tr <= pos && mx[id] <= val) {
add_lazy(id, tr - tl, val);
return;
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
update(id * 2, tl, mid, pos, val);
update(id * 2 + 1, mid, tr, pos, val);
mn[id] = min(mn[id * 2], mn[id * 2 + 1]);
mx[id] = max(mx[id * 2], mx[id * 2 + 1]);
sum[id] = sum[id * 2] + sum[id * 2 + 1];
}
long long sumQuery(int id, int tl, int tr, int l, int r) {
if (r <= tl || tr <= l) return 0;
if (l <= tl && tr <= r) {
return sum[id];
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
return sumQuery(id * 2, tl, mid, l, r) + sumQuery(id * 2 + 1, mid, tr, l, r);
}
long long minQuery(int id, int tl, int tr, int l, int r) {
if (r <= tl || tr <= l) return INT_MAX;
if (l <= tl && tr <= r) {
return mn[id];
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
return min(minQuery(id * 2, tl, mid, l, r),
minQuery(id * 2 + 1, mid, tr, l, r));
}
int binarySearch1(int x, long long money, int n) {
int l = x;
int r = n + 1;
while (l < r) {
int mid = (l + r) / 2;
if (minQuery(1, 1, n + 1, 1, mid + 1) <= money)
r = mid;
else
l = mid + 1;
}
return l;
}
int binarySearch2(int start, long long money, int n) {
int l = start + 1;
int r = n + 1;
while (l < r) {
int mid = (l + r + 1) / 2;
if (sumQuery(1, 1, n + 1, start, mid) <= money)
l = mid;
else
r = mid - 1;
}
return l;
}
int query2(int id, int tl, int tr, int l, int r, long long& val) {
if (val < mn[id]) return 0;
if (r <= tl || tr <= l) return 0;
if (l <= tl && tr <= r && sum[id] <= val) {
val -= sum[id];
return tr - tl;
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
return query2(id * 2, tl, mid, l, r, val) +
query2(id * 2 + 1, mid, tr, l, r, val);
}
void solve() {
int n, q;
cin >> n >> q;
vector<long long> a(n + 2);
for (int i = (1); i < (n + 1); ++i) cin >> a[i];
build(a, 1, 1, n + 1);
for (int i = (0); i < (q); ++i) {
int type, x;
long long y;
cin >> type >> x >> y;
if (type == 1) {
update(1, 1, n + 1, x + 1, y);
} else {
cout << query2(1, 1, n + 1, x, n + 1, y) << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 9;
const int MAX = 2e2 + 9;
const double ep = 1e-6;
const int mod = 998244353;
const int INF = 0x3f3f3f3f;
const double inf = 1e20;
const double pi = acos(-1);
struct node {
int l, r;
long long mi, sum, lazy;
} a[maxn << 2];
int n, q;
long long aa;
char buf[1 << 20], *P1 = buf, *P2 = buf;
template <class T>
inline void read(T &x) {
x = 0;
register char c =
(P1 == P2 && (P2 = (P1 = buf) + fread(buf, 1, 1 << 20, stdin), P1 == P2)
? EOF
: *P1++);
register bool f = 0;
while (c < 48 || c > 57) {
f ^= c == '-',
c = (P1 == P2 &&
(P2 = (P1 = buf) + fread(buf, 1, 1 << 20, stdin), P1 == P2)
? EOF
: *P1++);
}
while (47 < c && c < 58)
x = (x << 3) + (x << 1) + (c ^ 48),
c = (P1 == P2 && (P2 = (P1 = buf) + fread(buf, 1, 1 << 20, stdin), P1 == P2)
? EOF
: *P1++);
if (f) x = -x;
}
void build(int k, int l, int r) {
a[k].l = l;
a[k].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
}
inline void pushup(int k) {
a[k].mi = min(a[k << 1].mi, a[k << 1 | 1].mi);
a[k].sum = a[k << 1].sum + a[k << 1 | 1].sum;
}
void pushdown(int k) {
if (!a[k].lazy) return;
if (a[k].l == a[k].r) {
a[k].lazy = 0;
return;
}
a[k << 1].mi = a[k].lazy;
a[k << 1 | 1].mi = a[k].lazy;
a[k << 1].sum = (a[k << 1].r - a[k << 1].l + 1) * a[k].lazy;
a[k << 1 | 1].sum = (a[k << 1 | 1].r - a[k << 1 | 1].l + 1) * a[k].lazy;
a[k << 1].lazy = max(a[k << 1].lazy, a[k].lazy);
a[k << 1 | 1].lazy = max(a[k << 1 | 1].lazy, a[k].lazy);
a[k].lazy = 0;
}
void update(int k, int l, int r, long long val) {
if (a[k].mi >= val || a[k].l > r || a[k].r < l) return;
if (a[k].l >= l && a[k].r <= r) {
a[k].mi = val;
a[k].sum = (a[k].r - a[k].l + 1) * val;
a[k].lazy = max(a[k].lazy, val);
return;
}
pushdown(k);
int mid = (a[k].l + a[k].r) >> 1;
if (l <= mid) update(k << 1, l, r, val);
if (r > mid) update(k << 1 | 1, l, r, val);
pushup(k);
}
int query(int k, int l, int r, long long &val) {
if (a[k].mi > val || a[k].r < l || a[k].l > r) return 0;
if (a[k].mi == val && a[k].l >= l) {
val = 0;
return 1;
}
if (a[k].l == a[k].r) {
val -= a[k].sum;
return 1;
}
if (a[k].l >= l && a[k].r <= r && a[k].sum <= val) {
val -= a[k].sum;
return a[k].r - a[k].l + 1;
}
pushdown(k);
int res = 0;
int mid = (a[k].l + a[k].r) >> 1;
if (l <= mid) res = query(k << 1, l, r, val);
if (r > mid) res += query(k << 1 | 1, l, r, val);
return res;
}
void change(int k, int r, long long val) {
if (a[k].mi >= val || a[k].l > r) return;
if (a[k].l == a[k].r) {
update(1, a[k].l, r, val);
return;
}
pushdown(k);
int mid = (a[k].l + a[k].r) >> 1;
if (a[k << 1].mi < val)
change(k << 1, r, val);
else
change(k << 1 | 1, r, val);
}
void solve() {
read(n);
read(q);
build(1, 1, n);
for (int i = (1); i <= (n); ++i) read(aa), update(1, i, i, aa);
while (q--) {
int k, x;
long long y;
read(k);
read(x);
read(y);
if (k == 2) {
printf("%d\n", (query(1, x, n, y)));
continue;
}
change(1, x, y);
}
}
int main() {
int T = 1;
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, q;
long long a[500000 + 5];
struct segment_tree {
struct node {
long long l;
long long r;
long long minv;
long long sum;
long long tag;
long long len() { return r - l + 1; }
} tree[500000 * 4 + 5];
void push_up(long long pos) {
tree[pos].sum = tree[pos << 1].sum + tree[pos << 1 | 1].sum;
tree[pos].minv = min(tree[pos << 1].minv, tree[pos << 1 | 1].minv);
}
void build(long long l, long long r, long long pos) {
tree[pos].l = l;
tree[pos].r = r;
if (l == r) {
tree[pos].minv = tree[pos].sum = a[l];
return;
}
long long mid = (l + r) >> 1;
build(l, mid, pos << 1);
build(mid + 1, r, pos << 1 | 1);
push_up(pos);
}
void set_tag(long long pos, long long val) {
tree[pos].minv = val;
tree[pos].tag = val;
tree[pos].sum = val * tree[pos].len();
}
void push_down(long long pos) {
if (tree[pos].tag) {
set_tag(pos << 1, tree[pos].tag);
set_tag(pos << 1 | 1, tree[pos].tag);
tree[pos].tag = 0;
}
}
void update(long long L, long long R, long long val, long long pos) {
if (L <= tree[pos].l && R >= tree[pos].r) {
set_tag(pos, val);
return;
}
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
if (L <= mid) update(L, R, val, pos << 1);
if (R > mid) update(L, R, val, pos << 1 | 1);
push_up(pos);
}
long long getPos(long long val, long long pos) {
if (tree[pos].l == tree[pos].r) return tree[pos].l;
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
if (tree[pos << 1].minv >= val)
return getPos(val, pos << 1 | 1);
else
return getPos(val, pos << 1);
}
long long getSum(long long L, long long R, long long pos) {
if (L > R) return 0;
if (L <= tree[pos].l && R >= tree[pos].r) return tree[pos].sum;
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
long long ans = 0;
if (L <= mid) ans += getSum(L, R, pos << 1);
if (R > mid) ans += getSum(L, R, pos << 1 | 1);
return ans;
}
long long getAns(long long &val, long long pos) {
if (tree[pos].sum <= val) {
val -= tree[pos].sum;
return tree[pos].r - tree[pos].l + 1;
}
if (tree[pos].l == tree[pos].r) return 0;
push_down(pos);
long long mid = (tree[pos].l + tree[pos].r) >> 1;
long long ans = 0;
if (tree[pos << 1].minv <= val) ans += getAns(val, pos << 1);
if (tree[pos << 1 | 1].minv <= val) ans += getAns(val, pos << 1 | 1);
return ans;
}
} T;
signed main() {
long long op;
long long x, y;
scanf("%lld %lld", &n, &q);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
T.build(1, n, 1);
for (long long i = 1; i <= q; i++) {
scanf("%lld", &op);
if (op == 1) {
scanf("%lld %lld", &x, &y);
long long p = T.getPos(y, 1);
if (p <= x) T.update(p, x, y, 1);
} else {
scanf("%lld %lld", &x, &y);
y += T.getSum(1, x - 1, 1);
long long ans = T.getAns(y, 1) - (x - 1);
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int mi, mx, lz;
long long sm;
};
int n, q;
int a[200005];
node tree[4 * 200005];
void bld(int l = 0, int r = n, int p = 1) {
if (l == r) {
tree[p].sm = tree[p].mi = tree[p].mx = a[l];
return;
}
int mid = (l + r) >> 1;
bld(l, mid, p << 1);
bld(mid + 1, r, p << 1 | 1);
tree[p].mi = tree[p << 1 | 1].mi;
tree[p].mx = tree[p << 1].mx;
tree[p].sm = tree[p << 1].sm + tree[p << 1 | 1].sm;
}
void push(int& l, int& r, int p) {
if (!tree[p].lz) return;
tree[p].mi = tree[p].lz;
tree[p].mx = tree[p].lz;
tree[p].sm = 1LL * tree[p].lz * (r - l + 1);
if (l != r) {
tree[p << 1].lz = tree[p].lz;
tree[p << 1 | 1].lz = tree[p].lz;
}
tree[p].lz = 0;
}
void upd(int qr, int v, int l = 0, int r = n, int p = 1) {
push(l, r, p);
if (tree[p].mi >= v) return;
if (qr < l) return;
if (r <= qr && tree[p].mx <= v) {
tree[p].lz = v;
push(l, r, p);
return;
}
int mid = (l + r) >> 1;
upd(qr, v, l, mid, p << 1);
upd(qr, v, mid + 1, r, p << 1 | 1);
tree[p].mi = tree[p << 1 | 1].mi;
tree[p].mx = tree[p << 1].mx;
tree[p].sm = tree[p << 1].sm + tree[p << 1 | 1].sm;
}
pair<int, long long> qry0(int ql, int v, long long bef = 0, int l = 0,
int r = n, int p = 1) {
push(l, r, p);
if (l == r) return {l, bef};
int mid = (l + r) >> 1;
if (ql <= mid && tree[p << 1].mi <= v)
return qry0(ql, v, bef, l, mid, p << 1);
push(l, mid, p << 1);
return qry0(ql, v, bef + tree[p << 1].sm, mid + 1, r, p << 1 | 1);
}
pair<int, long long> qry1(long long lft, int l = 0, int r = n, int p = 1) {
push(l, r, p);
if (l == r) return {l, lft};
int mid = (l + r) >> 1;
push(l, mid, p << 1);
if (tree[p << 1].sm <= lft)
return qry1(lft - tree[p << 1].sm, mid + 1, r, p << 1 | 1);
return qry1(lft, l, mid, p << 1);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
bld();
int t, x, y;
while (q--) {
scanf("%d%d%d", &t, &x, &y), x--;
if (t == 1) {
upd(x, y);
} else {
int ans = 0;
while (x < n) {
auto c = qry0(x, y);
if (c.first >= n) break;
long long pref = c.second;
int st = c.first;
c = qry1(pref + y);
ans += (c.first - st);
y = c.second;
x = c.first;
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 200010, LOG = 20;
long long n, m, k, u, v, x, y, t, a, b, ans;
long long A[MAXN];
long long seg[MAXN << 2], lazy[MAXN << 2];
int Mn[MAXN << 2], Mx[MAXN << 2];
void Build(int id, int tl, int tr) {
if (tr - tl == 1) {
Mn[id] = Mx[id] = seg[id] = A[tl];
return;
}
int mid = (tl + tr) >> 1;
Build(id << 1, tl, mid);
Build(id << 1 | 1, mid, tr);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mx[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
inline void add_lazy(int id, int len, long long val) {
Mn[id] = val;
Mx[id] = val;
lazy[id] = val;
seg[id] = len * val;
}
inline void shift(int id, int tl, int tr) {
if (!lazy[id]) return;
int mid = (tl + tr) >> 1;
add_lazy(id << 1, mid - tl, lazy[id]);
add_lazy(id << 1 | 1, tr - mid, lazy[id]);
lazy[id] = 0;
}
void Maximize(int id, int tl, int tr, int pos, long long val) {
if (pos <= tl || val <= Mn[id]) return;
if (tr <= pos && Mx[id] <= val) {
add_lazy(id, tr - tl, val);
return;
}
shift(id, tl, tr);
int mid = (tl + tr) >> 1;
Maximize(id << 1, tl, mid, pos, val);
Maximize(id << 1 | 1, mid, tr, pos, val);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mx[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
int BS1(int id, int tl, int tr, int pos, long long val) {
if (tr <= pos || val < Mn[id]) return tr;
if (tr - tl == 1) return tl;
shift(id, tl, tr);
int mid = (tl + tr) >> 1, tmp = BS1(id << 1, tl, mid, pos, val);
if (tmp == mid) return BS1(id << 1 | 1, mid, tr, pos, val);
return tmp;
}
int BS2(int id, int tl, int tr, long long val) {
if (seg[id] <= val) return tr;
if (tr - tl == 1) return tl;
shift(id, tl, tr);
int mid = (tl + tr) >> 1, tmp = BS2(id << 1, tl, mid, val);
if (tmp < mid) return tmp;
return BS2(id << 1 | 1, mid, tr, val - seg[id << 1]);
}
long long Get(int id, int tl, int tr, int l, int r) {
if (r <= tl || tr <= l) return 0;
if (l <= tl && tr <= r) return seg[id];
shift(id, tl, tr);
int mid = (tl + tr) >> 1;
return Get(id << 1, tl, mid, l, r) + Get(id << 1 | 1, mid, tr, l, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> A[i];
Build(1, 1, n + 1);
while (m--) {
cin >> t >> x >> y;
if (t == 1)
Maximize(1, 1, n + 1, x + 1, y);
else {
ans = 0;
while (1) {
x = BS1(1, 1, n + 1, x, y);
if (x == n + 1) break;
long long val = y + Get(1, 1, n + 1, 1, x);
int xx = BS2(1, 1, n + 1, val);
ans += xx - x;
y -= Get(1, 1, n + 1, x, xx);
x = xx;
}
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Q;
int tag[200010 << 2], a[200010], mn[200010 << 2], mx[200010 << 2];
long long sum[200010 << 2];
void push_up(int k) {
mn[k] = mn[k << 1 | 1];
mx[k] = mx[k << 1];
sum[k] = sum[k << 1] + sum[k << 1 | 1];
}
void make_tag(int k, int l, int r, int t) {
tag[k] = t;
mx[k] = mn[k] = t;
sum[k] = 1ll * (r - l + 1) * t;
}
void push_down(int k, int l, int r) {
int mid = (l + r) >> 1;
if (tag[k] != -1) {
make_tag(k << 1, l, mid, tag[k]);
make_tag(k << 1 | 1, mid + 1, r, tag[k]);
tag[k] = -1;
}
}
void BT(int k, int l, int r) {
tag[k] = -1;
if (l == r) {
mx[k] = mn[k] = a[l];
sum[k] = a[l];
return;
}
int mid = (l + r) >> 1;
BT(k << 1, l, mid);
BT(k << 1 | 1, mid + 1, r);
push_up(k);
}
void Modify(int k, int l, int r, int L, int R, int t) {
if (l == L && r == R) {
if (l == L && r == R) make_tag(k, l, r, t);
return;
}
push_down(k, l, r);
int mid = (l + r) >> 1;
if (R <= mid)
Modify(k << 1, l, mid, L, R, t);
else if (mid < L)
Modify(k << 1 | 1, mid + 1, r, L, R, t);
else {
Modify(k << 1, l, mid, L, mid, t);
Modify(k << 1 | 1, mid + 1, r, mid + 1, R, t);
}
push_up(k);
}
int gao1(int k, int l, int r, int t) {
if (l == r) return l;
push_down(k, l, r);
int mid = (l + r) >> 1;
if (mx[k << 1 | 1] > t)
return gao1(k << 1 | 1, mid + 1, r, t);
else
return gao1(k << 1, l, mid, t);
}
int gao3(int k, int l, int r, int t) {
if (l == r) return l;
push_down(k, l, r);
int mid = (l + r) >> 1;
if (mn[k << 1] <= t) return gao3(k << 1, l, mid, t);
return gao3(k << 1 | 1, mid + 1, r, t);
}
int qu(int k, int l, int r, int &t) {
if (l == r) {
if (t >= mx[k]) {
t -= mx[k];
return l;
}
return l - 1;
}
push_down(k, l, r);
int mid = (l + r) >> 1;
if (sum[k << 1] < t) return qu(k << 1 | 1, mid + 1, r, t -= sum[k << 1]);
return qu(k << 1, l, mid, t);
}
pair<bool, int> Qu(int k, int l, int r, int L, int R, int &t) {
if (l == L && r == R) {
if (t <= sum[k] || R == n) return make_pair(1, qu(k, l, r, t));
t -= sum[k];
return make_pair(0, t);
}
push_down(k, l, r);
int mid = (l + r) >> 1;
if (R <= mid)
return Qu(k << 1, l, mid, L, R, t);
else if (mid < L)
return Qu(k << 1 | 1, mid + 1, r, L, R, t);
else {
pair<bool, int> res = Qu(k << 1, l, mid, L, mid, t);
if (res.first) return res;
return Qu(k << 1 | 1, mid + 1, r, mid + 1, R, t);
}
}
inline void rd(int &x) {
x = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
int main() {
rd(n);
rd(Q);
for (int i = 1; i <= n; ++i) rd(a[i]);
BT(1, 1, n);
int opt, x, y;
while (Q--) {
rd(opt);
rd(x);
rd(y);
if (opt == 1) {
int pos = gao1(1, 1, n, y);
if (mx[1] <= y) pos = 0;
if (pos + 1 <= x) Modify(1, 1, n, pos + 1, x, y);
} else {
int pre = x - 1, Ans = 0;
while (true) {
int pos = gao3(1, 1, n, y);
if (mn[1] > y) pos = n + 1;
pos = max(pos, pre + 1);
if (pos == n + 1) break;
int t = Qu(1, 1, n, pos, n, y).second;
Ans += t - pos + 1;
pre = t;
}
printf("%d\n", Ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int maxn = 2e5 + 100;
long long a[maxn];
struct Tree {
long long l, r, maxval, minval, sum, tag;
} tree[maxn << 2];
void push_up(long long p) {
tree[p].maxval = max(tree[p * 2].maxval, tree[p * 2 + 1].maxval);
tree[p].minval = min(tree[p * 2].minval, tree[p * 2 + 1].minval);
tree[p].sum = tree[p * 2].sum + tree[p * 2 + 1].sum;
}
int length(long long p) { return tree[p].r - tree[p].l + 1; }
void addtag(long long p, long long d) {
tree[p].tag = d;
tree[p].sum = tree[p].tag * length(p);
tree[p].maxval = tree[p].tag;
tree[p].minval = tree[p].tag;
}
void push_down(long long p) {
if (tree[p].tag != -1) {
addtag(p * 2, tree[p].tag);
addtag(p * 2 + 1, tree[p].tag);
tree[p].tag = -1;
}
}
void build(long long p, long long l, long long r) {
tree[p].l = l;
tree[p].r = r;
tree[p].maxval = -1e18;
tree[p].minval = 1e18;
tree[p].sum = 0;
tree[p].tag = -1;
if (l == r) {
tree[p].maxval = tree[p].minval = tree[p].sum = a[l];
return;
}
long long mid = (l + r) >> 1;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
push_up(p);
}
void modify(long long p, long long l, long long r, long long d) {
if (l <= tree[p].l && r >= tree[p].r) {
if (tree[p].minval >= d) return;
if (tree[p].maxval < d) {
addtag(p, d);
return;
}
}
push_down(p);
long long mid = (tree[p].l + tree[p].r) >> 1;
if (l <= mid) modify(p * 2, l, r, d);
if (r > mid) modify(p * 2 + 1, l, r, d);
push_up(p);
}
long long query(long long p, long long l, long long r, long long &y) {
if (l <= tree[p].l && r >= tree[p].r) {
if (tree[p].minval > y) return 0;
if (y >= tree[p].sum) {
y -= tree[p].sum;
return length(p);
}
if (tree[p].l == tree[p].r) return 0;
}
long long ans = 0;
push_down(p);
long long mid = (tree[p].l + tree[p].r) >> 1;
if (l <= mid) ans += query(p * 2, l, r, y);
if (r > mid) ans += query(p * 2 + 1, l, r, y);
return ans;
}
int main(void) {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (m--) {
long long op, x, y;
cin >> op >> x >> y;
if (op == 1) {
modify(1, 1, x, y);
} else if (op == 2) {
cout << query(1, x, n, y) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 2e5 + 2;
int n, q, a[N];
int lz[N << 2], mn[N << 2];
ll sum[N << 2];
void build(int id, int l, int r) {
if (l == r) {
sum[id] = mn[id] = a[l];
return;
}
int m = (l + r) >> 1;
build(id << 1, l, m);
build((id << 1) | 1, m + 1, r);
sum[id] = sum[id << 1] + sum[(id << 1) | 1];
mn[id] = min(mn[id << 1], mn[(id << 1) | 1]);
}
void dolz(int id, int l, int r) {
if (!lz[id]) return;
sum[id] = (r - l + 1) * 1LL * lz[id];
mn[id] = lz[id];
if (l != r) {
lz[id << 1] = lz[id];
lz[(id << 1) | 1] = lz[id];
}
lz[id] = 0;
}
int queryF(int id, int l, int r, int v) {
dolz(id, l, r);
if (l == r) {
if (mn[id] > v) {
assert(l == n);
return l + 1;
}
return l;
}
int m = (l + r) >> 1;
dolz(id << 1, l, m);
if (mn[id << 1] <= v) return queryF(id << 1, l, m, v);
return queryF((id << 1) | 1, m + 1, r, v);
}
void update(int id, int l, int r, int L, int R, int v) {
dolz(id, l, r);
if (l > R || r < L || L > R) return;
if (L <= l && r <= R) {
lz[id] = v;
dolz(id, l, r);
return;
}
int m = (l + r) >> 1;
update(id << 1, l, m, L, R, v);
update((id << 1) | 1, m + 1, r, L, R, v);
sum[id] = sum[id << 1] + sum[(id << 1) | 1];
mn[id] = min(mn[id << 1], mn[(id << 1) | 1]);
}
int cur = 0, ret = 0;
int query1(int id, int l, int r, int v) {
dolz(id, l, r);
if (l == r) {
if (sum[id] > v) return l - 1;
cur += sum[id];
return l;
}
int m = (l + r) >> 1;
dolz(id << 1, l, m);
if (sum[id << 1] < v) {
cur += sum[id << 1];
return query1((id << 1) | 1, m + 1, r, v - sum[id << 1]);
}
return query1(id << 1, l, m, v);
}
void query(int id, int l, int r, int L, int tot) {
if (r < L) return;
dolz(id, l, r);
if (L <= l) {
if (cur + sum[id] > tot)
ret = query1(id, l, r, tot - cur);
else
cur += sum[id];
return;
}
int m = (l + r) >> 1;
query(id << 1, l, m, L, tot);
if (ret) return;
query((id << 1) | 1, m + 1, r, L, tot);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = (1); i <= (n); ++i) cin >> a[i];
build(1, 1, n);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
int p = queryF(1, 1, n, y);
update(1, 1, n, p, x, y);
} else {
int res = 0;
cur = ret = 0;
int pL = max(x, queryF(1, 1, n, y));
query(1, 1, n, pL, y);
if (ret == 0) ret = n;
int cnt = 0;
while (ret <= n && pL <= n) {
cnt++;
if (cnt > 60) {
cout << pL << '.' << ret << '.' << cur << '\n';
return 0;
}
y -= cur;
res += ret - pL + 1;
pL = max(ret + 1, queryF(1, 1, n, y));
cur = ret = 0;
query(1, 1, n, pL, y);
if (ret == 0) ret = n;
}
cout << res << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Fastio {
struct Reader {
char endch;
Reader() { endch = '\0'; }
Reader& operator>>(char& ch) {
ch = getchar();
while (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t') ch = getchar();
return *this;
}
Reader& operator>>(char* str) {
while (((*str = getchar()) == ' ' || *str == '\n' || *str == '\r' ||
*str == '\t') &&
*str != EOF)
;
while ((*++str = getchar()) != ' ' && *str != '\n' && *str != '\r' &&
*str != '\t' && *str != EOF)
;
*str = '\0';
return *this;
}
template <typename Int>
Reader& operator>>(Int& d) {
bool flag = 0;
endch = getchar();
while ((!isdigit(endch)) && endch != '-' && endch != EOF) endch = getchar();
if (endch == '-') flag = 1, endch = getchar();
d = endch & 15;
while (isdigit(endch = getchar())) d = (d << 3) + (d << 1) + (endch & 15);
if (flag) d = -d;
return *this;
}
template <typename T>
inline T get() {
T Val;
(*this) >> Val;
return Val;
}
};
struct Writer {
Writer& operator<<(const char ch) {
putchar(ch);
return *this;
}
Writer& operator<<(const char* ch) {
while (*ch) putchar(*(ch++));
return *this;
}
Writer& operator<<(char* ss) { return *this << (const char*)ss; }
template <typename Int>
Writer& operator<<(Int x) {
static char buffer[33];
static int top = 0;
if (!x) {
putchar('0');
return *this;
}
if (x < 0) putchar('-'), x = -x;
while (x) {
buffer[++top] = '0' | (x % 10);
x /= 10;
}
while (top) putchar(buffer[top--]);
return *this;
}
};
} // namespace Fastio
Fastio::Reader kin;
Fastio::Writer kout;
const int N = 2e5 + 7;
int n, q, a[N];
namespace segt {
struct segtree_node_info {
int fir_min, sec_min;
int cnt_min;
long long sum;
} tr[N << 2];
void pushdown(int u) {
int ls = u << 1, rs = ls | 1, val = tr[u].fir_min;
if (val > tr[ls].fir_min) {
tr[ls].sum += (long long)(val - tr[ls].fir_min) * tr[ls].cnt_min;
tr[ls].fir_min = val;
}
if (val > tr[rs].fir_min) {
tr[rs].sum += (long long)(val - tr[rs].fir_min) * tr[rs].cnt_min;
tr[rs].fir_min = val;
}
}
void pushup(int u) {
int ls = u << 1, rs = ls | 1;
tr[u].sum = tr[ls].sum + tr[rs].sum;
if (tr[ls].fir_min == tr[rs].fir_min) {
tr[u].fir_min = tr[ls].fir_min;
tr[u].cnt_min = tr[ls].cnt_min + tr[rs].cnt_min;
tr[u].sec_min = min(tr[ls].sec_min, tr[rs].sec_min);
} else {
tr[u].fir_min = tr[rs].fir_min;
tr[u].cnt_min = tr[rs].cnt_min;
tr[u].sec_min = min(tr[rs].sec_min, tr[ls].fir_min);
}
}
void build(int u, int l, int r) {
if (l == r) {
tr[u].sum = tr[u].fir_min = a[l];
tr[u].sec_min = 1e9 + 7;
tr[u].cnt_min = 1;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void replace_max(int u, int l, int r, int mr, int val) {
if (r <= mr) {
if (val < tr[u].fir_min) return;
if (val < tr[u].sec_min) {
tr[u].sum += (long long)(val - tr[u].fir_min) * tr[u].cnt_min;
tr[u].fir_min = val;
return;
}
}
int mid = (l + r) >> 1;
pushdown(u);
replace_max(u << 1, l, mid, mr, val);
if (mr > mid) replace_max(u << 1 | 1, mid + 1, r, mr, val);
pushup(u);
}
int find_next_lesseq(int u, int l, int r, int ml, int val) {
if (l == r) return l;
int mid = (l + r) >> 1, ls = u << 1, rs = ls | 1;
pushdown(u);
if (ml <= mid && val >= tr[ls].fir_min)
return find_next_lesseq(ls, l, mid, ml, val);
else
return find_next_lesseq(rs, mid + 1, r, ml, val);
}
int find_next_lesseq(int pl, int value) {
if (value < tr[1].fir_min) return -1;
return find_next_lesseq(1, 1, n, pl, value);
}
int pos, *mon;
void try_to_expand_right(int u, int l, int r, int ml) {
if (l >= ml) {
if (*mon < tr[u].fir_min) return;
if (*mon >= tr[u].sum) {
*mon -= tr[u].sum;
pos = r;
return;
}
}
int mid = (l + r) >> 1;
pushdown(u);
if (ml <= mid) try_to_expand_right(u << 1, l, mid, ml);
if (pos >= mid) try_to_expand_right(u << 1 | 1, mid + 1, r, ml);
}
int try_to_expand_right(int* money, int pos_begin) {
pos = pos_begin;
mon = money;
try_to_expand_right(1, 1, n, pos_begin);
return pos;
}
} // namespace segt
signed main() {
kin >> n >> q;
for (int i = 1; i <= n; ++i) kin >> a[i];
segt::build(1, 1, n);
for (int i = 1, opt, x, y; i <= q; ++i) {
kin >> opt >> x >> y;
if (opt == 1)
segt::replace_max(1, 1, n, x, y);
else {
int ans = 0;
while (x <= n) {
x = segt::find_next_lesseq(x, y);
if (!~x) break;
int t = segt::try_to_expand_right(&y, x);
ans += t - x + 1;
x = t + 1;
}
kout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200010], bl[200010], fl[200010], fr[200010], tg[200010 / 193 + 5];
long long sc[200010 / 193 + 5];
void reslv(int u) {
sc[u] = 0;
for (int i = fl[u]; i <= fr[u]; i++) p[i] = max(p[i], tg[u]), sc[u] += p[i];
tg[u] = 0;
}
void slv(int u, int v) {
if (v <= p[fr[u]] || v <= tg[u]) return;
tg[u] = v;
if (v >= p[fl[u]]) {
sc[u] = 1ll * v * (fr[u] - fl[u] + 1);
return;
}
reslv(u);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &p[i]);
memset(fl, 0x3f, sizeof(fl));
for (int i = 1; i <= n; i++)
bl[i] = i / 193, fl[bl[i]] = min(fl[bl[i]], i),
fr[bl[i]] = max(fr[bl[i]], i);
for (int i = 1; i <= n; i++) sc[bl[i]] += p[i];
while (m-- > 0) {
int opt, v, x;
scanf("%d%d%d", &opt, &v, &x);
if (opt == 1) {
int pr = bl[v];
for (int i = 0; i < pr; i++) slv(i, x);
for (int i = fl[pr]; i <= v; i++) p[i] = max(p[i], x);
if (x > tg[pr]) reslv(pr);
} else {
int ans = 0, pr = bl[v];
if (tg[pr]) {
int pl = min(fr[pr] - v + 1, x / tg[pr]);
ans += pl, x -= pl * tg[pr];
} else
for (int i = v; i <= fr[pr]; i++)
if (x >= p[i]) x -= p[i], ans++;
for (int b = pr + 1; b <= bl[n]; b++) {
if (sc[b] <= x)
x -= sc[b], ans += fr[b] - fl[b] + 1;
else if (x < tg[b] || x < p[fr[b]])
continue;
else if (tg[b]) {
int pl = min(fr[b] - fl[b] + 1, x / tg[b]);
ans += pl, x -= pl * tg[b];
} else
for (int i = fl[b]; i <= fr[b] && x >= p[fr[b]]; i++)
if (x >= p[i]) x -= p[i], ans++;
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, h;
int l[600001], mi[600001], len[600001], r[600001], a[600001], accm[600001];
long long s[600001];
void build(int u, int lb, int rb) {
mi[u] = a[rb];
len[u] = rb - lb + 1;
if (lb == rb) {
s[u] = a[lb];
return;
}
int mid = (lb + rb) >> 1;
build(l[u] = ++h, lb, mid);
build(r[u] = ++h, mid + 1, rb);
s[u] = s[l[u]] + s[r[u]];
}
void fix(int u) {
if (accm[u]) {
mi[u] = accm[u];
s[u] = (long long)accm[u] * len[u];
}
}
void push_down(int u) {
if (accm[u]) {
accm[l[u]] = accm[r[u]] = accm[u];
accm[u] = 0;
fix(l[u]);
fix(r[u]);
}
}
int bin(int u, int lb, int rb, int val) {
if (lb == rb) return (s[u] <= val ? lb : n + 1);
push_down(u);
int mid = (lb + rb) >> 1;
if (mi[l[u]] <= val) {
return bin(l[u], lb, mid, val);
} else
return bin(r[u], mid + 1, rb, val);
}
void forcewrite(int u, int lb, int rb, int lq, int rq, int val) {
if (rq < lb || rb < lq) return;
if (lq <= lb && rb <= rq) {
accm[u] = val;
fix(u);
return;
}
push_down(u);
int mid = (lb + rb) >> 1;
forcewrite(l[u], lb, mid, lq, rq, val);
forcewrite(r[u], mid + 1, rb, lq, rq, val);
s[u] = s[l[u]] + s[r[u]];
mi[u] = min(mi[l[u]], mi[r[u]]);
}
void update(int x, int y) {
int nx = bin(0, 1, n, y);
if (nx <= x) {
forcewrite(0, 1, n, nx, x, y);
}
}
pair<int, int> query(int u, int lb, int rb, int start, int total) {
if (rb < start) return make_pair(0, 0);
if (lb == rb) {
return (s[u] <= total ? make_pair(1, (int)s[u]) : make_pair(0, 0));
}
push_down(u);
int mid = (lb + rb) >> 1;
if (start <= lb) {
if (s[l[u]] <= total) {
auto a2 = query(r[u], mid + 1, rb, start, total - (int)s[l[u]]);
return make_pair(a2.first + len[l[u]], (int)s[l[u]] + a2.second);
} else {
return query(l[u], lb, mid, start, total);
}
}
auto a1 = query(l[u], lb, mid, start, total);
pair<int, int> a2 = make_pair(0, 0);
int target = max(0, mid - start + 1);
if (a1.first == target)
a2 = query(r[u], mid + 1, rb, start, total - a1.second);
return make_pair(a1.first + a2.first, a1.second + a2.second);
}
int ask(int x, int y) {
if (x > n) return 0;
auto W = query(0, 1, n, x, y);
int tx = x + W.first;
int cnt = W.first;
int ny = y - W.second;
int nx = max(tx, bin(0, 1, n, ny));
return ask(nx, ny) + cnt;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(0, 1, n);
while (q--) {
int type, x, y;
scanf("%d%d%d", &type, &x, &y);
if (type == 1) {
update(x, y);
} else {
int nx = max(x, bin(0, 1, n, y));
printf("%d\n", ask(nx, y));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 19;
int n, q, a[N], w[N], f[N];
long long t[N];
void ch(int k, int x, int le) {
w[k] = x;
f[k] = x;
t[k] = (long long)x * le;
}
void pd(int k, int le) {
if (!w[k]) return;
ch(k << 1, w[k], le - (le >> 1));
ch(k << 1 | 1, w[k], le >> 1);
w[k] = 0;
}
void pu(int k) {
w[k] = 0;
f[k] = f[k << 1 | 1];
t[k] = t[k << 1] + t[k << 1 | 1];
}
void bd(int k = 1, int l = 1, int r = n) {
if (l == r) {
ch(k, a[l], r - l + 1);
return;
}
int h = l + r >> 1;
bd(k << 1, l, h);
bd(k << 1 | 1, h + 1, r);
pu(k);
}
void md(int L, int R, int X, int k = 1, int l = 1, int r = n) {
if (L <= l && r <= R) {
ch(k, X, r - l + 1);
return;
}
int h = l + r >> 1;
pd(k, r - l + 1);
if (L <= h) md(L, R, X, k << 1, l, h);
if (h < R) md(L, R, X, k << 1 | 1, h + 1, r);
pu(k);
}
int lb(long long x, int k = 1, int l = 1, int r = n) {
if (x < f[k]) return r + 1;
if (l == r) return l;
int h = l + r >> 1;
pd(k, r - l + 1);
if (f[k << 1] <= x)
return lb(x, k << 1, l, h);
else
return lb(x, k << 1 | 1, h + 1, r);
}
int go(long long x, int k = 1, int l = 1, int r = n) {
if (x >= t[k]) return r + 1;
if (l == r) return l;
int h = l + r >> 1;
pd(k, r - l + 1);
if (x < t[k << 1]) return go(x, k << 1, l, h);
return go(x - t[k << 1], k << 1 | 1, h + 1, r);
}
long long qu(int p, int k = 1, int l = 1, int r = n) {
if (p < l) return 0;
if (r <= p) return t[k];
int h = l + r >> 1;
pd(k, r - l + 1);
return qu(p, k << 1, l, h) + qu(p, k << 1 | 1, h + 1, r);
}
int main() {
int i, x, y, o, s;
long long z;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i = i + 1) scanf("%d", a + i);
bd();
while (q--) {
scanf("%d%d%d", &i, &x, &y);
if (i == 1) {
o = lb(y);
if (o <= x) md(o, x, y);
} else {
s = 0;
z = y;
while (1) {
z += qu(x - 1);
o = go(z);
s += o - x;
if (o > n) break;
z -= qu(o - 1);
x = lb(z);
if (x > n) break;
}
printf("%d\n", s);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
int n, m;
long long d[N << 2];
int tag[N << 2], mx[N << 2], mn[N << 2];
inline void pushdown(int o, int len) {
if (int& x = tag[o]) {
tag[o << 1] = tag[o << 1 | 1] = x;
d[o << 1] = (long long)x * ((len + 1) / 2);
d[o << 1 | 1] = (long long)x * (len / 2);
mx[o << 1] = mx[o << 1 | 1] = mn[o << 1] = mn[o << 1 | 1] = x;
x = 0;
}
}
void build(int l, int r, int o) {
if (l == r)
cin >> mx[o], d[o] = mn[o] = mx[o];
else {
const int mid = (l + r) / 2;
build(l, mid, o << 1), build(mid + 1, r, o << 1 | 1);
d[o] = d[o << 1] + d[o << 1 | 1];
mx[o] = max(mx[o << 1], mx[o << 1 | 1]);
mn[o] = min(mn[o << 1], mn[o << 1 | 1]);
}
}
void modify(int l, int r, int o, const int& L, const int& R, const int& v) {
if (mn[o] >= v) return;
if (L <= l && r <= R) {
if (mx[o] <= v) {
mx[o] = mn[o] = v;
d[o] = (r - l + 1LL) * v;
tag[o] = v;
return;
}
}
pushdown(o, r - l + 1);
const int mid = (l + r) / 2;
if (L <= mid) modify(l, mid, o << 1, L, R, v);
if (mid < R) modify(mid + 1, r, o << 1 | 1, L, R, v);
d[o] = d[o << 1] + d[o << 1 | 1];
mx[o] = max(mx[o << 1], mx[o << 1 | 1]);
mn[o] = min(mn[o << 1], mn[o << 1 | 1]);
}
long long query(int l, int r, int o, const int& L, const int& R) {
if (L <= l && r <= R) return d[o];
pushdown(o, r - l + 1);
const int mid = (l + r) / 2;
long long res = 0;
if (L <= mid) res = query(l, mid, o << 1, L, R);
if (mid < R) res += query(mid + 1, r, o << 1 | 1, L, R);
return res;
}
int find(int l, int r, int o, const int& L, const int& v) {
if (l == r) return l;
pushdown(o, r - l + 1);
const int mid = (l + r) / 2;
if (L <= mid && v >= mn[o << 1]) return find(l, mid, o << 1, L, v);
return find(mid + 1, r, o << 1 | 1, L, v);
}
int find0(int l, int r, int o, const long long& v) {
if (l == r) return v >= d[o] ? l + 1 : l;
pushdown(o, r - l + 1);
const int mid = (l + r) / 2;
if (v >= d[o << 1]) return find0(mid + 1, r, o << 1 | 1, v - d[o << 1]);
return find0(l, mid, o << 1, v);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
build(1, n, 1);
while (m--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1)
modify(1, n, 1, 1, x, y);
else {
int ans = 0;
while (x <= n && y >= mn[1]) {
int t = find(1, n, 1, x, y);
x = t;
long long pr = x == 1 ? 0 : query(1, n, 1, 1, x - 1);
t = find0(1, n, 1, pr + y);
ans += t - x;
y -= query(1, n, 1, x, t - 1);
x = t;
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
using namespace std;
double getTime() { return clock() / (double)CLOCKS_PER_SEC; };
const int mod = 1e9 + 7;
const long long INF = 3e18;
const int N = 2e5 + 5;
const int P0 = 437;
const int P1 = 343;
const int d = 400;
struct node {
int mi, ma, gift;
long long sum;
node() {
mi = gift = mod;
ma = -mod;
sum = 0;
}
};
vector<int> a;
int n, q;
vector<node> tree;
void Push(int v, int L, int R) {
if (tree[v].gift == mod) return;
int c = (L + R) / 2;
tree[v * 2].mi = tree[v * 2].ma = tree[v * 2 + 1].mi = tree[v * 2 + 1].ma =
tree[v * 2].gift = tree[v * 2 + 1].gift = tree[v].gift;
tree[v * 2].sum = (long long)(c - L) * tree[v].gift;
tree[v * 2 + 1].sum = (long long)(R - c) * tree[v].gift;
tree[v].gift = mod;
}
int F_smaller(int v, int L, int R, int k) {
if (R - L == 1) {
if (tree[v].mi > k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (tree[v * 2].mi > k) {
if (tree[v * 2 + 1].mi > k) return -1;
return F_smaller(v * 2 + 1, c, R, k);
}
return F_smaller(v * 2, L, c, k);
}
long long Get_sum(int v, int L, int R, int l, int r) {
if (L == l && R == r) return tree[v].sum;
Push(v, L, R);
int c = (L + R) / 2;
long long an = 0;
if (l < c) an += Get_sum(v * 2, L, c, l, min(r, c));
if (c < r) an += Get_sum(v * 2 + 1, c, R, max(l, c), r);
return an;
}
int F_right(int v, int L, int R, int Le, long long k, long long cur_sum) {
if (R - L == 1) {
if (tree[v].sum <= k) return L + 1;
return L;
}
Push(v, L, R);
int c = (L + R) / 2;
if (Le >= c)
return F_right(v * 2 + 1, c, R, Le, k, cur_sum - tree[v * 2].sum);
if (Le > L) {
long long Sleft = tree[v * 2].sum - cur_sum;
if (Sleft <= k) return F_right(v * 2 + 1, c, R, Le, k - Sleft, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
if (tree[v * 2].sum <= k)
return F_right(v * 2 + 1, c, R, Le, k - tree[v * 2].sum, cur_sum);
return F_right(v * 2, L, c, Le, k, cur_sum);
}
void Upd(int v, int L, int R, int l, int r, int nmax) {
if (L == l && R == r) {
tree[v].mi = tree[v].ma = tree[v].gift = nmax;
tree[v].sum = (long long)(R - L) * nmax;
return;
}
Push(v, L, R);
int c = (L + R) / 2;
if (l < c) Upd(v * 2, L, c, l, min(r, c), nmax);
if (c < r) Upd(v * 2 + 1, c, R, max(l, c), r, nmax);
tree[v].sum = tree[v * 2].sum + tree[v * 2 + 1].sum;
tree[v].mi = tree[v * 2 + 1].mi;
tree[v].ma = tree[v * 2].ma;
}
void Update(int x, int nmax) {
int pos = F_smaller(1, 0, n, nmax);
if (pos == -1 || pos > x) return;
Upd(1, 0, n, pos, x + 1, nmax);
}
void solve() {
cin >> n >> q;
a.resize(n);
tree.resize(n * 4);
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
for (int i = 0; i < (n); i++) Upd(1, 0, n, i, i + 1, a[i]);
for (int i = 0; i < (q); i++) {
long long t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1)
Update(x, y);
else {
int cnt = 0;
while (true) {
long long pos = F_smaller(1, 0, n, y);
if (pos == -1 || pos == n) break;
pos = max(pos, x);
long long Csum = 0;
if (pos) Csum = Get_sum(1, 0, n, 0, pos);
int R = F_right(1, 0, n, pos, y, Csum);
cnt += R - pos;
y -= Get_sum(1, 0, n, pos, R);
pos = R;
if (pos == n) break;
}
cout << cnt << '\n';
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int qq = 1;
while (qq--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 202020;
int n, q, a[MAXN];
map<int, pair<int, int>, greater<int> > blk;
map<int, pair<int, int>, greater<int> > mp;
int main() {
scanf("%d%d", &n, &q);
int laslen = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] != a[i - 1]) {
if (laslen) {
blk[i - laslen] = pair<int, int>(a[i - 1], laslen);
mp[a[i - 1]] = pair<int, int>(i - laslen, laslen);
}
laslen = 1;
} else
laslen++;
}
if (laslen) {
blk[n + 1 - laslen] = pair<int, int>(a[n], laslen);
mp[a[n]] = pair<int, int>(n + 1 - laslen, laslen);
}
while (q--) {
static int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 2) {
auto it = blk.lower_bound(x);
assert(it != blk.end());
int ans = 0, pos = it->first, val = it->second.first,
len = it->second.second, rig = len + pos - x, cc = min(rig, y / val);
ans += cc, y -= cc * val, pos = x + cc;
for (;;) {
it = mp.lower_bound(y);
if (it == mp.end()) break;
int oldpos = pos;
val = it->first, pos = it->second.first, rig = it->second.second;
if (pos < oldpos) {
it = blk.upper_bound(oldpos);
if (it == blk.begin() || it == blk.end()) break;
--it;
pos = it->first, val = it->second.first, rig = it->second.second;
}
cc = min(rig, y / val);
ans += cc, y -= cc * val, pos += cc;
if (cc == 0 || pos > n) break;
}
printf("%d\n", ans);
} else {
auto it = blk.lower_bound(x), nxt = it;
assert(it != blk.end()), ++nxt;
int pos = it->first, val = it->second.first, len = it->second.second,
rig = len + (pos - x) - 1;
if (val >= y) continue;
int nl = pos, nr = x;
blk.erase(it), mp.erase(val);
if (rig) {
blk[nr + 1] = pair<int, int>(val, rig);
mp[val] = pair<int, int>(nr + 1, rig);
}
for (;;) {
it = nxt;
if (it == blk.end()) break;
nxt = it, ++nxt;
if (it->second.first < y) {
nl = it->first;
mp.erase(it->second.first);
blk.erase(it);
} else if (it->second.first == y) {
it->second.second += nr - nl + 1;
mp[it->second.first].second += nr - nl + 1;
goto end_op;
} else
break;
}
blk[nl] = pair<int, int>(y, nr - nl + 1);
mp[y] = pair<int, int>(nl, nr - nl + 1);
end_op:;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 2e5 + 10;
struct tre {
long long sum;
int mn;
} tree[4 * sz];
int lazy[4 * sz], ara[sz];
void prop(int lo, int hi, int node) {
int mid = lo + hi >> 1, lft = node << 1, rgt = lft | 1;
tree[lft].mn = tree[rgt].mn = lazy[node];
tree[lft].sum = (long long)(mid - lo + 1) * lazy[node];
tree[rgt].sum = (long long)(hi - mid) * lazy[node];
lazy[lft] = lazy[rgt] = lazy[node];
lazy[node] = 0;
}
void build(int lo, int hi, int node) {
if (lo == hi) {
tree[node] = {ara[lo], ara[lo]};
return;
}
int mid = lo + hi >> 1, lft = node << 1, rgt = lft | 1;
build(lo, mid, node << 1);
build(mid + 1, hi, node << 1 | 1);
tree[node].mn = min(tree[lft].mn, tree[rgt].mn);
tree[node].sum = tree[lft].sum + tree[rgt].sum;
}
void upd(int lo, int hi, int l, int r, int v, int node) {
if (lo > r || hi < l) return;
if (lo >= l && hi <= r) {
tree[node].mn = lazy[node] = v;
tree[node].sum = (long long)(hi - lo + 1) * v;
return;
}
if (lazy[node]) prop(lo, hi, node);
int mid = lo + hi >> 1, lft = node << 1, rgt = lft | 1;
upd(lo, mid, l, r, v, lft);
upd(mid + 1, hi, l, r, v, rgt);
tree[node].mn = min(tree[lft].mn, tree[rgt].mn);
tree[node].sum = tree[lft].sum + tree[rgt].sum;
}
int qmn(int lo, int hi, int l, int r, int v, int node) {
if (lo > r || hi < l) return (1LL << 30);
if (lo == hi) return lo;
if (lazy[node]) prop(lo, hi, node);
int mid = lo + hi >> 1, lft = node << 1, rgt = lft | 1, ret = (1LL << 30);
if (tree[lft].mn <= v) ret = qmn(lo, mid, l, r, v, lft);
if (ret == (1LL << 30) && tree[rgt].mn <= v)
ret = qmn(mid + 1, hi, l, r, v, rgt);
return ret;
}
pair<int, int> query(int lo, int hi, int l, int r, int v, int node) {
if (lo > r || hi < l || tree[node].mn > v) return make_pair(v, (1LL << 30));
if (lo >= l && hi <= r && tree[node].sum <= v)
return make_pair(v - tree[node].sum, hi);
if (lazy[node]) prop(lo, hi, node);
int mid = lo + hi >> 1, lft = node << 1, rgt = lft | 1;
pair<int, int> got = query(lo, mid, l, r, v, lft),
got2 = make_pair((1LL << 30), (1LL << 30));
if ((l <= mid && got.second == mid) || l > mid)
got2 = query(mid + 1, hi, l, r, got.first, rgt);
if (got2.second != (1LL << 30))
return got2;
else
return got;
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; ++i) scanf("%d", &ara[i]);
build(1, n, 1);
while (q--) {
int typ, x, y;
scanf("%d", &typ), scanf("%d", &x), scanf("%d", &y);
if (typ == 1) {
int idx = qmn(1, n, 1, n, y, 1);
if (idx <= x) upd(1, n, idx, x, y, 1);
} else {
int ans = 0, start = x;
while (start <= n) {
int idx = qmn(1, n, start, n, y, 1);
if (idx > n) break;
pair<int, int> got = query(1, n, idx, n, y, 1);
ans += got.second - idx + 1;
y = got.first, start = got.second + 1;
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXL = 1 << 22;
char i_str[MAXL], *i_s, *i_t;
char gc() {
if (i_s == i_t) {
i_s = i_str;
i_t = i_s + fread(i_str, 1, MAXL, stdin);
return i_s == i_t ? EOF : *i_s++;
} else
return *i_s++;
}
long long read() {
long long x = 0, f = 0;
char ch = gc();
for (; ch < '0' || ch > '9'; ch = gc())
if (ch == '-') f = 1;
for (; ch >= '0' && ch <= '9'; ch = gc()) x = x * 10 + (ch ^ 48);
return f ? -x : x;
}
const long long maxn = 2e5 + 10;
long long Max[maxn << 2], Min[maxn << 2], f[maxn << 2], a[maxn];
long long sum[maxn << 2];
void tag(long long p, long long v, long long l) {
f[p] = Min[p] = Max[p] = v;
sum[p] = 1ll * l * v;
}
void pushdown(long long p, long long l) {
if (f[p]) {
tag(p << 1, f[p], l - l / 2);
tag(p << 1 | 1, f[p], l / 2);
f[p] = 0;
}
}
void pushup(long long p) {
Max[p] = max(Max[p << 1], Max[p << 1 | 1]);
Min[p] = min(Min[p << 1], Min[p << 1 | 1]);
sum[p] = sum[p << 1] + sum[p << 1 | 1];
}
void cover(long long p, long long l, long long r, long long x, long long v) {
if (Min[p] >= v) return;
if (r <= x && Max[p] <= v) return tag(p, v, r - l + 1);
pushdown(p, r - l + 1);
long long mid = (l + r) >> 1;
cover(p << 1, l, mid, x, v);
if (x > mid) cover(p << 1 | 1, mid + 1, r, x, v);
pushup(p);
}
long long qry1(long long p, long long l, long long r, long long v) {
if (l == r) return l;
pushdown(p, r - l + 1);
long long mid = (l + r) >> 1;
if (Min[p << 1] <= v)
return qry1(p << 1, l, mid, v);
else
return qry1(p << 1 | 1, mid + 1, r, v);
}
long long qry2(long long p, long long l, long long r, long long v) {
if (l == r) return l - (sum[p] > v);
pushdown(p, r - l + 1);
long long mid = (l + r) >> 1;
if (v <= sum[p << 1])
return qry2(p << 1, l, mid, v);
else
return qry2(p << 1 | 1, mid + 1, r, v - sum[p << 1]);
}
long long qry3(long long p, long long l, long long r, long long x,
long long y) {
if (x > y) return 0;
if (x <= l && r <= y) return sum[p];
pushdown(p, r - l + 1);
long long mid = (l + r) >> 1;
long long Sum = 0;
if (x <= mid) Sum += qry3(p << 1, l, mid, x, y);
if (y > mid) Sum += qry3(p << 1 | 1, mid + 1, r, x, y);
return Sum;
}
void build(long long p, long long l, long long r) {
if (l == r) {
Min[p] = Max[p] = sum[p] = a[l];
return;
}
long long mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
pushup(p);
}
signed main() {
long long n, q, opt, x, y;
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; i++) scanf("%lld", a + i);
build(1, 1, n);
for (long long i = 1; i <= q; i++) {
scanf("%lld%lld%lld", &opt, &x, &y);
if (opt == 1)
cover(1, 1, n, x, y);
else {
long long cnt = 0;
while (y >= Min[1]) {
long long L = max(qry1(1, 1, n, y), x),
R = qry2(1, 1, n, y + qry3(1, 1, n, 1, L - 1));
y -= qry3(1, 1, n, L, R);
cnt += R - L + 1;
if (R == n) break;
}
printf("%lld\n", cnt);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q, arr[200005];
struct tree {
int l, r, add, lv, rv;
long long sum;
} tr[200005 << 2];
void Add(int rt, int x) {
tr[rt].lv = tr[rt].rv = tr[rt].add = x;
tr[rt].sum = 1ll * (tr[rt].r - tr[rt].l + 1) * x;
}
void Pushdown(int rt) {
if (tr[rt].add) {
Add(rt << 1, tr[rt].add);
Add(rt << 1 | 1, tr[rt].add);
tr[rt].add = 0;
}
}
void Pushup(int rt) {
tr[rt].lv = tr[rt << 1].lv;
tr[rt].rv = tr[rt << 1 | 1].rv;
tr[rt].sum = tr[rt << 1].sum + tr[rt << 1 | 1].sum;
}
void Build(int rt, int l, int r) {
tr[rt].l = l, tr[rt].r = r;
if (l == r) {
tr[rt].sum = tr[rt].lv = tr[rt].rv = arr[l];
tr[rt].add = 0;
return;
}
int mid = (l + r) >> 1;
Build(rt << 1, l, mid), Build(rt << 1 | 1, mid + 1, r);
Pushup(rt);
}
void Modify(int rt, int x, int y) {
if (tr[rt].l > x) return;
if (tr[rt].rv >= y) return;
if (tr[rt].lv <= y && tr[rt].r <= x) return Add(rt, y);
Pushdown(rt);
Modify(rt << 1, x, y), Modify(rt << 1 | 1, x, y);
Pushup(rt);
}
int Ask(int rt, int x, int &y) {
if (y < tr[rt].rv || tr[rt].r < x) return 0;
int ret = 0;
if (tr[rt].l >= x && tr[rt].sum <= y)
return y -= tr[rt].sum, x = tr[rt].r + 1, tr[rt].r - tr[rt].l + 1;
if (tr[rt].l == tr[rt].r) return 0;
Pushdown(rt);
ret += Ask(rt << 1, x, y);
ret += Ask(rt << 1 | 1, x, y);
return ret;
}
int main() {
scanf("%d %d", &N, &Q);
for (int i = 1; i <= N; ++i) {
scanf("%d", &arr[i]);
}
Build(1, 1, N);
while (Q--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (a == 1) {
Modify(1, b, c);
} else {
printf("%d\n", Ask(1, b, c));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
const long long maxm = maxn << 3;
long long n, lzy, shu[maxn];
struct sg {
long long tree[maxm], luzy1[maxm], luzy2[maxm], luzy[maxm];
inline void pushup(long long x) {
tree[x] = tree[(x << 1)] + tree[(x << 1 | 1)];
luzy1[x] = min(luzy1[(x << 1)], luzy1[(x << 1 | 1)]);
luzy2[x] = max(luzy2[(x << 1)], luzy2[(x << 1 | 1)]);
return;
}
inline void pushdown(long long x, long long l, long long r) {
if (!luzy[x]) return;
luzy[(x << 1)] = luzy1[(x << 1)] = luzy2[(x << 1)] = luzy[(x << 1 | 1)] =
luzy1[(x << 1 | 1)] = luzy2[(x << 1 | 1)] = luzy[x];
tree[(x << 1)] = (((l + r) >> 1) - l + 1) * luzy[x],
tree[(x << 1 | 1)] = (r - ((l + r) >> 1)) * luzy[x];
luzy[x] = 0;
return;
}
void build(long long x, long long l, long long r) {
if (l == r) {
tree[x] = luzy1[x] = luzy2[x] = shu[l];
return;
}
build((x << 1), l, ((l + r) >> 1)),
build((x << 1 | 1), ((l + r) >> 1) + 1, r);
pushup(x);
return;
}
void add(long long x, long long l, long long r, long long pos,
long long jia) {
if (l > pos || luzy1[x] >= jia) return;
pushdown(x, l, r);
if (r <= pos && luzy2[x] <= jia) {
tree[x] = (luzy[x] = luzy1[x] = luzy2[x] = jia) * (r - l + 1);
return;
}
add((x << 1), l, ((l + r) >> 1), pos, jia),
add((x << 1 | 1), ((l + r) >> 1) + 1, r, pos, jia);
pushup(x);
return;
}
long long get(long long x, long long l, long long r, long long pos,
long long &ask) {
if (r < pos || luzy1[x] > ask) return 0;
pushdown(x, l, r);
if (l >= pos && ask >= tree[x]) {
ask -= tree[x];
return r - l + 1;
}
return get((x << 1), l, ((l + r) >> 1), pos, ask) +
get((x << 1 | 1), ((l + r) >> 1) + 1, r, pos, ask);
}
} tree;
signed main() {
ios::sync_with_stdio(false);
cin >> n >> lzy;
for (long long i = 1; i <= n; ++i) cin >> shu[i];
tree.build(1, 1, n);
for (long long lzv = 1, opt, x, y; lzv <= lzy; ++lzv) {
cin >> opt >> x >> y;
if (opt == 1)
tree.add(1, 1, n, x, y);
else
cout << tree.get(1, 1, n, x, y) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool d = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') d = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return d ? x : -x;
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 2e5 + 5;
int a[N], lazy[N << 2], len[N << 2], mn[N << 2];
long long sum[N << 2];
void buildtree(int k, int l, int r) {
len[k] = r - l + 1;
if (l == r) {
mn[k] = sum[k] = a[l];
return;
}
int mid = l + r >> 1;
buildtree(k << 1, l, mid);
buildtree(k << 1 | 1, mid + 1, r);
sum[k] = sum[k << 1] + sum[k << 1 | 1];
mn[k] = min(mn[k << 1], mn[k << 1 | 1]);
}
void add(int k, int x) {
sum[k] = (long long)len[k] * x;
mn[k] = lazy[k] = x;
}
void pushdown(int k) {
if (!lazy[k]) return;
add(k << 1, lazy[k]);
add(k << 1 | 1, lazy[k]);
lazy[k] = 0;
}
void change(int k, int l, int r, int L, int R, int x) {
if (l >= L && r <= R) return add(k, x);
pushdown(k);
int mid = l + r >> 1;
if (L <= mid) change(k << 1, l, mid, L, R, x);
if (R > mid) change(k << 1 | 1, mid + 1, r, L, R, x);
sum[k] = sum[k << 1] + sum[k << 1 | 1];
mn[k] = min(mn[k << 1], mn[k << 1 | 1]);
}
int find(int k, int l, int r, long long x) {
if (l == r) return l;
pushdown(k);
int mid = l + r >> 1;
if (sum[k << 1] <= x) return find(k << 1 | 1, mid + 1, r, x - sum[k << 1]);
return find(k << 1, l, mid, x);
}
int query(int k, int l, int r, int x) {
if (l == r) return l;
pushdown(k);
int mid = l + r >> 1;
if (mn[k << 1] > x) return query(k << 1 | 1, mid + 1, r, x);
return query(k << 1, l, mid, x);
}
long long ask(int k, int l, int r, int pos) {
if (pos == 0) return 0;
if (l == r) return sum[k];
pushdown(k);
int mid = l + r >> 1;
if (pos <= mid) return ask(k << 1, l, mid, pos);
return sum[k << 1] + ask(k << 1 | 1, mid + 1, r, pos);
}
int main() {
int n = read(), m = read();
for (int i = (int)(1); i <= (int)(n); i++) a[i] = read();
buildtree(1, 1, n);
for (int o = (int)(1); o <= (int)(m); o++) {
int op = read(), x = read(), y = read();
if (op == 1) {
int pos = query(1, 1, n, y);
if (pos <= x) change(1, 1, n, pos, x, y);
} else {
int pos = x, ans = 0;
while (1) {
if (y < mn[1]) break;
pos = max(pos, query(1, 1, n, y));
long long ssw = ask(1, 1, n, pos - 1);
if (sum[1] - ssw <= y) {
ans += n - pos + 1;
break;
}
int R = find(1, 1, n, ssw + y);
ssw = ask(1, 1, n, R - 1) - ssw;
ans += R - pos;
y -= ssw;
pos = R;
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <typename T>
using vec = std::vector<T>;
template <typename T>
using uset = std::unordered_set<T>;
template <typename T1, typename T2>
using umap = std::unordered_map<T1, T2>;
constexpr ll INFL = 1000000000000000069;
constexpr ll INFI = 1000000069;
const ld PI = acos(-1);
std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
vec<pair<ll, ll>> DD = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const ll N = 2e5;
ll mx[N * 4], mn[N * 4], sm[N * 4], agn[N * 4];
void build(ll v, ll l, ll r, vec<ll> &arr) {
if (r - l == 1) {
mx[v] = sm[v] = arr[l];
mn[v] = arr[l];
agn[v] = -1;
} else {
ll mid = (l + r) / 2;
build(v * 2 + 1, l, mid, arr);
build(v * 2 + 2, mid, r, arr);
mx[v] = max(mx[v * 2 + 1], mx[v * 2 + 2]);
mn[v] = min(mn[v * 2 + 1], mn[v * 2 + 2]);
sm[v] = sm[v * 2 + 1] + sm[v * 2 + 2];
agn[v] = -1;
}
}
void push(ll v, ll l, ll r) {
if (agn[v] != -1) {
mx[v] = agn[v];
mn[v] = agn[v];
sm[v] = agn[v] * (r - l);
if (r - l > 1) {
ll mid = (l + r) / 2;
agn[v * 2 + 1] = agn[v * 2 + 2] = agn[v];
}
agn[v] = -1;
}
}
void modify(ll v, ll l, ll r, ll lq, ll rq, ll x) {
push(v, l, r);
if (lq <= l && r <= rq) {
agn[v] = x;
push(v, l, r);
return;
}
if (rq <= l || r <= lq) return;
ll mid = (l + r) / 2;
modify(v * 2 + 1, l, mid, lq, rq, x);
modify(v * 2 + 2, mid, r, lq, rq, x);
mx[v] = max(mx[v * 2 + 1], mx[v * 2 + 2]);
sm[v] = sm[v * 2 + 1] + sm[v * 2 + 2];
}
ll desc(ll v, ll l, ll r, ll x) {
push(v, l, r);
if (mn[v] > x) {
return r;
}
if (r - l == 1) {
return l;
}
ll mid = (l + r) / 2;
ll ans = desc(v * 2 + 1, l, mid, x);
if (ans == mid) {
return desc(v * 2 + 2, mid, r, x);
}
return ans;
}
ll get(ll v, ll l, ll r, ll lq, ll rq) {
ll ans = 0;
if (lq <= l && r <= rq) {
return sm[v];
}
if (rq <= l || r <= lq) {
return 0;
}
ll mid = (l + r) / 2;
ans += get(v * 2 + 1, l, mid, lq, rq);
ans += get(v * 2 + 2, mid, r, lq, rq);
return ans;
}
pair<ll, ll> pizda(ll v, ll l, ll r, ll lq, ll mxx) {
push(v, l, r);
if (lq <= l && sm[v] <= mxx) {
return {r, mxx - sm[v]};
}
if (r <= lq) {
return {lq, mxx};
}
if (r - l == 1) {
return {l, mxx};
}
ll mid = (l + r) / 2;
auto ans = pizda(v * 2 + 1, l, mid, lq, mxx);
mxx = ans.second;
if (mxx && ans.first >= mid) {
auto rans = pizda(v * 2 + 2, mid, r, lq, mxx);
return rans;
}
return ans;
}
void run() {
ll n, q;
cin >> n >> q;
vec<ll> arr(n);
for (ll i = 0; i < n; i++) {
cin >> arr[i];
}
build(0, 0, n, arr);
while (q--) {
ll t, x, y;
cin >> t >> x >> y;
if (t == 1) {
ll l = desc(0, 0, n, y);
if (l < x) {
modify(0, 0, n, l, x, y);
}
} else {
ll l = desc(0, 0, n, y);
l = max(x - 1, l);
ll oy = y;
ll ans = 0;
while (l < n && y > 0) {
auto [nl, mxx] = pizda(0, 0, n, l, y);
ans += nl - l;
l = max(nl, desc(0, 0, n, mxx));
y = mxx;
}
cout << ans << '\n';
}
}
}
signed main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
ll t = 1;
while (t--) {
run();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, x, t;
long long a, y, lz[800000], sgt[800000], sgtm[800000];
bool ok;
void update(int p, int lo, int hi, int r, long long v) {
if (lz[p] >= sgtm[p]) {
sgtm[p] = lz[p];
sgt[p] = (hi - lo + 1) * lz[p];
}
if (lo > r || lz[p] >= v) return;
if (hi <= r) {
lz[p] = v;
if (lo == hi || sgtm[p] <= v) {
sgt[p] = (hi - lo + 1) * v;
sgtm[p] = v;
return;
}
if (sgtm[2 * p + 1] < v) update(2 * p, lo, (lo + hi) / 2, r, v);
update(2 * p + 1, (lo + hi) / 2 + 1, hi, r, v);
sgt[p] = sgt[2 * p] + sgt[2 * p + 1];
return;
}
lz[2 * p] = max(lz[2 * p], lz[p]);
lz[2 * p + 1] = max(lz[2 * p + 1], lz[p]);
update(2 * p, lo, (lo + hi) / 2, r, v);
update(2 * p + 1, (lo + hi) / 2 + 1, hi, r, v);
sgtm[p] = max(sgtm[2 * p], sgtm[2 * p + 1]);
sgt[p] = sgt[2 * p] + sgt[2 * p + 1];
}
int buscB(int p, int lo, int hi, int v) {
sgt[p] = max(lz[p] * (hi - lo + 1), sgt[p]);
sgtm[p] = max(lz[p], sgtm[p]);
if (hi < v) return 0;
if (lo < v) {
lz[2 * p] = max(lz[2 * p], lz[p]);
lz[2 * p + 1] = max(lz[2 * p + 1], lz[p]);
int h = buscB(2 * p, lo, (lo + hi) / 2, v);
if (ok) return h + buscB(2 * p + 1, (lo + hi) / 2 + 1, hi, v);
return h;
}
if (sgt[p] <= y) {
y -= sgt[p];
return hi - lo + 1;
}
if (lo == hi) {
ok = false;
return 0;
}
lz[2 * p] = max(lz[2 * p], lz[p]);
lz[2 * p + 1] = max(lz[2 * p + 1], lz[p]);
int h = buscB(2 * p, lo, (lo + hi) / 2, v);
if (ok) return h + buscB(2 * p + 1, (lo + hi) / 2 + 1, hi, v);
return h;
}
int prox(int p, int lo, int hi, int v) {
if (hi < v) return hi + 1;
if (lo < v) {
sgtm[2 * p] = max(sgtm[2 * p], lz[p]);
sgtm[2 * p + 1] = max(sgtm[2 * p + 1], lz[p]);
lz[2 * p] = max(lz[2 * p], lz[p]);
lz[2 * p + 1] = max(lz[2 * p + 1], lz[p]);
if ((lo + hi) / 2 < v || sgtm[2 * p + 1] > y)
return prox(2 * p + 1, (lo + hi) / 2 + 1, hi, v);
return prox(2 * p, lo, (lo + hi) / 2, v);
}
if (sgtm[p] <= y) return lo;
if (lo == hi) return hi + 1;
sgtm[2 * p] = max(sgtm[2 * p], lz[p]);
sgtm[2 * p + 1] = max(sgtm[2 * p + 1], lz[p]);
lz[2 * p] = max(lz[2 * p], lz[p]);
lz[2 * p + 1] = max(lz[2 * p + 1], lz[p]);
if (sgtm[2 * p + 1] > y) return prox(2 * p + 1, (lo + hi) / 2 + 1, hi, v);
return prox(2 * p, lo, (lo + hi) / 2, v);
}
int binS() {
int r = 0, lo = prox(1, 1, n, x), mid;
while (lo <= n) {
ok = true;
mid = buscB(1, 1, n, lo);
r += mid;
lo = prox(1, 1, n, mid + lo);
}
return r;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%lld", &a);
update(1, 1, n, i + 1, a);
}
for (int i = 0; i < q; i++) {
scanf("%d %d %lld", &t, &x, &y);
if (t == 1)
update(1, 1, n, x, y);
else
printf("%d\n", binS());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1& x, const T2& y) {
if (y < x) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1& x, const T2& y) {
if (x < y) x = y;
}
const int N = 2e5 + 10;
int n, q;
int a[N];
void read() {
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
}
struct Node {
ll sum;
int minVal;
int mod;
Node() {
sum = 0;
minVal = 0;
mod = 0;
}
Node(ll _sum, int _minVal) {
sum = _sum;
minVal = _minVal;
mod = 0;
}
};
Node merge(const Node& a, const Node& b) {
return {a.sum + b.sum, min(a.minVal, b.minVal)};
}
struct SegmentTree {
int n;
vector<Node> tree;
SegmentTree() {}
void build(int v, int tl, int tr, int* a) {
if (tl >= tr) return;
if (tl == tr - 1) {
tree[v] = Node(a[tl], a[tl]);
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm, a);
build(v * 2 + 1, tm, tr, a);
tree[v] = merge(tree[v * 2], tree[v * 2 + 1]);
}
SegmentTree(int _n, int* a) {
n = _n;
tree.resize(4 * n);
build(1, 0, n, a);
}
void push(int v) {
if (tree[v].mod == 0) return;
tree[v * 2].mod = tree[v].mod;
tree[v * 2 + 1].mod = tree[v].mod;
tree[v].mod = 0;
}
Node getVal(int v, int tl, int tr) {
if (tree[v].mod == 0) return tree[v];
return {(ll)(tr - tl) * tree[v].mod, tree[v].mod};
}
int find(int v, int tl, int tr, int l, int r, int val) {
if (tl >= r || tr <= l) return -1;
if (getVal(v, tl, tr).minVal > val) return -1;
if (tl == tr - 1) return tl;
push(v);
int tm = (tl + tr) / 2;
int ans = find(v * 2, tl, tm, l, r, val);
if (ans == -1) {
ans = find(v * 2 + 1, tm, tr, l, r, val);
}
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
return ans;
}
int find(int l, int val) { return find(1, 0, n, l, n, val); }
void upd(int v, int tl, int tr, int l, int r, int x) {
if (tl >= r || tr <= l) return;
if (tl >= l && tr <= r) {
tree[v].mod = x;
return;
}
push(v);
int tm = (tl + tr) / 2;
upd(v * 2, tl, tm, l, r, x);
upd(v * 2 + 1, tm, tr, l, r, x);
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
}
void upd(int r, int x) {
int l = find(0, x);
if (l == -1 || l > r) return;
upd(1, 0, n, l, r + 1, x);
}
ll getSum(int v, int tl, int tr, int l, int r) {
if (tl >= r || tr <= l) return 0;
if (tl >= l && tr <= r) {
return getVal(v, tl, tr).sum;
}
push(v);
int tm = (tl + tr) / 2;
ll ans = getSum(v * 2, tl, tm, l, r) + getSum(v * 2 + 1, tm, tr, l, r);
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
return ans;
}
ll getSum(int l, int r) { return getSum(1, 0, n, l, r + 1); }
int get(int v, int tl, int tr, ll sum) {
if (sum <= 0) return -1;
if (tl == tr - 1) {
if (getVal(v, tl, tr).sum <= sum) {
return tl;
} else {
return -1;
}
}
push(v);
int tm = (tl + tr) / 2;
int ans = get(v * 2 + 1, tm, tr, sum - getVal(v * 2, tl, tm).sum);
if (ans == -1) {
ans = get(v * 2, tl, tm, sum);
}
tree[v] = merge(getVal(v * 2, tl, tm), getVal(v * 2 + 1, tm, tr));
return ans;
}
int get(int l, ll sum) {
sum += getSum(0, l - 1);
int fans = get(1, 0, n, sum);
return fans - l + 1;
}
};
SegmentTree tree;
void upd() {
int r, x;
cin >> r >> x;
--r;
tree.upd(r, x);
}
void get() {
int ans = 0;
int l, sum;
cin >> l >> sum;
--l;
while (true) {
int pos = tree.find(l, sum);
if (pos == -1) break;
l = pos;
int fans = tree.get(l, sum);
sum -= tree.getSum(l, l + fans - 1);
ans += fans;
l += fans;
}
cout << ans << '\n';
}
void run() {
tree = SegmentTree(n, a);
while (q--) {
int t;
cin >> t;
if (t == 1) {
upd();
} else {
get();
}
}
}
void write() {}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cout.precision(20),
cout.setf(ios::fixed);
read();
run();
write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int n, q;
int a[maxN];
long long t[4 * maxN];
int mn[4 * maxN];
int cnt[4 * maxN];
int lazy[4 * maxN];
int mx[4 * maxN];
void merge(int v) {
mn[v] = min(mn[2 * v], mn[2 * v + 1]);
mx[v] = max(mx[2 * v], mx[2 * v + 1]);
t[v] = t[2 * v] + t[2 * v + 1];
}
void apply(int v, int x) {
lazy[v] = x;
mn[v] = x;
mx[v] = x;
t[v] = cnt[v] * 1ll * x;
}
void push(int v, int tl, int tr) {
if (tl != tr && lazy[v] != 0) {
apply(2 * v, lazy[v]);
apply(2 * v + 1, lazy[v]);
}
lazy[v] = 0;
}
void build(int v, int tl, int tr) {
if (tl == tr) {
mn[v] = a[tl];
mx[v] = a[tl];
t[v] = a[tl];
cnt[v] = 1;
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
cnt[v] = tr - tl + 1;
merge(v);
}
void do_max(int v, int tl, int tr, int l, int r, int x) {
if (tr < l || r < tl) return;
if (mn[v] >= x) return;
if (l <= tl && tr <= r && mx[v] < x) {
apply(v, x);
return;
}
push(v, tl, tr);
int tm = (tl + tr) / 2;
do_max(2 * v, tl, tm, l, r, x);
do_max(2 * v + 1, tm + 1, tr, l, r, x);
merge(v);
}
int go(int v, int tl, int tr, int l, int r, int& y) {
if (tr < l || r < tl) return 0;
push(v, tl, tr);
if (l <= tl && tr <= r) {
if (y >= t[v]) {
y -= t[v];
return cnt[v];
}
if (mn[v] > y) {
return 0;
}
}
int tm = (tl + tr) / 2;
int d1 = go(2 * v, tl, tm, l, r, y);
int d2 = go(2 * v + 1, tm + 1, tr, l, r, y);
return d1 + d2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (q--) {
int tp, x, y;
cin >> tp >> x >> y;
if (tp == 1) {
do_max(1, 1, n, 1, x, y);
} else {
cout << go(1, 1, n, x, n, y) << '\n';
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
struct Tree {
struct Node {
int min_val{0};
int add_push{0};
ll total{0};
};
vector<Node> nodes;
int base;
Tree(int n) : base(1) {
while (base <= n + 3) {
base *= 2;
}
nodes.resize(base * 2);
}
int lq, rq, vq;
void Touch(int v, int len) {
if (v < base) {
for (int s : {v * 2, v * 2 + 1}) {
nodes[s].min_val += nodes[v].add_push;
nodes[s].add_push += nodes[v].add_push;
nodes[s].total += nodes[v].add_push * ll(len) / 2;
debug() << " ["
<< "s"
": "
<< (s) << "] "
<< " ["
<< "nodes[s].total"
": "
<< (nodes[s].total) << "] "
<< " ["
<< "nodes[v].add_push"
": "
<< (nodes[v].add_push) << "] "
<< " ["
<< "len"
": "
<< (len) << "] ";
}
nodes[v].add_push = 0;
}
}
void AddRec(int lb, int rb, int v) {
if (lb >= rq || rb <= lq) {
return;
}
if (lq <= lb && rb <= rq) {
nodes[v].min_val += vq;
nodes[v].add_push += vq;
nodes[v].total += ll(vq) * (rb - lb);
debug() << " ["
<< "v"
": "
<< (v) << "] "
<< " ["
<< "nodes[v].total"
": "
<< (nodes[v].total) << "] ";
return;
}
Touch(v, rb - lb);
const int mid = (lb + rb) / 2;
AddRec(lb, mid, v * 2);
AddRec(mid, rb, v * 2 + 1);
nodes[v].min_val = nodes[v * 2 + 1].min_val;
nodes[v].total = nodes[v * 2].total + nodes[v * 2 + 1].total;
debug() << " ["
<< "v"
": "
<< (v) << "] "
<< " ["
<< "nodes[v].total"
": "
<< (nodes[v].total) << "] ";
}
void Add(int L, int R, int val) {
lq = L;
rq = R;
vq = val;
AddRec(0, base, 1);
}
int GetFirstEnough(int val) {
int v = 1;
int len = base;
while (v < base) {
Touch(v, len);
if (nodes[v * 2].min_val <= val) {
v *= 2;
} else {
v = v * 2 + 1;
}
len /= 2;
}
return v - base;
}
pii Reach(int where, int val) {
{
vi a;
int vx = where + base;
while (vx >= 1) {
a.push_back(vx);
vx /= 2;
}
int len = base;
while (!a.empty()) {
Touch(a.back(), len);
a.pop_back();
len /= 2;
}
}
int len = 1;
int v = where + base;
debug() << " ["
<< "v"
": "
<< (v) << "] "
<< " ["
<< "nodes[v].total"
": "
<< (nodes[v].total) << "] ";
ll rem = val - nodes[v].total;
while (true) {
debug() << " ["
<< "v"
": "
<< (v) << "] "
<< " ["
<< "rem"
": "
<< (rem) << "] ";
if (v == 1) {
return {2e9, 2e9};
}
if (v % 2 == 0) {
if (rem < nodes[v + 1].total) {
break;
}
rem -= nodes[v + 1].total;
}
v /= 2;
len *= 2;
}
v += 1;
while (v < base) {
Touch(v, len);
if (rem < nodes[v * 2].total) {
v *= 2;
} else {
rem -= nodes[v * 2].total;
v = v * 2 + 1;
}
len /= 2;
}
return {v - base, int(rem)};
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
cerr << fixed << setprecision(6);
int n, q;
cin >> n >> q;
Tree tree(n + 1);
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
tree.Add(i, i + 1, a);
}
while (q--) {
int type, x, y;
cin >> type >> x >> y;
debug() << " ["
<< "type"
": "
<< (type) << "] "
<< " ["
<< "x"
": "
<< (x) << "] "
<< " ["
<< "y"
": "
<< (y) << "] ";
if (type == 1) {
int cur = tree.GetFirstEnough(y - 1), last = y;
while (cur < x) {
last = tree.nodes[tree.base + cur].min_val;
int nxt = min(x, tree.GetFirstEnough(last - 1));
debug() << " ["
<< "cur"
": "
<< (cur) << "] "
<< " ["
<< "nxt"
": "
<< (nxt) << "] "
<< " ["
<< "last"
": "
<< (last) << "] ";
tree.Add(cur, nxt, y - last);
cur = nxt;
}
} else {
--x;
int cur = max(x, tree.GetFirstEnough(y));
int ans = 0;
while (cur < n) {
debug() << " ["
<< "cur"
": "
<< (cur) << "] ";
auto [first_no, rem] = tree.Reach(cur, y);
debug() << " ["
<< "first_no"
": "
<< (first_no) << "] "
<< " ["
<< "rem"
": "
<< (rem) << "] ";
y = rem;
ans += min(n, first_no) - cur;
if (first_no >= n) {
break;
}
cur = tree.GetFirstEnough(y);
}
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 2e5 + 5;
int read() {
int s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - '0';
c = getchar();
}
return s * f;
}
int n, m, Ans, Val, a[N];
struct Tree {
long long Max1, Max2, Min1, Min2, NumMax, NumMin, sum, tag;
};
struct Segment_Tree {
Tree t[N * 4];
void update(int p, int l, int r, long long val) {
t[p].Max1 += val;
t[p].Max2 += val;
t[p].Min1 += val;
t[p].Min2 += val;
t[p].sum += 1ll * val * (r - l + 1);
t[p].tag += val;
}
void updateMax(int p, int val) {
if (t[p].Max1 == t[p].Min1) t[p].Max1 = val;
if (t[p].Max2 == t[p].Min1) t[p].Max2 = val;
t[p].sum += 1ll * t[p].NumMin * (val - t[p].Min1);
t[p].Min1 = val;
}
void updateMin(int p, int val) {
if (t[p].Min1 == t[p].Max1) t[p].Min1 = val;
if (t[p].Min2 == t[p].Max1) t[p].Min2 = val;
t[p].sum += 1ll * t[p].NumMax * (val - t[p].Max1);
t[p].Max1 = val;
}
void Pushup(int p) {
int l = p << 1, r = p << 1 | 1;
t[p].sum = t[l].sum + t[r].sum;
if (t[l].Max1 > t[r].Max1) {
t[p].Max1 = t[l].Max1;
t[p].Max2 = max(t[r].Max1, t[l].Max2);
t[p].NumMax = t[l].NumMax;
}
if (t[l].Max1 < t[r].Max1) {
t[p].Max1 = t[r].Max1;
t[p].Max2 = max(t[l].Max1, t[r].Max2);
t[p].NumMax = t[r].NumMax;
}
if (t[l].Max1 == t[r].Max1) {
t[p].Max1 = t[l].Max1;
t[p].Max2 = max(t[l].Max2, t[r].Max2);
t[p].NumMax = t[l].NumMax + t[r].NumMax;
}
if (t[l].Min1 < t[r].Min1) {
t[p].Min1 = t[l].Min1;
t[p].Min2 = min(t[r].Min1, t[l].Min2);
t[p].NumMin = t[l].NumMin;
}
if (t[l].Min1 > t[r].Min1) {
t[p].Min1 = t[r].Min1;
t[p].Min2 = min(t[l].Min1, t[r].Min2);
t[p].NumMin = t[r].NumMin;
}
if (t[l].Min1 == t[r].Min1) {
t[p].Min1 = t[l].Min1;
t[p].Min2 = min(t[l].Min2, t[r].Min2);
t[p].NumMin = t[l].NumMin + t[r].NumMin;
}
}
void Pushdown(int p, int l, int r) {
int mid = (l + r) >> 1;
if (t[p].tag) {
update(p << 1, l, mid, t[p].tag);
update(p << 1 | 1, mid + 1, r, t[p].tag);
t[p].tag = 0;
}
if (t[p].Max1 < t[p << 1].Max1) updateMin(p << 1, t[p].Max1);
if (t[p].Min1 > t[p << 1].Min1) updateMax(p << 1, t[p].Min1);
if (t[p].Max1 < t[p << 1 | 1].Max1) updateMin(p << 1 | 1, t[p].Max1);
if (t[p].Min1 > t[p << 1 | 1].Min1) updateMax(p << 1 | 1, t[p].Min1);
}
void Init(int p, int x) {
t[p].Max1 = t[p].Min1 = t[p].sum = x;
t[p].Max2 = -inf;
t[p].Min2 = inf;
t[p].NumMax = t[p].NumMin = 1;
}
void Build(int p, int l, int r) {
if (l == r) {
Init(p, a[l]);
return;
}
int mid = (l + r) >> 1;
Build(p << 1, l, mid);
Build(p << 1 | 1, mid + 1, r);
Pushup(p);
}
void Add(int x, int y, int val, int p, int l, int r) {
if (y < l || x > r) return;
if (x <= l && r <= y) {
update(p, l, r, val);
return;
}
int mid = (l + r) >> 1;
Pushdown(p, l, r);
Add(x, y, val, p << 1, l, mid);
Add(x, y, val, p << 1 | 1, mid + 1, r);
Pushup(p);
}
void Max(int x, int y, int val, int p, int l, int r) {
if (y < l || x > r || t[p].Min1 >= val) return;
if (x <= l && r <= y && t[p].Min2 > val) {
updateMax(p, val);
return;
}
int mid = (l + r) >> 1;
Pushdown(p, l, r);
Max(x, y, val, p << 1, l, mid);
Max(x, y, val, p << 1 | 1, mid + 1, r);
Pushup(p);
}
void Min(int x, int y, int val, int p, int l, int r) {
if (y < l || x > r || t[p].Max1 <= val) return;
if (x <= l && r <= y && t[p].Max2 < val) {
updateMin(p, val);
return;
}
int mid = (l + r) >> 1;
Pushdown(p, l, r);
Min(x, y, val, p << 1, l, mid);
Min(x, y, val, p << 1 | 1, mid + 1, r);
Pushup(p);
}
long long Sum(int x, int y, int p, int l, int r) {
if (y < l || x > r) return 0;
if (x <= l && r <= y) return t[p].sum;
int mid = (l + r) >> 1;
Pushdown(p, l, r);
return Sum(x, y, p << 1, l, mid) + Sum(x, y, p << 1 | 1, mid + 1, r);
}
int GetMax(int x, int y, int p, int l, int r) {
if (y < l || x > r) return -inf;
if (x <= l && r <= y) return t[p].Max1;
int mid = (l + r) >> 1;
Pushdown(p, l, r);
return max(GetMax(x, y, p << 1, l, mid),
GetMax(x, y, p << 1 | 1, mid + 1, r));
}
int GetMin(int x, int y, int p, int l, int r) {
if (y < l || x > r) return inf;
if (x <= l && r <= y) return t[p].Min1;
int mid = (l + r) >> 1;
Pushdown(p, l, r);
return min(GetMin(x, y, p << 1, l, mid),
GetMin(x, y, p << 1 | 1, mid + 1, r));
}
void Query(int x, int y, int p, int l, int r) {
if (y < l || x > r) return;
if (t[p].Min1 > Val) return;
if (x <= l && r <= y) {
if (t[p].sum <= Val) {
Val -= t[p].sum;
Ans += r - l + 1;
return;
}
if (l == r) return;
int mid = (l + r) >> 1;
Pushdown(p, l, r);
Query(x, y, p << 1, l, mid);
Query(x, y, p << 1 | 1, mid + 1, r);
return;
}
int mid = (l + r) >> 1;
Pushdown(p, l, r);
Query(x, y, p << 1, l, mid);
Query(x, y, p << 1 | 1, mid + 1, r);
}
} tree;
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) a[i] = read();
tree.Build(1, 1, n);
while (m--) {
int op = read(), x = read(), y = read();
if (op == 1) tree.Max(1, x, y, 1, 1, n);
if (op == 2) {
Val = y;
Ans = 0;
tree.Query(x, n, 1, 1, n);
printf("%d\n", Ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int a[maxn];
class Node {
public:
int l, r;
long long v = 0, sum = 0, lazy = 0;
int right_v = 1 << 30, left_v = 0;
Node() {}
void init(int _l, int _r) {
l = _l;
r = _r;
if (l == r) {
right_v = left_v = v = sum = a[l];
}
}
void update(long long _v) {
if (is_leaf()) {
right_v = left_v = sum = v = _v;
} else {
sum = (r - l + 1) * _v;
right_v = left_v = lazy = _v;
}
}
bool is_leaf() const { return l == r; }
};
class XDT {
public:
Node T[maxn * 3];
long long init_tree(int l, int r, int root = 1) {
T[root].init(l, r);
if (l < r) {
int mid = (l + r) / 2;
T[root].sum =
init_tree(l, mid, root * 2) + init_tree(mid + 1, r, root * 2 + 1);
T[root].right_v = T[root * 2 + 1].right_v;
T[root].left_v = T[root * 2].left_v;
}
return T[root].sum;
}
long long update(int l, int r, int v, int root_index = 1) {
Node &root = T[root_index];
if (l > root.r || root.l > r || root.right_v >= v) return root.sum;
if (l <= root.l && root.r <= r && root.left_v <= v) {
root.update(v);
} else {
if (root.lazy > 0) {
lazy_update(root_index);
}
if (!root.is_leaf()) {
root.sum = update(l, r, v, root_index * 2) +
update(l, r, v, root_index * 2 + 1);
root.right_v = T[root_index * 2 + 1].right_v;
root.left_v = T[root_index * 2].left_v;
}
}
return root.sum;
}
void lazy_update(int root_index) {
Node &root = T[root_index];
T[root_index * 2].update(root.lazy);
T[root_index * 2 + 1].update(root.lazy);
root.lazy = 0;
}
int query(int l, int r, int &y, int root_index = 1) {
if (y == 0) return 0;
Node &root = T[root_index];
if (l > root.r || root.l > r || root.right_v > y) return 0;
if (l <= root.l && root.r <= r && root.sum <= y) {
y -= root.sum;
return root.r - root.l + 1;
} else {
if (root.lazy > 0) {
lazy_update(root_index);
}
return root.is_leaf() ? 0
: query(l, r, y, root_index * 2) +
query(l, r, y, root_index * 2 + 1);
}
}
long long get(int p, int root_index = 1) {
Node &root = T[root_index];
if (p > root.r || p < root.l) return 0;
if (root.lazy) {
return root.lazy;
} else if (root.is_leaf()) {
return root.v;
} else {
return get(p, root_index * 2) + get(p, root_index * 2 + 1);
}
}
} T;
int main() {
int n, q;
scanf("%d%d", &n, &q);
T.init_tree(1, n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
T.init_tree(1, n);
for (int i = 1; i <= q; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1 && T.get(x) < y) {
T.update(1, x, y);
}
if (t == 2) {
printf("%d\n", T.query(x, n, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long mod = 998244353;
const int inf = 1 << 31;
const int maxn = 1 << 18;
struct nd {
long long su, mx, mi, lazy;
} segT[maxn * 4];
int n;
int a[maxn];
void push(int idx, int l, int r) {
if (segT[idx].lazy) {
segT[idx].su = segT[idx].lazy * 1LL * (r - l + 1);
segT[idx].mi = segT[idx].lazy;
segT[idx].mx = segT[idx].lazy;
if (l != r) {
segT[idx << 1].lazy = segT[idx].lazy;
segT[(idx << 1) | 1].lazy = segT[idx].lazy;
}
segT[idx].lazy = 0;
}
}
void merge(int idx, int lidx, int ridx) {
segT[idx].mi = min(segT[lidx].mi, segT[ridx].mi);
segT[idx].mx = max(segT[lidx].mx, segT[ridx].mx);
segT[idx].su = segT[lidx].su + segT[ridx].su;
}
void updateSeg(int x, int y, int v, int idx = 1, int l = 0, int r = n - 1) {
push(idx, l, r);
if (x > r || y < l || segT[idx].mi >= v) return;
if (x <= l && y >= r && segT[idx].mx <= v) {
segT[idx].lazy = v;
push(idx, l, r);
return;
}
int mid = (l + r) >> 1, lidx = idx << 1, ridx = lidx | 1;
updateSeg(x, y, v, lidx, l, mid);
updateSeg(x, y, v, ridx, mid + 1, r);
merge(idx, lidx, ridx);
}
long long querySeg(int x, int y, int &v, int idx = 1, int l = 0,
int r = n - 1) {
push(idx, l, r);
if (x > r || y < l || segT[idx].mi > v) return 0;
if (x <= l && y >= r && segT[idx].su <= v) {
v -= segT[idx].su;
return (r - l + 1);
}
int mid = (l + r) >> 1, lidx = idx << 1, ridx = lidx | 1;
return querySeg(x, y, v, lidx, l, mid) + querySeg(x, y, v, ridx, mid + 1, r);
}
void build(int idx = 1, int l = 0, int r = n - 1) {
if (l == r) {
segT[idx].su = segT[idx].mi = segT[idx].mx = a[l];
segT[idx].lazy = 0;
return;
}
int mid = (l + r) >> 1, lidx = idx << 1, ridx = lidx | 1;
build(lidx, l, mid);
build(ridx, mid + 1, r);
merge(idx, lidx, ridx);
}
void solve() {
int q;
cin >> n >> q;
for (int i = 0; i < (int)(n); ++i) cin >> a[i];
build();
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1)
updateSeg(0, --x, y);
else
cout << querySeg(--x, n - 1, y) << "\n";
}
}
int main() {
int tc = 1;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int tt = 0; tt < (int)(tc); ++tt) {
solve();
}
}
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
struct LazyContext {
LazyContext(long long v = 0) { val = v; }
void reset() { val = 0; }
void operator+=(LazyContext o) { val = o.val; }
long long val;
};
struct Node {
Node() {
size = 0;
ans = 0;
mn = 2e9;
}
Node(long long v) {
size = 1;
ans = v;
mn = (int)v;
}
Node(const Node &l, const Node &r) {
ans = l.ans + r.ans;
size = l.size + r.size;
mn = std::min(l.mn, r.mn);
}
void apply(LazyContext lazy) {
ans = lazy.val * size;
mn = (int)lazy.val;
}
int size, mn;
long long ans;
};
template <class i_t, class e_t, class lazy_cont = int>
class SegmentTree {
public:
void init(std::vector<e_t> base) {
n = base.size();
h = 0;
while ((1 << h) < n) h++;
tree.resize(2 * n);
dirty.assign(n, false);
lazy.resize(n);
for (int i = 0; i < n; i++) {
tree[i + n] = i_t(base[i]);
}
for (int i = n - 1; i > 0; i--) {
tree[i] = i_t(tree[i + i], tree[i + i + 1]);
lazy[i].reset();
}
}
i_t qry(int l, int r) {
if (l >= r) return i_t();
l += n, r += n;
push(l);
push(r - 1);
i_t lp, rp;
for (; l < r; l /= 2, r /= 2) {
if (l & 1) lp = i_t(lp, tree[l++]);
if (r & 1) rp = i_t(tree[--r], rp);
}
return i_t(lp, rp);
}
void upd(int l, int r, lazy_cont lc) {
if (l >= r) return;
l += n, r += n;
push(l);
push(r - 1);
int l0 = l, r0 = r;
for (; l < r; l /= 2, r /= 2) {
if (l & 1) apply(l++, lc);
if (r & 1) apply(--r, lc);
}
build(l0);
build(r0 - 1);
}
template <class F>
std::pair<int, i_t> search(int l, int r, F f) {
if (l >= r) return std::pair<int, i_t>(r, i_t());
int lst = r;
l += n, r += n;
push(l);
push(r - 1);
static int pref[30], suf[30];
int s[2] = {0, 0};
for (; l < r; l /= 2, r /= 2) {
if (l & 1) pref[s[0]++] = l++;
if (r & 1) suf[s[1]++] = --r;
}
i_t cur;
for (int rep = 0; rep < 2; rep++) {
if (rep == 1) {
std::reverse(suf, suf + s[1]);
}
for (int id = 0; id < s[rep]; id++) {
int i = rep == 0 ? pref[id] : suf[id];
if (f(i_t(cur, tree[i]))) {
while (i < n) {
pushNode(i);
i += i;
i_t other = i_t(cur, tree[i]);
if (!f(other)) {
cur = other;
i++;
}
}
return std::pair<int, i_t>(i - n, cur);
}
cur = i_t(cur, tree[i]);
}
}
return std::pair<int, i_t>(lst, cur);
}
private:
int n, h;
std::vector<bool> dirty;
std::vector<i_t> tree;
std::vector<lazy_cont> lazy;
void apply(int p, lazy_cont &lc) {
tree[p].apply(lc);
if (p < n) {
dirty[p] = true;
lazy[p] += lc;
}
}
void push(int p) {
for (int s = h; s > 0; s--) {
int i = p >> s;
pushNode(i);
}
}
inline void pushNode(int i) {
if (dirty[i]) {
apply(i + i, lazy[i]);
apply(i + i + 1, lazy[i]);
lazy[i].reset();
dirty[i] = false;
}
}
void build(int p) {
for (p /= 2; p > 0; p /= 2) {
tree[p] = i_t(tree[p + p], tree[p + p + 1]);
if (dirty[p]) {
tree[p].apply(lazy[p]);
}
}
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n, q;
std::cin >> n >> q;
std::vector<long long> a(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
SegmentTree<Node, long long, LazyContext> tree;
tree.init(a);
while (q--) {
int t;
int x;
long long y;
std::cin >> t >> x >> y;
if (t == 1) {
int pt = tree.search(0, x, [&](const Node &node) { return node.mn < y; })
.first;
tree.upd(pt, x, LazyContext(y));
} else {
int ans = 0;
x--;
while (x < n) {
auto got =
tree.search(x, n, [&](const Node &node) { return node.ans > y; });
int pt2 = got.first;
ans += pt2 - x;
y -= got.second.ans;
x = tree.search(pt2, n, [&](const Node &node) { return node.mn <= y; })
.first;
}
std::cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int tot = 0, fh = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fh = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
tot = tot * 10 + c - '0';
c = getchar();
}
return tot * fh;
}
void getstr(char *a) {
char c = getchar();
int len = 0;
while (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
(c >= '0' && c <= '9')))
c = getchar();
while ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
(c >= '0' && c <= '9')) {
a[++len] = c;
c = getchar();
}
}
const int maxn = 200100;
int n, t, q, ans, block, num, belong[maxn];
long long a[maxn], L[2000], R[2000], sum[2000], tag[2000];
void build() {
block = sqrt(n);
num = n / block;
if (num * block != n) num++;
for (int i = 1; i <= num; i++) {
L[i] = block * (i - 1) + 1;
R[i] = block * i;
R[num] = n;
for (int j = L[i]; j <= R[i]; j++) {
belong[j] = i;
sum[i] += a[j];
}
}
}
int fd(int l, int r, int lim) {}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
build();
while (q--) {
t = read();
if (t == 1) {
int x = read();
long long y = read();
for (int i = 1; i < belong[x]; i++)
if (tag[i] == 0) {
if (a[R[i]] < y) {
if (a[L[i]] <= y) {
tag[i] = y;
sum[i] = (R[i] - L[i] + 1ll) * tag[i];
} else {
sum[i] = 0;
for (int j = L[i]; j <= R[i]; j++) {
a[j] = max(a[j], y);
sum[i] += a[j];
}
}
}
} else {
if (tag[i] < y) {
tag[i] = y;
sum[i] = (R[i] - L[i] + 1ll) * tag[i];
}
}
int cur = belong[x];
sum[cur] = 0;
for (int i = L[cur]; i <= R[cur]; i++)
if (i <= x) {
a[i] = max(a[i], max(y, tag[cur]));
sum[cur] += a[i];
} else {
a[i] = max(a[i], tag[cur]);
sum[cur] += a[i];
}
tag[cur] = 0;
} else {
int x = read();
long long y = read();
ans = 0;
int cur = belong[x];
for (int i = x; i <= R[cur]; i++) {
long long tmp = max(tag[cur], a[i]);
if (y >= tmp) {
y -= tmp;
ans++;
tmp = max(tag[cur], a[R[cur]]);
if (tmp > y) break;
}
}
for (int i = belong[x] + 1; i <= num; i++) {
long long tmp = sum[i];
if (y >= tmp) {
y -= tmp;
ans += R[i] - L[i] + 1;
} else {
tmp = max(tag[i], a[R[i]]);
if (tmp > y) continue;
for (int j = L[i]; j <= R[i]; j++) {
tmp = max(tag[i], a[j]);
if (y >= tmp) {
y -= tmp;
ans++;
tmp = max(tag[i], a[R[i]]);
if (tmp > y) break;
}
}
}
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
T sqr(T x) {
return x * x;
}
const double eps = 1e-8;
const double pi = acos(-1.);
const int inf = 1e9 + 7;
const int N = 2e5 + 20;
int n, m;
int a[N], mi[4 * N];
long long t[4 * N], how[4 * N];
inline void push(int v, int tl, int tr) {
if (!how[v]) return;
how[2 * v + 1] = how[v];
how[2 * v + 2] = how[v];
int c = (tl + tr) >> 1;
t[2 * v + 1] = how[v] * (c - tl + 1);
t[2 * v + 2] = how[v] * (tr - c);
mi[2 * v + 1] = mi[2 * v + 2] = how[v];
how[v] = 0;
}
void modify(int v, int tl, int tr, int l, int r, int h) {
if (tl > r || l > tr) return;
if (l <= tl && tr <= r) {
how[v] = h;
mi[v] = h;
t[v] = how[v] * (tr - tl + 1);
return;
}
push(v, tl, tr);
int c = (tl + tr) >> 1;
modify(2 * v + 1, tl, c, l, r, h);
modify(2 * v + 2, c + 1, tr, l, r, h);
t[v] = t[2 * v + 1] + t[2 * v + 2];
mi[v] = min(mi[2 * v + 1], mi[2 * v + 2]);
}
inline long long get(int v, int tl, int tr, int l, int r) {
if (tl > r || l > tr) return 0;
if (l <= tl && tr <= r) return t[v];
push(v, tl, tr);
int c = (tl + tr) >> 1;
return get(2 * v + 1, tl, c, l, r) + get(2 * v + 2, c + 1, tr, l, r);
}
int getPos(int L, int R, int y) {
auto f = get(0, 0, n - 1, L, L);
if (f <= y) return L;
f = get(0, 0, n - 1, R, R);
if (f > y) return R + 1;
int v = 0, tl = 0, tr = n - 1;
while (tl != tr) {
push(v, tl, tr);
int c = (tl + tr) >> 1;
if (mi[2 * v + 1] <= y) {
v = 2 * v + 1;
tr = c;
} else {
v = 2 * v + 2;
tl = c + 1;
}
}
return min(R + 1, tl);
int l = L;
int r = R;
while (l <= r) {
int c = (l + r) >> 1;
auto cur = get(0, 0, n - 1, c, c);
if (cur > y)
l = c + 1;
else
r = c - 1;
}
return l;
}
int go(int v, int tl, int tr, long long h) {
if (tl == tr) return tl;
push(v, tl, tr);
int c = (tl + tr) >> 1;
if (h >= t[2 * v + 1])
return go(2 * v + 2, c + 1, tr, h - t[2 * v + 1]);
else
return go(2 * v + 1, tl, c, h);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
modify(0, 0, n - 1, i, i, x);
}
while (m--) {
int type, x, y;
cin >> type >> x >> y;
x--;
if (type == 1) {
int l = getPos(0, x, y);
if (l <= x) modify(0, 0, n - 1, l, x, y);
} else {
int pos = getPos(x, n - 1, y);
int ans = 0;
int cnt = 0;
while (pos < n) {
cnt++;
if (get(0, 0, n - 1, pos, n - 1) <= y) {
ans += n - pos;
break;
}
long long sum = pos ? get(0, 0, n - 1, 0, pos - 1) : 0;
int l = 0;
int v = 0, tl = 0, tr = n - 1;
sum += y;
while (1) {
if (tl == tr) {
l = tl;
break;
}
push(v, tl, tr);
int c = (tl + tr) >> 1;
if (sum >= t[2 * v + 1]) {
v = 2 * v + 2;
tl = c + 1;
sum -= t[v - 1];
} else {
v = 2 * v + 1;
tr = c;
}
}
y -= get(0, 0, n - 1, pos, l - 1);
ans += l - pos;
pos = getPos(l, n - 1, y);
}
assert(cnt < 40);
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5000;
const long double eps = (1e-12);
const int logn = 21;
const double Pi = acos(-1.0);
const long long pp = 1000000000 + 7;
int lowbit(int x) { return x & (-x); }
const long long INF = 1e15 + 9;
long long n;
long long nums[MAXN];
struct node {
long long sum;
long long Min;
long long l;
long long r;
};
node tree[(MAXN << 2) + 5];
inline long long lk(long long p) { return p << 1; }
inline long long rk(long long p) { return (p << 1) | 1; }
long long tag[(MAXN << 2) + 5];
inline void push_up(long long p) {
tree[p].sum = tree[lk(p)].sum + tree[rk(p)].sum;
tree[p].Min = min(tree[lk(p)].Min, tree[rk(p)].Min);
}
inline void build(long long p, long long l, long long r) {
tag[p] = -1;
tree[p].l = l;
tree[p].r = r;
if (l == r) {
tree[p].sum = nums[l];
tree[p].Min = nums[l];
return;
}
long long mid = (l + r) >> 1;
build(lk(p), l, mid);
build(rk(p), mid + 1, r);
push_up(p);
}
inline void f(long long p, long long l, long long r, long long k) {
if (k != -1) {
tag[p] = k;
tree[p].sum = k * (r - l + 1);
tree[p].Min = k;
}
}
inline void push_down(long long p, long long l, long long r) {
long long mid = (l + r) >> 1;
f(lk(p), l, mid, tag[p]);
f(rk(p), mid + 1, r, tag[p]);
tag[p] = -1;
}
inline void update(long long nl, long long nr, long long l, long long r,
long long p, long long k) {
if (nl <= l && r <= nr) {
f(p, l, r, k);
return;
}
push_down(p, l, r);
long long mid = (l + r) >> 1;
if (nl <= mid) update(nl, nr, l, mid, lk(p), k);
if (nr > mid) update(nl, nr, mid + 1, r, rk(p), k);
push_up(p);
}
inline long long querySum(long long nl, long long nr, long long l, long long r,
long long p) {
if (nr < nl) return 0;
long long ans = 0;
if (nl <= l && r <= nr) return tree[p].sum;
long long mid = (l + r) >> 1;
push_down(p, l, r);
if (nl <= mid) ans += querySum(nl, nr, l, mid, lk(p));
if (nr > mid) ans += querySum(nl, nr, mid + 1, r, rk(p));
return ans;
}
inline long long queryMin(long long n1, long long n2, long long l, long long r,
long long par) {
long long res = LLONG_MIN;
if (n1 <= l && r <= n2) return tree[par].Min;
long long mid = (l + r) >> 1;
push_down(par, l, r);
if (n1 <= mid) res = min(res, queryMin(n1, n2, l, mid, (par << 1)));
if (n2 > mid) res = min(res, queryMin(n1, n2, mid + 1, r, ((par << 1) | 1)));
return res;
}
long long queryMnpos(long long l, long long r, long long p, long long tar,
long long liml, long long limr) {
if (l == r) {
if (queryMin(l, l, 1, n, 1) <= tar) return l;
return -1;
}
long long mid = (l + r) >> 1;
push_down(p, l, r);
long long ans = -1;
if (mid < liml) {
if (tree[rk(p)].Min <= tar)
ans = queryMnpos(mid + 1, r, rk(p), tar, liml, limr);
} else if (mid >= limr) {
if ((tree[lk(p)].Min <= tar))
ans = queryMnpos(l, mid, lk(p), tar, liml, limr);
} else {
if (tree[lk(p)].Min <= tar) {
ans = queryMnpos(l, mid, lk(p), tar, liml, limr);
}
if (tree[rk(p)].Min <= tar && ans == -1) {
ans = queryMnpos(mid + 1, r, rk(p), tar, liml, limr);
}
}
return ans;
}
long long queryAns(long long l, long long r, long long p, long long& tar,
long long nl, long long nr) {
if (tar >= tree[p].sum) {
tar -= tree[p].sum;
return r - l + 1;
}
if (l == r) {
return 0;
}
long long mid = (l + r) >> 1;
push_down(p, l, r);
long long ans = 0;
if (tree[lk(p)].Min <= tar && nl <= mid)
ans += queryAns(l, mid, lk(p), tar, nl, nr);
if (tree[rk(p)].Min <= tar && nr > mid)
ans += queryAns(mid + 1, r, rk(p), tar, nl, nr);
return ans;
}
signed main() {
long long q;
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &nums[i]);
}
build(1, 1, n);
while (q--) {
long long op, x, y;
scanf("%lld%lld%lld", &op, &x, &y);
if (op == 1) {
long long l = queryMnpos(1, n, 1, y, 1, x);
if (l != -1) update(l, x, 1, n, 1, y);
} else {
long long ans = -x + 1;
if (x > 1) y += querySum(1, x - 1, 1, n, 1);
ans += queryAns(1, n, 1, y, 1, n);
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200200;
int a[maxn];
long long sum[maxn * 4], mn[maxn * 4], laz[maxn * 4];
void print(int l, int r, int rt) {
printf("%d [%d,%d] sum %lld, mn %lld, laz %lld\n", rt, l, r, sum[rt], mn[rt],
laz[rt]);
if (l == r) return;
int mid = (l + r) / 2;
print(l, mid, rt << 1);
print(mid + 1, r, rt << 1 | 1);
}
void build(int l, int r, int rt) {
if (l == r) {
sum[rt] = mn[rt] = a[l];
return;
}
int mid = (l + r) / 2;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
mn[rt] = mn[rt << 1 | 1];
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void pushdown(int l, int r, int rt) {
if (laz[rt]) {
int mid = (l + r) / 2;
mn[rt << 1] = mn[rt << 1 | 1] = laz[rt << 1] = laz[rt << 1 | 1] = laz[rt];
sum[rt << 1] = (mid - l + 1) * laz[rt];
sum[rt << 1 | 1] = (r - mid) * laz[rt];
laz[rt] = 0;
}
}
void upd(int R, int v, int l, int r, int rt) {
if (r <= R) {
if (mn[rt] >= v) return;
if (l == r) {
sum[rt] = v * (long long)(r - l + 1);
mn[rt] = laz[rt] = v;
return;
}
pushdown(l, r, rt);
int mid = (l + r) / 2;
if (mn[rt << 1] <= v) {
sum[rt << 1 | 1] = v * (long long)(r - mid);
mn[rt << 1 | 1] = laz[rt << 1 | 1] = v;
upd(R, v, l, mid, rt << 1);
} else {
upd(R, v, mid + 1, r, rt << 1 | 1);
}
mn[rt] = mn[rt << 1 | 1];
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
return;
}
pushdown(l, r, rt);
int mid = (l + r) / 2;
upd(R, v, l, mid, rt << 1);
if (mid < R) upd(R, v, mid + 1, r, rt << 1 | 1);
mn[rt] = mn[rt << 1 | 1];
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
long long ask(int L, int& v, int l, int r, int rt) {
if (L <= l) {
if (sum[rt] <= v) {
v -= sum[rt];
return r - l + 1;
}
if (mn[rt] > v) return 0;
int mid = (l + r) / 2;
pushdown(l, r, rt);
long long ans = 0;
if (mn[rt << 1] <= v) ans += ask(L, v, l, mid, rt << 1);
ans += ask(L, v, mid + 1, r, rt << 1 | 1);
return ans;
}
int mid = (l + r) / 2;
pushdown(l, r, rt);
long long ans = 0;
if (L <= mid) ans += ask(L, v, l, mid, rt << 1);
ans += ask(L, v, mid + 1, r, rt << 1 | 1);
return ans;
}
int main(void) {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n, 1);
for (int i = 0; i < q; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
upd(x, y, 1, n, 1);
} else {
long long ans = ask(x, y, 1, n, 1);
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int seed = 131;
constexpr long long LLMAX = 2e18;
constexpr int MOD = 1e9 + 7;
constexpr double eps = 1e-8;
constexpr int MAXN = 1e6 + 10;
constexpr int hmod1 = 0x48E2DCE7;
constexpr int hmod2 = 0x60000005;
inline long long sqr(long long x) { return x * x; }
inline int sqr(int x) { return x * x; }
inline double sqr(double x) { return x * x; }
inline int mul(int x, int y) { return 1ll * x * y % MOD; }
inline int sub(int x, int y) { return x >= y ? x - y : MOD + x - y; }
inline int add(int x, int y) { return x + y >= MOD ? x + y - MOD : x + y; }
inline int dcmp(double x) {
if (fabs(x) < eps) return 0;
return (x > 0 ? 1 : -1);
}
inline long long qpow(long long a, long long n) {
long long sum = 1;
while (n) {
if (n & 1) sum = sum * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return sum;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d;
(b == 0 ? (x = 1, y = 0, d = a)
: (d = exgcd(b, a % b, y, x), y -= a / b * x));
return d;
}
int n, q;
long long tree[MAXN << 2], mn[MAXN << 2], lz[MAXN << 2];
inline void pushup(int rt) {
mn[rt] = mn[rt << 1 | 1], tree[rt] = tree[rt << 1] + tree[rt << 1 | 1];
}
inline void pushdown(int l, int r, int rt) {
if (lz[rt]) {
int mid = (l + r) >> 1;
mn[rt << 1] = mn[rt << 1 | 1] = lz[rt];
tree[rt << 1] = lz[rt] * (mid - l + 1), lz[rt << 1] = lz[rt];
tree[rt << 1 | 1] = lz[rt] * (r - mid), lz[rt << 1 | 1] = lz[rt];
lz[rt] = 0;
}
}
void update(int l, int r, int rt, int a, int b, long long c) {
if (a <= l && r <= b)
tree[rt] = c * (r - l + 1), mn[rt] = c, lz[rt] = c;
else {
pushdown(l, r, rt);
int mid = (l + r) >> 1;
if (a <= mid) update(l, (l + r) / 2, rt << 1, a, b, c);
if (mid < b) update((l + r) / 2 + 1, r, rt << 1 | 1, a, b, c);
pushup(rt);
}
}
long long query(int l, int r, int rt, int a, int b) {
if (a > b) return 0;
if (a <= l && r <= b)
return tree[rt];
else {
pushdown(l, r, rt);
int mid = (l + r) >> 1;
long long sum = 0;
if (a <= mid) sum = query(l, (l + r) / 2, rt << 1, a, b);
if (mid < b) sum += query((l + r) / 2 + 1, r, rt << 1 | 1, a, b);
pushup(rt);
return sum;
}
}
int query(int l, int r, int rt, long long a) {
if (l == r)
return l;
else {
pushdown(l, r, rt);
int ans = 0;
if (tree[rt << 1] > a)
ans = query(l, (l + r) / 2, rt << 1, a);
else
ans = query((l + r) / 2 + 1, r, rt << 1 | 1, a - tree[rt << 1]);
pushup(rt);
return ans;
}
}
int find(int l, int r, int rt, long long a) {
if (l == r)
return l;
else {
pushdown(l, r, rt);
int ans = 0;
if (mn[rt << 1] <= a)
ans = find(l, (l + r) / 2, rt << 1, a);
else
ans = find((l + r) / 2 + 1, r, rt << 1 | 1, a);
pushup(rt);
return ans;
}
}
int main(void) {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
update(1, n + 1, 1, i, i, x);
}
while (q--) {
long long t, x, y;
scanf("%I64d%I64d%I64d", &t, &x, &y);
if (t == 1) {
int p = find(1, n + 1, 1, y);
if (p <= x) update(1, n + 1, 1, p, x, y);
} else {
int p = max(x, 1ll * find(1, n + 1, 1, y)), ans = 0;
while (p <= n) {
y += query(1, n + 1, 1, 1, p - 1);
int cur = query(1, n + 1, 1, y);
y -= query(1, n + 1, 1, 1, cur - 1);
ans += cur - p;
if (cur == n + 1) break;
p = find(1, n + 1, 1, y);
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 11;
int n, q, a[N];
long long t[4 * N], w[4 * N], cur, mn[4 * N];
void push(int v, int l, int r) {
t[v] = max(t[v], w[v] * (r - l + 1));
mn[v] = max(mn[v], w[v]);
if (l != r) {
w[v + v] = max(w[v + v], w[v]);
w[v + v + 1] = max(w[v + v + 1], w[v]);
}
w[v] = 0;
}
void build(int v, int l, int r) {
if (l == r)
t[v] = a[l], mn[v] = a[l];
else {
int mid = (l + r) / 2;
build(v + v, l, mid);
build(v + v + 1, mid + 1, r);
t[v] = t[v + v] + t[v + v + 1];
mn[v] = min(mn[v + v], mn[v + v + 1]);
}
}
void upd(int v, int l, int r, int lx, int rx, int x) {
push(v, l, r);
if (r < lx or rx < l) return;
if (lx <= l and r <= rx) {
w[v] = x;
push(v, l, r);
return;
}
int mid = (l + r) / 2;
upd(v + v, l, mid, lx, rx, x);
upd(v + v + 1, mid + 1, r, lx, rx, x);
t[v] = t[v + v] + t[v + v + 1];
mn[v] = min(mn[v + v], mn[v + v + 1]);
}
int get(int v, int l, int r, int lx, int rx) {
push(v, l, r);
if (cur == 0) return 0;
if (r < lx or rx < l) return 0;
if (lx <= l and r <= rx) {
if (t[v] <= cur) {
cur -= t[v];
return r - l + 1;
}
}
if (mn[v] > cur) return 0;
if (l != r) {
int mid = (l + r) / 2;
return get(v + v, l, mid, lx, rx) + get(v + v + 1, mid + 1, r, lx, rx);
}
return 0;
}
int gett(int v, int l, int r, int pos) {
push(v, l, r);
if (l == r)
return t[v];
else {
int mid = (l + r) / 2;
if (pos <= mid)
return gett(v + v, l, mid, pos);
else
return gett(v + v + 1, mid + 1, r, pos);
}
}
void solve() {
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x, y;
cin >> x >> y;
int l = 1, r = x;
int res = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (gett(1, 1, n, mid) < y) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (res != -1) upd(1, 1, n, res, x, y);
} else {
int x, y;
cin >> x >> y;
cur = y;
cout << get(1, 1, n, x, n) << "\n";
}
}
}
int main() {
;
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
;
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, q, a[200005];
struct tree {
long long mi, mx, sum, laz, len;
} T[200005 << 2];
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
inline void upp(long long o, long long l, long long r) {
T[o].mi = min(T[(o << 1)].mi, T[(o << 1 | 1)].mi);
T[o].mx = max(T[(o << 1)].mx, T[(o << 1 | 1)].mx);
T[o].sum = T[(o << 1)].sum + T[(o << 1 | 1)].sum;
T[o].len = T[(o << 1)].len + T[(o << 1 | 1)].len;
}
void build(long long o, long long l, long long r) {
if (l == r) {
T[o].mi = T[o].mx = T[o].sum = a[l];
T[o].len = 1;
return;
}
build(o << 1, l, ((l + r) >> 1));
build(o << 1 | 1, ((l + r) >> 1) + 1, r);
upp(o, l, r);
}
inline void downn(long long o, long long l, long long r) {
if (l == r) return;
long long c = T[o].laz;
T[o].laz = 0;
T[(o << 1)].mi = T[(o << 1)].mx = T[(o << 1)].laz = c;
T[(o << 1 | 1)].mi = T[(o << 1 | 1)].mx = T[(o << 1 | 1)].laz = c;
T[(o << 1)].sum = T[(o << 1)].len * c;
T[(o << 1 | 1)].sum = T[(o << 1 | 1)].len * c;
}
void update(long long o, long long l, long long r, long long ll, long long rr,
long long k) {
if (T[o].laz) downn(o, l, r);
if (T[o].mi >= k) return;
if (ll <= l && rr >= r && T[o].mx <= k) {
T[o].mi = T[o].mx = T[o].laz = k;
T[o].sum = T[o].len * k;
return;
}
if (ll <= ((l + r) >> 1)) update((o << 1), l, ((l + r) >> 1), ll, rr, k);
if (rr > ((l + r) >> 1))
update((o << 1 | 1), ((l + r) >> 1) + 1, r, ll, rr, k);
upp(o, l, r);
}
long long query(long long o, long long l, long long r, long long ll,
long long rr, long long &k) {
if (T[o].laz) downn(o, l, r);
if (T[o].mi > k) return 0;
if (ll <= l && rr >= r && T[o].sum <= k) {
k -= T[o].sum;
return T[o].len;
}
long long ans = 0;
if (ll <= ((l + r) >> 1))
ans += query((o << 1), l, ((l + r) >> 1), ll, rr, k);
if (rr > ((l + r) >> 1))
ans += query((o << 1 | 1), ((l + r) >> 1) + 1, r, ll, rr, k);
return ans;
}
signed main() {
n = read(), q = read();
for (long long i = 1; i <= n; i++) a[i] = read();
build(1, 1, n);
while (q--) {
long long t, x, y;
t = read(), x = read(), y = read();
if (t == 1)
update(1, 1, n, 1, x, y);
else {
long long ans = query(1, 1, n, x, n, y);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void rd(T& x) {
int tmp = 1;
char c = getchar();
x = 0;
while (c > '9' || c < '0') {
if (c == '-') tmp = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= tmp;
}
const int N = 2e5 + 10;
const int M = 1e6 + 10;
int a[N];
struct node {
int Max, Min;
long long num;
} tree[N << 2];
int lazy[N << 2];
inline void pushUp(const int& rt) {
tree[rt].num = tree[rt << 1].num + tree[rt << 1 | 1].num;
tree[rt].Max = tree[rt << 1].Max > tree[rt << 1 | 1].Max
? tree[rt << 1].Max
: tree[rt << 1 | 1].Max;
tree[rt].Min = tree[rt << 1].Min < tree[rt << 1 | 1].Min
? tree[rt << 1].Min
: tree[rt << 1 | 1].Min;
}
inline void pushDown(const int& rt, int l, int r) {
if (lazy[rt]) {
int mid = l + r >> 1;
lazy[rt << 1] = lazy[rt];
tree[rt << 1].Max = tree[rt << 1].Min = lazy[rt];
tree[rt << 1].num = 1LL * (mid - l + 1) * lazy[rt];
lazy[rt << 1 | 1] = lazy[rt];
tree[rt << 1 | 1].Max = tree[rt << 1 | 1].Min = lazy[rt];
tree[rt << 1 | 1].num = 1LL * lazy[rt] * (r - mid);
lazy[rt] = 0;
}
}
void build(int rt, int l, int r) {
lazy[rt] = 0;
if (l == r) {
tree[rt].Max = tree[rt].Min = tree[rt].num = a[l];
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushUp(rt);
}
void update(int rt, int l, int r, int ql, int qr, int x) {
if (r < ql || l > qr || tree[rt].Min >= x) return;
if (ql <= l && r <= qr) {
if (x >= tree[rt].Max) {
tree[rt].Min = tree[rt].Max = x;
tree[rt].num = 1LL * (r - l + 1) * x;
lazy[rt] = x;
return;
}
tree[rt].Min = tree[rt].Min > x ? tree[rt].Min : x;
if (l == r) return;
}
pushDown(rt, l, r);
int mid = l + r >> 1;
if (ql <= mid) update(rt << 1, l, mid, ql, qr, x);
if (qr > mid) update(rt << 1 | 1, mid + 1, r, ql, qr, x);
pushUp(rt);
}
int query(int rt, int l, int r, int ql, int qr, int& sum) {
if (l > qr || r < ql || tree[rt].Min > sum) return 0;
if (ql <= l && r <= qr && tree[rt].num <= sum) {
sum -= tree[rt].num;
return r - l + 1;
}
pushDown(rt, l, r);
int mid = l + r >> 1;
if (mid >= qr)
return query(rt << 1, l, mid, ql, qr, sum);
else if (mid < ql)
return query(rt << 1 | 1, mid + 1, r, ql, qr, sum);
else
return query(rt << 1, l, mid, ql, qr, sum) +
query(rt << 1 | 1, mid + 1, r, ql, qr, sum);
}
int main() {
int n, q;
rd(n), rd(q);
for (int i = 1; i <= n; ++i) rd(a[i]);
build(1, 1, n);
while (q--) {
int op, x;
int y;
rd(op), rd(x), rd(y);
if (op == 1) {
update(1, 1, n, 1, x, y);
} else {
int ans = query(1, 1, n, x, n, y);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[1000000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T>
inline T frd(T x) {
int f = 1;
char ch = gc();
for (; ch < '0' || ch > '9'; ch = gc())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = gc()) x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}
template <typename T>
inline T read(T x) {
int f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}
inline void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 2e5;
int A[N + 10];
pair<int, int> operator+(pair<int, int> x, pair<int, int> y) {
return make_pair(x.first + y.first, y.second);
}
struct S1 {
struct node {
int Min, Max;
long long Sum;
node() { Min = 0x7f7f7f7f, Max = Sum = 0; }
node(int _Min, int _Max, long long _Sum) {
Min = _Min, Max = _Max, Sum = _Sum;
}
node operator+(node &tis) {
return node(min(Min, tis.Min), max(Max, tis.Max), Sum + tis.Sum);
}
} tree[(N << 2) + 10];
int Cov[(N << 2) + 10];
void update(int p) { tree[p] = tree[(p << 1)] + tree[(p << 1 | 1)]; }
void build(int p, int l, int r) {
if (l == r) {
tree[p] = node(A[l], A[l], A[l]);
return;
}
int mid = (l + r) >> 1;
build((p << 1), l, mid);
build((p << 1 | 1), mid + 1, r);
update(p);
}
void Add_cov(int p, int l, int r, int V) {
Cov[p] = V;
tree[p] = node(V, V, 1ll * (r - l + 1) * V);
}
void pushdown(int p, int l, int r) {
if (!Cov[p]) return;
int mid = (l + r) >> 1;
Add_cov((p << 1), l, mid, Cov[p]);
Add_cov((p << 1 | 1), mid + 1, r, Cov[p]);
Cov[p] = 0;
}
void Modify(int p, int l, int r, int L, int R, int V) {
if (L <= l && r <= R) {
if (tree[p].Min >= V) return;
if (tree[p].Max <= V) {
Add_cov(p, l, r, V);
return;
}
}
pushdown(p, l, r);
int mid = (l + r) >> 1;
if (L <= mid) Modify((p << 1), l, mid, L, R, V);
if (R > mid) Modify((p << 1 | 1), mid + 1, r, L, R, V);
update(p);
}
pair<int, int> Query(int p, int l, int r, int L, int R, int V) {
if (L <= l && r <= R) {
if (V >= tree[p].Sum) return make_pair(r - l + 1, V - tree[p].Sum);
if (V < tree[p].Min) return make_pair(0, V);
}
pushdown(p, l, r);
int mid = (l + r) >> 1;
pair<int, int> Ans = make_pair(0, V);
if (L <= mid) Ans = Ans + Query((p << 1), l, mid, L, R, Ans.second);
if (R > mid) Ans = Ans + Query((p << 1 | 1), mid + 1, r, L, R, Ans.second);
update(p);
return Ans;
}
} ST;
int main() {
int n = read(0), m = read(0);
for (int i = 1; i <= n; i++) A[i] = read(0);
ST.build(1, 1, n);
for (int i = 1; i <= m; i++) {
int type = read(0), x = read(0), y = read(0);
if (type == 1) ST.Modify(1, 1, n, 1, x, y);
if (type == 2) printf("%d\n", ST.Query(1, 1, n, x, n, y).first);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.