text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
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;
}
struct data {
int milk, order, ans;
friend data operator+(const data& a, const data& b) {
data c;
int add = min(a.milk, b.order);
add = 0;
c.ans = a.ans + b.ans + add;
c.milk = a.milk + b.milk - add;
c.order = a.order + b.order - add;
return c;
}
void Mod(int x) {
int add = min(milk, x);
ans += add;
milk -= add;
order += x - add;
}
};
struct Tree {
int l, r;
data d[3];
} T[200000 * 4 + 5];
int n, a, b, k, m;
void Build(int x, int l, int r) {
if ((T[x].l = l) == (T[x].r = r)) {
T[x].d[0] = (data){0, 0, 0};
T[x].d[1] = (data){a, 0, 0};
T[x].d[2] = (data){b, 0, 0};
return;
}
int mid = l + r >> 1;
Build(x << 1, l, mid);
Build(x << 1 | 1, mid + 1, r);
for (int i = 0; i < 3; ++i) T[x].d[i] = T[x << 1].d[i] + T[x << 1 | 1].d[i];
}
void Modify(int x, int k, int v) {
if (T[x].l == T[x].r) {
for (int i = 0; i < 3; ++i) T[x].d[i].Mod(v);
return;
}
int mid = T[x].l + T[x].r >> 1;
Modify(x << 1 | (k > mid), k, v);
for (int i = 0; i < 3; ++i) T[x].d[i] = T[x << 1].d[i] + T[x << 1 | 1].d[i];
}
data Query(int x, int l, int r, int v) {
if (l > r) return (data){0, 0, 0};
if (T[x].l == l && T[x].r == r) return T[x].d[v];
int mid = T[x].l + T[x].r >> 1;
if (r <= mid)
return Query(x << 1, l, r, v);
else if (l > mid)
return Query(x << 1 | 1, l, r, v);
else
return Query(x << 1, l, mid, v) + Query(x << 1 | 1, mid + 1, r, v);
}
int main() {
n = read();
k = read();
b = read();
a = read();
m = read();
Build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int op = read(), p, v;
if (op == 2)
p = read(),
printf("%d\n", (Query(1, 1, p - 1, 1) + Query(1, p, p + k - 1, 0) +
Query(1, p + k, n, 2))
.ans);
else
p = read(), v = read(), Modify(1, p, v);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const long long INF = 1e9 + 7;
const long double EPS = 1e-9;
const long long P = 485437;
const int C = 2016;
long long a, b;
pair<long long, long long> t[N];
void add(int i, int l, int r, int d, int x) {
if (d < l || d >= r) return;
if (l == r - 1) {
t[i].first = min(b, t[i].first + x);
t[i].second = min(a, t[i].second + x);
return;
}
int m = (l + r) / 2;
add(i * 2 + 1, l, m, d, x);
add(i * 2 + 2, m, r, d, x);
t[i].first = t[i * 2 + 1].first + t[i * 2 + 2].first;
t[i].second = t[i * 2 + 1].second + t[i * 2 + 2].second;
}
long long sum(int i, int l, int r, int a, int b, bool f) {
if (b <= l || a >= r) return 0;
if (a <= l && r <= b) return (f) ? t[i].second : t[i].first;
int m = (l + r) / 2;
return sum(i * 2 + 1, l, m, a, b, f) + sum(i * 2 + 2, m, r, a, b, f);
}
int main() {
ios_base::sync_with_stdio(0);
int n, k, d, q, typ, x;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
cin >> typ;
if (typ == 1) {
cin >> d >> x;
add(0, 0, n, d - 1, x);
} else {
cin >> d;
cout << sum(0, 0, n, 0, d - 1, 0) + sum(0, 0, n, d + k - 1, n, 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int inf = INT_MAX;
const int lim = 2e5 + 5;
int power(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret *= a;
a *= a;
if (ret >= mod) ret %= mod;
if (a >= mod) a %= mod;
b >>= 1;
}
return ret;
}
int inv(int x) { return power(x, mod - 2); }
int cnt[2][lim];
long long BIT[2][lim];
int n, k, a, b, q;
void update(int type, int idx, int val) {
while (idx <= n) {
BIT[type][idx] += val;
idx += idx & (-idx);
}
}
long long query(int type, int idx) {
long long ans = 0;
while (idx > 0) {
ans += BIT[type][idx];
idx -= idx & (-idx);
}
return ans;
}
int main() {
cin >> n >> k >> a >> b >> q;
int type, x, y;
while (q--) {
cin >> type;
if (type == 1) {
cin >> x >> y;
if (cnt[0][x] < b) {
int val = min(y, b - cnt[0][x]);
update(0, x, val);
cnt[0][x] += val;
}
if (cnt[1][x] < a) {
int val = min(y, a - cnt[1][x]);
update(1, x, val);
cnt[1][x] += val;
}
continue;
}
cin >> x;
cout << query(1, n) - query(1, x + k - 1) + query(0, x - 1) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
int N;
vector<int> A;
FenwickTree(int N) : N(N), A(N) {}
int rsq(int b) {
int sum = 0;
for (; b; b -= (b & (-b))) sum += A[b];
return sum;
}
int rsq(int a, int b) { return rsq(b) - (a == 1000000000 ? 0 : rsq(a - 1)); }
void adjust(int k, int v) {
for (; k < A.size(); k += k & -k) A[k] += v;
}
};
int n, k, a, b, q;
int main() {
cin >> n >> k >> a >> b >> q;
FenwickTree bef(n + 5), aft(n + 5);
vector<int> befa(n + 1), afta(n + 1);
int i, j, k1;
for (int c = 0; c < q; c++) {
scanf("%d", &i);
if (i == 1) {
scanf("%d%d", &j, &k1);
int befk = min(k1 + befa[j], b);
int aftk = min(k1 + afta[j], a);
bef.adjust(j, befk - befa[j]);
befa[j] = befk;
aft.adjust(j, aftk - afta[j]);
afta[j] = aftk;
} else {
scanf("%d", &j);
printf("%d\n", bef.rsq(1, j - 1) + aft.rsq(k + j, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
template <typename Type, class MainOperator, class AddOperator = MainOperator>
class SegmentTree {
protected:
vector<Type> t;
int ppow;
Type defaultValue;
MainOperator Operator;
AddOperator addOperator;
void _construct(int size, Type defaultValue, Type value) {
ppow = size;
while (ppow & (ppow - 1)) ppow++;
this->defaultValue = defaultValue;
t.resize(ppow * 2);
for (int i = 0; i < ppow; i++)
t[i + ppow] = i < size ? value : defaultValue;
for (int i = ppow - 1; i > 0; i--) t[i] = Operator(t[i * 2], t[i * 2 + 1]);
}
public:
SegmentTree(int size, Type defaultValue) {
_construct(size, defaultValue, defaultValue);
}
SegmentTree(int size, Type defaultValue, Type value) {
_construct(size, defaultValue, value);
}
template <typename Iterator>
SegmentTree(Iterator begin, Iterator end, Type defaultValue) {
this->defaultValue = defaultValue;
vector<Type> values(begin, end);
ppow = values.size();
while (ppow & (ppow - 1)) ppow++;
t.assign(ppow * 2, defaultValue);
for (int i = 0; i < (int)values.size(); i++) t[i + ppow] = values[i];
for (int i = ppow - 1; i > 0; i--) t[i] = Operator(t[i * 2], t[i * 2 + 1]);
}
Type Get(int L, int R) {
L += ppow;
R += ppow;
Type res = defaultValue;
while (L <= R) {
if (L & 1) res = Operator(res, t[L++]);
if (~R & 1) res = Operator(res, t[R--]);
L /= 2;
R /= 2;
}
return res;
}
void Add(int pos, Type value) {
pos += ppow;
t[pos] = addOperator(t[pos], value);
pos /= 2;
while (pos > 0) {
t[pos] = Operator(t[pos * 2], t[pos * 2 + 1]);
pos /= 2;
}
}
void Set(int pos, Type value) {
pos += ppow;
t[pos] = value;
pos /= 2;
while (pos > 0) {
t[pos] = Operator(t[pos * 2], t[pos * 2 + 1]);
pos /= 2;
}
}
};
template <typename Type>
struct Sum {
Type operator()(Type a, Type b) { return a + b; }
};
template <typename Type>
struct Min {
Type operator()(Type a, Type b) { return a < b ? a : b; }
};
template <typename Type>
struct Max {
Type operator()(Type a, Type b) { return a > b ? a : b; }
};
int main() {
int n, k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
SegmentTree<long long, Sum<int> > t1(n, 0ll);
SegmentTree<long long, Sum<int> > t2(n, 0ll);
while (q--) {
int type, pos, val;
scanf("%d %d", &type, &pos);
pos--;
if (type == 1) {
scanf("%d", &val);
auto v1 = t1.Get(pos, pos);
v1 = min((long long)a, v1 + val);
t1.Set(pos, v1);
auto v2 = t2.Get(pos, pos);
v2 = min((long long)b, v2 + val);
t2.Set(pos, v2);
} else {
printf("%I64d\n", t2.Get(0, pos - 1) + t1.Get(pos + k, n - 1));
}
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "( " << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<set<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
int i = 0;
for (auto it : v) {
if (i > 0) {
os << ' ';
}
os << it;
i++;
}
return os;
}
using ll = long long int;
ld dis(pair<int, int> a, pair<int, int> b) {
ld dx = a.first - b.first;
ld dy = a.second - b.second;
return sqrt(dx * dx + dy * dy);
}
using ll = long long int;
using Value = ll;
const Value ini = 0;
Value connect(Value al, const Value ar) { return al + ar; }
struct segtree {
int N;
vector<Value> dat;
segtree() {}
segtree(int n, vector<Value> &v) {
N = 1;
while (N < n) N *= 2;
dat.resize(2 * N);
for (int x = 0; x < N; ++x) {
if (x < v.size()) {
dat[x + N - 1] = v[x];
} else {
dat[x + N - 1] = ini;
}
}
for (int x = N - 2; x >= 0; --x) {
dat[x] = connect(dat[x * 2 + 1], dat[x * 2 + 2]);
}
}
void update(int k, const Value &a) {
k += N - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) >> 1;
dat[k] = connect(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
Value query(int a, int b) { return query(a, b, 0, 0, N); }
Value query(int a, int b, int k, int l, int r) {
if (r <= a or b <= l) return ini;
if (a <= l and r <= b) return dat[k];
const int m = (l + r) / 2;
return connect(query(a, b, k * 2 + 1, l, m), query(a, b, k * 2 + 2, m, r));
}
};
int main() {
ios::sync_with_stdio(false);
int N, K;
ll A, B;
int Q;
cin >> N >> K >> B >> A >> Q;
vector<Value> vec(N, 0);
segtree seg1(N, vec);
segtree seg2(N, vec);
vector<ll> nums(N);
while (Q--) {
int type;
cin >> type;
if (type == 1) {
int day;
cin >> day;
day--;
ll plus;
cin >> plus;
nums[day] += plus;
seg1.update(day, min(nums[day], A));
seg2.update(day, min(nums[day], B));
} else {
int s;
cin >> s;
ll answer = seg1.query(0, s - 1);
answer += seg2.query(min(N, K + s - 1), N);
cout << answer << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long z = 1000000007;
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % z;
b--;
} else {
a = (a * a) % z;
b = b >> 1;
}
}
return res;
}
vector<long long> seg, seg1;
void arrange(long long i, long long v, long long v1, long long x, long long lx,
long long rx) {
if (rx - lx == 1) {
seg[x] = v;
seg1[x] = v1;
return;
}
long long mid = (lx + rx) / 2;
if (i < mid)
arrange(i, v, v1, 2 * x + 1, lx, mid);
else
arrange(i, v, v1, 2 * x + 2, mid, rx);
seg[x] = seg[2 * x + 1] + seg[2 * x + 2];
seg1[x] = seg1[2 * x + 1] + seg1[2 * x + 2];
}
long long sum1(long long l, long long r, long long x, long long lx,
long long rx) {
if (l >= rx || r <= lx) return 0;
if (lx >= l && rx <= r) return seg[x];
long long mid = (lx + rx) / 2;
long long sl = sum1(l, r, 2 * x + 1, lx, mid),
sr = sum1(l, r, 2 * x + 2, mid, rx);
return (sl + sr);
}
long long sum2(long long l, long long r, long long x, long long lx,
long long rx) {
if (l >= rx || r <= lx) return 0;
if (lx >= l && rx <= r) return seg1[x];
long long mid = (lx + rx) / 2;
long long sl = sum2(l, r, 2 * x + 1, lx, mid),
sr = sum2(l, r, 2 * x + 2, mid, rx);
return (sl + sr);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
long long s = 1;
while (s < n) s *= 2;
seg.assign(2 * s, (long long)0);
seg1.assign(2 * s, (long long)0);
long long ar[n], ar1[n];
memset(ar, 0, sizeof(ar));
memset(ar1, 0, sizeof(ar1));
set<long long> s1;
while (q--) {
long long ty;
cin >> ty;
if (ty == 1) {
long long d, a1;
cin >> d >> a1;
d--;
if (s1.find(d) == s1.end()) {
ar[d] += a1;
ar1[d] += a1;
ar[d] = min(ar[d], a);
ar1[d] = min(ar1[d], b);
if (ar[d] <= a) arrange(d, ar[d], ar1[d], 0, 0, s);
if (ar[d] == a) s1.insert(d);
}
} else {
long long p;
cin >> p;
p--;
long long p1 = 0;
if (p > 0) p1 = sum2(0, p, 0, 0, s);
if (p + k < n) p1 += sum1(p + k, n, 0, 0, s);
cout << p1 << "\n";
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int res[500050] = {0};
int res1[500050] = {0};
int read(int idx) {
int sum = 0;
while (idx > 0) {
sum += res[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val, int N) {
while (idx <= N) {
res[idx] += val;
idx += (idx & -idx);
}
}
int read1(int idx) {
int sum = 0;
while (idx > 0) {
sum += res1[idx];
idx -= (idx & -idx);
}
return sum;
}
void update1(int idx, int val, int N) {
while (idx <= N) {
res1[idx] += val;
idx += (idx & -idx);
}
}
int main() {
ios_base::sync_with_stdio(0);
int n, k, a, b, q;
int t;
int d, ai, p;
int check, check1;
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> t;
if (t == 1) {
cin >> d >> ai;
check = read(d) - read(d - 1);
check1 = read1(d) - read1(d - 1);
if (check < a) {
if (check + ai <= a) {
update(d, ai, n);
} else {
update(d, a - check, n);
}
}
if (check1 < b) {
if (check1 + ai <= b) {
update1(d, ai, n);
} else {
update1(d, b - check1, n);
}
}
}
if (t == 2) {
cin >> p;
int post = 0;
int pre = 0;
if (p + k - 1 < n) {
post = read(n) - read(p + k - 1);
}
pre = read1(p - 1);
cout << pre + post << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200200;
int n;
const long long neutro = 0;
struct RMQ {
int sz;
long long tope;
long long t[4 * MAXN];
long long &operator[](int p) { return t[sz + p]; }
void init(int n, long long tope_) {
sz = 1 << (32 - __builtin_clz(n));
tope = tope_;
for (int i = (0); i < (2 * sz); i++) t[i] = neutro;
}
void updall() {
for (int i = sz - 1; i >= 0; i--) t[i] = (t[2 * i] + t[2 * i + 1]);
}
long long get(int i, int j) {
if (j <= i) return 0;
return get(i, j, 1, 0, sz);
}
long long get(int i, int j, int n, int a, int b) {
if (j <= a || i >= b) return neutro;
if (i <= a && b <= j) return t[n];
int c = (a + b) / 2;
return (get(i, j, 2 * n, a, c) + get(i, j, 2 * n + 1, c, b));
}
void set(int p, long long val) {
p += sz;
val = min(tope, t[p] + val);
for (; p > 0 && t[p] != val;) {
t[p] = val;
p /= 2;
val = (t[p * 2] + t[p * 2 + 1]);
}
}
} rmqa, rmqb;
int k, a, b, q;
int main() {
ios::sync_with_stdio(0);
while (cin >> n >> k >> a >> b >> q) {
rmqa.init(n, a);
rmqb.init(n, b);
for (int _ = (0); _ < (q); _++) {
int t;
cin >> t;
if (t == 1) {
int d, a;
cin >> d >> a;
rmqa.set(d - 1, a);
rmqb.set(d - 1, a);
} else {
int p;
cin >> p;
p--;
cout << rmqb.get(0, p) + rmqa.get(p + k, n) << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
int seg[2][200010 * 4];
int bv[200010];
int av[200010];
void up(int spot, int ss, int se, int si) {
if (spot < ss || spot > se || ss > se) return;
if (spot == ss && spot == se) {
seg[0][si] = bv[spot];
seg[1][si] = av[spot];
return;
}
int mid = (ss + se) / 2;
if (spot <= mid) {
up(spot, ss, mid, si * 2 + 1);
} else {
up(spot, mid + 1, se, si * 2 + 2);
}
seg[0][si] = seg[0][si * 2 + 1] + seg[0][si * 2 + 2];
seg[1][si] = seg[1][si * 2 + 1] + seg[1][si * 2 + 2];
}
void update(int spot, int inc) {
bv[spot] += inc;
av[spot] += inc;
bv[spot] = min(bv[spot], b);
av[spot] = min(av[spot], a);
up(spot, 1, n, 0);
}
int qu(int ind, int qs, int qe, int ss, int se, int si) {
if (qs > qe || ss > se || qe < ss || qs > se) return 0;
if (qs <= ss && se <= qe) {
return seg[ind][si];
}
int mid = (ss + se) / 2;
return qu(ind, qs, qe, ss, mid, si * 2 + 1) +
qu(ind, qs, qe, mid + 1, se, si * 2 + 2);
}
int query(int ind, int qs, int qe) { return qu(ind, qs, qe, 1, n, 0); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fill(seg[0], seg[0] + 200010 * 4, 0);
fill(seg[1], seg[1] + 200010 * 4, 0);
fill(bv, bv + 200010, 0);
fill(av, av + 200010, 0);
cin >> n >> k >> a >> b >> q;
int tp;
int di, ai, pi;
while (q--) {
cin >> tp;
if (tp == 1) {
cin >> di >> ai;
update(di, ai);
} else {
cin >> pi;
int ans = query(0, 1, pi - 1) + query(1, pi + k, n);
cout << ans << endl;
}
}
cin >> tp;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long tavan(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
long long n, k, a, b, q, fen[2][(201 * 1000)], in[(201 * 1000)];
long long query1(long long x) {
long long num = 0;
for (; x > 0; x -= x & (-x)) num += fen[0][x];
return num;
}
long long query2(long long x) {
long long num = 0;
for (; x > 0; x -= x & (-x)) num += fen[1][x];
return num;
}
void add1(long long x, long long y) {
for (; x <= n; x += x & (-x)) fen[0][x] += y;
}
void add2(long long x, long long y) {
for (; x <= n; x += x & (-x)) fen[1][x] += y;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> a >> b >> q;
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long x, y;
cin >> x >> y;
if (in[x] < b) add1(x, min(b - in[x], y));
if (in[x] < a) add2(x, min(a - in[x], y));
in[x] += y;
continue;
}
long long x;
cin >> x;
cout << query1(x - 1) + query2(n) - query2(x + k - 1) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct bit {
vector<int> tree;
int N;
bit(int _N) {
N = _N + 1;
tree = vector<int>(N, 0);
}
void update(int ind, int value) {
ind++;
while (ind < N) {
tree[ind] += value;
ind += (ind & -ind);
}
}
int get(int ind) {
int sum = 0;
while (ind > 0) {
sum += tree[ind];
ind -= (ind & -ind);
}
return sum;
}
int get(int ind1, int ind2) {
if (ind1 >= ind2) return 0;
return get(ind2) - get(ind1);
}
};
int main() {
int n, k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
bit bef(n + k + 10), aft(n + k + 10);
vector<int> val(n + k + 10, 0);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, ai;
scanf("%d %d", &d, &ai);
bef.update(d, -min(val[d], b));
aft.update(d, -min(val[d], a));
val[d] += ai;
bef.update(d, min(val[d], b));
aft.update(d, min(val[d], a));
} else {
int p;
scanf("%d", &p);
printf("%d\n", bef.get(p) + aft.get(p + k, n + 5));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point() { x = y = 0; }
point(double xx, double yy) {
x = xx;
y = yy;
}
point operator+(point p) { return point(x + p.x, y + p.y); }
point operator-(point p) { return point(x - p.x, y - p.y); }
point operator*(double a) { return point(x * a, y * a); }
double operator*(point p) { return x * p.x + y * p.y; }
double len2() { return (*this) * (*this); }
double len() { return sqrt((*this).len2()); }
bool operator==(point p) { return ((*this) - p).len() < 1e-7; }
};
int const cnt = (2 << 20);
int n, k, a, b, q;
int aa[cnt], bb[cnt];
void add_a(int d, int cc) {
int pos = cnt / 2 + d;
int h = min(aa[pos] + cc, a);
int add = h - aa[pos];
aa[pos] = h;
pos /= 2;
while (pos != 0) {
aa[pos] += add;
pos /= 2;
}
}
void add_b(int d, int cc) {
int pos = cnt / 2 + d;
int h = min(bb[pos] + cc, b);
int add = h - bb[pos];
bb[pos] = h;
pos /= 2;
while (pos != 0) {
bb[pos] += add;
pos /= 2;
}
}
long long get_a(int l, int r) {
l = cnt / 2 + l;
r = cnt / 2 + r;
long long ans = 0;
while (l <= r) {
if ((l & 1) == 1) ans += aa[l], l++;
if ((r & 1) == 0) ans += aa[r], r--;
l /= 2;
r /= 2;
}
return ans;
}
long long get_b(int l, int r) {
l = cnt / 2 + l;
r = cnt / 2 + r;
long long ans = 0;
while (l <= r) {
if ((l & 1) == 1) ans += bb[l], l++;
if ((r & 1) == 0) ans += bb[r], r--;
l /= 2;
r /= 2;
}
return ans;
}
int main() {
cout.setf(ios::fixed, ios::floatfield);
cout.precision(2);
cin >> n >> k >> a >> b >> q;
for (int(i) = (0); i < (q); ++(i)) {
int h;
cin >> h;
if (h == 1) {
int di, ai;
cin >> di >> ai;
add_a(di, ai);
add_b(di, ai);
} else {
int p;
cin >> p;
cout << get_b(1, p - 1) + get_a(p + k, n) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sg[800100][2], a, b, k, n, q;
long long querry(int id, int l, int r, int x, int y, int t) {
if (l > y || r < x) return 0;
if (l >= x && r <= y) return sg[id][t];
return querry(id * 2, l, (l + r) / 2, x, y, t) +
querry(id * 2 + 1, (l + r) / 2 + 1, r, x, y, t);
}
void updt(int id, int l, int r, int x, long long v, int t) {
if (l > x || r < x) return;
if (l == x && r == x) {
sg[id][t] = min(sg[id][t] + v, t ? a : b);
return;
}
updt(id * 2, l, (l + r) / 2, x, v, t);
updt(id * 2 + 1, (l + r) / 2 + 1, r, x, v, t);
sg[id][t] = sg[id * 2][t] + sg[id * 2 + 1][t];
}
int main() {
scanf("%lld %lld %lld %lld %lld", &n, &k, &a, &b, &q);
for (int i = 0; i < q; i++) {
int t;
scanf(" %d", &t);
if (t == 1) {
int x;
long long y;
scanf(" %d %lld", &x, &y);
updt(1, 1, n, x, y, 1);
updt(1, 1, n, x, y, 0);
} else {
int x;
scanf(" %d", &x);
cout << querry(1, 1, n, 1, x - 1, 0) + querry(1, 1, n, x + k, n, 1)
<< endl;
;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = (1 << 18);
int a, b;
struct Tree {
vector<pair<int, int> > t;
Tree() { t.resize(max_n * 2, {0, 0}); }
int get(int l, int r, int tl, int tr, int v, int type) {
if (l <= tl && tr <= r) {
if (type) {
return t[v].first;
} else {
return t[v].second;
}
}
if (l > tr || r < tl) {
return 0;
}
return get(l, r, tl, (tl + tr) / 2, v * 2, type) +
get(l, r, (tl + tr) / 2 + 1, tr, v * 2 + 1, type);
}
void update(int c, int x) {
c += max_n;
t[c].first = min(t[c].first + x, a);
t[c].second = min(t[c].second + x, b);
c /= 2;
while (c) {
t[c].first = t[c * 2].first + t[c * 2 + 1].first;
t[c].second = t[c * 2].second + t[c * 2 + 1].second;
c /= 2;
}
}
};
int main() {
int n, k, q;
cin >> n >> k >> a >> b;
cin >> q;
int type;
Tree T;
for (int i = 0; i < q; i++) {
cin >> type;
if (type == 1) {
int cnt, num;
cin >> num >> cnt;
T.update(num - 1, cnt);
} else {
int p;
cin >> p;
p--;
int res = 0;
res += T.get(0, p - 1, 0, max_n - 1, 1, 0);
res += T.get(p + k, max_n - 1, 0, max_n - 1, 1, 1);
cout << res << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
int n, k, a, b;
int A[N], B[N];
long long ft[2][N];
int LSOne(int b) { return b & (-b); }
long long rsq(int b, int idx) {
if (b <= 0) return 0;
long long s = 0;
for (; b; b -= LSOne(b)) s += ft[idx][b];
return s;
}
void adjust(int p, int v, int idx) {
for (; p <= n; p += LSOne(p)) ft[idx][p] += v;
}
int main(int argc, char *args[]) {
int q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
int t, x, y;
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &y);
if (B[x] < b) {
int tmp = min(b - B[x], y);
B[x] += tmp;
adjust(x, tmp, 0);
}
if (A[x] < a) {
int tmp = min(a - A[x], y);
A[x] += tmp;
adjust(x, tmp, 1);
}
continue;
}
scanf("%d", &x);
long long ans = rsq(n, 1) - rsq(x + k - 1, 1) + rsq(x - 1, 0);
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct FastReader {
FastReader operator>>(int &x) const {
scanf("%d", &x);
return *this;
}
FastReader operator>>(signed long long &x) const {
scanf("%I64d", &x);
return *this;
}
FastReader operator>>(double &x) const {
scanf("%lf", &x);
return *this;
}
FastReader operator>>(char &x) const {
do {
x = getchar();
} while (x == ' ' || x == '\n');
return *this;
}
FastReader operator>>(char *x) const {
scanf("%s", x);
return *this;
}
} in;
struct FastWriter {
FastWriter operator<<(const int x) const {
printf("%d", x);
return *this;
}
FastWriter operator<<(const signed long long x) const {
printf("%I64d", x);
return *this;
}
FastWriter operator<<(const double x) const {
printf("%lf", x);
return *this;
}
FastWriter operator<<(const char x) const {
putchar(x);
return *this;
}
FastWriter operator<<(const char *x) const {
printf("%s", x);
return *this;
}
FastWriter operator<<(const string x) const { return operator<<(x.c_str()); }
} out;
template <class T>
T sqr(T x) {
return x * x;
}
const int N = (int)2e5 + 11;
int n, k, a, b, q;
int t, x, y;
signed long long t1[N * 4], t2[N * 4];
void update1(int v, int l, int r, int i, int x) {
if (l >= r) return;
if (l + 1 == r)
t1[v] = min(t1[v] + x, (signed long long)a);
else {
int m = (l + r) / 2;
if (i < m)
update1(v * 2 + 1, l, m, i, x);
else
update1(v * 2 + 2, m, r, i, x);
t1[v] = t1[v * 2 + 1] + t1[v * 2 + 2];
}
}
void update2(int v, int l, int r, int i, int x) {
if (l >= r) return;
if (l + 1 == r)
t2[v] = min(t2[v] + x, (signed long long)b);
else {
int m = (l + r) / 2;
if (i < m)
update2(v * 2 + 1, l, m, i, x);
else
update2(v * 2 + 2, m, r, i, x);
t2[v] = t2[v * 2 + 1] + t2[v * 2 + 2];
}
}
signed long long query1(int v, int l, int r, int lq, int rq) {
if (l >= r || lq >= rq) return 0;
if (l == lq && r == rq) return t1[v];
int m = (l + r) / 2;
signed long long f = query1(v * 2 + 1, l, m, lq, min(rq, m));
signed long long s = query1(v * 2 + 2, m, r, max(lq, m), rq);
return f + s;
}
signed long long query2(int v, int l, int r, int lq, int rq) {
if (l >= r || lq >= rq) return 0;
if (l == lq && r == rq) return t2[v];
int m = (l + r) / 2;
signed long long f = query2(v * 2 + 1, l, m, lq, min(rq, m));
signed long long s = query2(v * 2 + 2, m, r, max(lq, m), rq);
return f + s;
}
int main() {
in >> n >> k >> a >> b >> q;
int m = n + 2;
for (int i = 0; i < q; i++) {
in >> t;
if (t == 1) {
in >> x >> y;
update1(0, 0, m, x, y);
update2(0, 0, m, x, y);
} else {
in >> x;
signed long long f = query2(0, 0, m, 0, x);
signed long long s = query1(0, 0, m, x + k, m);
out << (f + s) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class SumSegmentTree {
int *st;
int n;
int getMid(int s, int e) { return s + (e - s) / 2; }
int constructSTUtil(int arr[], int ss, int se, int *st, int si) {
if (ss == se) {
st[si] = arr[ss];
return st[si];
}
int mid = getMid(ss, se);
st[si] = constructSTUtil(arr, ss, mid, st, si * 2 + 1) +
constructSTUtil(arr, mid + 1, se, st, si * 2 + 2);
return st[si];
}
void updateValue(int *st, int ss, int se, int i, int v, int si) {
if (i < ss || i > se) return;
if (ss == se) {
st[si] = v;
return;
}
int mid = getMid(ss, se);
updateValue(st, ss, mid, i, v, si * 2 + 1);
updateValue(st, mid + 1, se, i, v, si * 2 + 2);
st[si] = st[si * 2 + 1] + st[si * 2 + 2];
}
int getVector(int *st, int ss, int se, int qs, int qe, int si) {
if (qs <= ss && qe >= se) {
return st[si];
}
if (se < qs || ss > qe) {
return 0;
}
int mid = getMid(ss, se);
return getVector(st, ss, mid, qs, qe, si * 2 + 1) +
getVector(st, mid + 1, se, qs, qe, si * 2 + 2);
}
public:
SumSegmentTree(int arr[], int n) {
int x = (int)(ceil(log2(n)));
int max_size = 2 * (int)pow(2, x) - 1;
this->st = new int[max_size];
this->n = n;
constructSTUtil(arr, 0, n - 1, st, 0);
}
void update(int i, int v) {
this->updateValue(this->st, 0, this->n - 1, i, v, 0);
}
int query(int qs, int qe) {
return this->getVector(this->st, 0, this->n - 1, qs, qe, 0);
}
};
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
int *v1 = new int[n];
int *v2 = new int[n];
for (int i = 0; i < n; i++) {
v1[i] = 0;
v2[i] = 0;
}
SumSegmentTree s1 = SumSegmentTree(v1, n);
SumSegmentTree s2 = SumSegmentTree(v2, n);
for (int i = 0; i < q; i++) {
int l;
cin >> l;
if (l == 1) {
int d, v;
cin >> d >> v;
d--;
int novo_v1 = min(b, v1[d] + v);
v1[d] = novo_v1;
s1.update(d, novo_v1);
int novo_v2 = min(a, v2[d] + v);
v2[d] = novo_v2;
s2.update(d, novo_v2);
} else {
int p;
cin >> p;
p--;
int resposta = 0;
if (p > 0) resposta += s1.query(0, p - 1);
if (p + k < n) resposta += s2.query(p + k, n);
cout << resposta << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 256 * 1024;
int cnt[MXN];
int t1[MXN];
int t2[MXN];
int n, k, a, b, q;
static void init() {
memset(cnt, 0, sizeof(cnt));
memset(t1, 0, sizeof(t1));
memset(t2, 0, sizeof(t2));
}
void update(int day, int v) {
int addA = max(0, min(a - cnt[day], v));
int addB = max(0, min(b - cnt[day], v));
cnt[day] += v;
for (int i = day; i < MXN; i |= (i + 1)) {
t1[i] += addA;
t2[i] += addB;
}
}
int query(int p) {
int ans = 0;
for (int i = p - 1; i > 0; i = (i & (i + 1)) - 1) ans += t2[i];
for (int i = MXN - 1; i > 0; i = (i & (i + 1)) - 1) ans += t1[i];
for (int i = p + k - 1; i > 0; i = (i & (i + 1)) - 1) ans -= t1[i];
return ans;
}
int main() {
while (scanf("%d %d %d %d %d", &n, &k, &a, &b, &q) == 5) {
init();
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int day, v;
scanf("%d %d", &day, &v);
update(day, v);
}
if (type == 2) {
int p;
scanf("%d", &p);
printf("%d\n", query(p));
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct fenwin_tree {
long long sum[200200];
void add(int x, int val) {
while (x < 200200) {
sum[x] += val, x += x & -x;
}
}
long long calc(int x) {
long long rlt = 0;
while (x) {
rlt += sum[x], x -= x & -x;
}
return rlt;
}
} A, B;
int n, k, a, b, q, type, val, d, p, f[200200], g[200200];
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &d, &val);
int x = min(val, b - f[d]);
A.add(d, x), f[d] += x;
int y = min(val, a - g[d]);
B.add(d, y), g[d] += y;
} else {
scanf("%d", &p);
printf("%I64d\n", A.calc(p - 1) + B.calc(n) - B.calc(p + k - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool getmin(T *a, const T &b) {
if (b < *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline bool getmax(T *a, const T &b) {
if (b > *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline void read(T *a) {
char c;
while (isspace(c = getchar())) {
}
bool flag = 0;
if (c == '-')
flag = 1, *a = 0;
else
*a = c - 48;
while (isdigit(c = getchar())) *a = *a * 10 + c - 48;
if (flag) *a = -*a;
}
const int mo = 1000000007;
template <class T>
T pow(T a, T b, int c = mo) {
T res = 1;
for (T i = 1; i <= b; i <<= 1, a = 1LL * a * a % c)
if (b & i) res = 1LL * res * a % c;
return res;
}
const int N = 201000;
int treeA[N * 4], treeB[N * 4];
int a, b, n, m, k;
void update(int u) {
treeA[u] = treeA[u * 2] + treeA[u * 2 + 1];
treeB[u] = treeB[u * 2] + treeB[u * 2 + 1];
}
void modify(int u, int L, int R, int p, int d) {
if (L == R) {
treeA[u] = min(treeA[u] + d, a);
treeB[u] = min(treeB[u] + d, b);
return;
}
int mid = (L + R) >> 1;
if (p <= mid)
modify(u * 2, L, mid, p, d);
else
modify(u * 2 + 1, mid + 1, R, p, d);
update(u);
}
int queryA(int u, int L, int R, int l, int r) {
if (l > r) return 0;
if (l <= L && r >= R) {
return treeA[u];
}
int mid = (L + R) >> 1;
if (r <= mid)
return queryA(u * 2, L, mid, l, r);
else if (l > mid)
return queryA(u * 2 + 1, mid + 1, R, l, r);
else
return queryA(u * 2, L, mid, l, mid) +
queryA(u * 2 + 1, mid + 1, R, mid + 1, r);
}
int queryB(int u, int L, int R, int l, int r) {
if (l > r) return 0;
if (l <= L && r >= R) {
return treeB[u];
}
int mid = (L + R) >> 1;
if (r <= mid)
return queryB(u * 2, L, mid, l, r);
else if (l > mid)
return queryB(u * 2 + 1, mid + 1, R, l, r);
else
return queryB(u * 2, L, mid, l, mid) +
queryB(u * 2 + 1, mid + 1, R, mid + 1, r);
}
int main() {
cin >> n >> k >> a >> b >> m;
while (m--) {
int com, x, y;
read(&com);
read(&x);
if (com == 1) {
read(&y);
modify(1, 1, n, x, y);
} else {
printf("%d\n", queryB(1, 1, n, 1, x - 1) + queryA(1, 1, n, x + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
struct node {
int l, r, flag;
long long num[4];
} tree[201000 * 4];
long long a, b;
void Build(int rt, int l, int r) {
tree[rt].l = l, tree[rt].r = r;
for (int i = 0; i < 3; i++) tree[rt].num[i] = 0;
if (l == r) return;
int mid = (l + r) / 2;
Build(rt << 1, l, mid);
Build(rt << 1 | 1, mid + 1, r);
}
void UP(int rt) {
for (int i = 0; i < 3; i++)
tree[rt].num[i] = tree[rt << 1].num[i] + tree[rt << 1 | 1].num[i];
}
void Update(int rt, int k, long long e) {
if (tree[rt].l == tree[rt].r) {
tree[rt].num[0] = min(tree[rt].num[0] + e, b);
tree[rt].num[1] = min(tree[rt].num[1] + e, a);
return;
}
int mid = (tree[rt].l + tree[rt].r) / 2;
if (k <= mid)
Update(rt << 1, k, e);
else
Update(rt << 1 | 1, k, e);
UP(rt);
}
long long Query(int rt, int l, int r, long long e) {
if (l > r) return 0;
if (tree[rt].l == l && tree[rt].r == r) return tree[rt].num[e];
int mid = (tree[rt].l + tree[rt].r) / 2;
if (r <= mid)
return Query(rt << 1, l, r, e);
else if (l > mid)
return Query(rt << 1 | 1, l, r, e);
else
return Query(rt << 1, l, mid, e) + Query(rt << 1 | 1, mid + 1, r, e);
}
int main() {
int n, k, q;
while (scanf("%d %d %I64d %I64d %d", &n, &k, &a, &b, &q) != EOF) {
Build(1, 1, n);
while (q--) {
long long x, y, z, ans1, ans2;
scanf("%I64d", &x);
if (x == 1) {
scanf("%I64d %I64d", &y, &z);
Update(1, y, z);
} else {
scanf("%I64d", &y);
ans1 = Query(1, 1, y - 1, 0);
ans2 = Query(1, y + k, n, 1);
printf("%I64d\n", ans1 + ans2);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
int seg[MAX * 4][2], n, k, a, b, q, ar[MAX];
void upd(int x, int s = 0, int e = n, int id = 0) {
if (e - s == 1) {
seg[id][0] = min(ar[s], a), seg[id][1] = min(ar[s], b);
return;
}
int mid = s + e >> 1;
if (x < mid)
upd(x, s, mid, id * 2 + 1);
else
upd(x, mid, e, id * 2 + 2);
seg[id][0] = seg[id * 2 + 1][0] + seg[id * 2 + 2][0];
seg[id][1] = seg[id * 2 + 1][1] + seg[id * 2 + 2][1];
}
pair<int, int> gt(int l, int r, int s = 0, int e = n, int id = 0) {
pair<int, int> ret = {0, 0};
if (r <= s || e <= l) return ret;
if (l <= s && e <= r) return {seg[id][0], seg[id][1]};
int mid = s + e >> 1;
pair<int, int> le = gt(l, r, s, mid, id * 2 + 1),
ri = gt(l, r, mid, e, id * 2 + 2);
ret = {le.first + ri.first, le.second + ri.second};
return ret;
}
int main() {
cin >> n >> k >> a >> b >> q, n++;
while (q--) {
int t, d, a;
cin >> t >> d;
if (t == 1)
cin >> a, ar[d] += a, upd(d);
else
cout << gt(0, d).second + gt(d + k, n).first << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ta, tb;
int n, k, a, b, q;
void builda(int node, int s, int e, int idx, int val) {
if (s == e) {
ta[node] = min(ta[node] + val, a);
} else {
int mid = (s + e) / 2;
if ((s <= idx) && (mid >= idx))
builda(2 * node, s, mid, idx, val);
else
builda(2 * node + 1, mid + 1, e, idx, val);
ta[node] = ta[2 * node] + ta[2 * node + 1];
}
}
void buildb(int node, int s, int e, int idx, int val) {
if (s == e) {
tb[node] = min(tb[node] + val, b);
} else {
int mid = (s + e) / 2;
if ((s <= idx) && (mid >= idx))
buildb(2 * node, s, mid, idx, val);
else
buildb(2 * node + 1, mid + 1, e, idx, val);
tb[node] = tb[2 * node] + tb[2 * node + 1];
}
}
int quarya(int node, int s, int e, int l, int r) {
if ((r < s) || (e < l))
return 0;
else if ((l <= s) && (e <= r))
return ta[node];
int mid = (s + e) / 2;
int c1 = quarya(2 * node, s, mid, l, r);
int c2 = quarya(2 * node + 1, mid + 1, e, l, r);
return c1 + c2;
}
int quaryb(int node, int s, int e, int l, int r) {
if ((r < s) || (e < l))
return 0;
else if ((l <= s) && (e <= r))
return tb[node];
int mid = (s + e) / 2;
int c1 = quaryb(2 * node, s, mid, l, r);
int c2 = quaryb(2 * node + 1, mid + 1, e, l, r);
return c1 + c2;
}
int main() {
cin >> n >> k >> a >> b >> q;
ta.resize(n * 4);
tb.resize(n * 4);
int x, y, z;
for (int i = 0; i < q; i++) {
cin >> x;
if (x == 1) {
cin >> y >> z;
builda(1, 1, n, y, min(a, z));
buildb(1, 1, n, y, min(b, z));
} else {
cin >> y;
cout << quaryb(1, 1, n, 1, y - 1) + quarya(1, 1, n, y + k, n) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long aa[200200];
long long tree[600200];
long long tree_b[600200];
void init(int b, int e, int node) {
if (b == e) {
tree[node] = aa[b];
return;
}
int mid = (b + e) / 2;
int left = node * 2;
int right = node * 2 + 1;
init(b, mid, left);
init(mid + 1, e, right);
tree[node] = tree[left] + tree[right];
}
void update(int node, int b, int e, int i, long long new_val) {
if (i > e || i < b) return;
if (b >= i && e <= i) {
tree[node] = new_val;
return;
}
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
update(left, b, mid, i, new_val);
update(right, mid + 1, e, i, new_val);
tree[node] = tree[left] + tree[right];
}
long long query(int node, int b, int e, int i, int j) {
if (i > e || j < b) return 0;
if (b >= i && e <= j) return tree[node];
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
long long p1 = query(left, b, mid, i, j);
long long p2 = query(right, mid + 1, e, i, j);
return p1 + p2;
}
void update_b(int node, int b, int e, int i, long long new_val) {
if (i > e || i < b) return;
if (b >= i && e <= i) {
tree_b[node] = new_val;
return;
}
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
update_b(left, b, mid, i, new_val);
update_b(right, mid + 1, e, i, new_val);
tree_b[node] = tree_b[left] + tree_b[right];
}
long long query_b(int node, int b, int e, int i, int j) {
if (i > e || j < b) return 0;
if (b >= i && e <= j) return tree_b[node];
int left = node * 2;
int right = node * 2 + 1;
int mid = (b + e) / 2;
long long p1 = query_b(left, b, mid, i, j);
long long p2 = query_b(right, mid + 1, e, i, j);
return p1 + p2;
}
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < n * 3; i++) {
tree[i] = 0;
tree_b[i] = 0;
}
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
long long order;
int day;
scanf("%d %I64d", &day, &order);
int dayy = day;
if (aa[dayy] + order >= a) {
update(1, 1, n, day, a);
} else {
update(1, 1, n, day, aa[dayy] + order);
}
if (aa[dayy] + order >= b) {
update_b(1, 1, n, day, b);
} else {
update_b(1, 1, n, day, aa[dayy] + order);
}
aa[dayy] = aa[dayy] + order;
} else {
int start_day;
scanf("%d", &start_day);
long long bal =
query_b(1, 1, n, 0, start_day - 1) + query(1, 1, n, start_day + k, n);
printf("%I64d\n", bal);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int pow2 = (1 << 20);
struct SegmentTree {
int tree[pow2 * 2];
SegmentTree() { memset(tree, 0, sizeof(tree)); }
void addValue(int pos, int value) {
int v = pos + pow2;
tree[v] += value;
while (v > 1) {
v /= 2;
tree[v] = tree[2 * v] + tree[2 * v + 1];
}
}
int getSum(int a, int b, int v, int l, int r) {
if (l >= a && r <= b) return tree[v];
if (l > b || r < a) return 0;
int m = (l + r) / 2;
return getSum(a, b, 2 * v, l, m) + getSum(a, b, 2 * v + 1, m + 1, r);
}
int getSum(int a, int b) {
if (a > b) return 0;
return getSum(a, b, 1, 0, pow2 - 1);
}
};
SegmentTree A, B;
int cnt[pow2];
int n, k, a, b, q;
void changeTree(SegmentTree &tree, int pos, int old, int nw, int border) {
tree.addValue(pos, -min(old, border));
tree.addValue(pos, min(border, nw));
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, add;
scanf("%d%d", &d, &add);
changeTree(A, d, cnt[d], cnt[d] + add, a);
changeTree(B, d, cnt[d], cnt[d] + add, b);
cnt[d] += add;
} else {
int p;
scanf("%d", &p);
int ans = B.getSum(1, p - 1) + A.getSum(p + k, n);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, k, a, b, q;
long long tree[2][N << 1];
void update(int i, int x) {
tree[0][i + n] = min(tree[0][i + n] + x, (long long)a);
tree[1][i + n] = min(tree[1][i + n] + x, (long long)b);
for (i += n; i; i >>= 1) {
tree[0][i >> 1] = tree[0][i] + tree[0][i ^ 1];
tree[1][i >> 1] = tree[1][i] + tree[1][i ^ 1];
}
}
long long query(long long tree[], int a, int b) {
long long ans = 0;
for (a += n, b += n + 1; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
ans += tree[a++];
}
if (b & 1) {
ans += tree[--b];
}
}
return ans;
}
int cmd, x, y;
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &cmd);
if (cmd == 1) {
scanf("%d%d", &x, &y);
update(x - 1, y);
} else {
scanf("%d", &x);
--x;
printf("%I64d\n",
query(tree[0], x + k, n - 1) + query(tree[1], 0, x - 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int debug = 0;
const int inf = 1000000000;
int full[212345];
int half[212345];
int fullBox[500];
int halfBox[500];
int n, k, a, b, q;
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 1; i <= n; i++) full[i] = half[i] = 0;
while (q--) {
int t, d, amount;
cin >> t >> d;
if (t == 1) {
cin >> amount;
int newValue = half[d] + amount;
if (newValue > b) newValue = b;
int diff = newValue - half[d];
int boxId = (d - 1) / 500 + 1;
halfBox[boxId] += diff;
half[d] = newValue;
newValue = full[d] + amount;
if (newValue > a) newValue = a;
diff = newValue - full[d];
fullBox[boxId] += diff;
full[d] = newValue;
} else {
int dd = d - 1;
int sum = 0;
while (dd > 0) {
if (dd % 500 == 0) {
int boxId = (dd - 1) / 500 + 1;
sum += halfBox[boxId];
dd -= 500;
} else {
sum += half[dd];
dd--;
}
}
dd = d + k;
while (dd <= n) {
if ((dd - 1) % 500 == 0) {
int boxId = (dd - 1) / 500 + 1;
sum += fullBox[boxId];
dd += 500;
} else {
sum += full[dd];
dd++;
}
}
cout << sum << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree[2][3 * 200007], a, b;
void upd(long long n, long long l, long long r, long long i, long long v) {
if (l == r && l == i) {
tree[0][n] = min(b, tree[0][n] + v);
tree[1][n] = min(a, tree[1][n] + v);
return;
}
if (i < l || i > r) return;
upd(2 * n, l, ((l + r) / 2), i, v);
upd(2 * n + 1, ((l + r) / 2) + 1, r, i, v);
tree[0][n] = tree[0][2 * n] + tree[0][2 * n + 1];
tree[1][n] = tree[1][2 * n] + tree[1][2 * n + 1];
}
long long qry(long long t, long long n, long long l, long long r, long long i,
long long j) {
if (l > j || r < i) return 0;
if (l >= i && r <= j) return tree[t][n];
return (qry(t, 2 * n, l, ((l + r) / 2), i, j) +
qry(t, 2 * n + 1, ((l + r) / 2) + 1, r, i, j));
}
int main() {
memset(tree, 0, sizeof(tree));
long long n, k, q;
scanf("%lld %lld", &n, &k);
scanf("%lld %lld", &a, &b);
scanf("%lld", &q);
while (q--) {
long long op;
scanf("%lld", &op);
if (op == 1) {
long long d, v;
scanf("%lld %lld", &d, &v);
upd(1, 1, n, d, v);
} else {
long long p;
scanf("%lld", &p);
long long ans = qry(0, 1, 1, n, 1, p - 1) + qry(1, 1, 1, n, p + k, n);
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int bt1[200011];
long long int bt2[200011];
long long int as[200011];
long long int bs[200011];
int n;
void update(int ind, int val, long long int *bt) {
while (ind <= n) {
bt[ind] += val;
ind += (ind & -ind);
}
}
long long int query(int ind, long long int *bt) {
long long int ans = 0;
while (ind > 0) {
ans += bt[ind];
ind -= (ind & -ind);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int k, a, b, q;
cin >> n >> k >> b >> a >> q;
int t, p, d, ai;
while (q--) {
cin >> t;
if (t == 1) {
cin >> d >> ai;
update(d, -as[d], bt1);
as[d] += ai;
as[d] = min(as[d], a);
update(d, as[d], bt1);
update(d, -bs[d], bt2);
bs[d] += ai;
bs[d] = min(bs[d], b);
update(d, bs[d], bt2);
} else {
cin >> p;
long long int ans =
query(p - 1, bt1) + query(n, bt2) - query(p + k - 1, bt2);
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const int nax = 2e5 + 5;
int n, k, a, b, q, d, x, poz, typ, res;
int d_pref[nax], d_suf[nax], val_pref[nax], val_suf[nax];
int magic(int x) { return x & -x; }
void insert_pref(int poz, int val) {
int r = min(b, val_pref[poz] + val) - val_pref[poz];
val_pref[poz] += r;
while (poz <= n) {
d_pref[poz] += r;
poz += magic(poz);
}
}
void insert_suf(int poz, int val) {
if (poz == 0) return;
int r = min(a, val_suf[poz] + val) - val_suf[poz];
val_suf[poz] += r;
while (poz) {
d_suf[poz] += r;
poz -= magic(poz);
}
}
int query_pref(int poz) {
if (poz == 0) return 0;
int res = 0;
while (poz) {
res += d_pref[poz];
poz -= magic(poz);
}
return res;
}
int query_suf(int poz) {
int res = 0;
while (poz <= n) {
res += d_suf[poz];
poz += magic(poz);
}
return res;
}
void insert(int poz, int val) {
insert_pref(poz, val);
insert_suf(poz, val);
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = (0); i <= ((q)-1); ++i) {
scanf("%d", &typ);
if (typ == 1) {
scanf("%d%d", &d, &x);
insert(d, x);
} else {
scanf("%d", &poz);
res = query_pref(poz - 1) + query_suf(poz + k);
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 200100;
using namespace std;
struct node {
int l, r;
int num1, num2;
} tree[maxn << 2];
int n, k, a, b, q;
void build(int l, int r, int cur) {
tree[cur].l = l;
tree[cur].r = r;
tree[cur].num1 = tree[cur].num2 = 0;
if (l == r) return;
int mid = (r + l) >> 1;
build(l, mid, cur << 1);
build(mid + 1, r, cur << 1 | 1);
}
void update(int tar, int cur, int val) {
if (tree[cur].l == tree[cur].r) {
tree[cur].num1 = min(tree[cur].num1 + val, a);
tree[cur].num2 = min(tree[cur].num2 + val, b);
return;
}
if (tar <= tree[cur * 2].r)
update(tar, cur * 2, val);
else
update(tar, cur * 2 + 1, val);
tree[cur].num1 = tree[cur * 2].num1 + tree[cur * 2 + 1].num1;
tree[cur].num2 = tree[cur * 2].num2 + tree[cur * 2 + 1].num2;
}
int query(int pl, int pr, int cur, int fg) {
if (pl <= tree[cur].l && tree[cur].r <= pr) {
if (fg)
return tree[cur].num1;
else
return tree[cur].num2;
}
int res = 0;
if (pl <= tree[cur * 2].r) res += query(pl, pr, cur * 2, fg);
if (pr >= tree[cur * 2 + 1].l) res += query(pl, pr, cur * 2 + 1, fg);
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
build(1, n, 1);
while (q--) {
int op, x, y;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &y);
update(x, 1, y);
} else {
scanf("%d", &x);
if (x > 1 && x + k <= n)
printf("%d\n", query(1, x - 1, 1, 0) + query(x + k, n, 1, 1));
else if (x + k <= n)
printf("%d\n", query(x + k, n, 1, 1));
else if (x > 1)
printf("%d\n", query(1, x - 1, 1, 0));
else
printf("0\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int MaxVal = int(1e6);
long long tree[int(1e6 + 6)][2];
long long read(int idx, int r) {
long long sum = 0;
while (idx > 0) {
sum += tree[idx][r];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val, int r) {
while (idx <= MaxVal) {
tree[idx][r] += val;
idx += (idx & -idx);
}
}
int main() {
int n, k, a, b, q, D, A, p, Q;
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> Q;
if (Q == 1) {
cin >> D >> A;
update(D, min(A, b), 0);
long long p1 = read(D, 0), p2 = read(D - 1, 0);
if (p1 - p2 > b) update(D, p2 - p1 + b, 0);
update(D, min(A, a), 1);
p1 = read(D, 1), p2 = read(D - 1, 1);
if (p1 - p2 > a) update(D, p2 - p1 + a, 1);
} else {
cin >> p;
cout << read(p - 1, 0) + read(n, 1) - read(p + k - 1, 1) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, K, A, B, Q, RN;
vector<long long> segA, segB;
void addAA(int k) {
if (k == 0) return;
segA[k] = segA[2 * k] + segA[2 * k + 1];
addAA(k / 2);
}
void addA(int d, long long a) {
segA[d + RN] += a;
int k = (d + RN) / 2;
segA[k] = min(segA[2 * k], A) + min(segA[2 * k + 1], A);
addAA(k / 2);
}
void addBB(int k) {
if (k == 0) return;
segB[k] = segB[2 * k] + segB[2 * k + 1];
addBB(k / 2);
}
void addB(int d, long long a) {
segB[d + RN] += a;
int k = (d + RN) / 2;
segB[k] = min(segB[2 * k], B) + min(segB[2 * k + 1], B);
addBB(k / 2);
}
long long getA(int a, int b, int k = 1, int l = 0, int r = RN - 1) {
if (b < l || r < a) return 0;
if (k >= RN) return min(segA[k], A);
if (a <= l && r <= b) return segA[k];
return getA(a, b, 2 * k, l, (l + r) / 2) +
getA(a, b, 2 * k + 1, (l + r) / 2 + 1, r);
}
long long getB(int a, int b, int k = 1, int l = 0, int r = RN - 1) {
if (b < l || r < a) return 0;
if (k >= RN) return min(segB[k], B);
if (a <= l && r <= b) return segB[k];
return getB(a, b, 2 * k, l, (l + r) / 2) +
getB(a, b, 2 * k + 1, (l + r) / 2 + 1, r);
}
int main() {
cin >> N >> K >> A >> B >> Q;
if (N == 1) N++;
RN = 1;
while (RN < N) RN *= 2;
segA.resize(2 * RN, 0);
segB.resize(2 * RN, 0);
for (int q = 0; q < Q; q++) {
int type;
cin >> type;
if (type == 1) {
long long d, a;
cin >> d >> a;
addA(--d, a);
addB(d, a);
} else {
int p;
cin >> p;
long long ans = 0;
p--;
if (p != 0) ans += getB(0, p - 1);
if (p + K <= RN - 1) ans += getA(p + K, RN - 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000001000;
const int mod = 1000 * 1000 * 1000 + 7;
const int mod9 = 1000 * 1000 * 1000 + 9;
const double PI = 3.1415926535897932;
double sqr(double first) { return first * first; };
long double sqr(long double first) { return first * first; };
long long sqr(long long first) { return first * first; };
long long sqr(int first) { return first * 1LL * first; };
long long gcd(long long a, long long b) {
while (b) a %= b, swap(a, b);
return a;
}
long long bpm(long long a, long long n = -2, long long m = mod) {
n = n >= 0 ? n : m + n;
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
long long dist(long long x1, long long y1, long long x2, long long y2) {
return sqr(x1 - x2) + sqr(y1 - y2);
}
std::ostream& operator<<(std::ostream& os, pair<int, int> p) {
return os << "{" << p.first << " " << p.second << "}";
}
const int N = 200005;
vector<long long> t, t2;
int n;
void init(int nn) {
n = nn;
t.assign(n, 0);
t2.assign(n, 0);
}
long long sum(vector<long long>& t, int r) {
long long result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
result += t[r];
}
return result;
}
void inc(vector<long long>& t, int i, int delta) {
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
long long sum(vector<long long>& t, int l, int r) {
return sum(t, r) - sum(t, l - 1);
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
;
init(n + 1);
int a, b;
scanf("%d %d", &a, &b);
;
int tests;
scanf("%d", &tests);
for (int test = 0; test < tests; test++) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int d, first;
scanf("%d %d", &d, &first);
;
long long c = sum(t, d, d);
long long c2 = sum(t2, d, d);
inc(t, d, min(a - c, 1LL * first));
inc(t2, d, min(b - c2, 1LL * first));
} else {
int d;
scanf("%d", &d);
long long res = 0;
if (d > 1) {
res += sum(t2, 1, d - 1);
}
if (d + k <= n) {
res += sum(t, d + k, n);
}
cout << res << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int MAXA = 1e4 + 4;
const int MAXQ = 2e5 + 5;
int n, k, a, b, q;
void init() { scanf("%d%d%d%d%d", &n, &k, &a, &b, &q); }
struct BIT {
int dat[MAXN];
void init() { memset(dat, 0, sizeof(dat)); }
void add(int x, int v) {
for (int i = x; i <= n; i += i & -i) dat[i] += v;
}
int sum(int x) {
int res = 0;
for (int i = x; i > 0; i -= i & -i) res += dat[i];
return res;
}
} pre, suf;
int val[MAXN];
void solve() {
pre.init();
suf.init();
for (int i = 0; i < q; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, v;
scanf("%d%d", &d, &v);
int x = min<int>(b, val[d] + v) - min<int>(b, val[d]);
int y = min<int>(a, val[d] + v) - min<int>(a, val[d]);
val[d] += v;
pre.add(d, min<int>(b, x));
suf.add(n - d + 1, min<int>(a, y));
} else {
int p;
scanf("%d", &p);
int ans = 0;
if (p - 1 >= 1) ans += pre.sum(p - 1);
if (n - p + 1 - k >= 1) ans += suf.sum(n - p + 1 - k);
printf("%d\n", ans);
}
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
long long ans;
int n, k, a, b, q;
int val[maxn];
struct node {
long long sum[2];
node *lc, *rc;
void add(int l, int r, int p, int c) {
if (l == r) {
val[p] += c;
sum[0] = min(val[p], b);
sum[1] = min(val[p], a);
return;
}
int mid = l + r >> 1;
if (p <= mid)
lc->add(l, mid, p, c);
else
rc->add(mid + 1, r, p, c);
sum[0] = lc->sum[0] + rc->sum[0];
sum[1] = lc->sum[1] + rc->sum[1];
}
long long ask(int l, int r, int a, int b, int t) {
if (l >= a && r <= b) return sum[t];
int mid = l + r >> 1;
long long res = 0;
if (a <= mid) res += lc->ask(l, mid, a, b, t);
if (b > mid) res += rc->ask(mid + 1, r, a, b, t);
return res;
}
} ndl[maxn * 2], *root, *ns = ndl;
node *build(int l, int r) {
node *x = ++ns;
if (l < r) x->lc = build(l, l + r >> 1), x->rc = build(l + r + 2 >> 1, r);
return x;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
root = build(1, n);
for (int op, x, y, p, qi = 1; qi <= q; qi++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &y);
root->add(1, n, x, y);
} else {
scanf("%d", &p);
ans = 0;
if (p > 1) ans += root->ask(1, n, 1, p - 1, 0);
if (p + k <= n) ans += root->ask(1, n, p + k, n, 1);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b;
int orders[200007];
int can_produce[2][200007];
int tree[2][200007];
void update(int t, int i, int a) {
while (i < 200007) {
tree[t][i] += a;
i += i & (-i);
}
}
long long get(int t, int i) {
long long sum = 0;
while (i > 0) {
sum += tree[t][i];
i -= i & (-i);
}
return sum;
}
void add_order(int day, int val) {
orders[day] += val;
int old_can_produce[2] = {can_produce[0][day], can_produce[1][day]};
can_produce[0][day] = min(b, orders[day]);
can_produce[1][day] = min(a, orders[day]);
for (int t = 0; t < (2); t++) {
update(t, day, can_produce[t][day] - old_can_produce[t]);
}
}
int main() {
int q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < (q); i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int d, a;
scanf("%d%d", &d, &a);
add_order(d, a);
} else {
int p;
scanf("%d", &p);
printf("%d\n",
(int)(get(0, p - 1) + get(1, 200007 - 1) - get(1, p + k - 1)));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
vector<long long> tree;
FenwickTree(int n) : tree(n + 1) {}
long long sum(int pos) {
++pos;
int ret = 0;
while (pos > 0) {
ret += tree[pos];
pos &= (pos - 1);
}
return ret;
}
void add(int pos, long long val) {
++pos;
while (pos < tree.size()) {
tree[pos] += val;
pos += (pos & -pos);
}
}
};
const int mx = 2e5 + 5;
vector<long long> v(mx, 0), w(mx, 0);
int main() {
FenwickTree x(mx), y(mx);
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
long long di, ai;
cin >> di >> ai;
long long first = min(b - v[di], ai);
long long second = min(a - w[di], ai);
v[di] += first;
w[di] += second;
x.add(di, first);
y.add(di, second);
} else {
int p;
cin >> p;
cout << x.sum(p - 1) + y.sum(n) - y.sum(p + k - 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct BIT {
long long tree[200010];
BIT(void) {
for (int i = 0; i < 200010; i++) tree[i] = 0;
}
void update(int idx, long long val) {
while (idx < 200010) {
tree[idx] += val;
idx += (idx & (-idx));
}
}
long long query(int idx) {
long long ret = 0;
while (idx > 0) {
ret += tree[idx];
idx -= (idx & (-idx));
}
return ret;
}
long long query(int a, int b) {
if (a > b) return 0;
long long ret = query(b) - query(a - 1);
return ret;
}
};
BIT AA, BB, CC, DD;
int N, K, A, B, Q;
long long val[200010];
inline void ReadInput(void) {
scanf("%d", &N);
scanf("%d", &K);
scanf("%d", &A);
scanf("%d", &B);
scanf("%d", &Q);
}
inline void solve(void) {
while (Q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int d;
long long a;
scanf("%d", &d);
scanf("%lld", &a);
if (val[d] > A) {
AA.update(d, -1);
} else {
CC.update(d, -val[d]);
}
if (val[d] > B) {
BB.update(d, -1);
} else {
DD.update(d, -val[d]);
}
a += val[d];
val[d] = a;
if (a > A) {
AA.update(d, 1);
} else {
CC.update(d, a);
}
if (a > B) {
BB.update(d, 1);
} else {
DD.update(d, a);
}
} else {
int p;
scanf("%d", &p);
long long ans = 0, foo = 0, bar = 0;
foo = AA.query(p + K, 200010 - 1);
bar = BB.query(1, p - 1);
foo *= A;
bar *= B;
foo += CC.query(p + K, 200010 - 1);
bar += DD.query(1, p - 1);
ans = foo + bar;
printf("%lld\n", ans);
}
}
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
int N;
vector<int> A;
FenwickTree(int N) : N(N), A(N) {}
int rsq(int b) {
int sum = 0;
for (; b; b -= (b & (-b))) sum += A[b];
return sum;
}
int rsq(int a, int b) { return rsq(b) - (a == 1 ? 0 : rsq(a - 1)); }
void adjust(int k, int v) {
for (; k < A.size(); k += k & -k) A[k] += v;
}
};
int n, k, a, b, q;
int main() {
cin >> n >> k >> a >> b >> q;
FenwickTree bef(n + 5), aft(n + 5);
vector<int> befa(n + 1), afta(n + 1);
int i, j, k1;
for (int c = 0; c < q; c++) {
scanf("%d", &i);
if (i == 1) {
scanf("%d%d", &j, &k1);
int befk = min(k1 + befa[j], b);
int aftk = min(k1 + afta[j], a);
bef.adjust(j, befk - befa[j]);
befa[j] = befk;
aft.adjust(j, aftk - afta[j]);
afta[j] = aftk;
} else {
scanf("%d", &j);
printf("%d\n", bef.rsq(1, j - 1) + aft.rsq(k + j, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class BinaryIndexedTree {
public:
BinaryIndexedTree(int n) : n(n), data(n + 1, 0) {}
void add(int p, int x) {
while (p <= n) {
data[p] += x;
p += p & -p;
}
}
int get(int p) {
int result = 0;
while (p > 0) {
result += data[p];
p -= p & -p;
}
return result;
}
private:
int n;
vector<int> data;
};
void add(BinaryIndexedTree& bit, int day, int orders, int limit) {
int now = bit.get(day) - bit.get(day - 1);
bit.add(day, min(limit - now, orders));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
BinaryIndexedTree broken(n);
BinaryIndexedTree repared(n);
for (int query = 0; query < q; ++query) {
int type;
cin >> type;
if (type == 1) {
int d, a_;
cin >> d >> a_;
add(broken, d, a_, b);
add(repared, d, a_, a);
} else {
int p;
cin >> p;
cout << broken.get(p - 1) + repared.get(n) - repared.get(p + k - 1)
<< '\n';
}
}
}
|
#include <bits/stdc++.h>
const int maxn = 200007;
int low[maxn], high[maxn], val[maxn], n;
void update(int bit[], int k, int c) {
for (; k <= n; k += -k & k) {
bit[k] += c;
}
}
int sum(int bit[], int k) {
int ret = 0;
for (; k; k -= -k & k) {
ret += bit[k];
}
return ret;
}
int main() {
int k, a, b, q, op, l, r, x;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %d", &l, &x);
update(low, l, -1 * std::min(val[l], b));
update(high, l, -1 * std::min(val[l], a));
val[l] += x;
update(low, l, std::min(val[l], b));
update(high, l, std::min(val[l], a));
} else {
scanf("%d", &l);
r = l + k - 1;
int ans = sum(low, l - 1) + sum(high, n) - sum(high, r);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, Q;
int D[200020];
int T[2][2000020];
void Update(int v, int tl, int tr, int cur) {
if (tl > cur || tr <= cur) return;
if (tl == tr - 1) {
T[0][v] = min(a, D[tl]);
T[1][v] = min(b, D[tl]);
return;
}
Update(2 * v, tl, (tl + tr) / 2, cur);
Update(2 * v + 1, (tl + tr) / 2, tr, cur);
T[0][v] = T[0][2 * v] + T[0][2 * v + 1];
T[1][v] = T[1][2 * v] + T[1][2 * v + 1];
}
int Get(int v, int tl, int tr, int l, int r, int cur) {
if (tl >= r || tr <= l) return 0;
if (l <= tl && tr <= r) return T[cur][v];
int A, B;
A = Get(2 * v, tl, (tl + tr) / 2, l, r, cur);
B = Get(2 * v + 1, (tl + tr) / 2, tr, l, r, cur);
return A + B;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &b, &a, &Q);
while (Q--) {
int indicator;
scanf("%d", &indicator);
if (indicator == 1) {
int d, val;
scanf("%d%d", &d, &val);
D[d] += val;
Update(1, 1, n + 1, d);
} else {
int d;
scanf("%d", &d);
int ans = 0;
ans += Get(1, 1, n + 1, 1, d, 0);
ans += Get(1, 1, n + 1, d + k, n + 1, 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long c[2][maxn];
int lowbit(int s) { return s & (-s); }
void modify(int op, int i, long long x) {
while (i < maxn) c[op][i] += x, i += lowbit(i);
return;
}
long long query(int op, int i) {
long long ret = 0LL;
while (i > 0) ret += c[op][i], i -= lowbit(i);
return ret;
}
int main(void) {
int n, k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q--) {
int op, x, y;
scanf("%d", &op);
if (op == 1) {
scanf("%d %d", &x, &y);
modify(0, x, min(a - query(0, x) + query(0, x - 1), (long long)y));
modify(1, x, min(b - query(1, x) + query(1, x - 1), (long long)y));
} else {
scanf("%d", &x);
printf("%I64d\n", query(1, x - 1) + query(0, n) - query(0, x + k - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tree {
vector<int64_t> t;
int n;
tree(int _n) : n(_n), t(2 * _n) {}
void modify(int p, int64_t value) {
for (t[p += n] = value; p > 1; p >>= 1) t[p >> 1] = t[p] + t[p ^ 1];
}
int64_t query(int l, int r, int64_t res = 0) {
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += t[l++];
if (r & 1) res += t[--r];
}
return res;
}
};
void solve() {
int n, k, q;
int64_t a, b;
cin >> n >> k >> a >> b >> q;
tree ta(n), tb(n);
for (int i = 0; i < q; ++i) {
int t;
cin >> t;
if (t == 1) {
int d, v;
cin >> d >> v;
--d;
int64_t cura = ta.query(d, d + 1) + v;
int64_t curb = tb.query(d, d + 1) + v;
ta.modify(d, min(a, cura));
tb.modify(d, min(b, curb));
} else {
int p;
cin >> p;
--p;
int64_t ans = tb.query(0, p);
ans += ta.query(p + k, n);
cout << ans << endl;
}
}
}
int main() {
std::ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sizet = 1 << 19;
int T[sizet];
int TT[sizet];
void posa_T(int p, int x) {
T[p + sizet / 2] = x;
for (p = (p + sizet / 2) / 2; p > 0; p /= 2) {
T[p] = T[2 * p] + T[2 * p + 1];
}
}
void posa_TT(int p, int x) {
TT[p + sizet / 2] = x;
for (p = (p + sizet / 2) / 2; p > 0; p /= 2) {
TT[p] = TT[2 * p] + TT[2 * p + 1];
}
}
int Suma_T(int a, int b, int p = 1, int i = 0, int j = sizet / 2) {
if (a <= i && j <= b) return T[p];
if (j <= a || b <= i) return 0;
return Suma_T(a, b, 2 * p, i, (i + j) / 2) +
Suma_T(a, b, 2 * p + 1, (i + j) / 2, j);
}
int Suma_TT(int a, int b, int p = 1, int i = 0, int j = sizet / 2) {
if (a <= i && j <= b) return TT[p];
if (j <= a || b <= i) return 0;
return Suma_TT(a, b, 2 * p, i, (i + j) / 2) +
Suma_TT(a, b, 2 * p + 1, (i + j) / 2, j);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, a, b, q;
while (cin >> n >> k >> a >> b >> q) {
for (int i = 0; i < sizet; i++) {
T[i] = 0;
TT[i] = 0;
}
vector<int> aux(n);
for (int query = 0; query < q; query++) {
int tipus;
cin >> tipus;
if (tipus == 1) {
int d, upd;
cin >> d >> upd;
--d;
aux[d] += upd;
posa_T(d, min(b, aux[d]));
posa_TT(d, min(a, aux[d]));
} else {
int d;
cin >> d;
--d;
cout << Suma_T(0, d) + (d + k < n ? Suma_TT(d + k, n) : 0) << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
srand(time(NULL));
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
long long n, k, a, b, q;
long long C[811111];
long long D[811111];
void addC(long long v, long long l, long long r, long long i, long long val) {
if (l == r)
C[v] = min(C[v] + val, a);
else {
long long mid = (l + r) / 2;
if (i <= mid)
addC(2 * v, l, mid, i, val);
else
addC(2 * v + 1, mid + 1, r, i, val);
C[v] = C[2 * v] + C[2 * v + 1];
}
}
void addD(long long v, long long l, long long r, long long i, long long val) {
if (l == r)
D[v] = min(D[v] + val, b);
else {
long long mid = (l + r) / 2;
if (i <= mid)
addD(2 * v, l, mid, i, val);
else
addD(2 * v + 1, mid + 1, r, i, val);
D[v] = D[2 * v] + D[2 * v + 1];
}
}
long long getC(long long v, long long l, long long r, long long tl,
long long tr) {
if (tl > tr)
return 0;
else if (tl == l && tr == r)
return C[v];
else {
long long mid = (l + r) / 2;
return getC(v * 2, l, mid, tl, min(tr, mid)) +
getC(v * 2 + 1, mid + 1, r, max(tl, mid + 1), tr);
}
}
long long getD(long long v, long long l, long long r, long long tl,
long long tr) {
if (tl > tr)
return 0;
else if (tl == l && tr == r)
return D[v];
else {
long long mid = (l + r) / 2;
return getD(v * 2, l, mid, tl, min(tr, mid)) +
getD(v * 2 + 1, mid + 1, r, max(tl, mid + 1), tr);
}
}
int main(void) {
cin >> n >> k >> a >> b >> q;
for (long long i = 0; i < (long long)(q); i++) {
long long x;
cin >> x;
if (x == 1) {
long long d;
cin >> d >> x;
d--;
addC(1, 0, n - 1, d, min(x, a));
addD(1, 0, n - 1, d, min(x, b));
} else {
cin >> x;
x--;
long long res = 0;
res += getD(1, 0, n - 1, 0, x - 1);
res += getC(1, 0, n - 1, x + k, n - 1);
cout << res << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 10;
long long t[2][4 * N], a, b;
void update(int l, int r, int j, int pos, int val) {
if (r < pos || pos < l) return;
if (pos <= l && r <= pos) {
t[0][j] = min(a, t[0][j] + val);
t[1][j] = min(b, t[1][j] + val);
return;
}
int mid = (l + r) >> 1;
update(l, mid, 2 * j, pos, val);
update(mid + 1, r, 2 * j + 1, pos, val);
if (l != r) {
t[0][j] = t[0][2 * j] + t[0][2 * j + 1];
t[1][j] = t[1][2 * j] + t[1][2 * j + 1];
}
}
long long getSum(int l, int r, int j, int x, int y, int wh) {
if (r < x || y < l) return 0LL;
if (x <= l && r <= y) {
return t[wh][j];
}
int mid = (l + r) >> 1;
long long X = getSum(l, mid, (j << 1), x, y, wh);
long long Y = getSum(mid + 1, r, ((j << 1) | 1), x, y, wh);
return X + Y;
}
int n, k, q;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
int di, ai;
cin >> di >> ai;
update(1, n, 1, di, ai);
} else {
int p;
cin >> p;
long long res = getSum(1, n, 1, 1, p - 1, 1);
res += getSum(1, n, 1, p + k, n, 0);
cout << res << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using lld = long double;
const ll oo = 0x3f3f3f3f;
const ll MOD = 1000000007;
const ll N = 2e5 + 100;
ll tree[2][N << 2];
ll n, k, a, b;
void upd(ll l, ll r, ll t, const ll idx, const ll val) {
if (l == r) {
tree[0][t] = min(a, tree[0][t] + val);
tree[1][t] = min(b, tree[1][t] + val);
return;
}
ll mid = (l + r) >> 1;
if (idx <= mid)
upd(l, mid, t << 1, idx, val);
else
upd(mid + 1, r, t << 1 | 1, idx, val);
for (ll o = 0; o < 2; o++) tree[o][t] = tree[o][t << 1] + tree[o][t << 1 | 1];
}
ll qry(ll l, ll r, ll t, ll ql, ll qr, ll o) {
if (l > qr || r < ql || r < l) return 0;
if (l >= ql && r <= qr) return tree[o][t];
ll mid = (l + r) >> 1;
return qry(l, mid, t << 1, ql, qr, o) +
qry(mid + 1, r, t << 1 | 1, ql, qr, o);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(tree, 0, sizeof tree);
cin >> n >> k >> a >> b;
ll q;
cin >> q;
while (q--) {
ll t;
cin >> t;
if (t == 2) {
ll x;
cin >> x;
cout << qry(0, n, 1, 0, max(-1LL, x - 1), 1) +
qry(0, n, 1, min(n + 1, x + k), n, 0);
cout << '\n';
} else {
ll di, ai;
cin >> di >> ai;
upd(0, n, 1, di, ai);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool mina(A &first, B second) {
return (first > second) ? (first = second, 1) : 0;
}
template <class A, class B>
inline bool maxa(A &first, B second) {
return (first < second) ? (first = second, 1) : 0;
}
const int MAXN = 2e5 + 5;
int N, K, A, B, Q;
int total[MAXN];
class SegmentTree {
public:
typedef struct segment_st {
int numa, numb;
int l, r;
} TreeNode;
vector<TreeNode> tree;
int N;
int tree_size;
vector<int> leaves;
SegmentTree(int n) { build_tree(n); }
int query(int ll, int rr, int limit) { return query(1, ll, rr, limit); }
void update(int at, int val) { internal_update(at, val); }
private:
void initialize_node(int at) {
tree[at].numa = 0;
tree[at].numb = 0;
}
void update_up(int at) {
int left = at + at;
int right = at + at + 1;
tree[at].numa = tree[left].numa + tree[right].numa;
tree[at].numb = tree[left].numb + tree[right].numb;
}
void update_result(int &res, int val) { res += val; }
void update_leaf_value(int at, int &val, int d) {
tree[at].numa = min(A, total[d]);
tree[at].numb = min(B, total[d]);
}
int query(int at, int ll, int rr, int limit) {
if (ll > tree[at].r || rr < tree[at].l) return 0;
if (ll <= tree[at].l && tree[at].r <= rr) {
if (limit == 0) {
return tree[at].numb;
} else {
return tree[at].numa;
}
} else {
int res = 0;
update_result(res, query(at + at, ll, rr, limit));
update_result(res, query(at + at + 1, ll, rr, limit));
return res;
}
}
void internal_update(int at, int &val) {
int tmp = at;
at = leaves[at];
update_leaf_value(at, val, tmp);
at >>= 1;
while (at) {
update_up(at);
at >>= 1;
}
}
void build_tree(int n) {
N = n;
int base = 1;
while (base < N) base <<= 1;
tree_size = base << 1;
leaves.resize(N + 1);
tree = vector<TreeNode>(tree_size);
init(1, 1, n);
}
void init(int at, int ll, int rr) {
tree[at].l = ll;
tree[at].r = rr;
initialize_node(at);
if (ll == rr) {
leaves[ll] = at;
} else {
int mid = (tree[at].l + tree[at].r) >> 1;
init(at + at, tree[at].l, mid);
init(at + at + 1, mid + 1, tree[at].r);
update_up(at);
}
}
};
int main() {
scanf("%d %d %d %d %d", &N, &K, &A, &B, &Q);
SegmentTree tree(N);
int c;
for (int(i) = 0; (i) < (Q); ++(i)) {
scanf("%d", &c);
if (c == 1) {
int d, a;
scanf("%d %d", &d, &a);
total[d] += a;
tree.update(d, a);
} else {
int p;
scanf("%d", &p);
int res = 0;
if (p - 1 >= 1) res += tree.query(1, p - 1, 0);
p += K;
if (p <= N) res += tree.query(p, N, 1);
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
int n, a, b;
int X[200010], Y[200010];
int Ba[200010], Bb[200010];
void update_a(int u, int first) {
int pre = X[u];
X[u] = min(a, X[u] + first);
int add = X[u] - pre;
for (; u; u -= u & -u) Ba[u] += add;
}
void update_b(int u, int first) {
int pre = Y[u];
Y[u] = min(b, Y[u] + first);
int add = Y[u] - pre;
for (; u <= n; u += u & -u) Bb[u] += add;
}
int calc_a(int u, int ans = 0) {
for (; u <= n; u += u & -u) ans += Ba[u];
return ans;
}
int calc_b(int u, int ans = 0) {
for (; u; u -= u & -u) ans += Bb[u];
return ans;
}
int main() {
int k, q;
gn(n, k);
gn(a, b, q);
while (q--) {
int t, first, second;
gn(t, first);
if (t == 1) {
gn(second);
update_a(first, second);
update_b(first, second);
} else
println(calc_b(first - 1) + calc_a(first + k));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 18;
const int SIZE = MAXN << 1;
int A, B;
int SEG[SIZE][2];
int query(int i, int a, int b, int cur = 1, int l = 0, int r = MAXN) {
if (b <= l || a >= r) return 0;
if (a <= l && b >= r) return SEG[cur][i];
int mid = (l + r) / 2;
return query(i, a, b, cur * 2, l, mid) + query(i, a, b, cur * 2 + 1, mid, r);
}
void update(int x, int v, int cur = 1, int l = 0, int r = MAXN) {
if (l + 1 == r) {
SEG[cur][0] = min(SEG[cur][0] + v, B);
SEG[cur][1] = min(SEG[cur][1] + v, A);
} else {
int mid = (l + r) / 2;
if (x < mid)
update(x, v, cur * 2, l, mid);
else
update(x, v, cur * 2 + 1, mid, r);
SEG[cur][0] = SEG[cur * 2][0] + SEG[cur * 2 + 1][0];
SEG[cur][1] = SEG[cur * 2][1] + SEG[cur * 2 + 1][1];
}
}
int main() {
ios_base::sync_with_stdio(0);
int N, K, Q;
cin >> N >> K >> A >> B >> Q;
for (int i = 0; i < Q; ++i) {
int t;
cin >> t;
if (t == 1) {
int d, v;
cin >> d >> v;
--d;
update(d, v);
} else {
int p;
cin >> p;
--p;
cout << query(0, 0, p) + query(1, p + K, N) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y);
bool isPrime(long long n);
long long modInv(long long a, long long b);
long long gcdExtended(long long a, long long b, long long *x, long long *y);
long long mpower(long long a, long long b, long long p);
bool sorted(vector<long long> v, long long n, long long strict);
const long long inf = (long long)1e17;
const long long N = (long long)3e6 + 5;
long long n, k, q, a, b;
pair<long long, long long> tree[N];
void update(long long ss, long long se, long long idx, long long val,
long long i) {
if (ss == se) {
tree[i].first += val;
tree[i].second += val;
tree[i].first = min(a, tree[i].first);
tree[i].second = min(b, tree[i].second);
return;
}
long long mid = (ss + se) >> 1;
if (idx <= mid)
update(ss, mid, idx, val, 2 * i);
else
update(mid + 1, se, idx, val, 2 * i + 1);
tree[i].first = tree[2 * i].first + tree[2 * i + 1].first;
tree[i].second = tree[2 * i].second + tree[2 * i + 1].second;
}
pair<long long, long long> query(long long ss, long long se, long long l,
long long r, long long i) {
if (l > r) return make_pair(0, 0);
if (l > se || r < ss) return make_pair(0, 0);
if (l <= ss && r >= se) return tree[i];
long long mid = (ss + se) >> 1;
pair<long long, long long> left = query(ss, mid, l, r, 2 * i);
pair<long long, long long> right = query(mid + 1, se, l, r, 2 * i + 1);
pair<long long, long long> ret;
ret.first = left.first + right.first;
ret.second = right.second + left.second;
return ret;
}
void solve() {
cin >> n >> k >> a >> b >> q;
for (long long i = 0; i < q; i++) {
long long t;
cin >> t;
if (t == 1) {
long long x, y;
cin >> x >> y;
update(1, n, x, y, 1);
} else {
long long d;
cin >> d;
pair<long long, long long> beg = query(1, n, 1, d - 1, 1);
pair<long long, long long> end = query(1, n, d + k, n, 1);
cout << beg.second + end.first << "\n";
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
clock_t start, end;
start = clock();
solve();
end = clock();
double time_taken = double(end - start) / (double)CLOCKS_PER_SEC;
return 0;
}
long long modInv(long long a, long long m) {
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
long long res = (x % m + m) % m;
return res;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long mpower(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
long long p = sqrt(n);
for (long long i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool sorted(vector<long long> v, long long n, long long strict) {
if (n <= 1) return 1;
for (long long i = 1; i < n; i++) {
if (strict) {
if (v[i] <= v[i - 1]) return 0;
} else {
if (v[i] < v[i - 1]) return 0;
}
}
return 1;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct fenwick {
vector<T> tree;
int n;
fenwick(int n) : n(n) { tree.resize(n + 1); }
void update(int a, T val) {
for (; a <= n; a += a & -a) {
tree[a] += val;
}
}
T query(int a) {
T res = 0;
for (; a > 0; a -= a & -a) {
res += tree[a];
}
return res;
}
int lower_bound(T k) {
int res = 0;
T cur = 0;
for (int i = 31 - __builtin_clz(n); i >= 0; --i) {
if (res + (1 << i) <= n && cur + tree[res + (1 << i)] < k) {
res += 1 << i;
cur += tree[res];
}
}
return res + 1;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
fenwick<int> before(n), after(n);
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x, y;
cin >> x >> y;
before.update(x, min(b - before.query(x) + before.query(x - 1), y));
after.update(x, min(a - after.query(x) + after.query(x - 1), y));
} else {
int p;
cin >> p;
cout << before.query(p - 1) + after.query(n) - after.query(p + k - 1)
<< "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class fenwick {
int *tree;
int length, max_el;
public:
fenwick(int size, int mxl) {
length = size + 5;
max_el = mxl;
tree = new int[length + 1];
for (int i = 0; i <= length; i++) {
tree[i] = 0;
}
}
int get(int index) {
int ans = 0;
for (int i = index; i > 0; i -= (i & -i)) {
ans += tree[i];
}
return ans;
}
void add(int index, int val) {
int cur = get(index) - get(index - 1);
int diff = min(val, max_el - cur);
for (int i = index; i <= length; i += (i & -i)) {
tree[i] += diff;
}
}
void ptree() {
for (int i = 1; i <= length; i++) {
cout << get(i) << " ";
}
cout << endl;
}
};
int main() {
int dayc, replen, frate, srate, queryc;
scanf("%d %d %d %d %d", &dayc, &replen, &frate, &srate, &queryc);
fenwick slow(dayc, srate);
fenwick fast(dayc, frate);
for (int i = 0; i < queryc; i++) {
int query;
scanf("%d", &query);
if (query == 1) {
int orderc, day;
scanf("%d %d", &day, &orderc);
slow.add(day, orderc);
fast.add(day, orderc);
} else {
int day;
scanf("%d", &day);
int ans =
slow.get(day - 1) + (fast.get(dayc) - fast.get(day + replen - 1));
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const long long LLINF = (long long)1e18;
const int LOG = 17;
const int N = (int)2e5 + 5;
const double PI = 3.141592653589793;
const double eps = 0.000005;
void operator delete(void* a) {}
void operator delete[](void* a) {}
int n, k, a, b, q;
int queries[N];
int pref[N], suff[N];
void add_pref(int x, int delta) {
for (; x < N; x |= x + 1) {
pref[x] += delta;
}
}
void add_suff(int x, int delta) {
x = N - x;
for (; x < N; x |= x + 1) {
suff[x] += delta;
}
}
int get_pref(int x) {
int ret = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) {
ret += pref[x];
}
return ret;
}
int get_suff(int x) {
int ret = 0;
x = N - x;
for (; x >= 0; x = (x & (x + 1)) - 1) {
ret += suff[x];
}
return ret;
}
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int type;
cin >> type;
if (type == 1) {
int d, x;
cin >> d >> x;
add_pref(d, -min(b, queries[d]));
add_suff(d, -min(a, queries[d]));
queries[d] += x;
add_pref(d, min(b, queries[d]));
add_suff(d, min(a, queries[d]));
} else {
int p;
cin >> p;
cout << get_pref(p - 1) + get_suff(p + k) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b;
const int N = 200005;
int n;
long long ta[2 * N];
long long tb[2 * N];
void modify(int p, long long value) {
int p2 = p;
for (p += n, ta[p] = min(a, ta[p] + value); p > 1; p >>= 1)
ta[p >> 1] = ta[p] + ta[p ^ 1];
p = p2;
for (p += n, tb[p] = min(b, tb[p] + value); p > 1; p >>= 1)
tb[p >> 1] = tb[p] + tb[p ^ 1];
}
long long querya(int l, int r) {
long long res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += ta[l++];
if (r & 1) res += ta[--r];
}
return res;
}
long long queryb(int l, int r) {
long long res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += tb[l++];
if (r & 1) res += tb[--r];
}
return res;
}
int main() {
int k, q;
scanf("%d%d%lld%lld%d", &n, &k, &a, &b, &q);
while (q--) {
int tt;
scanf("%d", &tt);
if (tt == 1) {
long long ai;
int di;
scanf("%d%lld", &di, &ai);
di--;
modify(di, ai);
} else {
int pi;
scanf("%d", &pi);
pi--;
long long ans = queryb(0, pi) + querya(pi + k, n);
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class Summator {
private:
int n;
vector<int> s;
inline int prev(int x) { return x & (x - 1); }
inline int next(int x) { return (x << 1) - (x & (x - 1)); }
public:
Summator(int n) {
this->n = n;
s.resize(n + 1, 0);
}
void modify(int pos, int diff) {
pos++;
int x = pos;
while (x <= n) {
s[x] += diff;
x = next(x);
}
}
int sum(int l, int r) {
l++;
r++;
int sum = 0;
int x = r;
while (x > 0) {
sum += s[x];
x = prev(x);
}
x = l - 1;
while (x > 0) {
sum -= s[x];
x = prev(x);
}
return sum;
}
};
int main() {
int n, k, A, B, q;
int key, d, x, p;
cin >> n >> k >> A >> B >> q;
Summator a(n), b(n);
vector<int> aa(n, 0), bb(n, 0);
for (int qq = 0; qq < q; qq++) {
cin >> key;
if (key == 1) {
cin >> d >> x;
d--;
if (aa[d] < A) {
int diff = min(A - aa[d], x);
a.modify(d, diff);
aa[d] += diff;
}
if (bb[d] < B) {
int diff = min(B - bb[d], x);
b.modify(d, diff);
bb[d] += diff;
}
} else if (key == 2) {
cin >> p;
p--;
int rez = (p - 1 >= 0 ? b.sum(0, p - 1) : 0) +
(p + k <= n - 1 ? a.sum(p + k, n - 1) : 0);
cout << rez << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int mof = 1000000007;
const int inf = 1000000010;
const long long llinf = 1000000007000000007;
const double pi = 3.14159265359;
int a[211111];
int a2[211111];
int t[211111];
int t2[211111];
int n, k, A, B, q;
int sum(int r) {
int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, int delta) {
if (a[i] + delta > B) {
delta = B - a[i];
a[i] = B;
} else {
a[i] = a[i] + delta;
}
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
int sum(int l, int r) { return sum(r) - sum(l - 1); }
void init(int a[]) {
for (unsigned i = 0; i < n; i++) inc(i, a[i]);
}
int sum2(int r) {
int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t2[r];
return result;
}
void inc2(int i, int delta) {
if (a2[i] + delta > A) {
delta = A - a2[i];
a2[i] = A;
} else {
a2[i] = a2[i] + delta;
}
for (; i < n; i = (i | (i + 1))) t2[i] += delta;
}
int sum2(int l, int r) { return sum2(r) - sum2(l - 1); }
void init2(int a[]) {
for (unsigned i = 0; i < n; i++) inc2(i, a[i]);
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &A, &B, &q);
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, a;
scanf("%d%d", &d, &a);
inc(d - 1, a);
inc2(d - 1, a);
} else {
int p;
scanf("%d", &p);
printf("%d\n", sum(0, p - 2) + sum2(p + k - 1, n - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cas = 1, T;
int n, k, a, b, q;
int c[200000 + 100][2];
int A[200000 + 100];
int lowbit(int x) { return x & (-x); }
void update(int x, int y, int z) {
for (int i = x; i < 200000 + 100; i += lowbit(i)) c[i][z] += y;
}
int query(int x, int z) {
int res = 0;
for (int i = x; i; i -= lowbit(i)) res += c[i][z];
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int x, y;
scanf("%d%d", &x, &y);
int temp = A[x];
A[x] += y;
update(x, min(b, A[x]) - min(b, temp), 0);
update(x, min(a, A[x]) - min(a, temp), 1);
} else {
int x;
scanf("%d", &x);
printf("%d\n", query(x - 1, 0) + query(n, 1) - query(x + k - 1, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxsize = 262144;
struct tree {
vector<long long> arr;
tree() { arr.resize(maxsize * 2); }
void set(int v, int l, int r, int x, long long val) {
if (x > r || x < l) return;
if (x <= l && x >= r) {
arr[v] = val;
return;
}
int m = (l + r) / 2;
set(v * 2, l, m, x, val);
set(v * 2 + 1, m + 1, r, x, val);
arr[v] = arr[v * 2] + arr[v * 2 + 1];
}
long long get(int v, int l, int r, int x, int y) {
if (x > r || y < l) return 0;
if (l >= x && r <= y) return arr[v];
int m = (l + r) / 2;
return get(v * 2, l, m, x, y) + get(v * 2 + 1, m + 1, r, x, y);
}
};
int main() {
long long n, k, a, b, q;
vector<long long> queries;
tree pref, suf;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int mode;
cin >> mode;
if (mode == 1) {
long long d, am;
cin >> d >> am;
d--;
pref.set(1, 0, maxsize - 1, d,
min(pref.get(1, 0, maxsize - 1, d, d) + am, b));
suf.set(1, 0, maxsize - 1, d,
min(suf.get(1, 0, maxsize - 1, d, d) + am, a));
} else {
long long p, res = 0;
cin >> p;
p--;
if (p > 0) res += pref.get(1, 0, maxsize - 1, 0, p - 1);
if (p + k <= n - 1) res += suf.get(1, 0, maxsize - 1, p + k, n - 1);
cout << res << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int inf = 2e9;
const long double eps = 1e-7;
const long double pi = acos(-1);
const int dx[4] = {0, 0, 1, -1};
const int dy[4] = {1, -1, 0, 0};
const int N = 2e5 + 11;
const int M = 2750132;
const int mod = 1e9 + 7;
int c[N], t[3][4 * N];
void upd(int v, int tl, int tr, int pos, int val, int type) {
if (tl == tr) {
t[type][v] = val;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm)
upd(v * 2, tl, tm, pos, val, type);
else
upd(v * 2 + 1, tm + 1, tr, pos, val, type);
t[type][v] = t[type][v * 2] + t[type][v * 2 + 1];
}
int get(int v, int tl, int tr, int l, int r, int type) {
if (tl > r || l > tr) return 0;
if (l <= tl && tr <= r) return t[type][v];
int tm = (tl + tr) / 2;
return get(v * 2, tl, tm, l, r, type) +
get(v * 2 + 1, tm + 1, tr, l, r, type);
}
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 1; i <= q; i++) {
int t, first, second;
cin >> t >> first;
if (t == 1) {
cin >> second;
c[first] += second;
upd(1, 1, n, first, min(c[first], b), 1);
upd(1, 1, n, first, min(c[first], a), 2);
} else {
cout << get(1, 1, n, 1, first - 1, 1) + get(1, 1, n, first + k, n, 2)
<< "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 7;
long long int t[2][MAXN], c[MAXN], d[MAXN], a, b;
int n, k, q;
int lowbit(int x) { return x & (-x); }
void add(int v, int x, long long int val) {
for (int i = x; i <= n; i += lowbit(i)) t[v][i] += val;
}
long long int getsum(int v, int x) {
long long int sum = 0;
for (int i = x; i >= 1; i -= lowbit(i)) sum += t[v][i];
return sum;
}
int main() {
scanf("%d%d%lld%lld%d", &n, &k, &a, &b, &q);
int s, x, y;
for (int i = 1; i <= q; i++) {
scanf("%d", &s);
if (s == 1) {
scanf("%d%d", &x, &y);
long long int pre = c[x];
c[x] += y;
long long int X = min(c[x], a) - min(pre, a);
long long int Y = min(c[x], b) - min(pre, b);
if (Y) add(0, x, Y);
if (X) add(1, x, X);
} else {
scanf("%d", &x);
long long int sum =
getsum(0, x - 1) - getsum(0, 0) + getsum(1, n) - getsum(1, x + k - 1);
printf("%lld\n", sum);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q, c1[200005], c2[200005], b1[200005], b2[200005];
void upd(int b[], int x, int y) {
for (int i = x; i <= n; i += i & -i) b[i] += y;
}
int get(int b[], int x) {
int ret = 0;
for (int i = x; i; i -= i & -i) ret += b[i];
return ret;
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q--) {
int cmd, x, y;
scanf("%d %d", &cmd, &x);
if (cmd == 1) {
scanf("%d", &y);
int p1 = c1[x];
c1[x] = min(b, c1[x] + y);
int p2 = c2[x];
c2[x] = min(a, c2[x] + y);
upd(b1, x, c1[x] - p1);
upd(b2, n - x + 1, c2[x] - p2);
} else
printf("%d\n", get(b1, x - 1) + get(b2, n - x - k + 1));
}
scanf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
long long bit[2][200010], n;
long long a1[200010], a2[200010];
void update(int i, int val, int f) {
while (i <= n) {
bit[f][i] += val;
i = i + (i & (-i));
}
}
long long query(int i, int f) {
long long ret = 0;
while (i) {
ret += bit[f][i];
i = i - (i & (-i));
}
return ret;
}
int main() {
int k, a, b, q, ch, x, y;
scanf("%lld", &n);
scanf("%d", &k);
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &q);
memset(bit[0], 0, sizeof(bit[0]));
memset(bit[1], 0, sizeof(bit[1]));
memset(a1, 0, sizeof(a1));
memset(a2, 0, sizeof(a2));
while (q--) {
scanf("%d", &ch);
if (ch == 1) {
scanf("%d", &x);
scanf("%d", &y);
update(x, min(y * 1ll, a - a1[x]), 0);
update(x, min(y * 1ll, b - a2[x]), 1);
a1[x] = min(a * 1ll, a1[x] + y);
a2[x] = min(b * 1ll, a2[x] + y);
} else {
scanf("%d", &x);
long long ans = query(x - 1, 1);
ans = ans + query(n, 0) - query(x + k - 1, 0);
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 2e5 + 10;
long long tr[2][MAXn];
long long a[2][MAXn];
int mx[2];
int n;
void add(int ti, int i, int v) {
if (a[ti][i] + v > mx[ti]) {
v = mx[ti] - a[ti][i];
}
a[ti][i] += v;
while (i <= n) {
tr[ti][i] += v;
i += (i & -i);
}
}
long long get(int ti, int i) {
long long res = 0;
while (i > 0) {
res += tr[ti][i];
i -= (i & -i);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
int k, a, b, q;
cin >> n >> k >> a >> b >> q;
mx[0] = b;
mx[1] = a;
for (int i = 0; i < q; i++) {
int t, j;
cin >> t >> j;
if (t == 1) {
int v;
cin >> v;
add(0, j, v);
add(1, n + 1 - j, v);
} else {
cout << get(0, j - 1) + get(1, n + 1 - (j + k)) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000 * 1000 * 1000 + 7;
long long n, k, a, b, q, type, d, x, p, arr[200005], arrb[200005], tree[200005],
treeb[200005], upd, updb;
void update(int x, long long val) {
while (x < 200005) {
tree[x] += val;
x += (x & -x);
}
}
void updateb(int x, long long val) {
while (x < 200005) {
treeb[x] += val;
x += (x & -x);
}
}
long long sum(int x) {
long long res = 0;
while (x > 0) {
res += tree[x];
x -= (x & -x);
}
return res;
}
long long sumb(int x) {
long long res = 0;
while (x > 0) {
res += treeb[x];
x -= (x & -x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> type;
if (type == 1) {
cin >> d >> x;
if (arr[d] + x > a) {
upd = a - arr[d];
arr[d] = a;
} else {
arr[d] += x;
upd = x;
}
if (arr[d] > b) {
updb = b - arrb[d];
arrb[d] = b;
} else {
arrb[d] = arr[d];
updb = x;
}
update(d, upd);
updateb(d, updb);
} else {
cin >> p;
cout << (sum(n) - sum(p + k - 1)) + sumb(p - 1) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int sum, add, lo, hi;
Node *le, *ri;
static Node* Build(int lo, int hi) {
Node* root = new Node();
root->lo = lo, root->hi = hi;
root->sum = root->add = 0;
root->le = root->ri = NULL;
if (lo != hi)
root->le = Build(lo, (lo + hi) >> 1),
root->ri = Build(((lo + hi) >> 1) + 1, hi);
return root;
}
void PushDown() {
if (add == 0) return;
if (le) {
le->add += add;
ri->add += add;
le->sum += add * (le->hi - le->lo + 1);
ri->sum += add * (ri->hi - ri->lo + 1);
add = 0;
}
}
void Add(int fr, int to, int how) {
if (to < lo || fr > hi) return;
if (fr <= lo && hi <= to) {
add += how;
sum += (hi - lo + 1) * how;
} else {
PushDown();
le->Add(fr, to, how);
ri->Add(fr, to, how);
sum = le->sum + ri->sum;
}
}
int Get(int fr, int to) {
if (fr > to) return 0;
if (to < lo || fr > hi) return 0;
if (fr <= lo && hi <= to) return sum;
PushDown();
return le->Get(fr, to) + ri->Get(fr, to);
}
};
int main() {
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
Node* pref = Node::Build(0, n - 1);
Node* suff = Node::Build(0, n - 1);
vector<int> pref_c(n, 0), suff_c(n, 0);
for (int i = 0; i < q; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, add;
scanf("%d%d", &d, &add);
--d;
int ptake = min(b - pref_c[d], add);
int stake = min(a - suff_c[d], add);
pref_c[d] += ptake;
suff_c[d] += stake;
pref->Add(d, n - 1, ptake);
suff->Add(0, d, stake);
} else {
int p;
scanf("%d", &p);
--p;
int ans = 0;
if (p) ans += pref->Get(p - 1, p - 1);
if (p + k < n) ans += suff->Get(p + k, p + k);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int a, b;
struct node {
int l, r, m, v[2];
} s[MAXN << 2];
void push_up(int n) {
for (int i = 0; i < 2; i++) s[n].v[i] = s[n << 1].v[i] + s[n << 1 | 1].v[i];
}
void build(int l, int r, int n) {
int m = (l + r) >> 1;
s[n].l = l;
s[n].r = r;
s[n].m = m;
if (r - l == 1) {
s[n].v[0] = s[n].v[1] = 0;
return;
}
build(l, m, n << 1);
build(m, r, n << 1 | 1);
push_up(n);
}
void update(int p, int v, int n) {
if (s[n].l == p && s[n].r == p + 1) {
s[n].v[0] = min(b, s[n].v[0] + v);
s[n].v[1] = min(a, s[n].v[1] + v);
return;
}
if (p < s[n].m)
update(p, v, n << 1);
else
update(p, v, n << 1 | 1);
push_up(n);
}
int query(int l, int r, int n, int id) {
if (r <= l) return 0;
if (s[n].l == l && s[n].r == r) return s[n].v[id];
if (r <= s[n].m) return query(l, r, n << 1, id);
if (l >= s[n].m) return query(l, r, n << 1 | 1, id);
return query(l, s[n].m, n << 1, id) + query(s[n].m, r, n << 1 | 1, id);
}
int main() {
int n, k, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
build(1, n + 1, 1);
for (int i = 1; i <= q; i++) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int x, y;
scanf("%d%d", &x, &y);
update(x, y, 1);
} else {
int p;
scanf("%d", &p);
printf("%d\n", query(1, p, 1, 0) + query(p + k, n + 1, 1, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
struct Input {
int n, m, k;
int a, b;
vector<pair<int, pair<int, int> > > q;
bool read() {
if (!(cin >> n >> k >> a >> b >> m)) {
return false;
}
q.resize(m);
for (int i = 0; i < m; ++i) {
int t;
cin >> t;
if (t == 1) {
int d, x;
cin >> d >> x;
--d;
q.push_back(make_pair(0, make_pair(d, x)));
} else {
int x;
cin >> x;
--x;
q.push_back(make_pair(1, make_pair(x, 0)));
}
}
return true;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
vector<int> ans;
void write() {
for (int i = 0; i < ((int)(ans).size()); ++i) {
cout << ans[i];
cout << "\n";
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct FenTree {
vector<int> a;
FenTree(int n) : a(n) {}
void add(int x, int d) {
while (x < ((int)(a).size())) {
a[x] += d;
x |= x + 1;
}
}
int sum(int x, int y) {
if (x > y) {
return 0;
}
return sum(y) - (x ? sum(x - 1) : 0);
}
int sum(int x) {
int res = 0;
while (x >= 0) {
res += a[x];
x &= x + 1;
--x;
}
return res;
}
};
struct Solution : Data {
vector<int> d;
void solve() {
FenTree as(n + 1), bs(n + 1);
vector<int> c(n);
for (int i = 0; i < ((int)(q).size()); ++i) {
if (q[i].first == 0) {
int x = q[i].second.first, d = q[i].second.second;
int da = min(a, c[x] + d) - c[x];
int db = min(b, c[x] + d) - c[x];
if (da > 0) {
as.add(x, da);
}
if (db > 0) {
bs.add(x + 1, db);
}
c[x] += d;
} else {
int x = q[i].second.first;
ans.push_back(bs.sum(x) + as.sum(x + k, n - 1));
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200500;
long long pref[MAXN];
long long suf[MAXN];
long long tsuf[MAXN];
long long tpref[MAXN];
long long n, k, a, b, q;
inline int f(int x) { return x & (-x); }
void upd1(int ind, long long dx) {
for (; ind < n; ind += f(ind + 1)) tpref[ind] += dx;
}
void upd2(int ind, long long dx) {
for (; ind < n; ind += f(ind + 1)) tsuf[ind] += dx;
}
long long get1(int ind) {
long long res = 0;
for (; ind >= 0; ind -= f(ind + 1)) res += tpref[ind];
return res;
}
long long get2(int ind) {
long long res = 0;
for (; ind >= 0; ind -= f(ind + 1)) res += tsuf[ind];
return res;
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; ++i) {
int c;
cin >> c;
if (c == 1) {
long long cnt, d;
cin >> d >> cnt;
d--;
long long val = min(b, cnt + pref[d]);
upd1(d, val - pref[d]);
pref[d] = val;
val = min(a, cnt + suf[d]);
upd2(d, val - suf[d]);
suf[d] = val;
} else {
long long p;
cin >> p;
p--;
long long cur = get1(p - 1) + get2(n - 1) - get2(p + k - 1);
cout << cur << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
long long binpowmod(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long c = binpowmod(a, b >> 1, mod);
return (((c * c) % mod) * (b & 1 ? a : 1)) % mod;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
return c * c * (b & 1 ? a : 1);
}
inline int getbit(int x, int b) { return (x >> b) & 1; }
inline long long getbit(long long x, int b) { return (x >> b) & 1; }
inline unsigned long long getbit(unsigned long long x, int b) {
return (x >> b) & 1;
}
inline int setbit(int x, int b) { return x | (1 << b); }
inline void _setbit(int &x, int b) { x = setbit(x, b); }
inline long long setbit(long long x, int b) { return x | (1ll << b); }
inline void _setbit(long long &x, int b) { x = setbit(x, b); }
inline int unsetbit(int x, int b) { return x & (INT_MAX - (1 << b)); }
inline void _unsetbit(int &x, int b) { x = unsetbit(x, b); }
inline int countbit(int x) {
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline long long countbit(long long x) {
int p1 = (x >> 32) & ((1ll << 32) - 1);
int p2 = x & ((1ll << 32) - 1);
return countbit(p1) + countbit(p2);
}
template <typename T>
void printbit(T x, int len) {
for (int i = len - 1; i >= 0; i--) printf("%d", getbit(x, i));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename A, typename B>
ostream &operator<<(ostream &stream, const pair<A, B> &p) {
stream << "{" << p.first << "," << p.second << "}";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const vector<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A, typename B>
ostream &operator<<(ostream &stream, const map<A, B> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const set<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const stack<A> &v) {
stack<A> st;
stream << "[";
while (!st.empty()) {
stream << st.top() << " ";
st.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const priority_queue<A> &v) {
priority_queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.top() << " ";
q.pop();
}
stream << "]";
return stream;
}
void run();
int main() {
srand(time(NULL));
do {
run();
if (0) {
0 ? printf("-------------------------------\n") : 0;
0 ? printf("-------------------------------\n") : 0;
}
} while (0);
return 0;
}
struct SegmentTree {
vector<long long> tr;
int n, mx;
SegmentTree(int _n, int _mx) : n(_n), mx(_mx) { tr.resize(4 * n); }
void update_impl(int v, int l, int r, int pos, long long d) {
if (l == r)
tr[v] = min(1ll * mx, tr[v] + d);
else {
int mid = (l + r) >> 1;
if (pos <= mid)
update_impl(v + v, l, mid, pos, d);
else
update_impl(v + v + 1, mid + 1, r, pos, d);
tr[v] = tr[v + v] + tr[v + v + 1];
}
}
long long get_sum_impl(int v, int l, int r, int L, int R) {
if (L > R) return 0;
if (l == L && r == R)
return tr[v];
else {
int mid = (l + r) >> 1;
return get_sum_impl(v + v, l, mid, L, min(mid, R)) +
get_sum_impl(v + v + 1, mid + 1, r, max(mid + 1, L), R);
}
}
long long get_sum(int l, int r) { return get_sum_impl(1, 0, n - 1, l, r); }
void update(int pos, long long d) { update_impl(1, 0, n - 1, pos, d); }
};
void run() {
int n, k, a, b, q;
scanf("%d%d", &n, &k);
scanf("%d%d%d", &a, &b, &q);
int t, x, y;
SegmentTree atree(n + 2, a), btree(n + 2, b);
while (q--) {
scanf("%d%d", &t, &x);
if (t == 1) {
scanf("%d", &y);
atree.update(x, y);
btree.update(x, y);
} else {
long long res = btree.get_sum(1, x - 1) + atree.get_sum(x + k, n);
printf(0 ? "%lld" : "%I64d", res);
putchar('\n');
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void aps554(long long int n = 10) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(n) << fixed;
}
long long int M = 1e9 + 7;
long long int M1 = 998244353;
vector<long long int> v;
struct info {
long long int x, lazy;
info() {
x = 0;
lazy = 0;
}
};
struct SegTree {
long long int N;
vector<info> st;
void init(long long int n) {
N = n;
st.resize(4 * N + 5, info());
}
void merge(info &cur, info &l, info &r) { cur.x = l.x + r.x; }
void Build(long long int node, long long int L, long long int R) {
if (L == R) {
st[node].x = v[L - 1];
return;
}
long long int MM = (L + R) / 2;
Build(node * 2, L, MM);
Build(node * 2 + 1, MM + 1, R);
merge(st[node], st[node * 2], st[node * 2 + 1]);
}
info Query(long long int node, long long int L, long long int R,
long long int i, long long int j) {
if (j < L || i > R) return info();
if (i <= L && R <= j) return st[node];
long long int MM = (L + R) / 2;
info left = Query(node * 2, L, MM, i, j);
info right = Query(node * 2 + 1, MM + 1, R, i, j);
info cur;
merge(cur, left, right);
return cur;
}
void Update(long long int node, long long int L, long long int R,
long long int ind, long long int limit, long long int val) {
if (L > ind || R < ind) return;
if (L == ind && R == ind) {
st[node].x = min(val + st[node].x, limit);
return;
}
long long int MM = (L + R) / 2;
Update(node * 2, L, MM, ind, limit, val);
Update(node * 2 + 1, MM + 1, R, ind, limit, val);
merge(st[node], st[node * 2], st[node * 2 + 1]);
}
info query(long long int l, long long int r) { return Query(1, 1, N, l, r); }
void update(long long int ind, long long int val, long long int limit) {
Update(1, 1, N, ind, limit, val);
}
void build() { Build(1, 1, N); }
};
int32_t main() {
aps554();
long long int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
SegTree segm, segM;
v.resize(n);
segm.init(n);
segM.init(n);
while (q--) {
long long int t;
cin >> t;
if (t == 1) {
long long int aa, bb;
cin >> aa >> bb;
segm.update(aa, bb, a);
segM.update(aa, bb, b);
} else {
long long int ind;
cin >> ind;
cout << segM.query(1, ind - 1).x + segm.query(ind + k, n).x << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, k, a, b, q;
int val[N];
struct bit {
long long t[N];
void add(int x, int v) {
while (x < N) {
t[x] += v;
x += (x & -x);
}
}
long long get(int x) {
long long res = 0;
while (x) {
res += t[x];
x -= (x & -x);
}
return res;
}
long long get(int l, int r) {
if (l > r) {
return 0ll;
}
return get(r) - get(l - 1);
}
} bigA, smallA, bigB, smallB;
void push(int x, int sign) {
if (val[x] < a) {
smallA.add(x, val[x] * sign);
} else {
bigA.add(x, sign);
}
if (val[x] < b) {
smallB.add(x, val[x] * sign);
} else {
bigB.add(x, sign);
}
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 1; i <= q; i++) {
int op, x, y;
scanf("%d", &op);
if (op == 1) {
scanf("%d %d", &x, &y);
push(x, -1);
val[x] += y;
push(x, 1);
} else {
scanf("%d", &x);
long long res = 0;
res = smallB.get(1, x - 1) + 1ll * bigB.get(1, x - 1) * b;
res += smallA.get(x + k, n) + 1ll * bigA.get(x + k, n) * a;
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long A[maxn], ta[maxn], tb[maxn];
long long n, k, a, b, q;
void insert(long long i, long long num, long long *t) {
for (; i < maxn; i += (i & (-i))) t[i] += num;
}
long long cal(long long i, long long *t) {
long long ans = 0;
for (; i > 0; i -= (i & (-i))) ans += t[i];
return ans;
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 1; i <= q; i++) {
int op;
long long dd, aa, pp;
scanf("%d", &op);
if (op == 1) {
scanf("%lld%lld", &dd, &aa);
insert(dd, max(0ll, min(b - A[dd], aa)), tb);
insert(dd, max(0ll, min(a - A[dd], aa)), ta);
A[dd] += aa;
} else {
scanf("%lld", &pp);
printf("%lld\n", cal(pp - 1, tb) + cal(n, ta) - cal(pp + k - 1, ta));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int N, K, A, B, Q;
int type, D, VAL;
int tree[MAX * 4];
int tree2[MAX * 4];
void update(int l, int r, int node, int idx, int val) {
if (l == r) {
tree[node] += val;
tree2[node] += val;
tree[node] = min(tree[node], B);
tree2[node] = min(tree2[node], A);
} else {
int mid = l + r >> 1;
if (idx <= mid)
update(l, mid, node + node, idx, val);
else
update(mid + 1, r, node + node + 1, idx, val);
tree[node] = tree[node + node] + tree[node + node + 1];
tree2[node] = tree2[node + node] + tree2[node + node + 1];
}
}
int query_tree(int l, int r, int node, int ql, int qr) {
if (l > qr || r < ql || qr < ql) return 0;
if (l >= ql && r <= qr) return tree[node];
int mid = l + r >> 1;
return query_tree(l, mid, node + node, ql, qr) +
query_tree(mid + 1, r, node + node + 1, ql, qr);
}
int query_tree2(int l, int r, int node, int ql, int qr) {
if (l > qr || r < ql || qr < ql) return 0;
if (l >= ql && r <= qr) return tree2[node];
int mid = l + r >> 1;
return query_tree2(l, mid, node + node, ql, qr) +
query_tree2(mid + 1, r, node + node + 1, ql, qr);
}
int main() {
cin.tie(0), ios::sync_with_stdio(false);
cin >> N >> K >> A >> B >> Q;
for (int i = 1; i <= Q; i++) {
cin >> type;
if (type == 1) {
cin >> D >> VAL;
update(1, N, 1, D, VAL);
} else {
cin >> VAL;
cout << (query_tree(1, N, 1, 1, VAL - 1) +
query_tree2(1, N, 1, VAL + K, N))
<< '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1e5 + 1;
int N, maxA, maxB, K, Q, A[MAXN];
int BIT1[MAXN], BIT2[MAXN];
void BIT_U(int ii, int val) {
for (int i = ii + 1; i <= N; i += i & -i) BIT1[i] -= min(A[ii], maxB);
for (int i = N - ii; i <= N; i += i & -i) BIT2[i] -= min(A[ii], maxA);
A[ii] += val;
for (int i = ii + 1; i <= N; i += i & -i) BIT1[i] += min(A[ii], maxB);
for (int i = N - ii; i <= N; i += i & -i) BIT2[i] += min(A[ii], maxA);
}
int BIT_Q(int ii) {
int ret = 0;
for (int i = ii; i; i -= i & -i) ret += BIT1[i];
for (int i = N - ii - K; i; i -= i & -i) ret += BIT2[i];
return ret;
}
int main() {
scanf("%d", &N), scanf("%d", &K);
scanf("%d", &maxA), scanf("%d", &maxB);
scanf("%d", &Q);
memset(A, 0, sizeof(A));
memset(BIT1, 0, sizeof(BIT1));
memset(BIT2, 0, sizeof(BIT2));
for (int q = 0; q < (int)Q; q++) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, a;
scanf("%d", &d), scanf("%d", &a);
BIT_U(d - 1, a);
} else {
int p;
scanf("%d", &p);
printf("%d\n", BIT_Q(p - 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 131072 * 2;
int n, k, a, b, q;
typedef struct {
int sa, sb;
} TVertex;
vector<TVertex> tree;
void build() {
TVertex zero;
zero.sa = 0;
zero.sb = 0;
tree.resize(2 * MAXN, zero);
}
void inc(int pos, int val) {
pos += MAXN;
tree[pos].sa = min(a, tree[pos].sa + val);
tree[pos].sb = min(b, tree[pos].sb + val);
pos >>= 1;
for (; pos > 0; pos >>= 1) {
tree[pos].sa = tree[pos * 2].sa + tree[pos * 2 + 1].sa;
tree[pos].sb = tree[pos * 2].sb + tree[pos * 2 + 1].sb;
}
}
int get_sum(int v, int vl, int vr, int l, int r, bool flag) {
if (l > r) return 0;
if (vl > r || l > vr) return 0;
if (l <= vl && vr <= r) {
if (flag)
return tree[v].sa;
else
return tree[v].sb;
}
int vm = (vl + vr) / 2;
return get_sum(v * 2, vl, vm, l, r, flag) +
get_sum(v * 2 + 1, vm + 1, vr, l, r, flag);
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
build();
for (int i = 0; i < q; ++i) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int d, ca;
scanf("%d%d", &d, &ca);
inc(d - 1, ca);
} else {
int p;
scanf("%d", &p);
cout << get_sum(1, 0, MAXN - 1, 0, p - 2, false) +
get_sum(1, 0, MAXN - 1, p + k - 1, n - 1, true)
<< "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sTree[2][4 * 200005], nums[200005], kaka[2], n, k, q, x, y, z;
void update(int ind, int c, int b, int e, int i) {
if (i < b || i > e)
return;
else if (b == e)
sTree[ind][c] = ((nums[b]) < (kaka[ind]) ? (nums[b]) : (kaka[ind]));
else if (b != e) {
int m = b + (e - b) / 2;
update(ind, 2 * c, b, m, i);
update(ind, 2 * c + 1, m + 1, e, i);
sTree[ind][c] = sTree[ind][2 * c] + sTree[ind][2 * c + 1];
}
}
void update(int ind, int i) { update(ind, 1, 1, n, i); }
int query(int ind, int c, int b, int e, int qb, int qe) {
if (qb <= b && qe >= e)
return sTree[ind][c];
else if (qe < b || qb > e)
return 0;
else {
int m = b + (e - b) / 2;
if (m > qe) return query(ind, 2 * c, b, m, qb, qe);
if (m < qb) return query(ind, 2 * c + 1, m + 1, e, qb, qe);
return query(ind, 2 * c, b, m, qb, qe) +
query(ind, 2 * c + 1, m + 1, e, qb, qe);
}
}
int query(int ind, int b, int e) { return query(ind, 1, 1, n, b, e); }
int main() {
scanf("%d%d%d%d%d", &n, &k, &kaka[0], &kaka[1], &q);
for (int i = 0; i < q; ++i) {
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z);
nums[y] += z;
update(0, y);
update(1, y);
} else {
scanf("%d", &y);
int ans = 0;
if (y > 1) ans += query(1, 1, y - 1);
if (n >= y + k) ans += query(0, y + k, n);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct segtr {
long long int siparis, normal, fazlaysa;
} seg[4 * 200005];
long long int N, k, slow, fast, Q;
void update(long long int k, long long int l, long long int r, long long int tg,
long long int extra) {
if (l > tg || r < tg) return;
if (l == tg && r == tg) {
seg[k].siparis += extra;
seg[k].normal = min(seg[k].siparis, slow);
if (seg[k].siparis > slow) {
seg[k].fazlaysa = min(fast - slow, seg[k].siparis - slow);
}
return;
}
update(2 * k, l, (l + r) / 2, tg, extra);
update(2 * k + 1, (l + r) / 2 + 1, r, tg, extra);
seg[k].normal = seg[2 * k].normal + seg[2 * k + 1].normal;
seg[k].fazlaysa = seg[2 * k].fazlaysa + seg[2 * k + 1].fazlaysa;
}
long long int find(long long int k, long long int l, long long int r,
long long int tg_l, long long int tg_r,
long long int extra) {
if (l > tg_r || r < tg_l) return 0;
if (l >= tg_l && r <= tg_r) {
long long int ret = 0;
ret = seg[k].normal + (extra ? seg[k].fazlaysa : 0);
return ret;
}
return find(2 * k, l, (l + r) / 2, tg_l, tg_r, extra) +
find(2 * k + 1, (l + r) / 2 + 1, r, tg_l, tg_r, extra);
}
int main() {
long long int a, b, c;
cin >> N >> k >> fast >> slow >> Q;
while (Q--) {
scanf("%lld %lld", &a, &b);
if (a == 1) {
scanf("%lld", &c);
update(1, 1, N, b, c);
} else {
long long int yaz = 0;
if (b > 1) yaz += find(1, 1, N, 1, b - 1, 0);
if (b + k - 1 < N) yaz += find(1, 1, N, b + k, N, 1);
printf("%lld\n", yaz);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, k, a, b, q, seg[4 * maxn][2], type;
void change(int l, int r, int pos, int val, int id) {
if (r - l == 1) {
seg[id][0] += val;
seg[id][1] += val;
seg[id][0] = min(a, seg[id][0]);
seg[id][1] = min(b, seg[id][1]);
return;
}
int mid = (l + r) / 2;
if (pos < mid)
change(l, mid, pos, val, id * 2);
else
change(mid, r, pos, val, id * 2 + 1);
seg[id][0] = seg[id * 2][0] + seg[id * 2 + 1][0];
seg[id][1] = seg[id * 2][1] + seg[id * 2 + 1][1];
return;
}
int query(int l, int r, int lo, int hi, int id, int f) {
if (l >= hi || lo >= r) return 0;
if (l >= lo && r <= hi) return seg[id][f];
int mid = (l + r) / 2;
int javab = query(l, mid, lo, hi, id * 2, f);
javab += query(mid, r, lo, hi, id * 2 + 1, f);
return javab;
}
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> type;
if (type == 2) {
int dayup;
cin >> dayup;
int ans = query(0, n, 0, --dayup, 1, 1);
ans += query(0, n, dayup + k, n, 1, 0);
cout << ans << '\n';
} else {
int pos, val;
cin >> pos >> val;
change(0, n, --pos, val, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const int BUCKET_SZ = 400;
int n, k, a, b, q;
int orders[300005];
int bad[300005 / BUCKET_SZ + 5], good[300005 / BUCKET_SZ + 5];
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, cnt;
scanf("%d %d", &d, &cnt);
d--;
if (orders[d] < b)
bad[d / BUCKET_SZ] += min(orders[d] + cnt, b) - orders[d];
if (orders[d] < a)
good[d / BUCKET_SZ] += min(orders[d] + cnt, a) - orders[d];
orders[d] += cnt;
} else {
int d;
scanf("%d", &d);
d--;
int res = 0;
int i = 0;
while (i + BUCKET_SZ <= d) {
res += bad[i / BUCKET_SZ];
i += BUCKET_SZ;
}
while (i < d) {
res += min(orders[i], b);
i++;
}
i = d + k;
while (i % BUCKET_SZ != 0) {
res += min(orders[i], a);
i++;
}
while (i < n) {
res += good[i / BUCKET_SZ];
i += BUCKET_SZ;
}
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200100;
int cnt[MAX_N];
int tree_a[MAX_N];
int tree_b[MAX_N];
int GetSum(int x, int tree[]) {
int result = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1) {
result += tree[i];
}
return result;
}
int GetSum(int left, int right, int tree[]) {
return GetSum(right, tree) - ((left == 0) ? 0 : GetSum(left - 1, tree));
}
void Update(int x, int delta, int tree[]) {
for (int i = x; i < MAX_N; i = (i | (i + 1))) {
tree[i] += delta;
}
}
int main() {
int n, k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &b, &a, &q);
for (int i = 0; i < q; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, x;
scanf("%d %d", &d, &x);
if (cnt[d] + x <= a) {
Update(d, x, tree_a);
} else if (cnt[d] < a) {
Update(d, a - cnt[d], tree_a);
}
if (cnt[d] + x <= b) {
Update(d, x, tree_b);
} else if (cnt[d] < b) {
Update(d, b - cnt[d], tree_b);
}
cnt[d] += x;
} else if (type == 2) {
int p;
scanf("%d", &p);
printf("%d\n",
GetSum(0, p - 1, tree_a) + GetSum(p + k, MAX_N - 1, tree_b));
} else {
throw 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 2 * 1e9;
const int mod = 1e9 + 7;
const long long infll = (long long)1e18;
const long double eps = 1e-9;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
using namespace std;
int a, b;
struct node {
int v1;
int v2;
node() : v1(0), v2(0) {}
node(int v1, int v2) : v1(v1), v2(v2) {}
};
vector<node> t;
node combine(const node& p, const node& q) {
return node(p.v1 + q.v1, p.v2 + q.v2);
}
void update(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t[v].v1 = min(a, t[v].v1 + val);
t[v].v2 = min(b, t[v].v2 + val);
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos, val);
else
update(v * 2 + 1, tm + 1, tr, pos, val);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
node get(int v, int tl, int tr, int l, int r) {
if (l > r) return node();
if (tl == l && tr == r) return t[v];
int tm = (tl + tr) / 2;
return combine(get(v * 2, tl, tm, l, min(r, tm)),
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void solve() {
int n, k, q;
cin >> n >> k >> a >> b >> q;
t.resize(4 * n);
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
int d, a;
cin >> d >> a;
d--;
update(1, 0, n - 1, d, a);
} else {
int p;
cin >> p;
p--;
node v1 = p ? get(1, 0, n - 1, 0, p - 1) : node();
int ind = p + k;
node v2 = ind != n ? get(1, 0, n - 1, ind, n - 1) : node();
cout << v1.v2 + v2.v1 << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sumlow;
long long sumhigh;
};
const int BT = 262144;
node itree[BT * 2];
int orders[BT];
int a, b;
void updatetree(int pos, int val) {
pos += BT;
itree[pos].sumlow = min(b, val);
itree[pos].sumhigh = min(a, val);
pos >>= 1;
while (pos >= 1) {
itree[pos].sumlow = itree[(pos << 1)].sumlow + itree[(pos << 1) + 1].sumlow;
itree[pos].sumhigh =
itree[(pos << 1)].sumhigh + itree[(pos << 1) + 1].sumhigh;
pos >>= 1;
}
}
long long getrangelow(int l, int r) {
long long ans = 0;
l += BT, r += BT;
while (l <= r) {
if (l & 1) {
ans += itree[l].sumlow;
}
if (!(r & 1)) {
ans += itree[r].sumlow;
}
l = (l + 1) >> 1;
r = (r - 1) >> 1;
}
return ans;
}
long long getrangehigh(int l, int r) {
long long ans = 0;
l += BT, r += BT;
while (l <= r) {
if (l & 1) {
ans += itree[l].sumhigh;
}
if (!(r & 1)) {
ans += itree[r].sumhigh;
}
l = (l + 1) >> 1;
r = (r - 1) >> 1;
}
return ans;
}
int main() {
int n, K, q;
scanf("%d%d%d%d%d", &n, &K, &a, &b, &q);
for (int i = 0; i < q; i++) {
int cmdtype;
scanf("%d", &cmdtype);
if (cmdtype == 1) {
int day, add;
scanf("%d%d", &day, &add);
orders[day] += add;
updatetree(day, orders[day]);
} else {
int pend;
scanf("%d", &pend);
long long a1 = getrangelow(0, pend - 1);
long long a2 = getrangehigh(pend + K, BT - 1);
printf("%lld\n", a1 + a2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
struct Tree {
int l, r, len, sum[2];
};
Tree tree[1000010 << 2];
void build(int le, int ri, int rt) {
tree[rt].l = le, tree[rt].r = ri, tree[rt].len = ri - le + 1;
tree[rt].sum[0] = 0;
tree[rt].sum[1] = 0;
if (ri == le)
return;
else {
int m = (le + ri) >> 1;
build(le, m, rt << 1);
build(m + 1, ri, rt << 1 | 1);
}
}
void update(int rt, int fd, int fa) {
if (tree[rt].l == tree[rt].r && fd == tree[rt].l) {
if (fa + tree[rt].sum[0] >= a)
tree[rt].sum[0] = a;
else
tree[rt].sum[0] += fa;
if (fa + tree[rt].sum[1] >= b)
tree[rt].sum[1] = b;
else
tree[rt].sum[1] += fa;
return;
}
int m = (tree[rt].l + tree[rt].r) >> 1;
if (fd <= m)
update(rt * 2, fd, fa);
else
update(rt * 2 + 1, fd, fa);
for (int i = 0; i < 2; i++)
tree[rt].sum[i] = tree[rt * 2].sum[i] + tree[rt * 2 + 1].sum[i];
}
int query(int L, int R, int le, int ri, int rt, int f) {
if (L > R) return 0;
if (L <= le && R >= ri) return tree[rt].sum[f];
int m = (le + ri) >> 1;
int res = 0;
if (L <= m) res += query(L, R, le, m, rt << 1, f);
if (R > m) res += query(L, R, m + 1, ri, rt << 1 | 1, f);
return res;
}
int main() {
int flag, na, d, p;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
build(1, n, 1);
for (int i = 0; i < q; i++) {
scanf("%d", &flag);
if (flag == 1) {
scanf("%d %d", &d, &na);
update(1, d, na);
} else {
scanf("%d", &p);
printf("%d\n", query(1, p - 1, 1, n, 1, 1) + query(p + k, n, 1, n, 1, 0));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
long long t[3][4 * MAXN + 1];
int a, b;
void upd(int num, int pos, int delta, int v = 1, int l = 1, int r = MAXN) {
if (l == r) {
if (num == 1 && t[num][v] + delta >= b)
t[num][v] = b;
else if (num == 1)
t[num][v] += delta;
if (num == 2 && t[num][v] + delta >= a)
t[num][v] = a;
else if (num == 2)
t[num][v] += delta;
} else {
int m = (l + r) / 2;
if (pos <= m)
upd(num, pos, delta, v * 2, l, m);
else
upd(num, pos, delta, v * 2 + 1, m + 1, r);
t[num][v] = t[num][v * 2] + t[num][v * 2 + 1];
}
}
long long get(int num, int l, int r, int tv = 1, int tl = 1, int tr = MAXN) {
if (l > r)
return 0;
else if (l == tl && r == tr)
return t[num][tv];
else {
int tm = (tl + tr) / 2;
return get(num, l, min(tm, r), tv * 2, tl, tm) +
get(num, max(tm + 1, l), r, tv * 2 + 1, tm + 1, tr);
}
}
int main() {
int n, k, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, a;
scanf("%d%d", &d, &a);
upd(1, d, a);
upd(2, d, a);
} else {
int p;
scanf("%d", &p);
long long ans = 0;
ans += get(1, 1, p - 1);
ans += get(2, p + k, n);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> staro(200005, 0), novo(200005, 0), vrijednost(200005, 0);
void update(int node, int koliko, int koji) {
if (koji == 1)
for (node; node <= 200005; node += node & (-node)) staro[node] += koliko;
else
for (node; node <= 200005; node += node & (-node)) novo[node] += koliko;
}
long long query(int node, int koji) {
long long res = 0;
if (koji == 1)
for (node; node >= 1; node -= node & (-node)) res += staro[node];
else
for (node; node >= 1; node -= node & (-node)) res += novo[node];
return res;
}
int main() {
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, x, y;
scanf("%d%d", &d, &x);
update(d, min(vrijednost[d] + x, b) - min(vrijednost[d], b), 1);
update(d, min(vrijednost[d] + x, a) - min(vrijednost[d], a), 2);
vrijednost[d] += x;
} else if (t == 2) {
int p;
scanf("%d", &p);
long long res = 0;
res += query(p - 1, 1);
if (p + k - 1 <= n) {
res += query(n, 2);
res -= query(p + k - 1, 2);
}
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, j, k, n, m, timer = 0, l, r, x, y;
int c[1011000], cnt = 0, fl = 0, a2, a3 = -1000000, ans = 0;
int t[3][200110];
void update(int idx, int id, int ad) {
while (idx <= n) {
t[id][idx] += ad;
idx += (idx & -idx);
}
}
int take(int idx, int id) {
int sm = 0;
while (idx > 0) {
sm += t[id][idx];
idx -= (idx & -idx);
}
return sm;
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d%d%d%d", &n, &k, &a, &b, &m);
for (i = 0; i < m; i++) {
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &x, &y);
if (c[x] + y <= a) {
update(x, 0, y);
} else {
if (a - c[x] > 0) update(x, 0, a - c[x]);
}
if (c[x] + y <= b) {
update(x, 1, y);
} else {
if (b - c[x] > 0) update(x, 1, b - c[x]);
}
if (c[x] <= a) c[x] += y;
} else {
scanf("%d", &x);
l = take(x - 1, 1);
r = take(n, 0) - take(x + k - 1, 0);
printf("%d\n", l + r);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
int s[2][N];
int x[N], y[N];
int n;
inline void modify(int q, int x, int v) {
while (x <= n) {
s[q][x] += v;
x = (x | (x - 1)) + 1;
}
}
inline int find_sum(int q, int x) {
int v = 0;
while (x > 0) {
v += s[q][x];
x &= x - 1;
}
return v;
}
int main() {
int k, a, b, tt;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &tt);
for (int i = 1; i <= n; i++) {
x[i] = 0;
y[i] = 0;
s[0][i] = s[1][i] = 0;
}
while (tt--) {
int type;
scanf("%d", &type);
if (type == 1) {
int day, cnt;
scanf("%d %d", &day, &cnt);
int new_x = min(b, x[day] + cnt);
int new_y = min(a, y[day] + cnt);
modify(0, day, new_x - x[day]);
modify(1, day, new_y - y[day]);
x[day] = new_x;
y[day] = new_y;
} else {
int from;
scanf("%d", &from);
int to = from + k - 1;
int ans = find_sum(0, from - 1);
ans += find_sum(1, n) - find_sum(1, to);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 3;
const int maxlog = 64;
const long long mod = 1e16 + 7;
const int maxh = 2 * 350;
int val1[maxn], val2[maxn];
vector<pair<int, int> > querry;
int seg1[4 * maxn], seg2[4 * maxn];
void update1(int ind, int l, int r, int x, int val) {
seg1[ind] += val;
if (r - l < 2) return;
int mid = (l + r) / 2;
if (x < mid)
update1(2 * ind, l, mid, x, val);
else
update1(2 * ind + 1, mid, r, x, val);
}
void update2(int ind, int l, int r, int x, int val) {
seg2[ind] += val;
if (r - l < 2) return;
int mid = (l + r) / 2;
if (x < mid)
update2(2 * ind, l, mid, x, val);
else
update2(2 * ind + 1, mid, r, x, val);
}
int get1(int ind, int l, int r, int x, int y) {
if (y <= l || r <= x) return 0;
if (x <= l && r <= y) return seg1[ind];
int mid = (l + r) / 2;
return get1(2 * ind, l, mid, x, y) + get1(2 * ind + 1, mid, r, x, y);
}
int get2(int ind, int l, int r, int x, int y) {
if (y <= l || r <= x) return 0;
if (x <= l && r <= y) return seg2[ind];
int mid = (l + r) / 2;
return get2(2 * ind, l, mid, x, y) + get2(2 * ind + 1, mid, r, x, y);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(30);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int type;
cin >> type;
if (type == 1) {
int d, x;
cin >> d >> x;
d--;
int cur = min(val1[d] + x, b);
int p = cur - val1[d];
update1(1, 0, n, d, p);
val1[d] += p;
cur = min(val2[d] + x, a);
p = cur - val2[d];
update2(1, 0, n, d, p);
val2[d] += p;
} else {
int p;
cin >> p;
p--;
int ans = 0;
if (p) ans += get1(1, 0, n, 0, p);
if (p + k != n) ans += get2(1, 0, n, p + k, n);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI =
3.141592653589793238462643383279502884197169399375105820974944592307816406286;
class SegmentTree {
long long int T[2 * 200002], N;
public:
int F(int A, int B) { return A + B; }
void build(int size, long long int *V) {
N = size;
for (int i = N; i < 2 * N; i++) T[i] = V[i - N];
for (int i = N - 1; i > 0; i--) T[i] = F(T[i << 1], T[i << 1 | 1]);
}
void set(int pos, long long int val) {
pos += N;
for (T[pos] = val; pos > 1; pos >>= 1) T[pos >> 1] = F(T[pos], T[pos ^ 1]);
}
long long int query(int i, int j) {
i += N;
j += N + 1;
long long int ret = 0;
while (i < j) {
if (i % 2) ret = F(ret, T[i++]);
if (j % 2) ret = F(ret, T[--j]);
i >>= 1;
j >>= 1;
}
return ret;
}
};
SegmentTree TA, TB;
long long int VA[200002], VB[200002];
long long int n, k, a, b, q, o, x, y;
int main() {
ios_base::sync_with_stdio(false);
scanf("%I64d %I64d %I64d %I64d %I64d", &n, &k, &a, &b, &q);
memset(VA, 0, sizeof(VA));
memset(VB, 0, sizeof(VB));
TA.build(n, VA);
TB.build(n, VB);
for (int i = 0; i < q; i++) {
scanf("%I64d", &o);
if (o == 1) {
scanf("%I64d %I64d", &x, &y);
x--;
TA.set(x, -VA[x]);
TB.set(x, -VB[x]);
VA[x] = min(a, VA[x] + y);
VB[x] = min(b, VB[x] + y);
TA.set(x, VA[x]);
TB.set(x, VB[x]);
} else {
scanf("%I64d", &x);
x--;
long long ret = 0;
if (x > 0) ret += TB.query(0, x - 1);
if (x + k < n) ret += TA.query(x + k, n - 1);
printf("%I64d\n", ret);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int BASE = 1 << 18;
int n, k, a, b, q, d, val, p, type;
int TreeA[1000000];
int TreeB[1000000];
void UpdateA(int, int);
void UpdateB(int, int);
int QueryA(int, int, int, int, int);
int QueryB(int, int, int, int, int);
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &d, &val);
UpdateA(d, val);
UpdateB(d, val);
} else {
scanf("%d", &p);
printf("%d\n", QueryB(1, 0, BASE - 1, 0, p - 1) +
QueryA(1, 0, BASE - 1, p + k, n));
}
}
}
void UpdateA(int x, int val) {
x += BASE;
if (TreeA[x] != a) {
TreeA[x] += val;
TreeA[x] = min(a, TreeA[x]);
do {
x /= 2;
TreeA[x] = TreeA[x * 2] + TreeA[x * 2 + 1];
} while (x != 1);
}
}
void UpdateB(int x, int val) {
x += BASE;
if (TreeB[x] != b) {
TreeB[x] += val;
TreeB[x] = min(b, TreeB[x]);
do {
x /= 2;
TreeB[x] = TreeB[x * 2] + TreeB[x * 2 + 1];
} while (x != 1);
}
}
int QueryA(int i, int pocz, int kon, int a, int b) {
if (a <= pocz && kon <= b) {
return TreeA[i];
} else {
int sum = 0;
int sr = (pocz + kon) / 2;
if (a <= sr) {
sum += QueryA(i * 2, pocz, sr, a, b);
}
if (sr + 1 <= b) {
sum += QueryA(i * 2 + 1, sr + 1, kon, a, b);
}
return sum;
}
}
int QueryB(int i, int pocz, int kon, int a, int b) {
if (a <= pocz && kon <= b) {
return TreeB[i];
} else {
int sum = 0;
int sr = (pocz + kon) / 2;
if (a <= sr) {
sum += QueryB(i * 2, pocz, sr, a, b);
}
if (sr + 1 <= b) {
sum += QueryB(i * 2 + 1, sr + 1, kon, a, b);
}
return sum;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, b, q;
void pluss(vector<long long> &t, long long v, long long tl, long long tr,
long long l, long long r, long long x, long long p) {
if (l > tr || tl > r) return;
if (tl >= l && tr <= r) {
t[v] = min(t[v] + x, p ? b : a);
return;
}
long long tm = (tl + tr) / 2;
pluss(t, v * 2, tl, tm, l, r, x, p);
pluss(t, v * 2 + 1, tm + 1, tr, l, r, x, p);
t[v] = t[v * 2] + t[v * 2 + 1];
}
long long get_sum(vector<long long> &t, long long v, long long tl, long long tr,
long long l, long long r) {
if (l > tr || tl > r) return 0;
if (tl >= l && tr <= r) {
return t[v];
}
long long tm = (tl + tr) / 2;
return get_sum(t, v * 2, tl, tm, l, r) +
get_sum(t, v * 2 + 1, tm + 1, tr, l, r);
}
signed main() {
cin >> n >> k >> a >> b >> q;
vector<long long> t(n * 4);
vector<long long> tt(n * 4);
while (q--) {
long long c;
scanf("%I64d", &c);
if (c == 1) {
long long num, cnt;
scanf("%I64d %I64d", &num, &cnt);
pluss(t, 1, 1, n, num, num, cnt, 0);
pluss(tt, 1, 1, n, num, num, cnt, 1);
} else {
long long ind;
scanf("%I64d", &ind);
long long l = ind + k;
long long ans;
if (l > n)
ans = 0;
else {
ans = get_sum(t, 1, 1, n, l, n);
}
ans += get_sum(tt, 1, 1, n, 1, ind - 1);
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace ::std;
class SegT {
public:
int op(int x, int y) { return (x + y); }
int up(int n) {
int m = 1;
n--;
while (n) {
n >>= 1;
m <<= 1;
}
return m;
}
SegT(int n) {
ID = 0;
sz = up(n);
P = new int[2 * sz];
for (int i = 0; i < 2 * sz; i++) P[i] = ID;
}
~SegT() { delete[] P; }
void update(int idx, int val) {
idx += sz;
P[idx] = val;
idx >>= 1;
while (idx) {
P[idx] = op(P[2 * idx], P[2 * idx + 1]);
idx >>= 1;
}
}
void update_delta(int idx, int delta) {
idx += sz;
P[idx] = op(P[idx], delta);
idx >>= 1;
while (idx) {
P[idx] = op(P[2 * idx], P[2 * idx + 1]);
idx >>= 1;
}
}
int range_val(int idx, int beg, int end, int s, int e) {
if (s > end || e < beg) return ID;
if (beg >= s && end <= e) return P[idx];
int mid = (beg + end) / 2;
return op(range_val(2 * idx, beg, mid, s, e),
range_val(2 * idx + 1, mid + 1, end, s, e));
}
int range_val(int s, int e) { return range_val(1, 0, sz - 1, s, e); }
private:
int ID;
int sz;
int *P;
};
int main() {
int n, k, a, b, q;
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &q);
SegT left(n + 5);
SegT right(n + 5);
vector<int> ord(n + 5, 0);
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, x;
scanf("%d", &d);
scanf("%d", &x);
int prev = ord[d];
if (prev < b) {
int delta = min(x, b - prev);
left.update_delta(d, delta);
}
if (prev < a) {
int delta = min(x, a - prev);
right.update_delta(d, delta);
}
ord[d] += x;
if (ord[d] > a) ord[d] = a;
} else {
int p;
scanf("%d", &p);
int ans = left.range_val(0, p - 1);
ans += right.range_val(p + k, n + 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 1;
inline long long input(void) {
char t;
long long x = 0;
int neg = 0;
t = getchar();
while ((t < 48 || t > 57) && t != '-') t = getchar();
if (t == '-') {
neg = 1;
t = getchar();
}
while (t >= 48 && t <= 57) {
x = (x << 3) + (x << 1) + t - 48;
t = getchar();
}
if (neg) x = -x;
return x;
}
inline void output(long long x) {
char a[20];
int i = 0, j;
a[0] = '0';
if (x < 0) {
putchar('-');
x = -x;
}
if (x == 0) putchar('0');
while (x) {
a[i++] = x % 10 + 48;
x /= 10;
}
for (j = i - 1; j >= 0; j--) {
putchar(a[j]);
}
putchar('\n');
}
long long Tree[1000010][2], a, b;
inline void maketree(int vertex, int idx, int l, int r) {
if (l == r) {
Tree[vertex][idx] = 0;
return;
}
int m = (l + r) / 2, left = 2 * vertex, right = left + 1;
maketree(left, idx, l, m);
maketree(right, idx, m + 1, r);
Tree[vertex][idx] = 0;
return;
}
inline void update(int vertex, int idx, int l, int r, int index, int value) {
if (l == r) {
Tree[vertex][idx] += value;
if (idx == 0 && Tree[vertex][idx] > a)
Tree[vertex][idx] = a;
else if (idx == 1 && Tree[vertex][idx] > b)
Tree[vertex][idx] = b;
return;
}
int m = (l + r) / 2, left = 2 * vertex, right = left + 1;
if (index > m)
update(right, idx, m + 1, r, index, value);
else
update(left, idx, l, m, index, value);
Tree[vertex][idx] = Tree[left][idx] + Tree[right][idx];
return;
}
inline long long query(int vertex, int idx, int l, int r, int u, int v) {
if (l == u && r == v) return Tree[vertex][idx];
int m = (l + r) / 2, left = 2 * vertex, right = left + 1;
if (v <= m) return query(left, idx, l, m, u, v);
if (u > m) return query(right, idx, m + 1, r, u, v);
long long a, b;
a = query(left, idx, l, m, u, m);
b = query(right, idx, m + 1, r, m + 1, v);
return (a + b);
}
int main() {
long long n, k, q, type, x, d, p, ans, sz;
n = input();
k = input();
a = input();
b = input();
q = input();
maketree(1, 0, 0, n - 1);
maketree(1, 1, 0, n - 1);
while (q--) {
type = input();
if (type == 1) {
d = input();
d -= 1;
x = input();
update(1, 0, 0, n - 1, d, x);
update(1, 1, 0, n - 1, d, x);
} else {
p = input();
p -= 1;
ans = 0;
sz = p;
if (sz) ans += query(1, 1, 0, n - 1, 0, p - 1);
sz = n - p - k;
if (sz) ans += query(1, 0, 0, n - 1, p + k, n - 1);
output(ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q, c[200010], tem, x, y;
struct node {
int t1, t2;
} tree[200010];
void add(int s, int v, int t) {
if (t == 1)
while (s <= n) {
tree[s].t1 += v;
s += s & (-s);
}
else
while (s <= n) {
tree[s].t2 += v;
s += s & (-s);
}
}
int sum(int s, int t) {
int res = 0;
if (t == 1)
while (s) {
res += tree[s].t1;
s -= s & (-s);
}
else
while (s) {
res += tree[s].t2;
s -= s & (-s);
}
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
memset(tree, 0, sizeof(tree));
memset(c, 0, sizeof(c));
for (int i = 0; i < q; i++) {
scanf("%d", &tem);
if (tem == 1) {
scanf("%d%d", &x, &y);
if (c[x] < a) add(x, min(y, a - c[x]), 2);
if (c[x] < b) add(x, min(y, b - c[x]), 1);
c[x] += y;
} else {
scanf("%d", &x);
int ans = 0;
if (x != 1) ans += sum(x - 1, 1);
if (x + k <= n) ans += sum(n, 2) - sum(x + k - 1, 2);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, q, a, b;
vector<int> ta, tb;
vector<int> orders;
int tsize;
void update(vector<int>& t, int i, int val) {
i += tsize;
t[i] = val;
i >>= 1;
while (i) {
t[i] = t[i * 2] + t[i * 2 + 1];
i >>= 1;
}
}
int sum(vector<int>& t, int l, int r) {
l += tsize;
r += tsize;
int ret = 0;
while (l <= r) {
if (l & 1) ret += t[l++];
if (!(r & 1)) ret += t[r--];
l /= 2;
r /= 2;
}
return ret;
}
int main() {
cin >> n >> k >> a >> b >> q;
tsize = 1;
while (tsize < n) tsize *= 2;
ta = vector<int>(2 * tsize + 10);
tb = vector<int>(2 * tsize + 10);
orders = vector<int>(n);
for (int i = 0; i < (int)(q); i++) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int d, cnt;
scanf("%d %d", &d, &cnt);
d--;
orders[d] += cnt;
update(ta, d, min(a, orders[d]));
update(tb, d, min(b, orders[d]));
} else {
int p;
scanf("%d", &p);
p--;
printf("%d\n", sum(tb, 0, p - 1) + sum(ta, p + k, n - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using std::min;
using std::vector;
struct indexed_tree {
int k = 1;
vector<long long> tree;
indexed_tree(int n) {
while (k < n) {
k *= 2;
}
tree.resize(k * 2, 0);
k--;
}
void update(int i, long long a) {
tree[k + i] = a;
int temp = (k + i) / 2;
while (temp != 0) {
tree[temp] = tree[temp * 2] + tree[temp * 2 + 1];
temp /= 2;
}
}
long long range_sum(int i, int j) {
int left = k + i;
int right = k + j;
long long ret = 0;
while (1) {
if (left > right) {
break;
}
if (left == right) {
ret += tree[left];
break;
}
if (left % 2 == 1) {
ret += tree[left];
}
if (right % 2 == 0) {
ret += tree[right];
}
left = (left + 1) / 2;
right = (right - 1) / 2;
}
return ret;
}
};
long long arr[200010];
int main() {
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
indexed_tree one(n), two(n);
for (int i = 0; i < q; i++) {
int qe;
scanf("%d", &qe);
if (qe == 1) {
int d, ai;
scanf("%d%d", &d, &ai);
arr[d] += ai;
one.update(d, min(arr[d], (long long)b));
two.update(d, min(arr[d], (long long)a));
} else if (qe == 2) {
int p;
scanf("%d", &p);
long long ans = 0;
ans = one.range_sum(1, p - 1) + two.range_sum(p + k, n);
printf("%lld\n", ans);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.