text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
long long oo = (long long)1e9 + 7;
int n, k, a, b, q;
int fuck[6 * 100008] = {0}, lol[6 * 100008] = {0};
void input() {
scanf("%d%d", &n, &k);
scanf("%d%d", &a, &b);
scanf("%d", &q);
}
void updat(int p, int l, int r, int day, int val) {
if (day > r || day < l) return;
if (l == r && l == day) {
fuck[p] += val;
fuck[p] = min(fuck[p], a);
return;
}
int son = p << 1, midd = (l + r) >> 1;
updat(son, l, midd, day, val);
updat(son + 1, midd + 1, r, day, val);
fuck[p] = fuck[son] + fuck[son + 1];
}
void update(int p, int l, int r, int day, int val) {
if (day > r || day < l) return;
if (l == r && l == day) {
lol[p] += val;
lol[p] = min(lol[p], b);
return;
}
int son = p << 1, midd = (l + r) >> 1;
update(son, l, midd, day, val);
update(son + 1, midd + 1, r, day, val);
lol[p] = lol[son] + lol[son + 1];
}
int sum(int p, int l, int r, int st, int nd) {
if (st > r || nd < l) return 0;
if (l >= st && r <= nd) return fuck[p];
int son = p << 1, midd = (l + r) >> 1;
return sum(son, l, midd, st, nd) + sum(son + 1, midd + 1, r, st, nd);
}
int get(int p, int l, int r, int st, int nd) {
if (st > r || nd < l) return 0;
if (l >= st && r <= nd) return lol[p];
int son = p << 1, midd = (l + r) >> 1;
return get(son, l, midd, st, nd) + get(son + 1, midd + 1, r, st, nd);
}
int main() {
input();
for (int i = 0; i < q; i++) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int ai, di;
scanf("%d%d", &di, &ai);
updat(1, 1, n, di, ai);
update(1, 1, n, di, ai);
} else {
int p;
scanf("%d", &p);
int ans = 0;
if (p > 1) ans += get(1, 1, n, 1, p - 1);
if (p + k <= n) ans += sum(1, 1, n, p + k, n);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int arbbrk[4 * 200003], arbrep[4 * 200003], n, a, b, k, q, ans, z, x, p, d;
void update(int arb[], int nod, int left, int right, int val, int poz, int c) {
int mij = (left + right) >> 1;
if (left == right) {
arb[nod] += val;
arb[nod] = min(arb[nod], c);
return;
}
if (poz <= mij)
update(arb, 2 * nod, left, mij, val, poz, c);
else
update(arb, 2 * nod + 1, mij + 1, right, val, poz, c);
arb[nod] = arb[2 * nod] + arb[2 * nod + 1];
}
void query(int arb[], int nod, int left, int right, int L, int R) {
int mij = (left + right) >> 1;
if (left > R || right < L) {
return;
}
if (left >= L && right <= R) {
ans += arb[nod];
return;
}
query(arb, 2 * nod, left, mij, L, R);
query(arb, 2 * nod + 1, mij + 1, right, L, R);
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; ++i) {
cin >> z;
if (z == 1) {
cin >> d >> p;
update(arbbrk, 1, 1, n, p, d, b);
update(arbrep, 1, 1, n, p, d, a);
} else {
cin >> x;
ans = 0;
query(arbbrk, 1, 1, n, 1, x - 1);
query(arbrep, 1, 1, n, x + k, n);
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, tp, ans, c[2][210001], m, t1, t2, w, a[210001];
void change(int *c, int x, int d) {
for (; x <= n; x += x & (-x)) c[x] += d;
}
int query(int *c, int x) {
int res = 0;
for (; x; x -= x & (-x)) res += c[x];
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &w, &t1, &t2, &m);
memset(c, 0, sizeof(c));
memset(a, 0, sizeof(a));
for (i = 1; i <= m; i++) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d", &j, &k);
change(c[0], j, min(t2, a[j] + k) - min(t2, a[j]));
change(c[1], n - j + 1, min(t1, a[j] + k) - min(t1, a[j]));
a[j] += k;
} else {
scanf("%d", &j);
ans = query(c[0], j - 1) + query(c[1], n - (j + w) + 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using D = double;
using uint = unsigned int;
const int treesize = 1 << 18;
int treea[2 * treesize], treeb[2 * treesize];
int n, k, a, b, q;
inline void upd(int *tree, int x) {
x /= 2;
while (x > 0) {
tree[x] = tree[x * 2] + tree[x * 2 + 1];
x /= 2;
}
}
inline int get(int *tree, int cur, int cl, int cr, int l, int r) {
if (cl > r || cr < l) return 0;
if (cl >= l && cr <= r) {
return tree[cur];
}
int cm = (cl + cr) / 2;
return get(tree, cur * 2, cl, cm, l, r) +
get(tree, cur * 2 + 1, cm + 1, cr, l, r);
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, y;
scanf("%d%d", &x, &y);
x--;
treeb[treesize + x] = min(b, treeb[treesize + x] + y);
upd(treeb, treesize + x);
treea[treesize + x] = min(a, treea[treesize + x] + y);
upd(treea, treesize + x);
} else {
int p;
scanf("%d", &p);
p--;
printf("%d\n", get(treeb, 1, 0, treesize - 1, 0, p - 1) +
get(treea, 1, 0, treesize - 1, p + k, n - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class ValueType>
class SegmentTree {
private:
int SIZE;
int *Left, *Right;
ValueType *value, *minimum, *maximum;
ValueType *lazy_add, *lazy_set_val;
bool *lazy_set;
void clearVertex(int v) {
if (lazy_set[v]) {
value[v] = lazy_set_val[v] * (Right[v] - Left[v]);
minimum[v] = maximum[v] = lazy_set_val[v];
lazy_set[v] = false;
if (Left[v] + 1 != Right[v]) {
lazy_set[2 * v] = lazy_set[2 * v + 1] = true;
lazy_set_val[2 * v] = lazy_set_val[2 * v + 1] = lazy_set_val[v];
lazy_add[2 * v] = lazy_add[2 * v + 1] = 0;
}
}
if (lazy_add[v]) {
value[v] += lazy_add[v] * (Right[v] - Left[v]);
minimum[v] += lazy_add[v];
maximum[v] += lazy_add[v];
if (Left[v] + 1 != Right[v]) {
if (lazy_set[2 * v]) clearVertex(2 * v);
lazy_add[2 * v] += lazy_add[v];
if (lazy_set[2 * v + 1]) clearVertex(2 * v + 1);
lazy_add[2 * v + 1] += lazy_add[v];
}
lazy_add[v] = 0;
}
}
ValueType getSum(int v, int l, int r) {
clearVertex(v);
if (l == Left[v] && r == Right[v]) return value[v];
int middle = (Left[v] + Right[v]) / 2;
if (middle >= r) return getSum(2 * v, l, r);
if (middle <= l) return getSum(2 * v + 1, l, r);
return getSum(2 * v, l, middle) + getSum(2 * v + 1, middle, r);
}
ValueType getMin(int v, int l, int r) {
clearVertex(v);
if (l == Left[v] && r == Right[v]) return minimum[v];
int middle = (Left[v] + Right[v]) / 2;
if (middle >= r) return getMin(2 * v, l, r);
if (middle <= l) return getMin(2 * v + 1, l, r);
return min(getMin(2 * v, l, middle), getMin(2 * v + 1, middle, r));
}
ValueType getMax(int v, int l, int r) {
clearVertex(v);
if (l == Left[v] && r == Right[v]) return maximum[v];
int middle = (Left[v] + Right[v]) / 2;
if (middle >= r) return getMax(2 * v, l, r);
if (middle <= l) return getMax(2 * v + 1, l, r);
return max(getMax(2 * v, l, middle), getMax(2 * v + 1, middle, r));
}
void add(int v, int l, int r, ValueType val) {
clearVertex(v);
if (l == Left[v] && r == Right[v]) {
lazy_add[v] = val;
return;
}
int middle = (Left[v] + Right[v]) / 2;
if (middle >= r)
add(2 * v, l, r, val);
else if (middle <= l)
add(2 * v + 1, l, r, val);
else {
add(2 * v, l, middle, val);
add(2 * v + 1, middle, r, val);
}
value[v] += (r - l) * val;
minimum[v] = min(minimum[2 * v] + lazy_add[2 * v],
minimum[2 * v + 1] + lazy_add[2 * v + 1]);
maximum[v] = max(maximum[2 * v] + lazy_add[2 * v],
maximum[2 * v + 1] + lazy_add[2 * v + 1]);
}
void setValue(int v, int l, int r, ValueType val) {
clearVertex(v);
if (l == Left[v] && r == Right[v]) {
lazy_set_val[v] = val;
lazy_set[v] = true;
return;
}
int middle = (Left[v] + Right[v]) / 2;
if (middle >= r)
setValue(2 * v, l, r, val);
else if (middle <= l)
setValue(2 * v + 1, l, r, val);
else {
setValue(2 * v, l, middle, val);
setValue(2 * v + 1, middle, r, val);
}
value[v] =
(lazy_set[2 * v] ? lazy_set_val[2 * v] * (middle - Left[v])
: value[2 * v]) +
(lazy_set[2 * v + 1] ? lazy_set_val[2 * v + 1] * (Right[v] - middle)
: value[2 * v + 1]);
minimum[v] = min(
(lazy_set[2 * v] ? lazy_set_val[2 * v] : minimum[2 * v]),
(lazy_set[2 * v + 1] ? lazy_set_val[2 * v + 1] : minimum[2 * v + 1]));
maximum[v] = max(
(lazy_set[2 * v] ? lazy_set_val[2 * v] : maximum[2 * v]),
(lazy_set[2 * v + 1] ? lazy_set_val[2 * v + 1] : maximum[2 * v + 1]));
}
public:
void init(int len) {
for (SIZE = 1; SIZE < len; SIZE *= 2)
;
Left = (int *)malloc(sizeof(int) * 2 * SIZE);
Right = (int *)malloc(sizeof(int) * 2 * SIZE);
value = (ValueType *)malloc(sizeof(ValueType) * 2 * SIZE);
minimum = (ValueType *)malloc(sizeof(ValueType) * 2 * SIZE);
maximum = (ValueType *)malloc(sizeof(ValueType) * 2 * SIZE);
lazy_add = (ValueType *)malloc(sizeof(ValueType) * 2 * SIZE);
lazy_set_val = (ValueType *)malloc(sizeof(ValueType) * 2 * SIZE);
lazy_set = (bool *)malloc(sizeof(bool) * 2 * SIZE);
Left[1] = 0;
Right[1] = SIZE;
for (int i = (1); i <= (SIZE - 1); i++) {
Left[2 * i] = Left[i];
Right[2 * i] = (Left[i] + Right[i]) / 2;
Left[2 * i + 1] = (Left[i] + Right[i]) / 2;
Right[2 * i + 1] = Right[i];
}
for (int i = 0; i < (2 * SIZE); i++) {
value[i] = minimum[i] = maximum[i] = lazy_add[i] = ValueType();
lazy_set[i] = false;
}
}
ValueType getSum(int l, int r) {
if (l == r) return 0;
return getSum(1, l, r);
}
ValueType getMin(int l, int r) { return getMin(1, l, r); }
ValueType getMax(int l, int r) { return getMax(1, l, r); }
void add(int l, int r, ValueType val) { add(1, l, r, val); }
void setValue(int l, int r, ValueType val) { setValue(1, l, r, val); }
};
int N, K, A, B, Q;
SegmentTree<int> sa, sb;
int main(int argc, char *argv[]) {
scanf("%d%d%d%d%d", &N, &K, &A, &B, &Q);
sa.init(N);
sb.init(N);
while (Q--) {
int cmd;
scanf("%d", &cmd);
if (cmd == 1) {
int d, add;
scanf("%d%d", &d, &add);
d--;
int val = sa.getSum(d, d + 1);
sa.setValue(d, d + 1, min(val + add, A));
val = sb.getSum(d, d + 1);
sb.setValue(d, d + 1, min(val + add, B));
} else {
int p;
scanf("%d", &p);
p--;
printf("%d\n", sb.getSum(0, p) + sa.getSum(p + K, N));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[2010000], L[2010000], R[2010000];
int n, m, x, y, q;
void addL(int a, int b) {
for (int i = a; i <= n; i += ((i) & (-i))) L[i] += b;
}
void addR(int a, int b) {
for (int i = n - a + 1; i <= n; i += ((i) & (-i))) R[i] += b;
}
int getL(int a) {
int ans = 0;
for (; a > 0; a -= ((a) & (-a))) ans += L[a];
return ans;
}
int getR(int a) {
int ans = 0;
for (a = n - a + 1; a > 0; a -= ((a) & (-a))) ans += R[a];
return ans;
}
int main() {
scanf("%d %d %d %d %d", &n, &m, &y, &x, &q);
for (; q; q--) {
int ch;
scanf("%d", &ch);
if (ch == 1) {
int a, b;
scanf("%d %d", &b, &a);
int pas = A[b];
A[b] += a;
addL(b, min(A[b], x) - min(pas, x));
addR(b, min(A[b], y) - min(pas, y));
} else {
int a;
scanf("%d", &a);
int ans = 0;
ans += getL(a - 1);
ans += getR(a + m);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n, k, a, b, q;
int val[4 * N], sma[4 * N], smb[4 * N];
void update(int nod, int pozx, int pozy, int poz, int el) {
if (pozx == pozy) {
val[nod] += el;
sma[nod] = min(val[nod], a);
smb[nod] = min(val[nod], b);
return;
}
int mid = (pozx + pozy) / 2;
if (mid >= poz)
update(2 * nod, pozx, mid, poz, el);
else
update(2 * nod + 1, mid + 1, pozy, poz, el);
sma[nod] = sma[2 * nod] + sma[2 * nod + 1];
smb[nod] = smb[2 * nod] + smb[2 * nod + 1];
}
int query(int op, int nod, int pozx, int pozy, int poz1, int poz2) {
if (poz2 == 0 || poz1 > n) return 0;
if (pozx >= poz1 && poz2 >= pozy) {
if (op == 2) return sma[nod];
return smb[nod];
}
int mid = (pozx + pozy) / 2, r = 0;
if (mid >= poz1) r = query(op, 2 * nod, pozx, mid, poz1, poz2);
if (mid < poz2) r += query(op, 2 * nod + 1, mid + 1, pozy, poz1, poz2);
return r;
}
int main() {
int i;
cin >> n >> k >> a >> b >> q;
for (i = 1; i <= q; ++i) {
int op, n1, n2;
scanf("%d%d", &op, &n1);
if (op == 1) {
scanf("%d", &n2);
update(1, 1, n, n1, n2);
} else {
printf("%d\n",
query(1, 1, 1, n, 1, n1 - 1) + query(2, 1, 1, n, n1 + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, k, a, b, q;
int cnt[MAXN];
int sum1[MAXN];
int sum2[MAXN];
void modify(int *sum, int p, int v) {
while (p <= n) {
sum[p] += v;
p += p & -p;
}
}
int query(int *sum, int p) {
int res = 0;
while (p >= 1) {
res += sum[p];
p -= p & -p;
}
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int tp, d, A, p, i = 1; i <= q; i++) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d", &d, &A);
modify(sum1, d, min(A, max(0, b - cnt[d])));
modify(sum2, d, min(A, max(0, a - cnt[d])));
cnt[d] += A;
} else {
scanf("%d", &p);
int ed = min(n, p + k - 1);
printf("%d\n", query(sum1, p - 1) + query(sum2, n) - query(sum2, ed));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q, t, x, val;
long long A[4 * 200005], B[4 * 200005];
void update(long long *tree, int low, int high, int idx, int val, int limit,
int pos) {
if (low == high) {
tree[pos] = min(tree[pos] + val, (long long)limit);
return;
}
int mid = (low + high) / 2;
if (idx <= mid)
update(tree, low, mid, idx, val, limit, pos * 2);
else
update(tree, mid + 1, high, idx, val, limit, pos * 2 + 1);
tree[pos] = tree[pos * 2] + tree[pos * 2 + 1];
}
long long query(long long *tree, int low, int high, int qlow, int qhigh,
int pos) {
if (qhigh < qlow) return 0;
if (low >= qlow && high <= qhigh) {
return tree[pos];
}
int mid = (low + high) / 2;
if (qhigh <= mid)
return query(tree, low, mid, qlow, qhigh, pos * 2);
else if (qlow > mid)
return query(tree, mid + 1, high, qlow, qhigh, pos * 2 + 1);
else
return query(tree, low, mid, qlow, qhigh, pos * 2) +
query(tree, mid + 1, high, qlow, qhigh, pos * 2 + 1);
}
int main() {
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d %d", &x, &val);
update(A, 1, n, x, val, b, 1);
update(B, 1, n, x, val, a, 1);
} else {
scanf("%d", &x);
long long res = query(A, 1, n, 1, x - 1, 1) + query(B, 1, n, x + k, n, 1);
printf("%I64d\n", res);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXINT = 1073741823;
struct node {
int value = 0, low = 0, high = 0;
} segment[MAXN * 4];
int a, b;
vector<int> selection;
void select(int from, int to, int current, int beginning, int ending) {
if (from > ending || to < beginning)
return;
else if (beginning <= from && to <= ending) {
selection.push_back(current);
return;
}
int mid = (from + to) / 2;
select(from, mid, current * 2 + 1, beginning, ending);
select(mid + 1, to, current * 2 + 2, beginning, ending);
return;
}
void update(int from, int to, int current, int index, int value) {
if (from > index || to < index)
return;
else if (from == to) {
segment[current].value += value;
segment[current].high = min(a, segment[current].value);
segment[current].low = min(b, segment[current].value);
return;
}
int mid = (from + to) / 2;
update(from, mid, current * 2 + 1, index, value);
update(mid + 1, to, current * 2 + 2, index, value);
segment[current].low =
segment[current * 2 + 1].low + segment[current * 2 + 2].low;
segment[current].high =
segment[current * 2 + 1].high + segment[current * 2 + 2].high;
return;
}
void display(int from, int to, int current) {
cout << from << ' ' << to << ' ' << current << ' ' << segment[current].low
<< ' ' << segment[current].high << '\n';
if (from == to) return;
int mid = (from + to) / 2;
display(from, mid, current * 2 + 1);
display(mid + 1, to, current * 2 + 2);
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, t, type, day, value, answer;
cin >> n >> k >> a >> b >> t;
for (int q = 0; q < t; q++) {
cin >> type >> day;
day--;
if (type == 1) {
cin >> value;
update(0, n - 1, 0, day, value);
} else {
answer = 0;
if (day != 0) {
selection.clear();
select(0, n - 1, 0, 0, day - 1);
for (int i : selection) answer += segment[i].low;
}
if (day != n - 1) {
selection.clear();
select(0, n - 1, 0, day + k, n - 1);
for (int i : selection) answer += segment[i].high;
}
cout << answer << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int i, j, k, l, K, n, r, c, a, b, q, A[200001], B[200001], first,
second, z, v[200001];
void updateA(int pos, int val) {
int t = a - v[pos];
if (t < 0) t = 0;
t = min(t, val);
if (t)
for (int i = pos; i <= n; i += i & (-i)) {
A[i] += t;
}
}
void updateB(int pos, int val) {
int t = b - v[pos];
if (t < 0) t = 0;
t = min(t, val);
if (t)
for (int i = pos; i <= n; i += i & (-i)) {
B[i] += t;
}
}
long long int querryA(int pos) {
int r = 0;
for (int i = pos; i; i -= i & (-i)) {
r += A[i];
}
return r;
}
long long int querryB(int pos) {
int r = 0;
for (int i = pos; i; i -= i & (-i)) {
r += B[i];
}
return r;
}
int main() {
ios::sync_with_stdio(false);
cout.precision(10);
cout << fixed;
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> first;
if (first == 1) {
cin >> second >> z;
updateA(second, z);
updateB(second, z);
v[second] += z;
} else {
long long int valA, valB;
valA = valB = 0;
cin >> first;
if (first != 1) valA = querryB(first - 1);
if (first + k <= n) valB = querryA(n) - querryA(first + k - 1);
cout << valA + valB << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 9;
const long long mod = 1e9 + 7;
int fen1[maxn], fen2[maxn], num[maxn];
void upd1(int x, int val) {
for (; x < maxn; x += x & -x) fen1[x] += val;
}
void upd2(int x, int val) {
for (; x < maxn; x += x & -x) fen2[x] += val;
}
int get1(int x) {
int res = 0;
for (; x; x -= x & -x) res += fen1[x];
return res;
}
int get2(int x) {
int res = 0;
for (; x; x -= x & -x) res += fen2[x];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int type, d, x, p;
cin >> type;
if (type == 1) {
cin >> d >> x;
upd1(d, -min(num[d], b));
upd2(d, -min(num[d], a));
num[d] += x;
upd1(d, min(num[d], b));
upd2(d, min(num[d], a));
}
if (type == 2) {
cin >> p;
cout << get1(p - 1) + get2(maxn - 1) - get2(p + k - 1) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 2e5 + 10;
int n, k, a, b, q, i;
int tip, d, p, lll;
pair<int, int> arb[4 * Nmax];
void update(int nod, int st, int dr, int val, int poz) {
if (st >= dr) {
arb[nod].first = min(b, arb[nod].first + val);
arb[nod].second = min(a, arb[nod].second + val);
return;
}
int mij = (st + dr) >> 1;
if (poz <= mij)
update((nod << 1), st, mij, val, poz);
else
update(((nod << 1) | 1), mij + 1, dr, val, poz);
arb[nod].first = arb[(nod << 1)].first + arb[((nod << 1) | 1)].first;
arb[nod].second = arb[(nod << 1)].second + arb[((nod << 1) | 1)].second;
}
int query(int nod, int st, int dr, int a, int b, int r) {
if (a <= st && dr <= b)
if (r == 0)
return arb[nod].first;
else
return arb[nod].second;
int mij = (st + dr) >> 1;
int val1 = (a <= mij) ? query((nod << 1), st, mij, a, b, r) : 0;
int val2 = (mij < b) ? query(((nod << 1) | 1), mij + 1, dr, a, b, r) : 0;
return val1 + val2;
}
int main() {
scanf("%d %d", &n, &k);
scanf("%d %d", &a, &b);
scanf("%d", &q);
for (i = 1; i <= q; ++i) {
scanf("%d", &tip);
if (tip == 1) {
scanf("%d %d", &d, &p);
update(1, 1, n, p, d);
} else {
scanf("%d", &lll);
int v = 0;
if (lll > 1) v += query(1, 1, n, 1, lll - 1, 0);
if (lll + k <= n) v += query(1, 1, n, lll + k, n, 1);
printf("%d\n", v);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
void add(int *s, int k, int v) {
k++;
for (; k < 200005; k += -k & k) s[k] += v;
}
int get(int *s, int k) {
if (k < 0) return 0;
k++;
int ans = 0;
for (; k; k -= -k & k) ans += s[k];
return ans;
}
int N, K, A, B, a[200005], sa[200005], sb[200005];
int xa[200005], xb[200005];
int main() {
int Q;
cin >> N >> K >> A >> B >> Q;
while (Q--) {
int t, d;
scanf("%d%d", &t, &d);
if (t == 1) {
int inc;
scanf("%d", &inc);
add(sa, (N - (d) + 1), -xa[d]);
add(sb, d, -xb[d]);
a[d] += inc;
xa[d] = min(a[d], A);
xb[d] = min(a[d], B);
add(sa, (N - (d) + 1), xa[d]);
add(sb, d, xb[d]);
} else {
int ans = get(sb, d - 1);
if (d + K <= N) {
ans += get(sa, (N - (d + K) + 1));
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using Pii = pair<int, int>;
constexpr int MAX = 1000100;
using namespace std;
struct SegTree {
i64 sum[MAX];
int M, LIM;
void PushUp(int x) { sum[x] = sum[x << 1] + sum[(x << 1) | 1]; }
void Init(int n, int m) {
for (M = 1; M < n + 2; M <<= 1)
;
memset(sum, 0, sizeof(sum));
LIM = m;
}
void Update(int x, i64 add) {
sum[x |= M] += add;
if (sum[x] > LIM) sum[x] = LIM;
for (x >>= 1; x; x >>= 1) PushUp(x);
}
i64 Query(int l, int r) {
i64 ret = 0;
for (l = (l | M) - 1, r = (r | M) + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) ret += sum[l ^ 1];
if (r & 1) ret += sum[r ^ 1];
}
return ret;
}
} sta, stb;
int main() {
int n, k, a, b, q;
while (~scanf("%d%d%d%d%d", &n, &k, &a, &b, &q)) {
sta.Init(n, b);
stb.Init(n, a);
int c, u, v;
for (int i = 0; i < q; ++i) {
scanf("%d", &c);
if (c == 1) {
scanf("%d%d", &u, &v);
sta.Update(u, v);
stb.Update(u, v);
} else {
scanf("%d", &u);
i64 ans = 0;
if (u > 1) ans += sta.Query(1, u - 1);
if (u + k <= n) ans += stb.Query(u + k, n);
cout << ans << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 18);
long long tree1[2 * MAXN], tree2[2 * MAXN];
int n, a, k, q, b, t, di, ai, pi;
long long la, lb;
int main() {
memset(tree1, 0, sizeof tree1);
memset(tree2, 0, sizeof tree2);
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
la = a;
lb = b;
int NN = MAXN - 1;
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &di, &ai);
tree1[NN + di] = min(tree1[NN + di] + ai, la);
for (int node = (NN + di) / 2; node; node /= 2)
tree1[node] = tree1[2 * node] + tree1[2 * node + 1];
tree2[NN + di] = min(tree2[NN + di] + ai, lb);
for (int node = (NN + di) / 2; node; node /= 2)
tree2[node] = tree2[2 * node] + tree2[2 * node + 1];
} else {
scanf("%d", &pi);
long long res = 0;
int l = NN + 1;
int r = NN + pi - 1;
while (l <= r) {
if (l & 1) res += tree2[l];
if (!(r & 1)) res += tree2[r];
l = (l + 1) / 2;
r = (r - 1) / 2;
}
l = NN + pi + k, r = NN + n;
while (l <= r) {
if (l & 1) res += tree1[l];
if (!(r & 1)) res += tree1[r];
l = (l + 1) / 2;
r = (r - 1) / 2;
}
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 1000;
struct fenwick {
int BIT[MAXN];
void update(int idx, int val) {
while (idx < MAXN) {
BIT[idx] += val;
idx += idx & (-idx);
}
}
long long get(int idx) {
long long sum = 0;
while (idx > 0) {
sum += BIT[idx];
idx -= idx & (-idx);
}
return sum;
}
long long get(int l, int r) { return get(r) - get(l - 1); }
};
long long n, a, b, k, q, type, p, d, m;
fenwick before, after;
void print() {
cout << "BEFORE:\n";
for (int i = 1; i <= n; ++i) cout << before.get(i, i) << " ";
cout << "\n";
cout << "AFTER:\n";
for (int i = 1; i <= n; ++i) cout << after.get(i, i) << " ";
cout << "\n";
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; ++i) {
cin >> type;
if (type == 1) {
cin >> d >> m;
long long x1 = before.get(d, d);
long long x2 = after.get(d, d);
before.update(d, min(b, x1 + m) - x1);
after.update(d, min(a, x2 + m) - x2);
} else {
cin >> p;
if (p == 1)
cout << after.get(p + k, n) << "\n";
else if (p == n - k + 1)
cout << before.get(1, p - 1) << "\n";
else
cout << before.get(1, p - 1) + after.get(p + k, n) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
inline int max(int a, int b) { return a < b ? b : a; }
inline int min(int a, int b) { return a > b ? b : a; }
inline long long max(long long a, long long b) { return a < b ? b : a; }
inline long long min(long long a, long long b) { return a > b ? b : a; }
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long inf = 1e18;
long long power(long long a, long long n) {
if (n == 0) {
return 1;
}
long long b = power(a, n / 2);
b = b * b % mod;
if (n % 2) b = b * a % mod;
return b;
}
int add(int a, int b) { return (a + b) % mod; }
int mul(int a, int b) { return (long long)a * b % mod; }
int n, k, up1, up2, q;
long long seg[2][N], A[N];
void update(int a, int b, int nod, int pos) {
if (pos < a || pos > b) return;
if (a == b) {
seg[0][nod] = min(A[a], (long long)up1);
seg[1][nod] = min(A[a], (long long)up2);
return;
}
int m = (a + b) / 2;
update(a, m, 2 * nod, pos);
update(m + 1, b, 2 * nod + 1, pos);
for (int i = 0; i < 2; ++i)
seg[i][nod] = seg[i][nod * 2] + seg[i][nod * 2 + 1];
}
pair<long long, long long> query(int a, int b, int nod, int l, int r) {
if (r < a || l > b || l > r) return make_pair(0, 0);
if (l <= a && b <= r) {
return make_pair(seg[0][nod], seg[1][nod]);
}
int m = (a + b) / 2;
pair<long long, long long> x = query(a, m, 2 * nod, l, r),
y = query(m + 1, b, 2 * nod + 1, l, r);
return make_pair(x.first + y.first, x.second + y.second);
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &up1, &up2, &q);
while (q--) {
int x;
scanf("%d", &x);
if (x == 1) {
int d, a;
scanf("%d %d", &d, &a);
d--;
A[d] += a;
update(0, n - 1, 1, d);
} else {
int p;
scanf("%d", &p);
p--;
pair<long long, long long> x1 = query(0, n - 1, 1, 0, p - 1);
pair<long long, long long> x2 = query(0, n - 1, 1, p + k, n - 1);
printf("%lld\n", x1.second + x2.first);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
const int maxn = 3e5;
int sum[4 * maxn][2];
void add(int p, int x, int v = 1, int l = 0, int r = maxn) {
if (r - l == 1) {
sum[v][0] = min(b, sum[v][0] + x);
sum[v][1] = min(a, sum[v][1] + x);
return;
}
int m = (l + r) / 2;
if (p < m)
add(p, x, 2 * v, l, m);
else
add(p, x, 2 * v + 1, m, r);
sum[v][0] = sum[2 * v][0] + sum[2 * v + 1][0];
sum[v][1] = sum[2 * v][1] + sum[2 * v + 1][1];
}
int get(int a, int b, int mod, int v = 1, int l = 0, int r = maxn) {
if (a <= l && r <= b) return sum[v][mod];
if (r <= a || b <= l) return 0;
int m = (l + r) / 2;
return get(a, b, mod, 2 * v, l, m) + get(a, b, mod, 2 * v + 1, m, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int d, a;
cin >> d >> a;
add(d, a);
} else {
int p;
cin >> p;
cout << get(0, p, 0) + get(p + k, maxn, 1) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, q, k;
int va[200010], vb[200010];
int aib[2][200010];
int lsb(int x) { return (x & (x - 1)) ^ x; }
int query(int arb[], int pz) {
int sol = 0;
while (pz > 0) {
sol += arb[pz];
pz -= lsb(pz);
}
return sol;
}
void update(int arb[], int pz, int val) {
while (pz <= n) {
arb[pz] += val;
pz += lsb(pz);
}
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
int t, x, y;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &y);
update(aib[0], x, min(b - vb[x], y));
vb[x] += min(b - vb[x], y);
update(aib[1], n - x + 1, min(a - va[x], y));
va[x] += min(a - va[x], y);
} else {
scanf("%d", &x);
printf("%d\n", query(aib[0], x - 1) + query(aib[1], n - x - k + 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5;
int a, b;
struct Segment {
int sum[maxn * 4], suma[maxn * 4], sumb[maxn * 4];
void pushUp(int k) {
int lc = k * 2, rc = k * 2 + 1;
sum[k] = sum[lc] + sum[rc];
suma[k] = suma[lc] + suma[rc];
sumb[k] = sumb[lc] + sumb[rc];
}
void build(int k, int l, int r) {
sum[k] = suma[k] = 0;
sumb[k] = 0;
if (l == r) {
return;
}
int m = (l + r) / 2;
build(k * 2, l, m);
build(k * 2 + 1, m + 1, r);
}
void update(int p, int v, int k, int l, int r) {
if (l == r) {
if (suma[k] + v >= a)
suma[k] = a;
else
suma[k] += v;
if (sumb[k] + v >= b)
sumb[k] = b;
else
sumb[k] += v;
return;
}
int m = (l + r) / 2;
if (p <= m)
update(p, v, k * 2, l, m);
else
update(p, v, k * 2 + 1, m + 1, r);
pushUp(k);
}
int ask(int A, int B, int f, int k, int l, int r) {
if (A <= l && r <= B) {
if (f) return sumb[k];
return suma[k];
}
int m = (l + r) / 2;
int res = 0;
if (A <= m) res += ask(A, B, f, k * 2, l, m);
if (B > m) res += ask(A, B, f, k * 2 + 1, m + 1, r);
return res;
}
} tree;
int main() {
int i, j, k, n, q;
while (scanf("%d%d%d%d%d", &n, &k, &a, &b, &q) != EOF) {
tree.build(1, 1, n);
while (q--) {
int o, d, v, p;
scanf("%d", &o);
if (o == 1) {
scanf("%d%d", &d, &v);
tree.update(d, v, 1, 1, n);
} else {
scanf("%d", &p);
int res = 0;
if (p > 1) res += tree.ask(1, p - 1, 1, 1, 1, n);
if (p + k - 1 < n) res += tree.ask(p + k, n, 0, 1, 1, n);
printf("%d\n", res);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int L, R, sum, sum1, sum2;
int Mid() { return (L + R) / 2; }
} a[210500 * 4];
int A, B;
void Build(int r, int L, int R) {
a[r].L = L, a[r].R = R;
a[r].sum = a[r].sum1 = a[r].sum2 = 0;
if (L == R) return;
Build(r << 1, L, a[r].Mid());
Build(r << 1 | 1, a[r].Mid() + 1, R);
}
void Update(int r, int pos, int num) {
if (a[r].L == a[r].R && a[r].L == pos) {
a[r].sum += num;
if (a[r].sum >= A) {
a[r].sum1 = A;
a[r].sum2 = B;
} else if (a[r].sum < A && a[r].sum >= B) {
a[r].sum1 = a[r].sum;
a[r].sum2 = B;
} else
a[r].sum1 = a[r].sum2 = a[r].sum;
return;
}
if (pos <= a[r].Mid())
Update(r << 1, pos, num);
else
Update(r << 1 | 1, pos, num);
a[r].sum = a[r << 1].sum + a[r << 1 | 1].sum;
a[r].sum1 = a[r << 1].sum1 + a[r << 1 | 1].sum1;
a[r].sum2 = a[r << 1].sum2 + a[r << 1 | 1].sum2;
}
int Query(int r, int L, int R, int op) {
if (L > R) return 0;
if (a[r].L == L && a[r].R == R) {
if (op == 2) return a[r].sum1;
return a[r].sum2;
}
if (R <= a[r].Mid())
return Query(r << 1, L, R, op);
else if (L > a[r].Mid())
return Query(r << 1 | 1, L, R, op);
else {
int ans1 = Query(r << 1, L, a[r].Mid(), op);
int ans2 = Query(r << 1 | 1, a[r].Mid() + 1, R, op);
return ans1 + ans2;
}
}
int main() {
int n, k, q, op, x, y;
while (scanf("%d %d %d %d %d", &n, &k, &A, &B, &q) != EOF) {
Build(1, 1, n);
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %d", &x, &y);
Update(1, x, y);
} else {
scanf("%d", &x);
int ans1 = Query(1, 1, x - 1, 1);
int ans2 = Query(1, x + k, n, 2);
printf("%d\n", ans1 + ans2);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, k, a, b, q, t, A, B, BITA[MAXN], BITB[MAXN], tot[MAXN];
int query1(int index) {
if (index >= MAXN) index = MAXN - 1;
int sum = 0;
for (; index > 0; index -= index & -index) sum += BITA[index];
return sum;
}
void set1(int index, int value) {
int val = -(query1(index) - query1(index - 1)) + value;
for (; index < MAXN; index += index & -index) BITA[index] += val;
}
int query2(int index) {
int sum = 0;
for (; index > 0; index -= index & -index) sum += BITB[index];
return sum;
}
void set2(int index, int value) {
int val = -(query2(index) - query2(index - 1)) + value;
for (; index < MAXN; index += index & -index) BITB[index] += val;
}
int main() {
scanf("%i%i%i%i%i", &n, &k, &a, &b, &q);
while (q--) {
scanf("%i", &t);
if (t == 1) {
scanf("%i%i", &A, &B);
tot[A] += B;
set1(A, min(tot[A], a));
set2(A, min(tot[A], b));
} else {
scanf("%i", &A);
printf("%i\n", query1(MAXN - 1) - query1(A + k - 1) + query2(A - 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 2e5 + 10, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n;
struct Bit {
int a[N], b[N];
void init() {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
void add(int a[], int x, int val) {
for (; x <= n; x += x & -x) a[x] += val;
}
int cnt(int a[], int x) {
int ret = 0;
for (; x; x -= x & -x) ret += a[x];
return ret;
}
} bit;
int k, a, b, q;
int nowa[N], nowb[N];
int main() {
while (~scanf("%d%d%d%d%d", &n, &k, &a, &b, &q)) {
bit.init();
memset(nowa, 0, sizeof(nowa));
memset(nowb, 0, sizeof(nowb));
while (q--) {
int op, d, x;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &d, &x);
bit.add(bit.a, d, -nowa[d]);
bit.add(bit.b, d, -nowb[d]);
nowa[d] = min(nowa[d] + x, a);
nowb[d] = min(nowb[d] + x, b);
bit.add(bit.a, d, nowa[d]);
bit.add(bit.b, d, nowb[d]);
} else {
scanf("%d", &d);
int ansa = bit.cnt(bit.a, n) - bit.cnt(bit.a, d + k - 1);
int ansb = bit.cnt(bit.b, d - 1);
printf("%d\n", ansa + ansb);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int q, x, y, z, a1, a2, i, j, k, l, n, m, ans;
bool f;
int a[maxn];
int b[maxn];
int c[maxn];
int d[maxn];
int get1(int x) {
int sum = 0;
while (x > 0) {
sum += b[x];
x -= x & (-x);
}
return sum;
}
int get2(int x) {
int sum = 0;
while (x > 0) {
sum += c[x];
x -= x & (-x);
}
return sum;
}
void add1(int x, int q) {
while (x <= n) {
b[x] += q;
x += x & (-x);
}
}
void add2(int x, int q) {
while (x <= n) {
c[x] += q;
x += x & (-x);
}
}
int main() {
cin >> n >> k >> a1 >> a2 >> q;
for (i = 1; i <= q; i++) {
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z);
add1(y, min(a1 - a[y], z));
a[y] = min(a1, a[y] + z);
add2(y, min(a2 - d[y], z));
d[y] = min(a2, d[y] + z);
} else {
scanf("%d", &y);
ans = get2(y - 1) + (get1(n) - get1(y + k - 1));
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t1[1000000];
int t2[1000000];
int a, b;
void update1(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t1[v] += val;
t1[v] = min(t1[v], a);
} else {
int m = (tl + tr) / 2;
if (pos <= m)
update1(v * 2, tl, m, pos, val);
else
update1(v * 2 + 1, m + 1, tr, pos, val);
t1[v] = t1[v * 2] + t1[v * 2 + 1];
}
}
int get1(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return t1[v];
int m = (tl + tr) / 2;
return get1(v * 2, tl, m, l, min(m, r)) +
get1(v * 2 + 1, m + 1, tr, max(m + 1, l), r);
}
int get2(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && r == tr) return t2[v];
int m = (tl + tr) / 2;
return get2(v * 2, tl, m, l, min(m, r)) +
get2(v * 2 + 1, m + 1, tr, max(m + 1, l), r);
}
void update2(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t2[v] += val;
t2[v] = min(t2[v], b);
} else {
int m = (tl + tr) / 2;
if (pos <= m)
update2(v * 2, tl, m, pos, val);
else
update2(v * 2 + 1, m + 1, tr, pos, val);
t2[v] = t2[v * 2] + t2[v * 2 + 1];
}
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n, k, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 0; i < 4 * n; i++) {
t1[i] = 0;
t2[i] = 0;
}
for (int i = 0; i < q; i++) {
int x;
scanf("%d", &x);
if (x == 1) {
int x1, x2;
scanf("%d %d", &x1, &x2);
x1--;
update1(1, 0, n - 1, x1, x2);
update2(1, 0, n - 1, x1, x2);
} else {
int x1;
scanf("%d", &x1);
x1--;
int ans = 0;
ans = get2(1, 0, n - 1, 0, x1 - 1);
ans += get1(1, 0, n - 1, x1 + k, n - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[2][2 * 200000], N;
void modify(int n, int v, int a, int id) {
n += N;
t[id][n] = min(t[id][n] + v, a);
while (n >>= 1) t[id][n] = t[id][n << 1] + t[id][n << 1 | 1];
}
int query(int l, int r, int id) {
int ans = 0;
for (l += N, r += N; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans += t[id][l++];
if (r & 1) ans += t[id][--r];
}
return ans;
}
int main() {
int K, a, b, Q, type, p, v;
while (scanf("%d %d %d %d %d", &N, &K, &a, &b, &Q) != EOF) {
memset(t, 0, sizeof(t));
for (int i = int(0); i < int(Q); i++) {
scanf("%d %d", &type, &p);
p--;
if (type & 1) {
scanf("%d", &v);
modify(p, v, b, 0);
modify(p, v, a, 1);
} else {
printf("%d\n", query(0, p, 0) + query(p + K, N, 1));
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * (1e5 + 100);
int n, k, puno, malo, q;
int tur[2][MAXN * 5];
int off;
inline void Update(int pos, int val, int flag) {
pos += off;
tur[flag][pos] += val;
if (flag == 0)
tur[flag][pos] = min(tur[flag][pos], malo);
else
tur[flag][pos] = min(tur[flag][pos], puno);
for (pos /= 2; pos; pos /= 2)
tur[flag][pos] = tur[flag][pos * 2] + tur[flag][pos * 2 + 1];
}
inline int Query(int node, int a, int b, int lo, int hi, int flag) {
if (a > hi || b < lo || a > b) return 0;
if (a >= lo && b <= hi) return tur[flag][node];
int mid = (a + b) / 2;
int left = Query(node * 2, a, mid, lo, hi, flag);
int right = Query(node * 2 + 1, mid + 1, b, lo, hi, flag);
return left + right;
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &puno, &malo, &q);
for (off = 1; off < n; off *= 2)
;
for (int i = 0; i < q; i++) {
int foo, dan, order;
scanf("%d", &foo);
if (foo == 1) {
scanf("%d %d", &dan, &order);
dan--;
Update(dan, min(order, malo), 0);
Update(dan, min(order, puno), 1);
} else {
scanf("%d", &dan);
dan--;
int mali, veliki;
if (dan == 0)
mali = 0;
else
mali = Query(1, 0, off - 1, 0, dan - 1, 0);
if (dan + k - 1 == n - 1)
veliki = 0;
else
veliki = Query(1, 0, off - 1, dan + k, n - 1, 1);
printf("%d\n", mali + veliki);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int L, R, val, val1, val2;
int Mid() { return (L + R) / 2; }
} a[200010 * 4];
int A, B;
void Build(int id, int L, int R) {
a[id].L = L, a[id].R = R;
a[id].val = a[id].val1 = a[id].val2 = 0;
if (L == R) return;
Build(id * 2, L, a[id].Mid());
Build(id * 2 + 1, a[id].Mid() + 1, R);
}
void Update(int id, int x, int y) {
if (a[id].L == a[id].R && a[id].L == x) {
a[id].val += y;
if (a[id].val >= A) {
a[id].val1 = A;
a[id].val2 = B;
} else if (a[id].val < A && a[id].val >= B) {
a[id].val1 = a[id].val;
a[id].val2 = B;
} else {
a[id].val1 = a[id].val2 = a[id].val;
}
return;
}
if (x <= a[id].Mid())
Update(id * 2, x, y);
else
Update(id * 2 + 1, x, y);
a[id].val = a[id * 2].val + a[id * 2 + 1].val;
a[id].val1 = a[id * 2].val1 + a[id * 2 + 1].val1;
a[id].val2 = a[id * 2].val2 + a[id * 2 + 1].val2;
}
int Query(int id, int L, int R, int f) {
if (L > R) return 0;
if (a[id].L == L && a[id].R == R) {
if (f == 1) {
return a[id].val1;
} else {
return a[id].val2;
}
}
if (R <= a[id].Mid())
return Query(id * 2, L, R, f);
else if (L > a[id].Mid())
return Query(id * 2 + 1, L, R, f);
else {
int ans1 = Query(id * 2, L, a[id].Mid(), f);
int ans2 = Query(id * 2 + 1, a[id].Mid() + 1, R, f);
return ans1 + ans2;
}
}
int main() {
int n, k, q, t, x, y;
scanf("%d %d %d %d %d", &n, &k, &A, &B, &q);
Build(1, 1, n);
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d %d", &x, &y);
Update(1, x, y);
} else {
scanf("%d", &x);
int ans1 = Query(1, 1, x - 1, 0);
int ans2 = Query(1, x + k, n, 1);
printf("%d\n", ans1 + ans2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n, k, q;
long long BITA[500010];
void updatea(long long idx, long long val) {
while (idx < 500010) {
BITA[idx] += val;
idx += (idx & (-idx));
}
}
long long reada(long long idx) {
long long sum = 0;
while (idx > 0) {
sum += BITA[idx];
idx -= (idx & (-idx));
}
return sum;
}
long long BITB[500010];
void updateb(long long idx, long long val) {
while (idx < 500010) {
BITB[idx] += val;
idx += (idx & (-idx));
}
}
long long readb(long long idx) {
long long sum = 0;
while (idx > 0) {
sum += BITB[idx];
idx -= (idx & (-idx));
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long i;
cin >> n >> k >> a >> b >> q;
for (i = 0; i < q; i++) {
long long type;
cin >> type;
if (type == 1) {
long long x, y;
cin >> x >> y;
long long curr = reada(x) - reada(x - 1);
if (curr < b) updatea(x, min(b - curr, y));
curr = readb(x) - readb(x - 1);
if (curr < a) updateb(x, min(a - curr, y));
} else {
long long x;
cin >> x;
long long ans = 0;
ans = reada(x - 1);
ans += readb(500010);
ans -= readb(x + k - 1);
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct seg {
int long long sum, sum2;
seg(int long long sum = 0, int long long sum2 = 0) : sum(sum), sum2(sum2) {}
};
int long long x, y;
vector<seg> t;
void update(int long long l, int long long r, int long long pos,
int long long v, int long long w) {
if (l > pos || r < pos) return;
if (l == r) {
t[v].sum = min(x, t[v].sum + w);
t[v].sum2 = min(y, t[v].sum2 + w);
return;
}
int long long m = (l + r) / 2;
update(l, m, pos, v * 2 + 1, w);
update(m + 1, r, pos, v * 2 + 2, w);
t[v].sum = t[v * 2 + 1].sum + t[v * 2 + 2].sum;
t[v].sum2 = t[v * 2 + 1].sum2 + t[v * 2 + 2].sum2;
}
seg find_sum(int long long l, int long long r, int long long lt,
int long long rt, int long long v) {
if (l > rt || r < lt) {
return seg();
}
if (l >= lt && r <= rt) return t[v];
int long long m = (l + r) / 2;
seg L = find_sum(l, m, lt, rt, v * 2 + 1);
seg R = find_sum(m + 1, r, lt, rt, v * 2 + 2);
return seg(L.sum + R.sum, L.sum2 + R.sum2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
int long long n, k, q, mode, z, w;
cin >> n >> k >> x >> y >> q;
t.resize(n * 4);
for (int i = 0; i < q; i++) {
cin >> mode;
if (mode == 1) {
cin >> z >> w;
z--;
update(0, n - 1, z, 0, w);
} else {
cin >> z;
z--;
cout << find_sum(0, n - 1, 0, z - 1, 0).sum2 +
find_sum(0, n - 1, z + k, n - 1, 0).sum
<< endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct fin {
vector<long long> T;
fin(int N) { T.resize(N + 47, 0); }
int lastone(int x) { return x & (x ^ (x - 1)); }
void put(int pos, long long val) {
for (int i = pos + 1; i < (int)T.size(); i += lastone(i)) T[i] += val;
}
long long get(int pos) {
long long ret = 0;
for (int i = pos + 1; i > 0; i -= lastone(i)) ret += T[i];
return ret;
}
};
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N, K, Q;
long long A, B;
scanf(" %d %d %lld %lld %d", &N, &K, &A, &B, &Q);
vector<long long> ord(N, 0);
fin F1(N), F2(N);
for (int q = 0; q < Q; q++) {
int tp;
scanf(" %d", &tp);
if (tp == 2) {
int p;
scanf(" %d", &p);
p--;
printf("%lld\n", F1.get(p - 1) + F2.get(N - (p + K)));
continue;
}
int d, a;
scanf(" %d %d", &d, &a);
d--;
F1.put(d, -min(B, ord[d]));
F2.put(N - d, -min(A, ord[d]));
ord[d] += a;
F1.put(d, min(B, ord[d]));
F2.put(N - d, min(A, ord[d]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
vector<int> arr;
vector<pair<int, int>> st;
int left(int p) { return p << 1; }
int right(int p) { return (p << 1) + 1; }
void bu(int p, int l, int r) {
if (l == r) {
int aux_a = (arr[l] >= a) ? a : arr[l];
int aux_b = (arr[l] >= b) ? b : arr[l];
st[p] = make_pair(aux_a, aux_b);
} else {
int mid = (l + r) / 2;
bu(left(p), l, mid);
bu(right(p), mid + 1, r);
pair<int, int> p1 = st[left(p)], p2 = st[right(p)];
st[p] = make_pair(p1.first + p2.first, p1.second + p2.second);
}
}
void build() { bu(1, 0, n - 1); }
int qa(int p, int l, int r, int i, int j) {
if (i > r || j < l) return 0;
if (l >= i && r <= j) return st[p].first;
int mid = (l + r) / 2;
int p1 = qa(left(p), l, mid, i, j);
int p2 = qa(right(p), mid + 1, r, i, j);
return p1 + p2;
}
int qb(int p, int l, int r, int i, int j) {
if (i > r || j < l) return 0;
if (l >= i && r <= j) return st[p].second;
int mid = (l + r) / 2;
int p1 = qb(left(p), l, mid, i, j);
int p2 = qb(right(p), mid + 1, r, i, j);
return p1 + p2;
}
int query_a(int i, int j) {
if (i <= j)
return qa(1, 0, n - 1, i, j);
else
return 0;
}
int query_b(int i, int j) {
if (i <= j)
return qb(1, 0, n - 1, i, j);
else
return 0;
}
void u(int p, int l, int r, int i, int v) {
if (l == r) {
int aux_a = (st[p].first + v >= a) ? a : st[p].first + v;
int aux_b = (st[p].second + v >= b) ? b : st[p].second + v;
st[p] = make_pair(aux_a, aux_b);
} else {
int mid = (l + r) / 2;
if (i <= mid)
u(left(p), l, mid, i, v);
else
u(right(p), mid + 1, r, i, v);
pair<int, int> p1 = st[left(p)], p2 = st[right(p)];
st[p] = make_pair(p1.first + p2.first, p1.second + p2.second);
}
}
void update(int i, int v) { u(1, 0, n - 1, i, v); }
int main() {
cin >> n >> k >> a >> b >> q;
arr.assign(n, 0);
st.assign(4 * n, make_pair(0, 0));
for (int i = 0; i < q; i++) {
int op, day, orders;
cin >> op;
if (op == 1) {
cin >> day >> orders;
day--;
update(day, orders);
} else {
cin >> day;
day--;
cout << query_b(0, day - 1) + query_a(day + k, n - 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree1[1000001], tree2[1000001];
void build(long long l, long long r, long long cur) {
if (l == r) {
tree1[cur] = 0;
tree2[cur] = 0;
return;
}
long long m = (l + r) / 2;
build(l, m, 2 * cur + 1);
build(m + 1, r, 2 * cur + 2);
tree1[cur] = 0;
tree2[cur] = 0;
}
long long sum1(long long l, long long r, long long start, long long end,
long long cur) {
if (l <= start && end <= r) return tree1[cur];
if (l > end || start > r) return 0;
long long m = (start + end) / 2;
return sum1(l, r, start, m, 2 * cur + 1) +
sum1(l, r, m + 1, end, 2 * cur + 2);
}
long long sum2(long long l, long long r, long long start, long long end,
long long cur) {
if (l <= start && end <= r) return tree2[cur];
if (l > end || start > r) return 0;
long long m = (start + end) / 2;
return sum2(l, r, start, m, 2 * cur + 1) +
sum2(l, r, m + 1, end, 2 * cur + 2);
}
void update1(long long idx, long long l, long long r, long long cur,
long long val, long long val1) {
if (l == r && l == idx) {
tree1[cur] = min(tree1[cur] + val, val1);
return;
}
if (idx < l || idx > r) return;
long long m = (l + r) / 2;
update1(idx, l, m, 2 * cur + 1, val, val1);
update1(idx, m + 1, r, 2 * cur + 2, val, val1);
tree1[cur] = tree1[2 * cur + 1] + tree1[2 * cur + 2];
}
void update2(long long idx, long long l, long long r, long long cur,
long long val, long long val1) {
if (l == r && l == idx) {
tree2[cur] = min(tree2[cur] + val, val1);
return;
}
if (idx < l || idx > r) return;
long long m = (l + r) / 2;
update2(idx, l, m, 2 * cur + 1, val, val1);
update2(idx, m + 1, r, 2 * cur + 2, val, val1);
tree2[cur] = tree2[2 * cur + 1] + tree2[2 * cur + 2];
}
int main() {
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) {
long long i, j, k, n, a, b, q;
cin >> n >> k >> a >> b >> q;
for (i = 0; i < q; i++) {
long long k1, d;
cin >> j >> k1;
if (j == 1) {
cin >> d;
update1(k1 - 1, 0, n - 1, 0, d, a);
update2(k1 - 1, 0, n - 1, 0, d, b);
continue;
}
k1--;
long long x = sum1(k1 + k, n - 1, 0, n - 1, 0);
x += sum2(0, k1 - 1, 0, n - 1, 0);
cout << x << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, a, b, q, cnt[N];
struct fenwick {
int fen[N];
void add(int p, int x) {
for (; p < N; p += p & -p) fen[p] += x;
}
int get(int p) {
int ans = 0;
for (; p; p -= p & -p) ans += fen[p];
return ans;
}
} fen1, fen2;
void readInput() { cin >> n >> k >> a >> b >> q; }
void writeOutput() {
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t & 1) {
int d, x;
cin >> d >> x;
cnt[d] += x;
fen1.add(d, max(min(b, cnt[d]) - cnt[d] + x, 0));
fen2.add(n - d + 1, max(min(a, cnt[d]) - cnt[d] + x, 0));
} else {
int p;
cin >> p;
cout << fen1.get(p - 1) + fen2.get(n - p - k + 1) << endl;
}
}
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
readInput(), writeOutput();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200020;
int n, k, a, b, q;
struct fenwick {
int limit, cur[maxn];
long long fw[maxn];
void update(int x, int v) {
v = min(limit - cur[x], v);
cur[x] += v;
for (; x < maxn; x += x & -x) fw[x] += v;
}
long long get(int x, int y) {
long long ret = 0;
for (x--; x; x &= x - 1) ret -= fw[x];
for (; y; y &= y - 1) ret += fw[y];
return ret;
}
} fwb, fwa;
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
fwb.limit = b;
fwa.limit = a;
for (int i = 1, type, a, b; i <= q; i++) {
scanf("%d%d", &type, &a);
if (type == 1) {
scanf("%d", &b);
fwa.update(a, b);
fwb.update(a, b);
} else {
long long ans = 0;
ans += fwb.get(1, a - 1);
ans += fwa.get(a + k, n);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a, b;
int q;
long long t[3][1000005];
int sz;
long long w[1000005];
inline void update(int x, int y, long long z) {
y += sz - 1;
t[x][y] = z;
y >>= 1;
while (y) {
t[x][y] = t[x][y + y] + t[x][y + y + 1];
y >>= 1;
}
}
long long get(int l, int r, int ll, int rr, int x, int y) {
if (l > r || ll > r || l > rr || ll > rr) return 0;
if (l >= ll && r <= rr) return t[y][x];
int mid = (l + r) >> 1;
return get(l, mid, ll, rr, x + x, y) + get(mid + 1, r, ll, rr, x + x + 1, y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> a >> b >> q;
sz = 1;
while (sz < n) sz += sz;
while (q--) {
long long tp, x, y;
cin >> tp;
if (tp == 1) {
cin >> x >> y;
w[x] += y;
update(1, x, min(w[x], b));
update(2, x, min(w[x], a));
} else {
cin >> x;
long long res = get(1, sz, 1, x - 1, 1, 1) + get(1, sz, x + k, n, 1, 2);
cout << res << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
return s << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &c) {
s << "[ ";
for (auto it : c) s << it << " ";
s << "]";
return s;
}
const int MAXN = 262144;
int N, K, A, B, Q;
int arr[MAXN];
int na[MAXN], nb[MAXN];
int sega[MAXN * 2], segb[MAXN * 2];
void update_seg(int s, int lb, int rb, int pos, int va, int vb) {
if (pos < lb || pos >= rb) return;
if (rb - lb == 1) {
sega[s] = va;
segb[s] = vb;
} else {
int mb = (lb + rb) >> 1;
update_seg(2 * s, lb, mb, pos, va, vb);
update_seg(2 * s + 1, mb, rb, pos, va, vb);
sega[s] = sega[2 * s] + sega[2 * s + 1];
segb[s] = segb[2 * s] + segb[2 * s + 1];
}
}
int qry_seg(int s, int lb, int rb, int l, int r, bool type) {
if (rb <= l || r <= lb) return 0;
if (l <= lb && rb <= r) {
if (type)
return sega[s];
else
return segb[s];
} else {
int mb = (lb + rb) >> 1;
return qry_seg(2 * s, lb, mb, l, r, type) +
qry_seg(2 * s + 1, mb, rb, l, r, type);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> K >> A >> B >> Q;
for (int i = 0; i < Q; i++) {
int ty;
cin >> ty;
if (ty == 1) {
int d, a;
cin >> d >> a;
d--;
na[d] = min(A, na[d] + a);
nb[d] = min(B, nb[d] + a);
update_seg(1, 0, N, d, na[d], nb[d]);
} else {
int p;
cin >> p;
p--;
int ans = qry_seg(1, 0, N, 0, p, 0) + qry_seg(1, 0, N, p + K, N, 1);
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct FenwickTree {
int N;
vector<int> A;
FenwickTree(int n) : N(n + 1), A(N) {}
int rq(int b) {
int sum = 0;
for (; b; b -= b & -b) sum += A[b];
return sum;
}
int rq(int a, int b) { return rq(b) - rq(a); }
void adjust(int i, int v) {
for (i++; i < N; i += i & -i) A[i] += 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 - 1, befk - befa[j]);
befa[j] = befk;
aft.adjust(j - 1, aftk - afta[j]);
afta[j] = aftk;
} else {
scanf("%d", &j);
printf("%d\n", bef.rq(0, j - 1) + aft.rq(k + j - 1, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s[200010], ba[200010], bb[200010];
void add(long long *b, int p, long long x) {
while (p < 200010) {
b[p] += x;
p += p & -p;
}
}
long long sum(long long *b, int p) {
long long res = 0;
while (p > 0) {
res += b[p];
p -= p & -p;
}
return res;
}
int main() {
int n, k, a, b, m, q, d, c;
long long t;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &m);
while (m--) {
scanf("%d", &q);
if (q == 1) {
scanf("%d%d", &d, &c);
t = min(s[d] + c, 1ll * b) - s[d];
if (t > 0) {
add(bb, d, t);
}
t = min(s[d] + c, 1ll * a) - s[d];
if (t > 0) {
add(ba, d, t);
}
s[d] += c;
} else {
scanf("%d", &d);
printf("%I64d\n", sum(bb, d - 1) - sum(ba, d + k - 1) + sum(ba, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
int A[MAXN], B[MAXN];
int N, K, a, b, Q;
int cnt[MAXN];
int get(int *bit, int x) {
int sm = 0;
while (x) {
sm += bit[x];
x -= x & -x;
}
return sm;
}
void inc(int *bit, int x, int val) {
while (x < MAXN) {
bit[x] += val;
x += x & -x;
}
}
void upd(int x, int val) {
if (cnt[x] + val > a) {
if (cnt[x] < a) inc(A, x, a - cnt[x]);
} else {
inc(A, x, val);
}
if (cnt[x] + val > b) {
if (cnt[x] < b) inc(B, x, b - cnt[x]);
} else {
inc(B, x, val);
}
cnt[x] += val;
}
int sm(int *bit, int x, int y) { return get(bit, y) - get(bit, x - 1); }
int main() {
scanf("%d %d %d %d %d", &N, &K, &b, &a, &Q);
for (int i = 0; i < Q; ++i) {
int qtype;
scanf("%d", &qtype);
if (qtype == 1) {
int x, val;
scanf("%d %d", &x, &val);
upd(x, val);
} else {
int p;
scanf("%d", &p);
int ans1 = sm(A, 1, p - 1);
int ans2 = sm(B, p + K, N);
int ans = ans1 + ans2;
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b;
vector<long long> treea, treeb;
void build(int node, int s, int e) {
if (s == e) {
treea[node] = 0;
treeb[node] = 0;
} else {
build(2 * node, s, (s + e) / 2);
build(2 * node + 1, (s + e) / 2 + 1, e);
treea[node] = treea[node * 2] + treea[node * 2 + 1];
treeb[node] = treeb[node * 2] + treeb[node * 2 + 1];
}
}
void update(int node, int s, int e, int idx, int val) {
if (s == e) {
treea[node] += val;
treea[node] = min(treea[node], a);
treeb[node] += val;
treeb[node] = min(treeb[node], b);
} else {
if (s <= idx && idx <= (s + e) / 2)
update(2 * node, s, (s + e) / 2, idx, val);
else
update(2 * node + 1, (s + e) / 2 + 1, e, idx, val);
treea[node] = treea[node * 2] + treea[node * 2 + 1];
treeb[node] = treeb[node * 2] + treeb[node * 2 + 1];
}
}
long long querya(int node, int s, int e, int l, int r) {
if (r < s || e < l || l > r) return 0;
if (l <= s && e <= r) return treea[node];
long long a = querya(2 * node, s, (s + e) / 2, l, r);
a += querya(2 * node + 1, (s + e) / 2 + 1, e, l, r);
return a;
}
long long queryb(int node, int s, int e, int l, int r) {
if (r < s || e < l || l > r) return 0;
if (l <= s && e <= r) return treeb[node];
long long a = queryb(2 * node, s, (s + e) / 2, l, r);
a += queryb(2 * node + 1, (s + e) / 2 + 1, e, l, r);
return a;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, q;
cin >> n >> k >> a >> b >> q;
treea.resize(4 * n + 1);
treeb.resize(4 * n + 1);
while (q--) {
int t, f;
cin >> t;
if (t == 1) {
cin >> t >> f;
update(1, 0, n - 1, t - 1, f);
} else {
cin >> t;
t--;
cout << queryb(1, 0, n - 1, 0, t - 1) + querya(1, 0, n - 1, t + k, n - 1)
<< "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a1[200001];
int a2[200001];
int b1[200001];
int b2[200001];
void update(int* b, int x, int t, int n) {
while (x <= n) {
b[x] = b[x] + t;
x = x + (x & (-x));
}
}
int query(int* b, int x) {
int ans = 0;
while (x > 0) {
ans = ans + b[x];
x = x - (x & (-x));
}
return ans;
}
int main() {
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
int t;
scanf("%d", &t);
int u, v;
if (t == 1) {
scanf("%d%d", &u, &v);
int old1 = a1[u];
a1[u] += v;
a1[u] = min(a1[u], b);
update(b1, u, a1[u] - old1, n);
int old2 = a2[n - u + 1];
a2[n - u + 1] += v;
a2[n - u + 1] = min(a2[n - u + 1], a);
update(b2, n - u + 1, a2[n - u + 1] - old2, n);
} else {
scanf("%d", &u);
printf("%d\n", query(b1, u - 1) + query(b2, n - u - k + 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, a, b, q;
class tree {
public:
int mn;
int t[N << 1];
void up(int x, int k) {
x += N;
t[x] = min(t[x] + k, mn);
while (x > 1) {
x >>= 1;
t[x] = t[x + x] + t[x + x + 1];
}
}
int get(int l, int r) {
int sum = 0;
for (l += N, r += N; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
if (l & 1) sum += t[l];
if (~r & 1) sum += t[r];
}
return sum;
}
} t[2];
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
t[0].mn = b;
t[1].mn = a;
for (int i = 1; i <= q; i++) {
int c;
scanf("%d", &c);
if (c == 1) {
int x, k;
scanf("%d %d", &x, &k);
t[0].up(x, k);
t[1].up(x, k);
} else {
int x;
scanf("%d", &x);
printf("%d\n", t[0].get(1, x - 1) + t[1].get(x + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
void update(vector<int> &tree, int day, int diff) {
while (day <= n) {
tree[day] += diff;
day += (-day & day);
}
}
int sum(vector<int> &tree, int ed) {
int sumv = 0;
while (ed >= 1) {
sumv += tree[ed];
ed -= (-ed & ed);
}
return sumv;
}
int main() {
vector<int> save(200001);
vector<int> fta(200001);
vector<int> ftb(200001);
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &q);
while (q--) {
int q1 = 0;
scanf("%d", &q1);
if (q1 == 1) {
int day, order;
scanf("%d", &day);
scanf("%d", &order);
update(fta, day, min(save[day] + order, a) - min(save[day], a));
update(ftb, day, min(save[day] + order, b) - min(save[day], b));
save[day] += order;
} else if (q1 == 2) {
int sd;
scanf("%d", &sd);
int anw = sum(fta, n) - sum(fta, sd + k - 1) + sum(ftb, sd - 1);
printf("%d\n", anw);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
int d1[900000], d2[900000], arr[900000];
int sum(int v, int l, int r, int tl, int tr, int d[]) {
if (l == tl && r == tr) return d[v];
if (tl > tr) return 0;
int m = (l + r) / 2;
return sum(v * 2, l, m, tl, min(tr, m), d) +
sum(v * 2 + 1, m + 1, r, max(tl, m + 1), tr, d);
}
void upd(int v, int l, int r, int x, int nw, int d[]) {
if (l == r) {
d[v] = nw;
} else {
int m = (l + r) / 2;
if (m >= x)
upd(v * 2, l, m, x, nw, d);
else
upd(v * 2 + 1, m + 1, r, x, nw, d);
d[v] = d[v * 2] + d[v * 2 + 1];
}
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 1; i <= q; i++) {
int x, l, r;
cin >> x;
if (x == 1) {
cin >> l >> r;
arr[l] += r;
upd(1, 1, n, l, min(arr[l], a), d1);
upd(1, 1, n, l, min(arr[l], b), d2);
} else {
int ans = 0;
cin >> l;
if (l != 1) ans += sum(1, 1, n, 1, l - 1, d2);
if (l + k != n + 1) ans += sum(1, 1, n, l + k, n, d1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bit[200005][2];
int n, k, a, b, q;
long long get(int idx, int t) {
long long ret = 0;
while (idx) {
ret += bit[idx][t];
idx -= (idx & (-idx));
}
return ret;
}
long long update(int idx, int t, long long val) {
while (idx <= n) {
bit[idx][t] += val;
idx += (idx & (-idx));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> a >> b >> q;
int op;
long long int d, v;
int p;
while (q--) {
cin >> op;
if (op == 1) {
cin >> d >> v;
long long int val1 = get(d, 0) - get(d - 1, 0);
if (val1 < b) update(d, 0, min(b - val1, v));
val1 = get(d, 1) - get(d - 1, 1);
if (val1 < a) update(d, 1, min(a - val1, v));
continue;
}
if (op == 2) {
cin >> p;
long long ans = get(p - 1, 0);
if (p + k - 1 <= n) ans += get(n, 1) - get(p + k - 1, 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long T[2][200005] = {0};
int n, k, a, b, q;
long long read(int x, long long tree[]) {
long long s = 0;
while (x > 0) {
s += tree[x];
x -= (x & -x);
}
return s;
}
void update(int x, long long tree[], long long val) {
while (x < 200005) {
tree[x] += val;
x += (x & -x);
}
}
int days[200005];
void add(int x, int mul) {
update(x, T[0], mul * min(days[x], a));
update(x, T[1], mul * min(days[x], b));
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
swap(a, b);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int idx, val;
scanf("%d%d", &idx, &val);
add(idx, -1);
days[idx] += val;
add(idx, 1);
} else {
int pi;
scanf("%d", &pi);
long long ans =
read(pi - 1, T[0]) + read(n, T[1]) - read(pi + k - 1, T[1]);
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int n, k, A, B, q;
vector<pair<int, int> > st;
pair<int, int> merge(pair<int, int> p1, pair<int, int> p2) {
pair<int, int> ans = {p1.first + p2.first, p1.second + p2.second};
return ans;
}
void update(int p, int L, int R, int pos, int val) {
if (pos < L || pos > R) return;
if (pos == L && pos == R) {
st[p].first = min(A, st[p].first + val);
st[p].second = min(B, st[p].second + val);
return;
}
int mid = (L + R) / 2;
update(p * 2, L, mid, pos, val);
update(p * 2 + 1, mid + 1, R, pos, val);
st[p] = merge(st[p * 2], st[p * 2 + 1]);
}
pair<int, int> query(int p, int L, int R, int i, int j) {
if (i > R || j < L) return {0, 0};
if (i <= L && j >= R) return st[p];
int mid = (L + R) / 2;
pair<int, int> p1 = query(p * 2, L, mid, i, j);
pair<int, int> p2 = query(p * 2 + 1, mid + 1, R, i, j);
return merge(p1, p2);
}
int main() {
cin >> n >> k >> A >> B >> q;
st.assign(4 * n, {0, 0});
while (q--) {
int type;
cin >> type;
if (type == 1) {
int pos, val;
cin >> pos >> val;
pos--;
update(1, 0, n - 1, pos, val);
} else {
int pos;
cin >> pos;
pos--;
pair<int, int> fh = {0, 0}, sh = {0, 0};
if (pos) fh = query(1, 0, n - 1, 0, pos - 1);
if (pos + k < n) sh = query(1, 0, n - 1, pos + k, n - 1);
int res = fh.second + sh.first;
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, k, tt;
int tree1[800000], tree2[800000];
void updata1(int L, int R, int ro, int x, int v) {
if (x < L || x > R) return;
if (L == R && L == x) {
tree1[ro] = min(v + tree1[ro], b);
return;
}
int Mid = (L + R) / 2;
updata1(L, Mid, ro * 2, x, v);
updata1(Mid + 1, R, ro * 2 + 1, x, v);
tree1[ro] = tree1[ro * 2] + tree1[ro * 2 + 1];
}
void updata2(int L, int R, int ro, int x, int v) {
if (x < L || x > R) return;
if (L == R && L == x) {
tree2[ro] = min(v + tree2[ro], a);
return;
}
int Mid = (L + R) / 2;
updata2(L, Mid, ro * 2, x, v);
updata2(Mid + 1, R, ro * 2 + 1, x, v);
tree2[ro] = tree2[ro * 2] + tree2[ro * 2 + 1];
}
int quary1(int ro, int L, int R, int l, int r) {
if (r < L || l > R) return 0;
if (l <= L && R <= r) return tree1[ro];
int Mid = (L + R) / 2;
int x1 = quary1(ro * 2, L, Mid, l, r),
x2 = quary1(ro * 2 + 1, Mid + 1, R, l, r);
return x1 + x2;
}
int quary2(int ro, int L, int R, int l, int r) {
if (r < L || l > R) return 0;
if (l <= L && R <= r) return tree2[ro];
int Mid = (L + R) / 2;
int x1 = quary2(ro * 2, L, Mid, l, r),
x2 = quary2(ro * 2 + 1, Mid + 1, R, l, r);
return x1 + x2;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &tt);
for (int i = 1; i <= tt; i++) {
int a1, b1, c1;
scanf("%d", &a1);
if (a1 == 1) {
scanf("%d%d", &b1, &c1);
updata1(1, n, 1, b1, c1);
updata2(1, n, 1, b1, c1);
} else if (a1 == 2) {
scanf("%d", &b1);
printf("%d\n", quary1(1, 1, n, 1, b1 - 1) + quary2(1, 1, n, b1 + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
struct info {
int rem, tot;
};
info merge(info A, info B) { return {A.rem + B.rem, A.tot + B.tot}; }
struct node {
int l, r;
info cont;
node *left, *right;
node(int l, int r, int s) : l(l), r(r) {
if (l == r)
cont = {s, 0};
else {
int m = (l + r) / 2;
left = new node(l, m, s);
right = new node(m + 1, r, s);
cont = merge(left->cont, right->cont);
}
}
void upd(int p, int v) {
if (r < p || p < l) return;
if (l == r) {
int m = min(cont.rem, v);
cont.rem -= m;
cont.tot += m;
return;
}
left->upd(p, v);
right->upd(p, v);
cont = merge(left->cont, right->cont);
}
info qry(int rl, int rr) {
if (rr < l || r < rl || l > r) return {0, 0};
if (rl <= l && r <= rr) return cont;
return merge(left->qry(rl, rr), right->qry(rl, rr));
}
void print() {
cout << "[" << l << ", " << r << "] : (" << cont.rem << " " << cont.tot
<< ")\n";
if (l < r) {
left->print();
right->print();
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> a >> b >> q;
node slow(1, n, b), fast(1, n, a);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int d, del;
cin >> d >> del;
slow.upd(d, del);
fast.upd(d, del);
}
if (t == 2) {
int p;
cin >> p;
info A = slow.qry(1, p - 1), B = fast.qry(p + k, n);
cout << A.tot + B.tot << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2 * 1E5 + 10;
struct bit {
int total[MAX];
bit() { memset(total, 0, sizeof total); }
void update(int i, int j) {
while (i < MAX) {
total[i] += j;
i += (i & (-i));
}
}
int get(int i) {
total[0] = 0;
while (i > 0) {
total[0] += total[i];
i -= (i & (-i));
}
return total[0];
}
int sum(int l, int r) {
if (l <= r)
return get(r) - get(l - 1);
else
return 0;
}
} ans[2];
int a[MAX], b[MAX], lim_a, lim_b, N, k, q;
void update(int i, int j) {
int _a = min(j, lim_a - a[i]);
int _b = min(j, lim_b - b[i]);
ans[0].update(i, _a);
ans[1].update(i, _b);
a[i] += _a;
b[i] += _b;
}
int query(int i) { return ans[1].sum(1, i - 1) + ans[0].sum(i + k, N); }
int main() {
scanf("%d %d %d %d %d", &N, &k, &lim_a, &lim_b, &q);
ans[0] = ans[1] = bit();
while (q--) {
int type, i, j;
scanf("%d %d", &type, &i);
if (type == 1) {
scanf("%d", &j);
update(i, j);
} else
printf("%d\n", query(i));
}
}
|
#include <bits/stdc++.h>
using namespace std;
void smain();
clock_t start;
int main() {
ios_base::sync_with_stdio(0);
cout.precision(12);
cout << fixed;
smain();
return 0;
}
long long n, k, a, b, q;
long long c[2][200002];
long long tr[2][4 * 200002];
void upd(long long t, long long v, long long l, long long r, long long pos,
long long val) {
if (l == r) return void(tr[t][v] = val);
long long m = (l + r) / 2;
if (pos <= m)
upd(t, 2 * v, l, m, pos, val);
else
upd(t, 2 * v + 1, m + 1, r, pos, val);
tr[t][v] = tr[t][2 * v] + tr[t][2 * v + 1];
}
long long query(long long t, long long v, long long l, long long r,
long long ql, long long qr) {
if (l == ql && r == qr) return tr[t][v];
long long m = (l + r) / 2, r1 = 0, r2 = 0;
if (ql <= m) r1 = query(t, 2 * v, l, m, ql, min(qr, m));
if (qr > m) r2 = query(t, 2 * v + 1, m + 1, r, max(m + 1, ql), qr);
return r1 + r2;
}
void smain() {
for (; cin >> n >> k >> a >> b >> q;) {
for (long long _ = 0; _ < q; _++) {
long long t;
cin >> t;
if (t == 1) {
long long d, v;
cin >> d >> v;
c[0][d] = min(a, c[0][d] + v);
c[1][d] = min(b, c[1][d] + v);
for (long long i = 0; i < 2; i++) upd(i, 1, 1, n, d, c[i][d]);
} else {
long long p;
cin >> p;
long long res = 0;
if (p > 1) res += query(1, 1, 1, n, 1, p - 1);
if (p + k <= n) res += query(0, 1, 1, n, p + k, n);
cout << res << '\n';
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int N, QAQ, k, s[maxn];
long long nu[maxn << 2], a, b;
struct Node {
int le, ri;
long long nua, nub;
} A[maxn << 2];
void Build(int i, int le, int ri) {
A[i].le = le, A[i].ri = ri;
A[i].nua = A[i].nub = 0LL;
if (le == ri) {
s[le] = i;
return;
}
int mid = (A[i].le + A[i].ri) >> 1;
Build((i << 1), le, mid);
Build((i << 1 | 1), mid + 1, ri);
}
inline void Update(int p, long long c) {
p = s[p];
nu[p] += c;
A[p].nua = (nu[p] < a ? nu[p] : a);
A[p].nub = (nu[p] < b ? nu[p] : b);
p >>= 1;
while (p) {
A[p].nua = A[p << 1].nua + A[p << 1 | 1].nua;
A[p].nub = A[p << 1].nub + A[p << 1 | 1].nub;
p >>= 1;
}
}
long long Query(int i, int le, int ri, int tc) {
if (A[i].le <= le && le <= ri && ri <= A[i].ri) {
if (A[i].le == le && A[i].ri == ri) return tc == 1 ? A[i].nua : A[i].nub;
int mid = (A[i].le + A[i].ri) >> 1;
if (ri <= mid)
return Query((i << 1), le, ri, tc);
else if (le > mid)
return Query((i << 1 | 1), le, ri, tc);
else {
return (Query((i << 1), le, mid, tc) +
Query((i << 1 | 1), mid + 1, ri, tc));
}
} else
return 0LL;
}
int main() {
scanf("%d%d%I64d%I64d%d", &N, &k, &a, &b, &QAQ);
for (int i = 0; i <= N * 4 + 1; ++i) nu[i] = 0LL;
Build(1, 1, N);
int tc;
long long vl;
while (QAQ--) {
scanf("%d", &tc);
if (tc == 1) {
scanf("%d%I64d", &tc, &vl);
Update(tc, vl);
} else if (tc == 2) {
scanf("%d", &tc);
printf("%I64d\n", Query(1, 1, tc - 1, 2) + Query(1, tc + k, N, 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n;
int K;
int a, b;
int q;
int arr[2];
int ST[2][3 * 200000 + 9 + 1 + 9];
int GS, GE;
void update(int idx, int val, int who, int s = GS, int e = GE, int p = 1) {
if (s == e) {
ST[who][p] = min(arr[who], ST[who][p] + val);
return;
}
int m = s + e;
m /= 2;
if (idx <= m)
update(idx, val, who, s, m, 2 * p);
else
update(idx, val, who, m + 1, e, 2 * p + 1);
ST[who][p] = ST[who][2 * p] + ST[who][2 * p + 1];
}
int query(int fr, int to, int who, int s = GS, int e = GE, int p = 1) {
if (fr <= s && e <= to) return ST[who][p];
if (fr > e || to < s) return 0;
int m = s + e;
m /= 2;
int ql = query(fr, to, who, s, m, 2 * p);
int qr = query(fr, to, who, m + 1, e, 2 * p + 1);
return ql + qr;
}
void init() {
GS = 0, GE = n - 1;
memset(ST[0], 0, sizeof ST[0]);
memset(ST[1], 0, sizeof ST[1]);
}
int main() {
read_file();
while (scanf("%d", &n) != EOF) {
scanf("%d%d%d%d", &K, &a, &b, &q);
arr[0] = a, arr[1] = b;
init();
while (q--) {
int cmd;
scanf("%d", &cmd);
if (cmd == 1) {
int idx, val;
scanf("%d%d", &idx, &val);
idx--;
update(idx, val, 0);
update(idx, val, 1);
} else {
int idx;
scanf("%d", &idx);
idx--;
int ans = 0;
if (idx - 1 >= 0) ans += query(0, idx - 1, 1);
if (idx + K - 1 + 1 <= n - 1) ans += query(idx + K - 1 + 1, n - 1, 0);
printf("%d\n", ans);
}
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXVAL = 200001;
long long n, k, a, b, q, bitA[MAXVAL], bitB[MAXVAL], t, x, y, dayTotal[MAXVAL];
int minimum(int x1, int x2) {
if (x1 < x2) return x1;
return x2;
}
void updateA(int pos, int val) {
while (pos <= n) {
bitA[pos] += val;
pos += (pos & -pos);
}
}
void updateB(int pos, int val) {
while (pos <= n) {
bitB[pos] += val;
pos += (pos & -pos);
}
}
int sumA(int pos) {
int s = 0;
while (pos > 0) {
s += bitA[pos];
pos -= (pos & -pos);
}
return s;
}
int sumB(int pos) {
int s = 0;
while (pos > 0) {
s += bitB[pos];
pos -= (pos & -pos);
}
return s;
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
cin >> t;
if (t == 1) {
cin >> x >> y;
if (dayTotal[x] < a) updateA(x, minimum(y, a - dayTotal[x]));
if (dayTotal[x] < b) updateB(x, minimum(y, b - dayTotal[x]));
dayTotal[x] += y;
} else {
cin >> x;
y = sumB(x - 1) + sumA(n) - sumA(x + k - 1);
cout << y << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long st[2][4 * 200010 + 2];
long long v[2][2 * 200010 + 2];
long long n, k, a, b, q;
void update(int p, int a, int b, int pos, long long val, bool flag) {
if (pos < a || pos > b) return;
if (a == b) {
st[flag][p] += val;
} else {
int mid = (a + b) / 2;
update(2 * p, a, mid, pos, val, flag);
update(2 * p + 1, mid + 1, b, pos, val, flag);
st[flag][p] = st[flag][2 * p] + st[flag][2 * p + 1];
}
}
long long query(int p, int a, int b, int i, int j, int flag) {
if (a > j || b < i || a > b) return 0;
if (a >= i && b <= j) {
return st[flag][p];
}
int mid = (a + b) / 2;
long long x = query(2 * p, a, mid, i, j, flag);
long long y = query(2 * p + 1, mid + 1, b, i, j, flag);
return x + y;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
long long x, y;
cin >> x;
if (x == 1) {
cin >> x >> y;
update(1, 1, n, x, min(b, y + v[0][x]) - v[0][x], 0);
update(1, 1, n, x, min(a, y + v[1][x]) - v[1][x], 1);
v[0][x] = query(1, 1, n, x, x, 0);
v[1][x] = query(1, 1, n, x, x, 1);
} else if (x == 2) {
cin >> x;
long long ans = query(1, 1, n, 1, x - 1, 0);
ans += query(1, 1, n, x + k, n, 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
int bx[200010], by[200010];
int a, b;
int calc1(int u) {
int ans = 0;
if (u == 0) return 0;
for (; u; u -= u & -u) ans += bx[u];
return ans;
}
void add1(int u, int x) {
int tmp = calc1(u) - calc1(u - 1);
x = min(a, tmp + x) - tmp;
for (; u < 200010; u += u & -u) bx[u] += x;
}
int calc2(int u) {
int ans = 0;
if (u == 0) return 0;
for (; u; u -= u & -u) ans += by[u];
return ans;
}
void add2(int u, int x) {
int tmp = calc2(u) - calc2(u - 1);
x = min(b, tmp + x) - tmp;
for (; u < 200010; u += u & -u) by[u] += x;
}
int main() {
int n, k, q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int f;
scanf("%d", &f);
if (f == 1) {
int id, val;
scanf("%d %d", &id, &val);
add1(id, val);
add2(id, val);
} else {
int id;
scanf("%d", &id);
int ans = 0;
ans = calc2(id - 1) + calc1(n) - calc1(id + k - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#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 ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int n, K, A, B, m, a[200009], b[200009], k[200009];
inline int Que(int *s, int x) {
int now = 0;
while (x) now += s[x], x -= (x & -x);
return now;
}
inline void Add(int *s, int x, int v) {
while (x <= n) s[x] += v, x += (x & -x);
}
int main() {
n = read(), K = read(), A = read(), B = read(), m = read();
for (int i = 1; i <= m; i++) {
int op = read();
if (op == 1) {
int x = read();
Add(a, x, -min(A, k[x]));
Add(b, x, -min(B, k[x]));
k[x] += read();
Add(a, x, min(A, k[x]));
Add(b, x, min(B, k[x]));
} else {
int d = read();
printf("%d\n", Que(b, d - 1) + Que(a, n) - Que(a, d + K - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int BASE = 1000000007;
const int MAX = 200007;
const int MAX2 = 7777;
const int MAXE = 100000;
const int ADD = 1000000;
const int MOD = 1000000007;
const int CNT = 800;
struct RMQ {
int* t;
int c;
RMQ(int cc) {
t = new int[4 * MAX];
for (int i = (0); i < (4 * MAX); i++) {
t[i] = 0;
}
c = cc;
}
void Add(int v, int l, int r, int pos, int val) {
if (l == r) {
t[v] += val;
if (t[v] >= c) t[v] = c;
return;
}
int m = (l + r) / 2;
if (pos <= m)
Add(2 * v + 1, l, m, pos, val);
else
Add(2 * v + 2, m + 1, r, pos, val);
t[v] = t[2 * v + 1] + t[2 * v + 2];
}
int Get(int v, int l, int r, int L, int R) {
if (L > R) return 0;
if (l == L && r == R) {
return t[v];
}
int m = (l + r) / 2;
return Get(2 * v + 1, l, m, L, min(R, m)) +
Get(2 * v + 2, m + 1, r, max(m + 1, L), R);
}
};
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
RMQ R1(b);
RMQ R2(a);
for (int qq = (0); qq < (q); qq++) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, y;
scanf("%d%d", &x, &y);
--x;
R1.Add(0, 0, n - 1, x, y);
R2.Add(0, 0, n - 1, x, y);
} else {
int x;
scanf("%d", &x);
--x;
int res =
R1.Get(0, 0, n - 1, 0, x - 1) + R2.Get(0, 0, n - 1, x + k, n - 1);
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {}
const long long maxn = 200500;
long long N, K, A, B, Q;
long long cnt[maxn];
long long bita[maxn], bitb[maxn];
void upd(long long arr[], long long ind, long long val) {
for (long long i = ind; i <= N; i += (i & (-i))) {
arr[i] += val;
}
}
long long query(long long arr[], long long l, long long r) {
long long x = 0;
for (long long i = l - 1; i >= 1; i -= (i & (-i))) {
x += arr[i];
}
long long y = 0;
for (long long i = r; i >= 1; i -= (i & (-i))) {
y += arr[i];
}
return y - x;
}
signed main() {
ios::sync_with_stdio(0);
cin.sync_with_stdio(0);
cin.tie(0);
cin >> N >> K >> A >> B >> Q;
while (Q--) {
long long t;
cin >> t;
if (t == 1) {
long long d, a;
cin >> d >> a;
long long cpy = cnt[d];
cnt[d] += a;
upd(bita, d, min(A, cnt[d]) - min(A, cpy));
upd(bitb, d, min(B, cnt[d]) - min(B, cpy));
for (long long i = 1; i <= N; i++) {
if (false) cerr << cnt[i] << " ";
}
if (false) cerr << '\n';
} else if (t == 2) {
long long p;
cin >> p;
long long ans = query(bitb, 1, p - 1) + query(bita, p + K, N);
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e6 + 20;
long long n, k, a, b, q, vec[2][MAXN];
long long fen[2][MAXN];
long long get(long long v, long long t) {
long long ret = 0;
for (; v; v -= v & (-v)) ret += fen[t][v];
return ret;
}
void add(long long v, long long val, long long t) {
for (; v < MAXN; v += v & (-v)) fen[t][v] += val;
}
int main() {
scanf("%I64d %I64d %I64d %I64d %I64d", &n, &k, &a, &b, &q);
while (q--) {
long long type;
scanf("%I64d", &type);
if (type == 2) {
long long v;
scanf("%I64d", &v);
printf("%I64d\n", get(v - 1, 0) + (get(MAXN - 2, 1) - get(v + k - 1, 1)));
} else {
long long v, val;
scanf("%I64d %I64d", &v, &val);
long long dif = min(val, b - vec[0][v]);
vec[0][v] += dif;
add(v, dif, 0);
dif = min(val, a - vec[1][v]);
vec[1][v] += dif;
add(v, dif, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
ostream &operator<<(ostream &out, pair<T, T1> obj) {
out << "(" << obj.first << "," << obj.second << ")";
return out;
}
template <typename T, typename T1>
ostream &operator<<(ostream &out, map<T, T1> cont) {
typename map<T, T1>::const_iterator itr = cont.begin();
typename map<T, T1>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, set<T> cont) {
typename set<T>::const_iterator itr = cont.begin();
typename set<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, multiset<T> cont) {
typename multiset<T>::const_iterator itr = cont.begin();
typename multiset<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T,
template <typename ELEM, typename ALLOC = allocator<ELEM>> class CONT>
ostream &operator<<(ostream &out, CONT<T> cont) {
typename CONT<T>::const_iterator itr = cont.begin();
typename CONT<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T, unsigned int N, typename CTy, typename CTr>
typename enable_if<!is_same<T, char>::value, basic_ostream<CTy, CTr> &>::type
operator<<(basic_ostream<CTy, CTr> &out, const T (&arr)[N]) {
for (auto i = 0; i < N; ++i) out << arr[i] << " ";
out << endl;
return out;
}
template <typename T>
T gcd(T a, T b) {
T min_v = min(a, b);
T max_v = max(a, b);
while (min_v) {
T temp = max_v % min_v;
max_v = min_v;
min_v = temp;
}
return max_v;
}
template <typename T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
template <typename T>
T fast_exp_pow(T base, T exp, T mod) {
long long res = 1;
while (exp) {
if (exp & 1) {
res *= base;
res %= mod;
}
exp >>= 1;
base *= base;
base %= mod;
}
return res;
}
int N, K, A, B, Q, D, P, ch;
long long bit_b[200010], bit_a[200010];
long long values[200010][2];
long long ret;
long long getSum(long long *bit, int ind) {
long long sum = 0;
while (ind) {
sum += bit[ind];
ind -= ind & (-ind);
}
return sum;
}
void updateBit(long long *bit, int ind, long long val) {
while (ind <= N) {
bit[ind] += val;
ind += ind & (-ind);
}
}
int main() {
scanf("%d%d%d%d%d", &N, &K, &A, &B, &Q);
for (auto q = 1; q <= Q; ++q) {
scanf("%d", &ch);
if (ch == 1) {
scanf("%d%d", &D, &P);
updateBit(bit_b, D, min((long long)B - values[D][0], (long long)P));
updateBit(bit_a, D, min((long long)A - values[D][1], (long long)P));
values[D][0] = min(values[D][0] + P, (long long)B);
values[D][1] = min(values[D][1] + P, (long long)A);
} else if (ch == 2) {
scanf("%d", &P);
ret = getSum(bit_b, P - 1) + getSum(bit_a, N) - getSum(bit_a, P + K - 1);
printf("%I64d\n", ret);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxval = 200000;
long long int oka[200000 + 11], wa[200000 + 11];
void update(long long int *BIT, int idx, int val) {
while (idx <= mxval) BIT[idx] += val, idx += idx & -idx;
}
long long int query(long long int *BIT, int idx) {
long long int ret = 0;
while (idx) ret += BIT[idx], idx -= idx & -idx;
return ret;
}
long long int order[200000 + 11];
int main() {
int i, j, n, k, a, b, q;
int tp, di, vi, st;
scanf("%d %d %d", &n, &k, &a);
scanf("%d %d", &b, &q);
long long int res;
while (q--) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d %d", &di, &vi);
order[di] += vi;
update(oka, di, -(query(oka, di) - query(oka, di - 1)));
update(wa, di, -(query(wa, di) - query(wa, di - 1)));
update(oka, di, min(order[di], (long long int)a));
update(wa, di, min(order[di], (long long int)b));
} else {
scanf("%d", &st);
res = query(wa, st - 1);
res += query(oka, mxval) - query(oka, st + k - 1);
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr1[1000][1000];
void qwerty() {
for (int k = 0; k < 100; k++)
;
}
void asdfgh() {
for (int k = 0; k < 100; k++)
;
}
long long a1[200005];
long long b1[200005];
long long t1[500005], t2[500005];
long long n, a, b;
void zxcvb(long long p, long long value) {
long long p1 = p;
long long p2 = p;
p1 += n;
p2 += n;
for (t1[p1] = min(t1[p1] + value, a); p1 > 1; p1 >>= 1) {
t1[p1 >> 1] = t1[p1] + t1[p1 ^ 1];
}
for (t2[p2] = min(t2[p2] + value, b); p2 > 1; p2 >>= 1) {
t2[p2 >> 1] = t2[p2] + t2[p2 ^ 1];
}
}
long long yuiop(long long l, long long r) {
long long res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += t1[l++];
if (r & 1) res += t1[--r];
}
return res;
}
long long poiuy(long long l, long long r) {
long long res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += t2[l++];
if (r & 1) res += t2[--r];
}
return res;
}
int main() {
long long k, q, i, ch, d, x, p, ans;
cin >> n >> k >> b >> a >> q;
qwerty();
for (i = 0; i < q; i++) {
cin >> ch;
asdfgh();
if (ch == 1) {
cin >> d;
d--;
cin >> x;
zxcvb(d, x);
qwerty();
} else {
ans = 0;
cin >> p;
p--;
ans += yuiop(0, p);
ans += poiuy(p + k, n);
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int n, k, a, b, q;
struct stree {
int tree[4 * MAX];
void update(int x, int st, int nd, int p, int v, int l) {
if (st > p || nd < p) return;
if (st == nd) {
tree[x] = min(tree[x] + v, l);
return;
}
int mid = (st + nd) >> 1, I = x << 1, D = I + 1;
update(I, st, mid, p, v, l);
update(D, mid + 1, nd, p, v, l);
tree[x] = tree[I] + tree[D];
}
int query(int x, int st, int nd, int a, int b) {
if (a > b || st > b || nd < a) return 0;
if (st >= a && nd <= b) return tree[x];
int mid = (st + nd) >> 1, I = x << 1, D = I + 1;
return query(I, st, mid, a, b) + query(D, mid + 1, nd, a, b);
}
} t1, t2;
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int d, c;
scanf("%d%d", &d, &c);
t1.update(1, 1, n, d, c, b);
t2.update(1, 1, n, d, c, a);
continue;
}
int d;
scanf("%d", &d);
int q = t1.query(1, 1, n, 1, d - 1) + t2.query(1, 1, n, d + k, n);
printf("%d\n", q);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
void precalc() {}
const int maxn = 2e5 + 10;
struct tree {
int x[4 * maxn];
int mx;
int n;
void build(int _n, int _mx) {
for (n = 1; n < _n; n <<= 1)
;
mx = _mx;
memset(x, 0, sizeof(x));
}
void set(int pos, int val) {
int j = n + pos;
x[j] = min(mx, x[j] + val);
for (j >>= 1; j > 0; j >>= 1) {
x[j] = x[2 * j] + x[2 * j + 1];
}
}
int get(int v, int L, int R, int l, int r) {
if (L >= r || l >= R) {
return 0;
}
if (l <= L && R <= r) {
return x[v];
}
int M = (L + R) / 2;
return get(2 * v, L, M, l, r) + get(2 * v + 1, M, R, l, r);
}
int get(int l, int r) {
if (l >= r) {
return 0;
}
return get(1, 0, n, l, r);
}
} ta, tb;
int n, k, a, b, q;
bool read() {
if (scanf("%d%d%d%d%d", &n, &k, &a, &b, &q) < 5) {
return false;
}
return true;
}
void solve() {
ta.build(n, a);
tb.build(n, b);
for (int i = 0; i < q; ++i) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int d, x;
scanf("%d%d", &d, &x);
d--;
ta.set(d, x);
tb.set(d, x);
} else {
assert(tp == 2);
int p;
scanf("%d", &p);
--p;
int res = tb.get(0, p) + ta.get(p + k, n);
printf("%d\n", res);
}
}
}
int main() {
srand(rdtsc());
precalc();
while (true) {
if (!read()) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(200005);
int n;
int f[2][MAXN], sumA[MAXN], sumB[MAXN];
void update(int c, int i, int v) {
for (i; i <= n; i += i & (-i)) f[c][i] += v;
}
int query(int c, int i) {
int ret = 0;
for (i; i; i -= i & (-i)) ret += f[c][i];
return ret;
}
int main() {
int k, A, B, q;
scanf("%d%d%d%d%d", &n, &k, &A, &B, &q);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, v;
scanf("%d%d", &d, &v);
update(0, d, min(v, A - sumA[d]));
update(1, d, min(v, B - sumB[d]));
sumA[d] = min(A, sumA[d] + v);
sumB[d] = min(B, sumB[d] + v);
} else {
int d;
scanf("%d", &d);
printf("%d\n", query(1, d - 1) + query(0, n) - query(0, d + k - 1));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class Tree {
private:
int limit;
vector<long long> v;
long long get(int r) {
long long res = 0;
while (r > 0) {
res += v[r];
r = (r & (r + 1)) - 1;
}
return res;
}
public:
Tree(int n, int lim) : limit(lim) { v.resize((size_t)n + 1, 0); }
void update(long long val, int pos) {
val = min(val, limit - range(pos, pos));
while (pos < v.size()) {
v[pos] += val;
pos = pos | (pos + 1);
}
}
long long range(int l, int r) { return get(r) - get(l - 1); }
};
void solve() {
int n, k, a, b, q, type, pos, val;
cin >> n >> k >> a >> b >> q;
Tree before(n, b), after(n, a);
for (int i = 0; i < q; ++i) {
cin >> type;
if (type == 1) {
cin >> pos >> val;
before.update(val, pos);
after.update(val, pos);
} else {
cin >> pos;
int l = 1, r = pos - 1;
long long res = 0;
if (l <= r) {
res += before.range(l, r);
}
l = pos + k;
r = n;
if (l <= r) {
res += after.range(l, r);
}
cout << res << endl;
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
int cs1[N];
int cs2[N];
int ss1[N];
int ss2[N];
int sum(int i, int cs[]) {
int s = 0;
while (i > 0) {
s += cs[i];
i -= i & -i;
}
return s;
}
void add(int i, int k, int cs[]) {
while (i < N) {
cs[i] += k;
i += i & -i;
}
}
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; ++i) {
int c;
scanf("%d", &c);
if (c == 1) {
int d, aa;
scanf("%d%d", &d, &aa);
add(d, min(aa, b - ss1[d]), cs1);
add(d, min(aa, a - ss2[d]), cs2);
ss1[d] = min(ss1[d] + aa, b);
ss2[d] = min(ss2[d] + aa, a);
} else {
int p;
scanf("%d", &p);
int o = sum(n, cs2) - sum(p + k - 1, cs2) + sum(p - 1, cs1);
printf("%d\n", o);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("fast-math")
using namespace std;
template <typename T>
inline void uin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
inline void uax(T &a, T b) {
if (b > a) a = b;
}
const long long maxn = 228228;
long long A[maxn];
long long n, k, a, b, q;
struct node {
long long sum;
long long mod;
long long l, r;
node() { sum = mod = l = r = 0; }
};
vector<node> d;
void build(long long l, long long r, long long v = 1) {
d[v].l = l;
d[v].r = r;
if (l == r) return;
long long m = (l + r) >> 1;
build(l, m, v << 1);
build(m + 1, r, v << 1 | 1);
}
inline void init(long long _n) {
long long ss = 1;
while (ss < _n) ss <<= 1;
ss <<= 1;
d.resize(ss + 5, node());
build(1, _n);
}
inline long long gets(long long v) {
return d[v].sum + d[v].mod * (d[v].r - d[v].l + 1);
}
inline void push(long long v) {
d[v << 1].mod += d[v].mod;
d[v << 1 | 1].mod += d[v].mod;
d[v].mod = 0;
d[v].sum = gets(v << 1) + gets(v << 1 | 1);
}
void update(long long l, long long r, long long x, long long v = 1) {
if (l > r || d[v].l > r || d[v].r < l) return;
if (l <= d[v].l && d[v].r <= r) {
d[v].mod += x;
} else {
push(v);
update(l, r, x, v << 1);
update(l, r, x, v << 1 | 1);
push(v);
}
}
long long get(long long i, long long v = 1) {
if (d[v].l == d[v].r) return gets(v);
push(v);
long long m = (d[v].l + d[v].r) >> 1;
if (i <= m) return get(i, v << 1);
return get(i, v << 1 | 1);
}
inline void solve1(long long d, long long new_a) {
update(1, d - k, -min(a, A[d]));
update(d + 1, n, -min(b, A[d]));
A[d] += new_a;
update(1, d - k, min(a, A[d]));
update(d + 1, n, min(b, A[d]));
}
inline void solve() {
cin >> n >> k >> a >> b >> q;
init(n);
for (long long iter = 1; iter <= (long long)q; ++iter) {
long long type;
cin >> type;
if (type == 1) {
long long d, a;
cin >> d >> a;
solve1(d, a);
} else {
long long p;
cin >> p;
cout << get(p) << '\n';
}
if (type == 2) continue;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, d1, d2, m, A[210000], B[210000], w[210000];
void add(int *A, int k1, int k2) {
for (; k1 <= n; k1 += k1 & (-k1)) A[k1] += k2;
}
int find(int *A, int k1) {
int ans = 0;
for (; k1; k1 -= k1 & (-k1)) ans += A[k1];
return ans;
}
int main() {
scanf("%d%d%d%d%d", &n, &K, &d1, &d2, &m);
memset(A, 0x00, sizeof A);
memset(B, 0x00, sizeof B);
int tot = 0;
for (; m; m--) {
int k1, k2;
scanf("%d%d", &k1, &k2);
if (k1 == 1) {
int k3;
scanf("%d", &k3);
int pre = w[k2];
add(A, k2, -min(w[k2], d2));
add(B, k2, -min(w[k2], d1));
w[k2] += k3;
add(A, k2, min(w[k2], d2));
add(B, k2, min(w[k2], d1));
} else if (k1 == 2) {
int l = k2 - 1, r = min(k2 + K, n + 1), ans = find(A, l);
if (r <= n) ans += find(B, n) - find(B, r - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T b, T p, T M) {
long long ret = 1;
for (; p > 0; p >>= 1) {
if (p & 1) ret = (ret * b) % M;
b = (b * b) % M;
}
return (T)ret;
}
int dx4[] = {-1, 0, 1, 0};
int dy4[] = {0, 1, 0, -1};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
const double PI = acos(-1.0), EPS = 1e-7;
const long long INF = (long long)1e18 + 7;
const int N = 2e5 + 5, M = 1e9 + 7;
int n, k, a, b, q;
int seg[2][4 * N];
void update(int c, int s, int e, int p, int v) {
if (s == e) {
seg[0][c] = min(b, seg[0][c] + v);
seg[1][c] = min(a, seg[1][c] + v);
return;
}
int m = (s + e) / 2;
if (p <= m)
update(2 * c + 1, s, m, p, v);
else
update(2 * c + 2, m + 1, e, p, v);
seg[0][c] = seg[0][2 * c + 1] + seg[0][2 * c + 2];
seg[1][c] = seg[1][2 * c + 1] + seg[1][2 * c + 2];
}
int query(int id, int c, int s, int e, int qs, int qe) {
if (qe < qs) return 0;
if (s == qs && e == qe) return seg[id][c];
int m = (s + e) / 2;
if (qe <= m)
return query(id, 2 * c + 1, s, m, qs, qe);
else if (qs > m)
return query(id, 2 * c + 2, m + 1, e, qs, qe);
else {
int x = query(id, 2 * c + 1, s, m, qs, m);
int y = query(id, 2 * c + 2, m + 1, e, m + 1, qe);
return x + y;
}
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int d, x, y;
scanf("%d %d", &d, &x);
if (d == 1) {
scanf("%d", &y);
update(0, 0, n - 1, x - 1, y);
} else {
int ans = query(0, 0, 0, n - 1, 0, x - 2);
ans += query(1, 0, 0, n - 1, x + k - 1, n - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[2][200200];
int bit[2][200200];
inline void update(bool def, int idx, int val) {
while (idx <= n) {
bit[def][idx] += val;
idx += idx & -idx;
}
}
inline int getSum(bool def, int idx) {
int sum = 0;
while (idx > 0) {
sum += bit[def][idx];
idx -= idx & -idx;
}
return sum;
}
int main() {
int k, a, b, q, t, d, x, pa, pb;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d %d", &d, &x);
arr[0][d] = min(x + (pa = arr[0][d]), a);
arr[1][d] = min(x + (pb = arr[1][d]), b);
update(0, d, arr[0][d] - pa);
update(1, d, arr[1][d] - pb);
} else {
scanf("%d", &x);
printf("%d\n", getSum(1, x - 1) + getSum(0, n) - getSum(0, x + k - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
struct node {
int s[2];
} tr[N << 2];
int a, b;
void push_up(int t) {
tr[t].s[0] = tr[t << 1].s[0] + tr[t << 1 | 1].s[0];
tr[t].s[1] = tr[t << 1].s[1] + tr[t << 1 | 1].s[1];
}
void update(int t, int L, int R, int x, int v) {
if (L == R) {
tr[t].s[0] = ((tr[t].s[0] + v) < (b) ? (tr[t].s[0] + v) : (b));
tr[t].s[1] = ((tr[t].s[1] + v) < (a) ? (tr[t].s[1] + v) : (a));
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
update(t << 1, L, mid, x, v);
else
update(t << 1 | 1, mid + 1, R, x, v);
push_up(t);
}
int query(int t, int L, int R, int l, int r, int op) {
if (r < l) return 0;
if (l <= L && R <= r) {
return tr[t].s[op];
}
int ans = 0, mid = (L + R) >> 1;
if (l <= mid) ans += query(t << 1, L, mid, l, r, op);
if (r > mid) ans += query(t << 1 | 1, mid + 1, R, l, r, op);
return ans;
}
int main() {
int n, k, q, op, x, v;
while (~scanf("%d%d%d%d%d", &n, &k, &a, &b, &q)) {
memset(tr, 0, sizeof(tr));
while (q--) {
scanf("%d%d", &op, &x);
if (op == 1) {
scanf("%d", &v);
update(1, 1, n, x, v);
} else {
printf("%d\n",
query(1, 1, n, 1, x - 1, 0) + query(1, 1, n, x + k, n, 1));
}
}
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
template <typename T, typename U>
pair<T, U> operator+(const pair<T, U> &l, const pair<T, U> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
int n, m, q;
long long A, B;
int S;
pair<long long, long long> it[600000];
long long a[200000];
void update(int x) {
for (x /= 2; x > 0; x /= 2) it[x] = it[x * 2] + it[x * 2 + 1];
}
pair<long long, long long> getres(int x, int y) {
pair<long long, long long> res(0, 0);
while (x <= y) {
if (x % 2 == 1) res = res + it[x++];
if (y % 2 == 0) res = res + it[y--];
x /= 2, y /= 2;
}
return res;
}
int main() {
int i, j, k;
cin >> n >> m >> A >> B >> q;
for (S = 1; S < n; S *= 2)
;
for (i = 0; i < q; i++) {
int x, y, z;
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &y, &z), y--;
a[y] += z;
it[S + y] = pair<long long, long long>(min(a[y], B), min(a[y], A));
update(S + y);
} else {
scanf("%d", &y), y--;
long long ans = getres(S + 0, S + y - 1).first;
ans += getres(S + y + m, S + n - 1).second;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, A, B, Q, x, y, t, ans;
int data[200010];
class segleaf {
public:
int s[2];
} seg[2000010];
void change(int x, int l, int r, int t, int delta) {
if (l == r) {
data[t] += delta;
seg[x].s[0] = min(data[t], B);
seg[x].s[1] = min(data[t], A);
return;
}
int mid = (l + r) >> 1;
if (t <= mid)
change(x << 1, l, mid, t, delta);
else
change((x << 1) + 1, mid + 1, r, t, delta);
seg[x].s[0] = seg[x << 1].s[0] + seg[(x << 1) + 1].s[0];
seg[x].s[1] = seg[x << 1].s[1] + seg[(x << 1) + 1].s[1];
}
int ask(int x, int l, int r, int ll, int rr, int tt) {
if (l == ll && r == rr) return seg[x].s[tt];
int mid = (l + r) >> 1;
if (rr <= mid)
return ask(x << 1, l, mid, ll, rr, tt);
else if (ll > mid)
return ask((x << 1) + 1, mid + 1, r, ll, rr, tt);
else
return ask(x << 1, l, mid, ll, mid, tt) +
ask((x << 1) + 1, mid + 1, r, mid + 1, rr, tt);
}
int main() {
scanf("%d%d%d%d%d", &N, &K, &A, &B, &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &y);
change(1, 1, N, x, y);
} else {
scanf("%d", &x);
ans = 0;
if (x > 1) ans += ask(1, 1, N, 1, x - 1, 0);
if (x + K <= N) ans += ask(1, 1, N, x + K, N, 1);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct BIT {
vector<long long> tree;
BIT(int n) : tree(n + 2) {}
void upd(int p, long long v) {
for (int i = ++p; i < tree.size(); i += i & -i) tree[i] += v;
}
long long get(int p) {
long long sum = 0;
for (int i = ++p; i; i -= i & -i) sum += tree[i];
return sum;
}
long long query(int l, int r) {
if (r < l) return 0;
return get(r) - get(l - 1);
}
int get_kth(long long k) {
int pos = 0;
long long s = 0;
for (int i = 1 + log2(tree.size()); i >= 0; i--)
if (pos + (1 << i) < tree.size() && s + tree[pos + (1 << i)] < k)
s += tree[pos + (1 << i)], pos += (1 << i);
return pos;
}
int lower_bound(int v) { return get_kth(get(v - 1) + 1); }
int upper_bound(int v) { return lower_bound(v + 1); }
};
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
BIT pre(n + 1), suff(n + 1);
vector<int> A(n + 1);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int day, add;
cin >> day >> add;
A[day] += add;
int oldpre = pre.query(day, day);
int oldsuff = suff.query(day, day);
pre.upd(day, min(A[day], b) - oldpre);
suff.upd(day, min(A[day], a) - oldsuff);
} else {
int p;
cin >> p;
int r = min(n + 1, p + k);
cout << pre.query(0, p - 1) + suff.query(r, n + 1) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long fg[200001], fb[200001];
long long arr[200001];
long long n, k, a, b, q;
void update(int index, long long amount) {
long long good, bad;
if (arr[index] + amount <= b)
good = amount;
else
good = max(0LL, b - arr[index]);
for (int i = index; i <= n; i += (i & -i)) fg[i] += good;
if (arr[index] + amount <= a)
bad = amount;
else
bad = max(0LL, a - arr[index]);
for (int i = index; i <= n; i += (i & -i)) fb[i] += bad;
arr[index] += amount;
}
long long get(int index, bool isGood) {
if (index <= 0) return 0;
long long sum = 0;
if (isGood) {
while (index > 0) {
sum += fg[index];
index -= (index & -index);
}
} else {
while (index > 0) {
sum += fb[index];
index -= (index & -index);
}
}
return sum;
}
int main() {
scanf("%I64d %I64d %I64d %I64d %I64d", &n, &k, &b, &a, &q);
while (q--) {
int which;
scanf("%d", &which);
if (which == 2) {
int day;
scanf("%d", &day);
printf("%I64d\n",
get(day - 1, false) + get(n, true) - get(day + k - 1, true));
} else {
int day;
long long amount;
scanf("%d %I64d", &day, &amount);
update(day, amount);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[200005], d[200005];
int n, k, a, b, q;
int w[200005], w1[200005];
void add(int i, int x) {
for (; i <= n + 1; c[i] += x, i += i & -i)
;
}
void add1(int i, int x) {
for (; i <= n + 1; d[i] += x, i += i & -i)
;
}
int sum(int i) {
int s = 0;
for (; i > 0; s += c[i], i -= i & -i)
;
return s;
}
int sum1(int i) {
int s = 0;
for (; i > 0; s += d[i], i -= i & -i)
;
return s;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int p, x;
scanf("%d%d", &p, &x);
if (w[p]) add(p, -w[p]);
if (w1[p]) add1(p, -w1[p]);
w[p] += x;
w1[p] += x;
w[p] = min(b, w[p]);
w1[p] = min(a, w1[p]);
add(p, w[p]);
add1(p, w1[p]);
} else {
int p;
scanf("%d", &p);
printf("%d\n", sum1(n) - sum1(p + k - 1) + sum(p - 1) - sum(0));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class SEG_TREE {
private:
struct node {
node *left, *right;
int val = 0;
};
node* root;
int N;
void build(int start, int end, node*& r) {
r = new node;
int mid = (start + end) / 2;
if (start != end) {
build(start, mid, r->left);
build(mid + 1, end, r->right);
}
}
void up(int start, int end, node*& x, int i, int v, int l) {
int mid = (start + end) / 2;
if (start == end) {
x->val = min(x->val + v, l);
return;
} else if (i <= mid) {
up(start, mid, x->left, i, v, l);
} else {
up(mid + 1, end, x->right, i, v, l);
}
x->val = x->left->val + x->right->val;
}
int qu(int start, int end, node*& x, int a, int b) {
int mid = (start + end) / 2;
if (start >= a && end <= b) {
return x->val;
} else if (start > b || end < a) {
return 0;
} else
return qu(start, mid, x->left, a, b) + qu(mid + 1, end, x->right, a, b);
}
public:
SEG_TREE(int n) {
N = n;
build(1, n, root);
}
void update(int i, int v, int l) { up(1, N, root, i, v, l); }
int query(int a, int b) {
if (b < a) {
return 0;
}
return qu(1, N, root, a, b);
}
};
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
SEG_TREE* t1 = new SEG_TREE(n);
SEG_TREE* t2 = new SEG_TREE(n);
int type;
int d, v, p;
while (q--) {
cin >> type;
if (type == 1) {
cin >> d >> v;
t1->update(d, v, a);
t2->update(d, v, b);
} else {
cin >> p;
cout << t2->query(1, p - 1) + t1->query(p + k, n) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int BASE = 1000000007;
const int MAX = 200047;
const int MAX2 = 7777;
const int MAXE = 100000;
const int ADD = 1000000;
const int MOD = 1000000007;
const int CNT = 800;
int n, k, q;
int a, b;
const int add = 262144;
struct RMQ {
int F[2 * add];
int S[2 * add];
RMQ() {
memset(F, 0, sizeof(F));
memset(S, 0, sizeof(S));
}
void upd(int pos, int add) {
pos += MAX;
F[pos] += add;
F[pos] = min(F[pos], b);
S[pos] += add;
S[pos] = min(S[pos], a);
pos /= 2;
while (pos) {
F[pos] = F[2 * pos + 1] + F[2 * pos];
S[pos] = S[2 * pos + 1] + S[2 * pos];
pos /= 2;
}
}
int su(int l, int r, int t) {
if (l > r) return 0;
int ret = 0;
if (l % 2 == 1) {
if (t)
ret += S[l];
else
ret += F[l];
l++;
}
if (r % 2 == 0) {
if (t)
ret += S[r];
else
ret += F[r];
r--;
}
return su(l / 2, r / 2, t) + ret;
}
int sum(int l1, int r1, int l2, int r2) {
return su(l1 + MAX, r1 + MAX, 0) + su(l2 + MAX, r2 + MAX, 1);
}
} R;
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = (0); i < (q); i++) {
int type, d, add;
scanf("%d", &type);
if (type == 1) {
scanf("%d%d", &d, &add);
d--;
R.upd(d, add);
} else {
scanf("%d", &d);
d--;
cout << R.sum(0, d - 1, d + k, n - 1) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (1 << 29) + 5;
const long long int LLINF = (1ll << 60) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 2000 * 100 + 5;
int n, k, a, b, q;
long long int arr[2][MAX_N];
long long int tree[2][MAX_N];
long long int get(int x, int at) {
long long int ans = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) ans += tree[at][x];
return ans;
}
void inc(int x, long long int add, int at) {
for (; x <= n; x = (x | (x + 1))) tree[at][x] += add;
}
long long int sum(int l, int r, int at) { return get(r, at) - get(l - 1, at); }
int main() {
memset(tree, 0, sizeof(tree));
memset(arr, 0, sizeof(arr));
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
int type, d;
long long int add;
for (int i = 0; i < q; ++i) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %I64d", &d, &add);
long long int up = min(a - arr[0][d], add);
arr[0][d] = min(arr[0][d] + add, a * 1ll);
inc(d, up, 0);
up = min(b - arr[1][d], add);
arr[1][d] = min(arr[1][d] + add, b * 1ll);
inc(d, up, 1);
} else {
scanf("%d", &d);
printf("%I64d\n", get(d - 1, 1) + sum(d + k, n, 0));
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
double Double() {
double x;
scanf("%lf", &x);
return x;
}
float Float() {
float x;
scanf("%f", &x);
return x;
}
const int N = 1e5 + 5;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
int a;
int b;
struct order {
int pre;
int post;
} tree[2 * N];
int last = 2 * (int)(1e5);
order query(int idx) {
order res;
res.pre = 0;
res.post = 0;
while (idx > 0) {
res.pre += tree[idx].pre;
res.post += tree[idx].post;
idx -= (idx & -idx);
}
return res;
}
void update(int idx, int x) {
order p = query(idx);
order q = query(idx - 1);
int pp = min(b - (p.pre - q.pre), x);
int qq = min(a - (p.post - q.post), x);
while (idx <= last) {
tree[idx].pre += pp;
tree[idx].post += qq;
idx += (idx & -idx);
}
}
int main() {
int n = Int(), k = Int();
a = Int(), b = Int();
int q = Int();
for (int i = 0; i < q; i++) {
int ty = Int();
if (ty == 1) {
int id = Int(), x = Int();
update(id, x);
} else {
int id = Int();
order ans1 = query(id - 1);
order ans2 = query(last);
order ans3 = query(id + k - 1);
cout << ans1.pre + ans2.post - ans3.post << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int n, seg[4 * maxn][2], arr[maxn];
void add(int t, int idx, int val, int L = 0, int R = n, int id = 1) {
if (L == R - 1) {
seg[id][t] = val;
return;
}
int mid = (L + R) >> 1;
if (idx < mid)
add(t, idx, val, L, mid, id * 2 + 0);
else
add(t, idx, val, mid, R, id * 2 + 1);
seg[id][t] = seg[id * 2 + 0][t] + seg[id * 2 + 1][t];
}
int get(int t, int l, int r, int L = 0, int R = n, int id = 1) {
if (l == L && r == R) return seg[id][t];
int mid = (L + R) >> 1, ret = 0;
if (l < mid) ret += get(t, l, min(mid, r), L, mid, id * 2 + 0);
if (r > mid) ret += get(t, max(l, mid), r, mid, R, id * 2 + 1);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int k, a, b, q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx, val;
cin >> idx >> val;
idx--, arr[idx] += val;
add(0, idx, min(a, arr[idx]));
add(1, idx, min(b, arr[idx]));
} else {
int pi;
cin >> pi;
pi--;
int ans = 0;
if (pi + k < n) ans += get(0, pi + k, n);
if (0 < pi) ans += get(1, 0, pi);
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long double pii = 3.14159265359;
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 200001;
int A, B;
class FenwickTree {
vector<int> ft;
public:
FenwickTree(int n) { ft.assign(n + 1, 0); }
long long rsq(int b) {
long long sum = 0;
while (b > 0) {
sum += ft[b];
b -= b & (-b);
}
return sum;
}
long long rsq(int a, int b) { return rsq(b) - (a == 1 ? 0 : rsq(a - 1)); }
void add(int k, long long v) {
while (k < (int)ft.size()) {
ft[k] += v;
k += k & (-k);
}
}
};
void solve() {
int N, K, Q;
cin >> N >> K >> A >> B >> Q;
FenwickTree fq(N + 2), fq1(N + 2);
long long ans = 0;
while (Q--) {
int ch;
cin >> ch;
if (ch == 1) {
int a, b;
cin >> a >> b;
if (fq.rsq(a, a) + b > A) {
fq.add(a, A - fq.rsq(a, a));
} else
fq.add(a, b);
if (fq1.rsq(a, a) + b > B) {
fq1.add(a, B - fq1.rsq(a, a));
} else
fq1.add(a, b);
} else {
int nb;
cin >> nb;
cout << fq1.rsq(0, nb - 1) + fq.rsq(N) - fq.rsq(min(nb + K - 1, N)) << nl;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int Test_case = 1;
while (Test_case-- != 0) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
void solve();
void precalc();
clock_t start;
int testNumber = 1;
bool todo = true;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
int testNum = 1;
while (t--) {
solve();
++testNumber;
}
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
void precalc() {}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
struct SegTree {
const int shift = 1 << 18;
vector<int> tree;
SegTree() { tree.assign(2 * shift, 0); }
int rmq(int l, int r) {
if (l >= r) {
return 0;
}
if (l & 1) {
return tree[l] + rmq(l + 1, r);
}
if (r & 1) {
return tree[r - 1] + rmq(l, r - 1);
}
return rmq(l / 2, r / 2);
}
int get_sum(int l, int r) { return rmq(l + shift, r + shift); }
void update(int v, int val) {
v += shift;
tree[v] = val;
v /= 2;
while (v) {
tree[v] = tree[2 * v] + tree[2 * v + 1];
v /= 2;
}
}
};
void solve() {
int n, k, Q;
vector<int> a(2);
cin >> n >> k >> a[0] >> a[1] >> Q;
vector<int> sums(n, 0);
vector<SegTree> tree(2);
for (int w = 0; w < Q; ++w) {
int type;
cin >> type;
if (type == 1) {
int day, num;
cin >> day >> num;
--day;
sums[day] += num;
for (int i = 0; i < 2; ++i) {
tree[i].update(day, min(sums[day], a[i]));
}
} else {
int l;
cin >> l;
--l;
long long res = (long long)tree[1].get_sum(0, l) +
(long long)tree[0].get_sum(l + k, n);
cout << res << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAX = 200005;
struct Segtree {
int arr[4 * MAX];
int tree[4 * MAX];
void build(int node, int a, int b) {
if (a == b) {
tree[node] = arr[a];
return;
}
build(2 * node, a, (a + b) / 2);
build(2 * node + 1, (a + b) / 2 + 1, b);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
void update(int node, int a, int b, int i, int value) {
if (a > i || b < i) {
return;
}
if (a == b) {
tree[node] = value;
return;
}
update(2 * node, a, (a + b) / 2, i, value);
update(2 * node + 1, (a + b) / 2 + 1, b, i, value);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
int query(int node, int a, int b, int i, int j) {
if (a > j || b < i) {
return 0;
}
if (i <= a && b <= j) {
return tree[node];
}
int x = query(2 * node, a, (a + b) / 2, i, j);
int y = query(2 * node + 1, (a + b) / 2 + 1, b, i, j);
return x + y;
}
};
int order[MAX];
Segtree bef;
Segtree aft;
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int qt;
scanf("%d", &qt);
if (qt == 1) {
int day, ord;
scanf("%d %d", &day, &ord);
order[day] += ord;
bef.update(1, 1, n, day, min(order[day], b));
aft.update(1, 1, n, day, min(order[day], a));
} else {
int b;
scanf("%d", &b);
int bend = b + k - 1;
cout << bef.query(1, 1, n, 1, b - 1) + aft.query(1, 1, n, bend + 1, n)
<< endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 100;
long long it1[6 * N];
long long it2[6 * N];
long long now[N];
int n;
long long a, b;
int q;
int t;
void update1(int node, int u, int l, int r, int cost) {
if (l == u && r == u) {
now[u] += 1LL * cost;
it1[node] = min(now[u], b);
return;
}
if (l > u || r < u) return;
int mid = (l + r) / 2;
update1(2 * node, u, l, mid, cost);
update1(2 * node + 1, u, mid + 1, r, cost);
it1[node] = it1[2 * node] + it1[2 * node + 1];
}
void update2(int node, int u, int l, int r, int cost) {
if (l == u && r == u) {
it2[node] = min(now[u], a);
return;
}
if (l > u || r < u) return;
int mid = (l + r) / 2;
update2(2 * node, u, l, mid, cost);
update2(2 * node + 1, u, mid + 1, r, cost);
it2[node] = it2[2 * node] + it2[2 * node + 1];
}
long long get1(int node, int u, int v, int l, int r) {
if (u <= l && r <= v) return it1[node];
if (l > v || r < u) return 0;
int mid = (l + r) / 2;
return (get1(2 * node, u, v, l, mid) + get1(2 * node + 1, u, v, mid + 1, r));
}
long long get2(int node, int u, int v, int l, int r) {
if (u <= l && r <= v) return it2[node];
if (l > v || r < u) return 0;
int mid = (l + r) / 2;
return (get2(2 * node, u, v, l, mid) + get2(2 * node + 1, u, v, mid + 1, r));
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> t >> a >> b >> q;
while (q--) {
int k;
cin >> k;
if (k == 1) {
int u, v;
cin >> u >> v;
update1(1, u, 1, n, v);
update2(1, u, 1, n, v);
} else {
int u;
cin >> u;
long long ans = 0;
if (u - 1 > 0) ans += get1(1, 1, u - 1, 1, n);
if (u + t <= n) ans += get2(1, u + t, n, 1, n);
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long sma[200010];
long long smb[200010];
long long d[200010];
int n;
void adda(int pos, long long x) {
for (int i = pos; i <= n; i = (i | (i - 1)) + 1) {
sma[i] += x;
}
}
long long suma(int pos) {
long long ans = 0;
for (int i = pos; i > 0; i &= i - 1) {
ans += sma[i];
}
return ans;
}
void addb(int pos, long long x) {
for (int i = pos; i <= n; i = (i | (i - 1)) + 1) {
smb[i] += x;
}
}
long long sumb(int pos) {
long long ans = 0;
for (int i = pos; i > 0; i &= i - 1) {
ans += smb[i];
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int k, q;
long long a, b;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (x == 1) {
int pos;
long long v;
cin >> pos >> v;
if (d[pos] < b) {
if (d[pos] + v < b) {
addb(pos, v);
} else {
addb(pos, b - d[pos]);
}
}
if (d[pos] < a) {
if (d[pos] + v < a) {
adda(pos, v);
} else {
adda(pos, a - d[pos]);
}
}
d[pos] += v;
} else {
int pos;
cin >> pos;
cout << sumb(pos - 1) + suma(n) - suma(pos + k - 1) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree1[200010], tree2[200010], cur1[200010], cur2[200010];
void update(int ind, long long dif1, long long dif2) {
for (int i = ind; i < 200010; i = i + (i & (-1 * i)))
tree1[i] += dif1, tree2[i] += dif2;
}
long long query1(long long a) {
long long ans = 0;
for (int i = a; i > 0; i = i - (i & (-1 * i))) ans += tree1[i];
return ans;
}
long long getrg1(long long a, long long b) {
if (a > b) return 0;
if (a <= 1) return query1(b);
return query1(b) - query1(a - 1);
}
long long query2(long long a) {
long long ans = 0;
for (int i = a; i > 0; i = i - (i & (-1 * i))) ans += tree2[i];
return ans;
}
long long getrg2(long long a, long long b) {
if (a > b) return 0;
if (a <= 1) return query2(b);
return query2(b) - query2(a - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int d, x;
cin >> d >> x;
long long old1 = cur1[d];
long long old2 = cur2[d];
cur1[d] = min(b, cur1[d] + x);
cur2[d] = min(a, cur2[d] + x);
update(d, cur1[d] - old1, cur2[d] - old2);
} else {
int d;
cin >> d;
cout << getrg1(1, d - 1) + getrg2(d + k, n) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long BIT[2][202001];
int n;
void update(long long tree[202001], int p, int v) {
for (; p <= n; p += p & -p) {
tree[p] += v;
}
}
long long query(long long tree[202001], int p) {
long long ret = 0;
while (p) {
ret += tree[p];
p -= p & -p;
}
return ret;
}
long long query(long long tree[202001], int a, int b) {
if (a > b) return 0LL;
return query(tree, b) - query(tree, a - 1);
}
int type, k, a, b, q, x, y, tmp;
int t[202001];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; ++i) {
cin >> type >> x;
if (type == 1) {
cin >> y;
if ((tmp = (min(t[x] + y, b) - t[x])) > 0) update(BIT[0], x, tmp);
if ((tmp = (min(t[x] + y, a) - t[x])) > 0) update(BIT[1], x, tmp);
t[x] = min(t[x] + y, a);
} else {
cout << (query(BIT[0], x - 1) + query(BIT[1], x + k, n)) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e6 + 15;
const int Q = 1e9 + 7;
long long tree[2][M];
long long v[M];
void upd(int tq, int i, long long x) {
for (; i < M; i = (i | (i - 1)) + 1) tree[tq][i] += x;
}
long long get(int tq, int i) {
long long res = 0;
for (; i; i = i & (i - 1)) res += tree[tq][i];
return res;
}
long long sum(int tq, int l, int r) { return get(tq, r) - get(tq, l - 1); }
int main() {
srand(time(NULL));
int n, k, q;
long long a, b;
cin >> n >> k >> b >> a >> q;
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
int di, ai;
cin >> di >> ai;
upd(0, di, min(a, v[di] + ai) - min(a, v[di]));
upd(1, di, min(b, v[di] + ai) - min(b, v[di]));
v[di] += ai;
} else {
int pi;
cin >> pi;
cout << sum(0, 1, pi - 1) + sum(1, pi + k, n) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct BIT {
int bit[200005];
void init() { memset(bit, 0, sizeof(bit)); }
void add(int k, int x) {
k++;
while (k < 200005) {
bit[k] += x;
k += k & -k;
}
}
int get(int k) {
k++;
int ret = 0;
while (k > 0) {
ret += bit[k];
k -= k & -k;
}
return ret;
}
int get(int s, int t) { return get(t) - get(s - 1); }
};
BIT bit1, bit2;
int cnt[200005];
int A, B;
int main() {
int n, k, q;
scanf("%d %d %d %d %d", &n, &k, &A, &B, &q);
bit1.init();
bit2.init();
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int a, b;
scanf("%d %d", &a, &b);
a--;
bit1.add(a, -min(B, cnt[a]));
bit2.add(a, -min(A, cnt[a]));
cnt[a] += b;
bit1.add(a, min(B, cnt[a]));
bit2.add(a, min(A, cnt[a]));
} else {
int v;
scanf("%d", &v);
v--;
printf("%d\n", bit1.get(0, v - 1) + bit2.get(v + k, n - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Ta[200001] = {}, Tb[200001] = {};
long long A[200001] = {};
void inc(int i, long long v, long long* t) {
for (; i < 200001; i += i & -i) t[i] += v;
}
long long sum(int r, long long* t) {
long long res = 0;
for (; r; r -= r & -r) res += t[r];
return res;
}
int main() {
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int x = 0; x < q; x++) {
long long Q, q1, q2;
cin >> Q;
if (Q == 1) {
cin >> q1 >> q2;
inc(q1, max(min(b - A[q1], (long long)q2), 0LL), Tb);
inc(q1, max(min(a - A[q1], (long long)q2), 0LL), Ta);
A[q1] += q2;
} else {
cin >> q1;
cout << sum(q1 - 1, Tb) + (sum(200001 - 1, Ta) - sum(q1 + k - 1, Ta))
<< '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> a;
long long int c, d;
vector<pair<long long int, long long int> > tree;
void update(long long int idx, long long int pos, long long int s,
long long int e) {
if (pos < s || pos > e) return;
if (s == e) {
tree[idx] = {min(a[s], c), min(a[s], d)};
return;
}
long long int mid = s + ((e - s) >> 1);
update(2 * idx, pos, s, mid);
update(2 * idx + 1, pos, mid + 1, e);
tree[idx] = {tree[2 * idx].first + tree[2 * idx + 1].first,
tree[2 * idx].second + tree[2 * idx + 1].second};
return;
}
long long query(long long int idx, long long int l, long long int r,
long long int type, long long int s, long long int e) {
if (r < s || l > e) return 0;
if (s >= l && e <= r) {
if (type == 1)
return tree[idx].first;
else
return tree[idx].second;
}
long long int mid = s + ((e - s) >> 1);
return (query(2 * idx, l, r, type, s, mid) +
query(2 * idx + 1, l, r, type, mid + 1, e));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k, i, l, r, q, t, ans;
cin >> n >> k >> c >> d >> q;
a.resize(n);
tree.resize(4 * n + 2);
while (q--) {
cin >> t;
if (t == 1) {
cin >> i >> l;
i--;
a[i] += l;
update(1, i, 0, n - 1);
} else {
cin >> i;
i--;
ans = query(1, 0, i - 1, 2, 0, n - 1);
i += k;
ans += query(1, i, n - 1, 1, 0, n - 1);
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
int tree0[200100], tree1[200100], cnt[200100];
void add0(int x, int y) {
for (int i = x; i <= n; i += ((i) & -(i))) tree0[i] += y;
}
void add1(int x, int y) {
for (int i = x; i; i -= ((i) & -(i))) tree1[i] += y;
}
int ask0(int x) {
int ans = 0;
for (int i = x; i; i -= ((i) & -(i))) ans += tree0[i];
return ans;
}
int ask1(int x) {
int ans = 0;
for (int i = x; i <= n; i += ((i) & -(i))) ans += tree1[i];
return ans;
}
int main() {
int i, j, ord, x, y;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &ord);
if (ord == 1) {
scanf("%d%d", &x, &y);
if (cnt[x] < b) add0(x, min(b, cnt[x] + y) - cnt[x]);
if (cnt[x] < a) add1(x, min(a, cnt[x] + y) - cnt[x]);
cnt[x] += y;
} else {
scanf("%d", &x);
printf("%d\n", ask0(x - 1) + ask1(x + k));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct BIT {
vector<ll> bit;
vector<ll> a;
ll n;
BIT(ll n) {
this->n = n;
bit.assign(n, 0);
a.assign(n, 0);
}
void add(ll idx, ll del) {
for (; idx < n; idx |= idx + 1) {
bit[idx] += del;
}
}
void update(ll idx, ll val) {
add(idx, val - a[idx]);
a[idx] = val;
}
ll sum(ll r) {
ll res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
res += bit[r];
}
return res;
}
ll sum(ll l, ll r) { return sum(r) - sum(l - 1); }
};
void solve() {
ll n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
BIT bit1(n), bit2(n);
vector<ll> v(n, 0);
while (q--) {
ll x;
cin >> x;
if (x == 1) {
ll d, e;
cin >> d >> e;
v[d - 1] += e;
bit1.update(d - 1, min(v[d - 1], b));
bit2.update(d - 1, min(v[d - 1], a));
} else {
ll p;
cin >> p;
cout << bit1.sum(p - 2) + bit2.sum(p + k - 1, n - 1) << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
long long dbg = 1;
using namespace std;
long long n, k, a, b, q;
long long t[2 * 200005], t1[2 * 200005];
void update(long long d, long long k) {
d += n;
t[d] = min(t[d] + k, a);
d /= 2;
while (d) {
t[d] = t[2 * d] + t[2 * d + 1];
d /= 2;
}
}
void update2(long long d, long long k) {
d += n;
t1[d] = min(t1[d] + k, b);
d /= 2;
while (d) {
t1[d] = t1[2 * d] + t1[2 * d + 1];
d /= 2;
}
}
long long query(long long c, long long d) {
c += n;
d += n;
long long ans = 0;
while (c < d) {
if (c % 2) ans += t[c++];
if (d % 2) ans += t[--d];
c /= 2;
d /= 2;
}
return ans;
}
long long query2(long long c, long long d) {
c += n;
d += n;
long long ans = 0;
while (c < d) {
if (c % 2) ans += t1[c++];
if (d % 2) ans += t1[--d];
c /= 2;
d /= 2;
}
return ans;
}
int main() {
cin >> n >> k >> a >> b >> q;
long long c, d, e;
while (q--) {
cin >> c >> d;
d--;
if (c == 1) {
cin >> e;
update(d, e);
update2(d, e);
} else {
cout << query2(0, d) + query(d + k, n) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ta[800000] = {0}, tb[800000] = {0};
int suma(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return ta[v];
int tm = (tl + tr) / 2;
return suma(v * 2, tl, tm, l, min(r, tm)) +
suma(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
void updatea(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr)
ta[v] = new_val;
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
updatea(v * 2, tl, tm, pos, new_val);
else
updatea(v * 2 + 1, tm + 1, tr, pos, new_val);
ta[v] = ta[v * 2] + ta[v * 2 + 1];
}
}
int sumb(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return tb[v];
int tm = (tl + tr) / 2;
return sumb(v * 2, tl, tm, l, min(r, tm)) +
sumb(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
void updateb(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr)
tb[v] = new_val;
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
updateb(v * 2, tl, tm, pos, new_val);
else
updateb(v * 2 + 1, tm + 1, tr, pos, new_val);
tb[v] = tb[v * 2] + tb[v * 2 + 1];
}
}
int mass[10000000] = {0};
int main() {
int k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
int d, add;
cin >> d >> add;
d--;
mass[d] += add;
updatea(1, 0, n - 1, d, min(mass[d], a));
updateb(1, 0, n - 1, d, min(mass[d], b));
} else {
int p = 0;
cin >> p;
p--;
cout << sumb(1, 0, n - 1, 0, p - 1) +
(p + k < n ? suma(1, 0, n - 1, p + k, n - 1) : 0)
<< endl;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.