Add a bunch of other problems
This commit is contained in:
@@ -80,5 +80,102 @@ int main()
|
||||
ios::sync_with_stdio(false);
|
||||
cin.tie(nullptr);
|
||||
|
||||
int n, m;
|
||||
cin >> n >> m;
|
||||
|
||||
if (n > 1) {
|
||||
n = 1 << (32 - __builtin_clz(n - 1));
|
||||
}
|
||||
|
||||
vl seg(n * 2);
|
||||
vl lazyconst(n * 2);
|
||||
vl lazyprog(n * 2);
|
||||
|
||||
auto propagateconst = [&](int i) {
|
||||
if (lazyconst[i] == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (i >= n) {
|
||||
seg[i] += lazyconst[i];
|
||||
lazyconst[i] = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
lazyconst[i * 2] += lazyconst[i];
|
||||
lazyconst[i * 2 + 1] += lazyconst[i];
|
||||
lazyconst[i] = 0;
|
||||
};
|
||||
|
||||
auto propagateprog = [&](int i) {
|
||||
if (lazyprog[i] == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (i >= n) {
|
||||
seg[i] += lazyprog[i] * (i - n + 1);
|
||||
lazyprog[i] = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
lazyprog[i * 2] += lazyprog[i];
|
||||
lazyprog[i * 2 + 1] += lazyprog[i];
|
||||
lazyprog[i] = 0;
|
||||
};
|
||||
|
||||
auto propagate = [&](int i) {
|
||||
propagateconst(i);
|
||||
propagateprog(i);
|
||||
};
|
||||
|
||||
function<void(int, int, int, int, int, ll, ll)> update = [&](int i, int l, int r, int tl, int tr, ll c, ll p) {
|
||||
propagate(i);
|
||||
if (l > tr || r < tl) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
lazyconst[i] += c;
|
||||
lazyprog[i] += p;
|
||||
propagate(i);
|
||||
return;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
update(i * 2, l, mid, tl, tr, c, p);
|
||||
update(i * 2 + 1, mid + 1, r, tl, tr, c, p);
|
||||
};
|
||||
|
||||
function<ll(int, int, int, int)> query = [&](int i, int l, int r, int t) {
|
||||
propagate(i);
|
||||
|
||||
if (i >= n) {
|
||||
return seg[i];
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
if (mid >= t) {
|
||||
return query(i * 2, l, mid, t);
|
||||
}
|
||||
|
||||
return query(i * 2 + 1, mid + 1, r, t);
|
||||
};
|
||||
|
||||
while (m--) {
|
||||
int op;
|
||||
cin >> op;
|
||||
|
||||
if (op == 1) {
|
||||
ll l, r, a, d;
|
||||
cin >> l >> r >> a >> d;
|
||||
update(1, 0, n - 1, l - 1, r - 1, a - d * l, d);
|
||||
continue;
|
||||
}
|
||||
|
||||
int i;
|
||||
cin >> i;
|
||||
cout << query(1, 0, n - 1, i - 1) << '\n';
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
/* Problem URL: https://codeforces.com/edu/course/2/lesson/5/4/practice/contest/280801/problem/C */
|
||||
|
||||
#include <bits/stdc++.h>
|
||||
#include <ext/pb_ds/assoc_container.hpp>
|
||||
#include <ext/pb_ds/tree_policy.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace __gnu_pbds;
|
||||
|
||||
template <class T, class comp = less<>>
|
||||
using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
|
||||
|
||||
#define V vector
|
||||
|
||||
#define rmin(a, b) a = min(a, b)
|
||||
#define rmax(a, b) a = max(a, b)
|
||||
|
||||
#define rep(i, lim) for (int i = 0; i < (lim); i++)
|
||||
#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
|
||||
|
||||
#define repv(i, v) for (auto &i : (v))
|
||||
#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
|
||||
#define sortv(v) sort(v.begin(), v.end())
|
||||
#define all(v) (v).begin(), (v).end()
|
||||
|
||||
using vi = vector<int>;
|
||||
using vvi = vector<vi>;
|
||||
using vvvi = vector<vvi>;
|
||||
using vvvvi = vector<vvvi>;
|
||||
|
||||
using ll = long long;
|
||||
|
||||
using vl = vector<ll>;
|
||||
using vvl = vector<vl>;
|
||||
using vvvl = vector<vvl>;
|
||||
using vvvvl = vector<vvvl>;
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
|
||||
os << vec[0];
|
||||
for (size_t i = 1; i < vec.size(); i++) {
|
||||
os << ' ' << vec[i];
|
||||
}
|
||||
os << '\n';
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<v> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
is >> i;
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
|
||||
for (auto &i : vec) {
|
||||
os << i[0];
|
||||
for (size_t j = 1; j < i.size(); j++) {
|
||||
os << ' ' << i[j];
|
||||
}
|
||||
os << '\n';
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<vector<v>> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
for (auto &j : i) {
|
||||
is >> j;
|
||||
}
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
cin.tie(nullptr);
|
||||
|
||||
int n;
|
||||
cin >> n;
|
||||
|
||||
int middle = 500000;
|
||||
|
||||
int size = 1 << (32 - __builtin_clz(1e6 + middle + 1));
|
||||
|
||||
struct node {
|
||||
int sum;
|
||||
int seg;
|
||||
bool suf;
|
||||
bool pref;
|
||||
bool total;
|
||||
|
||||
node() = default;
|
||||
};
|
||||
|
||||
V<node> seg(size * 2);
|
||||
V<bool> upd(size * 2);
|
||||
vi lazy(size * 2);
|
||||
|
||||
auto merge = [&](node &a, node &b) -> node {
|
||||
node ans;
|
||||
ans.sum = a.sum + b.sum;
|
||||
|
||||
if (a.total && b.total) {
|
||||
ans.total = true;
|
||||
ans.pref = true;
|
||||
ans.suf = true;
|
||||
ans.seg = 1;
|
||||
|
||||
return ans;
|
||||
}
|
||||
|
||||
ans.seg = a.seg + b.seg - (a.suf && b.pref);
|
||||
ans.pref = a.pref;
|
||||
ans.suf = b.suf;
|
||||
ans.total = false;
|
||||
|
||||
return ans;
|
||||
};
|
||||
|
||||
auto propagate = [&](int i, int l, int r) {
|
||||
if (!upd[i]) {
|
||||
return;
|
||||
}
|
||||
|
||||
upd[i] = false;
|
||||
|
||||
seg[i].sum = lazy[i] * (r - l + 1);
|
||||
seg[i].pref = lazy[i];
|
||||
seg[i].suf = lazy[i];
|
||||
seg[i].total = lazy[i];
|
||||
seg[i].seg = lazy[i];
|
||||
|
||||
if (i < size) {
|
||||
lazy[i * 2] = lazy[i];
|
||||
lazy[i * 2 + 1] = lazy[i];
|
||||
upd[i * 2] = true;
|
||||
upd[i * 2 + 1] = true;
|
||||
}
|
||||
|
||||
return;
|
||||
};
|
||||
|
||||
function<void(int, int, int, int, int, int)> update = [&](int i, int l, int r, int tl, int tr, int v) {
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l > tr || r < tl) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
lazy[i] = v;
|
||||
upd[i] = true;
|
||||
propagate(i, l, r);
|
||||
return;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
update(i * 2, l, mid, tl, tr, v);
|
||||
update(i * 2 + 1, mid + 1, r, tl, tr, v);
|
||||
|
||||
seg[i] = merge(seg[i * 2], seg[i * 2 + 1]);
|
||||
};
|
||||
|
||||
auto query = [&]() {
|
||||
propagate(1, 0, size - 1);
|
||||
|
||||
return seg[1];
|
||||
};
|
||||
|
||||
rep(i, n) {
|
||||
char op;
|
||||
int x, l;
|
||||
cin >> op >> x >> l;
|
||||
x += middle;
|
||||
|
||||
op = op == 'B';
|
||||
|
||||
update(1, 0, size - 1, x, x + l - 1, op);
|
||||
|
||||
auto ans = query();
|
||||
cout << ans.seg << ' ' << ans.sum << '\n';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,182 @@
|
||||
/* Problem URL: https://codeforces.com/edu/course/2/lesson/5/4/practice/contest/280801/problem/D */
|
||||
|
||||
#include <bits/stdc++.h>
|
||||
#include <ext/pb_ds/assoc_container.hpp>
|
||||
#include <ext/pb_ds/tree_policy.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace __gnu_pbds;
|
||||
|
||||
template <class T, class comp = less<>>
|
||||
using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
|
||||
|
||||
#define V vector
|
||||
|
||||
#define rmin(a, b) a = min(a, b)
|
||||
#define rmax(a, b) a = max(a, b)
|
||||
|
||||
#define rep(i, lim) for (int i = 0; i < (lim); i++)
|
||||
#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
|
||||
|
||||
#define repv(i, v) for (auto &i : (v))
|
||||
#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
|
||||
#define sortv(v) sort(v.begin(), v.end())
|
||||
#define all(v) (v).begin(), (v).end()
|
||||
|
||||
using vi = vector<int>;
|
||||
using vvi = vector<vi>;
|
||||
using vvvi = vector<vvi>;
|
||||
using vvvvi = vector<vvvi>;
|
||||
|
||||
using ll = long long;
|
||||
|
||||
using vl = vector<ll>;
|
||||
using vvl = vector<vl>;
|
||||
using vvvl = vector<vvl>;
|
||||
using vvvvl = vector<vvvl>;
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
|
||||
os << vec[0];
|
||||
for (size_t i = 1; i < vec.size(); i++) {
|
||||
os << ' ' << vec[i];
|
||||
}
|
||||
os << '\n';
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<v> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
is >> i;
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
|
||||
for (auto &i : vec) {
|
||||
os << i[0];
|
||||
for (size_t j = 1; j < i.size(); j++) {
|
||||
os << ' ' << i[j];
|
||||
}
|
||||
os << '\n';
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<vector<v>> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
for (auto &j : i) {
|
||||
is >> j;
|
||||
}
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
cin.tie(nullptr);
|
||||
|
||||
int n, m;
|
||||
cin >> n >> m;
|
||||
|
||||
vi a(n);
|
||||
cin >> a;
|
||||
|
||||
while (__builtin_popcount(n) != 1) {
|
||||
n++;
|
||||
a.push_back(0);
|
||||
}
|
||||
|
||||
V<pair<ll, ll>> seg(n * 2);
|
||||
vl lazy(n * 2);
|
||||
|
||||
auto merge = [&](pair<ll, ll> a, pair<ll, ll> b) -> pair<ll, ll> {
|
||||
return {a.first + b.first, a.second + b.second};
|
||||
};
|
||||
|
||||
nrep(i, n, n * 2) {
|
||||
seg[i] = {a[i - n], a[i - n] * (i - n + 1)};
|
||||
}
|
||||
|
||||
for (int i = n - 1; i > 0; i--) {
|
||||
seg[i] = merge(seg[i * 2], seg[i * 2 + 1]);
|
||||
}
|
||||
|
||||
auto propagate = [&](int i, int l, int r) {
|
||||
if (lazy[i] == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
ll size = (r - l + 1);
|
||||
|
||||
seg[i].first += lazy[i] * size;
|
||||
seg[i].second += lazy[i] * (size * (r + l + 2) / 2);
|
||||
|
||||
if (i < n) {
|
||||
lazy[i * 2] += lazy[i];
|
||||
lazy[i * 2 + 1] += lazy[i];
|
||||
}
|
||||
|
||||
lazy[i] = 0;
|
||||
};
|
||||
|
||||
function<void(int, int, int, int, int, int)> update = [&](int i, int l, int r, int tl, int tr, int v) {
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l > tr || r < tl) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
lazy[i] += v;
|
||||
propagate(i, l, r);
|
||||
return;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
update(i * 2, l, mid, tl, tr, v);
|
||||
update(i * 2 + 1, mid + 1, r, tl, tr, v);
|
||||
|
||||
seg[i] = merge(seg[i * 2], seg[i * 2 + 1]);
|
||||
};
|
||||
|
||||
function<pair<ll, ll>(int, int, int, int, int)> query = [&](int i, int l, int r, int tl, int tr) -> pair<ll, ll> {
|
||||
if (l > tr || r < tl) {
|
||||
return {0, 0};
|
||||
}
|
||||
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
return seg[i];
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
return merge(query(i * 2, l, mid, tl, tr), query(i * 2 + 1, mid + 1, r, tl, tr));
|
||||
};
|
||||
|
||||
while (m--) {
|
||||
int op;
|
||||
cin >> op;
|
||||
|
||||
if (op == 1) {
|
||||
int l, r, d;
|
||||
cin >> l >> r >> d;
|
||||
update(1, 0, n - 1, l - 1, r - 1, d);
|
||||
continue;
|
||||
}
|
||||
|
||||
int l, r;
|
||||
cin >> l >> r;
|
||||
|
||||
auto ans = query(1, 0, n - 1, l - 1, r - 1);
|
||||
|
||||
cout << ans.second - ans.first * (l - 1) << '\n';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
/* Problem URL: https://codeforces.com/edu/course/2/lesson/5/4/practice/contest/280801/problem/E */
|
||||
|
||||
#include <bits/stdc++.h>
|
||||
#include <ext/pb_ds/assoc_container.hpp>
|
||||
#include <ext/pb_ds/tree_policy.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace __gnu_pbds;
|
||||
|
||||
template <class T, class comp = less<>>
|
||||
using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
|
||||
|
||||
#define V vector
|
||||
|
||||
#define rmin(a, b) a = min(a, b)
|
||||
#define rmax(a, b) a = max(a, b)
|
||||
|
||||
#define rep(i, lim) for (int i = 0; i < (lim); i++)
|
||||
#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
|
||||
|
||||
#define repv(i, v) for (auto &i : (v))
|
||||
#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
|
||||
#define sortv(v) sort(v.begin(), v.end())
|
||||
#define all(v) (v).begin(), (v).end()
|
||||
|
||||
using vi = vector<int>;
|
||||
using vvi = vector<vi>;
|
||||
using vvvi = vector<vvi>;
|
||||
using vvvvi = vector<vvvi>;
|
||||
|
||||
using ll = long long;
|
||||
|
||||
using vl = vector<ll>;
|
||||
using vvl = vector<vl>;
|
||||
using vvvl = vector<vvl>;
|
||||
using vvvvl = vector<vvvl>;
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
|
||||
os << vec[0];
|
||||
for (size_t i = 1; i < vec.size(); i++) {
|
||||
os << ' ' << vec[i];
|
||||
}
|
||||
os << '\n';
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<v> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
is >> i;
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
|
||||
for (auto &i : vec) {
|
||||
os << i[0];
|
||||
for (size_t j = 1; j < i.size(); j++) {
|
||||
os << ' ' << i[j];
|
||||
}
|
||||
os << '\n';
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<vector<v>> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
for (auto &j : i) {
|
||||
is >> j;
|
||||
}
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
cin.tie(nullptr);
|
||||
|
||||
int n, k;
|
||||
cin >> n >> k;
|
||||
|
||||
int prev = n;
|
||||
|
||||
if (n > 1) {
|
||||
n = 1 << (32 - __builtin_clz(n - 1));
|
||||
}
|
||||
|
||||
vl seg(n * 2);
|
||||
V<pair<ll, ll>> lazy(n * 2, {0, 1e5});
|
||||
V<bool> upd(n * 2);
|
||||
|
||||
auto propagate = [&](int i) {
|
||||
if (!upd[i]) {
|
||||
return;
|
||||
}
|
||||
|
||||
upd[i] = false;
|
||||
|
||||
rmax(seg[i], lazy[i].first);
|
||||
rmin(seg[i], lazy[i].second);
|
||||
|
||||
if (i < n) {
|
||||
rmax(lazy[i * 2].first, lazy[i].first);
|
||||
rmin(lazy[i * 2].second, lazy[i].second);
|
||||
if (lazy[i * 2].first > lazy[i * 2].second) {
|
||||
if (lazy[i * 2].first == lazy[i].first) {
|
||||
lazy[i * 2].second = lazy[i * 2].first;
|
||||
} else {
|
||||
lazy[i * 2].first = lazy[i * 2].second;
|
||||
}
|
||||
}
|
||||
upd[i * 2] = true;
|
||||
rmax(lazy[i * 2 + 1].first, lazy[i].first);
|
||||
rmin(lazy[i * 2 + 1].second, lazy[i].second);
|
||||
if (lazy[i * 2 + 1].first > lazy[i * 2 + 1].second) {
|
||||
if (lazy[i * 2 + 1].first == lazy[i].first) {
|
||||
lazy[i * 2 + 1].second = lazy[i * 2 + 1].first;
|
||||
} else {
|
||||
lazy[i * 2 + 1].first = lazy[i * 2 + 1].first;
|
||||
}
|
||||
}
|
||||
upd[i * 2 + 1] = true;
|
||||
}
|
||||
|
||||
lazy[i] = {0, 1e5};
|
||||
};
|
||||
|
||||
function<void(int, int, int, int, int, int, ll)> update = [&](int i, int l, int r, int tl, int tr, int t, ll v) {
|
||||
propagate(i);
|
||||
|
||||
if (l > tr || r < tl) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
if (t) {
|
||||
lazy[i].second = v;
|
||||
} else {
|
||||
lazy[i].first = v;
|
||||
}
|
||||
upd[i] = true;
|
||||
propagate(i);
|
||||
return;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
update(i * 2, l, mid, tl, tr, t, v);
|
||||
update(i * 2 + 1, mid + 1, r, tl, tr, t, v);
|
||||
};
|
||||
|
||||
function<ll(int, int, int, int)> query = [&](int i, int l, int r, int t) {
|
||||
propagate(i);
|
||||
|
||||
if (i >= n) {
|
||||
return seg[i];
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
if (mid >= t) {
|
||||
return query(i * 2, l, mid, t);
|
||||
}
|
||||
return query(i * 2 + 1, mid + 1, r, t);
|
||||
};
|
||||
|
||||
while (k--) {
|
||||
int op, l, r, h;
|
||||
cin >> op >> l >> r >> h;
|
||||
|
||||
update(1, 0, n - 1, l, r, op - 1, h);
|
||||
}
|
||||
|
||||
rep(i, prev) {
|
||||
cout << query(1, 0, n - 1, i) << '\n';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,426 @@
|
||||
/* Problem URL: https://codeforces.com/edu/course/2/lesson/5/4/practice/contest/280801/problem/F */
|
||||
|
||||
#include <bits/stdc++.h>
|
||||
#include <ext/pb_ds/assoc_container.hpp>
|
||||
#include <ext/pb_ds/tree_policy.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace __gnu_pbds;
|
||||
|
||||
template <class T, class comp = less<>>
|
||||
using ordered_set = tree<T, null_type , comp , rb_tree_tag , tree_order_statistics_node_update>;
|
||||
|
||||
#define V vector
|
||||
|
||||
#define rmin(a, b) a = min(a, b)
|
||||
#define rmax(a, b) a = max(a, b)
|
||||
|
||||
#define rep(i, lim) for (int i = 0; i < (lim); i++)
|
||||
#define nrep(i, s, lim) for (int i = s; i < (lim); i++)
|
||||
|
||||
#define repv(i, v) for (auto &i : (v))
|
||||
#define fillv(v) for (auto &itr_ : (v)) { cin >> itr_; }
|
||||
#define sortv(v) sort(v.begin(), v.end())
|
||||
#define all(v) (v).begin(), (v).end()
|
||||
|
||||
using vi = vector<int>;
|
||||
using vvi = vector<vi>;
|
||||
using vvvi = vector<vvi>;
|
||||
using vvvvi = vector<vvvi>;
|
||||
|
||||
using ll = long long;
|
||||
|
||||
using vl = vector<ll>;
|
||||
using vvl = vector<vl>;
|
||||
using vvvl = vector<vvl>;
|
||||
using vvvvl = vector<vvvl>;
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<v> &vec)->ostream& {
|
||||
os << vec[0];
|
||||
for (size_t i = 1; i < vec.size(); i++) {
|
||||
os << ' ' << vec[i];
|
||||
}
|
||||
os << '\n';
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<v> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
is >> i;
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator<<(ostream &os, const vector<vector<v>> &vec)->ostream& {
|
||||
for (auto &i : vec) {
|
||||
os << i[0];
|
||||
for (size_t j = 1; j < i.size(); j++) {
|
||||
os << ' ' << i[j];
|
||||
}
|
||||
os << '\n';
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class v>
|
||||
auto operator>>(istream &is, vector<vector<v>> &vec)->istream& {
|
||||
for (auto &i : vec) {
|
||||
for (auto &j : i) {
|
||||
is >> j;
|
||||
}
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
class segtree_arithmethic {
|
||||
struct node {
|
||||
int val;
|
||||
int left;
|
||||
int right;
|
||||
};
|
||||
|
||||
struct lazynode {
|
||||
int c;
|
||||
int x;
|
||||
int xi;
|
||||
bool cupd;
|
||||
bool xupd;
|
||||
};
|
||||
|
||||
V<node> seg;
|
||||
V<lazynode> lazy;
|
||||
int n;
|
||||
|
||||
int newnode() {
|
||||
lazy.emplace_back(0LL, 0LL, 0LL, false, false);
|
||||
seg.emplace_back(0LL, -1, -1);
|
||||
|
||||
return seg.size() - 1;
|
||||
}
|
||||
|
||||
void createchildren(int i) {
|
||||
if (seg[i].left == -1) {
|
||||
seg[i].left = newnode();
|
||||
}
|
||||
|
||||
if (seg[i].right == -1) {
|
||||
seg[i].right = newnode();
|
||||
}
|
||||
}
|
||||
|
||||
void propagatear(int i, int l, int r) {
|
||||
if (!lazy[i].xupd) {
|
||||
return;
|
||||
}
|
||||
|
||||
seg[i].val = lazy[i].xi + lazy[i].x * (r - l);
|
||||
|
||||
if (l != r) {
|
||||
createchildren(i);
|
||||
|
||||
int left = seg[i].left;
|
||||
int right = seg[i].right;
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
lazy[left].x = lazy[i].x;
|
||||
lazy[left].c = 0;
|
||||
lazy[left].xi = lazy[i].xi;
|
||||
lazy[left].cupd = false;
|
||||
lazy[left].xupd = true;
|
||||
|
||||
lazy[right].x = lazy[i].x;
|
||||
lazy[right].c = 0;
|
||||
lazy[right].xi = lazy[i].xi + lazy[i].x * (mid - l + 1);
|
||||
lazy[right].cupd = false;
|
||||
lazy[right].xupd = true;
|
||||
}
|
||||
|
||||
lazy[i].xupd = false;
|
||||
};
|
||||
|
||||
void propagatec(int i, int l, int r) {
|
||||
if (!lazy[i].cupd) {
|
||||
return;
|
||||
}
|
||||
|
||||
seg[i].val += lazy[i].c;
|
||||
|
||||
if (l != r) {
|
||||
createchildren(i);
|
||||
|
||||
int left = seg[i].left;
|
||||
int right = seg[i].right;
|
||||
|
||||
lazy[left].c += lazy[i].c;
|
||||
lazy[left].cupd = true;
|
||||
|
||||
lazy[right].c += lazy[i].c;
|
||||
lazy[right].cupd = true;
|
||||
}
|
||||
|
||||
lazy[i].cupd = false;
|
||||
lazy[i].c = 0;
|
||||
}
|
||||
|
||||
void propagate(int i, int l, int r) {
|
||||
propagatear(i, l, r);
|
||||
propagatec(i, l, r);
|
||||
}
|
||||
|
||||
int x;
|
||||
int tl, tr;
|
||||
|
||||
void updatearithmethic(int i, int l, int r, int xi) {
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l > tr || r < tl) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
lazy[i].x = x;
|
||||
lazy[i].xi = xi;
|
||||
lazy[i].xupd = true;
|
||||
lazy[i].c = 0;
|
||||
lazy[i].cupd = false;
|
||||
propagate(i, l, r);
|
||||
return;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
createchildren(i);
|
||||
|
||||
updatearithmethic(seg[i].left, l, mid, xi);
|
||||
updatearithmethic(seg[i].right, mid + 1, r, xi + x * (mid - l + 1));
|
||||
|
||||
seg[i].val = max(seg[seg[i].left].val, seg[seg[i].right].val);
|
||||
}
|
||||
|
||||
int c;
|
||||
|
||||
void updateconst(int i, int l, int r) {
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l > tr || r < tl) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
lazy[i].c += c;
|
||||
lazy[i].cupd = true;
|
||||
propagate(i, l, r);
|
||||
return;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
createchildren(i);
|
||||
|
||||
updateconst(seg[i].left, l, mid);
|
||||
updateconst(seg[i].right, mid + 1, r);
|
||||
|
||||
seg[i].val = max(seg[seg[i].left].val, seg[seg[i].right].val);
|
||||
}
|
||||
|
||||
int h;
|
||||
|
||||
ll query(int i, int l, int r) {
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l == r) {
|
||||
return seg[i].val > h ? -1 : l;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
createchildren(i);
|
||||
propagate(seg[i].left, l, mid);
|
||||
propagate(seg[i].right, mid + 1, r);
|
||||
|
||||
if (seg[seg[i].left].val > h) {
|
||||
return query(seg[i].left, l, mid);
|
||||
}
|
||||
int res = query(seg[i].right, mid + 1, r);
|
||||
return res == -1 ? mid : res;
|
||||
}
|
||||
|
||||
public:
|
||||
segtree_arithmethic(int n): n(n) {
|
||||
seg.emplace_back(0LL, -1, -1);
|
||||
lazy.emplace_back();
|
||||
}
|
||||
|
||||
void updatearithmethic(int l, int r, ll x) {
|
||||
this->x = x;
|
||||
tl = l;
|
||||
tr = r;
|
||||
updatearithmethic(0, 0, n - 1, x * (-l + 1));
|
||||
}
|
||||
|
||||
void updateconst(int l, int r, ll c) {
|
||||
this->c = c;
|
||||
tl = l;
|
||||
tr = r;
|
||||
updateconst(0, 0, n - 1);
|
||||
}
|
||||
|
||||
ll query(int h) {
|
||||
this->h = h;
|
||||
return query(0, 0, n - 1);
|
||||
}
|
||||
};
|
||||
|
||||
class segtree_sum {
|
||||
struct node {
|
||||
int val;
|
||||
int left;
|
||||
int right;
|
||||
};
|
||||
|
||||
struct lazynode {
|
||||
int val;
|
||||
bool upd;
|
||||
};
|
||||
|
||||
V<node> seg;
|
||||
V<lazynode> lazy;
|
||||
int n;
|
||||
|
||||
int newnode() {
|
||||
seg.emplace_back(0LL, -1, -1);
|
||||
lazy.emplace_back(0LL, false);
|
||||
|
||||
return seg.size() - 1;
|
||||
}
|
||||
|
||||
void createchildren(int i) {
|
||||
if (seg[i].left == -1) {
|
||||
seg[i].left = newnode();
|
||||
}
|
||||
|
||||
if (seg[i].right == -1) {
|
||||
seg[i].right = newnode();
|
||||
}
|
||||
}
|
||||
|
||||
void propagate(int i, int l, int r) {
|
||||
if (!lazy[i].upd) {
|
||||
return;
|
||||
}
|
||||
|
||||
seg[i].val = lazy[i].val * (r - l + 1);
|
||||
|
||||
if (l != r) {
|
||||
createchildren(i);
|
||||
lazy[seg[i].left] = lazy[i];
|
||||
lazy[seg[i].right] = lazy[i];
|
||||
}
|
||||
|
||||
lazy[i].upd = false;
|
||||
}
|
||||
|
||||
int tl, tr;
|
||||
int v;
|
||||
|
||||
void upd(int i, int l, int r) {
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l > tr || r < tl) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
lazy[i] = {v, true};
|
||||
propagate(i, l, r);
|
||||
return;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
createchildren(i);
|
||||
|
||||
upd(seg[i].left, l, mid);
|
||||
upd(seg[i].right, mid + 1, r);
|
||||
|
||||
seg[i].val = seg[seg[i].left].val + seg[seg[i].right].val;
|
||||
}
|
||||
|
||||
ll query(int i, int l, int r) {
|
||||
if (l > tr || r < tl || i == -1) {
|
||||
return 0LL;
|
||||
}
|
||||
|
||||
propagate(i, l, r);
|
||||
|
||||
if (l >= tl && r <= tr) {
|
||||
return seg[i].val;
|
||||
}
|
||||
|
||||
int mid = (l + r) >> 1;
|
||||
|
||||
return query(seg[i].left, l, mid) + query(seg[i].right, mid + 1, r);
|
||||
}
|
||||
|
||||
public:
|
||||
segtree_sum(int n): n(n) {
|
||||
seg.emplace_back(0LL, -1, -1);
|
||||
lazy.emplace_back(0LL, false);
|
||||
}
|
||||
|
||||
void update(int l, int r, int d) {
|
||||
tl = l;
|
||||
tr = r;
|
||||
v = d;
|
||||
upd(0, 0, n - 1);
|
||||
}
|
||||
|
||||
ll query(int l, int r) {
|
||||
tl = l;
|
||||
tr = r;
|
||||
return query(0, 0, n - 1);
|
||||
}
|
||||
};
|
||||
|
||||
signed main()
|
||||
{
|
||||
ios::sync_with_stdio(false);
|
||||
cin.tie(nullptr);
|
||||
|
||||
ll n;
|
||||
cin >> n;
|
||||
|
||||
ll prev = n;
|
||||
|
||||
if (n > 1) {
|
||||
n = 1 << (32 - __builtin_clz(n));
|
||||
}
|
||||
|
||||
segtree_arithmethic arithmethic(n);
|
||||
segtree_sum sum(n);
|
||||
|
||||
char op;
|
||||
while (cin >> op, op != 'E') {
|
||||
if (op == 'I') {
|
||||
int a, b, d;
|
||||
cin >> a >> b >> d;
|
||||
|
||||
arithmethic.updateconst(b + 1, n, -sum.query(a, b));
|
||||
arithmethic.updatearithmethic(a, b, d);
|
||||
arithmethic.updateconst(a, b, sum.query(0, a - 1));
|
||||
sum.update(a, b, d);
|
||||
arithmethic.updateconst(b + 1, n, sum.query(a, b));
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
int h;
|
||||
cin >> h;
|
||||
|
||||
cout << min(arithmethic.query(h), prev) << '\n';
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user