text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1 << 18;
struct Node {
int l, r;
ll mx, mn, sum, toSet;
Node() : l(), r(), sum(0), mx(0), mn(0), toSet(-1) {}
Node(int l, int r) : l(l), r(r), mx(0), mn(0), sum(0), toSet(-1) {}
void set(ll x) {
toSet = x;
mx = mn = x;
sum = (r - l + 1) * x;
}
};
Node tree[2 * N + 5];
void build() {
for (int i = 0; i < (N); ++i) tree[N + i] = Node(i, i);
for (int i = (N - 1); i > 0; --i)
tree[i] = Node(tree[2 * i].l, tree[2 * i + 1].r);
}
void push(int i) {
if (tree[i].toSet == -1) return;
tree[2 * i].set(tree[i].toSet);
tree[2 * i + 1].set(tree[i].toSet);
tree[i].toSet = -1;
}
void update(int i) {
tree[i].sum = tree[2 * i].sum + tree[2 * i + 1].sum;
tree[i].mx = max(tree[2 * i].mx, tree[2 * i + 1].mx);
tree[i].mn = min(tree[2 * i].mn, tree[2 * i + 1].mn);
}
void setOnSeg(int i, int l, int r, ll x) {
if (l <= tree[i].l && r >= tree[i].r) {
tree[i].set(x);
return;
}
if (l > tree[i].r || r < tree[i].l) return;
push(i);
setOnSeg(2 * i, l, r, x);
setOnSeg(2 * i + 1, l, r, x);
update(i);
}
int getFirstLower(int i, int l, ll x) {
if (l >= tree[i].r) return N;
if (x >= tree[i].mx) return max(l, tree[i].l);
if (i >= N) return N;
push(i);
if (tree[2 * i + 1].mx >= x) return getFirstLower(2 * i + 1, l, x);
int res = getFirstLower(2 * i, l, x);
if (res == N)
return getFirstLower(2 * i + 1, l, x);
else
return res;
}
void getRight(int i, int l, int r, ll &sum, int &cnt) {
if (tree[i].mn > sum) return;
if (l > tree[i].r || r < tree[i].l) return;
if (l <= tree[i].l && r >= tree[i].r && sum >= tree[i].sum) {
sum -= tree[i].sum;
cnt += tree[i].r - tree[i].l + 1;
return;
}
push(i);
getRight(2 * i, l, r, sum, cnt);
getRight(2 * i + 1, l, r, sum, cnt);
}
void solve() {
build();
int n, q;
cin >> n >> q;
for (int i = 0; i < (n); ++i) {
ll x;
cin >> x;
setOnSeg(1, i, i, x);
}
while (q--) {
int t, x;
ll y;
cin >> t >> x >> y;
--x;
if (t & 1) {
int l = getFirstLower(1, 0, y);
if (l <= x) setOnSeg(1, l, x, y);
} else {
int cnt = 0;
getRight(1, x, n - 1, y, cnt);
cout << cnt << '\n';
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void debug_out() { clog << '\n'; }
template <typename H, typename... T>
void debug_out(H head, T... tail) {
clog << " " << head;
debug_out(tail...);
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
for (auto &i : vec) os << i << ' ';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &vec) {
if (!vec.empty()) os << vec[0];
for (size_t i = 1; i < vec.size(); ++i) os << '\n' << vec[i];
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << ' ' << p.second;
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
for (auto &i : s) os << i << ' ';
return os;
}
struct SegmentTree {
int n;
vector<int> mi;
vector<int64_t> sum;
vector<int> push_value;
SegmentTree(int _n) : n(_n) {
mi.resize(4 * n);
sum.resize(4 * n);
push_value.resize(4 * n);
}
void push(int v, int tl, int tr) {
if (push_value[v]) {
push_value[v * 2] = push_value[v * 2 + 1] = push_value[v];
int mid = tl + tr >> 1;
mi[v * 2] = mi[v * 2 + 1] = push_value[v];
sum[v * 2] = 1LL * (mid - tl + 1) * push_value[v];
sum[v * 2 + 1] = 1LL * (tr - mid) * push_value[v];
push_value[v] = 0;
}
}
void update(int l, int r, int val) { update(1, 0, n - 1, l, r, val); }
void update(int v, int tl, int tr, int l, int r, int val) {
if (l > r) return;
if (tl == l && tr == r) {
push_value[v] = val;
sum[v] = 1LL * (r - l + 1) * val;
mi[v] = val;
} else {
push(v, tl, tr);
int mid = tl + tr >> 1;
update(v * 2, tl, mid, l, min(mid, r), val);
update(v * 2 + 1, mid + 1, tr, max(mid + 1, l), r, val);
mi[v] = min(mi[v * 2], mi[v * 2 + 1]);
sum[v] = sum[v * 2] + sum[v * 2 + 1];
}
}
int ask(int l, int r, int y) { return ask(1, 0, n - 1, l, r, y); }
int ask(int v, int tl, int tr, int l, int r, int y) {
if (mi[v] >= y || l > r) return -1;
if (tl == tr) return tl;
push(v, tl, tr);
int mid = tl + tr >> 1;
int ans = ask(v * 2, tl, mid, l, min(mid, r), y);
if (ans == -1) ans = ask(v * 2 + 1, mid + 1, tr, max(mid + 1, l), r, y);
return ans;
}
int query(int l, int r, int &y) { return query(1, 0, n - 1, l, r, y); }
int query(int v, int tl, int tr, int l, int r, int &y) {
if (mi[v] > y || l > r) return 0;
if (tl == tr) return y -= sum[v], 1;
if (tl == l && tr == r && y >= sum[v]) return y -= sum[v], (r - l + 1);
push(v, tl, tr);
int mid = tl + tr >> 1;
int ans = query(v * 2, tl, mid, l, min(mid, r), y);
ans += query(v * 2 + 1, mid + 1, tr, max(mid + 1, l), r, y);
return ans;
}
int get_element(int pos) { return get_element(1, 0, n - 1, pos); }
int get_element(int v, int tl, int tr, int pos) {
if (tl == tr) return sum[v];
push(v, tl, tr);
int mid = tl + tr >> 1;
if (pos <= mid) return get_element(v * 2, tl, mid, pos);
return get_element(v * 2 + 1, mid + 1, tr, pos);
}
void print_tree() {
cout << "{";
if (n) cout << get_element(1, 0, n - 1, 0);
for (int i = 1; i < n; ++i) cout << ", " << get_element(1, 0, n - 1, i);
cout << "}\n";
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
SegmentTree st(n);
for (int i = 0; i < n; ++i) {
int val;
cin >> val;
st.update(i, i, val);
}
while (q--) {
int type, x, y;
cin >> type >> x >> y;
--x;
if (type == 1) {
int pos = st.ask(0, x, y);
if (pos != -1) st.update(pos, x, y);
} else {
int ans = st.query(x, n - 1, y);
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int inf = (1 << 30) - 1;
const ll INF = (1LL << 60) - 1;
template <typename T>
bool chmax(T &x, const T &y) {
return (x < y) ? (x = y, true) : false;
};
template <typename T>
bool chmin(T &x, const T &y) {
return (x > y) ? (x = y, true) : false;
};
struct io_setup {
io_setup() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
}
} io_setup;
template <typename T>
struct Node {
int l, r;
vector<T> v, s;
T base;
Node(int l, int r, const vector<T> &v) : l(l), r(r), v(v), base(-INF) {
s.resize(r - l + 1);
recalc();
}
void recalc() {
s[r - l] = 0;
for (int i = r - l - 1; i >= 0; i--) s[i] = s[i + 1] + v[i];
}
T get(int i) { return base == -INF ? v[i] : base; }
void update() {
for (int i = 0; i < r - l; i++) v[i] = get(i);
base = -INF;
}
void rmq(int R, const T &x) {
if (R <= l) return;
R -= l, chmin(R, r - l);
if (get(R - 1) >= x) return;
if (R == r - l) {
if (x >= get(0)) {
base = x;
return;
}
update();
for (int i = 0; i < R; i++) chmax(v[i], x);
recalc();
return;
}
update();
for (int i = 0; i < R; i++) chmax(v[i], x);
recalc();
}
T rsq(int L) {
if (L >= r) return 0;
L -= l, chmax(L, 0);
return base == -INF ? s[L] : base * (r - l - L);
}
};
template <typename T>
struct Data {
int n, m;
vector<Node<T>> nodes;
vector<T> s;
Data(int n, const vector<T> &v) : n(n) {
m = 0;
while (m * m < n) m++;
for (int i = 0; i < m; i++) {
int l = min(n, m * i), r = min(n, m * (i + 1));
nodes.emplace_back(l, r, vector<T>(begin(v) + l, begin(v) + r));
}
s.resize(m + 1), rmq(n, 0);
}
void rmq(int R, const T &x) {
for (auto &e : nodes) e.rmq(R, x);
s[m] = 0;
for (int i = m - 1; i >= 0; i--) s[i] = s[i + 1] + nodes[i].rsq(0);
}
T rsq(int L) {
int k = L / m + 1;
return s[k] + nodes[k - 1].rsq(L);
}
T get(int i) { return nodes[i / m].get(i % m); }
};
int main() {
int N, Q;
cin >> N >> Q;
vector<ll> a(N);
for (int i = 0; i < N; i++) cin >> a[i];
Data<ll> D(N, a);
while (Q--) {
int q, x;
ll y;
cin >> q >> x >> y;
if (q == 1) {
D.rmq(x, y);
} else {
x--;
int ans = 0;
while (x < N) {
int l = x - 1, r = N;
while (r - l > 1) {
int m = (l + r) / 2;
(D.get(m) <= y ? r : l) = m;
}
if (r == N) break;
x = r;
ll S = D.rsq(x);
l = x + 1, r = N + 1;
while (r - l > 1) {
int m = (l + r) / 2;
(D.rsq(m) >= S - y ? l : r) = m;
}
ans += l - x, x = l, y -= S - D.rsq(l);
}
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
const long long Mod = 1000000007;
long long a[maxn << 2], lazy[maxn << 2], mn[maxn << 2], mx[maxn << 2];
long long zuo[maxn << 2], you[maxn << 2];
void pushup(int rt) {
a[rt] = a[rt << 1] + a[rt << 1 | 1];
mn[rt] = min(mn[rt << 1], mn[rt << 1 | 1]);
mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
}
void build(int rt, int l, int r) {
lazy[rt] = 0;
zuo[rt] = l;
you[rt] = r;
if (l == r) {
long long x;
scanf("%lld", &x);
a[rt] = x;
mn[rt] = x;
mx[rt] = x;
return;
}
int mid = (l + r) / 2;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void pushdown(int rt) {
if (lazy[rt]) {
mn[rt << 1] = lazy[rt];
mn[rt << 1 | 1] = lazy[rt];
mx[rt << 1] = lazy[rt];
mx[rt << 1 | 1] = lazy[rt];
a[rt << 1] = 1ll * (you[rt << 1] - zuo[rt << 1] + 1ll) * lazy[rt];
lazy[rt << 1] = lazy[rt];
a[rt << 1 | 1] =
1ll * (you[rt << 1 | 1] - zuo[rt << 1 | 1] + 1ll) * lazy[rt];
lazy[rt << 1 | 1] = lazy[rt];
lazy[rt] = 0;
}
}
void upd(int rt, int l, int r, int L, int R, long long val) {
if (r < L || l > R) return;
if (r <= R && l >= L && mx[rt] < val) {
mn[rt] = val;
mx[rt] = val;
a[rt] = 1ll * (you[rt] - zuo[rt] + 1ll) * val;
lazy[rt] = val;
return;
}
pushdown(rt);
int mid = (l + r) / 2;
if (mn[rt << 1] < val) upd(rt << 1, l, mid, L, R, val);
if (mn[rt << 1 | 1] < val) upd(rt << 1 | 1, mid + 1, r, L, R, val);
pushup(rt);
}
int n;
long long lv;
int sum;
void query(int rt, int l, int r, int L, int R) {
if (r < L) return;
if (l > R) return;
if (L <= l && r <= R && a[rt] <= lv) {
sum += (you[rt] - zuo[rt] + 1);
lv -= a[rt];
return;
}
if (l == r) return;
int mid = (l + r) / 2;
pushdown(rt);
if (mn[rt << 1] <= lv) query(rt << 1, l, mid, L, R);
if (mn[rt << 1 | 1] <= lv) query(rt << 1 | 1, mid + 1, r, L, R);
pushup(rt);
}
int main() {
int q;
scanf("%d%d", &n, &q);
build(1, 1, n);
int op, x;
long long y;
while (q--) {
scanf("%d%d%lld", &op, &x, &y);
if (op == 1) {
upd(1, 1, n, 1, x, y);
} else {
lv = y;
sum = 0;
query(1, 1, n, x, n);
printf("%d\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chmin(T &x, const T &y) {
if (x > y) x = y;
}
template <typename T>
void chmax(T &x, const T &y) {
if (x < y) x = y;
}
inline long long read() {
long long 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;
}
const long long N = 2e5 + 10;
long long n, q;
struct Segment_Tree {
long long l, r, dat, minn, maxx, tag;
} t[N << 2];
inline void up(long long p) {
t[p].dat = t[(p << 1)].dat + t[(p << 1 | 1)].dat;
t[p].minn = t[(p << 1 | 1)].minn;
t[p].maxx = t[(p << 1)].maxx;
}
inline void down(long long p) {
if (!t[p].tag) return;
long long x = t[p].tag;
t[p].tag = 0;
t[(p << 1)].tag = t[(p << 1 | 1)].tag = x;
t[(p << 1)].maxx = t[(p << 1 | 1)].minn = t[(p << 1)].minn =
t[(p << 1 | 1)].maxx = x;
t[(p << 1)].dat = (t[(p << 1)].r - t[(p << 1)].l + 1) * x;
t[(p << 1 | 1)].dat = (t[(p << 1 | 1)].r - t[(p << 1 | 1)].l + 1) * x;
}
inline void build(long long p, long long l, long long r) {
t[p].l = l, t[p].r = r;
if (l == r) return (void)(t[p].dat = t[p].maxx = t[p].minn = read());
long long mid = (l + r) >> 1;
build((p << 1), l, mid), build((p << 1 | 1), mid + 1, r);
up(p);
}
inline void modify(long long p, long long l, long long r, long long x) {
if (l <= t[p].l && t[p].r <= r && t[p].maxx <= x) {
t[p].tag = t[p].maxx = t[p].minn = x;
t[p].dat = (t[p].r - t[p].l + 1) * x;
return;
}
down(p);
long long mid = (t[p].l + t[p].r) >> 1;
if (l <= mid && t[(p << 1)].minn <= x) modify((p << 1), l, r, x);
if (r > mid && t[(p << 1 | 1)].minn <= x) modify((p << 1 | 1), l, r, x);
up(p);
}
inline long long query(long long p, long long l, long long r, long long &val) {
if (l <= t[p].l && t[p].r <= r && val >= t[p].dat) {
val -= t[p].dat;
return t[p].r - t[p].l + 1;
}
down(p);
long long mid = (t[p].l + t[p].r) >> 1, res = 0;
if (l <= mid && t[(p << 1)].minn <= val) res += query((p << 1), l, r, val);
if (r > mid && t[(p << 1 | 1)].minn <= val)
res += query((p << 1 | 1), l, r, val);
return res;
}
signed main() {
n = read(), q = read();
build(1, 1, n);
long long opt, x, y;
while (q--) {
opt = read(), x = read(), y = read();
if (opt == 1)
modify(1, 1, x, y);
else
cout << query(1, x, n, y) << endl;
}
return 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
long long A[200201], seg[530000], mn[530000], lazy[530000];
void Init(int n, int l, int r) {
if (l == r) {
seg[n] = mn[n] = A[r];
return;
}
int mid = l + r >> 1;
Init(n << 1, l, mid);
Init(n << 1 | 1, mid + 1, r);
seg[n] = seg[n << 1] + seg[n << 1 | 1];
mn[n] = min(mn[n << 1], mn[n << 1 | 1]);
}
void Propagate(int n, int l, int r) {
if (lazy[n]) {
if (l != r) {
lazy[n << 1] = lazy[n];
lazy[n << 1 | 1] = lazy[n];
}
seg[n] = lazy[n] * (r - l + 1);
mn[n] = lazy[n];
lazy[n] = 0;
}
}
void Update(int L, int R, long long val, int n, int l, int r) {
Propagate(n, l, r);
if (r < L || R < l) return;
if (L <= l && r <= R) {
lazy[n] = val;
Propagate(n, l, r);
return;
}
int mid = l + r >> 1;
Update(L, R, val, n << 1, l, mid);
Update(L, R, val, n << 1 | 1, mid + 1, r);
seg[n] = seg[n << 1] + seg[n << 1 | 1];
mn[n] = min(mn[n << 1], mn[n << 1 | 1]);
}
pair<long long, long long> Query(int L, int R, int n, int l, int r) {
Propagate(n, l, r);
if (r < L || R < l) return {0, 1234567890};
if (L <= l && r <= R) return {seg[n], mn[n]};
int mid = l + r >> 1;
auto le = Query(L, R, n << 1, l, mid),
ri = Query(L, R, n << 1 | 1, mid + 1, r);
return {le.first + ri.first, min(le.second, ri.second)};
}
long long Sum(int L, int R, int n, int l, int r) {
Propagate(n, l, r);
if (r < L || R < l) return 0;
if (L <= l && r <= R) return seg[n];
int mid = l + r >> 1;
return Sum(L, R, n << 1, l, mid) + Sum(L, R, n << 1 | 1, mid + 1, r);
}
long long Min(int L, int R, int n, int l, int r) {
Propagate(n, l, r);
if (r < L || R < l) return 1234567890;
if (L <= l && r <= R) return mn[n];
int mid = l + r >> 1;
return min(Min(L, R, n << 1, l, mid), Min(L, R, n << 1 | 1, mid + 1, r));
}
int Lower(int k, int n, int l, int r) {
Propagate(n, l, r);
if (l == r) return r;
int mid = l + r >> 1;
Propagate(n << 1, l, mid);
if (mn[n << 1] <= k) return Lower(k, n << 1, l, mid);
return Lower(k, n << 1 | 1, mid + 1, r);
}
int Find(long long k, int n, int l, int r) {
Propagate(n, l, r);
if (l == r) return r;
int mid = l + r >> 1;
Propagate(n << 1 | 1, mid + 1, r);
if (seg[n << 1 | 1] >= k) return Find(k, n << 1 | 1, mid + 1, r);
return Find(k - seg[n << 1 | 1], n << 1, l, mid);
}
int main() {
scanf("%d %d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%lld", &A[i]);
Init(1, 1, N);
while (Q--) {
int t, x, y;
scanf("%d %d %d", &t, &x, &y);
if (t == 1) {
if (mn[1] <= y - 1) {
int idx = Lower(y - 1, 1, 1, N);
if (idx <= x) Update(idx, x, y, 1, 1, N);
}
} else if (t == 2) {
int res = 0;
while (mn[1] <= y) {
x = max(x, Lower(y, 1, 1, N));
long long sum = Sum(x, N, 1, 1, N);
if (sum <= y) {
res += N - x + 1;
break;
}
int idx = Find(sum - y, 1, 1, N) - 1;
assert(x <= idx);
res += idx - x + 1;
y -= Sum(x, idx, 1, 1, N);
x = idx + 1;
}
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200000 + 10];
const int N = 800000 + 10;
struct segtree {
int minn[N], laze[N];
long long sum[N];
void pushdown(int l, int r, int rt) {
if (laze[rt]) {
int mid = (l + r) / 2;
minn[rt * 2] = minn[rt * 2 + 1] = laze[rt];
sum[rt * 2] = (long long)laze[rt] * (mid - l + 1);
sum[rt * 2 + 1] = (long long)laze[rt] * (r - mid);
laze[rt * 2] = laze[rt * 2 + 1] = laze[rt];
laze[rt] = 0;
}
return;
}
void pushup(int l, int r, int rt) {
minn[rt] = min(minn[rt * 2], minn[rt * 2 + 1]);
sum[rt] = sum[rt * 2] + sum[rt * 2 + 1];
return;
}
void build(int l, int r, int rt) {
if (l == r) {
minn[rt] = sum[rt] = a[l];
return;
}
int mid = (l + r) / 2;
build(l, mid, rt * 2);
build(mid + 1, r, rt * 2 + 1);
pushup(l, r, rt);
}
void updata(int l, int r, int ql, int qr, int val, int rt) {
if (ql <= l && qr >= r) {
minn[rt] = val;
sum[rt] = (long long)(r - l + 1) * val;
laze[rt] = val;
return;
}
pushdown(l, r, rt);
int mid = (l + r) / 2;
if (ql <= mid) updata(l, mid, ql, qr, val, rt * 2);
if (qr > mid) updata(mid + 1, r, ql, qr, val, rt * 2 + 1);
pushup(l, r, rt);
}
int qry_minpos(int l, int r, int ql, int qr, int val, int rt) {
if (l == r) return l;
pushdown(l, r, rt);
int mid = (l + r) / 2;
if (ql <= mid && minn[rt * 2] <= val)
return qry_minpos(l, mid, ql, qr, val, rt * 2);
else
return qry_minpos(mid + 1, r, ql, qr, val, rt * 2 + 1);
pushup(l, r, rt);
}
long long qry_sum(int l, int r, int ql, int qr, int rt) {
if (l >= ql && r <= qr) return sum[rt];
pushdown(l, r, rt);
int mid = (l + r) / 2;
long long ans = 0;
if (ql <= mid) ans += qry_sum(l, mid, ql, qr, rt * 2);
if (qr > mid) ans += qry_sum(mid + 1, r, ql, qr, rt * 2 + 1);
pushup(l, r, rt);
return ans;
}
int qry_rpos(int l, int r, long long val, int rt) {
if (l == r) return l;
pushdown(l, r, rt);
int mid = (l + r) / 2;
int ans = 0;
if (sum[rt * 2] <= val)
ans = qry_rpos(mid + 1, r, val - sum[rt * 2], rt * 2 + 1);
else
ans = qry_rpos(l, mid, val, rt * 2);
pushup(l, r, rt);
return ans;
}
} seg;
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 + 1); i++) {
cin >> a[i];
}
seg.build(1, n + 1, 1);
while (q--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) {
int pos = seg.qry_minpos(1, n + 1, 1, n, y, 1);
seg.updata(1, n + 1, pos, x, y, 1);
} else {
int ans = 0;
while (x <= n) {
int pos = seg.qry_minpos(1, n + 1, x, n, y, 1);
long long presum = 0;
if (pos != 1) presum = seg.qry_sum(1, n + 1, 1, pos - 1, 1);
int r = seg.qry_rpos(1, n + 1, y + presum, 1);
y -= seg.qry_sum(1, n + 1, 1, r - 1, 1) - presum;
ans += r - pos;
x = r;
}
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 10;
int n, m;
int w[N];
struct node {
int l, r;
long long val;
int fmin, fmax;
long long lazy;
} t[N << 2];
void pushdown(node& op, long long lazy) {
if (op.fmin >= lazy) return;
lazy = max(lazy, op.lazy);
op.val = lazy * (op.r - op.l + 1);
op.fmin = lazy, op.fmax = lazy;
op.lazy = lazy;
}
void pushdown(int x) {
if (!t[x].lazy) return;
pushdown(t[x << 1], t[x].lazy);
pushdown(t[x << 1 | 1], t[x].lazy);
t[x].lazy = 0;
}
void pushup(node& p, node& l, node& r) {
p.val = l.val + r.val;
p.fmin = min(l.fmin, r.fmin), p.fmax = max(l.fmax, r.fmax);
}
void pushup(int x) { pushup(t[x], t[x << 1], t[x << 1 | 1]); }
void build(int l, int r, int x = 1) {
if (l == r) {
t[x] = {l, r, w[l], w[l], w[l], 0};
return;
}
t[x] = {l, r, 0, 0, 0, 0};
int mid = l + r >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
pushup(x);
}
void modify(int l, int r, int c, int x = 1) {
if (l <= t[x].l && r >= t[x].r) {
if (t[x].fmax < c) {
pushdown(t[x], c);
return;
}
}
if (t[x].fmin >= c) return;
pushdown(x);
int mid = t[x].l + t[x].r >> 1;
if (l <= mid) modify(l, r, c, x << 1);
if (r > mid) modify(l, r, c, x << 1 | 1);
pushup(x);
}
int ask(int l, int r, int& have, int x = 1) {
if (l <= t[x].l && r >= t[x].r) {
if (have < t[x].fmin) return 0;
if (have >= t[x].val) {
have -= t[x].val;
return t[x].r - t[x].l + 1;
}
if (t[x].l == t[x].r) return 0;
}
pushdown(x);
int mid = t[x].l + t[x].r >> 1;
int res = 0;
if (l <= mid) res += ask(l, r, have, x << 1);
if (r > mid) res += ask(l, r, have, x << 1 | 1);
return res;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= (n); ++i) scanf("%d", &w[i]);
build(1, n);
while (m--) {
int op, x, y;
scanf("%d %d %d", &op, &x, &y);
if (op == 1)
modify(1, x, y);
else
printf("%d\n", ask(x, n, y));
}
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].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")
using namespace std;
using ld = long double;
using ll = int64_t;
using pii = pair<int, int>;
using ull = uint64_t;
constexpr int SZ = 500;
int n, a[200200];
int tag[200200 / SZ + 5];
ll sum[200200];
inline void apply(int bi) {
int tg = tag[bi];
if (tg != -1) {
tag[bi] = -1;
const int upper = min(n, (bi + 1) * SZ);
const int lower = bi * SZ;
for (int i = upper - 1; i >= lower; --i) {
if (a[i] >= tg) break;
sum[bi] += tg - a[i];
a[i] = tg;
}
}
}
inline ll get_sum(int bi) {
if (tag[bi] != -1) {
const int upper = min(n, (bi + 1) * SZ);
const int lower = bi * SZ;
return tag[bi] * ll(upper - lower);
}
return sum[bi];
}
inline int get_min(int bi) {
if (tag[bi] != -1) return tag[bi];
const int upper = min(n, (bi + 1) * SZ);
return a[upper - 1];
}
inline int get_max(int bi) {
if (tag[bi] != -1) return tag[bi];
const int lower = bi * SZ;
return a[lower];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int q;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> a[i];
tag[i / SZ] = -1;
sum[i / SZ] += a[i];
}
const int BLOCKS = (n + SZ - 1) / SZ;
while (q--) {
int tp, x, y;
cin >> tp >> x >> y;
--x;
if (tp == 1) {
int bi = x / SZ;
apply(bi);
int lower = bi * SZ;
for (int i = x; i >= lower; --i) {
int nval = max(a[i], y);
sum[bi] += nval - a[i];
a[i] = nval;
}
for (; bi--;) {
if (get_max(bi) < y) {
tag[bi] = y;
} else {
apply(bi);
int upper = min(n, (bi + 1) * SZ);
int lower = bi * SZ;
for (int i = upper - 1; i >= lower; --i) {
if (a[i] >= y) break;
sum[bi] += y - a[i];
a[i] = y;
}
}
}
} else {
int bi = x / SZ;
apply(bi);
int ans = 0;
int upper = min(n, (bi + 1) * SZ);
for (int i = x; i < upper; ++i) {
if (a[i] <= y) {
y -= a[i];
++ans;
}
}
for (++bi; bi < BLOCKS; ++bi) {
int upper = min(n, (bi + 1) * SZ);
int lower = bi * SZ;
ll cursum = get_sum(bi);
if (cursum <= y) {
y -= cursum;
ans += upper - lower;
} else if (get_min(bi) <= y) {
apply(bi);
for (int i = lower; i < upper; ++i) {
if (a[i] <= y) {
y -= a[i];
++ans;
}
}
}
}
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int MAXN = 2e5 + 7;
int n, q, a[MAXN], lz[4 * MAXN], mx[4 * MAXN];
long long sum[4 * MAXN];
void lp(int g, int l, int r, int mid) {
if (lz[g]) {
lz[g * 2] = lz[g];
lz[g * 2 + 1] = lz[g];
mx[g * 2] = lz[g];
mx[g * 2 + 1] = lz[g];
sum[g * 2] = 1LL * (mid - l + 1) * lz[g];
sum[g * 2 + 1] = 1LL * (r - mid) * lz[g];
lz[g] = 0;
}
}
void upd(int g, int l, int r, int d, int c, int val) {
if (l > c || r < d) return;
if (d <= l && r <= c) {
mx[g] = val;
lz[g] = val;
sum[g] = 1LL * (r - l + 1) * val;
return;
}
int mid = (l + r) >> 1;
lp(g, l, r, mid);
upd(g * 2, l, mid, d, c, val);
upd(g * 2 + 1, mid + 1, r, d, c, val);
sum[g] = sum[g * 2] + sum[g * 2 + 1];
mx[g] = max(mx[g * 2], mx[g * 2 + 1]);
}
long long get_sum(int g, int l, int r, int pos) {
if (l > pos) return 0;
if (r <= pos) return sum[g];
int mid = (l + r) >> 1;
lp(g, l, r, mid);
return get_sum(g * 2, l, mid, pos) + get_sum(g * 2 + 1, mid + 1, r, pos);
}
int get_max(int g, int l, int r, int pos) {
if (l == r) return mx[g];
int mid = (l + r) >> 1;
lp(g, l, r, mid);
if (pos <= mid) return get_max(g * 2, l, mid, pos);
return get_max(g * 2 + 1, mid + 1, r, pos);
}
int get_pos(int g, int l, int r, long long val) {
if (l == r) {
return (sum[g] <= val ? l : -1);
}
int mid = (l + r) >> 1;
lp(g, l, r, mid);
if (sum[g * 2] <= val)
return max(mid, get_pos(g * 2 + 1, mid + 1, r, val - sum[g * 2]));
return get_pos(g * 2, l, mid, val);
}
void build(int g, int l, int r) {
lz[g] = 0;
if (l == r) {
sum[g] = mx[g] = a[l];
return;
}
int mid = (l + r) >> 1;
build(g * 2, l, mid);
build(g * 2 + 1, mid + 1, r);
sum[g] = sum[g * 2] + sum[g * 2 + 1];
mx[g] = max(mx[g * 2], mx[g * 2 + 1]);
}
int get_nxt(int g, int l, int r, int val) {
if (l == r) return (mx[g] <= val ? l : n + 7);
int mid = (l + r) >> 1;
lp(g, l, r, mid);
if (mx[g * 2 + 1] > val) return get_nxt(g * 2 + 1, mid + 1, r, val);
return min(mid + 1, get_nxt(g * 2, l, mid, val));
}
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);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
int lo = 1, hi = x;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (get_max(1, 1, n, mid) >= y)
lo = mid + 1;
else
hi = mid - 1;
}
upd(1, 1, n, hi + 1, x, y);
} else {
int res = 0;
x = max(get_nxt(1, 1, n, y), x);
while (y && x <= n) {
long long now = get_sum(1, 1, n, x - 1);
int nxt = get_pos(1, 1, n, now + y);
if (nxt < x) break;
res += (nxt - x + 1);
y -= (get_sum(1, 1, n, nxt) - now);
x = max(get_nxt(1, 1, n, y), nxt + 1);
}
cout << res << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 1e2;
void fin() {}
const bool flag = 0;
const int N = 2e5 + 10;
ll t[N << 2], tag[N << 2], mn[N << 2], a[N], n;
void build(int u = 0, int l = 0, int r = n) {
if (r - l == 1) {
t[u] = a[l];
mn[u] = a[l];
return;
}
int m = l + r >> 1;
build(u + u + 1, l, m);
build(u + u + 2, m, r);
t[u] = t[u + u + 1] + t[u + u + 2];
mn[u] = min(mn[u + u + 1], mn[u + u + 2]);
}
void push(int u, int l, int r) {
if (r - l == 1 || !tag[u]) return;
int m = l + r >> 1;
t[u + u + 1] = tag[u] * (m - l);
t[u + u + 2] = tag[u] * (r - m);
mn[u + u + 1] = tag[u];
mn[u + u + 2] = tag[u];
tag[u + u + 1] = tag[u];
tag[u + u + 2] = tag[u];
tag[u] = 0;
}
void modify(int l, int r, int first, int u = 0, int ul = 0, int ur = n) {
push(u, ul, ur);
if (l >= ur || ul >= r) return;
if (l <= ul && ur <= r) {
t[u] = first * 1ll * (ur - ul);
mn[u] = first;
tag[u] = first;
return;
}
int um = ul + ur >> 1;
modify(l, r, first, u + u + 1, ul, um);
modify(l, r, first, u + u + 2, um, ur);
t[u] = t[u + u + 1] + t[u + u + 2];
mn[u] = min(mn[u + u + 1], mn[u + u + 2]);
}
int second;
int get(int l, int u = 0, int ul = 0, int ur = n) {
push(u, ul, ur);
if (l >= ur || mn[u] > second) return 0;
if (t[u] <= second && l <= ul) {
second -= t[u];
return ur - ul;
}
int um = ul + ur >> 1;
return get(l, u + u + 1, ul, um) + get(l, u + u + 2, um, ur);
}
int getpos(int pos, int u = 0, int l = 0, int r = n) {
push(u, l, r);
if (r - l == 1) return t[u];
int m = l + r >> 1;
if (pos < m)
return getpos(pos, u + u + 1, l, m);
else
return getpos(pos, u + u + 2, m, r);
}
void ma1n() {
int q;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
build();
for (int t, first; q--;) {
cin >> t >> first >> second;
if (t == 1) {
int l = 0;
int r = first - 1;
int pos = first;
while (l <= r) {
int m = l + r >> 1;
if (getpos(m) < second) {
pos = m, r = m - 1;
} else {
l = m + 1;
}
}
if (pos < first) modify(pos, first, second);
} else {
cout << get(first - 1) << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr), fin();
int ts = 1;
if (flag) {
cin >> ts;
}
while (ts--) {
ma1n();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
const int INF = 1e9 + 7, N = 2e5 + 7;
struct node {
long long sum;
int mn, lz, islz;
node(int val = 0) {
sum = val;
mn = val;
islz = lz = 0;
}
} t[N * 4];
int a[N], n, q;
void pull(int v) {
t[v].sum = t[v * 2].sum + t[v * 2 + 1].sum;
t[v].mn = min(t[v * 2].mn, t[v * 2 + 1].mn);
}
void apply(int v, int val, int tl, int tr) {
t[v].islz = 1;
t[v].lz = t[v].mn = val;
t[v].sum = (long long)val * (tr - tl);
}
void push(int v, int tl, int tr) {
if (t[v].islz) {
int tm = (tl + tr) / 2;
apply(v * 2, t[v].lz, tl, tm);
apply(v * 2 + 1, t[v].lz, tm, tr);
t[v].islz = 0;
}
}
void build(int v = 1, int tl = 0, int tr = n + 1) {
if (tr - tl == 1) {
t[v] = node(a[tl]);
} else {
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm, tr);
pull(v);
}
}
int find_first_less(int val, int v = 1, int tl = 0, int tr = n + 1) {
if (tr - tl == 1) {
assert(t[v].mn < val);
return tl;
}
push(v, tl, tr);
int tm = (tl + tr) / 2;
if (t[v * 2].mn < val)
return find_first_less(val, v * 2, tl, tm);
else
return find_first_less(val, v * 2 + 1, tm, tr);
}
void upd(int l, int r, int val, int v = 1, int tl = 0, int tr = n + 1) {
if (l <= tl && tr <= r) {
apply(v, val, tl, tr);
} else {
push(v, tl, tr);
int tm = (tl + tr) / 2;
if (l < tm) upd(l, r, val, v * 2, tl, tm);
if (r > tm) upd(l, r, val, v * 2 + 1, tm, tr);
pull(v);
}
}
void go_right(int l, int r, int& sum, int& cnt, int v = 1, int tl = 0,
int tr = n + 1) {
if (t[v].mn > sum) return;
if (l <= tl && tr <= r && t[v].sum <= sum) {
sum -= t[v].sum;
cnt += tr - tl;
return;
}
push(v, tl, tr);
int tm = (tl + tr) / 2;
if (l < tm) go_right(l, r, sum, cnt, v * 2, tl, tm);
if (r > tm) go_right(l, r, sum, cnt, v * 2 + 1, tm, tr);
}
signed main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
build();
while (q--) {
int t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
int first = find_first_less(y);
if (first <= x) upd(first, x + 1, y);
} else {
int cnt = 0;
go_right(x, n, y, cnt);
cout << cnt << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 10;
int n, m;
int w[N];
struct node {
int l, r;
long long val;
int fmin, fmax;
long long lazy;
} t[N << 2];
void pushdown(node& op, long long lazy) {
if (op.fmin >= lazy) return;
lazy = max(lazy, op.lazy);
op.val = lazy * (op.r - op.l + 1);
op.fmin = lazy, op.fmax = lazy;
op.lazy = lazy;
}
void pushdown(int x) {
if (!t[x].lazy) return;
pushdown(t[x << 1], t[x].lazy);
pushdown(t[x << 1 | 1], t[x].lazy);
t[x].lazy = 0;
}
void pushup(node& p, node& l, node& r) {
p.val = l.val + r.val;
p.fmin = min(l.fmin, r.fmin), p.fmax = max(l.fmax, r.fmax);
}
void pushup(int x) { pushup(t[x], t[x << 1], t[x << 1 | 1]); }
void build(int l, int r, int x = 1) {
if (l == r) {
t[x] = {l, r, w[l], w[l], w[l], 0};
return;
}
t[x] = {l, r, 0, 0, 0, 0};
int mid = l + r >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
pushup(x);
}
void modify(int l, int r, int c, int x = 1) {
if (t[x].fmin >= c) return;
if (l <= t[x].l && r >= t[x].r) {
if (t[x].fmax < c) {
pushdown(t[x], c);
return;
}
}
pushdown(x);
int mid = t[x].l + t[x].r >> 1;
if (l <= mid) modify(l, r, c, x << 1);
if (r > mid) modify(l, r, c, x << 1 | 1);
pushup(x);
}
int ask(int l, int r, int& have, int x = 1) {
if (t[x].fmin > have) return 0;
if (t[x].l == t[x].r) {
if (have >= t[x].val) {
have -= t[x].val;
return 1;
}
return 0;
}
if (t[x].l >= l && t[x].val <= have) {
have -= t[x].val;
return t[x].r - t[x].l + 1;
}
pushdown(x);
int mid = t[x].l + t[x].r >> 1;
int res = 0;
if (l <= mid) res += ask(l, r, have, x << 1);
if (r > mid) res += ask(l, r, have, x << 1 | 1);
return res;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= (n); ++i) scanf("%d", &w[i]);
build(1, n);
while (m--) {
int op, x, y;
scanf("%d %d %d", &op, &x, &y);
if (op == 1) {
modify(1, x, y);
} else {
printf("%d\n", ask(x, n, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long k;
struct Node {
long long maxx;
long long minn;
long long sum;
} tree[N << 2];
long long lazy[N << 2], a[N << 2];
void push_up(int node) {
tree[node].maxx = max(tree[node << 1].maxx, tree[node << 1 | 1].maxx);
tree[node].minn = min(tree[node << 1].minn, tree[node << 1 | 1].minn);
tree[node].sum = tree[node << 1].sum + tree[node << 1 | 1].sum;
}
void push_down(int node, int len) {
if (lazy[node] != -1) {
tree[node << 1].maxx = tree[node << 1 | 1].maxx = lazy[node];
tree[node << 1].minn = tree[node << 1 | 1].minn = lazy[node];
tree[node << 1].sum = (len - (len >> 1)) * lazy[node];
tree[node].sum = len * lazy[node];
tree[node << 1 | 1].sum = (len >> 1) * lazy[node];
lazy[node << 1] = lazy[node << 1 | 1] = lazy[node];
lazy[node] = -1;
}
}
void build(int node, int l, int r) {
lazy[node] = -1;
if (l == r) {
tree[node].maxx = tree[node].minn = a[l];
tree[node].sum = a[l];
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
push_up(node);
}
void change(int node, int l, int r, int L, int R) {
if (L <= l && R >= r) {
if (k >= tree[node].maxx) {
lazy[node] = k;
tree[node].maxx = tree[node].minn = k;
tree[node].sum = (r - l + 1) * k;
return;
}
if (k <= tree[node].minn) return;
}
push_down(node, r - l + 1);
int mid = (l + r) >> 1;
if (L <= mid) change(node << 1, l, mid, L, R);
if (R > mid) change(node << 1 | 1, mid + 1, r, L, R);
push_up(node);
}
long long query(int node, int l, int r, int L, int R) {
if (k <= 0) return 0;
if (L <= l && R >= r) {
if (k >= tree[node].sum) {
k -= tree[node].sum;
return r - l + 1;
} else if (k < tree[node].minn)
return 0;
if (l == r) return 0;
}
push_down(node, r - l + 1);
int mid = (l + r) >> 1;
long long ans = 0;
if (L <= mid) ans += query(node << 1, l, mid, L, R);
if (R > mid) ans += query(node << 1 | 1, mid + 1, r, L, R);
return ans;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, 1, n);
while (q--) {
int t, x;
scanf("%d%d%lld", &t, &x, &k);
if (t == 1) {
change(1, 1, n, 1, x);
} else {
printf("%lld\n", query(1, 1, n, x, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
struct tree {
long long val, minval, sum, maxval;
long long lazy;
} a[maxn << 1];
int b[maxn];
int ans = 0;
void build(int l, int r, int idx) {
a[idx].lazy = -1;
if (l == r) {
a[idx].val = b[l];
a[idx].minval = a[idx].val;
a[idx].sum = a[idx].val;
a[idx].maxval = a[idx].val;
return;
}
int mid = (l + r) >> 1;
build(l, mid, idx << 1);
build(mid + 1, r, (idx << 1) + 1);
a[idx].sum = a[idx << 1].sum + a[(idx << 1) + 1].sum;
a[idx].minval = min(a[idx << 1].minval, a[(idx << 1) + 1].minval);
a[idx].maxval = max(a[idx << 1].maxval, a[(idx << 1) + 1].maxval);
}
void push_down(int idx, int l, int r) {
if (a[idx].lazy != -1) {
int mid = (l + r) >> 1;
a[idx << 1].lazy = a[idx << 1].maxval = a[idx << 1].minval = a[idx].lazy;
a[(idx << 1) + 1].lazy = a[(idx << 1) + 1].maxval =
a[(idx << 1) + 1].minval = a[idx].lazy;
a[idx << 1].sum = (1ll) * (mid - l + 1) * a[idx].lazy;
a[(idx << 1) + 1].sum = (1ll) * (r - mid) * a[idx].lazy;
a[idx].lazy = -1;
}
}
void update(int l, int r, int idx, long long val, int L, int R) {
if (l <= L && R <= r) {
if (a[idx].minval >= val) {
return;
} else {
if (a[idx].maxval <= val) {
a[idx].maxval = val;
a[idx].minval = val;
a[idx].sum = (1ll) * (R - L + 1) * val;
a[idx].lazy = val;
return;
}
}
}
push_down(idx, L, R);
if (L == R) return;
int mid = (L + R) >> 1;
if (l <= mid) update(l, r, idx << 1, val, L, mid);
if (mid + 1 <= r) update(l, r, (idx << 1) + 1, val, mid + 1, R);
a[idx].sum = a[idx << 1].sum + a[(idx << 1) + 1].sum;
a[idx].minval = min(a[idx << 1].minval, a[(idx << 1) + 1].minval);
a[idx].maxval = max(a[idx << 1].maxval, a[(idx << 1) + 1].maxval);
}
void query(int l, int r, int idx, long long &val, int L, int R) {
if (l <= L && R <= r) {
if (a[idx].minval > val) {
return;
} else {
if (a[idx].sum <= val) {
ans += (R - L) + 1;
val -= a[idx].sum;
return;
}
}
}
push_down(idx, L, R);
int mid = (L + R) >> 1;
if (mid >= l) query(l, r, idx << 1, val, L, mid);
if (mid + 1 <= r) query(l, r, (idx << 1) + 1, val, mid + 1, R);
}
int main() {
ios::sync_with_stdio(false);
int q, n;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> b[i];
build(1, n, 1);
while (q--) {
int op, x;
long long y;
cin >> op >> x >> y;
if (op == 1) {
update(1, x, 1, y, 1, n);
} else {
ans = 0;
query(x, n, 1, y, 1, n);
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 2e5 + 5;
int n, q;
int a[maxn];
const ll INV = -1;
struct Node {
int s, e, m;
ll sum;
ll mini;
ll lazy;
Node *l, *r;
Node(int a, int b) {
s = a;
e = b;
sum = 0;
mini = 0;
lazy = INV;
if (s != e) {
m = (s + e) / 2;
l = new Node(s, m);
r = new Node(m + 1, e);
} else {
l = NULL;
r = NULL;
}
}
void push() {
if (lazy == INV) return;
if (s != e) {
l->lazy = lazy;
l->sum = (l->e - l->s + 1) * lazy;
l->mini = lazy;
r->lazy = lazy;
r->sum = (r->e - r->s + 1) * lazy;
r->mini = lazy;
}
lazy = INV;
}
void pull() {
sum = l->sum + r->sum;
mini = min(l->mini, r->mini);
}
void add(int st, int en, ll x) {
if (st <= s && e <= en) {
lazy = x;
mini = x;
sum = (e - s + 1) * x;
return;
}
push();
if (st <= m) {
l->add(st, en, x);
}
if (en > m) {
r->add(st, en, x);
}
pull();
}
ll getsum(int st, int en) {
push();
if (st <= s && e <= en) {
return sum;
}
ll ret = 0;
if (st <= m) {
ret += l->getsum(st, en);
}
if (en > m) {
ret += r->getsum(st, en);
}
return ret;
}
int getMinIdx(ll y) {
push();
if (s == e) {
return mini <= y ? s : n + 1;
}
if (l->mini <= y) {
return l->getMinIdx(y);
} else {
return r->getMinIdx(y);
}
}
int walk(ll z) {
push();
if (s == e) return sum <= z ? s : s - 1;
if (l->sum + r->mini > z) {
return l->walk(z);
} else {
return r->walk(z - (l->sum));
}
}
};
int main() {
scanf("%d %d", &n, &q);
Node *root = new Node(1, n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
root->add(i, i, a[i]);
}
while (q--) {
int t, x, y;
scanf("%d %d %d", &t, &x, &y);
if (t == 1) {
int i = root->getMinIdx(y);
if (i <= x) root->add(i, x, y);
} else {
int ans = 0;
while (x <= n) {
ll sum = x == 1 ? 0 : root->getsum(1, x - 1);
int i = root->walk(sum + y);
ans += i - x + 1;
y -= root->getsum(x, i);
x = max(i + 1, root->getMinIdx(y));
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
vector<long long> mx, mn, c, sum;
long long n;
SegmentTree(vector<long long>& a) {
n = a.size();
mx.resize(n << 2);
c.resize(n << 2);
sum.resize(n << 2);
mn.resize(n * 4, 1e9);
build(1, 0, n, a);
}
void update(long long v, long long l, long long r) {
long long m = (l + r) / 2;
long long vl = 2 * v, vr = vl + 1;
mx[v] = max((c[vl] ? c[vl] : mx[vl]), (c[vr] ? c[vr] : mx[vr]));
mn[v] = min((c[vl] ? c[vl] : mn[vl]), (c[vr] ? c[vr] : mn[vr]));
sum[v] = (c[vl] ? (m - l) * c[vl] : sum[vl]) +
(c[vr] ? (r - m) * c[vr] : sum[vr]);
}
void push(long long v) {
if (c[v]) {
c[2 * v] = c[v];
c[2 * v + 1] = c[v];
c[v] = 0;
}
}
void build(long long v, long long l, long long r, vector<long long>& a) {
if (r - l == 1) {
mx[v] = sum[v] = mn[v] = a[l];
return;
}
long long m = (l + r) / 2, vl = 2 * v, vr = vl + 1;
build(vl, l, m, a);
build(vr, m, r, a);
update(v, l, r);
}
void change(long long v, long long l, long long r, long long askl,
long long askr, long long val) {
if (l >= askr || r <= askl) {
return;
}
if (l >= askl && r <= askr && (c[v] ? c[v] : mn[v]) >= val) {
return;
}
if (l >= askl && r <= askr && (c[v] ? c[v] : mx[v]) <= val) {
c[v] = val;
return;
}
push(v);
long long m = (l + r) / 2, vl = 2 * v, vr = 2 * v + 1;
change(vl, l, m, askl, askr, val);
change(vr, m, r, askl, askr, val);
update(v, l, r);
}
long long ans = 0;
void get(long long pos, long long val) {
ans = 0;
get_ans(1, 0, n, pos, n, val);
}
void get_ans(long long v, long long l, long long r, long long askl,
long long askr, long long& val) {
if (l > askr || r <= askl) {
return;
}
if (l >= askl && r <= askr && (c[v] ? c[v] * (r - l) : sum[v]) <= val) {
ans += r - l;
val -= (c[v] ? c[v] * (r - l) : sum[v]);
return;
}
push(v);
long long m = (l + r) / 2, vl = 2 * v, vr = 2 * v + 1;
if ((c[vl] ? c[vl] : mn[vl]) <= val) {
get_ans(vl, l, m, askl, askr, val);
}
if ((c[vr] ? c[vr] : mn[vr]) <= val) {
get_ans(vr, m, r, askl, askr, val);
}
update(v, l, r);
}
};
void solve() {
long long n, q;
cin >> n >> q;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
SegmentTree tree(a);
while (q--) {
long long type, x, y;
cin >> type >> x >> y;
if (type == 1) {
tree.change(1, 0, n, 0, x, y);
} else {
tree.get(x - 1, y);
cout << tree.ans << "\n";
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout.precision(30);
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
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 eval(int u, int v) {
tr[u].maxv = tr[u].minv = v;
tr[u].lazy = v;
tr[u].sum = (long long)(tr[u].r - tr[u].l + 1) * v;
}
void pushdown(int u) {
eval(u << 1, tr[u].lazy);
eval(u << 1 | 1, tr[u].lazy);
tr[u].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)
eval(u, v);
else {
if (tr[u].lazy) 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 {
if (tr[u].lazy) 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;
const int inf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 2e5 + 11;
const int maxm = 1e6 + 11;
const long double eps = 1e-9;
const int mod = 20000311;
inline long long rd() {
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 << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long qpow(long long a, long long b, long long p) {
long long res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= p;
}
b >>= 1;
a = a * a % p;
}
return res;
}
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long a[maxn];
struct node {
int l, r;
long long fmax, fmin, sum;
long long lazy;
} T[maxn << 2];
inline void pushup(int rt) {
T[rt].fmax = max(T[rt << 1].fmax, T[rt << 1 | 1].fmax);
T[rt].fmin = min(T[rt << 1].fmin, T[rt << 1 | 1].fmin);
T[rt].sum = T[rt << 1].sum + T[rt << 1 | 1].sum;
}
inline void pushdown(int rt) {
if (T[rt].lazy) {
T[rt << 1].lazy = max(T[rt << 1].lazy, T[rt].lazy);
T[rt << 1].fmax = max(T[rt << 1].fmax, T[rt].lazy);
if (T[rt << 1].fmax == T[rt].lazy)
T[rt << 1].fmin = max(T[rt << 1].fmin, T[rt].lazy),
T[rt << 1].sum = T[rt].lazy * (T[rt << 1].r - T[rt << 1].l + 1);
T[rt << 1 | 1].lazy = max(T[rt << 1 | 1].lazy, T[rt].lazy);
T[rt << 1 | 1].fmax = max(T[rt << 1 | 1].fmax, T[rt].lazy);
if (T[rt << 1 | 1].fmax == T[rt].lazy)
T[rt << 1 | 1].fmin = max(T[rt << 1 | 1].fmin, T[rt].lazy),
T[rt << 1 | 1].sum =
T[rt].lazy * (T[rt << 1 | 1].r - T[rt << 1 | 1].l + 1);
}
}
void build(int rt, int l, int r) {
if (l == r) {
T[rt] = node{l, r, a[l], a[l], a[l], 0};
return;
}
T[rt] = node{l, r, 0, 0, 0, 0};
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 c) {
if (l <= T[rt].l && r >= T[rt].r) {
if (T[rt].fmax < c) {
T[rt].fmax = c;
T[rt].fmin = c;
T[rt].sum = 1ll * (T[rt].r - T[rt].l + 1) * c;
T[rt].lazy = c;
return;
}
if (T[rt].fmin >= c) return;
}
pushdown(rt);
int mid = T[rt].l + T[rt].r >> 1;
if (l <= mid) update(rt << 1, l, r, c);
if (r > mid) update(rt << 1 | 1, l, r, c);
pushup(rt);
}
long long ask(int rt, int l, int r, long long& c) {
if (l <= T[rt].l && r >= T[rt].r) {
if (c >= T[rt].sum) {
c -= T[rt].sum;
return T[rt].r - T[rt].l + 1;
}
if (c < T[rt].fmin) return 0;
}
int mid = T[rt].r + T[rt].l >> 1;
pushdown(rt);
long long res = 0;
if (l <= mid) res += ask(rt << 1, l, r, c);
if (r > mid) res += ask(rt << 1 | 1, l, r, c);
pushup(rt);
return res;
}
void slove() {
int n = rd(), m = rd();
for (int i = 1; i <= n; i++) a[i] = rd();
build(1, 1, n);
while (m--) {
int op = rd(), x = rd();
long long y = rd();
if (op == 1) {
update(1, 1, x, y);
} else
printf("%lld\n", ask(1, x, n, y));
}
}
int main() {
int T = 1;
while (T--) {
slove();
}
return 0;
}
|
#include <bits/stdc++.h>
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 {
~debug() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, debug &>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, debug &>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
debug &operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
debug &operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
const long double eps = 1e-9;
const int T = 1e5;
const int M = 1e9 + 7;
const long long inf = 1e18;
auto rnd = bind(uniform_int_distribution<int>(1, 5), mt19937(time(0)));
const int N = 2e5 + 1;
int p[4 * N];
long long t[4 * N];
int mx[4 * N];
int n, q;
void push(int v, int tl, int tr) {
if (p[v] && tl != tr) {
int tm = (tl + tr) >> 1;
t[2 * v] = 1ll * p[v] * (tm - tl + 1);
t[2 * v + 1] = 1ll * p[v] * (tr - tm);
p[2 * v + 1] = p[2 * v] = p[v];
mx[2 * v] = mx[2 * v + 1] = p[v];
p[v] = 0;
}
}
long long getsum(int l, int r, int v, int tl, int tr) {
if (tl >= l && tr <= r) {
return t[v];
}
if (tr < l || tl > r) return 0;
push(v, tl, tr);
int tm = (tl + tr) >> 1;
return getsum(l, r, 2 * v, tl, tm) + getsum(l, r, 2 * v + 1, tm + 1, tr);
}
void upd(int l, int r, int vl, int v, int tl, int tr) {
if (tl >= l && tr <= r) {
p[v] = vl;
mx[v] = vl;
t[v] = 1ll * (tr - tl + 1) * vl;
return;
}
if (tr < l || tl > r) return;
push(v, tl, tr);
int tm = (tl + tr) >> 1;
upd(l, r, vl, 2 * v, tl, tm);
upd(l, r, vl, 2 * v + 1, tm + 1, tr);
t[v] = (t[2 * v] + t[2 * v + 1]);
mx[v] = min(mx[2 * v], mx[2 * v + 1]);
}
int firstlower(int vl, int v, int tl, int tr) {
if (tl == tr) {
return tl;
}
int tm = (tl + tr) >> 1;
push(v, tl, tr);
if (mx[2 * v] <= vl) {
return firstlower(vl, 2 * v, tl, tm);
} else if (mx[2 * v + 1] <= vl) {
return firstlower(vl, 2 * v + 1, tm + 1, tr);
} else
return n;
}
int togo(int l, int vl) { return l + (vl / getsum(l, l, 1, 0, n - 1)); }
void go(int &l, int &vl, int &cl) {
while (int nl = togo(l, vl)) {
nl = min(nl, n);
if (nl <= l) break;
vl -= getsum(l, nl - 1, 1, 0, n - 1);
cl += nl - l;
l = nl;
if (l >= n) break;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> n >> q;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
upd(i, i, x, 1, 0, n - 1);
}
while (q--) {
int tp;
cin >> tp;
if (tp == 1) {
int r, y;
cin >> r >> y;
r--;
int l = firstlower(y, 1, 0, n - 1);
if (l <= r) upd(l, r, y, 1, 0, n - 1);
} else {
int l, y;
cin >> l >> y;
l--;
int cl = 0;
while (l != n) {
int pl = l;
go(l, y, cl);
if (l == n) break;
l = firstlower(y, 1, 0, n - 1);
if (l == n) break;
}
cout << cl << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const long double PI = acos(-1.0);
const int MOD = 998244353;
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
namespace Solver {
const int MAXN = 200005;
int n, q;
int a[MAXN];
namespace SegmentTree {
int mi[MAXN << 2];
long long sum[MAXN << 2];
int lz[MAXN << 2];
void PushUp(int o) {
mi[o] = min(mi[(o << 1)], mi[(o << 1 | 1)]);
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
void PushDown(int o, int l, int r) {
if (lz[o]) {
int v = lz[o];
int m = (l + r) >> 1;
mi[(o << 1)] = v;
lz[(o << 1)] = v;
sum[(o << 1)] = 1LL * (m - l + 1) * v;
mi[(o << 1 | 1)] = v;
lz[(o << 1 | 1)] = v;
sum[(o << 1 | 1)] = 1LL * (r - m) * v;
lz[o] = 0;
}
}
void Update(int o, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
mi[o] = v;
lz[o] = v;
sum[o] = 1LL * (r - l + 1) * v;
} else {
PushDown(o, l, r);
int m = (l + r) >> 1;
if (ql <= m) Update((o << 1), l, m, ql, qr, v);
if (qr >= m + 1) Update((o << 1 | 1), m + 1, r, ql, qr, v);
PushUp(o);
}
}
int Query1(int o, int l, int r, int v) {
if (l == r) return l;
PushDown(o, l, r);
int m = (l + r) >> 1;
if (mi[(o << 1)] < v) return Query1((o << 1), l, m, v);
if (mi[(o << 1 | 1)] < v) return Query1((o << 1 | 1), m + 1, r, v);
return -1;
}
int cnt;
long long coin;
void Query3(int o, int l, int r, int Lb, int Rb) {
if (Lb <= l && r <= Rb) {
if (coin >= sum[o]) {
coin -= sum[o];
cnt += r - l + 1;
return;
}
if (coin < mi[o]) return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (Lb <= m) Query3((o << 1), l, m, Lb, Rb);
if (Rb >= m + 1) Query3((o << 1 | 1), m + 1, r, Lb, Rb);
return;
}
} // namespace SegmentTree
void InitOnce() {}
void Read() {
if (scanf("%d%d", &n, &q) == -1) exit(0);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
}
void Solve() {
Read();
for (int i = 1; i <= n; ++i) SegmentTree::Update(1, 1, n, i, i, a[i]);
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
int R = x;
int L = SegmentTree::Query1(1, 1, n, y);
if (L == -1) continue;
if (L <= R) SegmentTree::Update(1, 1, n, L, R, y);
} else {
SegmentTree::cnt = 0;
SegmentTree::coin = y;
SegmentTree::Query3(1, 1, n, x, n);
printf("%d\n", SegmentTree::cnt);
}
}
return;
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) Solver::Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
int readint() {
int 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, q;
long long a[200005], mina[600000], maxa[600000], lazy[600000], sum[600000];
void build(int id, int l, int r) {
if (l == r) return (void)(mina[id] = maxa[id] = sum[id] = a[l]);
int mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
maxa[id] = max(maxa[id << 1], maxa[id << 1 | 1]);
mina[id] = min(mina[id << 1], mina[id << 1 | 1]);
sum[id] = sum[id << 1] + sum[id << 1 | 1];
}
void pushdown(int id, int l, int r) {
int mid = (l + r) / 2;
if (lazy[id]) {
mina[id << 1] = mina[id << 1 | 1] = maxa[id << 1] = maxa[id << 1 | 1] =
lazy[id << 1] = lazy[id << 1 | 1] = lazy[id];
sum[id << 1] = lazy[id] * (mid - l + 1),
sum[id << 1 | 1] = lazy[id] * (r - mid);
lazy[id] = 0;
}
}
void change(int id, int l, int r, int ql, int qr, long long c) {
if (c <= mina[id]) return;
if (l == ql && r == qr && c >= maxa[id])
return (void)(mina[id] = maxa[id] = lazy[id] = c,
sum[id] = c * (r - l + 1));
pushdown(id, l, r);
int mid = (l + r) / 2;
if (qr <= mid)
change(id << 1, l, mid, ql, qr, c);
else if (ql > mid)
change(id << 1 | 1, mid + 1, r, ql, qr, c);
else
change(id << 1, l, mid, ql, mid, c),
change(id << 1 | 1, mid + 1, r, mid + 1, qr, c);
maxa[id] = max(maxa[id << 1], maxa[id << 1 | 1]);
mina[id] = min(mina[id << 1], mina[id << 1 | 1]);
sum[id] = sum[id << 1] + sum[id << 1 | 1];
}
pair<long long, long long> query(int id, int l, int r, int ql, int qr,
long long c) {
if (c < mina[id]) return make_pair(c, 0);
if (l == ql && r == qr && c >= sum[id])
return make_pair(c - sum[id], r - l + 1);
pushdown(id, l, r);
int mid = (l + r) / 2;
if (qr <= mid)
return query(id << 1, l, mid, ql, qr, c);
else if (ql > mid)
return query(id << 1 | 1, mid + 1, r, ql, qr, c);
else {
pair<long long, long long> lson = query(id << 1, l, mid, ql, mid, c),
rson = query(id << 1 | 1, mid + 1, r, mid + 1,
qr, lson.first);
return make_pair(rson.first, lson.second + rson.second);
}
}
int main() {
n = readint();
q = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
build(1, 1, n);
int opt, x, y;
while (q--) {
opt = readint();
x = readint();
y = readint();
if (opt == 1)
change(1, 1, n, 1, x, y);
else
printf("%lld\n", query(1, 1, n, x, n, y).second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long lazy[4 * 200005], seg[4 * 200005], sum[4 * 200005], mn[4 * 200005],
mx[4 * 200005], now, lst;
void propagate(int n, int s, int e) {
lazy[n * 2] = seg[n * 2] = mx[n * 2] = mn[n * 2] = lazy[n];
lazy[n * 2 + 1] = seg[n * 2 + 1] = mx[n * 2 + 1] = mn[n * 2 + 1] = lazy[n];
int mid = (s + e) / 2;
sum[n * 2] = seg[n * 2] * (mid - s + 1);
sum[n * 2 + 1] = seg[n * 2 + 1] * (e - mid);
lazy[n] = 0;
return;
}
void update(int n, int s, int e, int l, int r, long long val) {
if (mn[n] >= val) return;
if (s > r || e < l) return;
if (s >= l && e <= r && mx[n] < val) {
lazy[n] = val;
seg[n] = val;
sum[n] = val * (e - s + 1);
mx[n] = mn[n] = val;
return;
}
if (lazy[n]) propagate(n, s, e);
int mid = (s + e) / 2;
update(n * 2, s, mid, l, r, val);
update(n * 2 + 1, mid + 1, e, l, r, val);
sum[n] = sum[n * 2] + sum[n * 2 + 1];
mx[n] = max(mx[n * 2], mx[n * 2 + 1]);
mn[n] = min(mn[n * 2], mn[n * 2 + 1]);
return;
}
int query(int n, int s, int e, int l, int r) {
if (s > r || e < l || mn[n] > now) return 0;
if (s >= l && e <= r && sum[n] <= now) {
lst = e;
now -= sum[n];
return (e - s + 1);
}
if (lazy[n]) propagate(n, s, e);
int mid = (s + e) / 2;
return query(n * 2, s, mid, l, r) + query(n * 2 + 1, mid + 1, e, l, r);
}
int main() {
int n, q, t, x, y;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &x), update(1, 1, n, i, i, x);
while (q--) {
scanf("%d %d %d", &t, &x, &y);
if (t == 1)
update(1, 1, n, 1, x, y);
else {
now = y;
int res = 0;
lst = x - 1;
while (true) {
int ret = query(1, 1, n, lst + 1, n);
if (ret)
res += ret;
else
break;
}
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T, size_t N>
inline ostream &operator<<(ostream &os, const array<T, N> &a) {
os << "[";
int cnt = 0;
for (auto &val : a) {
if (cnt++) os << ", ";
os << val;
}
os << "]";
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "]";
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &v) {
os << "{";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "}";
}
template <typename T>
inline ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "{";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "}";
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &v) {
os << "[";
int cnt = 0;
for (auto &val : v) {
if (cnt++) os << ", ";
os << val;
}
return os << "]";
}
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vll = vector<long long>;
using vvi = vector<vector<int>>;
using vs = vector<string>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using si = set<int>;
using mpii = map<int, int>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
template <class T>
inline bool umin(T &a, const T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool umax(T &a, const T b) {
return a < b ? a = b, 1 : 0;
}
struct SegmentTree {
struct data {
int mi, ma;
ll sum;
data() {}
data(int _mi, int _ma, ll _sum) : mi(_mi), ma(_ma), sum(_sum) {}
};
struct node {
int l, r;
int lazy;
data val;
node() {}
} t[200004 << 2];
SegmentTree() {}
void build(int id, int l, int r, vi &a) {
t[id].l = l;
t[id].r = r;
t[id].lazy = 0;
if (l == r) {
t[id].val = data(a[l], a[l], a[l]);
return;
}
int mid = (l + r) >> 1;
build((id << 1), l, mid, a);
build(((id << 1) | 1), mid + 1, r, a);
t[id].val = merge(t[(id << 1)].val, t[((id << 1) | 1)].val);
}
void apply(int id, int ma) {
t[id].lazy = ma;
ll len = t[id].r - t[id].l + 1;
t[id].val = data(ma, ma, len * ma);
}
void pushDown(int id) {
assert(t[id].l != t[id].r);
if (t[id].lazy > 0) {
apply((id << 1), t[id].lazy);
apply(((id << 1) | 1), t[id].lazy);
}
t[id].lazy = 0;
}
data merge(const data &ld, const data &rd) {
assert(ld.ma >= ld.mi);
assert(rd.ma >= rd.mi);
assert(ld.mi >= rd.ma);
int mi = min(ld.mi, rd.mi);
int ma = max(ld.ma, rd.ma);
ll sum = ld.sum + rd.sum;
return data(mi, ma, sum);
}
void updateMax(int id, int l, int r, int ma) {
if (t[id].l == t[id].r) {
assert(t[id].val.mi == t[id].val.ma);
assert(t[id].val.mi == t[id].val.sum);
int newVal = max(t[id].val.ma, ma);
t[id].val = data(newVal, newVal, newVal);
return;
}
if (t[id].l == l && t[id].r == r) {
if (ma >= t[id].val.ma) {
apply(id, ma);
} else if (ma >= t[id].val.mi) {
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
updateMax((id << 1), l, mid, ma);
updateMax(((id << 1) | 1), mid + 1, r, ma);
t[id].val = merge(t[(id << 1)].val, t[((id << 1) | 1)].val);
}
return;
}
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
if (r <= mid)
updateMax((id << 1), l, r, ma);
else if (l > mid)
updateMax(((id << 1) | 1), l, r, ma);
else {
updateMax((id << 1), l, mid, ma);
updateMax(((id << 1) | 1), mid + 1, r, ma);
}
t[id].val = merge(t[(id << 1)].val, t[((id << 1) | 1)].val);
}
void query(int id, int l, int r, ll &had, int &got) {
if (t[id].l == t[id].r) {
assert(t[id].val.mi == t[id].val.ma);
assert(t[id].val.mi == t[id].val.sum);
if (had >= t[id].val.sum) {
had -= t[id].val.sum;
got++;
}
return;
}
if (t[id].l == l && t[id].r == r) {
if (had >= t[id].val.sum) {
had -= t[id].val.sum;
got += t[id].r - t[id].l + 1;
} else if (had >= t[id].val.mi) {
int mid = (t[id].l + t[id].r) >> 1;
pushDown(id);
query((id << 1), l, mid, had, got);
query(((id << 1) | 1), mid + 1, r, had, got);
}
return;
}
pushDown(id);
int mid = (t[id].l + t[id].r) >> 1;
if (r <= mid)
query((id << 1), l, r, had, got);
else if (l > mid)
query(((id << 1) | 1), l, r, had, got);
else {
query((id << 1), l, mid, had, got);
query(((id << 1) | 1), mid + 1, r, had, got);
}
}
} st;
int n, m;
void solve() {
vi a(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> a[i];
st.build(1, 1, n, a);
while (m--) {
int op, pos, val;
cin >> op >> pos >> val;
if (op == 1) {
st.updateMax(1, 1, pos, val);
} else if (op == 2) {
ll had = val;
int got = 0;
st.query(1, pos, n, had, got);
cout << got << endl;
}
}
}
void solve(int _cas) { solve(); }
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL), cout.precision(12);
while (cin >> n >> m) solve(1);
}
|
#include <bits/stdc++.h>
struct Node {
long long minVal, sum, lazyChange;
};
struct SegmentTree {
Node nodes[800010];
int n, n0;
SegmentTree(int a[], int n_) : n(1) {
while (n < n_) n <<= 1;
n0 = (n << 1) - n_;
for (int i = n; i < n0; ++i) {
nodes[i].sum = nodes[i].minVal = (1 << 30);
}
for (int i = n0; i < (n << 1); ++i) {
nodes[i].sum = nodes[i].minVal = a[i - n0];
}
build(1);
}
void build(int index) {
if (index >= n) return;
build(((index) << 1));
build(((index) << 1 | 1));
maintain(index);
}
void pushdown(int k) {
if (nodes[k].lazyChange) {
nodes[((k) << 1)].minVal = nodes[((k) << 1 | 1)].minVal =
nodes[((k) << 1)].lazyChange = nodes[((k) << 1 | 1)].lazyChange =
nodes[k].lazyChange;
nodes[((k) << 1)].sum = nodes[((k) << 1 | 1)].sum = nodes[k].sum / 2;
nodes[k].lazyChange = 0;
}
}
void maintain(int k) {
nodes[k].minVal =
std::min(nodes[((k) << 1)].minVal, nodes[((k) << 1 | 1)].minVal);
nodes[k].sum = nodes[((k) << 1)].sum + nodes[((k) << 1 | 1)].sum;
}
int indexValLeq(int val) {
int x = 1;
while (x < n) {
pushdown(x);
if (nodes[((x) << 1)].minVal <= val)
x = ((x) << 1);
else
x = ((x) << 1 | 1);
}
return nodes[x].minVal <= val ? x - n : -1;
}
void set(int l, int r, int val) { set(l, r, val, 0, n, 1); }
void set(int l, int r, int val, int a, int b, int k) {
if (a >= r || b <= l) return;
if (a >= l && b <= r) {
nodes[k].sum = (long long)(b - a) * val;
nodes[k].lazyChange = val;
nodes[k].minVal = val;
return;
}
pushdown(k);
set(l, r, val, a, (a + b) >> 1, ((k) << 1));
set(l, r, val, (a + b) >> 1, b, ((k) << 1 | 1));
maintain(k);
}
long long getSum(int l, int r, int a, int b, int k) {
if (a >= r || b <= l) return 0;
if (a >= l && b <= r) return nodes[k].sum;
pushdown(k);
return getSum(l, r, a, (a + b) >> 1, ((k) << 1)) +
getSum(l, r, (a + b) >> 1, b, ((k) << 1 | 1));
}
long long getSum(int index) { return getSum(0, index, 0, n, 1); }
int indexSumGreater(long long s) {
int x = 1;
long long s_ = 0;
while (x < n) {
pushdown(x);
if (s_ + nodes[((x) << 1)].sum > s)
x = ((x) << 1);
else {
s_ += nodes[((x) << 1)].sum;
x = ((x) << 1 | 1);
}
}
if (x == (n << 1) - 1 && s_ + nodes[x].sum <= s) return x - n + 1;
return x - n;
}
void opt1(int rindex, int val) {
int lindex = indexValLeq(val);
rindex += n0 - n;
if (lindex == -1 || lindex >= rindex) return;
set(lindex, rindex, val);
}
int opt2(int st, int x) {
st += n0 - n;
long long s1;
int index, ret = 0, loc = std::max(indexValLeq(x), st);
while (~loc) {
s1 = getSum(loc);
index = indexSumGreater(x + s1);
ret += index - loc;
x -= getSum(index) - s1;
if (index == n) break;
loc = indexValLeq(x);
}
return ret;
}
};
int a[200010];
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
SegmentTree *sgt = new SegmentTree(a, n);
for (int i = 0; i < q; ++i) {
int opt, x, y;
scanf("%d %d %d", &opt, &x, &y);
if (opt == 1) {
sgt->opt1(x, y);
} else {
printf("%d\n", sgt->opt2(x - 1, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class segment_tree {
int n;
vector<long long> mn;
vector<long long> sm;
vector<long long> mod;
void push(int v, int L, int R) {
if (mod[v] == 0) return;
sm[v] = mod[v] * (R - L);
mn[v] = mod[v];
mod[2 * v + 1] = mod[v];
mod[2 * v + 2] = mod[v];
mod[v] = 0;
}
long long get_sum(int v, int L, int R) {
if (mod[v] == 0) return sm[v];
return mod[v] * (R - L);
}
long long get_mn(int v) {
if (mod[v] == 0) return mn[v];
return mod[v];
}
void set(int v, int L, int R, int l, int r, long long x) {
if (R <= l || r <= L) return;
if (l <= L && R <= r) {
mod[v] = x;
sm[v] = x * (R - L);
mn[v] = x;
} else {
push(v, L, R);
set(2 * v + 1, L, (L + R) / 2, l, r, x);
set(2 * v + 2, (L + R) / 2, R, l, r, x);
sm[v] = get_sum(2 * v + 1, L, (L + R) / 2) +
get_sum(2 * v + 2, (L + R) / 2, R);
mn[v] = min(get_mn(2 * v + 1), get_mn(2 * v + 2));
}
}
long long get_sum(int v, int L, int R, int l, int r) {
if (R <= l || r <= L)
return 0;
else if (l <= L && R <= r)
return get_sum(v, L, R);
push(v, L, R);
return get_sum(2 * v + 1, L, (L + R) / 2, l, r) +
get_sum(2 * v + 2, (L + R) / 2, R, l, r);
}
pair<int, long long> last_sum_leq(int v, int L, int R, int l, long long x) {
if (R <= l) return {-1, 0};
if (l <= L) {
if (get_sum(v, L, R) <= x) return {R, get_sum(v, L, R)};
if (L == R - 1) return {L, 0};
push(v, L, R);
if (get_sum(2 * v + 1, L, (L + R) / 2) > x)
return last_sum_leq(2 * v + 1, L, (L + R) / 2, l, x);
else {
auto a = last_sum_leq(2 * v + 2, (L + R) / 2, R, l,
x - get_sum(2 * v + 1, L, (L + R) / 2));
return {a.first, a.second + get_sum(2 * v + 1, L, (L + R) / 2)};
}
}
push(v, L, R);
auto a = last_sum_leq(2 * v + 1, L, (L + R) / 2, l, x);
if (a.first > -1) return a;
return last_sum_leq(2 * v + 2, (L + R) / 2, R, l, x);
}
int first_leq(int v, int L, int R, long long x) {
if (get_mn(v) > x) return n;
if (L == R - 1) return L;
push(v, L, R);
int a = first_leq(2 * v + 1, L, (L + R) / 2, x);
if (a < n) return a;
return first_leq(2 * v + 2, (L + R) / 2, R, x);
}
public:
segment_tree(int N) : n(N), mn(4 * n), sm(4 * n), mod(4 * n) {}
void set(int l, int r, long long x) { set(0, 0, n, l, r, x); }
pair<int, long long> last_sum_leq(int l, long long x) {
return last_sum_leq(0, 0, n, l, x);
}
long long get_sum(int l, int r) { return get_sum(0, 0, n, l, r); }
int first_leq(long long x) { return first_leq(0, 0, n, x); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
scanf("%d %d", &n, &q);
segment_tree st(n);
for (int i = 0; i < (int)(n); i++) {
int a;
scanf("%d", &a);
st.set(i, i + 1, a);
}
for (int i = 0; i < (int)(n - 1); i++)
assert(st.get_sum(i, i + 1) >= st.get_sum(i + 1, i + 2));
for (int i = 0; i < (int)(q); i++) {
int type, x;
long long y;
scanf("%d %d %lld", &type, &x, &y);
if (type == 1) {
x--;
int j = st.first_leq(y);
if (j < x + 1) st.set(j, x + 1, y);
} else {
x--;
int ans = 0;
while (x < n && y > 0) {
int r = max(x, st.first_leq(y));
if (r == n) break;
auto [rr, yy] = st.last_sum_leq(r, y);
assert(rr > r);
y -= yy;
x = rr;
ans += rr - r;
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int N = 2e5 + 5;
int n, q, a[N];
struct node {
int mx;
long long sum;
};
node ST[4 * N];
int lazy[4 * N];
void dolazy(int id, int l, int r) {
if (lazy[id] == 0) return;
ST[id].sum = 1ll * lazy[id] * (r - l + 1);
ST[id].mx = lazy[id];
if (l != r) {
lazy[id * 2 + 1] = lazy[id];
lazy[id * 2] = lazy[id];
}
lazy[id] = 0;
}
void update(int id, int l, int r, int u, int v, int val) {
dolazy(id, l, r);
if (l > v || r < u) return;
if (u <= l && r <= v) {
lazy[id] = val;
dolazy(id, l, r);
return;
}
int mid = (l + r) / 2;
update(id * 2, l, mid, u, v, val);
update(id * 2 + 1, mid + 1, r, u, v, val);
ST[id].mx = max(ST[id * 2].mx, ST[id * 2 + 1].mx);
ST[id].sum = ST[id * 2].sum + ST[id * 2 + 1].sum;
}
int fin(int id, int l, int r, int val) {
dolazy(id, l, r);
if (l == r) {
if (ST[id].mx > val) return l;
return 0;
}
int mid = (l + r) / 2;
dolazy(id * 2, l, mid);
dolazy(id * 2 + 1, mid + 1, r);
if (ST[id * 2 + 1].mx > val) return fin(id * 2 + 1, mid + 1, r, val);
if (ST[id * 2].mx > val) return fin(id * 2, l, mid, val);
return 0;
}
long long get(int id, int l, int r, int u, int v) {
dolazy(id, l, r);
if (l > v || r < u) return 0;
if (u <= l && r <= v) return ST[id].sum;
int mid = (l + r) / 2;
return get(id * 2, l, mid, u, v) + get(id * 2 + 1, mid + 1, r, u, v);
}
int finsum(int id, int l, int r, long long need, long long cur_sum = 0) {
dolazy(id, l, r);
if (l == r) {
if (cur_sum + ST[id].sum <= need) return l;
return 0;
}
int mid = (l + r) / 2;
dolazy(id * 2, l, mid);
dolazy(id * 2 + 1, mid + 1, r);
if (cur_sum + ST[id * 2].sum <= need)
return max(mid,
finsum(id * 2 + 1, mid + 1, r, need, cur_sum + ST[id * 2].sum));
return finsum(id * 2, l, mid, need, cur_sum);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
update(1, 1, n, i, i, a[i]);
}
while (q--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) {
int l = fin(1, 1, n, y) + 1;
if (l <= x) update(1, 1, n, l, x, y);
} else {
int cur = y;
int cnt = 0;
while (x <= n) {
int l = fin(1, 1, n, cur) + 1;
l = max(l, x);
long long val;
if (l > 1)
val = get(1, 1, n, 1, l - 1);
else
val = 0;
int r = finsum(1, 1, n, cur + val);
if (r < l) break;
cur -= get(1, 1, n, l, r);
x = r + 2;
cnt += (r - l + 1);
}
cout << cnt << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5;
const int inf = 2e9;
ll t[N * 8], p[N * 8];
pair<ll, ll> q[N * 8];
inline void push(int v, int tl, int tr) {
if (p[v] != -1) {
t[v] = p[v] * static_cast<ll>(tr - tl + 1);
p[v * 2 + 1] = p[v];
p[v * 2] = p[v];
q[v] = {p[v], p[v]};
p[v] = -1;
}
}
void update(int v, int tl, int tr, int l, int r, int x) {
if (l > r) return;
push(v, tl, tr);
if (tl == l && r == tr) {
p[v] = x;
push(v, tl, tr);
return;
}
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), x);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, x);
push(v * 2, tl, tm);
push(v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
q[v].first = min(q[v * 2].first, q[v * 2 + 1].first);
q[v].second = min(q[v * 2].second, q[v * 2 + 1].second);
}
ll get(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
push(v, tl, tr);
if (tl == l && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
auto res = get(v * 2, tl, tm, l, min(r, tm)) +
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
push(v * 2, tl, tm);
push(v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
q[v].first = min(q[v * 2].first, q[v * 2 + 1].first);
q[v].second = min(q[v * 2].second, q[v * 2 + 1].second);
return res;
}
int L;
void go(int v, int tl, int tr, int& s, int& res) {
if (q[v].first > s) return;
if (tr < L) return;
push(v, tl, tr);
if (tl >= L && q[v].second <= s && t[v] <= s) {
res += tr - tl + 1;
s -= t[v];
} else if (tl < tr) {
int tm = (tl + tr) / 2;
go(v * 2, tl, tm, s, res);
go(v * 2 + 1, tm + 1, tr, s, res);
push(v * 2, tl, tm);
push(v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2] + t[v * 2 + 1];
q[v].first = min(q[v * 2].first, q[v * 2 + 1].first);
q[v].second = min(q[v * 2].second, q[v * 2 + 1].second);
}
}
int main() {
for (int i = 0; i < N * 8; ++i) {
p[i] = -1;
q[i] = {inf, -inf};
}
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
update(1, 0, n - 1, i, i, x);
}
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
--x;
if (t == 1) {
int l = -1;
int r = n;
while (r - l > 1) {
int m = (l + r) / 2;
ll w = get(1, 0, n - 1, m, m);
if (w < y) {
r = m;
} else {
l = m;
}
}
update(1, 0, n - 1, r, x, y);
} else {
int res = 0;
L = x;
go(1, 0, n - 1, y, res);
printf("%d\n", res);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 1e6 + 10;
ll a[N];
struct Node {
ll maxx{0LL}, minn{0LL}, sum{0LL}, lazy{0LL}, num{0LL};
Node() = default;
} tree[N];
void pushup(ll rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
tree[rt].maxx = max(tree[rt << 1].maxx, tree[rt << 1 | 1].maxx);
tree[rt].minn = min(tree[rt << 1].minn, tree[rt << 1 | 1].minn);
}
void pushDown(ll rt) {
if (tree[rt].lazy) {
tree[rt << 1].lazy = tree[rt].lazy;
tree[rt << 1 | 1].lazy = tree[rt].lazy;
tree[rt << 1].sum = tree[rt << 1].lazy * tree[rt << 1].num;
tree[rt << 1 | 1].sum = tree[rt << 1 | 1].lazy * tree[rt << 1 | 1].num;
tree[rt << 1].maxx = tree[rt << 1].minn = tree[rt << 1].lazy;
tree[rt << 1 | 1].maxx = tree[rt << 1 | 1].minn = tree[rt << 1 | 1].lazy;
tree[rt].lazy = 0;
}
}
int build(ll l, ll r, ll rt) {
if (l == r) {
tree[rt].sum = tree[rt].maxx = tree[rt].minn = a[l];
tree[rt].num = 1;
tree[rt].lazy = 0;
return 1;
}
ll sum = 0;
ll mid = (l + r) >> 1;
sum += build(l, mid, rt << 1);
sum += build(mid + 1, r, rt << 1 | 1);
pushup(rt);
tree[rt].num = sum;
return sum;
}
ll tmpV;
ll query(ll L, ll R, ll l, ll r, ll rt) {
if (L <= l && r <= R) {
if (tmpV < tree[rt].minn) return 0;
if (tmpV >= tree[rt].sum) {
tmpV -= tree[rt].sum;
return r - l + 1;
}
}
if (l == r) return 0;
pushDown(rt);
ll mid = (l + r) >> 1;
ll sum = 0;
if (L <= mid) {
sum += query(L, R, l, mid, rt << 1);
}
if (R > mid) {
sum += query(L, R, mid + 1, r, rt << 1 | 1);
}
return sum;
}
void update(ll L, ll R, ll val, ll l, ll r, ll rt) {
if (L <= l && r <= R) {
if (tree[rt].minn >= val) return;
if (tree[rt].maxx < val) {
tree[rt].sum = val * (r - l + 1);
tree[rt].minn = tree[rt].maxx = val;
tree[rt].lazy = val;
return;
}
}
if (l == r) return;
pushDown(rt);
ll mid = (l + r) >> 1;
if (L <= mid) update(L, R, val, l, mid, rt << 1);
if (R > mid) update(L, R, val, mid + 1, r, rt << 1 | 1);
pushup(rt);
}
int main() {
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
build(1, n, 1);
while (q--) {
ll t, x, y;
cin >> t >> x >> y;
if (t == 1) {
update(1, x, y, 1, n, 1);
} else if (t == 2) {
tmpV = y;
cout << query(x, n, 1, n, 1) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long N = 2e5 + 100;
long long t[4 * N], mn[4 * N], assign[4 * N], a[N];
long long n, q;
void push(long long v, long long l, long long r) {
if (assign[v]) {
t[v] = assign[v] * (r - l);
mn[v] = assign[v];
if (l + 1 != r) {
assign[v * 2 + 1] = max(assign[v * 2 + 1], assign[v]);
assign[v * 2 + 2] = max(assign[v * 2 + 2], assign[v]);
}
assign[v] = 0;
}
}
void build(long long v, long long l, long long r) {
if (l + 1 == r) {
t[v] = mn[v] = a[l];
return;
}
long long m = (l + r) / 2;
build(v * 2 + 1, l, m);
build(v * 2 + 2, m, r);
t[v] = t[v * 2 + 1] + t[v * 2 + 2];
mn[v] = min(mn[v * 2 + 1], mn[v * 2 + 2]);
}
void upd(long long v, long long l, long long r, long long ql, long long qr,
long long x) {
push(v, l, r);
if (qr <= l || r <= ql) {
return;
}
if (ql <= l && r <= qr) {
assign[v] = max(assign[v], x);
push(v, l, r);
return;
}
long long m = (l + r) / 2;
upd(v * 2 + 1, l, m, ql, qr, x);
upd(v * 2 + 2, m, r, ql, qr, x);
t[v] = t[v * 2 + 1] + t[v * 2 + 2];
mn[v] = min(mn[v * 2 + 1], mn[v * 2 + 2]);
}
long long sum(long long v, long long l, long long r, long long ql,
long long qr) {
push(v, l, r);
if (qr <= l || r <= ql) {
return 0;
}
if (ql <= l && r <= qr) {
return t[v];
}
long long m = (l + r) / 2;
return sum(v * 2 + 1, l, m, ql, qr) + sum(v * 2 + 2, m, r, ql, qr);
}
long long get(long long v, long long l, long long r, long long x) {
push(v, l, r);
if (l + 1 == r) {
return l + (t[v] <= x);
}
long long m = (l + r) / 2;
push(v * 2 + 1, l, m);
if (t[v * 2 + 1] >= x) {
return get(v * 2 + 1, l, m, x);
} else {
return get(v * 2 + 2, m, r, x - t[v * 2 + 1]);
}
}
long long find(long long v, long long l, long long r, long long x) {
push(v, l, r);
if (mn[v] > x) {
return n;
}
if (l + 1 == r) {
return l;
}
long long m = (l + r) / 2;
push(v * 2 + 1, l, m);
if (mn[v * 2 + 1] <= x) {
return find(v * 2 + 1, l, m, x);
} else {
return find(v * 2 + 2, m, r, x);
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
build(0, 0, n);
auto getSum = [&](long long l, long long r) {
r = min(r, n);
return sum(0, 0, n, l, r);
};
auto go = [&](long long x, long long y) {
long long ret = 0;
while (x < n) {
long long to = get(0, 0, n, y + getSum(0, x));
y -= getSum(x, to);
ret += to - x;
x = to;
if (x == n) break;
x = find(0, 0, n, y);
}
return ret;
};
while (q--) {
long long type, x, y;
cin >> type >> x >> y;
x--;
if (type == 1) {
long long l = find(0, 0, n, y);
long long r = x + 1;
if (r > l) upd(0, 0, n, l, r, y);
} else {
cout << go(x, y) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename _Tp>
inline void red(_Tp &x) {
x = 0;
bool fg = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fg ^= 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (_Tp)(ch ^ 48), ch = getchar();
if (fg) x = -x;
}
const int N = 200010;
const int inf = 0x3f3f3f3f;
int n, Q, a[N], mn[N << 2], tag[N << 2], len[N << 2];
long long sum[N << 2];
void pushup(int x) {
sum[x] = sum[(x << 1)] + sum[(x << 1 | 1)];
mn[x] = min(mn[(x << 1)], mn[(x << 1 | 1)]);
}
void build(int l = 1, int r = n, int x = 1) {
len[x] = r - l + 1;
tag[x] = -1;
if (l == r) return mn[x] = sum[x] = a[l], void();
build(l, ((l + r) >> 1), (x << 1));
build(((l + r) >> 1) + 1, r, (x << 1 | 1));
pushup(x);
}
void updata(int x, int vl) {
sum[x] = 1ll * vl * len[x];
mn[x] = tag[x] = vl;
}
void pushdown(int x) {
if (tag[x] == -1) return;
updata((x << 1), tag[x]);
updata((x << 1 | 1), tag[x]);
tag[x] = -1;
}
void modify(int L, int R, int vl, int l = 1, int r = n, int x = 1) {
if (L <= l && r <= R) return updata(x, vl);
pushdown(x);
if (L <= ((l + r) >> 1)) modify(L, R, vl, l, ((l + r) >> 1), (x << 1));
if (R > ((l + r) >> 1)) modify(L, R, vl, ((l + r) >> 1) + 1, r, (x << 1 | 1));
pushup(x);
}
int query(long long vl, int l = 1, int r = n, int x = 1) {
if (l == r) {
if (l == n && sum[x] > vl) return n + 1;
return l;
}
pushdown(x);
if (mn[(x << 1)] <= vl)
return query(vl, l, ((l + r) >> 1), (x << 1));
else
return query(vl, ((l + r) >> 1) + 1, r, (x << 1 | 1));
}
int Query(long long vl, int l = 1, int r = n, int x = 1) {
if (l == r) {
if (l == n && sum[x] <= vl) return n + 1;
return l;
}
pushdown(x);
if (sum[(x << 1)] > vl)
return Query(vl, l, ((l + r) >> 1), (x << 1));
else
return Query(vl - sum[(x << 1)], ((l + r) >> 1) + 1, r, (x << 1 | 1));
}
long long querysum(int L, int R, int l = 1, int r = n, int x = 1) {
if (L > R) return 0;
if (L <= l && r <= R) return sum[x];
pushdown(x);
long long ret = 0;
if (L <= ((l + r) >> 1)) ret += querysum(L, R, l, ((l + r) >> 1), (x << 1));
if (R > ((l + r) >> 1))
ret += querysum(L, R, ((l + r) >> 1) + 1, r, (x << 1 | 1));
return ret;
}
int main() {
red(n);
red(Q);
for (int i = 1; i <= n; ++i) red(a[i]);
build();
for (int i = 1; i <= Q; ++i) {
int op, x;
long long y;
red(op);
red(x);
red(y);
if (op == 1) {
int ps = query(y);
if (ps <= x) modify(ps, x, y);
} else {
long long tmp;
int ans = 0, ps = x, pp;
while (ps <= n) {
tmp = querysum(1, ps - 1);
pp = Query(tmp + y);
ans += pp - ps;
y -= querysum(ps, pp - 1);
if (pp == n + 1) break;
ps = query(y);
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
int a[200200];
int t[550000], tq[550000];
long long ts[550000];
int s[550000], e[550000], p = 1 << 18;
int fq(int x, int v) {
if (x >= p) return s[x];
if (t[x]) return e[x];
if (tq[2 * x + 1] >= v) return fq(2 * x + 1, v);
return fq(2 * x, v);
}
void fqq(int x, int l, int r, int v) {
if (t[x] && x < p) {
t[2 * x] = t[2 * x + 1] = t[x];
tq[2 * x] = tq[2 * x + 1] = t[x];
ts[2 * x] = ts[2 * x + 1] = t[x] * (e[2 * x] - s[2 * x] + 1ll);
t[x] = 0;
}
if (s[x] == l && e[x] == r) {
t[x] = max(t[x], v);
tq[x] = max(tq[x], v);
return;
} else if (l >= s[2 * x + 1])
fqq(2 * x + 1, l, r, v);
else if (r <= e[2 * x])
fqq(2 * x, l, r, v);
else {
fqq(2 * x, l, e[2 * x], v);
fqq(2 * x + 1, s[2 * x + 1], r, v);
}
tq[x] = max(tq[2 * x], tq[2 * x + 1]);
}
void fv(int x, int l, int r, long long v) {
if (t[x] && x < p) {
t[2 * x] = t[2 * x + 1] = t[x];
ts[2 * x] = ts[2 * x + 1] = t[x] * (e[2 * x] - s[2 * x] + 1ll);
tq[2 * x] = tq[2 * x + 1] = t[x];
}
t[x] = 0;
if (l == s[x] && r == e[x]) {
t[x] = v;
ts[x] = v * (e[x] - s[x] + 1);
return;
} else if (l >= s[2 * x + 1])
fv(2 * x + 1, l, r, v);
else if (r <= e[2 * x])
fv(2 * x, l, r, v);
else
fv(2 * x, l, e[2 * x], v), fv(2 * x + 1, s[2 * x + 1], r, v);
ts[x] = ts[2 * x] + ts[2 * x + 1];
}
int fl(int x, int v) {
if (x >= p)
return s[x];
else if (t[x])
return e[x];
else if (tq[2 * x + 1] > v)
return fl(2 * x + 1, v);
else
return fl(2 * x, v);
}
long long fs(int x, int l, int r) {
if (l == s[x] && r == e[x])
return ts[x];
else if (t[x])
return t[x] * (r - l + 1ll);
else if (l >= s[2 * x + 1])
return fs(2 * x + 1, l, r);
else if (r <= e[2 * x])
return fs(2 * x, l, r);
else
return fs(2 * x, l, e[2 * x]) + fs(2 * x + 1, s[2 * x + 1], r);
}
pair<int, long long> fr(int x, int l, long long v) {
if (l == s[x]) {
if (v >= ts[x])
return {e[x] + 1, v - ts[x]};
else if (x >= p)
return {e[x], v};
else if (t[x])
return {l + v / t[x], v % t[x]};
else if (ts[2 * x] <= v)
return fr(2 * x + 1, s[2 * x + 1], v - ts[2 * x]);
else
return fr(2 * x, l, v);
} else if (t[x]) {
int c = v / t[x];
c = min(c, e[x] - l + 1);
return {l + c, v - t[x] * c};
} else if (l >= s[2 * x + 1])
return fr(2 * x + 1, l, v);
else {
pair<int, long long> pr = fr(2 * x, l, v);
if (pr.first == s[2 * x + 1])
return fr(2 * x + 1, s[2 * x + 1], pr.second);
else
return pr;
}
}
int main(void) {
for (int i = 0; i < p; i++) s[i + p] = e[i + p] = i;
for (int i = p - 1; i; i--) {
s[i] = s[2 * i];
e[i] = e[2 * i + 1];
}
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
ts[i + p] = a[i];
tq[i + p] = a[i];
}
for (int i = p - 1; i; i--) {
ts[i] = ts[2 * i] + ts[2 * i + 1];
tq[i] = max(tq[2 * i], tq[2 * i + 1]);
}
while (q--) {
int t, x, y;
scanf("%d %d %d", &t, &x, &y);
x--;
if (t == 1) {
int l = 0;
if (tq[1] >= y) l = max(l, fq(1, y) + 1);
if (l > x) continue;
fqq(1, l, x, y);
fv(1, l, x, y);
} else {
int c = 0;
while (1) {
int l = 0;
if (tq[1] > y) l = fl(1, y) + 1;
l = max(x, l);
if (l >= n) break;
pair<int, long long> pr = fr(1, l, y);
x = pr.first;
x = min(x, n);
c += x - l;
y = pr.second;
}
printf("%d\n", c);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 200005;
ll st[4 * N];
int lz[4 * N];
int n, q, a[N];
void prop(int p, int L, int R) {
if (lz[p]) {
st[p] = 1LL * (R - L + 1) * lz[p];
a[L] = a[R] = lz[p];
if (L < R) {
lz[2 * p] = lz[2 * p + 1] = lz[p];
}
lz[p] = 0;
}
}
void upd(int p, int L, int R, int i, int y) {
prop(p, L, R);
if (L > i or a[R] >= y) return;
if (a[L] <= y and R <= i) {
lz[p] = y;
prop(p, L, R);
return;
}
int mid = (L + R) / 2;
upd(2 * p, L, mid, i, y);
upd(2 * p + 1, mid + 1, R, i, y);
st[p] = st[2 * p] + st[2 * p + 1];
}
int query(int p, int L, int R, int i, int &y) {
prop(p, L, R);
if (R < i) return 0;
if (L >= i and y >= st[p]) {
y -= st[p];
return R - L + 1;
}
if (L == R) return 0;
if (a[R] > y) return 0;
int mid = (L + R) / 2;
int ans = query(2 * p, L, mid, i, y);
ans += query(2 * p + 1, mid + 1, R, i, y);
return ans;
}
void build(int p, int L, int R) {
if (L == R) {
st[p] = a[L];
return;
}
int mid = (L + R) / 2;
build(2 * p, L, mid);
build(2 * p + 1, mid + 1, R);
st[p] = st[2 * p] + st[2 * p + 1];
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
build(1, 1, n);
while (q--) {
int t, x, y;
scanf("%d %d %d", &t, &x, &y);
if (t == 1) {
upd(1, 1, n, x, y);
} else {
printf("%d\n", query(1, 1, n, x, y));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long sum[maxn << 2], mv[maxn << 2], col[maxn << 2];
void color(int l, int r, int rt, int c) {
mv[rt] = c;
sum[rt] = (r - l + 1) * 1ll * c;
col[rt] = c;
}
void pushcol(int l, int r, int rt) {
int mid = (l + r) >> 1;
if (col[rt]) {
color(l, mid, rt << 1, col[rt]);
color(mid + 1, r, rt << 1 | 1, col[rt]);
col[rt] = 0;
}
}
int a[maxn];
void update(int rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
mv[rt] = mv[rt << 1 | 1];
}
void build(int l, int r, int rt) {
col[rt] = 0;
if (l == r) {
mv[rt] = sum[rt] = a[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
update(rt);
}
int findpos(int l, int r, int rt, int lpos, int val) {
if (l == r) {
return r;
}
pushcol(l, r, rt);
int mid = (l + r) >> 1;
if (mv[rt << 1] <= val && mid >= lpos)
return findpos(l, mid, rt << 1, lpos, val);
else
return findpos(mid + 1, r, rt << 1 | 1, lpos, val);
}
long long getsum(int l, int r, int rt, int nl, int nr) {
if (nl <= l && nr >= r) {
return sum[rt];
}
pushcol(l, r, rt);
int mid = (l + r) >> 1;
long long ans = 0;
if (nl <= mid) ans += getsum(l, mid, rt << 1, nl, nr);
if (nr > mid) ans += getsum(mid + 1, r, rt << 1 | 1, nl, nr);
return ans;
}
void modify(int l, int r, int rt, int nl, int nr, int val) {
if (nl <= l && nr >= r) {
color(l, r, rt, val);
return;
}
pushcol(l, r, rt);
int mid = (l + r) >> 1;
if (nl <= mid) modify(l, mid, rt << 1, nl, nr, val);
if (nr > mid) modify(mid + 1, r, rt << 1 | 1, nl, nr, val);
update(rt);
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n + 1, 1);
while (q--) {
int c, x, y;
scanf("%d%d%d", &c, &x, &y);
if (c == 1) {
int pos = findpos(1, n + 1, 1, 1, y);
if (pos <= x) modify(1, n + 1, 1, pos, x, y);
} else {
int pos = findpos(1, n + 1, 1, x, y);
int ans = 0;
while (pos <= n) {
long long val = getsum(1, n + 1, 1, pos, pos);
int nxpos = min(pos + y / val - 1, (long long)n);
ans += nxpos - pos + 1;
y -= getsum(1, n + 1, 1, pos, nxpos);
pos = findpos(1, n + 1, 1, nxpos + 1, y);
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 31;
const long long INF = 1e18 + 5;
inline long long read() {
long long sum = 0, fh = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fh = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * fh;
}
inline int read2() {
char c = getchar();
while (c < '0' || c > '9') {
c = getchar();
}
return c - '0';
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
inline long long ab(long long x) { return x < 0 ? -x : x; }
long long a[N];
int n, m;
struct miaow {
int l, r;
long long imx, imi, sum;
long long bj;
} t[N * 4 + 3];
inline void upd(int o) {
if (t[o].bj) {
t[o].imx = t[o].imi = t[o].bj;
t[o].sum = t[o].bj * (t[o].r - t[o].l + 1);
return;
}
if (t[o].l == t[o].r) return;
t[o].imx = max(t[(o * 2)].imx, t[(o * 2 + 1)].imx);
t[o].imi = min(t[(o * 2)].imi, t[(o * 2 + 1)].imi);
t[o].sum = t[(o * 2)].sum + t[(o * 2 + 1)].sum;
}
inline void csh(int l, int r, int o) {
t[o].l = l, t[o].r = r, t[o].bj = 0;
if (l == r) {
t[o].imx = t[o].imi = t[o].sum = a[l];
return;
}
int mid = (l + r) >> 1;
csh(l, mid, (o * 2)), csh(mid + 1, r, (o * 2 + 1));
upd(o);
}
inline void pd(int o) {
if (!t[o].bj) return;
if (t[o].l != t[o].r) {
t[(o * 2)].bj = t[(o * 2 + 1)].bj = t[o].bj;
upd((o * 2)), upd((o * 2 + 1));
}
t[o].bj = 0;
}
inline long long cx1(int l, int r, int o) {
if (l <= t[o].l && r >= t[o].r) return t[o].sum;
pd(o);
int mid = (t[o].l + t[o].r) >> 1;
long long sum = 0;
if (l <= mid) sum += cx1(l, min(r, mid), (o * 2));
if (r > mid) sum += cx1(max(l, mid + 1), r, (o * 2 + 1));
return sum;
}
inline int cx2(int o, long long x) {
if (x >= t[o].sum) return n + 1;
if (t[o].l == t[o].r) return t[o].l;
pd(o);
if (t[(o * 2)].sum > x)
return cx2((o * 2), x);
else
return cx2((o * 2 + 1), x - t[(o * 2)].sum);
}
inline int cx3(int o, long long x) {
if (t[o].l == t[o].r) return t[o].r;
if (t[o].imi > x) return n + 1;
if (t[(o * 2)].imi > x)
return cx3((o * 2 + 1), x);
else
return cx3((o * 2), x);
}
inline void xg(int l, int r, int o, long long x) {
if (l <= t[o].l && r >= t[o].r) {
t[o].bj = x;
upd(o);
return;
}
pd(o);
int mid = (t[o].l + t[o].r) >> 1;
if (l <= mid) xg(l, min(r, mid), (o * 2), x);
if (r > mid) xg(max(l, mid + 1), r, (o * 2 + 1), x);
upd(o);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) a[i] = read();
csh(1, n, 1);
for (int i = 1; i <= m; ++i) {
long long o = read(), x = read(), y = read();
if (o == 1) {
int wz = cx3(1, y);
if (wz > x) continue;
xg(wz, x, 1, y);
} else {
long long ans = 0;
int wz = max((int)x, cx3(1, y));
while (wz <= n) {
long long z = (wz == 1) ? 0 : cx1(1, wz - 1, 1);
int wz2 = cx2(1, y + z) - 1;
ans += wz2 - wz + 1;
y -= cx1(wz, wz2, 1);
wz = max(wz2 + 1, cx3(1, y));
}
write(ans), putchar('\n');
}
}
}
|
#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>
using namespace std;
const int inf = 1e9 + 5;
const long long int inf64 = 1e18 + 5;
class segtree {
private:
vector<int64_t> value;
vector<int> min_val;
vector<int> op;
int size;
int n;
public:
segtree(int _n) : n(_n) {
size = 1;
while (size < _n) size *= 2;
value.assign(2 * size, 0);
min_val.assign(2 * size, 2e9);
op.assign(2 * size, 0);
}
void modify1(int64_t &a, int b, int len) {
if (b == 0) return;
a = 1LL * b * len;
}
void modify2(int &a, int b, int len) {
if (b == 0) return;
a = b * len;
}
void propogate(int x, int lx, int rx) {
if (rx - lx == 1 || op[x] == 0) return;
int m = (lx + rx) / 2;
modify1(value[2 * x + 1], op[x], m - lx);
modify1(value[2 * x + 2], op[x], rx - m);
modify2(min_val[2 * x + 1], op[x], 1);
modify2(min_val[2 * x + 2], op[x], 1);
modify2(op[2 * x + 1], op[x], 1);
modify2(op[2 * x + 2], op[x], 1);
op[x] = 0;
}
void build(vector<int> &v, int x, int lx, int rx) {
if (rx - lx == 1) {
if (lx < (int)v.size()) {
value[x] = v[lx];
min_val[x] = v[lx];
}
return;
}
int m = (lx + rx) / 2;
build(v, 2 * x + 1, lx, m);
build(v, 2 * x + 2, m, rx);
value[x] = value[2 * x + 1] + value[2 * x + 2];
min_val[x] = min(min_val[2 * x + 1], min_val[2 * x + 2]);
}
void upd(int l, int r, int v, int x, int lx, int rx) {
propogate(x, lx, rx);
if (l >= rx || lx >= r) return;
if (l <= lx && rx <= r) {
modify1(value[x], v, rx - lx);
modify2(min_val[x], v, 1);
modify2(op[x], v, 1);
return;
}
int m = (lx + rx) / 2;
upd(l, r, v, 2 * x + 1, lx, m);
upd(l, r, v, 2 * x + 2, m, rx);
value[x] = value[2 * x + 1] + value[2 * x + 2];
min_val[x] = min(min_val[2 * x + 1], min_val[2 * x + 2]);
}
int get_start_ind(int v, int x, int lx, int rx) {
propogate(x, lx, rx);
if (rx - lx == 1) return (min_val[x] <= v ? lx : -1);
int m = (lx + rx) / 2;
if (min_val[2 * x + 1] <= v) return get_start_ind(v, 2 * x + 1, lx, m);
return get_start_ind(v, 2 * x + 2, m, rx);
}
int get_end_ind(int64_t v, int x, int lx, int rx) {
propogate(x, lx, rx);
if (lx >= n) return -1;
if (rx - lx == 1) return (value[x] <= v ? lx : -1);
int m = (lx + rx) / 2;
int res = -1;
if (value[2 * x + 1] < v)
res = get_end_ind(v - value[2 * x + 1], 2 * x + 2, m, rx);
if (~res) return res;
return get_end_ind(v, 2 * x + 1, lx, m);
}
int64_t qry_sum(int l, int r, int x, int lx, int rx) {
propogate(x, lx, rx);
if (l >= rx || lx >= r) return 0;
if (l <= lx && rx <= r) return value[x];
int m = (lx + rx) / 2;
int64_t s1 = qry_sum(l, r, 2 * x + 1, lx, m);
int64_t s2 = qry_sum(l, r, 2 * x + 2, m, rx);
return s1 + s2;
}
void build(vector<int> &v) { build(v, 0, 0, size); }
void upd(int l, int r, int v) { upd(l, r, v, 0, 0, size); }
int64_t qry_sum(int l, int r) { return qry_sum(l, r, 0, 0, size); }
int get_start_ind(int v) { return get_start_ind(v, 0, 0, size); }
int get_end_ind(int64_t v) { return get_end_ind(v, 0, 0, size); }
};
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
segtree st(n);
st.build(a);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
int ind = st.get_start_ind(y);
if (~ind) st.upd(ind, x, y);
} else {
--x;
int ans = 0, start = x;
while (y > 0) {
if (start >= n) break;
int ind = st.get_start_ind(y);
if (ind == -1) break;
start = max(start, ind);
int en = st.get_end_ind(y + st.qry_sum(0, start));
ans += (en - start + 1);
y -= st.qry_sum(start, en + 1);
start = en + 1;
}
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct mn_mx {
long long mn, mx;
};
class seg_tree {
public:
seg_tree(long long n) {
while (x < n) x *= 2;
tree.resize(x * 2 - 1);
segments.resize(x * 2 - 1);
sum.resize(x * 2 - 1);
for (long long i = x - 1; i < x - 1 + n; i++)
cin >> tree[i].mn, tree[i].mx = tree[i].mn;
for (long long i = x - 1 + n; i < tree.size(); i++)
tree[i].mn = INT_MAX, tree[i].mx = tree[i].mn;
make_tree(0);
}
void make_tree(long long i) {
if (i >= x - 1) {
segments[i].first = i - x + 2;
segments[i].second = i - x + 2;
sum[i] = tree[i].mn;
return;
}
make_tree(i * 2 + 1);
make_tree(i * 2 + 2);
sum[i] = sum[i * 2 + 1] + sum[i * 2 + 2];
tree[i].mn = min(tree[i * 2 + 1].mn, tree[i * 2 + 2].mn);
tree[i].mx = max(tree[i * 2 + 1].mx, tree[i * 2 + 2].mx);
segments[i].first = segments[i * 2 + 1].first;
segments[i].second = segments[i * 2 + 2].second;
}
void update(long long i, long long id, long long y, long long mx = 0) {
mx = max(mx, tree[i].mn);
tree[i].mn = mx;
tree[i].mx = max(mx, tree[i].mx);
if (tree[i].mx == tree[i].mn) {
sum[i] = mx * (segments[i].second - segments[i].first + 1);
}
if (segments[i].first > id) return;
if (tree[i].mn > y) return;
if (segments[i].second > id) {
update(i * 2 + 1, id, y, mx);
update(i * 2 + 2, id, y, mx);
sum[i] = sum[i * 2 + 1] + sum[i * 2 + 2];
tree[i].mn = min(tree[i * 2 + 1].mn, tree[i * 2 + 2].mn);
tree[i].mx = max(tree[i * 2 + 1].mx, tree[i * 2 + 2].mx);
return;
}
if (tree[i].mx <= y) {
tree[i].mn = tree[i].mx = y;
sum[i] = y * (segments[i].second - segments[i].first + 1);
return;
}
if (i >= x - 1) return;
update(i * 2 + 1, id, y, mx);
update(i * 2 + 2, id, y, mx);
tree[i].mn = min(tree[i * 2 + 1].mn, tree[i * 2 + 2].mn);
tree[i].mx = max(tree[i * 2 + 1].mx, tree[i * 2 + 2].mx);
sum[i] = sum[i * 2 + 1] + sum[i * 2 + 2];
}
void calc_ans(long long i = 0, long long mx = 0) {
mx = max(tree[i].mn, mx);
tree[i].mn = mx;
tree[i].mx = max(tree[i].mx, mx);
if (tree[i].mx == tree[i].mn) {
sum[i] = mx * (segments[i].second - segments[i].first + 1);
}
if (left_segment > segments[i].second) return;
if (money < tree[i].mn) {
left_segment = segments[i].second + 1;
return;
}
if (left_segment > segments[i].first) {
if (i >= x - 1) return;
calc_ans(i * 2 + 1, mx);
calc_ans(i * 2 + 2, mx);
tree[i].mn = min(tree[i * 2 + 1].mn, tree[i * 2 + 2].mn);
tree[i].mx = max(tree[i * 2 + 1].mx, tree[i * 2 + 2].mx);
sum[i] = sum[i * 2 + 1] + sum[i * 2 + 2];
return;
}
if (money >= sum[i]) {
ans += segments[i].second - segments[i].first + 1;
money -= sum[i];
left_segment = segments[i].second + 1;
return;
}
if (i >= x - 1) return;
calc_ans(i * 2 + 1, mx);
calc_ans(i * 2 + 2, mx);
tree[i].mn = min(tree[i * 2 + 1].mn, tree[i * 2 + 2].mn);
tree[i].mx = max(tree[i * 2 + 1].mx, tree[i * 2 + 2].mx);
sum[i] = sum[i * 2 + 1] + sum[i * 2 + 2];
}
void to_money(long long y) { money = y; }
void to_left(long long id) { left_segment = id; }
void show() const {
long long a = 0;
for (const mn_mx& i : tree)
cout << i.mn << " " << i.mx << " " << sum[a++] << endl;
cout << endl;
}
long long get_ans() {
long long x = ans;
ans = 0;
return x;
}
private:
long long x = 1;
long long ans = 0, left_segment = 0, money;
vector<mn_mx> tree;
vector<long long> sum;
vector<pair<long long, long long>> segments;
};
int main() {
long long n, q;
cin >> n >> q;
seg_tree tree(n);
while (q--) {
long long t, id, y;
cin >> t >> id >> y;
if (t == 1)
tree.update(0, id, y);
else {
tree.to_left(id);
tree.to_money(y);
tree.calc_ans();
cout << tree.get_ans() << endl;
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {}
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100000], *p1 = buf + 100000, *pend = buf + 100000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(int &x) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
}
} // namespace fastIO
using namespace fastIO;
const double PI = acos(-1.0);
const double eps = 1e-8;
const int maxn = 2e5 + 7;
long long a[maxn];
long long mi[maxn << 2], lazy[maxn << 2], sum[maxn << 2];
void build(int l, int r, int rt) {
lazy[rt] = 0;
if (l == r) return mi[rt] = sum[rt] = a[l], void();
int mid = l + r >> 1;
build(l, mid, rt << 1), build(mid + 1, r, rt << 1 | 1);
mi[rt] = min(mi[rt << 1], mi[rt << 1 | 1]);
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void pushdown(int l, int r, int rt) {
if (lazy[rt] == 0) return;
mi[rt << 1] = mi[rt << 1 | 1] = lazy[rt << 1] = lazy[rt << 1 | 1] = lazy[rt];
int mid = l + r >> 1;
sum[rt << 1] = 1LL * (mid - l + 1) * lazy[rt];
sum[rt << 1 | 1] = 1LL * (r - mid) * lazy[rt];
lazy[rt] = 0;
}
void update(int L, int R, long long v, int l, int r, int rt) {
if (L <= l && r <= R) {
lazy[rt] = v;
sum[rt] = (r - l + 1) * 1LL * v;
mi[rt] = v;
return;
}
int mid = l + r >> 1;
pushdown(l, r, rt);
if (L <= mid) update(L, R, v, l, mid, rt << 1);
if (mid < R) update(L, R, v, mid + 1, r, rt << 1 | 1);
mi[rt] = min(mi[rt << 1], mi[rt << 1 | 1]);
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
int querymx(int l, int r, int rt, long long v) {
if (l == r) return l;
int mid = l + r >> 1;
pushdown(l, r, rt);
if (mi[rt << 1] <= v) return querymx(l, mid, rt << 1, v);
return querymx(mid + 1, r, rt << 1 | 1, v);
}
long long Sum(int L, int R, int l, int r, int rt) {
if (R < L) return 0;
if (L <= l && r <= R) return sum[rt];
int mid = l + r >> 1;
pushdown(l, r, rt);
long long ans = 0;
if (L <= mid) ans = Sum(L, R, l, mid, rt << 1);
if (mid < R) ans += Sum(L, R, mid + 1, r, rt << 1 | 1);
return ans;
}
int query(long long tmp, int l, int r, int rt) {
if (l == r) return sum[rt] <= tmp ? l : l - 1;
int mid = l + r >> 1;
pushdown(l, r, rt);
if (sum[rt << 1] == tmp)
return mid;
else if (sum[rt << 1] > tmp)
return query(tmp, l, mid, rt << 1);
else
return query(tmp - sum[rt << 1], mid + 1, r, rt << 1 | 1);
}
int main() {
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 = 1; i <= q; ++i) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
int p = n;
if (mi[1] <= y) p = querymx(1, n, 1, y);
if (p <= x) update(p, x, y, 1, n, 1);
} else {
int ans = 0;
int now = x;
while (y >= mi[1] && now <= n) {
now = max(now, querymx(1, n, 1, y));
long long s = Sum(1, now - 1, 1, n, 1);
long long nxt = query(s + y, 1, n, 1);
ans += nxt - now + 1;
y -= Sum(1, nxt, 1, n, 1) - s;
now = nxt + 1;
}
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2e5 + 42;
int n, q, inp[nmax];
struct info {
long long sum;
int lazy;
int cnt;
int maxi, mini;
};
info tree[4 * nmax];
info actual(info cur) {
if (cur.lazy) {
cur.sum = 1LL * cur.cnt * cur.lazy;
cur.mini = cur.lazy;
cur.maxi = cur.lazy;
cur.lazy = 0;
}
return cur;
}
info my_merge(info l, info r) {
l = actual(l);
r = actual(r);
info ret;
ret.sum = l.sum + r.sum;
ret.lazy = 0;
ret.cnt = l.cnt + r.cnt;
ret.maxi = max(l.maxi, r.maxi);
ret.mini = min(l.mini, r.mini);
ret.cnt = l.cnt + r.cnt;
return ret;
}
void push(int node) {
if (tree[node].lazy) {
tree[node * 2].lazy = tree[node].lazy;
tree[node * 2 + 1].lazy = tree[node].lazy;
}
return;
}
void update(int node, int l, int r, int lq, int rq, int val) {
if (l == lq && r == rq) {
tree[node].cnt = r - l + 1;
tree[node].lazy = val;
return;
}
push(node);
int av = (l + r) / 2;
if (lq <= av) update(node * 2, l, av, lq, min(av, rq), val);
if (av < rq) update(node * 2 + 1, av + 1, r, max(av + 1, lq), rq, val);
tree[node] = my_merge(tree[node * 2], tree[node * 2 + 1]);
}
int query(int node, int l, int r, int pos) {
if (l == r) return actual(tree[node]).sum;
push(node);
int av = (l + r) / 2, ret;
if (pos <= av)
ret = query(node * 2, l, av, pos);
else
ret = query(node * 2 + 1, av + 1, r, pos);
tree[node] = my_merge(tree[node * 2], tree[node * 2 + 1]);
return ret;
}
int move_nxt(int node, int l, int r, int val) {
if (l == r) return l;
push(node);
tree[node] = my_merge(tree[node * 2], tree[node * 2 + 1]);
int av = (l + r) / 2, ret;
if (actual(tree[node * 2]).mini <= val)
ret = move_nxt(node * 2, l, av, val);
else
ret = move_nxt(node * 2 + 1, av + 1, r, val);
tree[node] = my_merge(tree[node * 2], tree[node * 2 + 1]);
return ret;
}
int cur_le, cur_sum;
bool move_fast(int node, int l, int r, int lq, int rq) {
if (l == lq && r == rq) {
if (actual(tree[node]).sum <= cur_sum) {
cur_sum = cur_sum - actual(tree[node]).sum;
cur_le = r + 1;
return 1;
}
if (l == r) return 0;
}
push(node);
int av = (l + r) / 2;
if (lq <= av) {
if (move_fast(node * 2, l, av, lq, min(av, rq)) == 0) return 0;
}
if (av < rq) {
if (move_fast(node * 2 + 1, av + 1, r, max(av + 1, lq), rq) == 0) return 0;
}
return 1;
}
int go(int le, int sum) {
if (le > n) return 0;
cur_le = le;
cur_sum = sum;
move_fast(1, 1, n, le, n);
int ret = cur_le - le;
if (cur_le > n) return ret;
if (cur_sum >= query(1, 1, n, n))
return go(move_nxt(1, 1, n, cur_sum), cur_sum) + ret;
return ret;
}
int main() {
scanf("%i%i", &n, &q);
for (int i = 1; i <= n; i++) scanf("%i", &inp[i]);
for (int i = 1; i <= n; i++) update(1, 1, n, i, i, inp[i]);
for (int i = 1; i <= q; i++) {
int type;
scanf("%i", &type);
if (type == 1) {
int x, val;
scanf("%i%i", &x, &val);
if (query(1, 1, n, x) > val) continue;
int ok = move_nxt(1, 1, n, val);
if (ok <= x) update(1, 1, n, ok, x, val);
} else {
int le, val;
scanf("%i%i", &le, &val);
printf("%i\n", go(le, val));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int n, q, mx[maxn << 2], a[maxn], cnt[maxn << 2], lazy[maxn << 2],
mn[maxn << 2];
long long t[maxn << 2];
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] = mx[v] = x;
t[v] = 1LL * cnt[v] * x;
}
void push(int v, int tl, int tr) {
if (tl != tr and 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 md = (tl + tr) >> 1;
build(2 * v, tl, md);
build(2 * v + 1, md + 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 or r < tl) return;
if (mn[v] >= x) return;
if (tl >= l and tr <= r and mx[v] < x) {
apply(v, x);
return;
}
push(v, tl, tr);
int md = (tl + tr) >> 1;
do_max(2 * v, tl, md, l, r, x);
do_max(2 * v + 1, md + 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 and tr == r) {
if (y >= t[v]) {
y -= t[v];
return cnt[v];
}
if (mn[v] > y) return 0;
int md = (tl + tr) >> 1;
int d1 = go(2 * v, tl, md, l, md, y);
int d2 = go(2 * v + 1, md + 1, tr, md + 1, r, y);
return d1 + d2;
}
int md = (tl + tr) >> 1;
if (r <= md)
return go(2 * v, tl, md, l, r, y);
else if (l > md)
return go(2 * v + 1, md + 1, tr, l, r, y);
else {
int d1 = go(2 * v, tl, md, l, md, y);
int d2 = go(2 * v + 1, md + 1, tr, md + 1, r, y);
return d1 + d2;
}
}
int main() {
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 type, x, y;
cin >> type >> x >> y;
if (type == 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;
const int N = 200005;
long long marked[4 * N + 50], t[4 * N + 50], val[4 * N + 50];
long long prep[4 * N + 50], prep2[4 * N + 50];
void push(int v, int l, int r) {
if (marked[v]) {
t[v] = marked[v] * (r - l + 1);
val[v] = marked[v];
if (l != r) marked[v * 2] = marked[v * 2 + 1] = marked[v];
marked[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, int new_val) {
push(v, tl, tr);
if (l > r) return;
if (tr < l or tl > r) return;
if (tl >= l and tr <= r) {
marked[v] = new_val;
push(v, tl, tr);
} else {
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), new_val);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, new_val);
t[v] = t[v * 2] + t[v * 2 + 1];
val[v] = max(val[v * 2], val[v * 2 + 1]);
}
}
long long get(int v, int tl, int tr, int l, int r) {
push(v, tl, tr);
if (l > r) return 0;
if (tr < l or tl > r) return 0;
if (tl >= l and tr <= r) return t[v];
int tm = (tl + tr) / 2;
return get(v * 2, tl, tm, l, r) + get(v * 2 + 1, tm + 1, tr, l, r);
}
int kth(int v, int tl, int tr, int l, int limit) {
push(v, tl, tr);
if (tr < l) return -1;
if (tl == tr) {
if (val[v] <= limit)
return tl;
else
return tl - 1;
}
if (tl >= l) {
int tm = (tl + tr) / 2;
push(v * 2, tl, tm);
if (t[v * 2] > limit) {
return kth(v * 2, tl, tm, l, limit);
} else {
return kth(v * 2 + 1, tm + 1, tr, l, limit - t[v * 2]);
}
} else {
int tm = (tl + tr) / 2;
if (prep[v * 2] > limit) {
return kth(v * 2, tl, tm, l, limit);
} else {
return kth(v * 2 + 1, tm + 1, tr, l, limit - prep[v * 2]);
}
}
}
int findFirst(int v, int tl, int tr, int l, int limit) {
push(v, tl, tr);
if (tr < l) return l;
if (tl == tr) {
if (val[v] <= limit)
return tl;
else
return tl + 1;
}
int tm = (tl + tr) / 2;
push(v * 2 + 1, tm + 1, tr);
if (val[v * 2 + 1] > limit)
return findFirst(v * 2 + 1, tm + 1, tr, l, limit);
else
return findFirst(v * 2, tl, tm, l, limit);
}
pair<long long, int> dfs(int v, int tl, int tr, int l) {
push(v, tl, tr);
if (tr < l) {
prep[v] = 0;
prep2[v] = 1012345678;
return make_pair(0, 1012345678);
}
if (tl >= l) {
prep[v] = t[v];
prep2[v] = val[v];
return make_pair(t[v], val[v]);
}
int tm = (tl + tr) / 2;
auto p1 = dfs(v * 2, tl, tm, l);
auto p2 = dfs(v * 2 + 1, tm + 1, tr, l);
prep[v] = p1.first + p2.first;
prep2[v] = min(p1.second, p2.second);
return make_pair(prep[v], prep2[v]);
}
void build_tree(int v, int tl, int tr, vector<int> &a) {
if (tl == tr) {
t[v] = val[v] = a[tl];
} else {
int tm = (tl + tr) / 2;
build_tree(v * 2, tl, tm, a);
build_tree(v * 2 + 1, tm + 1, tr, a);
t[v] = t[v * 2] + t[v * 2 + 1];
val[v] = max(val[v * 2], val[v * 2 + 1]);
}
}
int main() {
int t = 1;
while (t--) {
int n, q;
scanf("%d %d", &n, &q);
vector<int> a(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
build_tree(1, 0, n - 1, a);
while (q--) {
int t, x, y;
scanf("%d %d %d", &t, &x, &y);
x--;
if (t == 1) {
int l = 0, r = x;
while (l <= r) {
int m = (l + r) / 2;
long long val = get(1, 0, n - 1, m, m);
if (val < y) {
r = m - 1;
} else {
l = m + 1;
}
}
if (r == x) continue;
update(1, 0, n - 1, r + 1, x, y);
} else {
int l = x, r = n - 1;
int ans = 0;
while (l <= r) {
dfs(1, 0, n - 1, l);
int f = findFirst(1, 0, n - 1, l, y);
if (f == n) break;
l = f;
dfs(1, 0, n - 1, l);
int next = kth(1, 0, n - 1, l, y);
long long sum = get(1, 0, n - 1, l, next);
ans += next - l + 1;
y -= sum;
l = next + 1;
}
printf("%d\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200010], bl[200010], fl[200010], fr[200010], tg[200010 / 223 + 5];
long long sc[200010 / 223 + 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 / 223, 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 long long maxn = 2e5 + 5;
long long stmn[4 * maxn], stsum[4 * maxn], lazy[4 * maxn];
long long N, a[maxn], Q;
void push(long long id, long long l, long long r) {
if (lazy[id] == 0) return;
stmn[id] = lazy[id];
stsum[id] = (r - l + 1) * lazy[id];
if (l != r) {
lazy[id << 1] = lazy[id];
lazy[id << 1 | 1] = lazy[id];
}
lazy[id] = 0;
}
void pull(long long id) {
stsum[id] = stsum[id << 1] + stsum[id << 1 | 1];
stmn[id] = min(stmn[id << 1], stmn[id << 1 | 1]);
}
void build(long long id, long long l, long long r) {
if (l == r) {
stmn[id] = stsum[id] = a[l];
return;
}
long long mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
pull(id);
}
void modify(long long L, long long R, long long v, long long id = 1,
long long l = 1, long long r = N) {
push(id, l, r);
if (R < l || r < L) return;
if (L <= l && r <= R) {
lazy[id] = v;
push(id, l, r);
return;
}
long long mid = (l + r) / 2;
modify(L, R, v, id << 1, l, mid);
modify(L, R, v, id << 1 | 1, mid + 1, r);
pull(id);
}
long long findfirst(long long val, long long id = 1, long long l = 1,
long long r = N) {
push(id, l, r);
if (stmn[id] > val) return N + 1;
if (l == r) {
if (stmn[id] <= val) return l;
return N + 1;
}
long long mid = (l + r) / 2;
push(id << 1, l, mid);
push(id << 1 | 1, mid + 1, r);
if (stmn[id << 1] <= val) return findfirst(val, id << 1, l, mid);
return findfirst(val, id << 1 | 1, mid + 1, r);
}
long long getval(long long L, long long R, long long id = 1, long long l = 1,
long long r = N) {
push(id, l, r);
if (R < l || r < L) return 0;
if (L <= l && r <= R) {
return stsum[id];
}
long long mid = (l + r) / 2;
return getval(L, R, id << 1, l, mid) + getval(L, R, id << 1 | 1, mid + 1, r);
}
long long findfirstsum(long long val, long long id = 1, long long l = 1,
long long r = N) {
push(id, l, r);
if (l == r) {
if (stsum[id] > val) return l;
return N + 1;
}
long long mid = (l + r) / 2;
push(id << 1, l, mid);
push(id << 1 | 1, mid + 1, r);
if (stsum[id << 1] <= val)
return findfirstsum(val - stsum[id << 1], id << 1 | 1, mid + 1, r);
return findfirstsum(val, id << 1, l, mid);
}
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> Q;
for (long long i = 1; i <= N; ++i) {
cin >> a[i];
}
build(1, 1, N);
for (long long i = 1; i <= Q; ++i) {
long long type;
cin >> type;
long long x, y;
cin >> x >> y;
if (type == 1) {
long long pos = findfirst(y);
if (pos <= x) modify(pos, x, y);
} else {
long long ret = 0;
while (x <= N && y > 0) {
x = max(x, findfirst(y));
long long psum = getval(1, x - 1);
long long nxtpos = findfirstsum(psum + y);
if (i == Q) cerr << x << ' ' << y << ' ' << nxtpos << '\n';
if (nxtpos == x) {
break;
} else {
y -= getval(x, nxtpos - 1);
ret += nxtpos - x;
x = nxtpos;
}
}
cout << ret << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, opt, x;
long long a[200011], y;
struct segment_tree {
long long minn[800011], sum[800011], tag[800011];
void build(int k, int l, int r) {
if (l == r) {
sum[k] = minn[k] = a[l];
return;
}
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
minn[k] = min(minn[k << 1], minn[k << 1 | 1]);
sum[k] = sum[k << 1] + sum[k << 1 | 1];
}
void pushdown(int k, int l, int r) {
if (tag[k]) {
int mid = (l + r) >> 1;
tag[k << 1] = tag[k << 1 | 1] = tag[k];
minn[k << 1] = minn[k << 1 | 1] = tag[k];
sum[k << 1] = (mid - l + 1) * tag[k];
sum[k << 1 | 1] = (r - mid) * tag[k];
tag[k] = 0;
}
}
void modify(int k, int l, int r, int L, int R, long long num) {
if (l >= L && r <= R) {
minn[k] = num;
tag[k] = num;
sum[k] = (r - l + 1) * num;
return;
}
pushdown(k, l, r);
int mid = (l + r) >> 1;
if (L <= mid) modify(k << 1, l, mid, L, R, num);
if (R > mid) modify(k << 1 | 1, mid + 1, r, L, R, num);
minn[k] = min(minn[k << 1], minn[k << 1 | 1]);
sum[k] = sum[k << 1] + sum[k << 1 | 1];
}
int binary(int k, int l, int r, long long num) {
if (l == r) {
if (minn[k] <= num) return l;
return n + 1;
}
pushdown(k, l, r);
int mid = (l + r) >> 1;
if (minn[k << 1] <= num) return binary(k << 1, l, mid, num);
if (minn[k << 1 | 1] <= num) return binary(k << 1 | 1, mid + 1, r, num);
return n + 1;
}
int binary1(int k, int l, int r, long long num) {
if (sum[k] <= num) return n + 1;
if (l == r) return l;
pushdown(k, l, r);
int mid = (l + r) >> 1;
if (sum[k << 1] > num) return binary1(k << 1, l, mid, num);
return binary1(k << 1 | 1, mid + 1, r, num - sum[k << 1]);
}
long long query(int k, int l, int r, int L, int R) {
if (L > R) return 0;
if (l >= L && r <= R) return sum[k];
pushdown(k, l, r);
int mid = (l + r) >> 1;
long long ret = 0;
if (L <= mid) ret += query(k << 1, l, mid, L, R);
if (R > mid) ret += query(k << 1 | 1, mid + 1, r, L, R);
return ret;
}
} t;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
t.build(1, 1, n);
for (int i = 1; i <= q; i++) {
scanf("%d%d%lld", &opt, &x, &y);
if (opt == 1) {
int w = t.binary(1, 1, n, y);
if (w > x) continue;
t.modify(1, 1, n, w, x, y);
} else {
y += t.query(1, 1, n, 1, x - 1);
int w = t.binary(1, 1, n, y), ans = -(x - 1);
while (w != n + 1) {
long long sum = t.query(1, 1, n, 1, w - 1);
int r = t.binary1(1, 1, n, y + sum) - 1;
ans += (r - w + 1);
if (r == n) break;
y -= t.query(1, 1, n, w, r);
w = t.binary(1, 1, n, y);
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
int mst[4 * 200005], lz[4 * 200005];
long long st[4 * 200005];
void push(int si, int ss, int se) {
if (lz[si] != -1) {
if (ss != se) {
lz[2 * si + 1] = lz[si];
lz[2 * si + 2] = lz[si];
}
st[si] = 1ll * (se - ss + 1) * lz[si];
mst[si] = lz[si];
lz[si] = -1;
}
}
int findind(int si, int ss, int se, int y) {
push(si, ss, se);
if (mst[si] >= y) {
return 2e9;
}
if (ss == se) {
return ss;
}
int mid = (ss + se) >> 1;
if (mst[2 * si + 1] < y) {
return findind(2 * si + 1, ss, mid, y);
} else {
return findind(2 * si + 2, mid + 1, se, y);
}
}
void update(int si, int ss, int se, int l, int r, int val) {
push(si, ss, se);
if (se < l || ss > r) return;
if (ss >= l && se <= r) {
if (ss != se) {
lz[2 * si + 1] = val;
lz[2 * si + 2] = val;
}
mst[si] = val;
st[si] = 1ll * (se - ss + 1) * val;
return;
}
int mid = (ss + se) >> 1;
update(2 * si + 1, ss, mid, l, r, val);
update(2 * si + 2, mid + 1, se, l, r, val);
mst[si] = min(mst[2 * si + 1], mst[2 * si + 2]);
st[si] = st[2 * si + 1] + st[2 * si + 2];
return;
}
pair<long long, int> query(int si, int ss, int se, int ind, long long val) {
if (se < ind) {
return {0, -1};
}
push(si, ss, se);
if (ss == se) {
if (st[si] > val) {
return {0, ss};
}
}
if (ss >= ind) {
if (st[si] <= val) {
return {st[si], -1};
}
}
int mid = (ss + se) >> 1;
auto pa = query(2 * si + 1, ss, mid, ind, val);
if (pa.second != -1) {
return pa;
} else {
auto pb = query(2 * si + 2, mid + 1, se, ind, val - pa.first);
return {pb.first + pa.first, pb.second};
}
}
int main() {
memset(lz, -1, sizeof(lz));
int n, q;
scanf("%d%d", &n, &q);
for (int i = 0, v; i < n; i++) {
scanf("%d", &v);
update(0, 0, n - 1, i, i, v);
}
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
x--;
if (t == 1) {
int ind = findind(0, 0, n - 1, y);
if (ind <= x) {
update(0, 0, n - 1, ind, x, y);
}
} else {
int ans = 0;
while (x < n) {
auto p = query(0, 0, n - 1, x, y);
if (p.second == -1) {
ans += n - x;
break;
} else if (p.second == x) {
x = findind(0, 0, n - 1, y + 1);
} else {
ans += p.second - x;
x = p.second;
y -= p.first;
}
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2e5 + 9, M = 6e6 + 10;
int n, q;
int a[N];
struct node {
int l, r, len;
long long sum, mi, lzy;
} tr[N << 2];
void pushup(int rt) {
tr[rt].sum = tr[rt << 1].sum + tr[rt << 1 | 1].sum;
tr[rt].mi = min(tr[rt << 1 | 1].mi, tr[rt << 1].mi);
}
void pushdown(int rt) {
if (tr[rt].lzy) {
long long lzy = tr[rt].lzy;
tr[rt << 1].lzy = max(lzy, tr[rt << 1].lzy);
tr[rt << 1].mi = (lzy);
tr[rt << 1].sum = lzy * tr[rt << 1].len;
tr[rt << 1 | 1].lzy = max(lzy, tr[rt << 1 | 1].lzy);
tr[rt << 1 | 1].mi = (lzy);
tr[rt << 1 | 1].sum = lzy * tr[rt << 1 | 1].len;
tr[rt].lzy = 0;
}
}
void build(int rt, int l, int r) {
if (l == r) {
tr[rt] = {l, l, 1, a[l], a[l], 0};
return;
}
int mid = (l + r) >> 1;
tr[rt] = {l, r, r - l + 1};
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void update(int rt, int l, int r, long long d) {
if (l <= tr[rt].l && r >= tr[rt].r) {
tr[rt].lzy = max(d, tr[rt].lzy);
tr[rt].mi = (d);
tr[rt].sum = d * tr[rt].len;
return;
}
pushdown(rt);
int mid = (tr[rt].l + tr[rt].r) >> 1;
if (mid >= l) update(rt << 1, l, r, d);
if (mid < r) update(rt << 1 | 1, l, r, d);
pushup(rt);
}
int query1(int rt, long long d) {
if (tr[rt].len == 1) return tr[rt].l;
int mid = (tr[rt].l + tr[rt].r) >> 1;
pushdown(rt);
if (tr[rt << 1].mi < d)
return query1(rt << 1, d);
else
return query1(rt << 1 | 1, d);
}
int query(int rt, int l, int r, int &d) {
int sum = 0;
if (tr[rt].mi > d) return 0;
if (tr[rt].l >= l && tr[rt].r <= r && tr[rt].sum <= d) {
d -= tr[rt].sum;
return tr[rt].len;
}
pushdown(rt);
int mid = (tr[rt].l + tr[rt].r) >> 1;
if (mid >= l) sum += query(rt << 1, l, r, d);
if (mid < r) sum += query(rt << 1 | 1, l, r, d);
return sum;
}
void solve() {
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) {
if (tr[1].mi < y) {
int pos = query1(1, y);
if (pos <= x) update(1, pos, x, y);
}
} else {
printf("%d\n", query(1, x, n, y));
}
}
}
int main() {
int _;
_ = 1;
while (_--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
inline void print(long long x) {
if (x < 0) putchar('-'), x = ~x + 1;
if (x >= 10) print(x / 10);
putchar((x % 10) | 48);
}
long long n, q;
long long a[200010];
long long sum[800010], minn[800010], tag[800010], maxn[800010];
void pushup(long long p) {
sum[p] = sum[p << 1] + sum[p << 1 | 1];
minn[p] = min(minn[p << 1], minn[p << 1 | 1]);
maxn[p] = max(maxn[p << 1], maxn[p << 1 | 1]);
}
void pushdown(long long p, long long l, long long r) {
if (tag[p]) {
tag[p << 1] = tag[p << 1 | 1] = tag[p];
minn[p << 1] = minn[p << 1 | 1] = maxn[p << 1] = maxn[p << 1 | 1] = tag[p];
long long mid = l + r >> 1;
sum[p << 1] = tag[p] * (mid - l + 1);
sum[p << 1 | 1] = tag[p] * (r - mid);
tag[p] = 0;
}
}
void build(long long p, long long l, long long r) {
if (l == r) {
sum[p] = minn[p] = maxn[p] = a[l];
return;
}
long long mid = l + r >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
pushup(p);
}
void update(long long p, long long l, long long r, long long L, long long R,
long long k) {
if (L > R) return;
if (minn[p] > k) return;
if (l >= L && r <= R && maxn[p] <= k) {
sum[p] = k * (r - l + 1);
minn[p] = maxn[p] = k;
tag[p] = k;
return;
}
pushdown(p, l, r);
long long mid = l + r >> 1;
if (L <= mid) update(p << 1, l, mid, L, R, k);
if (R > mid) update(p << 1 | 1, mid + 1, r, L, R, k);
pushup(p);
}
long long query(long long p, long long l, long long r, long long L,
long long &k) {
if (minn[p] > k) return 0;
if (sum[p] <= k && l >= L && r <= n) {
k -= sum[p];
return r - l + 1;
}
if (l == r) return 0;
pushdown(p, l, r);
long long mid = l + r >> 1;
long long res = 0;
if (L <= mid) res += query(p << 1, l, mid, L, k);
return res + query(p << 1 | 1, mid + 1, r, L, k);
}
signed main() {
memset(minn, 0x3f, sizeof(minn));
n = read(), q = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
a[0] = 0x3f3f3f3f, a[n + 1] = 0;
build(1, 0, n + 1);
while (q--) {
long long op = read();
long long x = read(), y = read();
if (op == 1) {
update(1, 0, n + 1, 1, x, y);
} else {
printf("%d\n", query(1, 0, n + 1, x, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200010], bl[200010], fl[200010], fr[200010], tg[200010 / 393 + 5];
long long sc[200010 / 393 + 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 / 393, 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>
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
const int Maxn = 200000;
int n, q;
int a[Maxn + 5];
struct Segment_Node {
long long sum;
int maxn, minn;
int lazy;
} seg[Maxn << 2 | 5];
void update_tag(int root, int a, int left, int right) {
if (a >= seg[root].maxn) {
seg[root].maxn = seg[root].minn = a;
seg[root].sum = 1ll * (right - left + 1) * a;
seg[root].lazy = a;
}
}
void push_down(int root, int left, int right) {
if (seg[root].lazy) {
int mid = (left + right) >> 1;
update_tag(root << 1, seg[root].lazy, left, mid);
update_tag(root << 1 | 1, seg[root].lazy, mid + 1, right);
seg[root].lazy = 0;
}
}
void push_up(int root) {
seg[root].minn = min(seg[root << 1].minn, seg[root << 1 | 1].minn);
seg[root].maxn = max(seg[root << 1].maxn, seg[root << 1 | 1].maxn);
seg[root].sum = seg[root << 1].sum + seg[root << 1 | 1].sum;
}
void build(int root = 1, int left = 1, int right = n) {
seg[root].lazy = 0;
if (left == right) {
seg[root].maxn = seg[root].minn = seg[root].sum = a[left];
return;
}
int mid = (left + right) >> 1;
build(root << 1, left, mid);
build(root << 1 | 1, mid + 1, right);
push_up(root);
}
void update(int l, int r, int a, int root = 1, int left = 1, int right = n) {
if (l > right || r < left) {
return;
}
if (l <= left && r >= right) {
if (seg[root].minn >= a) {
return;
}
if (a >= seg[root].maxn) {
update_tag(root, a, left, right);
return;
}
}
push_down(root, left, right);
int mid = (left + right) >> 1;
update(l, r, a, root << 1, left, mid);
update(l, r, a, root << 1 | 1, mid + 1, right);
push_up(root);
}
int query(int l, int r, int &val, int root = 1, int left = 1, int right = n) {
if (l > right || r < left) {
return 0;
}
if (l <= left && r >= right) {
if (val >= seg[root].sum) {
val -= seg[root].sum;
return right - left + 1;
}
if (val < seg[root].minn) {
return 0;
}
}
push_down(root, left, right);
int mid = (left + right) >> 1;
return query(l, r, val, root << 1, left, mid) +
query(l, r, val, root << 1 | 1, mid + 1, right);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
build();
for (int i = 1; i <= q; i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int x, y;
scanf("%d%d", &x, &y);
update(1, x, y);
} else {
int x, y;
scanf("%d%d", &x, &y);
printf("%d\n", query(x, n, y));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 7;
long long n, m, p, a[maxn];
struct node {
long long l, r, mi, sum, lazy;
} t[maxn * 4];
struct segtree {
void pushup(long long k) {
t[k].mi = t[k * 2 + 1].mi;
t[k].sum = t[k * 2].sum + t[k * 2 + 1].sum;
}
void pushdown(long long k) {
if (t[k].lazy) {
t[k * 2].lazy = t[k].lazy;
t[k * 2 + 1].lazy = t[k].lazy;
t[k * 2].mi = t[k].lazy;
t[k * 2 + 1].mi = t[k].lazy;
t[k * 2].sum = t[k].lazy * (t[k * 2].r - t[k * 2].l + 1);
t[k * 2 + 1].sum = t[k].lazy * (t[k * 2 + 1].r - t[k * 2 + 1].l + 1);
t[k].lazy = 0;
}
}
void build(long long l, long long r, long long k = 1) {
t[k].l = l;
t[k].r = r;
t[k].lazy = 0;
if (l == r) {
t[k].sum = a[l];
t[k].mi = a[l];
return;
}
long long mid = (l + r) / 2;
build(l, mid, k * 2);
build(mid + 1, r, k * 2 + 1);
pushup(k);
}
void update(long long l, long long r, long long x, long long k = 1) {
if (l <= t[k].l && t[k].r <= r) {
t[k].sum = (t[k].r - t[k].l + 1) * x;
t[k].lazy = x;
t[k].mi = x;
return;
}
pushdown(k);
if (t[k * 2].r >= l) update(l, r, x, k * 2);
if (t[k * 2 + 1].l <= r) update(l, r, x, k * 2 + 1);
pushup(k);
}
long long search(long long l, long long r, long long x, long long k = 1) {
if (t[k].mi > x || l > r) return 0;
if (t[k].l == t[k].r) return t[k].l;
long long res = 0;
pushdown(k);
if (t[k * 2].r >= l) res = search(l, r, x, k * 2);
if (res == 0 && t[k * 2 + 1].l <= r) res = search(l, r, x, k * 2 + 1);
pushup(k);
return res;
}
long long find(long long l, long long r, long long k = 1) {
if (t[k].mi > p || t[k].l == 0) return 0;
if (l <= t[k].l && t[k].r <= r) {
if (t[k].sum <= p) {
p -= t[k].sum;
return t[k].r - t[k].l + 1;
}
}
long long ans = 0;
pushdown(k);
if (t[k * 2].r >= l) ans += find(l, r, k * 2);
if (t[k * 2 + 1].l <= r) ans += find(l, r, k * 2 + 1);
pushup(k);
return ans;
}
} st;
signed main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
st.build(1, n);
long long op, x, y;
while (m--) {
scanf("%lld%lld%lld", &op, &x, &y);
if (op == 1) {
long long ans = st.search(1, x, y);
if (ans) {
st.update(ans, x, y);
}
} else {
p = y;
long long ans = st.find(x, n);
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
void read(T& re) {
re = 0;
int re2 = 1;
char ch = '!';
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') re2 = -1, ch = getchar();
while (ch >= '0' && ch <= '9') {
re = re * 10 + ch - '0';
ch = getchar();
}
re *= re2;
}
template <typename T, typename... Args>
void read(T& re, Args&... args) {
read(re);
read(args...);
}
template <typename T>
void write(T A) {
if (A < 0) {
A = -A;
putchar('-');
}
if (A / 10) write(A / 10);
putchar(A % 10 + '0');
}
int T;
const int MAXN = 2e5 + 7;
int n, q;
struct node {
long long sum;
int maxn, minn, tag;
} tr[MAXN * 6];
void pushdown(int l, int r, int now) {
if (l == r) return;
int mid = (l + r) >> 1;
if (tr[now].tag) {
tr[now << 1].sum = (mid - l + 1) * (long long)tr[now].tag;
tr[now << 1].minn = tr[now << 1].maxn = tr[now].tag;
tr[now << 1 | 1].sum = (r - mid) * (long long)tr[now].tag;
tr[now << 1 | 1].minn = tr[now << 1 | 1].maxn = tr[now].tag;
tr[now << 1].tag = tr[now << 1 | 1].tag = tr[now].tag;
tr[now].tag = 0;
}
}
void update(int now) {
tr[now].sum = tr[now << 1].sum + tr[now << 1 | 1].sum;
tr[now].maxn =
(tr[now << 1].maxn > tr[now << 1 | 1].maxn ? tr[now << 1].maxn
: tr[now << 1 | 1].maxn);
tr[now].minn =
(tr[now << 1].minn > tr[now << 1 | 1].minn ? tr[now << 1 | 1].minn
: tr[now << 1].minn);
}
void change(int X, int L, int R, int l = 1, int r = n, int now = 1) {
pushdown(l, r, now);
if (L > r || R < l) return;
if (L <= l && R >= r) {
tr[now].sum = (r - l + 1) * (long long)X;
tr[now].minn = tr[now].maxn = X;
tr[now].tag = X;
return;
}
int mid = (l + r) >> 1;
change(X, L, R, l, mid, now << 1);
change(X, L, R, mid + 1, r, now << 1 | 1);
update(now);
}
long long find0(int P, int l = 1, int r = n, int now = 1) {
pushdown(l, r, now);
if (l == r) {
if (P >= r)
return tr[now].sum;
else
return 0;
}
int mid = (l + r) >> 1;
if (P >= mid)
return find0(P, mid + 1, r, now << 1 | 1) + tr[now << 1].sum;
else
return find0(P, l, mid, now << 1);
}
std::pair<long long, int> find1(long long X, int l = 1, int r = n,
int now = 1) {
pushdown(l, r, now);
if (l == r) {
if (X - tr[now].sum >= 0)
return std::make_pair(tr[now].sum, 1);
else
return std::make_pair(0, 0);
}
int mid = (l + r) >> 1;
if (X - tr[now << 1].sum >= 0) {
std::pair<long long, int> re =
find1(X - tr[now << 1].sum, mid + 1, r, now << 1 | 1);
re.first += tr[now << 1].sum;
re.second += mid - l + 1;
return re;
} else
return find1(X, l, mid, now << 1);
}
std::pair<long long, int> find2(int X, int l = 1, int r = n, int now = 1) {
pushdown(l, r, now);
if (l == r) {
if (tr[now].maxn > X)
return std::make_pair(tr[now].sum, 1);
else
return std::make_pair(0, 0);
}
int mid = (l + r) >> 1;
if (tr[now << 1].minn > X) {
std::pair<long long, int> re = find2(X, mid + 1, r, now << 1 | 1);
re.first += tr[now << 1].sum;
re.second += mid - l + 1;
return re;
} else
return find2(X, l, mid, now << 1);
}
int main() {
T = 1;
while (T--) {
read(n, q);
for (int i = 1, i2; i <= n; i++) {
read(i2);
change(i2, i, i);
}
long long now, now2, S1, S2, ans;
std::pair<long long, int> XX;
for (int i = 1, opt, x, y; i <= q; i++) {
read(opt, x, y);
if (opt == 1) {
change(y, find2(y).second + 1, x);
} else {
S1 = find0(x - 1);
now = x;
ans = 0;
while (now <= n) {
XX = find1(S1 + y);
S2 = XX.first;
now2 = XX.second;
y -= S2 - S1;
ans += now2 - now + 1;
XX = find2(y);
now = (XX.second + 1 > now2 + 1 ? XX.second + 1 : now2 + 1);
S1 = XX.first;
}
write(ans);
putchar('\n');
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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];
long long min_s[M], up_v[M], max_s[M];
long long sum_s[M];
void check(int t, int l, int r, long long v) {
if (l > r) return;
if (v > min_s[t]) {
up_v[t] = max(up_v[t], v);
max_s[t] = max(max_s[t], v);
min_s[t] = v;
sum_s[t] = v * (r - l + 1);
}
}
void push_down(int t, int l, int r) {
if (up_v[t] == 0) {
return;
}
if (l >= r) {
return;
}
int mid = (l + r) >> 1;
check(t << 1, l, mid, up_v[t]);
check(t << 1 | 1, mid + 1, r, up_v[t]);
up_v[t] = 0;
}
void push_up(int t, int l, int r) {
sum_s[t] = sum_s[t << 1] + sum_s[t << 1 | 1];
max_s[t] = max(max_s[t << 1], max_s[t << 1 | 1]);
min_s[t] = min(min_s[t << 1], min_s[t << 1 | 1]);
}
void build(int t, int l, int r) {
if (l > r) return;
if (l == r) {
max_s[t] = a[l];
min_s[t] = a[l];
sum_s[t] = a[l];
return;
}
int mid = (l + r) >> 1;
build(t << 1, l, mid);
build((t << 1) | 1, mid + 1, r);
push_up(t, l, r);
}
int sum(int t, int l, int r, int ul, int ur, long long& money) {
push_down(t, l, r);
if (r < ul || l > ur) {
return 0;
}
if (money < min_s[t]) {
return 0;
}
if (ul <= l && ur >= r && sum_s[t] > 0 && sum_s[t] <= money) {
money -= sum_s[t];
return (r - l + 1);
}
if (l >= r) {
return 0;
}
long long ret = 0;
int mid = (l + r) >> 1;
if (ul <= mid) {
ret += sum(t << 1, l, mid, ul, ur, money);
}
if (ur >= mid + 1) {
ret += sum(t << 1 | 1, mid + 1, r, ul, ur, money);
}
push_up(t, l, r);
return ret;
}
void update(int t, int l, int r, int ul, int ur, long long v) {
if (r < ul || l > ur) {
return;
}
if (v <= min_s[t]) {
return;
}
if (ul <= l && ur >= r && v >= max_s[t]) {
max_s[t] = max(max_s[t], v);
min_s[t] = max(min_s[t], v);
sum_s[t] = v * (r - l + 1);
up_v[t] = max(up_v[t], v);
return;
}
if (l >= r) {
return;
}
push_down(t, l, r);
int mid = (l + r) >> 1;
if (ul <= mid) {
update(t << 1, l, mid, ul, ur, v);
}
if (ur >= mid + 1) {
update(t << 1 | 1, mid + 1, r, ul, ur, v);
}
push_up(t, l, r);
}
int main() {
int op, x, y;
read(n);
read(q);
for (int i = 1; i <= n; i++) read(a[i]);
memset(up_v, 0, sizeof(up_v));
build(1, 1, n);
while (q--) {
read(op);
read(x);
read(y);
if (op == 2) {
long long yy = y;
int res = sum(1, 1, n, x, n, yy);
printf("%d\n", res);
} else {
update(1, 1, n, 1, x, y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 1e6 + 10;
struct Node {
ll l{0LL}, r{0LL}, maxx{0LL}, minn{0LL}, lazy{0LL}, sum{0LL};
Node() = default;
} tree[N];
ll a[N];
ll tmpV;
void pushUp(int rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
tree[rt].maxx = max(tree[rt << 1].maxx, tree[rt << 1 | 1].maxx);
tree[rt].minn = min(tree[rt << 1].minn, tree[rt << 1 | 1].minn);
}
void pushDown(int rt) {
if (tree[rt].lazy) {
tree[rt << 1].lazy = tree[rt << 1 | 1].lazy = tree[rt].lazy;
tree[rt << 1].sum = tree[rt].lazy * (tree[rt << 1].r - tree[rt << 1].l + 1);
tree[rt << 1 | 1].sum =
tree[rt].lazy * (tree[rt << 1 | 1].r - tree[rt << 1 | 1].l + 1);
tree[rt << 1].maxx = tree[rt << 1 | 1].maxx = tree[rt << 1].minn =
tree[rt << 1 | 1].minn = tree[rt].lazy;
tree[rt].lazy = 0;
}
}
void build(int l, int r, int rt) {
if (l == r) {
tree[rt].sum = tree[rt].maxx = tree[rt].minn = a[l];
tree[rt].lazy = 0;
tree[rt].l = tree[rt].r = l;
return;
}
tree[rt].l = l, tree[rt].r = r;
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushUp(rt);
}
void update(int l, int r, int val, int rt) {
if (l <= tree[rt].l && tree[rt].r <= r) {
if (val <= tree[rt].minn) return;
if (val > tree[rt].maxx) {
tree[rt].sum = val * (tree[rt].r - tree[rt].l + 1);
tree[rt].maxx = tree[rt].minn = val;
tree[rt].lazy = val;
return;
}
}
pushDown(rt);
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) update(l, r, val, rt << 1);
if (r > mid) update(l, r, val, rt << 1 | 1);
pushUp(rt);
}
ll query(int l, int r, int rt) {
if (l <= tree[rt].l && tree[rt].r <= r) {
if (tmpV < tree[rt].minn) return 0;
if (tree[rt].sum <= tmpV) {
tmpV -= tree[rt].sum;
return tree[rt].r - tree[rt].l + 1;
}
}
if (tree[rt].l == tree[rt].r) return 0;
pushDown(rt);
ll sum = 0;
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) sum += query(l, r, rt << 1);
if (r > mid) sum += query(l, r, rt << 1 | 1);
return sum;
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
update(1, x, y, 1);
} else if (t == 2) {
tmpV = y;
cout << query(x, n, 1) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
struct segTreemin {
long long n;
vector<long long> tree, lazy;
segTreemin(long long n) : n(n), tree(4 * n, 0), lazy(4 * n, -1) {}
void propagate(long long node, long long l, long long r) {
if (lazy[node] != -1) {
tree[node] = lazy[node];
if (l != r) lazy[2 * node] = lazy[node], lazy[2 * node + 1] = lazy[node];
}
lazy[node] = -1;
}
void treeUpdate(long long node, long long l, long long r, long long u,
long long v, long long val) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return;
if (l >= u && r <= v) {
lazy[node] = val;
propagate(node, l, r);
return;
}
treeUpdate(2 * node, l, mid, u, v, val);
treeUpdate(2 * node + 1, mid + 1, r, u, v, val);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
void update(long long l, long long r, long long val) {
treeUpdate(1, 1, n, l, r, val);
}
long long treeQuery(long long node, long long l, long long r, long long val) {
if (tree[node] > val) return n + 1;
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l == r) return l;
if (tree[2 * node] <= val) return treeQuery(2 * node, l, mid, val);
return treeQuery(2 * node + 1, mid + 1, r, val);
}
long long query(long long val) { return treeQuery(1, 1, n, val); }
};
struct segTreesum {
long long n;
vector<long long> tree, lazy;
segTreesum(long long n) : n(n), tree(4 * n, 0), lazy(4 * n, -1) {}
void propagate(long long node, long long l, long long r) {
if (lazy[node] != -1) {
tree[node] = lazy[node] * (r - l + 1);
if (l != r) lazy[2 * node] = lazy[node], lazy[2 * node + 1] = lazy[node];
}
lazy[node] = -1;
}
void treeUpdate(long long node, long long l, long long r, long long u,
long long v, long long val) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return;
if (l >= u && r <= v) {
lazy[node] = val;
propagate(node, l, r);
return;
}
treeUpdate(2 * node, l, mid, u, v, val);
treeUpdate(2 * node + 1, mid + 1, r, u, v, val);
tree[node] = (tree[2 * node] + tree[2 * node + 1]);
}
void update(long long l, long long r, long long val) {
treeUpdate(1, 1, n, l, r, val);
}
long long treeQuery(long long node, long long l, long long r, long long u,
long long v) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return 0;
if (l >= u && r <= v) return tree[node];
return (treeQuery(2 * node, l, mid, u, v) +
treeQuery(2 * node + 1, mid + 1, r, u, v));
}
long long query(long long l, long long r) { return treeQuery(1, 1, n, l, r); }
long long treeQuery2(long long node, long long l, long long r,
long long val) {
long long mid = (l + r) >> 1;
propagate(node, l, r);
if (l == r) {
if (tree[node] <= val) return l;
return l - 1;
}
propagate(2 * node, l, mid);
if (tree[2 * node] >= val) return treeQuery2(2 * node, l, mid, val);
propagate(2 * node + 1, mid + 1, r);
return treeQuery2(2 * node + 1, mid + 1, r, val - tree[2 * node]);
}
long long query2(long long val) { return treeQuery2(1, 1, n, val); }
};
long long arr[200005];
int main() {
long long i, j, k, l, m, n, o, r, q;
long long testcase;
long long input, flag, tag, ans;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (cin >> n >> m) {
segTreemin seg1(n);
segTreesum seg2(n);
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
seg1.update(i, i, arr[i]);
seg2.update(i, i, arr[i]);
}
for (long long i = 1; i <= m; i++) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) {
long long pos = seg1.query(y);
if (pos <= x) {
seg1.update(pos, x, y);
seg2.update(pos, x, y);
}
} else {
ans = 0;
while (y) {
long long pos = seg1.query(y);
pos = max(pos, x);
if (pos > n) break;
long long tot = y;
if (pos > 1) tot += seg2.query(1, pos - 1);
long long ret = seg2.query2(tot);
ans += ret - pos + 1;
y -= seg2.query(pos, ret);
x = ret + 1;
assert(y >= 0);
}
cout << ans << "\n";
}
}
}
}
|
#include <bits/stdc++.h>
const int md = 1e9 + 7;
const long long inf = 3e18;
const int OO = 0;
const int OOO = 1;
using namespace std;
struct segtree {
int n, orig;
vector<long long> tree, tag;
vector<int> len;
segtree() {}
segtree(vector<long long> &a) {
n = max(2, (int)a.size());
orig = a.size();
while (n != (n & -n)) n += (n & -n);
tree.resize(2 * n);
len.resize(2 * n, 1);
tag.resize(2 * n, -1);
for (int i = 0; i < a.size(); i++) tree[i + n - 1] = a[i];
for (int i = n - 2; i >= 0; i--) {
tree[i] = tree[i + i + 1] + tree[i + i + 2];
len[i] = len[i + i + 1] + len[i + i + 2];
}
}
void push(int x) {
if (tag[x] == -1) return;
tree[x] = tag[x] * len[x];
if (x < n - 1) {
tag[x + x + 1] = tag[x];
tag[x + x + 2] = tag[x];
}
tag[x] = -1;
}
void fix(int x) {
push(x + x + 1), push(x + x + 2);
tree[x] = tree[x + x + 1] + tree[x + x + 2];
}
void upd(int l, int r, int v) { upd(l, r, v, 0, 0, n - 1); }
void upd(int l, int r, int v, int node, int nl, int nr) {
if (r < nl || nr < l) return;
if (l <= nl && nr <= r) {
tag[node] = v;
return;
}
push(node);
int mid = (nl + nr) / 2;
upd(l, r, v, 2 * node + 1, nl, mid);
upd(l, r, v, 2 * node + 2, mid + 1, nr);
fix(node);
}
long long query(int l, int r) { return query(l, r, 0, 0, n - 1); }
long long query(int l, int r, int node, int nl, int nr) {
if (r < nl || nr < l) return 0;
push(node);
if (l <= nl && nr <= r) {
return tree[node];
}
int mid = (nl + nr) / 2;
return query(l, r, 2 * node + 1, nl, mid) +
query(l, r, 2 * node + 2, mid + 1, nr);
}
int first(long long more) { return first(more, 0, 0, n - 1); }
int first(long long more, int node, int nl, int nr) {
push(node);
if (more >= tree[node]) return min(nr + 1, orig);
if (nl == nr) return nl;
int mid = (nl + nr) / 2;
int res = first(more, 2 * node + 1, nl, mid);
if (res <= mid) return res;
return first(more - tree[2 * node + 1], 2 * node + 2, mid + 1, nr);
}
int get(int i) {
i += n - 1;
int val = tree[i];
if (tag[i] != -1) val = tag[i];
while (i > 0) {
i = (i - 1) / 2;
if (tag[i] != -1) val = tag[i];
}
return val;
}
};
int n, q;
vector<long long> a;
segtree T;
void upd(int l, int r, int v) {
int lo = l, hi = r + 1, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (T.get(mid) < v)
hi = mid;
else
lo = mid + 1;
}
if (lo <= r) T.upd(lo, r, v);
}
int findfirst(int i, long long v) {
int lo = i, hi = n, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (T.get(mid) <= v)
hi = mid;
else
lo = mid + 1;
}
return lo;
}
int query(int i, long long y) {
int ans = 0, lo, hi, mid;
i = findfirst(i, y);
while (i < n) {
long long sub = 0;
if (i > 0) sub = T.query(0, i - 1);
lo = T.first(y + sub);
if (OO) {
cout << "from " << i << " " << lo << '\n';
}
ans += lo - i;
y -= T.query(i, lo - 1);
i = findfirst(lo, y);
}
return ans;
}
void solve() {
cin >> n >> q;
a.resize(n);
for (auto &i : a) cin >> i;
T = segtree(a);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
upd(0, x - 1, y);
} else {
cout << query(x - 1, y) << '\n';
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int tst = 1;
while (tst--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmax(T& x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
bool ckmin(T& x, T y) {
return x > y ? x = y, 1 : 0;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
const int N = 200005;
const int T = N << 2;
int n, m, a[N], ans;
long long y;
int miv[T], tag[T];
long long sum[T];
inline void pushup(int p) {
miv[p] = min(miv[(p << 1)], miv[(p << 1 | 1)]);
sum[p] = sum[(p << 1)] + sum[(p << 1 | 1)];
}
void build(int l = 1, int r = n, int p = 1) {
if (l == r) {
sum[p] = miv[p] = a[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, (p << 1)), build(mid + 1, r, (p << 1 | 1));
pushup(p);
}
inline void pushdown(int p, int l, int r) {
if (tag[p]) {
int mid = (l + r) >> 1;
tag[(p << 1)] = tag[p], sum[(p << 1)] = 1ll * (mid - l + 1) * tag[p],
miv[(p << 1)] = tag[p];
tag[(p << 1 | 1)] = tag[p], sum[(p << 1 | 1)] = 1ll * (r - mid) * tag[p],
miv[(p << 1 | 1)] = tag[p];
tag[p] = 0;
}
}
int solve1(int d, int l = 1, int r = n, int p = 1) {
if (l == r) return l;
int mid = (l + r) >> 1;
pushdown(p, l, r);
if (d >= miv[(p << 1)])
return solve1(d, l, mid, (p << 1));
else
return solve1(d, mid + 1, r, (p << 1 | 1));
}
void cov(int ql, int qr, int d, int l = 1, int r = n, int p = 1) {
if (ql > qr) return;
if (ql <= l && r <= qr) {
miv[p] = d, sum[p] = 1ll * d * (r - l + 1), tag[p] = d;
return;
}
pushdown(p, l, r);
int mid = (l + r) >> 1;
if (ql <= mid) cov(ql, qr, d, l, mid, (p << 1));
if (mid < qr) cov(ql, qr, d, mid + 1, r, (p << 1 | 1));
pushup(p);
}
inline long long query_sum(int ql, int qr, int l = 1, int r = n, int p = 1) {
if (ql > qr) return 0;
if (ql <= l && r <= qr) return sum[p];
pushdown(p, l, r);
int mid = (l + r) >> 1;
long long res = 0;
if (ql <= mid) res += query_sum(ql, qr, l, mid, (p << 1));
if (mid < qr) res += query_sum(ql, qr, mid + 1, r, (p << 1 | 1));
return res;
}
int CNT;
inline void solve(int l = 1, int r = n, int p = 1) {
++CNT;
if (sum[p] <= y) return y -= sum[p], ans += r - l + 1, void();
if (l == r) return;
pushdown(p, l, r);
if (miv[p] <= y) {
int mid = (l + r) >> 1;
if (miv[(p << 1)] <= y) solve(l, mid, (p << 1));
if (miv[(p << 1 | 1)] <= y) solve(mid + 1, r, (p << 1 | 1));
}
}
signed main() {
n = read(), m = read();
for (int i = 1, iend = n; i <= iend; ++i) a[i] = read();
build();
while (m--) {
int opt = read(), x = read();
y = read();
if (opt == 1)
cov(solve1(y), x, y);
else
y += query_sum(1, x - 1), ans = 0, solve(), printf("%d\n", ans - x + 1);
}
return 0;
}
|
#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;
namespace SegmentTreeBeats {
const long long inf = 1e9 + 7;
const long long maxn = 5e5 + 5;
long long sum[maxn << 2], col[maxn << 2], v[maxn << 2];
template <class cmp, long long Inf>
struct INFO {
long long mv, smv;
long long cnt;
const static long long INF = Inf;
INFO operator+(const INFO& p) const {
INFO ans;
if (cmp()(mv, p.mv)) {
ans.mv = p.mv;
ans.cnt = p.cnt;
ans.smv = cmp()(mv, p.smv) ? p.smv : mv;
} else if (cmp()(p.mv, mv)) {
ans.mv = mv;
ans.cnt = cnt;
ans.smv = cmp()(smv, p.mv) ? p.mv : smv;
} else {
ans.mv = mv;
ans.cnt = cnt + p.cnt;
ans.smv = cmp()(smv, p.smv) ? p.smv : smv;
}
return ans;
}
};
INFO<less<long long>, -inf> Mx[maxn << 2];
INFO<greater<long long>, inf> Mn[maxn << 2];
void updata(long long rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
Mx[rt] = Mx[rt << 1] + Mx[rt << 1 | 1];
Mn[rt] = Mn[rt << 1] + Mn[rt << 1 | 1];
}
void build(long long l, long long r, long long rt) {
col[rt] = 0;
if (l == r) {
Mx[rt].mv = Mn[rt].mv = sum[rt] = v[l];
Mx[rt].cnt = Mn[rt].cnt = 1;
Mx[rt].smv = Mx[rt].INF;
Mn[rt].smv = Mn[rt].INF;
return;
}
long long mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
updata(rt);
}
inline void color(long long l, long long r, long long rt, long long val) {
sum[rt] += val * (r - l + 1);
col[rt] += val;
if (Mx[rt].smv != -inf) Mx[rt].smv += val;
if (Mn[rt].smv != inf) Mn[rt].smv += val;
Mx[rt].mv += val, Mn[rt].mv += val;
}
inline void colorToLess(long long rt, long long val) {
if (Mx[rt].mv <= val) return;
sum[rt] += (val - Mx[rt].mv) * Mx[rt].cnt;
if (Mn[rt].smv == Mx[rt].mv) Mn[rt].smv = val;
if (Mn[rt].mv == Mx[rt].mv) Mn[rt].mv = val;
Mx[rt].mv = val;
}
inline void colorToMore(long long rt, long long val) {
if (Mn[rt].mv >= val) return;
sum[rt] += (val - Mn[rt].mv) * Mn[rt].cnt;
if (Mx[rt].smv == Mn[rt].mv) Mx[rt].smv = val;
if (Mx[rt].mv == Mn[rt].mv) Mx[rt].mv = val;
Mn[rt].mv = val;
}
inline void pushcol(long long l, long long r, long long rt) {
if (col[rt]) {
long long mid = (l + r) >> 1;
color(l, mid, rt << 1, col[rt]);
color(mid + 1, r, rt << 1 | 1, col[rt]);
col[rt] = 0;
}
colorToLess(rt << 1, Mx[rt].mv);
colorToLess(rt << 1 | 1, Mx[rt].mv);
colorToMore(rt << 1, Mn[rt].mv);
colorToMore(rt << 1 | 1, Mn[rt].mv);
}
void toLess(long long l, long long r, long long rt, long long nl, long long nr,
long long val) {
if (Mx[rt].mv <= val) return;
if (nl <= l && nr >= r && Mx[rt].smv < val) {
colorToLess(rt, val);
return;
}
pushcol(l, r, rt);
long long mid = (l + r) >> 1;
if (nl <= mid) toLess(l, mid, rt << 1, nl, nr, val);
if (nr > mid) toLess(mid + 1, r, rt << 1 | 1, nl, nr, val);
updata(rt);
}
void toMore(long long l, long long r, long long rt, long long nl, long long nr,
long long val) {
if (Mn[rt].mv >= val) return;
if (nl <= l && nr >= r && Mn[rt].smv > val) {
colorToMore(rt, val);
return;
}
pushcol(l, r, rt);
long long mid = (l + r) >> 1;
if (nl <= mid) toMore(l, mid, rt << 1, nl, nr, val);
if (nr > mid) toMore(mid + 1, r, rt << 1 | 1, nl, nr, val);
updata(rt);
}
void modify(long long l, long long r, long long rt, long long nl, long long nr,
long long val) {
if (nl <= l && nr >= r) {
color(l, r, rt, val);
return;
}
pushcol(l, r, rt);
long long mid = (l + r) >> 1;
if (nl <= mid) modify(l, mid, rt << 1, nl, nr, val);
if (nr > mid) modify(mid + 1, r, rt << 1 | 1, nl, nr, val);
updata(rt);
}
long long querySum(long long l, long long r, long long rt, long long nl,
long long nr) {
if (nl <= l && nr >= r) return sum[rt];
pushcol(l, r, rt);
long long mid = (l + r) >> 1;
long long ans = 0;
if (nl <= mid) ans += querySum(l, mid, rt << 1, nl, nr);
if (nr > mid) ans += querySum(mid + 1, r, rt << 1 | 1, nl, nr);
return ans;
}
long long queryMx(long long l, long long r, long long rt, long long nl,
long long nr) {
if (nl <= l && nr >= r) return Mx[rt].mv;
pushcol(l, r, rt);
long long mid = (l + r) >> 1;
long long ans = Mx->INF;
if (nl <= mid) ans = max(ans, queryMx(l, mid, rt << 1, nl, nr));
if (nr > mid) ans = max(ans, queryMx(mid + 1, r, rt << 1 | 1, nl, nr));
return ans;
}
long long queryMn(long long l, long long r, long long rt, long long nl,
long long nr) {
if (nl <= l && nr >= r) return Mn[rt].mv;
pushcol(l, r, rt);
long long mid = (l + r) >> 1;
long long ans = Mn->INF;
if (nl <= mid) ans = min(ans, queryMn(l, mid, rt << 1, nl, nr));
if (nr > mid) ans = min(ans, queryMn(mid + 1, r, rt << 1 | 1, nl, nr));
return ans;
}
long long queryMnpos(long long l, long long r, long long rt, long long tar,
long long liml, long long limr) {
if (l == r) {
if (queryMn(l, l, 1, n, 1) >= tar) return l;
return -1;
}
long long mid = (l + r) >> 1;
pushcol(l, r, rt);
long long ans = -1;
if (mid < liml) {
if (Mn[mid + 1, r, rt << 1 | 1].mv <= tar)
ans = queryMnpos(mid + 1, r, rt << 1 | 1, tar, liml, limr);
} else if (mid >= limr) {
if (Mn[l, mid, rt << 1].mv <= tar)
ans = queryMnpos(l, mid, rt << 1, tar, liml, limr);
} else {
if (Mn[l, mid, rt << 1].mv <= tar) {
ans = queryMnpos(l, mid, rt << 1, tar, liml, limr);
}
if (Mn[mid + 1, r, rt << 1 | 1].mv <= tar && ans == -1) {
ans = queryMnpos(mid + 1, r, rt << 1 | 1, tar, liml, limr);
}
}
return ans;
}
long long queryAns(long long l, long long r, long long rt, long long& tar,
long long nl, long long nr) {
if (tar >= sum[rt]) {
tar -= sum[rt];
return r - l + 1;
}
if (l == r) {
return 0;
}
long long mid = (l + r) >> 1;
pushcol(l, r, rt);
long long ans = 0;
if (Mn[l, mid, rt << 1].mv <= tar && nl <= mid)
ans += queryAns(l, mid, rt << 1, tar, nl, nr);
if (Mn[mid + 1, r, rt << 1 | 1].mv <= tar && nr > mid)
ans += queryAns(mid + 1, r, rt << 1 | 1, tar, nl, nr);
return ans;
}
} // namespace SegmentTreeBeats
using namespace SegmentTreeBeats;
signed main() {
long long q;
scanf("%lld%lld", &n, &q);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &v[i]);
}
build(1, n, 1);
while (q--) {
long long op, x, y;
scanf("%lld%lld%lld", &op, &x, &y);
if (op == 1) {
toMore(1, n, 1, 1, x, y);
} else {
long long ans = -x + 1;
if (x > 1) y += querySum(1, n, 1, 1, x - 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 = 2e5;
int N, Q, A[MAXN + 10];
struct SEG {
long long tree[MAXN * 4 + 10], treel[MAXN * 4 + 10], treer[MAXN * 4 + 10],
lazy[MAXN * 4 + 10], t[MAXN * 4 + 10];
void init(int node, int tl, int tr) {
lazy[node] = 0;
if (tl == tr) {
tree[node] = A[tl];
treel[node] = A[tl];
treer[node] = A[tl];
return;
}
int mid = tl + tr >> 1;
init(node * 2, tl, mid);
init(node * 2 + 1, mid + 1, tr);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
treel[node] = treel[node * 2];
treer[node] = treer[node * 2 + 1];
}
void busy(int node, int tl, int tr) {
if (lazy[node] == 0) return;
tree[node] = (tr - tl + 1) * lazy[node];
treel[node] = lazy[node];
treer[node] = lazy[node];
if (tl != tr) {
lazy[node * 2] = lazy[node];
lazy[node * 2 + 1] = lazy[node];
}
lazy[node] = 0;
}
int query0(int node, int tl, int tr, int x) {
busy(node, tl, tr);
if (tl == tr) return tree[node];
int mid = tl + tr >> 1;
if (x <= mid)
return query0(node * 2, tl, mid, x);
else
return query0(node * 2 + 1, mid + 1, tr, x);
}
long long query1(int node, int tl, int tr, int l, int r) {
busy(node, tl, tr);
if (l <= tl && tr <= r) return tree[node];
if (r < tl || tr < l) return 0;
int mid = tl + tr >> 1;
return query1(node * 2, tl, mid, l, r) +
query1(node * 2 + 1, mid + 1, tr, l, r);
}
void update(int node, int tl, int tr, int l, int r, int k) {
busy(node, tl, tr);
if (r < tl || tr < l) return;
if (l <= tl && tr <= r) {
lazy[node] = k;
busy(node, tl, tr);
return;
}
int mid = tl + tr >> 1;
update(node * 2, tl, mid, l, r, k);
update(node * 2 + 1, mid + 1, tr, l, r, k);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
treel[node] = treel[node * 2];
treer[node] = treer[node * 2 + 1];
}
int query2(int node, int tl, int tr, int k) {
busy(node, tl, tr);
if (tl == tr) return tl;
int mid = tl + tr >> 1;
if (treer[node * 2] <= k)
return query2(node * 2, tl, mid, k);
else
return query2(node * 2 + 1, mid + 1, tr, k);
}
void query3(int node, int tl, int tr, int l, int r) {
busy(node, tl, tr);
if (l <= tl && tr <= r) {
t[node] = tree[node];
return;
}
if (r < tl || tr < l) {
t[node] = 0;
return;
}
int mid = tl + tr >> 1;
query3(node * 2, tl, mid, l, r);
query3(node * 2 + 1, mid + 1, tr, l, r);
t[node] = t[node * 2] + t[node * 2 + 1];
}
int query4(int node, int tl, int tr, int l, int r, long long k) {
busy(node, tl, tr);
if (tl == tr) return tl;
int mid = tl + tr >> 1;
busy(node * 2, tl, mid);
busy(node * 2 + 1, mid + 1, tr);
if (l <= tl && mid <= r) t[node * 2] = tree[node * 2];
if (l <= mid + 1 && tr <= r) t[node * 2 + 1] = tree[node * 2 + 1];
if (t[node * 2] > k) {
return query4(node * 2, tl, mid, l, r, k);
} else {
return query4(node * 2 + 1, mid + 1, tr, l, r, k - t[node * 2]);
}
}
} seg;
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
seg.init(1, 1, N + 1);
while (Q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
int l, r = x;
if (y <= seg.query0(1, 1, N + 1, x)) continue;
l = seg.query2(1, 1, N + 1, y);
seg.update(1, 1, N + 1, l, r, y);
} else {
int ans = 0;
x = max(x, seg.query2(1, 1, N + 1, y));
while (x <= N) {
seg.query3(1, 1, N + 1, x, N + 1);
int t = seg.query4(1, 1, N + 1, x, N + 1, y) - 1;
y -= seg.query1(1, 1, N + 1, x, t);
ans += t - x + 1;
x = t + 1;
x = max(x, seg.query2(1, 1, N + 1, y));
}
printf("%d\n", ans);
}
}
}
|
#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<int> bit;
vector<int> a;
vector<int> lazy;
int n;
seg_tree_max(int n) {
this->n = n;
bit.assign(4 * n + 5, 0);
lazy.assign(4 * n + 5, 0);
}
seg_tree_max(vector<int> a) : seg_tree_max(a.size()) {
this->a = a;
build(0, 0, (int)a.size() - 1);
}
int merge(int x, int y) { return max(x, y); }
void build(int node, int start, int end) {
if (start == end) {
bit[node] = a[start];
return;
}
int lch = 2 * node + 1;
int rch = 2 * node + 2;
int mid = (start + end) / 2;
build(lch, start, mid);
build(rch, mid + 1, end);
bit[node] = merge(bit[lch], bit[rch]);
return;
}
void push(int 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(int v, int tl, int tr, int l, int r, int 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);
int 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]);
}
}
int query(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l <= tl && tr <= r) return bit[v];
push(v, tl, tr);
int 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));
}
int binary_search(int v, int tl, int tr, int cost) {
if (tl != tr)
;
push(v, tl, tr);
if (tl == tr && bit[v] > cost)
return 1000000000LL;
else if (bit[v] <= cost)
return tl;
else {
int 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<int> a;
vector<int> lazy;
int n;
seg_tree(int n) {
this->n = n;
bit.assign(4 * n + 5, 0);
lazy.assign(4 * n + 5, 0);
}
seg_tree(vector<int> a) : seg_tree(a.size()) {
this->a = a;
build(0, 0, (int)a.size() - 1);
}
long long merge(long long x, long long y) { return x + y; }
void build(int node, int start, int end) {
if (start == end) {
bit[node] = a[start];
return;
}
int lch = 2 * node + 1;
int rch = 2 * node + 2;
int mid = (start + end) / 2;
build(lch, start, mid);
build(rch, mid + 1, end);
bit[node] = merge(bit[lch], bit[rch]);
return;
}
void push(int v, int tl, int tr) {
if (tl == tr) {
return;
}
if (lazy[v] != 0) {
int mid = (tr + tl) / 2;
bit[v * 2 + 1] = (long long)(mid - tl + 1) * lazy[v];
lazy[v * 2 + 1] = lazy[v];
bit[v * 2 + 2] = (long long)(tr - mid) * lazy[v];
lazy[v * 2 + 2] = lazy[v];
}
lazy[v] = 0;
}
void update(int v, int tl, int tr, int l, int 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);
int 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]);
}
}
int query(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l <= tl && tr <= r) return bit[v];
push(v, tl, tr);
int 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<int, int> get_number_of_shops(int v, int tl, int tr, int start,
int 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 {
int 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<int, int> pl =
get_number_of_shops(2 * v + 1, tl, mid, start, money);
pair<int, int> 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<int> a;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
seg_tree_max sgmax(a);
seg_tree sgsum(a);
int t, y;
while (q--) {
cin >> t >> x >> y;
if (t == 1) {
x--;
int 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 {
int num_shops = 0;
x--;
while (y > 0) {
int br = sgmax.binary_search(0, 0, n - 1, y);
int start = max(br, x);
if (start < n) {
pair<int, int> 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;
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 ll N = 2e5 + 10;
ll n, q;
ll a[N];
void read() {
cin >> n >> q;
for (ll i = 0; i < n; ++i) {
cin >> a[i];
}
}
struct Node {
ll sum;
ll maxVal, minVal;
ll mod;
Node() {
sum = 0;
minVal = 0;
maxVal = 0;
mod = 0;
}
Node(ll _sum, ll _minVal, ll _maxVal) {
sum = _sum;
minVal = _minVal;
maxVal = _maxVal;
mod = 0;
}
};
Node merge(const Node& a, const Node& b) {
return {a.sum + b.sum, min(a.minVal, b.minVal), max(a.maxVal, b.maxVal)};
}
struct SegmentTree {
ll n;
vector<Node> tree;
SegmentTree() {}
void build(ll v, ll tl, ll tr, ll* a) {
if (tl >= tr) return;
if (tl == tr - 1) {
tree[v] = Node(a[tl], a[tl], a[tl]);
return;
}
ll 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(ll _n, ll* a) {
n = _n;
tree.resize(4 * n);
build(1, 0, n, a);
}
void push(ll 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(ll v, ll tl, ll tr) {
if (tree[v].mod == 0) return tree[v];
return {(tr - tl) * tree[v].mod, tree[v].mod, tree[v].mod};
}
ll find(ll v, ll tl, ll tr, ll l, ll r, ll 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);
ll tm = (tl + tr) / 2;
ll 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;
}
ll find(ll l, ll val) { return find(1, 0, n, l, n, val); }
void upd(ll v, ll tl, ll tr, ll l, ll r, ll x) {
if (tl >= r || tr <= l) return;
if (tl >= l && tr <= r) {
tree[v].mod = x;
return;
}
push(v);
ll 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(ll r, ll x) {
ll l = find(0, x);
if (l == -1 || l > r) return;
upd(1, 0, n, l, r + 1, x);
}
ll getSum(ll v, ll tl, ll tr, ll l, ll r) {
if (tl >= r || tr <= l) return 0;
if (tl >= l && tr <= r) {
return getVal(v, tl, tr).sum;
}
push(v);
ll 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(ll l, ll r) { return getSum(1, 0, n, l, r + 1); }
ll get(ll v, ll tl, ll 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);
ll tm = (tl + tr) / 2;
ll 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;
}
ll get(ll l, ll sum) {
sum += getSum(0, l - 1);
ll fans = get(1, 0, n, sum);
assert(fans != -1);
return fans - l + 1;
}
};
SegmentTree tree;
void upd() {
ll r, x;
cin >> r >> x;
--r;
tree.upd(r, x);
}
void get() {
ll ans = 0;
ll l, sum;
cin >> l >> sum;
--l;
while (true) {
ll pos = tree.find(l, sum);
if (pos == -1) break;
l = pos;
ll 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--) {
ll 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;
struct ST {
int N;
vector<int> first;
vector<int> last;
vector<int> lazy;
vector<int64_t> sum;
ST(int N = 0)
: N(N), first(N << 2), last(N << 2), lazy(N << 2), sum(N << 2) {}
void pop(int v) {
sum[v] = sum[v << 1] + sum[v << 1 | 1];
first[v] = first[v << 1];
last[v] = last[v << 1 | 1];
}
void init(int v, int l, int r, vector<int> &A) {
if (l == r) {
first[v] = A[l];
last[v] = A[l];
sum[v] = A[l];
return;
}
int md = (l + r) >> 1;
init(v << 1, l, md, A);
init(v << 1 | 1, md + 1, r, A);
pop(v);
}
void apply(int v, int l, int r, int lz) {
lazy[v] = lz;
last[v] = lz;
first[v] = lz;
sum[v] = int64_t(r - l + 1) * lz;
}
void push(int v, int l, int r) {
if (lazy[v]) {
int md = (l + r) >> 1;
apply(v << 1, l, md, lazy[v]);
apply(v << 1 | 1, md + 1, r, lazy[v]);
lazy[v] = 0;
}
}
void modify(int v, int l, int r, int x, int y) {
if (last[v] >= y) return;
if (r <= x && first[v] <= y) {
apply(v, l, r, y);
return;
}
push(v, l, r);
int md = (l + r) >> 1;
modify(v << 1, l, md, x, y);
if (md + 1 <= x) modify(v << 1 | 1, md + 1, r, x, y);
pop(v);
}
int walk0(int v, int l, int r, int x, int y) {
if (r < x || last[v] > y) return N;
if (l == r) return l;
push(v, l, r);
int md = (l + r) >> 1;
int ans = walk0(v << 1, l, md, x, y);
if (ans == N) ans = walk0(v << 1 | 1, md + 1, r, x, y);
return ans;
}
void walk1(int v, int l, int r, int x, int &y, int &diff, bool &die) {
if (r < x) return;
if (die) return;
if (l >= x && y < first[v]) {
die = true;
return;
}
if (l >= x && y >= sum[v]) {
diff += r - l + 1;
y -= sum[v];
return;
}
int md = (l + r) >> 1;
push(v, l, r);
walk1(v << 1, l, md, x, y, diff, die);
walk1(v << 1 | 1, md + 1, r, x, y, diff, die);
}
int query(int x, int y) {
int ans = 0;
while (x < N) {
x = walk0(1, 0, N - 1, x, y);
if (x == N) break;
bool die = false;
int diff = 0;
walk1(1, 0, N - 1, x, y, diff, die);
ans += diff;
x += diff;
;
}
return ans;
}
void print(int v, int l, int r) {
if (l == r) {
cerr << last[v] << ' ';
} else {
int md = (l + r) >> 1;
push(v, l, r);
print(v << 1, l, md);
print(v << 1 | 1, md + 1, r);
}
if (v == 1) cerr << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, Q;
cin >> N >> Q;
vector<int> A(N);
for (int &a : A) cin >> a;
ST st(N);
st.init(1, 0, N - 1, A);
while (Q--) {
int t, x, y;
cin >> t >> x >> y;
--x;
if (t == 1) {
st.modify(1, 0, N - 1, x, y);
} else {
cout << st.query(x, y) << '\n';
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long N = 2e5 + 5;
long long read() {
long long s = 0;
char c = getchar(), lc = '+';
while (c < '0' || '9' < c) lc = c, c = getchar();
while ('0' <= c && c <= '9') s = s * 10 + c - '0', c = getchar();
return lc == '-' ? -s : s;
}
void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10)
putchar(x + '0');
else {
write(x / 10);
putchar(x % 10 + '0');
}
}
void print(long long x, char c = '\n') {
write(x);
putchar(c);
}
struct node {
long long sum, Max, Min;
} t[N * 4];
node operator+(const node &a, const node &b) {
node ret;
ret.sum = a.sum + b.sum;
ret.Max = max(a.Max, b.Max);
ret.Min = min(a.Min, b.Min);
return ret;
}
long long tag[N * 4], a[N];
void build(long long w, long long l, long long r) {
tag[w] = 0;
if (l == r) return void(t[w].Max = t[w].Min = t[w].sum = a[l]);
build((w * 2), l, ((l + r) / 2));
build((w * 2 + 1), ((l + r) / 2) + 1, r);
t[w] = t[(w * 2)] + t[(w * 2 + 1)];
}
void cover(long long w, long long x, long long l, long long r) {
tag[w] = x;
t[w].sum = x * (r - l + 1);
t[w].Max = t[w].Min = x;
}
void pushdown(long long w, long long l, long long r) {
if (!tag[w]) return;
cover((w * 2), tag[w], l, ((l + r) / 2));
cover((w * 2 + 1), tag[w], ((l + r) / 2) + 1, r);
tag[w] = 0;
}
void cover(long long w, long long l, long long r, long long x, long long y) {
if (l > x) return;
if (r <= x && t[w].Max <= y) return cover(w, y, l, r);
if (t[w].Min >= y) return;
pushdown(w, l, r);
cover((w * 2), l, ((l + r) / 2), x, y);
cover((w * 2 + 1), ((l + r) / 2) + 1, r, x, y);
t[w] = t[(w * 2)] + t[(w * 2 + 1)];
}
long long query(long long w, long long l, long long r, long long x) {
if (x < l) return 0;
if (r <= x) return t[w].sum;
pushdown(w, l, r);
return query((w * 2), l, ((l + r) / 2), x) +
query((w * 2 + 1), ((l + r) / 2) + 1, r, x);
}
long long find1(long long w, long long l, long long r, long long y) {
if (t[w].sum <= y) return r;
if (t[w].Max > y) return l - 1;
if (l == r) return l;
pushdown(w, l, r);
if (t[(w * 2)].sum <= y)
return find1((w * 2 + 1), ((l + r) / 2) + 1, r, y - t[(w * 2)].sum);
return find1((w * 2), l, ((l + r) / 2), y);
}
long long find2(long long w, long long l, long long r, long long y) {
if (t[w].Min > y) return r + 1;
if (l == r) return l;
pushdown(w, l, r);
if (t[(w * 2)].Min <= y) return find2((w * 2), l, ((l + r) / 2), y);
return find2((w * 2 + 1), ((l + r) / 2) + 1, r, y);
}
signed main() {
long long n = read(), m = read();
for (long long i = 1; i <= n; i++) a[i] = read();
build(1, 1, n);
for (long long i = 1; i <= m; i++) {
long long opt = read(), x = read(), y = read();
if (opt == 1) cover(1, 1, n, x, y);
if (opt == 2) {
x = max(find2(1, 1, n, y), x);
long long ans = 0;
while (x <= n) {
long long nxt = find1(1, 1, n, y + query(1, 1, n, x - 1));
if (nxt < x) break;
ans += nxt - x + 1;
y -= query(1, 1, n, nxt) - query(1, 1, n, x - 1);
x = max(find2(1, 1, n, y), nxt + 1);
}
print(ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 10;
int n, m;
long long a[mx], t[mx << 2], sum[mx << 2], tag[mx << 2];
void build(int rt, int l, int r) {
if (l == r) {
t[rt] = a[r];
sum[rt] = a[r];
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid), build(rt << 1 | 1, mid + 1, r);
t[rt] = t[rt << 1 | 1];
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void pushdown(int rt, int l, int r, int mid) {
if (tag[rt]) {
t[rt << 1] = t[rt << 1 | 1] = t[rt];
sum[rt << 1] = t[rt] * (mid - l + 1);
sum[rt << 1 | 1] = t[rt] * (r - mid);
tag[rt << 1] = tag[rt << 1 | 1] = 1;
tag[rt] = 0;
}
}
void updata(int rt, int l, int r, int nl, int nr, long long c) {
if (nl <= l && r <= nr) {
t[rt] = c;
sum[rt] = c * (r - l + 1);
tag[rt] = 1;
return;
}
int mid = l + r >> 1;
pushdown(rt, l, r, mid);
if (nl <= mid) updata(rt << 1, l, mid, nl, nr, c);
if (nr > mid) updata(rt << 1 | 1, mid + 1, r, nl, nr, c);
t[rt] = t[rt << 1 | 1];
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
int query(int rt, int l, int r, long long c, long long x) {
if (l == r) {
if (x <= r && c >= t[rt])
return r;
else
return r + 1;
}
int mid = l + r >> 1;
pushdown(rt, l, r, mid);
if (x <= mid && c >= t[rt << 1])
return query(rt << 1, l, mid, c, x);
else
return query(rt << 1 | 1, mid + 1, r, c, x);
}
long long ask(int rt, int l, int r, int nl, int nr) {
if (nl <= l & r <= nr) {
return sum[rt];
}
long long ans = 0;
int mid = l + r >> 1;
pushdown(rt, l, r, mid);
if (nl <= mid) ans += ask(rt << 1, l, mid, nl, nr);
if (nr > mid) ans += ask(rt << 1 | 1, mid + 1, r, nl, nr);
return ans;
}
int ss(int rt, int l, int r, long long c, long long now) {
if (l == r) {
if (c >= sum[rt] - now)
return r;
else
return r - 1;
}
int mid = l + r >> 1;
pushdown(rt, l, r, mid);
if (c >= sum[rt << 1] - now) {
now -= sum[rt << 1];
return ss(rt << 1 | 1, mid + 1, r, c, now);
} else
return ss(rt << 1, l, mid, c, now);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
build(1, 1, n);
long long op, x, y;
while (m--) {
scanf("%lld%lld%lld", &op, &x, &y);
if (op == 1) {
int p = query(1, 1, n, y, -1);
if (p <= x) updata(1, 1, n, p, x, y);
} else {
long long ans = 0;
while (y && x <= n) {
long long p = query(1, 1, n, y, x);
if (p > n) break;
long long now = 0;
if (p > 1) now = ask(1, 1, n, 1, p - 1);
long long q = ss(1, 1, n, y, now);
if (p <= q) {
y -= ask(1, 1, n, p, q);
ans += q - p + 1;
x = q + 1;
} else
break;
}
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
int n, q;
long long smt[200005 * 4], owo[200005 * 4];
long long _min[200005 * 4], _max[200005 * 4];
void build(int idx, int l, int r) {
owo[idx] = -1;
if (l == r) {
scanf("%lld", &smt[idx]);
_min[idx] = _max[idx] = smt[idx];
return;
}
int m = (l + r) / 2;
build(idx << 1, l, m);
build(idx << 1 | 1, m + 1, r);
smt[idx] = smt[idx << 1] + smt[idx << 1 | 1];
_min[idx] = _min[idx << 1 | 1];
_max[idx] = _max[idx << 1];
}
void push(int idx, int l, int r) {
if (owo[idx] == -1) return;
if (l == r) return;
int m = (l + r) / 2;
smt[idx << 1] = owo[idx] * (m - l + 1);
smt[idx << 1 | 1] = owo[idx] * (r - m);
_min[idx << 1] = owo[idx];
_max[idx << 1] = max(_max[idx << 1], owo[idx]);
_min[idx << 1 | 1] = owo[idx];
_max[idx << 1 | 1] = max(_max[idx << 1 | 1], owo[idx]);
owo[idx << 1] = owo[idx];
owo[idx << 1 | 1] = owo[idx];
owo[idx] = -1;
}
void update(int idx, int l, int r, int a, int b, long long x) {
push(idx, l, r);
if (l > b || r < a) return;
if (l >= a && r <= b) {
smt[idx] = x * (r - l + 1);
owo[idx] = x;
_min[idx] = x;
_max[idx] = max(_max[idx], x);
return;
}
int m = (l + r) / 2;
update(idx << 1, l, m, a, b, x);
update(idx << 1 | 1, m + 1, r, a, b, x);
smt[idx] = smt[idx << 1] + smt[idx << 1 | 1];
_min[idx] = _min[idx << 1 | 1];
_max[idx] = _max[idx << 1];
}
long long query(int idx, int l, int r, int a, int b) {
push(idx, l, r);
if (l > b || r < a) return 0;
if (l >= a && r <= b) return smt[idx];
int m = (l + r) / 2;
return query(idx << 1, l, m, a, b) + query(idx << 1 | 1, m + 1, r, a, b);
}
struct QQ {
int len;
long long sum;
};
QQ qq(int idx, int l, int r, int x, long long y) {
push(idx, l, r);
if (r < x || y < _min[idx]) return QQ{0, 0};
if (l >= x && y >= smt[idx]) return QQ{r - l + 1, smt[idx]};
if (l == r) return QQ{1, smt[idx]};
int m = (l + r) / 2;
QQ q = qq(idx << 1, l, m, x, y);
QQ q2 = qq(idx << 1 | 1, m + 1, r, x, y - q.sum);
return QQ{q.len + q2.len, q.sum + q2.sum};
}
int main() {
cin >> n >> q;
build(1, 1, n);
while (q--) {
int type;
scanf("%d", &type);
int x;
long long y;
scanf("%d%lld", &x, &y);
if (type == 1) {
int l = 0, r = x + 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (query(1, 1, n, m, m) >= y)
l = m;
else
r = m;
}
if (r <= x) update(1, 1, n, r, x, y);
} else {
QQ q = qq(1, 1, n, x, y);
printf("%d\n", q.len);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1000;
int read() {
int ans = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' or ch > '9') {
if (ch == '-') f = 1;
ch = getchar();
}
while (ch >= '0' and ch <= '9') {
ans = (ans << 1) + (ans << 3) + (ch ^ 48);
ch = getchar();
}
return f ? ~ans + 1 : ans;
}
int n, a[maxn], t, m, op, u, v;
struct sd {
int l, r, ls, rs;
long long datamax, datasum, f;
} tr[maxn << 2];
int nw(int l, int r) {
tr[++t] = (sd){l, r, 0, 0, 0, 0, 0};
return t;
}
void xf(int o) {
if (tr[o].f) {
tr[o].datamax = tr[o].f;
tr[o].datasum = tr[o].f * (tr[o].r - tr[o].l + 1);
tr[tr[o].ls].f = tr[o].f;
tr[tr[o].rs].f = tr[o].f;
tr[o].f = 0;
}
}
void gx(int o) {
xf(o), xf(tr[o].ls), xf(tr[o].rs);
tr[o].datasum = tr[tr[o].ls].datasum + tr[tr[o].rs].datasum;
tr[o].datamax = max(tr[tr[o].ls].datamax, tr[tr[o].rs].datamax);
}
void build(int o) {
if (tr[o].l == tr[o].r) {
tr[o].datamax = tr[o].datasum = a[tr[o].l];
return;
}
int mid = tr[o].l + tr[o].r >> 1;
build(tr[o].ls = nw(tr[o].l, mid));
build(tr[o].rs = nw(mid + 1, tr[o].r));
gx(o);
}
int fmax(int o, int x) {
xf(o), xf(tr[o].ls), xf(tr[o].rs);
if (tr[o].l == tr[o].r) {
if (tr[o].datamax > x) return tr[o].l + 1;
return tr[o].l;
}
int mid = tr[o].l + tr[o].r >> 1;
if (tr[tr[o].rs].datamax >= x)
fmax(tr[o].rs, x);
else
fmax(tr[o].ls, x);
}
void xg(int o, int l, int r, int val) {
xf(o);
if (tr[o].l == l and tr[o].r == r) {
tr[o].f = val;
return;
}
int mid = tr[o].l + tr[o].r >> 1;
if (l > mid)
xg(tr[o].rs, l, r, val);
else if (r <= mid)
xg(tr[o].ls, l, r, val);
else
xg(tr[o].ls, l, mid, val), xg(tr[o].rs, mid + 1, r, val);
gx(o);
}
int cx(int o, int p) {
xf(o);
if (p <= tr[o].l and tr[o].datasum <= v) {
v -= tr[o].datasum;
return tr[o].r + 1;
}
if (tr[o].l == tr[o].r) return tr[o].l;
int mid = tr[o].l + tr[o].r >> 1;
int tt = 0;
if (p <= mid) tt = cx(tr[o].ls, p);
if (!tt or tt == mid + 1) return cx(tr[o].rs, p);
return tt;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) a[i] = read();
build(nw(1, n));
while (m) {
m--;
op = read(), u = read(), v = read();
if (op == 1) {
int pos = fmax(1, v);
if (pos <= u) xg(1, pos, u, v);
}
if (op == 2) {
int ans = 0, now = u, r, tt;
while (now < n + 1 and (tt = max(now, fmax(1, v))) and tt < n + 1) {
r = cx(1, tt);
ans += r - tt, now = r + 1;
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 10;
long long a[MAX];
struct segTree {
int left, right;
long long sum, lazy, Max, Min;
} tree[4 * MAX + 10];
void pushup(int rt) {
tree[rt].Max = max(tree[rt << 1].Max, tree[rt << 1 | 1].Max);
tree[rt].Min = min(tree[rt << 1].Min, tree[rt << 1 | 1].Min);
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
}
void build(int rt, int l, int r) {
tree[rt].left = l, tree[rt].right = r;
tree[rt].Max = 0x7f3f3f3f, tree[rt].Min = -0x7f3f3f3f;
if (l == r) {
tree[rt].sum = a[l];
tree[rt].Max = tree[rt].Min = a[l];
tree[rt].lazy = 0;
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void addtag(int rt, long long lz) {
tree[rt].sum = (tree[rt].right - tree[rt].left + 1) * lz;
tree[rt].lazy = lz;
tree[rt].Max = tree[rt].Min = lz;
}
void pushdown(int rt) {
if (!tree[rt].lazy) return;
int lc = rt << 1, rc = rt << 1 | 1;
addtag(lc, tree[rt].lazy);
addtag(rc, tree[rt].lazy);
tree[rt].lazy = 0;
}
void modify(int rt, int l, int r, long long val) {
if (tree[rt].left >= l && tree[rt].right <= r) {
if (tree[rt].Min >= val) return;
if (tree[rt].Max <= val) {
addtag(rt, val);
return;
}
if (tree[rt].left == tree[rt].right) return;
}
pushdown(rt);
int mid = (tree[rt].left + tree[rt].right) >> 1;
if (l <= mid) modify(rt << 1, l, r, val);
if (r > mid) modify(rt << 1 | 1, l, r, val);
pushup(rt);
}
long long query(int rt, int l, int r, long long &val) {
if (tree[rt].left >= l && tree[rt].right <= r) {
if (tree[rt].Min > val) return 0;
if (val >= tree[rt].sum) {
val -= tree[rt].sum;
return tree[rt].right - tree[rt].left + 1;
}
if (tree[rt].left == tree[rt].right) return 0;
}
pushdown(rt);
int mid = (tree[rt].left + tree[rt].right) >> 1;
long long res = 0;
if (l <= mid) res += query(rt << 1, l, r, val);
if (r > mid) res += query(rt << 1 | 1, l, r, val);
return res;
}
int main() {
int Cas = 1;
while (Cas--) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
build(1, 1, n);
while (m--) {
int op, x;
long long y;
scanf("%d%d%lld", &op, &x, &y);
if (op == 1)
modify(1, 1, x, y);
else {
printf("%lld\n", query(1, x, n, y));
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2E5 + 10;
int n, m;
int w[N];
struct node {
int l, r;
long long val;
int fmin, fmax;
long long lazy;
} t[N << 2];
void pushdown(node &op, long long lazy) {
op.val = lazy * (op.r - op.l + 1);
op.fmin = lazy, op.fmax = lazy;
op.lazy = lazy;
}
void pushdown(int x) {
if (!t[x].lazy) return;
pushdown(t[x << 1], t[x].lazy), pushdown(t[x << 1 | 1], t[x].lazy);
t[x].lazy = 0;
}
void pushup(node &p, node &l, node &r) {
p.val = l.val + r.val;
p.fmin = min(l.fmin, r.fmin), p.fmax = max(l.fmax, r.fmax);
}
void pushup(int x) { pushup(t[x], t[x << 1], t[x << 1 | 1]); }
void build(int l, int r, int x = 1) {
if (l == r) {
t[x] = {l, r, w[l], w[l], w[l], 0};
return;
}
t[x] = {l, r, 0, 0, 0, 0};
int mid = l + r >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
pushup(x);
}
void modify(int l, int r, int c, int x = 1) {
if (l <= t[x].l && r >= t[x].r) {
if (t[x].fmin >= c) return;
if (t[x].fmax < c) {
pushdown(t[x], c);
return;
}
}
pushdown(x);
int mid = t[x].l + t[x].r >> 1;
if (l <= mid) modify(l, r, c, x << 1);
if (r > mid) modify(l, r, c, x << 1 | 1);
pushup(x);
}
int ask(int l, int r, int &have, int x = 1) {
if (l <= t[x].l && r >= t[x].r) {
if (have < t[x].fmin) return 0;
if (have >= t[x].val) {
have -= t[x].val;
return t[x].r - t[x].l + 1;
}
if (t[x].l == t[x].r) return 0;
}
pushdown(x);
int mid = t[x].l + t[x].r >> 1;
int res = 0;
if (l <= mid) res += ask(l, r, have, x << 1);
if (r > mid) res += ask(l, r, have, x << 1 | 1);
return res;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= (n); ++i) scanf("%d", &w[i]);
build(1, n);
while (m--) {
int op, x, y;
scanf("%d %d %d", &op, &x, &y);
if (op == 1)
modify(1, x, y);
else
printf("%d\n", ask(x, n, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 400005;
long long treemax[maxn << 2];
long long treemin[maxn << 2];
long long treesum[maxn << 2];
long long lz[maxn << 2];
void pushup(int rt) {
treemax[rt] = max(treemax[rt << 1], treemax[rt << 1 | 1]);
treemin[rt] = min(treemin[rt << 1], treemin[rt << 1 | 1]);
treesum[rt] = treesum[rt << 1] + treesum[rt << 1 | 1];
}
void pushdown(int l, int r, int rt) {
if (lz[rt]) {
int m = (l + r) >> 1;
lz[rt << 1] = lz[rt];
lz[rt << 1 | 1] = lz[rt];
treesum[rt << 1] = (m - l + 1) * lz[rt];
treesum[rt << 1 | 1] = (r - m) * lz[rt];
treemax[rt << 1] = lz[rt];
treemax[rt << 1 | 1] = lz[rt];
treemin[rt << 1] = lz[rt];
treemin[rt << 1 | 1] = lz[rt];
lz[rt] = 0;
}
}
void build(int l, int r, int rt) {
if (l == r) {
cin >> treesum[rt];
treemax[rt] = treemin[rt] = treesum[rt];
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
void updata(int L, int R, long long add, int l, int r, int rt) {
if (l > R || r < L) return;
if (treemin[rt] >= add) {
return;
}
if (L <= l && R >= r) {
if (add > treemax[rt]) {
treemax[rt] = treemin[rt] = add;
treesum[rt] = add * (r - l + 1);
lz[rt] = add;
return;
}
}
pushdown(l, r, rt);
int m = (l + r) >> 1;
updata(L, R, add, l, m, rt << 1);
updata(L, R, add, m + 1, r, rt << 1 | 1);
pushup(rt);
}
long long query(int L, int R, int l, int r, int rt, long long &y) {
if (l > R || r < L) return 0;
if (treemin[rt] > y) {
return 0;
}
if (L <= l && r <= R && treesum[rt] <= y) {
y -= treesum[rt];
return r - l + 1;
}
int m = (l + r) >> 1;
pushdown(l, r, rt);
return query(L, R, l, m, rt << 1, y) + query(L, R, m + 1, r, rt << 1 | 1, y);
}
void solve() {
long long n, m;
cin >> n >> m;
build(1, n, 1);
while (m--) {
long long q, x, y;
cin >> q >> x >> y;
if (q == 1) {
updata(1, x, y, 1, n, 1);
} else {
cout << query(x, n, 1, n, 1, y) << endl;
}
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t, class... A>
inline void read(t &x, A &...a) {
read(x);
read(a...);
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 2e5 + 5;
long long tr[N << 2];
int mi[N << 2], ma[N << 2], tg[N << 2], n, m;
void pushup(int x) {
tr[x] = tr[x << 1] + tr[x << 1 | 1];
mi[x] = min(mi[x << 1], mi[x << 1 | 1]);
ma[x] = max(ma[x << 1], ma[x << 1 | 1]);
}
void tomax(int x, int l, int r, int v) {
ma[x] = mi[x] = tg[x] = v;
tr[x] = 1ll * (r - l + 1) * v;
}
void pushdown(int x, int l, int r) {
if (!tg[x]) return;
int mid = l + r >> 1;
tomax(x << 1, l, mid, tg[x]);
tomax(x << 1 | 1, mid + 1, r, tg[x]);
tg[x] = 0;
}
void build(int x, int l, int r) {
if (l == r) {
mi[x] = ma[x] = read(tr[x]);
return;
}
int mid = l + r >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pushup(x);
}
void up(int x, int l, int r, int p, int q, int v) {
if (p <= l && r <= q) {
if (mi[x] >= v) return;
if (ma[x] <= v) {
tomax(x, l, r, v);
return;
}
}
pushdown(x, l, r);
int mid = l + r >> 1;
if (p <= mid) up(x << 1, l, mid, p, q, v);
if (q > mid) up(x << 1 | 1, mid + 1, r, p, q, v);
pushup(x);
}
int bin1(int x, int l, int r, int p, int q, int v) {
if (mi[x] > v) return -1;
if (l == r) return l;
pushdown(x, l, r);
int mid = l + r >> 1;
if (p <= mid) {
int res = bin1(x << 1, l, mid, p, q, v);
if (~res) return res;
}
if (q > mid) return bin1(x << 1 | 1, mid + 1, r, p, q, v);
}
int bin2(int x, int l, int r, long long v) {
if (l == r) {
if (tr[x] <= v) return l;
return l - 1;
}
pushdown(x, l, r);
int mid = l + r >> 1;
if (tr[x << 1] <= v) return bin2(x << 1 | 1, mid + 1, r, v - tr[x << 1]);
return bin2(x << 1, l, mid, v);
}
long long que(int x, int l, int r, int p, int q) {
if (q < p) return 0ll;
if (p <= l && r <= q) return tr[x];
pushdown(x, l, r);
int mid = l + r >> 1;
long long res = 0;
if (p <= mid) res += que(x << 1, l, mid, p, q);
if (q > mid) res += que(x << 1 | 1, mid + 1, r, p, q);
return res;
}
void doit() {
int o, x, y;
read(o, x, y);
if (o == 1) {
up(1, 1, n, 1, x, y);
} else {
int ans = 0;
while (x <= n) {
x = bin1(1, 1, n, x, n, y);
if (x == -1) break;
int pos = bin2(1, 1, n, y + que(1, 1, n, 1, x - 1));
ans += pos - x + 1;
y -= que(1, 1, n, x, pos);
x = pos + 2;
}
write(ans);
puts("");
}
}
signed main() {
read(n, m);
build(1, 1, n);
while (m--) doit();
}
|
#include <bits/stdc++.h>
const int mod = 998244353;
const int mod2 = 998244353;
const int maxn = 2e5 + 111;
const int N = 1e6;
using namespace std;
int n, q, a[maxn], mn[4 * maxn], mx[4 * maxn], p[4 * maxn], res, sum;
long long t[4 * maxn];
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = a[tl];
mx[v] = a[tl];
mn[v] = a[tl];
return;
}
int tm = (tl + tr) >> 1;
build(v << 1, tl, tm);
build(v << 1 | 1, tm + 1, tr);
t[v] = t[v << 1] + t[v << 1 | 1];
mx[v] = max(mx[v << 1], mx[v << 1 | 1]);
mn[v] = min(mn[v << 1], mn[v << 1 | 1]);
}
void push(int v, int tl, int tr) {
if (p[v]) {
p[v << 1] = p[v];
mn[v << 1] = p[v];
mx[v << 1] = p[v];
p[v << 1 | 1] = p[v];
mn[v << 1 | 1] = p[v];
mx[v << 1 | 1] = p[v];
t[v << 1] = 1ll * p[v] * ((tl + tr) / 2 - tl + 1);
t[v << 1 | 1] = 1ll * p[v] * (tr - (tl + tr) / 2);
p[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, int cost) {
if (tr < l || r < tl || l > r || mn[v] >= cost) return;
if (tl >= l && tr <= r && mx[v] <= cost) {
t[v] = 1ll * (tr - tl + 1) * cost;
mn[v] = cost;
mx[v] = cost;
p[v] = cost;
return;
}
push(v, tl, tr);
int tm = (tl + tr) >> 1;
update(v << 1, tl, tm, l, r, cost);
update(v << 1 | 1, tm + 1, tr, l, r, cost);
t[v] = t[v << 1] + t[v << 1 | 1];
mx[v] = max(mx[v << 1], mx[v << 1 | 1]);
mn[v] = min(mn[v << 1], mn[v << 1 | 1]);
}
void get(int v, int tl, int tr, int l, int r) {
if (tr < l || r < tl || l > r || mn[v] > res) return;
if (tl >= l && tr <= r && t[v] <= res) {
res -= t[v];
sum += (tr - tl + 1);
return;
}
push(v, tl, tr);
int tm = (tl + tr) >> 1;
get(v << 1, tl, tm, l, r);
get(v << 1 | 1, tm + 1, tr, l, r);
}
void solve() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
while (q--) {
int type, x, y;
scanf("%d%d%d", &type, &x, &y);
if (type == 1)
update(1, 1, n, 1, x, y);
else {
sum = 0;
res = y;
get(1, 1, n, x, n);
printf("%d\n", sum);
}
}
}
int main() {
int qq = 1;
while (qq--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sum;
int mn;
node() : sum(0), mn(2e9) {}
node(long long sum, int mn) : sum(sum), mn(mn) {}
};
node merge(node a, node b) { return node(a.sum + b.sum, min(a.mn, b.mn)); }
struct STree {
vector<node> st;
vector<int> lazy;
int n;
STree(int n) : st(4 * n + 5), lazy(4 * n + 5, 0), n(n) {}
void push(int k, int s, int e) {
if (!lazy[k]) return;
st[k].mn = lazy[k];
st[k].sum = 1ll * (e - s) * lazy[k];
if (s + 1 < e) {
lazy[2 * k] = lazy[k];
lazy[2 * k + 1] = lazy[k];
}
lazy[k] = 0;
}
void upd(int k, int s, int e, int a, int b, int v) {
push(k, s, e);
if (s >= b || e <= a) return;
if (s >= a && e <= b) {
lazy[k] = v;
push(k, s, e);
return;
}
int m = (s + e) / 2;
upd(2 * k, s, m, a, b, v);
upd(2 * k + 1, m, e, a, b, v);
st[k] = merge(st[2 * k], st[2 * k + 1]);
}
int right(int k, int s, int e, int p, int v) {
push(k, s, e);
if (e - 1 < p) return n;
if (s >= p) {
if (st[k].mn > v) return n;
if (s + 1 == e) return s;
}
int m = (s + e) / 2;
int ans = right(2 * k, s, m, p, v);
if (ans == n) ans = right(2 * k + 1, m, e, p, v);
return ans;
}
pair<int, int> get(int k, int s, int e, int p, int v) {
push(k, s, e);
if (e - 1 < p) return {n, v};
if (s >= p) {
if (st[k].sum <= v) return {n, v - st[k].sum};
if (s + 1 == e) return {s, v};
}
int m = (s + e) / 2;
pair<int, int> ans = get(2 * k, s, m, p, v);
if (ans.first == n) ans = get(2 * k + 1, m, e, p, ans.second);
return ans;
}
void upd(int a, int b, int v) { upd(1, 0, n, a, b, v); }
int right(int p, int v) { return right(1, 0, n, p, v); }
pair<int, int> get(int p, int v) { return get(1, 0, n, p, v); }
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
STree st(n);
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
int x;
cin >> x;
st.upd(i, i + 1, x);
}
while (q--) {
int t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
int s = st.right(0, y - 1);
st.upd(s, x + 1, y);
} else {
int ans = 0;
while (x < n) {
x = st.right(x, y);
pair<int, int> now = st.get(x, y);
ans += now.first - x;
x = now.first;
y = now.second;
}
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807;
const long long MOD = 1000000007;
const long double PI = acos(-1);
inline long long power(long long a, long long b, long long z = MOD) {
long long res = 1;
a = (a % z);
while (b) {
if (b & 1) res = (res * a) % z;
a = (a * a) % z;
b = b >> 1;
}
return res;
}
inline long long inverse(long long a, long long z = MOD) {
return power(a, z - 2, z);
}
long long extend(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long x1, y1;
long long g = extend(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
inline long long mat_power(long long a, long long b, long long c, long long d,
long long n, long long z = MOD) {
long long a0 = 1, b0 = 0, c0 = 0, d0 = 1;
while (n) {
if (n & 1) {
long long a1 = a0, b1 = b0, c1 = c0, d1 = d0;
a0 = (a1 * a + b1 * c) % z;
b0 = (a1 * b + b1 * d) % z;
c0 = (c1 * a + d1 * c) % z;
d0 = (c1 * b + d1 * d) % z;
}
long long a1 = a, b1 = b, c1 = c, d1 = d;
a = (a1 * a1 + b1 * c1) % z;
b = (a1 * b1 + b1 * d1) % z;
c = (c1 * a1 + d1 * c1) % z;
d = (c1 * b1 + d1 * d1) % z;
n = n >> 1;
}
return c0;
}
long long aray[200000], sum[800005], low[800005], high[800005], lazy[800005];
void build(long long node, long long l, long long r) {
lazy[node] = 0;
if (l == r) {
sum[node] = low[node] = high[node] = aray[l];
return;
}
long long mid = (l + r) >> 1;
build(node << 1, l, mid);
build((node << 1) + 1, mid + 1, r);
sum[node] = sum[node << 1] + sum[(node << 1) + 1];
low[node] = min(low[node << 1], low[(node << 1) + 1]);
high[node] = max(high[node << 1], high[(node << 1) + 1]);
return;
}
void update(long long node, long long l, long long r, long long left,
long long right, long long val) {
if (lazy[node] != 0) {
sum[node] = lazy[node] * (r - l + 1);
low[node] = high[node] = lazy[node];
if (l != r) {
lazy[node << 1] = max(lazy[node], lazy[node << 1]);
lazy[(node << 1) + 1] = max(lazy[node], lazy[(node << 1) + 1]);
}
lazy[node] = 0;
}
if (left > right) return;
if (left > r || l > right) return;
if (left <= l && right >= r) {
if (high[node] <= val) {
sum[node] = val * (r - l + 1);
low[node] = high[node] = val;
if (l != r) {
long long mid = (l + r) >> 1;
lazy[node << 1] = max(lazy[node << 1], val);
lazy[(node << 1) + 1] = max(lazy[(node << 1) + 1], val);
}
} else if (low[node] > val)
return;
else {
long long mid = (l + r) >> 1;
update(node << 1, l, mid, left, min(mid, right), val);
update((node << 1) + 1, mid + 1, r, max(left, mid + 1), right, val);
sum[node] = sum[node << 1] + sum[(node << 1) + 1];
low[node] = min(low[node << 1], low[(node << 1) + 1]);
high[node] = max(high[node << 1], high[(node << 1) + 1]);
}
return;
}
long long mid = (l + r) >> 1;
update(node << 1, l, mid, left, min(mid, right), val);
update((node << 1) + 1, mid + 1, r, max(left, mid + 1), right, val);
sum[node] = sum[node << 1] + sum[(node << 1) + 1];
low[node] = min(low[node << 1], low[(node << 1) + 1]);
high[node] = max(high[node << 1], high[(node << 1) + 1]);
return;
}
pair<long long, long long> query(long long node, long long l, long long r,
long long left, long long right,
long long val) {
if (left > right) return make_pair(0, 0);
if (left > r || l > right) return make_pair(0, 0);
if (lazy[node] != 0) {
sum[node] = lazy[node] * (r - l + 1);
low[node] = high[node] = lazy[node];
if (l != r) {
lazy[node << 1] = max(lazy[node], lazy[node << 1]);
lazy[(node << 1) + 1] = max(lazy[node], lazy[(node << 1) + 1]);
}
lazy[node] = 0;
}
if (left <= l && right >= r) {
if (low[node] > val) return make_pair(0, 0);
if (sum[node] <= val) return make_pair(r - l + 1, sum[node]);
long long mid = (l + r) >> 1;
pair<long long, long long> num =
query(node << 1, l, mid, left, max(right, mid), val);
pair<long long, long long> tot =
query((node << 1) + 1, mid + 1, r, max(left, mid + 1), right,
val - num.second);
return make_pair(num.first + tot.first, num.second + tot.second);
}
if (low[node] > val) return make_pair(0, 0);
long long mid = (l + r) >> 1;
pair<long long, long long> num =
query(node << 1, l, mid, left, max(right, mid), val);
pair<long long, long long> tot = query(
(node << 1) + 1, mid + 1, r, max(left, mid + 1), right, val - num.second);
return make_pair(num.first + tot.first, num.second + tot.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, q;
cin >> n >> q;
for (long long i = 0; i < n; i++) cin >> aray[i];
build(1, 0, n - 1);
while (q--) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1)
update(1, 0, n - 1, 0, x - 1, y);
else
cout << query(1, 0, n - 1, x - 1, n - 1, y).first << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long a[N], n, q;
long long t[N << 2], lz[N << 2], mx[N << 2], mi[N << 2];
void up(long long x) {
t[x] = t[x << 1] + t[x << 1 | 1];
mx[x] = mx[x << 1];
mi[x] = mi[x << 1 | 1];
}
void build(long long x, long long l, long long r) {
if (l == r)
mi[x] = mx[x] = t[x] = a[l];
else {
long long mid = l + r >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
up(x);
}
}
void zuo(long long x, long long l, long long r, long long y) {
t[x] = y * (r - l + 1);
mx[x] = y;
mi[x] = y;
lz[x] = y;
}
void down(long long x, long long l, long long r) {
if (!lz[x]) return;
long long mid = l + r >> 1;
zuo(x << 1, l, mid, lz[x]);
zuo(x << 1 | 1, mid + 1, r, lz[x]);
lz[x] = 0;
}
long long qge(long long y, long long x, long long l, long long r) {
if (l == r) return l;
down(x, l, r);
long long mid = l + r >> 1;
if (y > mx[x << 1 | 1])
return qge(y, x << 1, l, mid);
else
return qge(y, x << 1 | 1, mid + 1, r);
}
void ins(long long L, long long R, long long y, long long x, long long l,
long long r) {
if (l >= L && r <= R) {
zuo(x, l, r, y);
return;
}
down(x, l, r);
long long mid = l + r >> 1;
if (mid >= L) ins(L, R, y, x << 1, l, mid);
if (mid + 1 <= R) ins(L, R, y, x << 1 | 1, mid + 1, r);
up(x);
}
long long pyf(long long L, long long R, long long x, long long l, long long r) {
if (l >= L && r <= R) {
return t[x];
}
down(x, l, r);
long long mid = l + r >> 1, ans = 0;
if (mid >= L) ans += pyf(L, R, x << 1, l, mid);
if (mid + 1 <= R) ans += pyf(L, R, x << 1 | 1, mid + 1, r);
return ans;
}
long long qur(long long& y, long long x, long long l, long long r) {
if (l == r) return 0;
down(x, l, r);
long long mid = l + r >> 1, bian = 0;
if (y >= mi[x << 1])
if (y >= t[x << 1])
bian += mid - l + 1, y -= t[x << 1];
else
bian += qur(y, x << 1, l, mid);
if (y >= mi[x << 1 | 1])
if (y >= t[x << 1 | 1])
bian += r - mid, y -= t[x << 1 | 1];
else
bian += qur(y, x << 1 | 1, mid + 1, r);
return bian;
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> q;
for (long long i = 1; i <= n; ++i) cin >> a[i];
a[0] = 1e9 + 1;
n = n + 1;
build(1, 0, n);
for (long long opt, x, y, i = 1; i <= q; ++i) {
cin >> opt >> x >> y;
if (opt == 1) {
long long L = qge(y + 1, 1, 0, n) + 1;
if (L > x) continue;
ins(L, x, y, 1, 0, n);
} else {
long long now = y + pyf(0, x - 1, 1, 0, n);
long long dis = qur(now, 1, 0, n);
cout << dis - x - 1 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (int i = 0; i < (int)v.size(); i++) {
if (i) os << ", ";
os << v[i];
}
os << "}";
return os;
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
struct Data {
long long sum;
int mn;
};
const int INF = 1e9 + 10;
Data merge(const Data& A, const Data& B) {
return {A.sum + B.sum, min(A.mn, B.mn)};
}
struct segtree {
vector<Data> tree;
vector<int> lazy;
int n;
segtree(vector<int> a) : n(a.size()) {
tree.resize(4 * n + 10);
lazy.resize(4 * n + 10);
function<void(int, int, int)> make = [&](int s, int e, int ind) {
if (s == e) {
tree[ind] = {a[s], a[s]};
return;
}
int mid = (s + e) >> 1;
make(s, mid, ind << 1);
make(mid + 1, e, ind << 1 | 1);
tree[ind] = merge(tree[ind << 1], tree[ind << 1 | 1]);
};
make(0, n - 1, 1);
}
void push(int s, int e, int ind) {
int x = lazy[ind];
if (!x) return;
tree[ind].sum = x * (long long)(e - s + 1);
tree[ind].mn = x;
if (s != e) {
lazy[ind << 1] = lazy[ind << 1 | 1] = x;
}
lazy[ind] = 0;
}
void update(int l, int r, int x, int s, int e, int ind) {
push(s, e, ind);
if (s > r || l > e) return;
if (s >= l && e <= r) {
lazy[ind] = x;
push(s, e, ind);
return;
}
int mid = (s + e) >> 1;
update(l, r, x, s, mid, ind << 1);
update(l, r, x, mid + 1, e, ind << 1 | 1);
tree[ind] = merge(tree[ind << 1], tree[ind << 1 | 1]);
}
int getFirst(int x, int s, int e, int ind) {
push(s, e, ind);
if (s == e) {
return s;
}
int mid = (s + e) >> 1;
push(s, mid, ind << 1);
if (tree[ind << 1].mn >= x)
return getFirst(x, mid + 1, e, ind << 1 | 1);
else
return getFirst(x, s, mid, ind << 1);
}
int getFirst(int x) {
push(0, n - 1, 1);
if (tree[1].mn >= x) return n;
return getFirst(x, 0, n - 1, 1);
}
long long getSum(int l, int r, int s, int e, int ind) {
if (l > r) return 0;
push(s, e, ind);
if (s > r || l > e) return 0;
if (s >= l && e <= r) return tree[ind].sum;
int mid = (s + e) >> 1;
return getSum(l, r, s, mid, ind << 1) +
getSum(l, r, mid + 1, e, ind << 1 | 1);
}
int getFirstSum(long long sm, long long x, int s, int e, int ind) {
push(s, e, ind);
if (s == e) {
return s;
}
int mid = (s + e) >> 1;
push(s, mid, ind << 1);
long long v = tree[ind << 1].sum + sm;
if (v > x)
return getFirstSum(sm, x, s, mid, ind << 1);
else
return getFirstSum(v, x, mid + 1, e, ind << 1 | 1);
}
void update(int r, int x) {
int h = getFirst(x);
if (h > r) return;
update(h, r, x, 0, n - 1, 1);
}
int getPos(int pos, long long val) {
push(0, n - 1, 1);
long long s = getSum(0, pos - 1, 0, n - 1, 1);
if (s + val >= tree[1].sum) return n;
return getFirstSum(0, s + val, 0, n - 1, 1);
}
int getNum(int pos, long long y) {
int ans = 0;
while (pos != n) {
pos = max(pos, getFirst(y + 1));
if (pos == n) break;
int pos2 = getPos(pos, y);
assert(pos2 > pos);
y -= getSum(pos, pos2 - 1, 0, n - 1, 1);
ans += pos2 - pos;
pos = pos2;
}
return ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
segtree st(a);
while (q--) {
int type, x, y;
cin >> type >> x >> y;
x--;
if (type == 1) {
st.update(x, y);
} else {
cout << st.getNum(x, y) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const int maxn = 2e5 + 10;
int n, q;
ll a[maxn];
ll mn[maxn * 4], mx[maxn * 4], t[maxn * 4], tag[maxn * 4];
int siz[maxn * 4];
void push(int v) {
if (tag[v] != 0 && siz[v] > 1) {
mn[2 * v] = mx[2 * v] = tag[v];
mn[2 * v + 1] = mx[2 * v + 1] = tag[v];
t[2 * v] = 1ll * siz[2 * v] * tag[v];
t[2 * v + 1] = 1ll * siz[2 * v + 1] * tag[v];
tag[2 * v] = tag[2 * v + 1] = tag[v];
tag[v] = 0;
}
}
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];
siz[v] = siz[2 * v] + siz[2 * v + 1];
}
void build(int v, int tl, int tr) {
if (tl == tr) {
mn[v] = mx[v] = t[v] = a[tl];
siz[v] = 1;
} else {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
merge(v);
}
}
ll qry(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return 0;
if (l <= tl && tr <= r) return t[v];
push(v);
int tm = (tl + tr) / 2;
return qry(2 * v, tl, tm, l, r) + qry(2 * v + 1, tm + 1, tr, l, r);
}
void updMax(int v, int tl, int tr, int l, int r, ll val) {
if (l > tr || r < tl) return;
if (mn[v] >= val) return;
if (l <= tl && tr <= r && mx[v] < val) {
mn[v] = mx[v] = val;
t[v] = 1ll * siz[v] * val;
tag[v] = val;
return;
}
push(v);
int tm = (tl + tr) / 2;
updMax(2 * v, tl, tm, l, r, val);
updMax(2 * v + 1, tm + 1, tr, l, r, val);
merge(v);
}
int solve(int v, int tl, int tr, int l, int r, ll& have) {
push(v);
if (l == tl && tr == r) {
if (t[v] <= have) {
have -= t[v];
return siz[v];
}
if (mn[v] > have) {
return 0;
}
int tm = (tl + tr) / 2;
int left = solve(2 * v, tl, tm, l, tm, have);
int right = solve(2 * v + 1, tm + 1, tr, tm + 1, r, have);
return left + right;
} else {
int tm = (tl + tr) / 2;
if (r <= tm) {
return solve(2 * v, tl, tm, l, r, have);
} else if (l >= tm + 1) {
return solve(2 * v + 1, tm + 1, tr, l, r, have);
}
int left = solve(2 * v, tl, tm, l, tm, have);
int right = solve(2 * v + 1, tm + 1, tr, tm + 1, r, have);
return left + right;
}
}
void print() {
for (int i = 1; i <= n; i++) {
cout << qry(1, 1, n, i, i) << " ";
}
cout << endl << endl;
}
int main() {
ios_base::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, 1, n);
while (q--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) {
updMax(1, 1, n, 1, x, y);
} else {
ll money = y;
cout << solve(1, 1, n, x, n, money) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 7;
const long long mod = 1e9 + 7;
const long long INF = 1e9 + 7;
const long long mlog = 20;
const long long SQ = 400;
long long n, q;
long long a[maxn];
long long seg[maxn * 4], lazy[maxn * 4], mini[maxn * 4], maxi[maxn * 4];
void shift(long long s, long long e, long long id) {
if (lazy[id] == -1) return;
lazy[id * 2 + 0] = lazy[id * 2 + 1] = lazy[id];
long long mid = (s + e) / 2;
seg[id * 2 + 0] = (mid - s) * lazy[id];
seg[id * 2 + 1] = (e - mid) * lazy[id];
mini[id * 2 + 0] = maxi[id * 2 + 0] = mini[id * 2 + 1] = maxi[id * 2 + 1] =
lazy[id];
lazy[id] = -1;
}
void BUILD(long long s = 0, long long e = n, long long id = 1) {
if (e - s < 2) {
mini[id] = maxi[id] = seg[id] = a[s];
return;
}
long long mid = (s + e) / 2;
BUILD(s, mid, id * 2 + 0);
BUILD(mid, e, id * 2 + 1);
seg[id] = seg[id * 2 + 0] + seg[id * 2 + 1];
mini[id] = min(mini[id * 2 + 0], mini[id * 2 + 1]);
maxi[id] = max(maxi[id * 2 + 0], maxi[id * 2 + 1]);
}
void UPDATE(long long l, long long val, long long s = 0, long long e = n,
long long id = 1) {
if (l <= s || mini[id] > val) return;
if (l >= e && maxi[id] <= val) {
seg[id] = (e - s) * val;
mini[id] = maxi[id] = lazy[id] = val;
return;
}
shift(s, e, id);
long long mid = (s + e) / 2;
UPDATE(l, val, s, mid, id * 2 + 0);
UPDATE(l, val, mid, e, id * 2 + 1);
seg[id] = seg[id * 2 + 0] + seg[id * 2 + 1];
mini[id] = min(mini[id * 2 + 0], mini[id * 2 + 1]);
maxi[id] = max(maxi[id * 2 + 0], maxi[id * 2 + 1]);
}
pair<long long, long long> GET(long long l, long long v, long long s = 0,
long long e = n, long long id = 1) {
if (l >= e || v < mini[id]) return {0, v};
if (l <= s && v >= seg[id]) return {e - s, v - seg[id]};
shift(s, e, id);
long long mid = (s + e) / 2;
pair<long long, long long> P1 = GET(l, v, s, mid, id * 2 + 0);
pair<long long, long long> P2 = GET(l, P1.second, mid, e, id * 2 + 1);
return {P1.first + P2.first, P2.second};
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
;
cin >> n >> q;
for (long long i = 0; i < n; i++) cin >> a[i];
BUILD();
memset(lazy, -1, sizeof(lazy));
while (q--) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) UPDATE(x, y);
if (t == 2) cout << GET(--x, y).first << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:512000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937_64 gen(time(nullptr));
namespace {
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template <typename T, typename F>
using HashMap = unordered_map<T, F, custom_hash>;
template <typename T>
using HashSet = unordered_set<T, custom_hash>;
} // namespace
ll mod = 1e9 + 7;
namespace {
ll mul(ll a, ll b) {
ll val = a * b - (ll)((ld)a * b / mod) * mod;
if (val < 0) val += mod;
if (val >= mod) val -= mod;
return val;
}
ll poww(ll a, ll b) {
ll val = 1;
a %= mod;
while (b > 0) {
if (b % 2) val = mul(a, val);
a = mul(a, a);
b >>= 1;
}
return val % mod;
}
ll inv(ll a) { return poww(a, mod - 2); }
ll gcd(ll a, ll b) { return (a == 0 ? b : gcd(b % a, a)); }
ll gcdex(ll a, ll b, ll& x, ll& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
ll x1, y1;
ll d = gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
ll inv_eu(ll a, ll m) {
ll x, y;
ll g = gcdex(a, m, x, y);
if (g != 1)
assert(0);
else {
x = (x % m + m) % m;
return x;
}
}
} // namespace
ll const inf = 1e11 + 9;
ll const maxk = 22;
int const maxn = 1 << 20;
int a[maxn];
ll t_sm[4 * maxn];
int t_mx[4 * maxn], t_mn[4 * maxn], lazy[4 * maxn];
void upd(int u) {
t_sm[u] = t_sm[2 * u] + t_sm[2 * u + 1];
t_mx[u] = max(t_mx[2 * u], t_mx[2 * u + 1]);
t_mn[u] = min(t_mn[2 * u], t_mn[2 * u + 1]);
}
void push(int u, int tl, int tr) {
if (lazy[u]) {
t_mx[u] = lazy[u];
t_mn[u] = lazy[u];
t_sm[u] = (tr - tl + 1) * 1LL * (lazy[u]);
lazy[u * 2] = max(lazy[u * 2], lazy[u]);
lazy[u * 2 + 1] = max(lazy[u * 2 + 1], lazy[u]);
lazy[u] = 0;
}
}
void upd_max(int u, int tl, int tr, int l, int r, int mx) {
push(u, tl, tr);
if (tr < l or tl > r) return;
if (t_mn[u] >= mx) return;
if (t_mx[u] <= mx and tl >= l and tr <= r) {
lazy[u] = mx;
push(u, tl, tr);
return;
}
int tm = (tl + tr) / 2;
upd_max(u * 2, tl, tm, l, r, mx);
upd_max(u * 2 + 1, tm + 1, tr, l, r, mx);
upd(u);
}
int last_pos = -1;
int ans = 0;
ll sum = 0;
void query(int u, int tl, int tr, int pos) {
push(u, tl, tr);
if (tr < pos or (last_pos != -1 and last_pos != tl - 1)) return;
if (t_mn[u] > sum) return;
if (t_sm[u] <= sum and tl >= pos) {
if (last_pos == -1 or last_pos == tl - 1) {
ans += tr - tl + 1;
last_pos = tr;
sum -= t_sm[u];
return;
}
}
int tm = (tl + tr) / 2;
query(u * 2, tl, tm, pos);
query(u * 2 + 1, tm + 1, tr, pos);
}
void build(int u, int tl, int tr) {
if (tr == tl) {
t_mn[u] = t_mx[u] = t_sm[u] = a[tl];
return;
}
int tm = (tl + tr) / 2;
build(u * 2, tl, tm);
build(u * 2 + 1, tm + 1, tr);
upd(u);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fill_n(a, maxn, 1e9 + 1);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
int mn = a[n - 1];
build(1, 0, maxn - 1);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
upd_max(1, 0, maxn - 1, 0, x, y);
if (x == n - 1) mn = max(mn, y);
} else {
sum = y;
ans = 0;
last_pos = -1;
int ps = x;
while (ps <= n - 1 and sum >= mn) {
last_pos = -1;
query(1, 0, maxn - 1, ps);
ps = max(ps, last_pos + 2);
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200003;
int n, q;
unsigned long long a[N];
struct ok {
int lo;
int hi;
unsigned long long val;
unsigned long long cnt;
unsigned long long lazy;
unsigned long long mi;
};
ok Node[4 * N];
void build(int id, int l, int r) {
Node[id].lo = l;
Node[id].hi = r;
if (l == r) {
Node[id].val = a[l];
Node[id].cnt = 1;
Node[id].mi = a[l];
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
Node[id].val = Node[id * 2].val + Node[id * 2 + 1].val;
Node[id].cnt = Node[id * 2].cnt + Node[id * 2 + 1].cnt;
Node[id].mi = Node[id * 2 + 1].mi;
}
void down(int id) {
unsigned long long t = Node[id].lazy;
Node[id * 2].val = max(Node[id * 2].val, t * Node[id * 2].cnt);
Node[id * 2].lazy = max(Node[id * 2].lazy, t);
Node[id * 2].mi = max(Node[id * 2].mi, t);
Node[id * 2 + 1].val = max(Node[id * 2 + 1].val, t * Node[id * 2 + 1].cnt);
Node[id * 2 + 1].lazy = max(Node[id * 2 + 1].lazy, t);
Node[id * 2 + 1].mi = max(Node[id * 2 + 1].mi, t);
Node[id].lazy = 0;
return;
}
void update(int id, int l, int r, unsigned long long val) {
if (l > r) return;
if (Node[id].lo > r || Node[id].hi < l) return;
if (l <= Node[id].lo && Node[id].hi <= r) {
Node[id].val = max(Node[id].val, val * Node[id].cnt);
Node[id].lazy = max(Node[id].lazy, val);
Node[id].mi = max(Node[id].mi, val);
return;
}
down(id);
update(id * 2, l, r, val);
update(id * 2 + 1, l, r, val);
Node[id].val = Node[id * 2].val + Node[id * 2 + 1].val;
Node[id].mi = Node[id * 2 + 1].mi;
}
unsigned long long getpos(int id, int pos) {
if (Node[id].lo > pos || Node[id].hi < pos) return 0;
if (Node[id].lo == Node[id].hi) return Node[id].val;
down(id);
return max(getpos(id * 2, pos), getpos(id * 2 + 1, pos));
}
pair<unsigned long long, unsigned long long> getval(int id, int l, int r,
unsigned long long sum) {
if (Node[id].lo > r || Node[id].hi < l) return {0, 0};
if (Node[id].mi > sum) return {0, 0};
if (Node[id].val <= sum && Node[id].lo >= l)
return {Node[id].cnt, Node[id].val};
down(id);
if (Node[id * 2].mi <= sum) {
pair<unsigned long long, unsigned long long> top =
getval(id * 2, l, r, sum);
int cnt = top.first;
unsigned long long val = top.second;
top = getval(id * 2 + 1, l, r, sum - val);
return {cnt + top.first, val + top.second};
} else
return getval(id * 2 + 1, l, r, sum);
}
int main() {
ios::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);
while (q--) {
int tp, x;
unsigned long long y;
cin >> tp >> x >> y;
if (tp == 1) {
int pos = x + 1;
int lo = 1, hi = x;
while (lo <= hi) {
int mid = (lo + hi) / 2;
unsigned long long cur = getpos(1, mid);
if (cur >= y) {
lo = mid + 1;
} else {
pos = mid;
hi = mid - 1;
}
}
update(1, pos, x, y);
} else {
cout << getval(1, x, n, y).first << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 5e5 + 5;
int N, M, A[MN], tg[MN << 2], mn[MN << 2];
long long sum[MN << 2];
inline void pushup(int now) {
sum[now] = sum[now << 1] + sum[now << 1 | 1];
mn[now] = min(mn[now << 1], mn[now << 1 | 1]);
}
inline void build(int now, int l, int r) {
tg[now] = -1;
if (l == r) {
sum[now] = mn[now] = A[l];
return;
}
int mid = l + r >> 1;
build(now << 1, l, mid), build(now << 1 | 1, mid + 1, r);
pushup(now);
}
inline void pushdown(int now, int l, int r) {
if (tg[now] == -1) return;
int mid = l + r >> 1;
mn[now << 1] = mn[now << 1 | 1] = tg[now];
sum[now << 1] = 1LL * (mid - l + 1) * tg[now];
sum[now << 1 | 1] = 1LL * (r - mid) * tg[now];
tg[now << 1] = tg[now], tg[now << 1 | 1] = tg[now];
tg[now] = -1;
return;
}
inline long long query(int now, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return sum[now];
int mid = l + r >> 1;
pushdown(now, l, r);
if (mid >= qr)
return query(now << 1, l, mid, ql, qr);
else if (mid + 1 <= ql)
return query(now << 1 | 1, mid + 1, r, ql, qr);
else
return query(now << 1, l, mid, ql, mid) +
query(now << 1 | 1, mid + 1, r, mid + 1, qr);
}
inline void modify(int now, int l, int r, int ql, int qr, int val) {
if (l == ql && r == qr) {
mn[now] = val;
sum[now] = 1LL * (r - l + 1) * val;
tg[now] = val;
return;
}
int mid = l + r >> 1;
pushdown(now, l, r);
if (mid >= qr)
modify(now << 1, l, mid, ql, qr, val);
else if (mid + 1 <= ql)
modify(now << 1 | 1, mid + 1, r, ql, qr, val);
else
modify(now << 1, l, mid, ql, mid, val),
modify(now << 1 | 1, mid + 1, r, mid + 1, qr, val);
pushup(now);
}
inline int ask(int now, int l, int r, long long &val) {
if (val >= sum[now]) {
val -= sum[now];
return r - l + 1;
}
if (l == r) return 0;
int mid = l + r >> 1;
pushdown(now, l, r);
int res = 0;
if (mn[now << 1] <= val) res += ask(now << 1, l, mid, val);
if (mn[now << 1 | 1] <= val) res += ask(now << 1 | 1, mid + 1, r, val);
return res;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) scanf("%d", &A[i]);
build(1, 1, N);
for (int i = 1; i <= M; ++i) {
int op, x;
long long y;
scanf("%d%d%lld", &op, &x, &y);
if (op == 1) {
int l = 1, r = x, ans = 0;
while (l <= r) {
int mid = l + r >> 1;
if (query(1, 1, N, mid, mid) < y) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans) modify(1, 1, N, ans, x, y);
} else {
if (x > 1) y += query(1, 1, N, 1, x - 1);
printf("%d\n", ask(1, 1, N, y) - (x - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 200;
struct node {
long long sum, mn, mx, subval;
} t[4 * N];
long long a[N];
int n, q;
inline void merge(int v) {
t[v].sum = t[v << 1].sum + t[v << 1 | 1].sum;
t[v].mn = min(t[v << 1].mn, t[v << 1 | 1].mn);
t[v].mx = max(t[v << 1].mx, t[v << 1 | 1].mx);
}
inline void push(int v, int tl, int tr) {
if (tl == tr) return;
int tm = (tl + tr) / 2;
if (t[v].subval != 0) {
t[v << 1].subval = max(t[v << 1].subval, t[v].subval);
t[v << 1].mx = t[v << 1].subval;
t[v << 1].mn = t[v << 1].subval;
t[v << 1].sum = t[v << 1].subval * (long long)(tm - tl + 1);
t[v << 1 | 1].subval = max(t[v << 1 | 1].subval, t[v].subval);
t[v << 1 | 1].mx = t[v << 1 | 1].subval;
t[v << 1 | 1].mn = t[v << 1 | 1].subval;
t[v << 1 | 1].sum = t[v << 1 | 1].subval * (long long)(tr - tm);
t[v].subval = 0;
}
}
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v].sum = t[v].mn = t[v].mx = t[v].subval = a[tl];
return;
}
int tm = (tl + tr) / 2;
build(v << 1, tl, tm);
build(v << 1 | 1, tm + 1, tr);
merge(v);
}
void upd(int v, int tl, int tr, int x, long long y) {
push(v, tl, tr);
if (t[v].mn >= y || tl > x) return;
if (tr <= x && t[v].mx <= y) {
t[v].subval = max(t[v].subval, y);
t[v].mx = t[v].mn = t[v].subval;
t[v].sum = t[v].subval * (long long)(tr - tl + 1);
return;
}
if (tl == tr) return;
int tm = (tl + tr) / 2;
upd(v << 1, tl, tm, x, y);
upd(v << 1 | 1, tm + 1, tr, x, y);
merge(v);
}
int go(int v, int tl, int tr, int x, long long& y) {
push(v, tl, tr);
if (tr < x) return 0;
if (t[v].sum <= y && tl >= x) {
y -= t[v].sum;
return tr - tl + 1;
}
if (tl == tr || y < t[v].mn) return 0;
int tm = (tl + tr) / 2;
return go(v << 1, tl, tm, x, y) + go(v << 1 | 1, tm + 1, tr, x, y);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
build(1, 0, n - 1);
while (q--) {
int t;
long long x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
upd(1, 0, n - 1, x, y);
} else {
cout << go(1, 0, n - 1, x, y) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
struct tree {
int l, r, add, lv, rv;
ll sum;
} tr[N << 2];
int n, q, a[N];
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 = a[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", a + i);
Build(1, 1, n);
while (q--) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1)
Modify(1, x, y);
else
printf("%d\n", Ask(1, x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long k;
struct Node {
long long maxx;
long long minn;
long long sum;
} tree[N << 2];
long long lazy[N << 2], a[N << 2];
void push_up(int node) {
tree[node].maxx = max(tree[node << 1].maxx, tree[node << 1 | 1].maxx);
tree[node].minn = min(tree[node << 1].minn, tree[node << 1 | 1].minn);
tree[node].sum = tree[node << 1].sum + tree[node << 1 | 1].sum;
if (lazy[node << 1] == lazy[node << 1 | 1]) lazy[node] = lazy[node << 1];
}
void push_down(int node, int len) {
if (lazy[node] != -1) {
tree[node << 1].maxx = tree[node << 1 | 1].maxx = lazy[node];
tree[node << 1].minn = tree[node << 1 | 1].minn = lazy[node];
tree[node << 1].sum = (len - (len >> 1)) * lazy[node];
tree[node].sum = len * lazy[node];
tree[node << 1 | 1].sum = (len >> 1) * lazy[node];
lazy[node << 1] = lazy[node << 1 | 1] = lazy[node];
lazy[node] = -1;
}
}
void build(int node, int l, int r) {
lazy[node] = -1;
if (l == r) {
tree[node].maxx = tree[node].minn = a[l];
tree[node].sum = a[l];
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
push_up(node);
}
void change(int node, int l, int r, int L, int R) {
if (L <= l && R >= r) {
if (k >= tree[node].maxx) {
lazy[node] = k;
tree[node].maxx = tree[node].minn = k;
tree[node].sum = (r - l + 1) * k;
return;
}
if (k <= tree[node].minn) return;
}
push_down(node, r - l + 1);
int mid = (l + r) >> 1;
if (L <= mid) change(node << 1, l, mid, L, R);
if (R > mid) change(node << 1 | 1, mid + 1, r, L, R);
push_up(node);
}
long long query(int node, int l, int r, int L, int R) {
if (k <= 0) return 0;
if (L <= l && R >= r) {
if (k >= tree[node].sum) {
k -= tree[node].sum;
return r - l + 1;
} else if (k < tree[node].minn)
return 0;
if (l == r) return 0;
}
push_down(node, r - l + 1);
int mid = (l + r) >> 1;
long long ans = 0;
if (L <= mid) ans += query(node << 1, l, mid, L, R);
if (R > mid) ans += query(node << 1 | 1, mid + 1, r, L, R);
return ans;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, 1, n);
while (q--) {
int t, x;
scanf("%d%d%lld", &t, &x, &k);
if (t == 1) {
change(1, 1, n, 1, x);
} else {
printf("%lld\n", query(1, 1, n, x, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
int A[202020];
int S[4 * 202020];
int E[4 * 202020];
struct NODE {
long long mx;
long long sum, lz;
} T[4 * 202020];
vector<int> v;
void init(int idx, int s, int e) {
S[idx] = s;
E[idx] = e;
if (s == e) return;
int m = s + e >> 1;
init(idx << 1, s, m);
init(idx << 1 | 1, m + 1, e);
}
void propa(int idx, int s, int e) {
if (T[idx].lz) {
T[idx].mx = T[idx].lz;
T[idx].sum = T[idx].mx * (e - s + 1);
}
if (s != e) {
T[idx << 1].lz = max(T[idx << 1].lz, T[idx].lz);
T[idx << 1 | 1].lz = max(T[idx << 1 | 1].lz, T[idx].lz);
}
T[idx].lz = 0;
}
long long fd(int idx, int s, int e, int x) {
propa(idx, s, e);
if (s == e) {
if (T[idx].mx <= x)
return s;
else
return s + 1;
}
int m = s + e >> 1;
propa(idx << 1, s, m);
propa(idx << 1 | 1, m + 1, e);
if (T[idx << 1 | 1].mx > x) return fd(idx << 1 | 1, m + 1, e, x);
return fd(idx << 1, s, m, x);
}
void upd(int idx, int s, int e, int p, int q, int x) {
propa(idx, s, e);
if (q < p || q < s || e < p) return;
if (p <= s && e <= q) {
T[idx].lz = x;
propa(idx, s, e);
return;
}
int m = s + e >> 1;
upd(idx << 1, s, m, p, q, x);
upd(idx << 1 | 1, m + 1, e, p, q, x);
T[idx].mx = max(T[idx << 1].mx, T[idx << 1 | 1].mx);
T[idx].sum = T[idx << 1].sum + T[idx << 1 | 1].sum;
}
void get_intervals(int idx, int s, int e, int p, int q) {
propa(idx, s, e);
if (q < p || q < s || e < p) return;
if (p <= s && e <= q) {
v.push_back(idx);
return;
}
int m = s + e >> 1;
get_intervals(idx << 1, s, m, p, q);
get_intervals(idx << 1 | 1, m + 1, e, p, q);
}
long long fd2(int idx, int s, int e, int& y) {
propa(idx, s, e);
if (s == e) {
if (T[idx].sum <= y)
return s + 1;
else
return s;
}
int m = s + e >> 1;
propa(idx << 1, s, m);
propa(idx << 1 | 1, m + 1, e);
if (T[idx << 1].sum > y) return fd2(idx << 1, s, m, y);
y -= T[idx << 1].sum;
return fd2(idx << 1 | 1, m + 1, e, y);
}
int main() {
scanf("%d%d", &N, &Q);
init(1, 1, N);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
upd(1, 1, N, i, i, A[i]);
}
while (Q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
int a = fd(1, 1, N, y);
if (a <= x) upd(1, 1, N, a, x, y);
} else {
int pos = x;
int ans = 0;
while (1) {
if (pos > N) break;
int a = fd(1, 1, N, y);
a = max(a, pos);
if (a > N) break;
v.clear();
get_intervals(1, 1, N, a, N);
for (int i : v) {
propa(i, S[i], E[i]);
if (T[i].sum > y) {
int r = fd2(i, S[i], E[i], y);
ans += r - S[i];
pos = r;
break;
} else {
ans += E[i] - S[i] + 1;
y -= T[i].sum;
pos = E[i] + 1;
}
}
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 7;
int n, q, e, ans;
long long a[N], f[N], g[N], tg[N];
inline void build(int l, int r, int t) {
tg[t] = -1;
if (l == r) {
f[t] += a[l], g[t] += a[l];
return;
}
int d = (l + r) >> 1;
build(l, d, t << 1), build(d + 1, r, t << 1 | 1);
f[t] = f[t << 1] + f[t << 1 | 1], g[t] = min(g[t << 1], g[t << 1 | 1]);
}
inline void cover(int ql, int qr, int t, int l, int r, int c) {
int d = (l + r) >> 1;
if (tg[t] != -1) {
tg[t << 1] = tg[t], tg[t << 1 | 1] = tg[t];
g[t << 1] = tg[t], g[t << 1 | 1] = tg[t];
f[t << 1] = (d - l + 1) * tg[t], f[t << 1 | 1] = (r - d) * tg[t],
tg[t] = -1;
}
if (l == ql && r == qr) {
tg[t] = c, f[t] = 1ll * (r - l + 1) * c, g[t] = c;
return;
}
if (ql <= d) cover(ql, min(d, qr), t << 1, l, d, c);
if (d + 1 <= qr) cover(max(d + 1, ql), qr, t << 1 | 1, d + 1, r, c);
g[t] = min(g[t << 1], g[t << 1 | 1]);
f[t] = f[t << 1] + f[t << 1 | 1];
}
inline int getans(int l, int r, int t, int x) {
int d = (l + r) >> 1;
if (tg[t] != -1) {
tg[t << 1] = tg[t], tg[t << 1 | 1] = tg[t];
g[t << 1] = tg[t], g[t << 1 | 1] = tg[t];
f[t << 1] = (d - l + 1) * tg[t], f[t << 1 | 1] = (r - d) * tg[t],
tg[t] = -1;
}
if (l == r) return g[t];
if (x <= d) return getans(l, d, t << 1, x);
if (d + 1 <= x) getans(d + 1, r, t << 1 | 1, x);
}
inline void getsum(int ql, int qr, int t, int l, int r) {
int d = (l + r) >> 1;
if (tg[t] != -1) {
tg[t << 1] = tg[t], tg[t << 1 | 1] = tg[t];
g[t << 1] = tg[t], g[t << 1 | 1] = tg[t];
f[t << 1] = (d - l + 1) * tg[t], f[t << 1 | 1] = (r - d) * tg[t],
tg[t] = -1;
}
if (ql == l && qr == r) {
if (f[t] <= e) {
e -= f[t], ans += (r - l + 1);
return;
}
if (l == r) return;
if (g[t << 1] <= e) getsum(l, d, t << 1, l, d);
if (g[t << 1 | 1] <= e) getsum(d + 1, r, t << 1 | 1, d + 1, r);
return;
}
if (ql <= d) getsum(ql, min(d, qr), t << 1, l, d);
if (d + 1 <= qr) getsum(max(d + 1, ql), qr, t << 1 | 1, d + 1, r);
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
build(1, n, 1);
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
int l = 1, r = x - 1, p = x;
if (getans(1, n, 1, x) >= y) continue;
while (l <= r) {
int d = (l + r) >> 1;
if (getans(1, n, 1, d) < y)
p = d, r = d - 1;
else
l = d + 1;
}
cover(p, x, 1, 1, n, y);
} else {
ans = 0, e = y;
getsum(x, n, 1, 1, n);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF(0x3f3f3f3f3f3f3f3fll);
const long long inf(0x3f3f3f3f);
template <typename T>
void read(T &res) {
bool flag = false;
char ch;
while (!isdigit(ch = getchar())) (ch == '-') && (flag = true);
for (res = ch - 48; isdigit(ch = getchar());
res = (res << 1) + (res << 3) + ch - 48)
;
flag && (res = -res);
}
template <typename T>
void Out(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) Out(x / 10);
putchar(x % 10 + '0');
}
const long long N = 3e5 + 10;
struct Tree {
long long l, r, lazy, sum, mi, ma;
} tree[N << 2];
void push_up(long long rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
tree[rt].ma = tree[rt << 1].ma;
tree[rt].mi = tree[rt << 1 | 1].mi;
}
void build(long long l, long long r, long long rt, long long *a) {
tree[rt].l = l, tree[rt].r = r, tree[rt].lazy = 0;
if (l == r) {
tree[rt].sum = tree[rt].mi = tree[rt].ma = a[l];
return;
}
long long mid = l + r >> 1;
build(l, mid, rt << 1, a);
build(mid + 1, r, rt << 1 | 1, a);
push_up(rt);
}
void push_down(long long rt) {
if (tree[rt].lazy) {
long long x = tree[rt].lazy, l = tree[rt].l, r = tree[rt].r;
tree[rt].lazy = 0;
tree[rt << 1].sum = (tree[rt << 1].r - tree[rt << 1].l + 1) * x;
tree[rt << 1].mi = tree[rt << 1].ma = x;
tree[rt << 1].lazy = x;
tree[rt << 1 | 1].sum = (tree[rt << 1 | 1].r - tree[rt << 1 | 1].l + 1) * x;
tree[rt << 1 | 1].mi = tree[rt << 1 | 1].ma = x;
tree[rt << 1 | 1].lazy = x;
}
}
void update_range(long long L, long long R, long long Y, long long rt) {
long long l = tree[rt].l, r = tree[rt].r;
if (tree[rt].mi >= Y || l > R) return;
if (tree[rt].ma <= Y && r <= R) {
tree[rt].sum = (r - l + 1) * Y;
tree[rt].mi = tree[rt].ma = Y;
tree[rt].lazy = Y;
return;
}
push_down(rt);
update_range(L, R, Y, rt << 1);
update_range(L, R, Y, rt << 1 | 1);
push_up(rt);
}
long long query_range(long long L, long long R, long long rt, long long &Y) {
long long l = tree[rt].l, r = tree[rt].r;
if (tree[rt].mi > Y || r < L) return 0;
if (tree[rt].sum <= Y && L <= l) {
Y -= tree[rt].sum;
return r - l + 1;
}
if (l == r) return 0;
push_down(rt);
long long res = 0;
res += query_range(L, R, rt << 1, Y);
res += query_range(L, R, rt << 1 | 1, Y);
return res;
}
long long n, q, a[N];
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1, a);
while (q--) {
long long op, x, y;
cin >> op >> x >> y;
if (op == 1)
update_range(1, x, y, 1);
else {
cout << query_range(x, n, 1, y) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
void ckmn(T& a, T b) {
a = min(a, b);
}
template <typename T>
void ckmx(T& a, T b) {
a = max(a, b);
}
void rd(int& x) { scanf("%i", &x); }
void rd(long long& x) { scanf("%lld", &x); }
void rd(char* x) { scanf("%s", x); }
void rd(double& x) { scanf("%lf", &x); }
void rd(string& x) { scanf("%s", &x); }
template <typename T1, typename T2>
void rd(pair<T1, T2>& x) {
rd(x.first);
rd(x.second);
}
template <typename T>
void rd(vector<T>& x) {
for (T& i : x) rd(i);
}
template <typename T, typename... A>
void rd(T& x, A&... args) {
rd(x);
rd(args...);
}
template <typename T>
void rd() {
T x;
rd(x);
return x;
}
int ri() {
int x;
rd(x);
return x;
}
template <typename T>
vector<T> rv(int n) {
vector<T> x(n);
rd(x);
return x;
}
template <typename T>
void ra(T a[], int n, int st = 1) {
for (int i = 0; i < n; ++i) rd(a[st + i]);
}
template <typename T1, typename T2>
void ra(T1 a[], T2 b[], int n, int st = 1) {
for (int i = 0; i < n; ++i) rd(a[st + i]), rd(b[st + i]);
}
template <typename T1, typename T2, typename T3>
void ra(T1 a[], T2 b[], T3 c[], int n, int st = 1) {
for (int i = 0; i < n; ++i) rd(a[st + i]), rd(b[st + i]), rd(c[st + i]);
}
void re(vector<int> E[], int m, bool dir = 0) {
for (int i = 0, u, v; i < m; ++i) {
rd(u, v);
E[u].push_back(v);
if (!dir) E[v].push_back(u);
}
}
template <typename T>
void re(vector<pair<int, T>> E[], int m, bool dir = 0) {
for (int i = 0, u, v; i < m; ++i) {
T w;
rd(u, v, w);
E[u].push_back({v, w});
if (!dir) E[v].push_back({u, w});
}
}
const int N = 200050;
const int M = 2 * N;
int ls[M], rs[M], tsz, root;
long long sum[M], mn[M], lzy[M];
void pull(int c) {
sum[c] = sum[ls[c]] + sum[rs[c]];
mn[c] = mn[rs[c]];
}
void Build(int& c, int ss, int se, int a[]) {
c = ++tsz;
lzy[c] = -1;
if (ss == se) {
sum[c] = mn[c] = a[ss];
return;
}
int mid = ss + se >> 1;
Build(ls[c], ss, mid, a);
Build(rs[c], mid + 1, se, a);
pull(c);
}
void upd(int c, int ss, int se, int x) {
lzy[c] = x;
sum[c] = (long long)x * (se - ss + 1);
mn[c] = x;
}
void push(int c, int ss, int se) {
int mid = ss + se >> 1;
if (lzy[c] != -1) {
upd(ls[c], ss, mid, lzy[c]);
upd(rs[c], mid + 1, se, lzy[c]);
lzy[c] = -1;
}
}
void Set(int c, int ss, int se, int qs, int qe, int x) {
if (qs > qe || qs > se || ss > qe) return;
if (qs <= ss && qe >= se) {
upd(c, ss, se, x);
return;
}
int mid = ss + se >> 1;
push(c, ss, se);
Set(ls[c], ss, mid, qs, qe, x);
Set(rs[c], mid + 1, se, qs, qe, x);
pull(c);
}
long long Sum(int c, int ss, int se, int qs, int qe) {
if (qs > qe || qs > se || ss > qe) return 0;
if (qs <= ss && qe >= se) return sum[c];
int mid = ss + se >> 1;
push(c, ss, se);
return Sum(ls[c], ss, mid, qs, qe) + Sum(rs[c], mid + 1, se, qs, qe);
}
int Walk(int c, int ss, int se, long long k) {
if (ss == se) return k >= sum[c] ? ss + 1 : ss;
push(c, ss, se);
int mid = ss + se >> 1;
if (sum[ls[c]] <= k)
return Walk(rs[c], mid + 1, se, k - sum[ls[c]]);
else
return Walk(ls[c], ss, mid, k);
}
int Srch(int c, int ss, int se, int k) {
if (ss == se) return k < mn[c] ? ss + 1 : ss;
push(c, ss, se);
int mid = ss + se >> 1;
if (mn[ls[c]] > k)
return Srch(rs[c], mid + 1, se, k);
else
return Srch(ls[c], ss, mid, k);
}
int a[N];
int main() {
int n, q;
rd(n, q);
ra(a, n);
Build(root, 1, n, a);
while (q--) {
int t, x, y;
rd(t, x, y);
if (t == 1) {
int L = Srch(root, 1, n, y);
int R = x;
Set(root, 1, n, L, R, y);
} else {
int ptr = x, ans = 0;
while (1) {
ptr = max(ptr, Srch(root, 1, n, y));
if (ptr > n) break;
int nxt = Walk(root, 1, n, y + Sum(root, 1, n, 1, ptr - 1));
ans += nxt - ptr;
y -= Sum(root, 1, n, ptr, nxt - 1);
ptr = nxt;
}
printf("%i\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[200010], bl[200010], fl[200010], fr[200010], tg[200010 / 233 + 5];
long long sc[200010 / 233 + 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 / 233, 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>
inline void read(char &x) {
do x = getchar();
while (x <= ' ');
}
inline void read(char *s) {
char ch;
do ch = getchar();
while (ch <= ' ');
while (ch > ' ') {
(*s) = ch;
s++;
ch = getchar();
}
(*s) = 0;
}
inline void read(std::string &s) {
char ch;
do ch = getchar();
while (ch <= ' ');
while (ch > ' ') {
s.push_back(ch);
ch = getchar();
}
}
template <class A>
inline void readint(A &x) {
bool neg = false;
char ch;
do ch = getchar();
while (ch <= ' ');
if (ch == '-') {
neg = true;
ch = getchar();
}
x = 0;
while (ch > ' ') {
x = x * 10 + (ch & 15);
ch = getchar();
}
if (neg) x = -x;
}
inline void read(int &x) { readint(x); }
inline void read(long long &x) { readint(x); }
template <class A, class B>
inline void read(A &a, B &b) {
read(a);
read(b);
}
template <class A, class B, class C>
inline void read(A &a, B &b, C &c) {
read(a);
read(b);
read(c);
}
template <class A, class B, class C, class D>
inline void read(A &a, B &b, C &c, D &d) {
read(a);
read(b);
read(c);
read(d);
}
inline void writeln() { putchar('\n'); }
template <class A>
inline void writeint(A x) {
static char buf[20];
int top = 0;
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
buf[++top] = (x % 10) | 48;
x /= 10;
}
while (top) putchar(buf[top--]);
}
inline void write(int x) { writeint(x); }
inline void write(unsigned x) { writeint(x); }
inline void write(long long x) { writeint(x); }
inline void write(unsigned long long x) { writeint(x); }
inline void write(char ch) { putchar(ch); }
inline void write(char *s) {
while (*s) {
putchar(*s);
s++;
}
}
inline void write(const char *s) { printf(s); }
template <class A>
inline void write_(A x) {
write(x);
putchar(' ');
}
template <class A>
inline void writeln(A x) {
write(x);
putchar('\n');
}
template <class A, class B>
inline void write(A a, B b) {
write_(a);
write(b);
}
template <class A, class B>
inline void writeln(A a, B b) {
write_(a);
writeln(b);
}
template <class A, class B, class C>
inline void writeln(A a, B b, C c) {
write_(a);
write_(b);
writeln(c);
}
template <class A, class B, class C, class D>
inline void writeln(A a, B b, C c, D d) {
write_(a);
write_(b);
write_(c);
writeln(d);
}
const int N = 2e5 + 10;
int n, q;
int a[N];
int maxv[N << 2], minv[N << 2], mark[N << 2];
long long sum[N << 2];
inline void updnode(int p, int l, int r, int x) {
maxv[p] = minv[p] = mark[p] = x;
sum[p] = (r - l + 1LL) * x;
}
inline void down(int p, int l, int r) {
if (mark[p]) {
updnode((p << 1), l, ((l + r) >> 1), mark[p]);
updnode((p << 1 | 1), ((l + r) >> 1) + 1, r, mark[p]);
mark[p] = 0;
}
}
inline void up(int p) {
maxv[p] = std::max(maxv[(p << 1)], maxv[(p << 1 | 1)]);
minv[p] = std::min(minv[(p << 1)], minv[(p << 1 | 1)]);
sum[p] = sum[(p << 1)] + sum[(p << 1 | 1)];
}
void build(int p, int l, int r) {
if (l ^ r) {
build((p << 1), l, ((l + r) >> 1));
build((p << 1 | 1), ((l + r) >> 1) + 1, r);
up(p);
} else
minv[p] = maxv[p] = sum[p] = a[l];
}
void update(int p, int l, int r, int b, int x) {
if (minv[p] >= x) return;
if (r <= b and maxv[p] <= x) {
updnode(p, l, r, x);
return;
}
down(p, l, r);
update((p << 1), l, ((l + r) >> 1), b, x);
if (b > ((l + r) >> 1)) update((p << 1 | 1), ((l + r) >> 1) + 1, r, b, x);
up(p);
}
void query(int p, int l, int r, int a, int &x, int &cnt) {
if (minv[p] > x) return;
if (a <= l and x >= sum[p]) {
x -= sum[p];
cnt += r - l + 1;
return;
}
down(p, l, r);
if (a <= ((l + r) >> 1)) query((p << 1), l, ((l + r) >> 1), a, x, cnt);
query((p << 1 | 1), ((l + r) >> 1) + 1, r, a, x, cnt);
}
int main() {
int i;
int opt, x, y, ans;
read(n, q);
for (i = int(1); i <= int(n); i++) read(a[i]);
build(1, 1, n);
for (i = int(1); i <= int(q); i++) {
read(opt, x, y);
if (opt == 1)
update(1, 1, n, x, y);
else {
ans = 0;
query(1, 1, n, x, y, ans);
writeln(ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
struct SegTree {
vector<long long> maxv, sum, lazy;
int base, idx;
SegTree(int a, long long arr[]) {
base = 1;
while (base < a) base <<= 1;
maxv.resize(base * 2);
sum.resize(base * 2);
lazy.resize(base * 2);
base--;
for (int i = 1; i <= a; i++) maxv[base + i] = sum[base + i] = arr[i];
for (int i = base; i >= 1; i--) {
maxv[i] = max(maxv[i * 2], maxv[i * 2 + 1]);
sum[i] = sum[i * 2] + sum[i * 2 + 1];
}
}
void propagate(int ns, int nf, int num) {
if (lazy[num]) {
if (ns < nf) {
lazy[num * 2] = max(lazy[num * 2], lazy[num]);
lazy[num * 2 + 1] = max(lazy[num * 2 + 1], lazy[num]);
}
maxv[num] = max(maxv[num], lazy[num]);
sum[num] = maxv[num] * (nf - ns + 1);
lazy[num] = 0;
}
}
void update(long long v, int st, int fn, int ns = 1, int nf = -1,
int num = 1) {
if (nf == -1) nf = base + 1;
propagate(ns, nf, num);
if (fn < ns || nf < st) return;
if (st <= ns && nf <= fn) {
lazy[num] = v;
propagate(ns, nf, num);
return;
}
int mid = (ns + nf) >> 1;
update(v, st, fn, ns, mid, num * 2);
update(v, st, fn, mid + 1, nf, num * 2 + 1);
maxv[num] = max(maxv[num * 2], maxv[num * 2 + 1]);
sum[num] = sum[num * 2] + sum[num * 2 + 1];
}
int get_st(long long v, int ns = 1, int nf = -1, int num = 1) {
if (nf == -1) nf = base + 1;
propagate(ns, nf, num);
if (v >= maxv[1]) return 0;
if (ns == nf) return ns;
int mid = (ns + nf) >> 1;
if (v < maxv[num * 2 + 1]) return get_st(v, mid + 1, nf, num * 2 + 1);
return get_st(v, ns, mid, num * 2);
}
long long get_fn(long long v, int ns = 1, int nf = -1, int num = 1) {
if (nf == -1) nf = base + 1;
propagate(ns, nf, num);
if (ns == nf) {
idx = ns;
if (sum[num] > v) idx--;
return v;
}
int mid = (ns + nf) >> 1;
propagate(ns, mid, num * 2);
propagate(mid + 1, nf, num * 2 + 1);
if (sum[num * 2] <= v && sum[num * 2 + 1])
return get_fn(v - sum[num * 2], mid + 1, nf, num * 2 + 1);
return get_fn(v, ns, mid, num * 2);
}
long long get_sum(int fn, int ns = 1, int nf = -1, int num = 1) {
if (nf == -1) nf = base + 1;
propagate(ns, nf, num);
if (fn < ns) return 0;
if (nf <= fn) return sum[num];
int mid = (ns + nf) >> 1;
return get_sum(fn, ns, mid, num * 2) +
get_sum(fn, mid + 1, nf, num * 2 + 1);
}
};
int n, q;
long long m[200005];
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &m[i]);
SegTree st(n, m);
for (int i = 1; i <= q; i++) {
int t, x, y, s;
scanf("%d %d %d", &t, &x, &y);
if (t == 1) {
s = st.get_st(y) + 1;
if (s <= x) st.update(y, s, x);
} else {
long long v = y;
int cnt = 0;
s = max(x - 1, st.get_st(v));
while (s < n) {
if (s > 0) v += st.get_sum(s);
v = st.get_fn(v);
cnt += st.idx - s;
s = max(st.idx, st.get_st(v));
}
printf("%d\n", cnt);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename... T>
void rd(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void wr(T... args) {
((cout << args << " "), ...);
cout << endl;
}
struct SegTree {
int n;
vector<ll> sum;
vector<int> lazy, mn;
SegTree(int n_) : n(n_), sum(4 * n), lazy(4 * n), mn(4 * n) {}
SegTree(const vector<int>& v) : SegTree((int)v.size()) {
function<void(int, int, int)> build = [&](int node, int l, int r) {
if (l == r) {
sum[node] = mn[node] = v[l];
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
pushup(node);
};
build(1, 0, n - 1);
}
void pushup(int node) {
sum[node] = sum[node << 1] + sum[node << 1 | 1];
mn[node] = min(mn[node << 1], mn[node << 1 | 1]);
}
void addtag(int p, int x, int l, int r) {
sum[p] = ll(r - l + 1) * x;
mn[p] = x;
lazy[p] = x;
}
void spread(int p, int l, int r) {
if (lazy[p]) {
addtag(p << 1, lazy[p], l, (l + r) >> 1);
addtag(p << 1 | 1, lazy[p], (l + r) / 2 + 1, r);
lazy[p] = 0;
}
}
void update(int node, int ql, int qr, int l, int r, int x) {
if (ql <= l && qr >= r) return addtag(node, x, l, r);
spread(node, l, r);
int mid = (l + r) >> 1;
if (ql <= mid) update(node << 1, ql, qr, l, mid, x);
if (qr > mid) update(node << 1 | 1, ql, qr, mid + 1, r, x);
pushup(node);
}
int bound(int p, int l, int r, int x) {
if (l == r) return mn[p] >= x ? l + 1 : l;
int m = (l + r) / 2;
spread(p, l, r);
if (mn[2 * p] >= x) return bound(2 * p + 1, m + 1, r, x);
return bound(2 * p, l, m, x);
}
void modify(int x, int y) {
int l = bound(1, 0, n - 1, y);
if (l > x) return;
update(1, l, x, 0, n - 1, y);
}
int query(int p, int l, int r, int x, ll& y) {
if (r < x) return 0;
if (mn[p] > y) return 0;
if (l >= x && y >= sum[p]) {
y -= sum[p];
return r - l + 1;
}
int m = (l + r) / 2;
spread(p, l, r);
int res = query(2 * p, l, m, x, y) + query(2 * p + 1, m + 1, r, x, y);
return res;
}
int query(int x, ll y) { return query(1, 0, n - 1, x, y); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (auto& i : a) cin >> i;
SegTree tr(a);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1)
tr.modify(x - 1, y);
else
cout << tr.query(x - 1, y) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
stringstream ssin;
const long long LINF = 0x7fffffffffffffffll;
const long long N = 2e5 + 5, M = 4e5 + 5, mod = 1e9 + 7, INF = 0x3f3f3f3f;
long long n, q;
long long a[N];
struct node {
long long l, r;
long long maxx, minn, lazy, sum;
} tr[N << 2];
inline long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
void pushup(int u) {
tr[u].maxx = max(tr[u << 1].maxx, tr[u << 1 | 1].maxx);
tr[u].minn = min(tr[u << 1].minn, tr[u << 1 | 1].minn);
tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}
void change(int u, long long num) {
tr[u].sum = (tr[u].r - tr[u].l + 1) * num;
tr[u].minn = tr[u].maxx = num;
tr[u].lazy = num;
}
void pushdown(int u) {
change(u << 1, tr[u].lazy);
change(u << 1 | 1, tr[u].lazy);
tr[u].lazy = 0;
}
void build(int u, int l, int r) {
tr[u].l = l;
tr[u].r = r;
tr[u].lazy = 0;
if (l == r) {
tr[u].minn = a[l];
tr[u].maxx = a[l];
tr[u].sum = a[l];
return;
}
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void upd(int u, int l, int r, long long val) {
if (tr[u].minn > val) {
return;
}
if (l <= tr[u].l && tr[u].r <= r) {
if (tr[u].maxx <= val) {
change(u, val);
return;
}
}
if (tr[u].lazy) pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
if (mid >= l) upd(u << 1, l, r, val);
if (mid + 1 <= r) upd(u << 1 | 1, l, r, val);
pushup(u);
}
int qry(int u, int l, int r, long long &val) {
if (tr[u].minn > val) return 0;
if (tr[u].l >= l && tr[u].r <= r) {
if (tr[u].sum <= val) {
val -= tr[u].sum;
return tr[u].r - tr[u].l + 1;
}
}
if (tr[u].lazy) pushdown(u);
int mid = tr[u].l + tr[u].r >> 1;
int ans1 = 0, ans2 = 0;
if (mid >= l) ans1 = qry(u << 1, l, r, val);
if (mid + 1 <= r) ans2 = qry(u << 1 | 1, l, r, val);
return ans1 + ans2;
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
build(1, 1, n);
while (q--) {
long long op, x, y;
op = read();
x = read();
y = read();
if (op == 1) {
upd(1, 1, x, y);
} else if (op == 2) {
cout << qry(1, x, n, y) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 2e5 + 51;
struct SegmentTree {
long long int l, r, mn, sum, tag;
};
SegmentTree tree[MAXN << 2];
long long int n, m, op, u, v;
long long int x[MAXN];
inline long long int read() {
register long long int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline void update(long long int node) {
tree[node].mn = min(tree[node << 1].mn, tree[(node << 1) | 1].mn);
tree[node].sum = tree[node << 1].sum + tree[(node << 1) | 1].sum;
}
inline void create(long long int l, long long int r, long long int node) {
tree[node] = (SegmentTree){l, r, 0, 0, 0};
if (l == r) {
return (void)(tree[node].sum = tree[node].mn = x[l]);
}
long long int mid = (l + r) >> 1;
create(l, mid, node << 1), create(mid + 1, r, (node << 1) | 1), update(node);
}
inline void spread(long long int node) {
if (tree[node].tag) {
long long int lenl = tree[node << 1].r - tree[node << 1].l + 1,
lenr = tree[(node << 1) | 1].r - tree[(node << 1) | 1].l + 1;
long long int tag = tree[node].tag;
tree[node << 1].mn = tag, tree[(node << 1) | 1].mn = tag,
tree[node << 1].tag = tag, tree[(node << 1) | 1].tag = tag;
tree[node << 1].sum = tag * lenl, tree[(node << 1) | 1].sum = tag * lenr,
tree[node].tag = 0;
}
}
inline void cover(long long int l, long long int r, long long int val,
long long int node) {
if (l <= tree[node].l && r >= tree[node].r) {
tree[node].sum = val * (tree[node].r - tree[node].l + 1);
return (void)(tree[node].tag = tree[node].mn = val);
}
long long int mid = (tree[node].l + tree[node].r) >> 1;
spread(node);
l <= mid ? cover(l, r, val, node << 1) : (void)1,
r > mid ? cover(l, r, val, (node << 1) | 1) : (void)1;
update(node);
}
inline long long int query(long long int l, long long int r,
long long int node) {
if (l <= tree[node].l && r >= tree[node].r) {
return tree[node].sum;
}
long long int mid = (tree[node].l + tree[node].r) >> 1;
spread(node);
return (l <= mid ? query(l, r, node << 1) : 0) +
(r > mid ? query(l, r, (node << 1) | 1) : 0);
}
inline long long int lb(long long int val, long long int node) {
if (tree[node].l == tree[node].r) {
return tree[node].l;
}
long long int mid = (tree[node].l + tree[node].r) >> 1;
spread(node);
return lb(val, tree[node << 1].mn > val ? (node << 1) | 1 : node << 1);
}
inline long long int query(long long int &val, long long int node) {
if (tree[node].sum <= val) {
return val -= tree[node].sum, tree[node].r - tree[node].l + 1;
}
if (tree[node].l == tree[node].r) {
return 0;
}
spread(node);
long long int lenl = tree[node].r - tree[node].l + 1, res = 0;
tree[node << 1].mn <= val ? res += query(val, node << 1) : 1;
tree[(node << 1) | 1].mn <= val ? res += query(val, (node << 1) | 1) : 1;
return res;
}
inline void disp(long long int node) {
if (tree[node].l == tree[node].r) {
return (void)(printf("%d ", tree[node].sum));
}
spread(node), disp(node << 1), disp((node << 1) | 1);
}
int main() {
n = read(), m = read();
for (register int i = 1; i <= n; i++) {
x[i] = read();
}
create(1, n, 1);
for (register int i = 0; i < m; i++) {
op = read(), u = read(), v = read();
if (op == 1) {
cover(lb(v, 1), u, v, 1);
}
if (op == 2) {
v += u > 1 ? query(1, u - 1, 1) : 0, printf("%d\n", query(v, 1) - u + 1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long oo = 1e18 + 7, mod = 1e9 + 7;
struct it {
long long mini, sum, lazy;
};
long long n, q;
long long a[N];
it IT[N << 2];
it merge(it a, it b) {
it c;
c.mini = min(a.mini, b.mini);
c.sum = a.sum + b.sum;
c.lazy = 0;
return c;
}
void build(long long id, long long l, long long r) {
IT[id].lazy = 0;
if (l == r) {
IT[id].mini = IT[id].sum = a[l];
return;
}
long long mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
IT[id] = merge(IT[id << 1], IT[id << 1 | 1]);
}
void laz(long long id, long long l, long long r) {
if (!IT[id].lazy) return;
IT[id << 1].lazy = IT[id].lazy;
IT[id << 1 | 1].lazy = IT[id].lazy;
long long mid = (l + r) >> 1;
IT[id << 1].mini = IT[id << 1 | 1].mini = IT[id].lazy;
IT[id << 1].sum = IT[id << 1].mini * (mid - l + 1);
IT[id << 1 | 1].sum = IT[id << 1 | 1].mini * (r - mid);
IT[id].lazy = 0;
}
void upd(long long id, long long l, long long r, long long L, long long R,
long long x) {
if (l > R || r < L) return;
if (l >= L && r <= R) {
IT[id].mini = IT[id].lazy = x;
IT[id].sum = (r - l + 1) * x;
return;
}
laz(id, l, r);
long long mid = (l + r) >> 1;
upd(id << 1, l, mid, L, R, x);
upd(id << 1 | 1, mid + 1, r, L, R, x);
IT[id] = merge(IT[id << 1], IT[id << 1 | 1]);
}
long long fipos(long long id, long long l, long long r, long long x) {
if (l == r) {
if (IT[id].mini <= x)
return l;
else
return oo;
}
laz(id, l, r);
long long mid = (l + r) >> 1;
if (IT[id << 1].mini > x)
return fipos(id << 1 | 1, mid + 1, r, x);
else
return fipos(id << 1, l, mid, x);
}
long long sum(long long id, long long l, long long r, long long L,
long long R) {
if (l > R || r < L || l > r) return 0;
if (l >= L && r <= R) return IT[id].sum;
laz(id, l, r);
long long mid = (l + r) >> 1;
return sum(id << 1, l, mid, L, R) + sum(id << 1 | 1, mid + 1, r, L, R);
}
long long fipos2(long long id, long long l, long long r, long long acc) {
if (l == r) {
if (IT[id].mini <= acc)
return oo;
else
return l;
}
laz(id, l, r);
long long mid = (l + r) >> 1;
if (IT[id << 1].sum > acc)
return fipos2(id << 1, l, mid, acc);
else
return fipos2(id << 1 | 1, mid + 1, r, acc - IT[id << 1].sum);
}
void process() {
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
for (long long i = 1; i <= q; i++) {
long long type, x, y;
cin >> type >> x >> y;
if (type == 1) {
long long temp = fipos(1, 1, n, y);
if (temp <= x) upd(1, 1, n, temp, x, y);
} else {
long long ans = 0, itr = x;
while (1) {
itr = max(itr, fipos(1, 1, n, y));
if (itr > n) break;
long long itr2 = fipos2(1, 1, n, y + sum(1, 1, n, 1, itr - 1));
if (itr2 > n) {
ans += (n - itr + 1);
break;
}
ans += itr2 - itr;
y -= sum(1, 1, n, itr, itr2 - 1);
}
cout << ans << "\n";
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
process();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename G1, typename G2 = G1, typename G3 = G1>
struct triple {
G1 first;
G2 second;
G3 T;
};
struct segment_tree {
struct node {
long long sum, mn, mx;
};
node merge(node &a, node &b) { return {a.sum + b.sum, b.mn, a.mx}; }
vector<node> st;
vector<int> lazy;
segment_tree(int n, vector<int> &v) : st(2 * n), lazy(2 * n) {
build(0, n, v);
}
inline int id(int b, int e) { return (b + e - 1) | (b != e - 1); }
void build(int l, int r, vector<int> &v) {
int cur = id(l, r);
if (r == l + 1) {
st[cur] = {v[l], v[l], v[l]};
return;
}
int mid = (l + r + 1) >> 1;
build(l, mid, v);
build(mid, r, v);
st[cur] = merge(st[id(l, mid)], st[id(mid, r)]);
}
void prop(int l, int r) {
int cur = id(l, r);
st[cur].sum = (long long)lazy[cur] * (r - l);
st[cur].mn = st[cur].mx = lazy[cur];
if (l != r - 1) {
int mid = (l + r + 1) >> 1;
lazy[id(l, mid)] = lazy[cur];
lazy[id(mid, r)] = lazy[cur];
}
lazy[cur] = 0;
}
void upd(int l, int r, int p, int v) {
int cur = id(l, r);
if (lazy[cur]) prop(l, r);
if (st[cur].mn >= v || p < l) return;
if (r <= p + 1 && st[cur].mx < v) {
lazy[cur] = v;
prop(l, r);
return;
}
int mid = (l + r + 1) >> 1;
upd(l, mid, p, v);
upd(mid, r, p, v);
st[cur] = merge(st[id(l, mid)], st[id(mid, r)]);
}
pair<long long, long long> query(int l, int r, int p, int v) {
int cur = id(l, r);
if (lazy[cur]) prop(l, r);
if (st[cur].mn > v || p >= r) return {0, v};
if (p <= l && st[cur].sum <= v) return {r - l, v - st[cur].sum};
if (r == l + 1) return {0, v};
int x = 0;
int mid = (l + r + 1) >> 1;
pair<long long, long long> temp = query(l, mid, p, v);
x += temp.first;
v = temp.second;
temp = query(mid, r, p, v);
x += temp.first, v = temp.second;
return {x, v};
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> v(n);
for (auto &i : v) cin >> i;
segment_tree st(n, v);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
--x;
st.upd(0, n, x, y);
} else {
--x;
pair<long long, long long> ans = st.query(0, n, x, y);
cout << ans.first << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 2e5 + 5;
int n, q;
int a[maxn];
const ll INV = -1;
struct Node {
int s, e, m;
ll sum;
ll mini;
ll lazy;
Node *l, *r;
Node(int a, int b) {
s = a;
e = b;
sum = 0;
mini = 0;
lazy = INV;
if (s != e) {
m = (s + e) / 2;
l = new Node(s, m);
r = new Node(m + 1, e);
} else {
l = NULL;
r = NULL;
}
}
void push() {
if (lazy == INV) return;
if (s != e) {
l->lazy = lazy;
l->sum = (l->e - l->s + 1) * lazy;
l->mini = lazy;
r->lazy = lazy;
r->sum = (r->e - r->s + 1) * lazy;
r->mini = lazy;
}
lazy = INV;
}
void pull() {
sum = l->sum + r->sum;
mini = min(l->mini, r->mini);
}
void add(int st, int en, ll x) {
if (st <= s && e <= en) {
lazy = x;
mini = x;
sum = (e - s + 1) * x;
return;
}
push();
if (st <= m) {
l->add(st, en, x);
}
if (en > m) {
r->add(st, en, x);
}
pull();
}
ll getsum(int st, int en) {
push();
if (st <= s && e <= en) {
return sum;
}
ll ret = 0;
if (st <= m) {
ret += l->getsum(st, en);
}
if (en > m) {
ret += r->getsum(st, en);
}
return ret;
}
int getMinIdx(ll y) {
push();
if (s == e) {
return mini <= y ? s : n + 1;
}
if (l->mini <= y) {
return l->getMinIdx(y);
} else {
return r->getMinIdx(y);
}
}
int walk(ll z) {
push();
if (s == e) return sum <= z ? s : s - 1;
if (l->sum + r->mini > z) {
return l->walk(z);
} else {
return r->walk(z - (l->sum));
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
Node *root = new Node(1, n);
for (int i = 1; i <= n; i++) {
cin >> a[i];
root->add(i, i, a[i]);
}
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
int i = root->getMinIdx(y);
if (i <= x) root->add(i, x, y);
} else {
int ans = 0;
while (x <= n) {
ll sum = x == 1 ? 0 : root->getsum(1, x - 1);
int i = root->walk(sum + y);
ans += i - x + 1;
y -= root->getsum(x, i);
x = max(i + 1, root->getMinIdx(y));
}
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 2 * 100005;
struct node {
long long mn, sum;
bool lazyset;
long long lazyval;
void assign(long long val) {
mn = val;
sum = val;
}
void merge(node& a, node& b) {
mn = min(a.mn, b.mn);
sum = a.sum + b.sum;
}
};
struct segtree {
node t[4 * N];
void pushdown(long long v, long long tl, long long tr) {
long long tm = (tl + tr) / 2;
if (t[v].lazyset) {
apply(v * 2, tl, tm, t[v].lazyval);
apply(v * 2 + 1, tm + 1, tr, t[v].lazyval);
t[v].lazyset = 0;
}
}
void apply(long long v, long long tl, long long tr, long long val) {
t[v].mn = val;
t[v].sum = val * (tr - tl + 1);
t[v].lazyset = 1;
t[v].lazyval = val;
}
void build(long long a[], long long v, long long tl, long long tr) {
if (tl == tr) {
t[v].assign(a[tl]);
} else {
long long tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
t[v].lazyset = 0;
}
long long query(long long v, long long tl, long long tr, long long l,
long long r) {
if (tl > r || tr < l) return 0;
if (l <= tl && tr <= r) {
return t[v].sum;
}
pushdown(v, tl, tr);
long long tm = (tl + tr) / 2;
return query(v * 2, tl, tm, l, r) + query(v * 2 + 1, tm + 1, tr, l, r);
}
long long sumdescent(long long v, long long tl, long long tr, long long val) {
if (tl == tr) return t[v].sum > val ? tl : N;
pushdown(v, tl, tr);
long long tm = (tl + tr) / 2;
if (t[v * 2].sum > val) return sumdescent(v * 2, tl, tm, val);
return sumdescent(v * 2 + 1, tm + 1, tr, val - t[v * 2].sum);
}
long long descent(long long v, long long tl, long long tr, long long val) {
if (t[v].mn >= val) return tr + 1;
if (tl == tr) return tl;
pushdown(v, tl, tr);
long long tm = (tl + tr) / 2;
if (t[v * 2].mn < val) return descent(v * 2, tl, tm, val);
return descent(v * 2 + 1, tm + 1, tr, val);
}
void rupd(long long v, long long tl, long long tr, long long l, long long r,
long long val) {
if (tl > r || tr < l) return;
if (l <= tl && tr <= r) {
apply(v, tl, tr, val);
return;
}
pushdown(v, tl, tr);
long long tm = (tl + tr) / 2;
rupd(v * 2, tl, tm, l, r, val);
rupd(v * 2 + 1, tm + 1, tr, l, r, val);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
} st;
void solve() {
long long n, q;
cin >> n >> q;
long long a[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
st.build(a, 1, 0, n - 1);
for (long long i = 0; i < q; ++i) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) {
long long l = st.descent(1, 0, n - 1, y);
long long r = x - 1;
if (l <= r) st.rupd(1, 0, n - 1, l, r, y);
} else {
long long cur = y;
long long idx = x - 1;
long long ans = 0;
while (idx < n) {
long long nxtidx = st.descent(1, 0, n - 1, cur + 1);
amax(idx, nxtidx);
long long sumidx =
st.sumdescent(1, 0, n - 1,
cur + st.query(1, 0, n - 1, 0, idx - 1)) -
1;
amin(sumidx, n - 1);
ans += sumidx - idx + 1;
cur -= st.query(1, 0, n - 1, idx, sumidx);
idx = sumidx + 1;
}
cout << ans << "\n";
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
int n, m, i, j, a[200005];
long long sum[800005];
int tag[800005], len[800005], mx[800005], mi[800005];
void pushup(int x) {
sum[x] = sum[x + x] + sum[x + x + 1];
mx[x] = max(mx[x + x], mx[x + x + 1]);
mi[x] = min(mi[x + x], mi[x + x + 1]);
}
void upd(int x, int y) {
tag[x] = mx[x] = mi[x] = y;
sum[x] = 1ll * len[x] * y;
}
void pushdo(int x) {
if (tag[x]) {
upd(x + x, tag[x]);
upd(x + x + 1, tag[x]);
tag[x] = 0;
}
}
void build(int x, int l, int r) {
len[x] = r - l + 1;
if (l == r) {
sum[x] = mx[x] = mi[x] = a[l];
tag[x] = a[l];
return;
}
int mid = (l + r) / 2;
build(x + x, l, mid);
build(x + x + 1, mid + 1, r);
pushup(x);
}
void update(int x, int l, int r, int ql, int qr, int c) {
if (mi[x] >= c) return;
if (ql <= l && r <= qr && mx[x] <= c) {
upd(x, c);
return;
}
int mid = (l + r) / 2;
pushdo(x);
if (ql <= mid) update(x + x, l, mid, ql, qr, c);
if (qr > mid) update(x + x + 1, mid + 1, r, ql, qr, c);
pushup(x);
}
int query(int x, int l, int r, int qr, int &y) {
if (l >= qr && sum[x] <= y) {
y -= sum[x];
return r;
}
if (l == r) {
return l - 1;
}
int mid = (l + r) / 2;
pushdo(x);
if (qr <= mid) {
int t = query(x + x, l, mid, qr, y);
if (t < mid) return t;
}
return query(x + x + 1, mid + 1, r, qr, y);
}
int query2(int x, int l, int r, int y) {
if (mi[x] > y) return r + 1;
if (l == r) {
return l;
}
int mid = (l + r) / 2;
pushdo(x);
int t = query2(x + x, l, mid, y);
if (t == mid + 1) t = query2(x + x + 1, mid + 1, r, y);
return t;
}
int main() {
read(n);
read(m);
for (((i)) = (1); ((i)) <= ((n)); ((i))++) read(a[i]);
build(1, 1, n);
while (m--) {
int op, x, y;
read(op);
read(x);
read(y);
if (op == 1)
update(1, 1, n, 1, x, y);
else {
int t = x, ans = 0;
int ttt = query(1, 1, n, t, y);
ans += (ttt - t + 1);
t = ttt + 1;
while (t <= n) {
int tt = query2(1, 1, n, y);
if (tt > n) break;
int ttt = query(1, 1, n, tt, y);
ans += (ttt - tt + 1);
t = ttt + 1;
}
printf("%d\n", ans);
}
}
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;
ll taken = 0;
struct Node {
static constexpr ll unit = 0LL, unit2 = 1e18;
ll f(ll a, ll b) { return a + b; }
ll f2(ll a, ll b) { return min(a, b); }
Node *l = 0, *r = 0;
int lo, hi, mset = unit;
ll val = unit, mn = unit2;
Node(int _lo, int _hi) : lo(_lo), hi(_hi) {}
Node(vector<ll> &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 = f(l->val, r->val);
mn = f2(l->mn, r->mn);
} else
val = mn = v[lo];
}
ll query(int L, int R) {
if (R <= lo || hi <= L) return unit;
if (L <= lo && hi <= R) return val;
push();
return f(l->query(L, R), r->query(L, R));
}
int query_first(int R, int X) {
if (lo + 1 == hi) return val < X ? lo : -1;
push();
int mid = lo + (hi - lo) / 2;
if (R <= mid) return l->query_first(R, X);
if (l->mn >= X) return r->query_first(R, X);
return l->query_first(R, X);
}
int query2(int L, int X, ll pref) {
if (lo + 1 == hi) {
if (val <= X) taken += val;
return val <= X;
}
push();
int mid = lo + (hi - lo) / 2;
if (L >= mid) return r->query2(L, X, pref - l->val);
if (l->val - pref <= X) {
taken += l->val - pref;
return mid - L + r->query2(mid, X + pref - l->val, 0);
}
return l->query2(L, X, pref);
}
void set(int L, int R, ll x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
mset = mn = x;
val = 1LL * (hi - lo) * x;
} else {
push(), l->set(L, R, x), r->set(L, R, x);
val = f(l->val, r->val);
mn = f2(l->mn, r->mn);
}
}
void push() {
if (!l) {
int mid = lo + (hi - lo) / 2;
l = new Node(lo, mid);
r = new Node(mid, hi);
}
if (mset != unit) l->set(lo, hi, mset), r->set(lo, hi, mset), mset = unit;
}
};
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;
vector<ll> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
Node *tr = new Node(v, 0, n);
vector<array<ll, 2>> intervals;
for (int i = 0; i < n;) {
int j = i;
while (j < n && v[i] == v[j]) ++j;
intervals.push_back({i, v[i]});
i = j;
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x, y;
cin >> x >> y;
--x;
int left = tr->query_first(x + 1, y);
if (left != -1) tr->set(left, x + 1, y);
} else {
int x, y;
cin >> x >> y;
--x;
int ans = 0, rt = x;
do {
taken = 0;
int len = tr->query2(x, y, tr->query(0, x));
ans += len;
rt = x + len;
y -= taken;
x = tr->query_first(n, y + 1);
} while (x >= rt && y > 0);
cout << ans << '\n';
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.