text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Fenwik {
int n;
vector<int> bit;
int max_value;
void unite(int n_, int max_value_) {
n = n_;
max_value = max_value_;
bit.assign(n + 1, 0);
}
int get(int L, int R) { return get(R) - get(L); }
int get(int pos) {
int ans = 0;
for (; pos > 0; pos -= pos & -pos) {
ans += bit[pos];
}
return ans;
}
void add(int pos, int delta) {
int val = get(pos, pos + 1);
delta = min(delta, max_value - val);
for (pos++; pos <= n; pos += pos & -pos) {
bit[pos] += delta;
}
}
};
int n, k, a, b, q;
Fenwik bit_a, bit_b;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> k >> a >> b >> q;
bit_a.unite(n, a);
bit_b.unite(n, b);
while (q--) {
int type;
cin >> type;
if (type == 1) {
int pos, delta;
cin >> pos >> delta;
pos--;
bit_a.add(pos, delta);
bit_b.add(pos, delta);
} else {
int pos;
cin >> pos;
pos--;
int ans = 0;
ans += bit_b.get(0, pos);
ans += bit_a.get(pos + k, n);
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
static int y[2 * 200005];
static int y2[2 * 200005];
int orders[2 * 200005];
void update(int i, int x) {
for (; i < 200005; i += i & -i) y[i] += x;
}
void update2(int i, int x) {
for (; i < 200005; i += i & -i) y2[i] += x;
}
int prefixSum(int i) {
int sum = 0;
for (; i > 0; i -= i & -i) sum += y[i];
return sum;
}
int prefixSum2(int i) {
int sum = 0;
for (; i > 0; i -= i & -i) sum += y2[i];
return sum;
}
int query(int i, int j) { return prefixSum(j) - prefixSum(i - 1); }
int query2(int i, int j) { return prefixSum2(j) - prefixSum2(i - 1); }
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(0);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < 2 * 200005; i++) {
y[i] = 0;
y2[i] = 0;
orders[i] = 0;
}
for (int i = 0; i < q; i++) {
int j;
cin >> j;
if (j == 1) {
int ai, di;
cin >> di >> ai;
orders[di] += ai;
update(di, min(orders[di], b) - min((orders[di] - ai), b));
update2(di, min(orders[di], a) - min((orders[di] - ai), a));
}
if (j == 2) {
int p;
cin >> p;
cout << query(1, p - 1) + query2(p + k, n) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, o, p, q, re = 0;
long long res = 0;
int a[1000010], b[1000010];
bool chk[1000010];
struct fenwick {
long long t[1000010];
void add(int d, long long val) {
for (; d < 1000010; d += d & -d) {
t[d] += val;
}
}
long long view(int d) {
long long val = 0;
for (; d > 0; d -= d & -d) {
val += t[d];
}
return val;
}
} fea, feb;
int main() {
int i, j, k, l;
long long ll = 0, rr = 9223372036854775807LL, mid;
scanf("%d %d %d %d %d", &n, &m, &q, &p, &o);
for (i = 0; i < o; i++) {
scanf("%d", &j);
if (j == 1) {
scanf("%d %d", &j, &k);
fea.add(j, min(p - (fea.view(j) - fea.view(j - 1)), (long long)k));
feb.add(j, min(q - (feb.view(j) - feb.view(j - 1)), (long long)k));
} else {
scanf("%d", &j);
printf("%I64d\n", fea.view(j - 1) + feb.view(n) - feb.view(j + m - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 18);
int n, m;
int a, b;
struct node {
int suma, sumb, cnt_a, cnt_b;
node() {
suma = 0;
sumb = 0;
cnt_a = 0;
cnt_b = 0;
}
};
node temp, broken;
node merge(node l, node r) {
temp.cnt_a = l.cnt_a + r.cnt_a;
temp.cnt_b = l.cnt_b + r.cnt_b;
return temp;
}
struct segment_tree {
set<int> stb[4 * MAXN], sta[4 * MAXN];
node tr[4 * MAXN];
void init(int l, int r, int idx) {
if (l == r) {
tr[idx] = node();
return;
}
int mid = (l + r) >> 1;
init(l, mid, 2 * idx + 1);
init(mid + 1, r, 2 * idx + 2);
tr[idx] = merge(tr[2 * idx + 1], tr[2 * idx + 2]);
}
void update(int pos, int val, int l, int r, int idx) {
if (l > pos || r < pos) return;
if (l == r && l == pos) {
tr[idx].suma += val;
tr[idx].sumb += val;
tr[idx].cnt_a = min(a, tr[idx].suma);
tr[idx].cnt_b = min(b, tr[idx].suma);
return;
}
int mid = (l + r) >> 1;
update(pos, val, l, mid, 2 * idx + 1);
update(pos, val, mid + 1, r, 2 * idx + 2);
tr[idx] = merge(tr[2 * idx + 1], tr[2 * idx + 2]);
}
node query(int qL, int qR, int l, int r, int idx) {
if (l > qR || r < qL) return broken;
if (qL <= l && r <= qR) return tr[idx];
int mid = (l + r) >> 1;
return merge(query(qL, qR, l, mid, 2 * idx + 1),
query(qL, qR, mid + 1, r, 2 * idx + 2));
}
};
int q, k;
void read() { cin >> n >> k >> a >> b >> q; }
segment_tree t;
void solve() {
t.init(0, n, 0);
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
int idx, val;
cin >> idx >> val;
t.update(idx, val, 0, n, 0);
} else {
int p;
cin >> p;
cout << t.query(0, p - 1, 0, n, 0).cnt_b +
t.query(p + k, n, 0, n, 0).cnt_a
<< '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
long long f1[N], f2[N];
long long sz[N];
void add1(int x, int val) {
for (; x < N; x += x & -x) {
f1[x] += val;
}
}
long long get1(int x) {
long long sol = 0;
for (; x > 0; x -= x & -x) {
sol += f1[x];
}
return sol;
}
void add2(int x, int val) {
for (; x < N; x += x & -x) {
f2[x] += val;
}
}
long long get2(int x) {
long long sol = 0;
for (; x > 0; x -= x & -x) {
sol += f2[x];
}
return sol;
}
int main() {
int b, p, va, vb, q;
cin >> b >> p >> va >> vb >> q;
int u, d, n;
for (int i = 0; i < q; i++) {
cin >> u;
if (u == 1) {
cin >> d >> n;
if (sz[d] < vb) {
if (sz[d] + n > vb) {
add1(d, vb - sz[d]);
} else {
add1(d, n);
}
}
if (sz[d] < va) {
if (sz[d] + n > va) {
add2(d, va - sz[d]);
} else {
add2(d, n);
}
}
sz[d] += n;
} else {
cin >> d;
cout << get1(d - 1) + get2(b) - get2(d + p - 1) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int requests[200005];
int read(int i, int *tree) {
int ret = 0;
while (i > 0) {
ret += tree[i];
i -= (i & -i);
}
return ret;
}
void add(int i, int v, int *tree, int maxi) {
while (i <= maxi) {
tree[i] += v;
i += (i & -i);
}
}
int readS(int i, int *tree) {
int sum = tree[i];
if (i > 0) {
int z = i - (i & -i);
i--;
while (i != z) {
sum -= tree[i];
i -= (i & -i);
}
}
return sum;
}
int arva[200005], arvb[200005];
int main() {
int n, k, a, b, q, tmp, di, ai, pi;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int query = 0; query < q; query++) {
scanf("%d", &tmp);
if (tmp == 1) {
scanf("%d %d", &di, &ai);
add(di, min(ai, max(0, b - requests[di])), arvb, n + 1);
add(di, min(ai, max(0, a - requests[di])), arva, n + 1);
requests[di] += ai;
} else {
scanf("%d", &pi);
int ans = 0;
if (pi > 1) ans += read(pi - 1, arvb);
if (pi + k <= n) ans += read(n, arva) - read(pi + k - 1, arva);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tree1[200009], maxval, tree2[200009];
void update(int idx, int val, int type) {
while (idx <= maxval) {
if (type)
tree1[idx] += val;
else
tree2[idx] += val;
idx += (-idx & idx);
}
}
int read(int idx, int type) {
int sum = 0;
while (idx != 0) {
if (type)
sum += tree1[idx];
else
sum += tree2[idx];
idx -= (idx & -idx);
}
return sum;
}
int main() {
maxval = 200009;
int n, k, a, b, q, d, thimble, p, type;
cin >> n >> k >> a >> b >> q;
while (q--) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &d, &thimble);
int sum;
if (d == 1)
sum = read(d, 0);
else
sum = read(d, 0) - read(d - 1, 0);
update(d, min(b - sum, thimble), 0);
if (d == 1)
sum = read(d, 1);
else
sum = read(d, 1) - read(d - 1, 1);
update(d, min(a - sum, thimble), 1);
} else {
scanf("%d", &p);
int sum = 0;
if (p + k - 1 < n) {
sum = read(n, 1) - read(p + k - 1, 1);
}
if (p > 1) {
sum += read(p - 1, 0);
}
printf("%d\n", sum);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_D = 2000005;
int n, k, a, b, q;
int days[MAX_D];
int fenA[MAX_D];
int fenB[MAX_D];
int get(int *fen, int x) {
int sum = 0;
while (x > 0) {
sum += fen[x];
x = (x & (x + 1)) - 1;
}
return sum;
}
void update(int *fen, int i, int x) {
while (i <= n) {
fen[i] += x;
i = ((i + 1) | i);
}
}
int getLine(int *fen, int l, int r) {
if (l > r)
return 0;
else
return get(fen, r) - get(fen, l - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; ++i) {
int t;
cin >> t;
if (t == 1) {
int d, x;
cin >> d >> x;
int pred = days[d];
days[d] += x;
update(fenA, d, min(days[d], a) - min(pred, a));
update(fenB, d, min(days[d], b) - min(pred, b));
} else {
int p;
cin >> p;
cout << getLine(fenB, 1, p - 1) + getLine(fenA, p + k, n) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
const int maxn = 1e5 + 10;
const double eps = 1e-8;
const double PI = acos(-1.0);
long long sum[2 * maxn][2];
int now[2 * maxn];
void add(int x, int val1, int val2) {
while (x < (maxn << 1)) {
sum[x][0] += val1;
sum[x][1] += val2;
x += ((x) & (-x));
}
}
long long query(int t, int x) {
long long res = 0;
while (x > 0) {
res += sum[x][t];
x -= ((x) & (-x));
}
return res;
}
int main() {
int n, a, b, k, q;
cin >> n >> k >> b >> a >> q;
while (q--) {
int t, d, order;
cin >> t;
if (t == 1) {
cin >> d >> order;
int pre = now[d];
now[d] += order;
int or0 = min(now[d], a) - min(pre, a);
int or1 = min(now[d], b) - min(pre, b);
add(d, or0, or1);
} else {
cin >> d;
long long ans = query(0, d - 1) + query(1, n) - query(1, d + k - 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)1e9 + 10;
const long long int INFLL = (long long int)1e18 + 10;
const long double EPS = 1e-12;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
template <class T>
inline T sq(T a) {
return a * a;
}
long long int in() {
long long int x;
scanf("%lld", &x);
return x;
}
char yuyushiki[1000010];
string stin() {
scanf("%s", yuyushiki);
return yuyushiki;
}
struct BIT {
vector<long long int> bit;
int size;
void init(int n) {
size = 1;
while (size < n) size *= 2;
bit = vector<long long int>(size, 0);
}
void add(int k, long long int v) {
for (int i = k + 1; i <= size; i += i & -i) bit[i - 1] += v;
}
long long int sum(int k) {
long long int res = 0;
for (int i = k; i > 0; i -= i & -i) res += bit[i - 1];
return res;
}
long long int sum(int l, int r) { return sum(r) - sum(l); }
long long int get(int k) { return sum(k + 1) - sum(k); }
long long int update(int k, long long int x) { add(k, x - get(k)); }
};
BIT bita, bitb;
long long int n, k, a, b, q;
long long int c[200010];
int main() {
n = in();
k = in();
a = in();
b = in();
q = in();
bita.init(n);
bitb.init(n);
for (long long int qc = (0); qc < (long long int)(q); qc++) {
int t = in();
if (t == 1) {
long long int x = in() - 1;
long long int y = in();
c[x] += y;
bitb.update(x, min(b, c[x]));
bita.update(x, min(a, c[x]));
} else if (t == 2) {
long long int x = in() - 1;
long long int bb = bitb.sum(x);
long long int aa = bita.sum(n) - bita.sum(x + k);
long long int ans = aa + bb;
printf("%lld\n", ans);
} else {
assert(false);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class fenwick {
long long size;
vector<long long> integral;
vector<long long> kof;
public:
fenwick(int n) {
size = n;
integral.assign(size, 0);
kof.assign(size, 0);
}
void add_range(long long r, long long num) {
long long i;
if (r < 0) return;
for (i = r; i >= 0; i = (i & (i + 1)) - 1) {
kof[i] += num;
}
for (i = r | (r + 1); i < size; i |= i + 1) {
integral[i] += num * (r - (i & (i + 1)) + 1);
}
}
void add_range(long long l, long long r, long long num) {
add_range(r, num);
add_range(l - 1, -num);
}
long long sum(long long r) {
long long i;
if (r < 0) return 0;
long long res = 0;
for (i = r; i >= 0; i = (i & (i + 1)) - 1) {
res += integral[i] + kof[i] * (i - (i & (i + 1)) + 1);
}
for (i = r | (r + 1); i < size; i |= i + 1) {
res += kof[i] * (r - (i & (i + 1)) + 1);
}
return res;
}
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(4);
int n, k;
cin >> n >> k;
long long a, b;
cin >> a >> b;
int q;
cin >> q;
fenwick trbe(n + 100);
fenwick traf(n + 100);
for (int i = 0; i < q; ++i) {
int z;
cin >> z;
if (z == 1) {
long long d, t;
cin >> d >> t;
long long sm = trbe.sum(d, d);
long long dif = min(t + sm, b) - sm;
trbe.add_range(d, d, dif);
sm = traf.sum(d, d);
dif = min(t + sm, a) - sm;
traf.add_range(d, d, dif);
} else {
int p;
cin >> p;
cout << trbe.sum(0, p - 1) + traf.sum(p + k, n) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct segment_tree {
private:
int n, m;
vector<long long> tree;
void update_tree(int a, int b, int pos, int node, long long value) {
if (a > b || a > pos || b < pos) return;
if (a == b) {
tree[node] += value;
tree[node] = min(tree[node], (long long)(m));
return;
}
update_tree(a, (a + b) >> 1, pos, node << 1, value);
update_tree(((a + b) >> 1) + 1, b, pos, (node << 1) | 1, value);
tree[node] = tree[node << 1] + tree[(node << 1) | 1];
}
long long query_tree(int a, int b, int i, int j, int node) {
if (a > b || a > j || b < i) return 0;
if (a >= i && b <= j) return tree[node];
return query_tree(a, (a + b) >> 1, i, j, node << 1) +
query_tree(((a + b) >> 1) + 1, b, i, j, (node << 1) | 1);
}
public:
void initialize(int k, int p) {
n = k;
m = p;
tree.assign((n << 2) + 5, 0);
}
void update(int pos, long long value) { update_tree(1, n, pos, 1, value); }
long long query(int l, int r) { return query_tree(1, n, l, r, 1); }
};
int n, k, a, b, q;
segment_tree lt, rt;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int type, x, y;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
lt.initialize(n, b);
rt.initialize(n, a);
while (q--) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &x, &y);
lt.update(x, y);
rt.update(x, y);
} else {
scanf("%d", &x);
printf("%lld\n", lt.query(1, x - 1) + rt.query(x + k, n));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e10;
void scf(int &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
void scf(int &x, int &y) {
scf(x);
return scf(y);
}
void scf(int &x, int &y, int &z) {
scf(x);
scf(y);
return scf(z);
}
const int N = 2e5 + 100;
int n, k, a, b, q;
struct fenwick_tree {
int num[N];
void init() {
memset(num, 0, sizeof(num));
return;
}
inline int lowbit(int i) { return i & (-i); }
inline void update(int i, int x) {
for (; i <= q; i += lowbit(i)) num[i] += x;
return;
}
inline int query(int i) {
int ret = 0;
for (; i; i -= lowbit(i)) ret += num[i];
return ret;
}
} BIT;
struct query {
int op, a, b;
void in() {
scf(op, a);
if (op == 1) scf(b);
return;
}
} qry[N];
vector<int> upd[N], qst[N];
int has[N];
inline int MIN(int a, int b) { return a < b ? a : b; }
int main() {
scf(n, k);
scf(a, b, q);
for (int i = (1); i <= (q); i++) qry[i].in();
for (int i = (1); i <= (q); i++)
if (qry[i].op == 1)
upd[qry[i].a].push_back(i);
else
qst[qry[i].a].push_back(i);
for (int i = (1); i <= (n); i++) {
for (__typeof((qst[i]).begin()) j = (qst[i]).begin(); j != (qst[i]).end();
j++)
qry[*j].b = BIT.query(*j);
for (__typeof((upd[i]).begin()) j = (upd[i]).begin(); j != (upd[i]).end();
j++) {
int tmp = MIN(qry[*j].b, b - has[i]);
BIT.update(*j, tmp);
has[i] += tmp;
}
qst[i].clear();
}
BIT.init();
memset(has, 0, sizeof(has));
for (int i = (1); i <= (q); i++)
if (qry[i].op == 2) qst[qry[i].a + k - 1].push_back(i);
for (int i = (n); i >= (1); i--) {
for (__typeof((qst[i]).begin()) j = (qst[i]).begin(); j != (qst[i]).end();
j++)
qry[*j].b += BIT.query(*j);
for (__typeof((upd[i]).begin()) j = (upd[i]).begin(); j != (upd[i]).end();
j++) {
int tmp = MIN(qry[*j].b, a - has[i]);
BIT.update(*j, tmp);
has[i] += tmp;
}
qst[i].clear();
}
for (int i = (1); i <= (q); i++)
if (qry[i].op == 2) printf("%d\n", qry[i].b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long va[300300];
long long vb[300300];
int T[2][300300];
void update(int idx, int val, int r) {
idx++;
while (idx < 300300) {
T[r][idx] += val;
idx += idx & -idx;
}
}
long long query(int idx, int r) {
if (idx < 0) return 0;
int ret = 0;
idx++;
while (idx) {
ret += T[r][idx];
idx -= idx & -idx;
}
return ret;
}
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);
if (t == 1) {
int d, s;
scanf("%d%d", &d, &s), d--;
int old = va[d];
va[d] = min((long long)a, va[d] + s);
update(d, va[d] - old, 0);
old = vb[d];
vb[d] = min((long long)b, vb[d] + s);
update(d, vb[d] - old, 1);
} else {
int d;
scanf("%d", &d), d--;
long long ans = query(d - 1, 1) + query(n, 0) - query(d + k - 1, 0);
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q, query, c[200010], d, e, p, old[200010], rep[200010],
treeo[200010], treer[200010];
void updateo(int i, int x) {
for (int k = i; k <= n; k += (k & -k)) {
treeo[k] += (x - old[i]);
}
}
void updater(int i, int x) {
for (int k = i; k > 0; k -= (k & -k)) {
treer[k] += (x - rep[i]);
}
}
int queryo(int i) {
int ans = 0;
for (int k = i; k > 0; k -= (k & -k)) {
ans += treeo[k];
}
return ans;
}
int queryr(int i) {
int ans = 0;
for (int k = i; k <= n; k += (k & -k)) ans += treer[k];
return ans;
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &query);
if (query == 1) {
scanf("%d %d", &d, &e);
c[d] += e;
updateo(d, min(c[d], b));
updater(d, min(c[d], a));
old[d] = min(c[d], b);
rep[d] = min(c[d], a);
} else {
scanf("%d", &p);
printf("%d\n", queryo(p - 1) + queryr(p + k));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p) {
if (p == 0) return 1;
long long my = bigmod(b, p / 2);
my *= my;
my %= 1000000007;
if (p & 1) my *= b, my %= 1000000007;
return my;
}
int setb(int n, int pos) { return n = n | (1 << pos); }
int resb(int n, int pos) { return n = n & ~(1 << pos); }
bool checkb(int n, int pos) { return (bool)(n & (1 << pos)); }
int n, k, A, B, q;
int tree[4 * 200005][2], ara[200005];
inline int max(int a, int b) { return (a > b) ? a : b; }
inline int min(int a, int b) { return (a < b) ? a : b; }
void U(int ind, int b, int e, int i, int x) {
if (b == e) {
tree[ind][0] = min(x, B);
tree[ind][1] = min(x, A);
return;
}
int mid = (b + e) / 2, l = 2 * ind, r = l + 1;
if (i <= mid)
U(l, b, mid, i, x);
else
U(r, mid + 1, e, i, x);
tree[ind][0] = tree[l][0] + tree[r][0];
tree[ind][1] = tree[l][1] + tree[r][1];
}
int Q(int ind, int b, int e, int i, int j, int f) {
if (i > j) return 0;
if (b == i && e == j) return tree[ind][f];
int mid = (b + e) / 2, l = 2 * ind, r = l + 1;
return Q(l, b, mid, i, min(j, mid), f) +
Q(r, mid + 1, e, max(mid + 1, i), j, f);
}
int cnt, c;
int fun(int p) {
int l, r, ret = 0;
l = 1;
r = p - 1;
if (l <= r) ret += Q(1, 1, n, l, r, 0);
l = p + k;
r = n;
if (l <= r) ret += Q(1, 1, n, l, r, 1);
return ret;
}
int main() {
int i, j, ins, x, y;
scanf("%d %d", &n, &k);
scanf("%d %d", &A, &B);
scanf("%d", &q);
for (i = 1; i <= q; i++) {
c++;
scanf("%d", &ins);
if (ins == 1) {
scanf("%d %d", &x, &y);
ara[x] += y;
U(1, 1, n, x, ara[x]);
} else {
scanf("%d", &x);
int my = 0;
my = fun(x);
printf("%d", my);
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
int val[200100];
int ac[200100], bc[200100];
int sum(int *f, int x) {
int r = 0;
while (x) {
r += f[x];
x -= x & -x;
}
return r;
}
void upd(int *f, int x, int v) {
while (x < 200100) {
f[x] += v;
x += x & -x;
}
}
int main() {
int n, k, a, b, q;
int t, d, x;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d%d", &t, &d);
if (t == 1) {
scanf("%d", &x);
int av = (val[d] + x > a ? a : val[d] + x) - (val[d] > a ? a : val[d]);
int bv = (val[d] + x > b ? b : val[d] + x) - (val[d] > b ? b : val[d]);
val[d] += x;
upd(ac, d, av);
upd(bc, d, bv);
} else {
printf("%d\n", sum(ac, n) - sum(ac, d + k - 1) + sum(bc, d - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct less_key {
bool operator()(const pair<int64_t, int64_t>& p1,
const pair<int64_t, int64_t>& p2) {
return p1.first < p2.first ||
(p1.first == p2.first && p1.second > p2.second);
}
};
struct pair_hash {
std::size_t operator()(const pair<int64_t, int64_t>& k) const {
return static_cast<size_t>(k.first ^ k.second);
}
};
int64_t n, k, a, b, q;
int64_t sta[524300];
int64_t stb[524300];
int64_t N;
void build() {
N = 1;
while (N < n) {
N <<= 1;
}
return;
}
int64_t find(int64_t st[], int64_t i, int64_t tl, int64_t tr, int64_t l,
int64_t r) {
if (l > tr || r < tl) {
return 0;
}
if (l <= tl && tr <= r) {
return st[i];
}
int64_t t1 = find(st, i * 2, tl, (tl + tr) / 2, l, r);
int64_t t2 = find(st, i * 2 + 1, (tl + tr) / 2 + 1, tr, l, r);
return t1 + t2;
}
void update(int64_t st[], int64_t i, int64_t tl, int64_t tr, int64_t pos,
int64_t new_val) {
if (tl == tr)
st[i] = new_val;
else {
int64_t tm = (tl + tr) / 2;
if (pos <= tm) {
update(st, i * 2, tl, tm, pos, new_val);
} else {
update(st, i * 2 + 1, tm + 1, tr, pos, new_val);
}
st[i] = st[i * 2] + st[i * 2 + 1];
}
}
int64_t find(int64_t st[], int64_t l, int64_t r) {
if (r < l) {
return 0;
}
return find(st, 1, 0, N - 1, l, r);
}
void update(int64_t st[], int64_t pos, int64_t new_val) {
update(st, 1, 0, N - 1, pos, new_val);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> a >> b >> q;
build();
for (int64_t i = 0; i < q; i++) {
int64_t t;
cin >> t;
switch (t) {
case 1: {
int64_t d, x;
cin >> d >> x;
update(sta, d - 1, min(sta[N + d - 1] + x, a));
update(stb, d - 1, min(stb[N + d - 1] + x, b));
break;
}
case 2: {
int64_t p;
cin >> p;
int64_t t1 = find(stb, 0, p - 1 - 1);
int64_t t2 = find(sta, p - 1 + k, n - 1);
cout << t1 + t2 << endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tree {
int suma, sumb;
tree* l;
tree* r;
tree() : suma(0), sumb(0) {
l = NULL;
r = NULL;
}
};
int n, a, b, st2 = 1;
void init(tree*& t, int l = 1, int r = st2) {
if (l == r) return;
int mid = (l + r) / 2;
tree* lt = new tree();
tree* rt = new tree();
init(lt, l, mid);
init(rt, mid + 1, r);
t->l = lt;
t->r = rt;
}
void add(tree*& t, int v, int z, int l = 1, int r = st2) {
if ((l == v) && (r == v)) {
t->suma = min(t->suma + z, a);
t->sumb = min(t->sumb + z, b);
return;
}
int mid = (l + r) / 2;
if (v > mid) {
int sa, sb;
sa = t->r->suma;
sb = t->r->sumb;
add(t->r, v, z, mid + 1, r);
t->suma -= sa;
t->suma += t->r->suma;
t->sumb -= sb;
t->sumb += t->r->sumb;
} else {
int sa, sb;
sa = t->l->suma;
sb = t->l->sumb;
add(t->l, v, z, l, mid);
t->suma -= sa;
t->suma += t->l->suma;
t->sumb -= sb;
t->sumb += t->l->sumb;
}
}
int suma(tree* t, int l, int r, int lu = 1, int ru = st2) {
if (lu > r) return 0;
if (ru < l) return 0;
if ((l <= lu) && (r >= ru)) return t->suma;
int mid = (lu + ru) / 2;
int q1 = suma(t->l, l, r, lu, mid);
int q2 = suma(t->r, l, r, mid + 1, ru);
return (q1 + q2);
}
int sumb(tree* t, int l, int r, int lu = 1, int ru = st2) {
if (lu > r) return 0;
if (ru < l) return 0;
if ((l <= lu) && (r >= ru)) return t->sumb;
int mid = (lu + ru) / 2;
int q1 = sumb(t->l, l, r, lu, mid);
int q2 = sumb(t->r, l, r, mid + 1, ru);
return q1 + q2;
}
void dfs(tree* t, int l = 1, int r = st2) {
if (t == NULL) return;
cout << l << " " << r << " - " << t->suma << " " << t->sumb << "\n";
int mid = (l + r) / 2;
dfs(t->l, l, mid);
dfs(t->r, mid + 1, r);
}
int main() {
int k, q;
cin >> n >> k >> a >> b >> q;
while (st2 < n) st2 <<= 1;
tree* t = new tree();
init(t);
for (int i = 0; i < q; i++) {
int w;
cin >> w;
if (w == 1) {
int cnt, d;
cin >> d >> cnt;
add(t, d, cnt);
}
if (w == 2) {
int p;
cin >> p;
int pa = 0, pb = 0;
if (p > 1) pa = sumb(t, 1, p - 1);
if ((p + k - 1) <= n) pb = suma(t, p + k, n);
cout << pa + pb << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int stat[N << 2][2], cur[N];
int a, b;
void update(int s, int l, int r, int idx, int val) {
if (l > idx or r < idx) {
return;
}
if (l == r) {
cur[l] += val;
stat[s][0] = min(cur[l], a);
stat[s][1] = min(cur[l], b);
return;
}
int mid = (l + r) >> 1;
update((s << 1) + 1, l, mid, idx, val);
update((s << 1) + 2, mid + 1, r, idx, val);
stat[s][0] = stat[(s << 1) + 1][0] + stat[(s << 1) + 2][0];
stat[s][1] = stat[(s << 1) + 1][1] + stat[(s << 1) + 2][1];
}
int get(int s, int l, int r, int idx, int idy, int p) {
if (l > idy or r < idx) {
return 0;
}
if (l >= idx and r <= idy) {
return stat[s][p];
}
int mid = (l + r) >> 1;
return get((s << 1) + 1, l, mid, idx, idy, p) +
get((s << 1) + 2, mid + 1, r, idx, idy, p);
}
int main() {
int n, k, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
swap(a, b);
while (q--) {
int p;
scanf("%d", &p);
if (p == 1) {
int c, d;
scanf("%d %d", &c, &d);
update(0, 0, n - 1, c - 1, d);
} else {
int c;
scanf("%d", &c);
int res =
get(0, 0, n - 1, c + k - 1, n - 1, 1) + get(0, 0, n - 1, 0, c - 2, 0);
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct segment_tree {
long long seg[1000000];
void update(int n, int s, int e, int j, int v, int mx) {
if (s == e) {
seg[n] = min(mx * 1ll, seg[n] + v);
} else {
int mid = (s + e) / 2;
if (j <= mid)
update(n + n, s, mid, j, v, mx);
else
update(n + n + 1, mid + 1, e, j, v, mx);
seg[n] = seg[n + n] + seg[n + n + 1];
}
}
long long query(int n, int s, int e, int l, int r) {
if (s > e || s > r || l > e) return 0;
if (l <= s && e <= r) return seg[n];
int mid = (s + e) / 2;
return query(n + n, s, mid, l, r) + query(n + n + 1, mid + 1, e, l, r);
}
} seg[2];
int main() {
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 1; i <= q; i++) {
int t, x, y;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &x, &y);
seg[0].update(1, 1, n, x, y, b);
seg[1].update(1, 1, n, x, y, a);
} else {
scanf("%d", &x);
printf("%lld\n",
seg[0].query(1, 1, n, 1, x - 1) + seg[1].query(1, 1, n, x + k, n));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int res[500050] = {0};
int res1[500050] = {0};
int read(int idx) {
int sum = 0;
while (idx > 0) {
sum += res[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val, int N) {
while (idx <= N) {
res[idx] += val;
idx += (idx & -idx);
}
}
int read1(int idx) {
int sum = 0;
while (idx > 0) {
sum += res1[idx];
idx -= (idx & -idx);
}
return sum;
}
void update1(int idx, int val, int N) {
while (idx <= N) {
res1[idx] += val;
idx += (idx & -idx);
}
}
int main() {
int n, k, a, b, q;
int t;
int d, ai, p;
int check, check1;
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> t;
if (t == 1) {
cin >> d >> ai;
check = read(d) - read(d - 1);
check1 = read1(d) - read1(d - 1);
if (check < a) {
if (check + ai <= a) {
update(d, ai, n);
} else {
update(d, a - check, n);
}
}
if (check1 < b) {
if (check1 + ai <= b) {
update1(d, ai, n);
} else {
update1(d, b - check1, n);
}
}
}
if (t == 2) {
cin >> p;
int post = 0;
int pre = 0;
if (p + k - 1 < n) {
post = read(n) - read(p + k - 1);
}
pre = read1(p - 1);
cout << pre + post << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5;
void update(long long in, long long x, vector<long long> &sum, long long c) {
x = min(sum[in] + x, c) - sum[in];
while (in != 0) {
sum[in] += x;
in /= 2;
}
}
long long get_sum(long long l, long long r, vector<long long> &sum) {
if (r < l) {
return 0;
}
if (l == r) {
return sum[l];
}
if (l % 2 == 1) {
if (r % 2 == 0) {
return get_sum(l + 1, r - 1, sum) + sum[l] + sum[r];
} else {
return get_sum(l + 1, r, sum) + sum[l];
}
} else if (r % 2 == 0) {
return get_sum(l, r - 1, sum) + sum[r];
} else {
return get_sum(l / 2, r / 2, sum);
}
}
vector<long long> sum1(MAXN);
vector<long long> sum2(MAXN);
int main() {
ios_base::sync_with_stdio(0);
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
long long cur = 1;
while (cur < n) {
cur *= 2;
}
n = cur;
for (int i = 0; i < q; ++i) {
int ind;
cin >> ind;
if (ind == 1) {
long long c, d;
cin >> d >> c;
d += n - 1;
update(d, c, sum1, b);
update(d, c, sum2, a);
} else {
long long l;
cin >> l;
--l;
long long r = l + k;
l += n, r += n;
cout << get_sum(n, l - 1, sum1) + get_sum(r, n * 2 - 1, sum2) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T SQR(T x) {
return x * x;
}
template <typename T>
inline T MIN(T x, T y) {
return (x < y) ? x : y;
}
template <typename T>
inline T MAX(T x, T y) {
return (x > y) ? x : y;
}
template <typename T>
inline T ABS(T x) {
return (x > 0) ? x : -x;
}
template <typename T>
inline void UPDATE_MIN(T &x, T y) {
if (y < x) {
x = y;
}
}
template <typename T>
inline void UPDATE_MAX(T &x, T y) {
if (x < y) {
x = y;
}
}
template <typename T>
inline int ARGMAX(T cont) {
return max_element(cont.begin(), cont.end()) - cont.begin();
}
template <typename T>
inline int ARGMIN(T cont) {
return min_element(cont.begin(), cont.end()) - cont.begin();
}
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);
}
template <typename T, typename... Args>
inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (__typeof(n - 1) i = (0), __tmpvar__end87 = (n - 1); i < __tmpvar__end87;
i++)
s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
template <class T>
inline string TOSTR(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
inline int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
inline long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
inline long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
struct pairhash {
template <typename T, typename U>
std::size_t operator()(const std::pair<T, U> &x) const {
return std::hash<T>()(x.first) ^ std::hash<U>()(x.second);
}
};
template <typename K, typename V>
V GetWithDef(const std::unordered_map<K, V> &m, const K &key, const V &defval) {
auto it = m.find(key);
return (it == m.end()) ? defval : it->second;
}
template <typename K, typename V>
void SetDef(std::unordered_map<K, V> &m, const K &key, const V &defval) {
auto it = m.find(key);
if (it == m.end()) m[key] = defval;
}
const int MOD = 1000 * 1000 * 1000 + 7;
const double PI = 3.1415926535897932384626433832795l;
inline void addto(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline void subto(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
if (a >= MOD) a -= MOD;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
if (a >= MOD) a -= MOD;
return a;
}
inline void multo(int &a, int b) { a = (long long)a * b % MOD; }
inline int mul(int a, int b) { return (long long)a * b % MOD; }
inline int mulmod(int a, int b, int mod) { return (long long)a * b % mod; }
inline int powmod(int a, int e, int mod) {
int x;
for (x = 1; e > 0; e >>= 1) {
if (e & 1) x = mulmod(x, a, mod);
a = mulmod(a, a, mod);
}
return x;
}
inline int invmod(int a, int mod) { return powmod(a, mod - 2, mod); }
inline long long invmodLL(long long p) {
long long q = p;
for (long long a = p * p; a != 1; a *= a) q *= a;
return q;
}
int N, K, A, B, Q;
struct BIT {
vector<long long> bit;
int N;
void init(int N) {
this->N = N;
bit.assign(N + 1, 0);
}
void add_to_i(int x, long long val) {
for (; x <= N; x += x & -x) bit[x] += val;
}
void set_i(int x, long long val) { add_to_i(x, val - get(x)); }
long long sum_prefix(int x) {
long long sum = 0;
for (; x > 0; x -= x & -x) sum += bit[x];
return sum;
}
long long sum_range(int l, int r) {
if (l > r) return 0;
return sum_prefix(r) - sum_prefix(l - 1);
}
long long get(int i) { return sum_range(i, i); }
};
BIT limb;
BIT lima;
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &N, &K);
scanf("%d%d%d", &A, &B, &Q);
lima.init(N);
limb.init(N);
for (__typeof(Q) i = (0), __tmpvar__end246 = (Q); i < __tmpvar__end246; i++) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int d, a;
scanf("%d%d", &d, &a);
lima.add_to_i(d, a);
if (lima.get(d) > A) lima.set_i(d, A);
limb.add_to_i(d, a);
if (limb.get(d) > B) limb.set_i(d, B);
} else {
assert(typ == 2);
int p;
scanf("%d", &p);
long long ans = 0;
if (p > 1) ans += limb.sum_prefix(p - 1);
if (p + K <= N) ans += lima.sum_range(p + K, N);
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200333;
int orders[2][MAX_N + 123];
int f[2][MAX_N + 123];
void add(const int& d, int x, const int& value) {
while (x < MAX_N) {
f[d][x] += value;
x |= x + 1;
}
}
int getSum(const int& d, int x) {
int res = 0;
while (x > 0) {
res += f[d][x];
x = (x & (x + 1)) - 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int mx[2];
int n, k, q;
cin >> n >> k >> mx[1] >> mx[0] >> q;
for (int i = 1; i <= q; i++) {
int t;
cin >> t;
if (t == 1) {
int day, amount;
cin >> day >> amount;
for (int j = 0; j < 2; j++) {
int newVal = min(orders[j][day] + amount, mx[j]);
add(j, day, newVal - orders[j][day]);
orders[j][day] = newVal;
}
} else {
int l, r;
cin >> l;
r = l + k - 1;
int ans = getSum(1, n) - getSum(1, r);
ans += getSum(0, l - 1);
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 2 * 1e5 + 1e3;
int n;
int res;
int a, b, d, k, p, q, ai, pcase;
int v1[1 + NMAX];
int v2[1 + NMAX];
int ap[1 + NMAX];
int bp[1 + NMAX];
void update(int i, int v, int bit[]) {
for (; i <= n; i += i & (-i)) bit[i] += v;
}
int query(int i, int bit[]) {
int res;
for (res = 0; i > 0; i -= i & (-i)) res += bit[i];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a >> b >> q;
for (int test = 1; test <= q; test++) {
cin >> pcase;
if (pcase == 1) {
cin >> d >> ai;
update(d, min(a - ap[d], ai), v1);
ap[d] += min(a - ap[d], ai);
update(d, min(b - bp[d], ai), v2);
bp[d] += min(b - bp[d], ai);
} else {
cin >> p;
res = query(p - 1, v2) + query(n, v1) - query(p + k - 1, v1);
cout << res << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, k, a, b, q;
struct T {
int L, R;
int sum[3];
} dat[maxn << 2];
void pushUp(int root) {
for (int i = 0; i < 3; i++)
dat[root].sum[i] = dat[root << 1].sum[i] + dat[root << 1 | 1].sum[i];
}
void update(int pos, int val, int root) {
if (dat[root].L == dat[root].R) {
int add = dat[root].sum[2] + val;
dat[root].sum[0] = min(b, add);
dat[root].sum[1] = min(a, add);
dat[root].sum[2] = add;
return;
}
int m = (dat[root].L + dat[root].R) >> 1;
if (pos <= m)
update(pos, val, root << 1);
else
update(pos, val, root << 1 | 1);
pushUp(root);
}
int query(int a, int b, int root, int flag) {
if (a > b) return 0;
if (a == dat[root].L && dat[root].R == b) return dat[root].sum[flag];
int m = (dat[root].L + dat[root].R) >> 1;
if (b <= m)
return query(a, b, root << 1, flag);
else if (a > m)
return query(a, b, root << 1 | 1, flag);
else
return query(a, m, root << 1, flag) + query(m + 1, b, root << 1 | 1, flag);
}
void build(int root, int l, int r) {
dat[root].L = l;
dat[root].R = r;
for (int i = 0; i < 3; i++) dat[root].sum[i] = 0;
if (l == r) return;
int m = (l + r) >> 1;
build(root << 1, l, m);
build(root << 1 | 1, m + 1, r);
}
int main() {
while (~scanf("%d%d%d%d%d", &n, &k, &a, &b, &q)) {
build(1, 1, n);
while (q--) {
int cmd;
scanf("%d", &cmd);
if (cmd == 1) {
int day, cnt;
scanf("%d%d", &day, &cnt);
update(day, cnt, 1);
} else {
int from;
scanf("%d", &from);
int ans = query(1, from - 1, 1, 0) + query(from + k, n, 1, 1);
printf("%d\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int TSIZE = 200005;
long long atree[TSIZE + 1];
long long btree[TSIZE + 1];
long long query(int p, long long *tree) {
long long ret = 0;
for (; p > 0; p -= p & -p) {
ret += tree[p];
}
return ret;
}
void add(int p, long long val, long long *tree) {
for (; p <= TSIZE; p += p & -p) {
tree[p] += val;
}
}
long long orders[200005];
int main() {
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int c, d;
scanf("%d%d", &c, &d);
long long before = orders[c];
orders[c] += d;
if (before < a) {
long long inc = min<long long>(orders[c], a) - before;
add(c, inc, atree);
}
if (before < b) {
long long inc = min<long long>(orders[c], b) - before;
add(c, inc, btree);
}
} else {
int c;
scanf("%d", &c);
printf("%lld\n",
query(c - 1, btree) + query(n, atree) - query(c + k - 1, atree));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int sum1[200005], sum2[200005], n, a1[200005], a2[200005];
void u1(int idx, int x) {
while (idx <= n) {
sum1[idx] += x;
idx += idx & (-idx);
}
return;
}
int qu1(int idx) {
int ret = 0;
while (idx > 0) {
ret += sum1[idx];
idx -= idx & (-idx);
}
return ret;
}
void u2(int idx, int x) {
while (idx <= n) {
sum2[idx] += x;
idx += idx & (-idx);
}
return;
}
int qu2(int idx) {
int ret = 0;
while (idx > 0) {
ret += sum2[idx];
idx -= idx & (-idx);
}
return ret;
}
int main() {
int i, j, k, l, m, q, a, b, tot = 0, idx, x, ans;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (i = 1; i <= q; i++) {
scanf("%d", &l);
if (l == 1) {
scanf("%d %d", &idx, &x);
if (a1[idx] + x > b) {
u1(idx, b - a1[idx]);
} else
u1(idx, x);
a1[idx] = min(a1[idx] + x, b);
if (a2[idx] + x > a) {
u2(idx, a - a2[idx]);
} else
u2(idx, x);
a2[idx] = min(a2[idx] + x, a);
}
if (l == 2) {
scanf("%d", &idx);
ans = qu1(idx - 1);
j = idx + k - 1;
ans += qu2(n) - qu2(j);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 262144;
long long A, B;
int n, k, q;
long long ta[M];
long long Da[2 * M];
long long Db[2 * M];
void insert(int x, long long ww) {
ta[x] += ww;
Da[x + M] = min(ta[x], A);
Db[x + M] = min(ta[x], B);
x += M;
x /= 2;
while (x > 0) {
Da[x] = Da[2 * x] + Da[2 * x + 1];
Db[x] = Db[2 * x] + Db[2 * x + 1];
x /= 2;
}
}
long long querya(int a, int b) {
a += M;
b += M;
long long res = Da[a];
if (a != b) res += Da[b];
while (a / 2 != b / 2) {
if (a % 2 == 0) res += Da[a + 1];
if (b % 2 == 1) res += Da[b - 1];
a /= 2;
b /= 2;
}
return res;
}
long long queryb(int a, int b) {
a += M;
b += M;
long long res = Db[a];
if (a != b) res += Db[b];
while (a / 2 != b / 2) {
if (a % 2 == 0) res += Db[a + 1];
if (b % 2 == 1) res += Db[b - 1];
a /= 2;
b /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> A >> B >> q;
while (q--) {
int md;
cin >> md;
if (md == 1) {
int x, ww;
cin >> x >> ww;
insert(x, ww);
} else {
int x;
cin >> x;
long long res = 0;
if (x > 1) res += queryb(1, x - 1);
if (x + k - 1 < n) res += querya(x + k, n);
cout << res << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
long long BIT[2][N];
inline long long getPrefix(int i, int z) {
++i;
long long ret = 0;
while (i) ret += BIT[z][i], i -= i & -i;
return ret;
}
inline void add(int i, long long v, int z) {
++i;
while (i < N) BIT[z][i] += v, i += i & -i;
}
inline long long getRange(int l, int r, int z) {
return getPrefix(r, z) - getPrefix(l - 1, z);
}
long long arr[N], brr[N], a, b, n, k, q;
int main() {
cin >> n >> k >> a >> b >> q;
for (int C = 0; C < q; ++C) {
long long type;
scanf("%lld", &type);
if (type == 1) {
long long d, c;
scanf("%lld", &d), scanf("%lld", &c);
add(d, min(c, a - arr[d]), 0);
arr[d] = min(a, arr[d] + c);
add(d, min(c, b - brr[d]), 1);
brr[d] = min(b, brr[d] + c);
}
if (type == 2) {
long long p;
scanf("%lld", &p);
printf("%lld\n", getRange(1, p - 1, 1) + getRange(p + k, n, 0));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infLL = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 200000 + 5;
int n, k, A, B, q;
int a[maxn], b[maxn];
int c[2][maxn];
void update(int o, int i, int v) {
for (; i <= n; i += i & -i) c[o][i] += v;
}
int query(int o, int i) {
int ret = 0;
for (; i; i -= i & -i) ret += c[o][i];
return ret;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &A, &B, &q);
while (q--) {
int op, i, d;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &i, &d);
if (a[i] + d < A)
update(0, i, d), a[i] += d;
else
update(0, i, A - a[i]), a[i] = A;
if (b[i] + d < B)
update(1, i, d), b[i] += d;
else
update(1, i, B - b[i]), b[i] = B;
} else {
scanf("%d", &i);
printf("%d\n", query(0, n) - query(0, i + k - 1) + query(1, i - 1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long n, i, j, a, b, t, k, q, d, x, p;
struct ab {
long a, b;
} A[600005];
void up(long nod, long a, long b) {
A[nod].a += a;
A[nod].b += b;
if (nod != 1) up(nod / 2, a, b);
}
long querry(long nod, long a, long b, long st, long dr, long val) {
long mij = (a + b) / 2;
if (st > dr) return 0;
if (st <= a && dr >= b) {
if (val == 1)
return A[nod].b;
else
return A[nod].a;
}
if (st > mij) return querry(nod * 2 + 1, mij + 1, b, st, dr, val);
if (dr < mij) return querry(nod * 2, a, mij, st, dr, val);
return querry(nod * 2, a, mij, st, mij, val) +
querry(nod * 2 + 1, mij + 1, b, mij + 1, dr, val);
}
int main() {
cin >> n >> k >> a >> b;
cin >> q;
p = 1;
while (p < n) p = p << 1;
for (i = 1; i <= q; i++) {
cin >> t;
if (t == 1) {
cin >> d >> x;
if (min(x + A[p + d - 1].a, a) - A[p + d - 1].a > 0 ||
min(x + A[p + d - 1].b, b) - A[p + d - 1].b > 0) {
up(p + d - 1, min(x + A[p + d - 1].a, a) - A[p + d - 1].a,
min(x + A[p + d - 1].b, b) - A[p + d - 1].b);
}
} else {
cin >> d;
cout << querry(1, 1, p, 1, d - 1, 1) + querry(1, 1, p, d + k, n, 2)
<< '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vec = vector<T>;
template <typename Iter>
ostream& _IterOutput_(ostream& o, Iter b, Iter e, const string ss = "",
const string se = "") {
o << ss;
for (auto it = b; it != e; it++) o << (it == b ? "" : ", ") << *it;
return o << se;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& o, pair<T1, T2>& pair) {
return o << "(" << pair.first << ", " << pair.second << ")";
}
template <typename T>
ostream& operator<<(ostream& o, const vector<T>& vec) {
return _IterOutput_(o, begin(vec), end(vec), "[", "]");
}
template <typename T>
ostream& operator<<(ostream& o, const set<T>& st) {
return _IterOutput_(o, begin(st), end(st), "{", "}");
}
template <typename T, size_t N>
ostream& operator<<(ostream& o, const array<T, N>& arr) {
return _IterOutput_(o, begin(arr), end(arr), "|", "|");
}
inline long long lb(long long a) { return a & (-a); }
const long long MX = 333333;
struct BIT {
long long v[MX];
void add(long long a, long long vl) {
a += 2;
while (a < MX) {
v[a] += vl;
a += lb(a);
}
}
long long qry(long long a) {
a += 2;
long long res = 0;
while (a) {
res += v[a];
a -= lb(a);
}
return res;
}
long long qp(long long a) { return qry(a) - qry(a - 1); }
} bit1, bit2;
int32_t main() {
long long N, K, A, B, Q;
cin >> N >> K >> A >> B >> Q;
for (long long _t125 = 0; _t125 < (Q); (_t125)++) {
long long t;
cin >> t;
if (t == 1) {
long long a, b;
cin >> a >> b;
long long z1 = bit1.qp(a);
long long d1 = min(z1 + b, B) - z1;
bit1.add(a, d1);
long long z2 = bit2.qp(a);
long long d2 = min(z2 + b, A) - z2;
bit2.add(a, d2);
} else {
long long q;
cin >> q;
;
cout << bit1.qry(q - 1) + bit2.qry(N + 1) - bit2.qry(q + K - 1) << endl;
}
}
do {
ios_base::sync_with_stdio(0);
cin.tie(0);
} while (0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> segta;
vector<long long> segtb;
void build(vector<long long> &seg) {
for (int i = 0; i < 4 * 100005; i++) {
seg.push_back(0);
}
}
long long query(vector<long long> &segt, int id, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return segt[id];
if (qr < l || r < ql) return 0;
int m = (r + l) / 2;
return query(segt, 2 * id, l, m, ql, qr) +
query(segt, 2 * id + 1, m + 1, r, ql, qr);
}
void update(vector<long long> &segt, int id, int l, int r, int p, long long v,
int lim) {
if (l == r) {
segt[id] += v;
if (segt[id] > lim) segt[id] = lim;
} else {
int m = (r + l) / 2;
if (p <= m)
update(segt, 2 * id, l, m, p, v, lim);
else
update(segt, 2 * id + 1, m + 1, r, p, v, lim);
segt[id] = segt[id * 2] + segt[id * 2 + 1];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
build(segta);
build(segtb);
int n, k, a, b, q, c, x, y;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
cin >> c;
if (c == 1) {
cin >> x >> y;
update(segta, 1, 1, n, x, y, a);
update(segtb, 1, 1, n, x, y, b);
} else {
cin >> x;
long long l = query(segtb, 1, 1, n, 1, x - 1);
long long r = query(segta, 1, 1, n, x + k, n);
long long ans = 0LL;
if (x > 1) ans += l;
if (x + k - 1 < n) ans += r;
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
const int INF = 1e9 + 7;
const int MAXN = int(2e5 + 7);
int n, a, b, k, q, t[5 * MAXN], t2[5 * MAXN];
int sum1(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return t[v];
int tm = (tl + tr) / 2;
return sum1(v * 2, tl, tm, l, min(r, tm)) +
sum1(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
int sum2(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return t2[v];
int tm = (tl + tr) / 2;
return sum2(v * 2, tl, tm, l, min(r, tm)) +
sum2(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
void update1(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr)
t[v] = min(a, t[v] + new_val);
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update1(v * 2, tl, tm, pos, new_val);
else
update1(v * 2 + 1, tm + 1, tr, pos, new_val);
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
void update2(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr)
t2[v] = min(b, t2[v] + new_val);
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update2(v * 2, tl, tm, pos, new_val);
else
update2(v * 2 + 1, tm + 1, tr, pos, new_val);
t2[v] = t2[v * 2] + t2[v * 2 + 1];
}
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0, ty, d, a, p; i < q; i++) {
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &d, &a);
update1(1, 1, n, d, a);
update2(1, 1, n, d, a);
} else {
scanf("%d", &p);
long long res = 0;
if (p != 1) res += sum2(1, 1, n, 1, p - 1);
res += sum1(1, 1, n, p + k, n);
printf("%I64d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
int n, k, q;
unsigned int a, b;
unsigned int query(unsigned int BIT[], int day) {
unsigned int result = 0;
for (int i = day; i > 0; i -= (i & -i)) {
result += BIT[i];
}
return result;
}
unsigned int query(unsigned int BIT[], int left, int right) {
unsigned int l = query(BIT, left - 1);
unsigned int r = query(BIT, right);
return query(BIT, right) - query(BIT, left - 1);
}
void update(unsigned int BIT[], unsigned int rate, int day, int orders) {
int value = rate - query(BIT, day, day);
if (value > 0) {
orders = std::min(orders, value);
for (int i = day; i < n + 1; i += (i & -i)) {
BIT[i] += orders;
}
}
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
unsigned int BIT_A[n + 1];
unsigned int BIT_B[n + 1];
memset(&BIT_A, (0), sizeof(BIT_A));
memset(&BIT_B, (0), sizeof(BIT_B));
for (int _ = 0; (_) < int(q); (_)++) {
int op;
scanf(" %d", &op);
int day, orders;
if (op == 1) {
scanf(" %d", &day);
scanf(" %d", &orders);
update(BIT_A, a, day, orders);
update(BIT_B, b, day, orders);
if (false) printf("BIT A\n");
for (int i = 1; i < n + 1; i++)
if (false) printf("%d\n", BIT_A[i]);
if (false) printf("BIT B\n");
for (int i = 1; i < n + 1; i++)
if (false) printf("%d\n", BIT_B[i]);
} else if (op == 2) {
scanf(" %d", &day);
unsigned int q_a = query(BIT_A, day + k, n);
unsigned int q_b = query(BIT_B, 1, day - 1);
if (false) printf("query on BIT A: %d\nquery on BIT B: %d\n", q_a, q_b);
unsigned int result = q_a + q_b;
printf("%d\n", result);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T const& Max(T const& a, T const& b) {
return a > b ? a : b;
}
template <typename T>
T const& Min(T const& a, T const& b) {
return a < b ? a : b;
}
template <typename T>
inline T gcd(T a, T b) {
return (b ? gcd(b, a % b) : a);
}
template <typename T>
T sqaa(T a) {
return a * a;
}
long long int Pow(long long int a, long long int pow) {
long long int ret = 1;
for (; pow; pow >>= 1) {
if (pow & 1) ret = (ret * a);
a = (a * a);
}
return ret;
}
long long int modPow(long long int a, long long int pow, long long int mod) {
long long int ret = 1;
for (; pow; pow >>= 1) {
if (pow & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
}
return ret;
}
long long int modINV(long long int a, long long int M) {
return modPow(a, M - 2, M);
}
const int mx = 2e5 + 10;
int tra[mx * 3];
int trb[mx * 3];
int ar[mx];
int n, k, a, b, q, ai, kk, d;
void upda(int node, int s, int e, int idx, int val) {
if (s == e) {
tra[node] = min(val, b);
return;
}
int mid = (s + e) / 2;
int left = node * 2;
int right = node * 2 + 1;
if (idx <= mid)
upda(left, s, mid, idx, val);
else
upda(right, mid + 1, e, idx, val);
tra[node] = tra[left] + tra[right];
}
void updb(int node, int s, int e, int idx, int val) {
if (s == e) {
trb[node] = min(val, a);
return;
}
int mid = (s + e) / 2;
int left = node * 2;
int right = node * 2 + 1;
if (idx <= mid)
updb(left, s, mid, idx, val);
else
updb(right, mid + 1, e, idx, val);
trb[node] = trb[left] + trb[right];
}
int qua(int node, int s, int e, int i, int j) {
if (i > e || j < s) return 0;
if (s >= i && e <= j) {
return tra[node];
}
int mid = (s + e) / 2;
int left = node * 2;
int right = node * 2 + 1;
return qua(left, s, mid, i, j) + qua(right, mid + 1, e, i, j);
}
int qub(int node, int s, int e, int i, int j) {
if (i > e || j < s) return 0;
if (s >= i && e <= j) {
return trb[node];
}
int mid = (s + e) / 2;
int left = node * 2;
int right = node * 2 + 1;
return qub(left, s, mid, i, j) + qub(right, mid + 1, e, i, j);
}
int main() {
long long int ri, lef;
while (~scanf("%d %d %d %d %d", &n, &k, &a, &b, &q)) {
memset(tra, 0, sizeof(tra));
memset(trb, 0, sizeof(trb));
memset(ar, 0, sizeof(ar));
for (int i = 0; i < q; i++) {
scanf("%d %d", &d, &ai);
if (d == 1) {
scanf("%d", &kk);
ar[ai] += kk;
upda(1, 1, n, ai, ar[ai]);
updb(1, 1, n, ai, ar[ai]);
} else {
ri = 0, lef = 0;
if (ai > 1) {
ri = qua(1, 1, n, 1, ai - 1);
}
if (ai + k <= n) {
lef = qub(1, 1, n, ai + k, n);
}
printf("%lld\n", lef + ri);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 21474846495;
void read(int &x) {
char ch;
bool flag = 0;
for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || 1);
ch = getchar())
;
for (x = 0; isdigit(ch); x = (x << 1) + (x << 3) + ch - 48, ch = getchar())
;
x *= 1 - 2 * flag;
}
int s1[maxn], s2[maxn];
long long sum[maxn][2];
int n, k, a, b, q;
int lob(int x) { return x & (-x); }
void update(int x, int val, int cnt) {
while (x <= n) {
sum[x][cnt] += val;
x += lob(x);
}
}
int query(int id, int cnt) {
int ans = 0;
while (id) {
ans += sum[id][cnt];
id -= lob(id);
}
return ans;
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int c;
cin >> c;
if (c == 1) {
int d, cost;
cin >> d >> cost;
int t1 = a - s1[d];
if (t1 >= cost)
s1[d] += cost, t1 = cost;
else
s1[d] = a;
update(d, t1, 0);
int t2 = b - s2[d];
if (t2 >= cost)
s2[d] += cost, t2 = cost;
else
s2[d] = b;
update(d, t2, 1);
} else {
int d;
cin >> d;
int ans = query(d - 1, 1) + query(n, 0) - query(min(d + k - 1, n), 0);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int total[200005], tree[3][4 * 200005];
void update(long long int id, long long int node, long long int a,
long long int b, long long int ind, long long int val) {
if (a > b || a > ind || b < ind) return;
if (a == b) {
tree[id][node] = val;
return;
}
long long int mid = (a + b) / 2;
if (ind <= mid)
update(id, 2 * node, a, mid, ind, val);
else
update(id, 2 * node + 1, mid + 1, b, ind, val);
tree[id][node] = tree[id][2 * node] + tree[id][2 * node + 1];
}
long long int query(long long int id, long long int node, long long int a,
long long int b, long long int l, long long int r) {
if (a > b || a > r || b < l) return 0;
if (a >= l && b <= r) return tree[id][node];
long long int mid = (a + b) / 2;
return query(id, 2 * node, a, mid, l, r) +
query(id, 2 * node + 1, mid + 1, b, l, r);
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
long long int i, j, n, q, A, B, ind, val, type, ans, k;
cin >> n >> k >> A >> B >> q;
while (q--) {
cin >> type;
if (type == 1) {
cin >> ind >> val;
total[ind] += val;
update(1, 1, 1, n, ind, min(total[ind], B));
update(2, 1, 1, n, ind, min(total[ind], A));
} else {
cin >> ind;
ans = query(1, 1, 1, n, 1, ind - 1);
ans += query(2, 1, 1, n, ind + k, n);
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const bool print = false;
const int MAXN = 400111;
long long orders[MAXN];
long long tr1[MAXN];
long long tr2[MAXN];
void dod1(int pos1, long long val) {
pos1++;
for (; pos1 < MAXN; pos1 += (pos1 & (-pos1))) tr1[pos1] += val;
}
void dod2(int pos, long long val) {
pos++;
for (; pos > 0; pos -= (pos & (-pos))) tr2[pos] += val;
}
long long pyta1(int pos) {
pos++;
long long wyn = 0;
for (; pos > 0; pos -= (pos & (-pos))) wyn += tr1[pos];
return wyn;
}
long long pyta2(int pos1) {
pos1++;
long long wyn = 0;
for (; pos1 < MAXN; pos1 += (pos1 & (-pos1))) wyn += tr2[pos1];
return wyn;
}
int main() {
int n, k;
long long a, b;
int q;
cin >> n >> k >> a >> b >> q;
while (q--) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int d, aa;
scanf("%d%d", &d, &aa);
dod1(d, -min(b, orders[d]));
dod2(d, -min(a, orders[d]));
orders[d] += aa;
dod1(d, min(b, orders[d]));
dod2(d, min(a, orders[d]));
} else {
int p;
scanf("%d", &p);
long long wyn = pyta1(p - 1) + pyta2(p + k);
printf("%I64d\n", wyn);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double EPS = 1e-7;
int INF = 1000000000;
long long INFLL = 1000000000000000000LL;
int mx[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
int my[8] = {0, 0, -1, 1, -1, 1, -1, 1};
vector<pair<int, pair<int, int>>> que;
int MGC = 400;
int cntPre[200005];
int cntSuf[200005];
int ori[200005];
int main() {
int n, k, A, B, q;
scanf("%d%d%d%d%d", &n, &k, &A, &B, &q);
for (int(a) = (0); (a) <= (q - 1); (a)++) {
int i, j, k;
scanf("%d", &i);
if (i == 1) {
scanf("%d%d", &j, &k);
que.push_back(make_pair(i, make_pair(j, k)));
} else {
scanf("%d", &j);
que.push_back(make_pair(i, make_pair(j, 0)));
}
}
vector<pair<int, int>> upd;
for (int(a) = (0); (a) <= (q - 1); (a)++) {
int t = que[a].first;
if (t == 1) {
int d = que[a].second.first;
int x = que[a].second.second;
upd.push_back(make_pair(d, x));
} else {
int p = que[a].second.first;
unordered_map<int, int> um;
long long ans = cntPre[p - 1];
if (p + k <= n) ans += cntSuf[p + k];
for (int(a) = (0); (a) <= ((int)upd.size() - 1); (a)++) {
um[upd[a].first] += upd[a].second;
}
for (__typeof((um).begin()) it = (um).begin(); it != (um).end(); it++) {
int idx = (*it).first;
int val = (*it).second;
if (idx < p) {
ans -= min(ori[idx], B);
ans += min(ori[idx] + val, B);
} else if (idx >= p + k) {
ans -= min(ori[idx], A);
ans += min(ori[idx] + val, A);
}
}
printf("%lld\n", ans);
}
if (a % MGC == 0) {
for (int(a) = (0); (a) <= ((int)upd.size() - 1); (a)++) {
ori[upd[a].first] += upd[a].second;
}
upd.clear();
for (int(a) = (1); (a) <= (n); (a)++) {
cntPre[a] = cntPre[a - 1] + min(ori[a], B);
}
for (int(a) = (n); (a) >= (1); (a)--) {
cntSuf[a] = cntSuf[a + 1] + min(ori[a], A);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class segment_tree {
public:
long long l, r, sum, t, tm, limit;
segment_tree *left, *right;
segment_tree(long long _l, long long _r, long long _limit) {
l = _l;
r = _r;
limit = _limit;
tm = (l + r) / 2;
left = NULL;
right = NULL;
sum = 0;
t = 0;
}
void add() {
if (left == NULL) left = new segment_tree(l, tm, limit);
if (right == NULL) right = new segment_tree(tm + 1, r, limit);
}
void push() {
left->t += t;
right->t += t;
sum += (r - l + 1) * t;
t = 0;
}
void update_cell(long long pos, long long val) {
if (l == r) {
sum = min(sum + val, limit);
} else {
add();
if (pos <= tm)
left->update_cell(pos, val);
else
right->update_cell(pos, val);
sum = left->sum + right->sum;
}
}
long long get_sum(long long _l, long long _r) {
if (_l > _r) return 0;
add();
push();
if (l == _l && r == _r) return sum;
return left->get_sum(_l, min(tm, _r)) + right->get_sum(max(_l, tm + 1), _r);
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
long long n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
segment_tree *t1 = new segment_tree(0, n - 1, b);
segment_tree *t2 = new segment_tree(0, n - 1, a);
for (int it = 0; it < q; it++) {
int z;
cin >> z;
if (z == 1) {
int d, a;
cin >> d >> a;
d--;
t1->update_cell(d, a);
t2->update_cell(d, a);
} else {
int p;
cin >> p;
p--;
int v1 = 0, v2 = 0;
if (p) {
v1 = t1->get_sum(0, p - 1);
}
if (p + k <= n - 1) {
v2 = t2->get_sum(p + k, n - 1);
}
cout << v1 + v2 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200000;
int n, k, a, b, q, day[MAX_N], fta[MAX_N], ftb[MAX_N];
void init() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 0; i < n; i++) {
day[i] = 0;
fta[i] = 0;
ftb[i] = 0;
}
}
void changeItem(int d, int k) {
for (int i = d; i < n; i |= i + 1) {
fta[i] += max(0, min(a, day[d] + k) - day[d]);
ftb[i] += max(0, min(b, day[d] + k) - day[d]);
}
day[d] += k;
}
int getAns(int p) {
int ans = 0;
for (int i = p - 1; i >= 0; i &= i + 1, i--) {
ans += ftb[i];
}
for (int i = n - 1; i >= 0; i &= i + 1, i--) {
ans += fta[i];
}
for (int i = p + k - 1; i >= 0; i &= i + 1, i--) {
ans -= fta[i];
}
return ans;
}
void handleRequest() {
int t, d, a, p;
scanf("%d", &t);
switch (t) {
case 1: {
scanf("%d %d", &d, &a);
changeItem(--d, a);
break;
}
case 2: {
scanf("%d", &p);
printf("%d\n", getAns(--p));
break;
}
}
}
void handleRequests() {
for (int i = 0; i < q; i++) {
handleRequest();
}
}
int main() {
init();
handleRequests();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 19;
int n, k, a, b, q;
struct Seg {
int upper;
int a[MAXN];
int t[MAXN];
void update(int i, int dex) {
for (; i <= n; i += i & -i) {
t[i] += dex;
}
}
int query(int i) {
int ret = 0;
for (; i > 0; i -= i & -i) {
ret += t[i];
}
return ret;
}
void import(int i, int dex) {
int next = min(upper, a[i] + dex);
update(i, next - a[i]);
a[i] = next;
}
};
Seg ls, rs;
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
ls.upper = b;
rs.upper = a;
for (int i = 0; i < q; i++) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int d, dex;
scanf("%d%d", &d, &dex);
ls.import(d, dex);
rs.import(n - d + 1, dex);
} else {
int p;
scanf("%d", &p);
int ans = ls.query(p - 1);
ans += rs.query(n - k - p + 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> s1;
vector<int> s2;
int a, b;
int print(vector<int> s) {
int n = s.size();
for (int i = 0; i < n; i++) cout << s[i] << " ";
cout << endl;
return 0;
}
int make1(int d, int ai) {
s1[d] = min(b, s1[d] + ai);
d = (d - 1) / 2;
while (d > 0) {
s1[d] = s1[d * 2 + 1] + s1[d * 2 + 2];
d = (d - 1) / 2;
}
s2[d] = s2[d * 2 + 1] + s2[d * 2 + 2];
return 0;
}
int make2(int d, int ai) {
s2[d] = min(a, s2[d] + ai);
d = (d - 1) / 2;
while (d > 0) {
s2[d] = s2[d * 2 + 1] + s2[d * 2 + 2];
d = (d - 1) / 2;
}
s2[d] = s2[d * 2 + 1] + s2[d * 2 + 2];
return 0;
}
int get1(int v, int vl, int vr, int l, int r) {
if (r < l) return 0;
if (vr < l || vl > r) return 0;
if (vl >= l && vr <= r) return s1[v];
int vm = (vl + vr) / 2;
if (vm < l) return get1(v * 2 + 2, vm + 1, vr, l, r);
if (vm > r) return get1(v * 2 + 1, vl, vm, l, r);
if (vm >= l && vr <= r) return s1[v * 2 + 2] + get1(v * 2 + 1, vl, vm, l, r);
if (vm >= l && vr > r)
return get1(v * 2 + 2, vm + 1, vr, l, r) + get1(v * 2 + 1, vl, vm, l, r);
if (vm <= r && vl >= l)
return s1[v * 2 + 1] + get1(v * 2 + 1, vm + 1, vr, l, r);
if (vm <= r && vl < l)
return get1(v * 2 + 2, vm + 1, vr, l, r) + get1(v * 2 + 1, vl, vm, l, r);
}
int get2(int v, int vl, int vr, int l, int r) {
if (vr < l || vl > r) return 0;
if (vl >= l && vr <= r) return s2[v];
int vm = (vl + vr) / 2;
if (vm < l) return get2(v * 2 + 2, vm + 1, vr, l, r);
if (vm > r) return get2(v * 2 + 1, vl, vm, l, r);
if (vm >= l && vr <= r) return s2[v * 2 + 2] + get2(v * 2 + 1, vl, vm, l, r);
if (vm >= l && vr > r)
return get2(v * 2 + 2, vm + 1, vr, l, r) + get2(v * 2 + 1, vl, vm, l, r);
if (vm <= r && vl >= l)
return s2[v * 2 + 1] + get2(v * 2 + 1, vm + 1, vr, l, r);
if (vm <= r && vl < l)
return get2(v * 2 + 2, vm + 1, vr, l, r) + get2(v * 2 + 1, vl, vm, l, r);
}
int main() {
int n, k, q;
cin >> n >> k >> a >> b >> q;
int x = 1;
while (x < n) x *= 2;
x *= 2;
s1.resize(x - 1);
s2.resize(x - 1);
for (int i = 0; i < x - 1; i++) {
s1[i] = 0;
s2[i] = 0;
}
for (int i = 0; i < q; i++) {
int y;
cin >> y;
if (y == 1) {
int d, ai;
cin >> d;
cin >> ai;
make1(x / 2 - 2 + d, ai);
make2(x / 2 - 2 + d, ai);
} else {
int p;
cin >> p;
get2(0, 0, x / 2 - 1, p + k - 1, x / 2 - 1);
cout << get1(0, 0, x / 2 - 1, 0, p - 2) +
get2(0, 0, x / 2 - 1, p + k - 1, x / 2 - 1)
<< endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
struct Fenwick {
int sum(int i) {
if (i < 1 || i > n) return 0;
int s = 0;
while (i > 0) s += tree[i], i -= i & -i;
return s;
}
void add(int i, int x) {
int cur = sum(i) - sum(i - 1);
if (cur + x > lim) x = lim - cur;
while (i <= n) tree[i] += x, i += i & -i;
}
int tree[223456], lim;
};
Fenwick pre, suf;
int main() {
cin >> n >> k >> a >> b >> q;
pre.lim = b;
suf.lim = a;
for (int i(0); i < q; i++) {
int t;
cin >> t;
;
if (t == 1) {
int di;
cin >> di;
int ai;
cin >> ai;
;
pre.add(di, ai);
suf.add(n - di + 1, ai);
} else {
int pi;
cin >> pi;
int tot = 0, en = pi + k;
tot += pre.sum(pi - 1);
tot += suf.sum(n - en + 1);
cout << tot << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
int N, K, A, B, Q, a[200001], TA[524288], TB[524288];
void P(int x) {
int p = 1, l = 1, r = N;
while (l < r) {
int m = l + r >> 1;
if (x <= m)
r = m, p <<= 1;
else
l = m + 1, p = p << 1 | 1;
}
TA[p] = std::min(a[x], A);
TB[p] = std::min(a[x], B);
while (p > 1) {
p >>= 1;
TA[p] = TA[p << 1] + TA[p << 1 | 1];
TB[p] = TB[p << 1] + TB[p << 1 | 1];
}
}
int G(int *T, int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return T[p];
int m = l + r >> 1;
if (R <= m) return G(T, p << 1, l, m, L, R);
if (L > m) return G(T, p << 1 | 1, m + 1, r, L, R);
return G(T, p << 1, l, m, L, R) + G(T, p << 1 | 1, m + 1, r, L, R);
}
int main() {
scanf("%d%d%d%d%d", &N, &K, &A, &B, &Q);
while (Q--) {
int ty, u, w;
scanf("%d%d", &ty, &u);
if (ty == 1) {
scanf("%d", &w);
a[u] += w;
P(u);
} else
printf("%d\n", (u > 1 ? G(TB, 1, 1, N, 1, u - 1) : 0) +
(u > N - K ? 0 : G(TA, 1, 1, N, u + K, N)));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 200005;
int n, k, a, b, q, sol;
int A[4 * NMAX], B[4 * NMAX], v[NMAX];
void update(int node, int l, int r, int poz, int val) {
if (l == r) {
v[l] += val;
A[node] = min(v[l], a);
B[node] = min(v[l], b);
return;
}
int m = (l + r) / 2;
int ls = 2 * node;
int rs = 2 * node + 1;
if (poz <= m)
update(ls, l, m, poz, val);
else
update(rs, m + 1, r, poz, val);
A[node] = A[ls] + A[rs];
B[node] = B[ls] + B[rs];
}
int queryA(int node, int l, int r, int x, int y) {
if (l >= x && r <= y) {
return A[node];
}
int m = (l + r) / 2;
int ls = 2 * node;
int rs = 2 * node + 1;
int X = 0;
int Y = 0;
if (x <= m) X = queryA(ls, l, m, x, y);
if (y > m) Y = queryA(rs, m + 1, r, x, y);
return X + Y;
}
int queryB(int node, int l, int r, int x, int y) {
if (l >= x && r <= y) {
return B[node];
}
int m = (l + r) / 2;
int ls = 2 * node;
int rs = 2 * node + 1;
int X = 0;
int Y = 0;
if (x <= m) X = queryB(ls, l, m, x, y);
if (y > m) Y = queryB(rs, m + 1, r, x, y);
return X + Y;
}
int main() {
cin.sync_with_stdio(false);
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
swap(a, b);
for (; q; q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int d, x;
scanf("%d%d", &d, &x);
update(1, 1, n, d, x);
} else {
int x;
scanf("%d", &x);
sol = 0;
if (x - 1 >= 1) sol += queryA(1, 1, n, 1, x - 1);
if (x + k <= n) sol += queryB(1, 1, n, x + k, n);
printf("%d\n", sol);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 * 100 + 10, L = 20;
int n, k, a, b, q;
int minn[N * L], maxx[N * L], ar[N];
void add(int ind, int be, int en, int p, int val) {
if (be + 1 == en) {
minn[ind] = min(b, minn[ind] + val);
maxx[ind] = min(a, maxx[ind] + val);
return;
}
int mid = (be + en) / 2;
if (p < mid)
add(ind * 2, be, mid, p, val);
else
add(ind * 2 + 1, mid, en, p, val);
minn[ind] = minn[ind * 2] + minn[ind * 2 + 1];
maxx[ind] = maxx[ind * 2] + maxx[ind * 2 + 1];
return;
}
int get(int ind, int be, int en, int l, int r, bool f) {
if (l <= be && r >= en) {
if (f) return maxx[ind];
return minn[ind];
}
int mid = (be + en) / 2, ret = 0;
if (l < mid) ret += get(ind * 2, be, mid, l, r, f);
if (r > mid) ret += get(ind * 2 + 1, mid, en, l, r, f);
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int x, l, r;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
cin >> x >> l;
if (x == 1) {
cin >> r;
l--;
add(1, 0, n, l, r);
} else {
int t = 0;
if (l - 1 > 0) t += get(1, 0, n, 0, l - 1, 0);
if (l + k - 1 < n) t += get(1, 0, n, l + k - 1, n, 1);
cout << t << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 10;
int fta[mx], ftb[mx];
int cura[mx], curb[mx];
void upd(int i, int v, int ft[]) {
for (++i; i < mx; i += (i & -i)) ft[i] += v;
}
int qry(int i, int ft[]) {
int a = 0;
for (++i; i > 0; i -= (i & -i)) a += ft[i];
return a;
}
int rng(int l, int r, int ft[]) {
if (l > r) return 0;
return qry(r, ft) - qry(l - 1, ft);
}
int main() {
int n, k, a, b, q, op;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
while (q--) {
scanf("%d", &op);
if (op == 1) {
int di, ai;
scanf("%d %d", &di, &ai);
int olda = cura[di], oldb = curb[di];
cura[di] = min(a, olda + ai);
curb[di] = min(b, oldb + ai);
upd(di, cura[di] - olda, fta);
upd(di, curb[di] - oldb, ftb);
} else {
int l;
scanf("%d", &l);
int r = l + k - 1;
int ans = rng(0, l - 1, ftb) + rng(r + 1, n, fta);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tree[200009][2], n, orders[200009], cur[200009][2], a, b, k;
void update(int idx, int val, int ch) {
while (idx <= n) {
tree[idx][ch] += val;
idx += (idx & -idx);
}
}
int sum(int idx, int ch) {
int val = 0;
while (idx > 0) {
val += tree[idx][ch];
idx -= (idx & -idx);
}
return val;
}
int main() {
int q;
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &q);
for (int i = int(0); i <= int(q - 1); i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, ai;
scanf("%d", &d);
scanf("%d", &ai);
update(d, -1 * cur[d][0], 0);
update(d, -1 * cur[d][1], 1);
orders[d] += ai;
cur[d][0] = min(orders[d], b);
cur[d][1] = min(orders[d], a);
update(d, cur[d][0], 0);
update(d, cur[d][1], 1);
} else {
int p;
scanf("%d", &p);
int ans = sum(n, 1) - sum(p + k - 1, 1) + sum(p - 1, 0);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class BIT {
public:
int n, lim, bit[1000001];
BIT(int ninp, int limp) {
n = ninp;
lim = limp;
for (int i = 0; i <= n; i++) bit[i] = 0;
}
void increaseBit(int index, int newVal) {
int sums = getSum(index, index);
if (newVal + sums > lim) newVal = lim - sums;
index++;
while (index <= n) {
bit[index] += newVal;
index = index + index - (index & (index - 1));
}
}
void updateBIT(int index, int newVal) {
increaseBit(index, newVal - bit[index + 1]);
}
void constructBIT(int a[]) {
for (int i = 0; i < n; i++) increaseBit(i, a[i]);
}
int getSum(int right) {
if (right < 0) return 0;
int sum = 0;
right++;
while (right > 0) {
sum += bit[right];
right = right & (right - 1);
}
return sum;
}
int getSum(int left, int right) { return (getSum(right) - getSum(left - 1)); }
};
int main() {
int i, n, k, a, b, q, t, pos, inc, ans;
cin >> n >> k >> a >> b >> q;
BIT abit(n, a), bbit(n, b);
while (q--) {
cin >> t;
if (t == 1) {
cin >> pos >> inc;
pos--;
abit.increaseBit(pos, inc);
bbit.increaseBit(pos, inc);
} else {
cin >> pos;
pos--, ans = 0;
if (pos > 0) ans = bbit.getSum(0, pos - 1);
if (pos + k < n) ans += abit.getSum(pos + k, n - 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const modul = 1;
long long mod_sum(long long x, long long y) { return (x + y) % modul; }
long long mod_sub(long long x, long long y) {
if (x > y) {
return (x - y) % modul;
} else {
return (modul + x - y) % modul;
}
}
long long mod_mpl(long long x, long long y) { return (x * y) % modul; }
void set_precise(int n) {
cout << fixed;
cout << setprecision(n);
}
int const N = 200000;
class Tree {
private:
long long tree[N * 4];
int start;
int size;
void rebuild(int id) {
if (id < 1) {
return;
}
tree[id] = tree[id * 2] + tree[id * 2 + 1];
rebuild(id / 2);
};
long long count_sum(int cur, int left, int right, int cur_l, int cur_r) {
int mid = (cur_l + cur_r) / 2;
if ((left == cur_l) && (right == cur_r)) {
return tree[cur];
}
if (right <= mid) {
return count_sum(cur * 2, left, right, cur_l, mid);
} else if (left >= mid + 1) {
return count_sum(cur * 2 + 1, left, right, mid + 1, cur_r);
} else {
return count_sum(cur * 2, left, mid, cur_l, mid) +
count_sum(cur * 2 + 1, mid + 1, right, mid + 1, cur_r);
}
};
public:
Tree() {
size = 0;
start = 0;
};
void initialize(int n) {
int cur = 1;
int sum = 0;
while (cur < n) {
sum += cur;
cur *= 2;
}
start = sum + 1;
size = cur;
for (int i = 1; i < start + cur; ++i) {
tree[i] = 0;
}
}
Tree(int n) {
int cur = 1;
int sum = 0;
while (cur < n) {
sum += cur;
cur *= 2;
}
start = sum + 1;
size = cur;
for (int i = 1; i < start + cur; ++i) {
tree[i] = 0;
}
};
void update(int pos, long long q, long long no_more) {
long long cur = tree[start + pos];
cur += q;
if (cur > no_more) {
cur = no_more;
}
tree[start + pos] = cur;
rebuild((start + pos) / 2);
};
long long get_sum(int left, int right) {
if (left > right) {
return 0;
}
return count_sum(1, left, right, 0, size - 1);
}
};
Tree max_a;
Tree max_b;
int main() {
int n, k;
long long a, b;
int q;
cin >> n >> k >> a >> b >> q;
max_a.initialize(n);
max_b.initialize(n);
for (int i = 0; i < q; ++i) {
int type;
cin >> type;
if (type == 1) {
int day;
long long x;
cin >> day >> x;
--day;
max_a.update(day, x, a);
max_b.update(day, x, b);
} else {
int p;
cin >> p;
--p;
long long ans = 0;
ans += max_b.get_sum(0, p - 1);
ans += max_a.get_sum(p + k, n - 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class BIT {
private:
vector<int> ft;
public:
BIT(int n) { ft.assign(n + 1, 0); }
int rsq(int b) {
int sum = 0;
for (; b; b -= b & (-b)) sum += ft[b];
return sum;
}
void update(int k, int v) {
for (; k < ft.size(); k += k & (-k)) ft[k] += v;
}
};
int main() {
int n, k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
BIT ft1(n);
BIT ft2(n);
vector<int> dias(n + 1, 0);
while (q--) {
int opr;
scanf("%d", &opr);
if (opr == 1) {
int dia, v;
scanf("%d %d", &dia, &v);
int dif;
if (dias[dia] < b) {
if (dias[dia] + v > b) {
dif = b - dias[dia];
} else {
dif = v;
}
ft1.update(dia, dif);
}
if (dias[dia] < a) {
if (dias[dia] + v > a) {
dif = a - dias[dia];
} else {
dif = v;
}
ft2.update(dia, dif);
}
dias[dia] += v;
} else {
int rep;
scanf("%d", &rep);
int resp = 0;
resp = ft1.rsq(rep - 1);
resp += ft2.rsq(n) - ft2.rsq(rep + k - 1);
printf("%d\n", resp);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tree {
vector<long long> a;
int N;
tree(int size) {
for (N = 1; N < size; N <<= 1)
;
a.resize(N << 1);
}
void update(int ind, long long val, long long bound) {
ind += N;
a[ind] = min(val + a[ind], bound);
for (int k = ind >> 1; k >= 1; k >>= 1) {
a[k] = a[k << 1] + a[k << 1 | 1];
}
}
int query(int v, int L, int R, int l, int r) {
if (l > r) {
return 0;
}
if (l == L && r == R) {
return a[v];
}
int mid = (L + R) / 2;
return query(v << 1, L, mid, l, min(r, mid)) +
query(v << 1 | 1, mid + 1, R, max(l, mid + 1), r);
}
int call_query(int l, int r) { return query(1, 0, N - 1, l, r); }
void print() {
for (int k = 0; k < (int)a.size(); k++) {
cout << a[k] << " ";
}
cout << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
int n, m, a, b, q;
cin >> n >> m >> a >> b >> q;
tree A(n), B(n);
for (int k = 0; k < q; k++) {
int mode;
cin >> mode;
if (mode == 1) {
int day, ai;
cin >> day >> ai;
A.update(day - 1, ai, a);
B.update(day - 1, ai, b);
} else {
int x;
cin >> x;
cout << B.call_query(0, x - 2) + A.call_query(x + m - 1, n - 1) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sign(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dxKn[] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dyKn[] = {1, 2, 2, 1, -1, -2, -2, -1};
const int N = int(5e5) + 9;
const int M = int(3e3) + 9;
const int LOGN = 22;
const int SQN = 350;
const int MOD = int(1e9) + 7;
const int INF = 1e9 + 100;
const long long INF64 = 2e18;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
int n, k, a, b, q;
int ta[N * 4], tb[N * 4];
void upd(int v, int l, int r, int pos, int d) {
if (l == r) {
assert(pos == l);
ta[v] = min(ta[v] + d, a);
tb[v] = min(tb[v] + d, b);
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
upd(v * 2 + 1, l, mid, pos, d);
else
upd(v * 2 + 2, mid + 1, r, pos, d);
ta[v] = ta[v * 2 + 1] + ta[v * 2 + 2];
tb[v] = tb[v * 2 + 1] + tb[v * 2 + 2];
}
int geta(int v, int l, int r, int L, int R) {
if (l == L && r == R) return ta[v];
int mid = (l + r) / 2;
if (R <= mid)
return geta(v * 2 + 1, l, mid, L, R);
else if (L > mid)
return geta(v * 2 + 2, mid + 1, r, L, R);
else
return geta(v * 2 + 1, l, mid, L, mid) +
geta(v * 2 + 2, mid + 1, r, mid + 1, R);
}
int getb(int v, int l, int r, int L, int R) {
if (l == L && r == R) return tb[v];
int mid = (l + r) / 2;
if (R <= mid)
return getb(v * 2 + 1, l, mid, L, R);
else if (L > mid)
return getb(v * 2 + 2, mid + 1, r, L, R);
else
return getb(v * 2 + 1, l, mid, L, mid) +
getb(v * 2 + 2, mid + 1, r, mid + 1, R);
}
void solve() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 0; i < (int)(q); ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int pos, d;
scanf("%d %d", &pos, &d);
--pos;
upd(0, 0, n - 1, pos, d);
} else {
int pos;
scanf("%d", &pos);
--pos;
int res = 0;
if (pos) res += getb(0, 0, n - 1, 0, pos - 1);
if (pos + k < n) res += geta(0, 0, n - 1, pos + k, n - 1);
printf("%d\n", res);
}
}
}
int main() {
srand(time(NULL));
cout << setprecision(10) << fixed;
cerr << setprecision(10) << fixed;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 * 1000 + 85 - 69;
long long int seg1[maxn * 4], seg2[maxn * 4];
long long int cnt[maxn];
long long int n, k, a, b, q;
void modify(long long int *seg, int idx, long long int val, int l = 0,
int r = n, int id = 1) {
if (idx >= r or idx < l) return;
if (r - l == 1) {
seg[id] = val;
return;
}
int mid = (l + r) >> 1;
modify(seg, idx, val, l, mid, id * 2 + 0);
modify(seg, idx, val, mid, r, id * 2 + 1);
seg[id] = seg[id * 2 + 0] + seg[id * 2 + 1];
return;
}
long long int get(long long int *seg, int st, int en, int l = 0, int r = n,
int id = 1) {
if (st >= r or en <= l) return 0;
if (st <= l and r <= en) return seg[id];
int mid = (l + r) >> 1;
return get(seg, st, en, l, mid, id * 2 + 0) +
get(seg, st, en, mid, r, id * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> a >> b >> q;
while (q--) {
int ty, fi, se;
cin >> ty >> fi;
fi--;
if (ty == 1) {
cin >> se;
cnt[fi] += se;
modify(seg1, fi, min(b, cnt[fi]));
modify(seg2, fi, min(a, cnt[fi]));
} else
cout << get(seg1, 0, fi) + get(seg2, fi + k, n) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const long double PI = acos(-1.0);
using namespace std;
struct Po {
long long Old, New;
Po(long long O = 0, long long E = 0) : Old(O), New(E) {}
inline Po operator+(const Po& x) {
Po tem;
tem.Old = this->Old + x.Old;
tem.New = this->New + x.New;
return tem;
}
inline Po& operator+=(const Po& x) {
this->New += x.New;
this->Old += x.Old;
return *this;
}
};
Po T[8 * (200000 + 100)];
long long tt[(200000 + 100)];
int E;
int a, b;
void init(int n) {
E = 1;
while (E <= n + 1) E <<= 1;
memset(T, 0, sizeof(T));
memset(tt, 0, sizeof(tt));
}
void Push_up(int t) { T[t] = T[t << 1] + T[t << 1 | 1]; }
void aP(int k1, int k2) {
k1 += E;
if (k2 < a)
T[k1].New = k2;
else
T[k1].New = a;
if (k2 < b)
T[k1].Old = k2;
else
T[k1].Old = b;
for (k1 >>= 1; k1; k1 >>= 1) Push_up(k1);
}
long long query(int L, int R, int p) {
Po sum;
for (L += E - 1, R += E + 1; L ^ R ^ 1; L >>= 1, R >>= 1) {
if (~L & 1) sum += T[L ^ 1];
if (R & 1) sum += T[R ^ 1];
}
if (p == 1)
return sum.Old;
else
return sum.New;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, q;
cin >> n >> k >> a >> b >> q;
int i, p;
init(n);
for (i = 1; i <= q; i++) {
cin >> p;
if (p == 1) {
int k1, k2;
cin >> k1 >> k2;
tt[k1] += k2;
aP(k1, tt[k1]);
} else {
int k1;
cin >> k1;
long long sum = query(1, k1 - 1, 1) + query(k1 + k, n, 2);
cout << sum << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct segment_tree {
int n;
vector<T> a;
function<T(T, T)> append;
T unit;
template <typename F>
segment_tree(int a_n, T a_unit, F a_append) {
n = pow(2, ceil(log2(a_n)));
a.resize(2 * n - 1, a_unit);
unit = a_unit;
append = a_append;
}
void point_update(int i, T z) {
a[i + n - 1] = z;
for (i = (i + n) / 2; i > 0; i /= 2) {
a[i - 1] = append(a[2 * i - 1], a[2 * i]);
}
}
T range_concat(int l, int r) { return range_concat(0, 0, n, l, r); }
T range_concat(int i, int il, int ir, int l, int r) {
if (l <= il and ir <= r) {
return a[i];
} else if (ir <= l or r <= il) {
return unit;
} else {
return append(range_concat(2 * i + 1, il, (il + ir) / 2, l, r),
range_concat(2 * i + 2, (il + ir) / 2, ir, l, r));
}
}
};
int main() {
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
segment_tree<long long> ta(n, 0, [&](int x, int y) { return x + y; });
segment_tree<long long> tb(n, 0, [&](int x, int y) { return x + y; });
for (int query = 0; (query) < (q); ++(query)) {
int type;
cin >> type;
if (type == 1) {
int d, c;
cin >> d >> c;
--d;
ta.point_update(d, min<long long>(a, ta.range_concat(d, d + 1) + c));
tb.point_update(d, min<long long>(b, tb.range_concat(d, d + 1) + c));
} else if (type == 2) {
int p;
cin >> p;
--p;
cout << tb.range_concat(0, p) + ta.range_concat(min(p + k, n), n) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
long long n, k, t1[800800], t2[800800], q, d, x, p, a, b;
void update1(int v, int tl, int tr, int pos, long long x) {
if (tl == tr) {
t1[v] = min(t1[v] + x, a);
return;
}
int mid = (tl + tr) / 2;
if (pos <= mid)
update1(2 * v, tl, mid, pos, x);
else
update1(2 * v + 1, mid + 1, tr, pos, x);
t1[v] = t1[2 * v] + t1[2 * v + 1];
}
void update2(int v, int tl, int tr, int pos, long long x) {
if (tl == tr) {
t2[v] = min(t2[v] + x, b);
return;
}
int mid = (tl + tr) / 2;
if (pos <= mid)
update2(2 * v, tl, mid, pos, x);
else
update2(2 * v + 1, mid + 1, tr, pos, x);
t2[v] = t2[2 * v] + t2[2 * v + 1];
}
long long get1(int v, int tl, int tr, int l, int r) {
if (tl >= l && tr <= r) return t1[v];
if (tl > r || tr < l) return 0;
int mid = (tl + tr) / 2;
return get1(2 * v, tl, mid, l, r) + get1(2 * v + 1, mid + 1, tr, l, r);
}
long long get2(int v, int tl, int tr, int l, int r) {
if (tl >= l && tr <= r) return t2[v];
if (tl > r || tr < l) return 0;
int mid = (tl + tr) / 2;
return get2(2 * v, tl, mid, l, r) + get2(2 * v + 1, mid + 1, tr, l, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> b >> a >> q;
for (int i = 0; i < q; ++i) {
cin >> p;
if (p == 1) {
cin >> d >> x;
update1(1, 1, n, d, x);
update2(1, 1, n, d, x);
} else {
cin >> d;
cout << get1(1, 1, n, 1, d - 1) + get2(1, 1, n, d + k, n) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const long long MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long add(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a + b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long mul(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a * b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long pow_mod(long long a, long long b, long long m = MOD) {
long long res = 1LL;
a = a % m;
while (b) {
if (b & 1) res = mul(res, a, m);
b >>= 1;
a = mul(a, a, m);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 200000 + 5;
int n;
int q;
int k;
int a, b;
int ft[3][N];
void update(int id, int pos, int val) {
pos++;
while (pos <= n) {
ft[id][pos] += val;
pos += (-pos) & pos;
}
}
int getSum(int id, int pos) {
pos++;
int ans = 0;
while (pos > 0) {
ans += ft[id][pos];
pos &= pos - 1;
}
return ans;
}
int query(int id, int L, int R) {
if (L > R) return 0;
return getSum(id, R) - getSum(id, L - 1);
}
int main() {
scanf("%d %d", &(n), &(k));
scanf("%d %d", &(a), &(b));
scanf("%d", &(q));
int op;
int x, y;
while (q--) {
scanf("%d", &(op));
if (op == 1) {
scanf("%d %d", &(x), &(y));
x--;
int take = query(0, x, x);
update(0, x, max(0, min(y, b - take)));
take = query(1, x, x);
update(1, x, max(0, min(y, a - take)));
} else {
scanf("%d", &(x));
x--;
int ans = query(0, 0, x - 1) + query(1, x + k, n - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void update(int idx, long long *bit, int value) {
while (idx < 200001) {
bit[idx] += value;
idx += (idx & -idx);
}
}
long long query(int idx, long long *bit) {
long long sum = 0;
while (idx) {
sum += bit[idx];
idx -= (idx & -idx);
}
return sum;
}
long long qtd[200001];
long long bit1[200001], bit2[200001];
int main() {
int n, k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
swap(a, b);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int d, ai;
scanf("%d %d", &d, &ai);
long long aux = qtd[d];
if (qtd[d] < a) {
qtd[d] = min((long long)a, qtd[d] + ai);
update(d, bit1, qtd[d] - aux);
}
qtd[d] = aux;
if (qtd[d] < b) {
qtd[d] = min((long long)b, qtd[d] + ai);
update(d, bit2, qtd[d] - aux);
}
qtd[d] = aux + ai;
} else {
int d;
scanf("%d", &d);
long long ans = 0;
ans += query(d - 1, bit1);
ans += (query(n, bit2) - query(min(d + k - 1, n), bit2));
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline T gcd(T a, T b) {
return a % b ? gcd(b, a % b) : b;
}
using namespace std;
class ppp {
public:
long long val;
long long tree[4 * 200010];
void update(int node, int low, int hi, int i, long long value) {
if (low == hi) {
tree[node] = min(val, tree[node] + value);
return;
}
int mid = (low + hi) / 2;
int left = 2 * node;
int right = left + 1;
if (i <= mid)
update(left, low, mid, i, value);
else
update(right, mid + 1, hi, i, value);
tree[node] = tree[left] + tree[right];
}
long long query(int node, int low, int hi, int i, int j) {
if (i > hi || j < low) return 0;
if (low >= i && hi <= j) return tree[node];
int mid = (low + hi) / 2;
int left = 2 * node;
int right = left + 1;
int x = query(left, low, mid, i, j);
int y = query(right, mid + 1, hi, i, j);
return x + y;
}
} s1, s2;
int main() {
int n, k, a, b, q;
;
scanf("%d%d%d%d", &n, &k, &a, &b);
;
;
scanf("%d", &q);
;
s1.val = b;
s2.val = a;
while (q--) {
int x;
;
scanf("%d", &x);
;
if (x == 1) {
int p, q;
;
scanf("%d%d", &p, &q);
;
s1.update(1, 1, n, p, q);
s2.update(1, 1, n, p, q);
} else {
int p;
;
scanf("%d", &p);
;
long long ans;
if (p == 1)
ans = 0;
else
ans = s1.query(1, 1, n, 1, p - 1);
ans += s2.query(1, 1, n, p + k, n);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
struct {
int L, R;
int pl, pr;
int suma, sumb;
} T[2 * maxn];
int buildTree(int L, int R) {
static int sz = 1;
int cur = sz++;
T[cur].L = L;
T[cur].R = R;
if (L < R) {
T[cur].pl = buildTree(L, (L + R) / 2);
T[cur].pr = buildTree((L + R) / 2 + 1, R);
}
return cur;
}
int get(int L, int R, char c, int cur) {
if (L <= T[cur].L && R >= T[cur].R) {
if (c == 'a') return T[cur].suma;
return T[cur].sumb;
}
int ret = 0;
if (L <= T[T[cur].pl].R && T[T[cur].pl].L <= R)
ret += get(L, R, c, T[cur].pl);
if (L <= T[T[cur].pr].R && T[T[cur].pr].L <= R)
ret += get(L, R, c, T[cur].pr);
return ret;
}
int a, b;
void add(int i, int val, int cur) {
if (T[cur].L == T[cur].R) {
T[cur].suma += val;
T[cur].suma = min(a, T[cur].suma);
T[cur].sumb += val;
T[cur].sumb = min(b, T[cur].sumb);
return;
}
if (i <= T[T[cur].pl].R)
add(i, val, T[cur].pl);
else
add(i, val, T[cur].pr);
T[cur].suma = T[T[cur].pl].suma + T[T[cur].pr].suma;
T[cur].sumb = T[T[cur].pl].sumb + T[T[cur].pr].sumb;
}
int main() {
int n, k, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
buildTree(0, 200001);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int di, ai;
scanf("%d %d", &di, &ai);
add(di, ai, 1);
} else {
int p;
scanf("%d", &p);
int sum = get(0, p - 1, 'b', 1) + get(p + k, 200001, 'a', 1);
printf("%d\n", sum);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int oo = 0x7fffffff;
const int mod = 1000000007;
const int maxn = 1000007;
int a, b;
struct da {
int l, r;
int s[3];
int mid() { return (l + r) / 2; }
int len() { return (r - l + 1); }
void Clear() { s[0] = s[1] = s[2] = 0; }
void add(int num) {
num = s[2] + num;
s[0] = min(b, num);
s[1] = min(a, num);
s[2] = num;
}
} tree[maxn << 2];
void build(int l, int r, int rt) {
tree[rt].l = l;
tree[rt].r = r;
tree[rt].Clear();
if (l == r) return;
int mid = tree[rt].mid();
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
}
void update(int rt, int pos, int val) {
tree[rt].add(val);
if (tree[rt].l == tree[rt].r) return;
if (pos <= tree[rt].mid())
update(rt << 1, pos, val);
else
update(rt << 1 | 1, pos, val);
tree[rt].s[0] = tree[rt << 1].s[0] + tree[rt << 1 | 1].s[0];
tree[rt].s[1] = tree[rt << 1].s[1] + tree[rt << 1 | 1].s[1];
tree[rt].s[2] = tree[rt << 1].s[2] + tree[rt << 1 | 1].s[2];
}
int query(int l, int r, int op, int rt) {
if (l > r) return 0;
if (tree[rt].l == l && r == tree[rt].r) {
return tree[rt].s[op];
}
int mid = tree[rt].mid();
if (r <= mid)
return query(l, r, op, rt << 1);
else if (l > mid)
return query(l, r, op, rt << 1 | 1);
else {
return query(l, mid, op, rt << 1) + query(mid + 1, r, op, rt << 1 | 1);
}
}
int main() {
int n, k, q, i, op, u, v, ans;
while (scanf("%d %d %d %d %d", &n, &k, &a, &b, &q) != EOF) {
build(1, n, 1);
while (q--) {
scanf("%d %d", &op, &u);
if (op == 1) {
scanf("%d", &v);
update(1, u, v);
} else {
ans = query(1, u - 1, 0, 1) + query(u + k, n, 1, 1);
printf("%d\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 18;
long long A, B;
pair<long long, long long> operator+(pair<long long, long long> p1, int x) {
return pair<long long, long long>(min(A, p1.first + x),
min(B, p1.second + x));
}
pair<long long, long long> operator+(pair<long long, long long> p1,
pair<long long, long long> p2) {
return pair<long long, long long>(p1.first + p2.first, p1.second + p2.second);
}
pair<long long, long long> tree[2 * MAXN];
long long lazy[2 * MAXN];
void update(int x, long long v) {
x += MAXN;
tree[x] = tree[x] + v;
while (x /= 2) {
tree[x] = tree[2 * x] + tree[2 * x + 1];
}
}
pair<long long, long long> query(int a, int b, int cur = 1, int lt = 0,
int rt = MAXN) {
if (rt <= a || b <= lt) {
return pair<long long, long long>(0, 0);
}
if (a <= lt && rt <= b) {
return tree[cur];
}
int mid = (lt + rt) / 2;
return query(a, b, 2 * cur, lt, mid) + query(a, b, 2 * cur + 1, mid, rt);
}
int N, K, Q;
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d %d %lld %lld %d", &N, &K, &A, &B, &Q);
int qt, d, p;
long long a;
for (int qi = 0; qi < Q; qi++) {
scanf("%d", &qt);
if (qt == 1) {
scanf("%d %lld", &d, &a);
d--;
update(d, a);
} else {
scanf("%d", &p);
p--;
long long bef = query(0, p).second;
long long aft = query(p + K, N).first;
printf("%lld\n", bef + aft);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, k, a, b, q, N, wa[MAXN], wb[MAXN];
int BIT[MAXN];
void Change(int x, int tar) {
for (int i = x; i <= N; i += (i & (-i))) BIT[i] += tar;
}
int Query(int x) {
int res = 0;
for (int i = x; i; i ^= (i & (-i))) res += BIT[i];
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
N = n - k + 1;
while (q--) {
int op, d, c;
scanf("%d%d", &op, &d);
if (op == 1) scanf("%d", &c);
if (op == 1) {
int da, db;
da = min(a, wa[d] + c) - wa[d];
db = min(b, wb[d] + c) - wb[d];
wa[d] = min(a, wa[d] + c);
wb[d] = min(b, wb[d] + c);
if (d - k > 0) {
Change(1, da);
Change(d - k + 1, -da);
}
Change(d + 1, db);
} else
printf("%d\n", Query(d));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long n, k, a, b, q;
class SegTree {
public:
vector<long long> seg_tree;
vector<long long> arr;
SegTree(int N) {
for (int i = 1; i <= 4 * N; i++) seg_tree.push_back(0);
for (int i = 1; i <= N; i++) arr.push_back(0);
}
void buildTree(int si, int ss, int second) {
if (ss == second) {
seg_tree[si] = arr[ss];
return;
}
int mid = (ss + second) / 2;
buildTree(2 * si, ss, mid);
buildTree(2 * si + 1, mid + 1, second);
seg_tree[si] = seg_tree[2 * si] + seg_tree[2 * si + 1];
return;
}
void updateTree(int si, int ss, int second, int qi) {
if (ss == second) {
seg_tree[si] = arr[ss];
return;
}
int mid = (ss + second) / 2;
if (qi <= mid)
updateTree(2 * si, ss, mid, qi);
else
updateTree(2 * si + 1, mid + 1, second, qi);
seg_tree[si] = seg_tree[2 * si] + seg_tree[2 * si + 1];
return;
}
long long queryTree(int si, int ss, int second, int qs, int qe) {
if (qs > second || ss > qe) return 0;
if (ss >= qs && second <= qe) return seg_tree[si];
int mid = (ss + second) / 2;
long long lsum = queryTree(2 * si, ss, mid, qs, qe);
long long rsum = queryTree(2 * si + 1, mid + 1, second, qs, qe);
return lsum + rsum;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> a >> b >> q;
int N = 2e5 + 10;
SegTree segA(N), segB(N);
while (q--) {
int qi;
cin >> qi;
;
if (qi == 1) {
int di, oi;
cin >> di >> oi;
;
segB.arr[di] = min((long long)b, (long long)(segB.arr[di] + oi));
segB.updateTree(1, 1, n, di);
segA.arr[di] = min((long long)a, (long long)(segA.arr[di] + oi));
segA.updateTree(1, 1, n, di);
} else {
int pi;
cin >> pi;
;
long long ansB, ansA;
if (pi == 1)
ansB = 0;
else
ansB = segB.queryTree(1, 1, n, 1, pi - 1);
if (pi + k - 1 == n)
ansA = 0;
else
ansA = segA.queryTree(1, 1, n, pi + k, n);
cout << ansA + ansB << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> arr;
vector<int> block_B;
vector<int> block_A;
int block_size;
int a, b;
int n;
int get_A(int l, int r) {
if (l >= n) return 0;
int block_l = l / block_size;
int block_r = r / block_size;
int pos_l = l % block_size;
int pos_r = r % block_size;
int q_ans = 0;
for (int i = block_l; i <= block_r; i++) q_ans += block_A[i];
for (int i = 0; i < pos_l; i++)
q_ans -= min(a, arr[block_l * block_size + i]);
for (int i = pos_r + 1; i < block_size; i++)
q_ans -= min(a, arr[block_r * block_size + i]);
return q_ans;
}
int get_B(int l, int r) {
if (l >= n) return 0;
int block_l = l / block_size;
int block_r = r / block_size;
int pos_l = l % block_size;
int pos_r = r % block_size;
int q_ans = 0;
for (int i = block_l; i <= block_r; i++) q_ans += block_B[i];
for (int i = 0; i < pos_l; i++)
q_ans -= min(b, arr[block_l * block_size + i]);
for (int i = pos_r + 1; i < block_size; i++)
q_ans -= min(b, arr[block_r * block_size + i]);
return q_ans;
}
void update(int pos, int x) {
arr[pos] += x;
int block = pos / block_size;
block_A[block] = 0;
block_B[block] = 0;
for (int i = 0; i < block_size; i++)
block_A[block] += min(a, arr[block * block_size + i]);
for (int i = 0; i < block_size; i++)
block_B[block] += min(b, arr[block * block_size + i]);
}
int main() {
int k, q;
cin >> n >> k >> a >> b >> q;
arr.resize(n);
block_size = sqrt(n) + 1;
while (arr.size() % block_size != 0) arr.push_back(0);
block_A.resize(arr.size() / block_size + 1);
block_B.resize(arr.size() / block_size + 1);
while (q--) {
int g;
cin >> g;
if (g == 1) {
int D, A;
cin >> D >> A;
D--;
update(D, A);
} else {
int p;
cin >> p;
p--;
int l_1 = 0;
int r_1 = p - 1;
int l_2 = p + k;
int r_2 = n - 1;
cout << get_B(l_1, r_1) + get_A(l_2, r_2) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
class FenwickTree {
public:
explicit FenwickTree(int N) : F(N, 0) {}
void Add(int i, int add) {
for (; i < F.size(); i = (i | (i + 1))) {
F[i] += add;
}
}
int Sum(int i) const {
int r = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
r += F[i];
}
return r;
}
int Sum(int i, int j) const {
if (i > j) {
return 0;
}
return Sum(j) - Sum(i - 1);
}
private:
vector<int> F;
};
int main() {
int N, K, A, B, Q;
scanf("%d%d%d%d%d", &N, &K, &A, &B, &Q);
vector<int> D(N, 0);
FenwickTree up(N), down(N);
for (int q = 0; q < Q; ++q) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, a;
scanf("%d%d", &d, &a);
--d;
int up_value = min(A, D[d] + a);
int down_value = min(B, D[d] + a);
if (up_value > D[d]) {
up.Add(d, up_value - D[d]);
}
if (down_value > D[d]) {
down.Add(d, down_value - D[d]);
}
D[d] = up_value;
} else {
int p;
scanf("%d", &p);
--p;
int result = down.Sum(0, p - 1) + up.Sum(p + K, N - 1);
printf("%d\n", result);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma warning(disable : 4996)
#pragma hdrstop
template <class T>
inline bool umin(T& a, const T& b) {
return (b < a ? a = b, true : false);
}
namespace std {}
namespace Random {}
inline bool is_digit(const char ch) { return (ch >= '0' && ch <= '9'); }
class IO {
public:
constexpr static const std::size_t kBufferSize = 1 << 18;
IO()
: read_bytes_count_(0),
read_buffer_offset_(0),
current_char_(0),
eof_(false) {
static_assert(kBufferSize > 32,
"Size of a buffer must be greater than 32 due to comparison "
"in IO::flush() method.");
}
~IO() { flush(); }
IO(const IO&) = delete;
IO& operator=(const IO&) = delete;
IO(const IO&&) = delete;
IO& operator=(const IO&&) = delete;
inline void shift_char();
inline int32_t next_int();
IO& operator>>(int32_t& x);
inline void flush();
inline void new_line();
inline void print_int(const int32_t x);
IO& operator<<(const int32_t x);
IO& operator<<(std::ostream& (*)(std::ostream&));
private:
using Buffer = std::array<char, kBufferSize>;
Buffer read_buffer_;
Buffer write_buffer_;
std::size_t read_bytes_count_;
std::size_t read_buffer_offset_;
std::size_t write_buffer_offset_;
bool eof_;
char current_char_;
inline void update_buffer();
template <typename T>
T read_number();
template <typename T>
void print_number(const T& value);
};
extern bool useFastIO;
extern std::istream* pin;
extern std::ostream* pout;
extern IO io;
inline int32_t next_int();
inline void new_line();
inline void print_int(const int32_t x);
using namespace std;
int __;
IO io;
template <typename T>
class SegmentTreeSum {
public:
SegmentTreeSum(const int P, const size_t N,
const T& neutral_ = static_cast<T>(0))
: P_(P), N_(N), neutral_(neutral_) {
offset_ = 1 << (31 - __builtin_clz(N) + ((N & (N - 1)) == 0 ? 0 : 1));
size_ = offset_ << 1;
data_.resize(size_);
init();
}
SegmentTreeSum() = delete;
SegmentTreeSum(SegmentTreeSum&) = default;
SegmentTreeSum(SegmentTreeSum&&) = default;
SegmentTreeSum& operator=(SegmentTreeSum&) = default;
SegmentTreeSum& operator=(SegmentTreeSum&&) = default;
~SegmentTreeSum() = default;
void init() { std::fill_n(data_.begin(), data_.size(), neutral_); }
T query(const size_t left, const size_t right) const {
T res = neutral_;
for (size_t l = left + offset_, r = right + offset_; l <= r;
l >>= 1, r >>= 1) {
if (l & 1) {
res += data_[l++];
}
if ((r & 1) == 0) {
res += data_[r--];
}
}
return res;
}
void update(const size_t position, const T& value) {
size_t pos = position + offset_;
data_[pos] += value;
umin(data_[pos], P_);
for (pos >>= 1; pos >= 1; pos >>= 1) {
data_[pos] = data_[pos << 1] + data_[(pos << 1) ^ 1];
}
}
private:
int P_;
std::vector<T> data_;
const T neutral_;
size_t offset_;
size_t size_;
size_t N_;
};
void solve(istream& ins, ostream& out) {
int n, k, a, b;
io >> n >> k >> a >> b >> __;
SegmentTreeSum<int> tree_a(a, n), tree_b(b, n);
for (int _ = 0; _ < __; ++_) {
int type, day;
io >> type >> day;
if (type == 1) {
int cnt;
io >> cnt;
tree_a.update(day - 1, cnt);
tree_b.update(day - 1, cnt);
} else {
int ans = tree_b.query(0, day - 2);
ans += tree_a.query(day + k - 1, n - 1);
io << ans << endl;
}
}
}
extern class IO io;
bool useFastIO = false;
istream* pin;
ostream* pout;
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
useFastIO = true;
ostream& out = cout;
out << fixed << setprecision(16);
pin = ∈
pout = &out;
solve(in, out);
return 0;
}
template <typename T>
T IO::read_number() {
bool is_negative = false;
while (!eof_ && !is_digit(current_char_) &&
(std::is_unsigned<T>() || current_char_ != '-')) {
shift_char();
}
if (std::is_signed<T>() && current_char_ == '-') {
is_negative = true;
shift_char();
}
T result = 0;
while (!eof_ && is_digit(current_char_)) {
result = (result << 3) + (result << 1) + current_char_ - '0';
shift_char();
}
return (is_negative ? result * -1 : result);
}
template <typename T>
void IO::print_number(const T& value) {
T current_value = value;
if (write_buffer_offset_ + 32 > kBufferSize) {
flush();
}
if (current_value < 0) {
write_buffer_[write_buffer_offset_++] = '-';
current_value = abs(current_value);
} else if (current_value == 0) {
write_buffer_[write_buffer_offset_++] = '0';
return;
}
std::size_t start_index = write_buffer_offset_;
while (current_value != 0) {
write_buffer_[write_buffer_offset_++] = current_value % 10 + '0';
current_value /= 10;
}
std::reverse(write_buffer_.begin() + start_index,
write_buffer_.begin() + write_buffer_offset_);
}
inline void IO::update_buffer() {
if (read_buffer_offset_ == read_bytes_count_) {
read_bytes_count_ = fread(&read_buffer_[0], sizeof(read_buffer_[0]),
read_buffer_.size(), stdin);
if (read_bytes_count_ == 0) {
eof_ = true;
return;
}
read_buffer_offset_ = 0;
}
}
inline void IO::shift_char() {
update_buffer();
current_char_ = read_buffer_[read_buffer_offset_++];
}
inline int32_t IO::next_int() { return read_number<int32_t>(); }
IO& IO::operator>>(int32_t& x) {
x = ::next_int();
return *this;
}
inline void IO::flush() {
fwrite(&write_buffer_[0], sizeof(write_buffer_[0]), write_buffer_offset_,
stdout);
write_buffer_offset_ = 0;
}
inline void IO::new_line() {
if (write_buffer_offset_ == kBufferSize) {
flush();
}
write_buffer_[write_buffer_offset_++] = '\n';
}
inline void IO::print_int(const int32_t x) { print_number(x); }
IO& IO::operator<<(const int32_t x) {
::print_int(x);
return *this;
}
IO& IO::operator<<(std::ostream& (*)(std::ostream&)) {
::new_line();
return *this;
}
inline int32_t next_int() {
if (useFastIO) {
return io.next_int();
}
int32_t ret;
*pin >> ret;
return ret;
}
inline void new_line() {
if (useFastIO) {
io.new_line();
return;
}
*pout << std::endl;
}
inline void print_int(const int32_t x) {
if (useFastIO) {
io.print_int(x);
return;
}
*pout << x;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD9 = 1e9 + 7;
const int MOD91 = 1e9 + 9;
const long long MOD12 = 1e12 + 39LL;
const long long MOD15 = 1e15 + 37LL;
const int INF = 1e9;
const int base = 1e9;
const int MAXN = 2e5 + 6;
const long double EPS = 1e-10;
int n, k, a, b, q;
int aa[MAXN], bb[MAXN];
int tp[MAXN], ts[MAXN];
int sum(int r, int t[]) {
int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(unsigned i, int delta, int t[]) {
for (; i < n; i = (i | (i + 1))) {
t[i] += delta;
}
}
int main() {
scanf("%d %d %d %d %d\n", &n, &k, &a, &b, &q);
for (int i = (0); i < (q); ++i) {
int x, y, z;
scanf("%d ", &x);
if (x == 1) {
scanf("%d %d\n", &y, &z);
int x1 = aa[y - 1];
aa[y - 1] += z;
if (aa[y - 1] > a) {
aa[y - 1] = a;
}
if (aa[y - 1] - x1) inc((unsigned)(n - y), aa[y - 1] - x1, ts);
x1 = bb[y - 1];
bb[y - 1] += z;
if (bb[y - 1] > b) {
bb[y - 1] = b;
}
if (bb[y - 1] - x1) inc(y - 1, bb[y - 1] - x1, tp);
} else {
scanf("%d\n", &y);
cout << sum(y - 2, tp) + sum(n - y - k, ts) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, k, a, b, q;
int c[N];
int bit1[N], bit2[N];
void C(int *a, int i, int d) {
for (; i <= n; i += i & -i) a[i] += d;
}
int Q(int *a, int i) {
int res = 0;
for (; i; i -= i & -i) res += a[i];
return res;
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 1; i <= q; i++) {
int kd, x, y;
scanf("%d%d", &kd, &x);
if (kd == 1) {
scanf("%d", &y);
C(bit1, x, -min(c[x], b)), C(bit2, x, -min(c[x], a));
c[x] += y;
C(bit1, x, min(c[x], b)), C(bit2, x, min(c[x], a));
} else {
int ans = Q(bit1, x - 1) + Q(bit2, n) - Q(bit2, x + k - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> pmin(2 * 262144);
vector<int> pmax(2 * 262144);
void muutaMin(int k, int x) {
k += 262144;
pmin[k] = x;
for (k /= 2; k >= 1; k /= 2) {
pmin[k] = pmin[2 * k] + pmin[2 * k + 1];
}
}
int summaMin(int a, int b) {
a += 262144;
b += 262144;
int s = 0;
while (a <= b) {
if (a % 2 == 1) {
s += pmin[a];
a++;
}
if (b % 2 == 0) {
s += pmin[b];
b--;
}
a /= 2;
b /= 2;
}
return s;
}
void muutaMax(int k, int x) {
k += 262144;
pmax[k] = x;
for (k /= 2; k >= 1; k /= 2) {
pmax[k] = pmax[2 * k] + pmax[2 * k + 1];
}
}
int summaMax(int a, int b) {
a += 262144;
b += 262144;
int s = 0;
while (a <= b) {
if (a % 2 == 1) {
s += pmax[a];
a++;
}
if (b % 2 == 0) {
s += pmax[b];
b--;
}
a /= 2;
b /= 2;
}
return s;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
int day, orders;
cin >> day >> orders;
int curMin = summaMin(day, day);
curMin = min(b, curMin + orders);
muutaMin(day, curMin);
int curMax = summaMax(day, day);
curMax = min(a, curMax + orders);
muutaMax(day, curMax);
} else {
int p;
cin >> p;
long long sum1 = summaMin(0, p - 1);
long long sum2 = summaMax(p + k, 262144);
cout << sum1 + sum2 << "\n";
}
}
}
|
#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;
}
template <class T>
inline void gn(T &x) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), x = 0; c >= '0' && c <= '9';
c = getchar())
x = (x << 1) + (x << 3) + c - '0';
if (sg) x = -x;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1), gn(x2), gn(x3);
}
template <class T1, class T2, class T3, class T4>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
gn(x1), gn(x2), gn(x3), gn(x4);
}
template <class T>
inline void print(T x) {
if (x < 0) {
putchar('-');
return print(-x);
}
if (x < 10) {
putchar('0' + x);
return;
}
print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void printsp(T x) {
print(x);
putchar(' ');
}
template <class T>
inline void println(T x) {
print(x);
putchar('\n');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % 1000000007)
if (b & 1) ans = 1LL * ans * a % 1000000007;
return ans;
}
int Ba[222222], Bb[222222];
int x[222222], y[222222];
int a, b, n;
void update_a(int u, int ad) {
int cur = x[u];
x[u] = min(a, x[u] + ad);
int up = x[u] - cur;
for (; u; u -= u & -u) Ba[u] += up;
}
void update_b(int u, int ad) {
int cur = y[u];
y[u] = min(b, y[u] + ad);
int add = y[u] - cur;
for (; u <= n + 10; u += u & -u) Bb[u] += add;
}
int calc_a(int u) {
int ans = 0;
for (; u <= n + 10; u += u & -u) ans += Ba[u];
return ans;
}
int calc_b(int u) {
int ans = 0;
for (; u; u -= u & -u) ans += Bb[u];
return ans;
}
int main() {
int q, k;
int op, x, y;
gn(n, k);
gn(a, b, q);
while (q--) {
gn(op, x);
if (op == 1) {
gn(y);
update_a(x, y), update_b(x, y);
} else
println(calc_b(x - 1) + calc_a(x + k));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
long long _max[200100];
long long _min[200100];
int n;
void max_add(int i, long long x) {
while (i <= n) {
_max[i] += x;
i += i & (-i);
}
}
long long max_sum(int i) {
long long sum = 0;
while (i > 0) {
sum += _max[i];
i -= i & (-i);
}
return sum;
}
void min_add(int i, long long x) {
while (i <= n) {
_min[i] += x;
i += i & (-i);
}
}
long long min_sum(int i) {
long long sum = 0;
while (i > 0) {
sum += _min[i];
i -= i & (-i);
}
return sum;
}
int k, q;
long long a, b;
long long num[200100];
int main() {
memset(_max, 0, sizeof(_max));
memset(_min, 0, sizeof(_min));
cin >> n >> k >> a >> b >> q;
while (q--) {
int cmd;
cin >> cmd;
if (cmd == 1) {
int d;
long long x;
cin >> d >> x;
if (num[d]) {
max_add(d, -min(num[d], a));
min_add(d, -min(num[d], b));
}
num[d] += x;
max_add(d, min(num[d], a));
min_add(d, min(num[d], b));
} else {
int p;
cin >> p;
long long ans = min_sum(p - 1);
ans += max_sum(n) - max_sum(p + k - 1);
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long A[maxn], ta[maxn], tb[maxn];
long long n, k, a, b, q;
void insert(long long i, long long num, long long *t) {
for (; i <= n; i += (i & (-i))) t[i] += num;
}
long long cal(long long i, long long *t) {
long long ans = 0;
for (; i > 0; i -= (i & (-i))) ans += t[i];
return ans;
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 1; i <= q; i++) {
int op;
long long dd, aa, pp;
scanf("%d", &op);
if (op == 1) {
scanf("%lld%lld", &dd, &aa);
insert(dd, max(0ll, min(b - A[dd], aa)), tb);
insert(dd, max(0ll, min(a - A[dd], aa)), ta);
A[dd] += aa;
} else {
scanf("%lld", &pp);
printf("%lld\n", cal(pp - 1, tb) + cal(n, ta) - cal(pp + k - 1, ta));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> ans;
const int N = 200000;
long long ta[6 * N];
long long tb[6 * N];
const int INF = 100000000;
long long n, k, a, b, q;
long long get_a(int v, int vl, int vr, int l, int r) {
if (vl == l && vr == r) {
return ta[v];
}
long long r1, r2;
if (l >= r)
return 0;
else {
int d = (vl + vr) / 2;
r1 = get_a(2 * v + 1, vl, d, l, min(d, r));
r2 = get_a(2 * v + 2, d, vr, max(d, l), r);
}
return r1 + r2;
}
long long get_b(int v, int vl, int vr, int l, int r) {
if (vl == l && vr == r) {
return tb[v];
}
long long r1, r2;
if (l >= r)
return 0;
else {
int d = (vl + vr) / 2;
r1 = get_b(2 * v + 1, vl, d, l, min(d, r));
r2 = get_b(2 * v + 2, d, vr, max(d, l), r);
}
return r1 + r2;
}
void put_a(int v, int vl, int vr, int l, int r, int add) {
if (vl == l && vr == r) {
ta[v] = min(a, add + ta[v]);
return;
}
if (l >= r)
return;
else {
int d = (vl + vr) / 2;
put_a(2 * v + 1, vl, d, l, min(d, r), add);
put_a(2 * v + 2, d, vr, max(d, l), r, add);
ta[v] = ta[2 * v + 1] + ta[2 * v + 2];
}
}
void put_b(int v, int vl, int vr, int l, int r, int add) {
if (vl == l && vr == r) {
tb[v] = min(b, add + tb[v]);
return;
}
if (l >= r)
return;
else {
int d = (vl + vr) / 2;
put_b(2 * v + 1, vl, d, l, min(d, r), add);
put_b(2 * v + 2, d, vr, max(d, l), r, add);
tb[v] = tb[2 * v + 1] + tb[2 * v + 2];
}
}
int main() {
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < 6 * N; i++) {
ta[i] = 0;
tb[i] = 0;
}
for (int i = 0; i < q; i++) {
int pq;
cin >> pq;
if (pq == 1) {
int val, cnt;
cin >> val >> cnt;
val--;
put_a(0, 0, n, val, val + 1, cnt);
put_b(0, 0, n, val, val + 1, cnt);
} else {
int p;
cin >> p;
p--;
int t = get_b(0, 0, n, 0, p);
int t1 = get_a(0, 0, n, p + k, n);
ans.push_back(t + t1);
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
int gcd(int x, int y) {
while (y) {
int t = x % y;
x = y;
y = t;
}
return x;
}
int sum[200010], n;
struct bit {
int c[200010];
bit() { memset(c, 0, sizeof c); }
void add(int x, int v) {
for (int i = x; i <= n; i += ((i) & (-i))) c[i] += v;
}
int query(int x) {
int res = 0;
for (int i = x; i; i -= ((i) & (-i))) res += c[i];
return res;
}
} s[2];
int main() {
int k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; i++) {
int typ, d, p;
scanf("%d", &typ);
if (typ == 1) {
scanf("%d%d", &d, &p);
int x = max(b - sum[d], 0);
int y = max(a - sum[d], 0);
s[1].add(d, min(y, p));
s[0].add(d, min(x, p));
sum[d] += p;
} else {
scanf("%d", &d);
int ans1 = s[0].query(d - 1);
int now = min(n, d + k - 1);
int ans2 = s[1].query(n) - s[1].query(now);
printf("%d\n", ans1 + ans2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200005;
struct BIT {
int tree[200005];
BIT() { memset(tree, 0, sizeof(tree)); }
void add(int i, int val) {
while (i < MAX) {
tree[i] += val;
i += (i & -i);
}
}
int read(int i) {
int sm = 0;
while (i > 0) {
sm += tree[i];
i -= (i & -i);
}
return sm;
}
};
int ord[200005];
int main() {
memset(ord, 0, sizeof(ord));
int n, k, a, b, q;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
BIT t1;
BIT t2;
while (q--) {
int c;
scanf("%d", &c);
if (c == 1) {
int d, ai;
scanf("%d %d", &d, &ai);
int olda, oldb;
olda = ord[d];
oldb = olda;
if (olda >= b) olda = b;
if (oldb >= a) oldb = a;
ord[d] += ai;
int nw = ord[d];
int nwa = min(b, nw);
int nwb = min(a, nw);
t1.add(d, nwa - olda);
t2.add(d, nwb - oldb);
} else {
int p;
scanf("%d", &p);
int sm = t1.read(p - 1);
p += k - 1;
sm += t2.read(200003) - t2.read(p);
printf("%d\n", sm);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int st[2][200005];
void init() { memset(st, 0, sizeof(st)); }
int ask(int pos, int t) {
int tt = 0;
for (++pos; pos; pos -= (pos & (-pos))) tt += st[t][pos];
return tt;
}
void upd(int pos, int v, int t) {
for (++pos; pos <= n; pos += (pos & (-pos))) st[t][pos] += v;
return;
}
int main() {
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
init();
int N, k, a, b, q, t, d, h;
cin >> N >> k >> a >> b >> q;
n = N + 10;
while (q--) {
cin >> t >> d;
if (t == 1) {
cin >> h;
int tmp = ask(d, 0) - ask(d - 1, 0);
int tmp2 = ask(d, 1) - ask(d - 1, 1);
upd(d, -tmp, 0);
upd(d, -tmp2, 1);
upd(d, (b < tmp + h ? b : tmp + h), 0);
upd(d, (a < tmp2 + h ? a : tmp2 + h), 1);
} else {
cout << ask(N, 1) - ask(d + k - 1, 1) + ask(d - 1, 0) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 7;
long long n, k, a, b, q;
long long arr[MAXN];
void read() { cin >> n >> k >> a >> b >> q; }
long long acnt[MAXN << 2], asum[MAXN << 2], bcnt[MAXN << 2], bsum[MAXN << 2];
long long getacnt(long long v, long long tl, long long tr, long long l,
long long r) {
if (tr < l || r < tl) return 0;
if (l <= tl && tr <= r) return acnt[v];
long long tm = (tl + tr) >> 1;
return getacnt(v * 2 + 1, tl, tm, l, r) +
getacnt(v * 2 + 2, tm + 1, tr, l, r);
}
long long getbcnt(long long v, long long tl, long long tr, long long l,
long long r) {
if (tr < l || r < tl) return 0;
if (l <= tl && tr <= r) return bcnt[v];
long long tm = (tl + tr) >> 1;
return getbcnt(v * 2 + 1, tl, tm, l, r) +
getbcnt(v * 2 + 2, tm + 1, tr, l, r);
}
long long getasum(long long v, long long tl, long long tr, long long l,
long long r) {
if (tr < l || r < tl) return 0;
if (l <= tl && tr <= r) return asum[v];
long long tm = (tl + tr) >> 1;
return getasum(v * 2 + 1, tl, tm, l, r) +
getasum(v * 2 + 2, tm + 1, tr, l, r);
}
long long getbsum(long long v, long long tl, long long tr, long long l,
long long r) {
if (tr < l || r < tl) return 0;
if (l <= tl && tr <= r) return bsum[v];
long long tm = (tl + tr) >> 1;
return getbsum(v * 2 + 1, tl, tm, l, r) +
getbsum(v * 2 + 2, tm + 1, tr, l, r);
}
void updacnt(long long v, long long tl, long long tr, long long p,
long long x) {
if (tl == tr) {
acnt[v] = (arr[p] + x >= a);
return;
}
long long tm = (tl + tr) >> 1;
if (p <= tm)
updacnt(v * 2 + 1, tl, tm, p, x);
else
updacnt(v * 2 + 2, tm + 1, tr, p, x);
acnt[v] = acnt[v * 2 + 1] + acnt[v * 2 + 2];
}
void updbcnt(long long v, long long tl, long long tr, long long p,
long long x) {
if (tl == tr) {
bcnt[v] = (arr[p] + x >= b);
return;
}
long long tm = (tl + tr) >> 1;
if (p <= tm)
updbcnt(v * 2 + 1, tl, tm, p, x);
else
updbcnt(v * 2 + 2, tm + 1, tr, p, x);
bcnt[v] = bcnt[v * 2 + 1] + bcnt[v * 2 + 2];
}
void updasum(long long v, long long tl, long long tr, long long p,
long long x) {
if (tl == tr) {
asum[v] = (arr[p] + x) * (arr[p] + x < a);
return;
}
long long tm = (tl + tr) >> 1;
if (p <= tm)
updasum(v * 2 + 1, tl, tm, p, x);
else
updasum(v * 2 + 2, tm + 1, tr, p, x);
asum[v] = asum[v * 2 + 1] + asum[v * 2 + 2];
}
void updbsum(long long v, long long tl, long long tr, long long p,
long long x) {
if (tl == tr) {
bsum[v] = (arr[p] + x) * (arr[p] + x < b);
return;
}
long long tm = (tl + tr) >> 1;
if (p <= tm)
updbsum(v * 2 + 1, tl, tm, p, x);
else
updbsum(v * 2 + 2, tm + 1, tr, p, x);
bsum[v] = bsum[v * 2 + 1] + bsum[v * 2 + 2];
}
void print() {
for (long long i = 0; i < q; ++i) {
long long t;
cin >> t;
if (t == 1) {
long long p, x;
cin >> p >> x;
--p;
updacnt(0, 0, MAXN, p, x);
updbcnt(0, 0, MAXN, p, x);
updasum(0, 0, MAXN, p, x);
updbsum(0, 0, MAXN, p, x);
arr[p] += x;
} else {
long long p;
cin >> p;
--p;
long long sum1 =
getbcnt(0, 0, MAXN, 0, p - 1) * b + getbsum(0, 0, MAXN, 0, p - 1);
long long sum2 = getacnt(0, 0, MAXN, p + k, MAXN) * a +
getasum(0, 0, MAXN, p + k, MAXN);
cout << sum1 + sum2 << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
read();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int st[2][1 << 19] = {};
const int off = 1 << 18;
void stUpdate(int t, int v, int val) {
v += off;
st[t][v] = val;
for (v >>= 1; v >= 1; v >>= 1) {
st[t][v] = st[t][2 * v] + st[t][2 * v + 1];
}
}
int stGet(int t, int v, int L, int R, int l, int r) {
if (l > r) return 0;
if (L == l && R == r) {
return st[t][v];
}
int mid = (L + R) >> 1;
return stGet(t, 2 * v, L, mid, l, min(r, mid)) +
stGet(t, 2 * v + 1, mid + 1, R, max(l, mid + 1), r);
}
int n, k, a, b, q;
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int qq = 0; qq < (int)(q); ++qq) {
int qt, x, y;
scanf("%d", &qt);
if (qt == 1) {
scanf("%d%d", &x, &y), --x;
stUpdate(0, x, min(st[0][off + x] + y, b));
stUpdate(1, x, min(st[1][off + x] + y, a));
} else {
scanf("%d", &x), --x;
int ans = stGet(0, 1, 0, off - 1, 0, x - 1);
ans += stGet(1, 1, 0, off - 1, x + k, n - 1);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e5 + 9;
int n, k, a, b, q;
pair<int, int> tree[inf << 2];
void update(int node, int l, int r, int idx, int val) {
if (l == r) {
tree[node].first += val;
tree[node].second += val;
tree[node] = make_pair(min(tree[node].first, a), min(tree[node].second, b));
return;
}
if (idx <= (l + r) / 2)
update(node + node, l, (l + r) / 2, idx, val);
else
update(node + node + 1, (l + r) / 2 + 1, r, idx, val);
tree[node] =
make_pair(tree[node + node].first + tree[node + node + 1].first,
tree[node + node].second + tree[node + node + 1].second);
}
pair<int, int> query(int node, int l, int r, int x, int y) {
if (l > r || l > y || r < x || x > y) return make_pair(0, 0);
if (l >= x && r <= y) return tree[node];
pair<int, int> d = query(node + node, l, (l + r) / 2, x, y),
f = query(node + node + 1, (l + r) / 2 + 1, r, x, y);
return make_pair(d.first + f.first, d.second + f.second);
}
int main() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int ty, x, y;
cin >> ty >> x;
if (ty == 1)
cin >> y, update(1, 1, n, x, y);
else
cout << query(1, 1, n, 1, x - 1).second + query(1, 1, n, x + k, n).first
<< endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
int n, k;
long long a, b, tree[2][4 * 200003];
void update(int node, int s, int e, int pos, int val) {
if (s > e || pos < s || pos > e) return;
if (s == e) {
tree[0][node] = min(b, tree[0][node] + val);
tree[1][node] = min(a, tree[1][node] + val);
return;
}
int mid = (s + e) / 2;
update((2 * (node)), s, mid, pos, val);
update((2 * (node) + 1), mid + 1, e, pos, val);
tree[0][node] = tree[0][(2 * (node))] + tree[0][(2 * (node) + 1)];
tree[1][node] = tree[1][(2 * (node))] + tree[1][(2 * (node) + 1)];
}
long long query(int type, int node, int s, int e, int lo, int hi) {
if (s > e || s > hi || lo > e) return 0;
if (s >= lo && e <= hi) return tree[type][node];
int mid = (s + e) / 2;
return query(type, (2 * (node)), s, mid, lo, hi) +
query(type, (2 * (node) + 1), mid + 1, e, lo, hi);
}
int main() {
int q;
scanf("%d%d%I64d%I64d%d", &n, &k, &a, &b, &q);
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int day, extra;
scanf("%d%d", &day, &extra);
update(1, 1, n, day, extra);
} else {
int day;
scanf("%d", &day);
long long ans =
query(0, 1, 1, n, 1, day - 1) + query(1, 1, 1, n, day + k, n);
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, b;
struct bitch {
long long b[200100];
bitch() { memset(b, 0, sizeof b); }
void reset() { memset(b, 0, sizeof b); }
void update(int at, int val) {
for (int i = at; i < 200100; i += (i & (-i))) b[i] += val;
}
long long query(int at) {
long long ret = 0;
for (int i = at; i > 0; i -= (i & (-i))) ret += b[i];
return ret;
}
long long query(int i, int j) { return query(j) - query(i - 1); }
};
bitch A, B;
int main() {
int q;
scanf("%lld %lld %lld %lld %d", &n, &k, &a, &b, &q);
A.reset();
B.reset();
while (q--) {
int o;
scanf("%d", &o);
if (o == 1) {
long long d, val;
scanf("%lld %lld", &d, &val);
long long addA = min(a - A.query(d, d), val);
A.update(d, addA);
long long addB = min(b - B.query(d, d), val);
B.update(d, addB);
} else {
long long d;
scanf("%lld", &d);
cout << B.query(d - 1) + A.query(d + k, n + 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long va[300300];
long long vb[300300];
long long T[2][300300];
void update(int idx, int val, int r) {
idx++;
while (idx < 300300) {
T[r][idx] += val;
idx += idx & -idx;
}
}
long long query(int idx, int r) {
if (idx < 0) return 0;
long long ret = 0;
idx++;
while (idx) {
ret += T[r][idx];
idx -= idx & -idx;
}
return ret;
}
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);
if (t == 1) {
int d, s;
scanf("%d%d", &d, &s), d--;
int old = va[d];
va[d] = min((long long)a, va[d] + s);
update(d, va[d] - old, 0);
old = vb[d];
vb[d] = min((long long)b, vb[d] + s);
update(d, vb[d] - old, 1);
} else {
int d;
scanf("%d", &d), d--;
long long ans = query(d - 1, 1) + query(n, 0) - query(d + k - 1, 0);
cout << ans << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q;
const int mxn = (2 * (1e5)) + 20;
int st[mxn * 4];
int st1[mxn * 4];
void change(int p, int l, int r, int i, int xx) {
if (r < i || l > i) return;
if (l == r)
st[p] = min(st[p] + xx, b);
else {
int m = (l + r) / 2;
change(p * 2, l, m, i, xx);
change(p * 2 + 1, m + 1, r, i, xx);
st[p] = st[p * 2] + st[p * 2 + 1];
}
}
int sum(int p, int l, int r, int i, int j) {
if (r < i || l > j) return 0;
if (l >= i && r <= j) return st[p];
int m = (l + r) / 2;
return sum(p * 2, l, m, i, j) + sum(p * 2 + 1, m + 1, r, i, j);
}
void change1(int p, int l, int r, int i, int xx) {
if (r < i || l > i) return;
if (l == r)
st1[p] = min(st1[p] + xx, a);
else {
int m = (l + r) / 2;
change1(p * 2, l, m, i, xx);
change1(p * 2 + 1, m + 1, r, i, xx);
st1[p] = st1[p * 2] + st1[p * 2 + 1];
}
}
int sum1(int p, int l, int r, int i, int j) {
if (r < i || l > j) return 0;
if (l >= i && r <= j) return st1[p];
int m = (l + r) / 2;
return sum1(p * 2, l, m, i, j) + sum1(p * 2 + 1, m + 1, r, i, j);
}
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; ++i) {
int t, d, x;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &d, &x);
change(1, 0, n, d, x);
change1(1, 0, n, d, x);
} else {
scanf("%d", &x);
int p1 = sum(1, 0, n, 0, x - 1);
int p2 = sum1(1, 0, n, (x + k), n);
printf("%d\n", p1 + p2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long unsigned arb[200005], arb1[200005], A[200005], B[200005], n, k, a, b,
q, tip, d, x, xx, p, y;
void upd1(long long unsigned poz, long long unsigned x) {
long long unsigned bit;
for (; poz <= n;) {
bit = (poz & (-poz));
arb1[poz] += x;
poz += bit;
}
}
void upd(long long unsigned poz, long long unsigned x) {
long long unsigned bit;
for (; poz <= n;) {
bit = (poz & (-poz));
arb[poz] += x;
poz += bit;
}
}
long long unsigned query1(long long unsigned poz) {
long long unsigned bit, sol = 0;
for (; poz;) {
bit = (poz & (-poz));
sol += arb1[poz];
poz -= bit;
}
return sol;
}
long long unsigned query(long long unsigned poz) {
long long unsigned bit, sol = 0;
for (; poz;) {
bit = (poz & (-poz));
sol += arb[poz];
poz -= bit;
}
return sol;
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
cin >> n >> k >> a >> b >> q;
for (; q; q--) {
cin >> tip;
if (tip == 1) {
cin >> d >> x;
xx = min(b - A[d], x);
A[d] += xx;
upd1(d, xx);
xx = min(a - B[d], x);
B[d] += xx;
upd(d, xx);
} else {
cin >> p;
x = y = 0;
if (p > 1) x = query1(p - 1);
if (p + k <= n) y = query(n) - query(p + k - 1);
cout << x + y << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "{";
for (const T& v : vc) o << v << ",";
o << "}";
return o;
}
using ll = long long;
template <class T>
using V = vector<T>;
template <class T>
using VV = vector<vector<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
struct segtree {
using D = long long;
int N;
vector<D> val;
segtree() {}
segtree(int n) {
N = 1;
while (N < n) N *= 2;
val.assign(N * 2, 0);
}
segtree(const vector<D>& ds) {
int n = ds.size();
N = 1;
while (N < n) N *= 2;
val.assign(N * 2, 0);
for (int i = 0; i < (int)(n); i++) val[i + N] = ds[i];
for (int i = N - 1; i > 0; i--) val[i] = val[i * 2] + val[i * 2 + 1];
}
void assign(int k, D d) {
k += N;
val[k] = d;
k /= 2;
while (k) {
val[k] = val[k * 2] + val[k * 2 + 1];
k /= 2;
}
}
D sum(int a, int b) {
D res = 0;
a += N, b += N;
while (a < b) {
if (a & 1) res += val[a++];
if (b & 1) res += val[--b];
a /= 2, b /= 2;
}
return res;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, K, A, B, Q;
cin >> N >> K >> A >> B >> Q;
segtree sega(N), segb(N);
V<int> sm(N);
for (int _ = 0; _ < (int)(Q); _++) {
int t;
cin >> t;
if (t == 1) {
int d, n;
cin >> d >> n;
d--;
sm[d] += n;
sega.assign(d, min(sm[d], A));
segb.assign(d, min(sm[d], B));
} else {
int p;
cin >> p;
p--;
cout << segb.sum(0, p) + sega.sum(p + K, N) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long before[200005], after[200005];
void update1(int idx, long long val) {
while (idx <= 200000) {
before[idx] += val;
idx += (idx & -idx);
}
}
void update2(int idx, long long val) {
while (idx <= 200000) {
after[idx] += val;
idx += (idx & -idx);
}
}
long long query1(int idx) {
long long res = 0;
while (idx > 0) {
res += before[idx];
idx -= (idx & -idx);
}
return res;
}
long long query2(int idx) {
long long res = 0;
while (idx > 0) {
res += after[idx];
idx -= (idx & -idx);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, q;
long long a, b;
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int ch;
cin >> ch;
if (ch == 1) {
int d;
long long val;
cin >> d >> val;
long long temp = query1(d) - query1(d - 1);
if (temp + val <= b)
update1(d, val);
else
update1(d, b - temp);
long long temp2 = query2(d) - query2(d - 1);
if (temp2 + val <= a)
update2(d, val);
else
update2(d, a - temp2);
} else {
int d;
cin >> d;
cout << query1(d - 1) + query2(200000) - query2(d + k - 1) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long nmax = 200001;
const long long inf = (long long)1e9;
inline long long max(long long a, long long b) { return a > b ? a : b; }
inline long long min(long long a, long long b) { return a < b ? a : b; }
long long c1[nmax], c2[nmax];
long long n, k, a, b, q;
long long lowbit(long long s) { return s & (-s); }
void update(long long ind, long long val, long long* c) {
while (ind <= n) {
c[ind] += val;
ind += lowbit(ind);
}
}
long long sum(long long r, long long* c) {
long long ret = 0;
while (r > 0) {
ret += c[r];
r -= lowbit(r);
}
return ret;
}
long long query(long long l, long long r, long long* c) {
long long ret = sum(r, c);
ret -= sum(l - 1, c);
return ret;
}
inline long long value(bool flag, long long vv, long long label) {
if (flag == 0)
return vv >= label ? label : vv;
else
return vv >= label ? label : vv;
}
long long f, d, v, p;
int main() {
while (scanf("%lld%lld%lld%lld%lld", &n, &k, &a, &b, &q) != EOF) {
memset(c1, 0, sizeof(c1));
memset(c2, 0, sizeof(c2));
long long relt = 0;
for (long long i = 0; i < q; i++) {
scanf("%lld", &f);
if (f == 1) {
scanf("%lld%lld", &d, &v);
p = query(d, d, c1);
if (p < b) update(d, value(0, v, b - p), c1);
p = query(d, d, c2);
if (p < a) update(d, value(1, v, a - p), c2);
} else {
scanf("%lld", &d);
relt = sum(d - 1, c1);
relt += query(d + k, n, c2);
printf("%lld\n", relt);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long num_a[200010], num_b[200010], sum_a[200010], sum_b[200010];
long long n, k, a, b, q, ans;
long long lowbit(long long x) { return (-x) & x; }
int main() {
long long i, j, s, t, u;
scanf("%I64d%I64d%I64d%I64d%I64d", &n, &k, &a, &b, &q);
for (i = 1; i <= q; i++) {
scanf("%I64d", &u);
if (u == 1) {
scanf("%I64d%I64d", &s, &t);
for (j = s; j <= n; j += lowbit(j)) {
sum_a[j] -= num_a[s];
sum_b[j] -= num_b[s];
}
num_a[s] = min(a, num_a[s] + t);
num_b[s] = min(b, num_b[s] + t);
for (j = s; j <= n; j += lowbit(j)) {
sum_a[j] += num_a[s];
sum_b[j] += num_b[s];
}
} else {
scanf("%I64d", &s);
ans = 0;
for (j = s - 1; j; j -= lowbit(j)) {
ans += sum_b[j];
}
for (j = n; j; j -= lowbit(j)) {
ans += sum_a[j];
}
for (j = s + k - 1; j; j -= lowbit(j)) {
ans -= sum_a[j];
}
printf("%I64d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vst[250005], vdr[250005];
int n, k, a, b, q, d, sol;
int adist[250005 * 4], adidr[250005 * 4];
void update(int a[], int nod, int st, int dr, int val, int poz) {
a[nod] += val;
if (st == dr) return;
int mid = (st + dr) >> 1;
if (poz <= mid)
update(a, nod * 2, st, mid, val, poz);
else
update(a, nod * 2 + 1, mid + 1, dr, val, poz);
}
void query(int a[], int nod, int st, int dr, int p1, int p2) {
if (p1 <= st && dr <= p2) {
sol += a[nod];
return;
}
if (st == dr) return;
int mid = (st + dr) >> 1;
if (p1 <= mid) query(a, nod * 2, st, mid, p1, p2);
if (p2 >= mid + 1) query(a, nod * 2 + 1, mid + 1, dr, p1, p2);
}
int main() {
int i, j, p, aux;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
for (i = 1; i <= q; i++) {
scanf("%d", &j);
if (j == 1) {
scanf("%d %d", &d, &p);
aux = vst[d];
vst[d] += p;
if (vst[d] > b) vst[d] = b;
update(adist, 1, 1, n, vst[d] - aux, d);
aux = vdr[d];
vdr[d] += p;
if (vdr[d] > a) vdr[d] = a;
update(adidr, 1, 1, n, vdr[d] - aux, d);
} else {
scanf("%d", &p);
sol = 0;
query(adist, 1, 1, n, 1, p - 1);
query(adidr, 1, 1, n, p + k, n);
printf("%d\n", sol);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T read() {
T res;
std::cin >> res;
return res;
}
template <typename T>
void print(const T& t) {
std::cout << t;
}
template <>
int read<int>() {
int res;
scanf("%d", &res);
return res;
}
template <>
void print<int>(const int& t) {
printf("%d", t);
};
template <>
unsigned int read<unsigned int>() {
unsigned int res;
scanf("%u", &res);
return res;
}
template <>
void print<unsigned int>(const unsigned int& t) {
printf("%u", t);
};
template <>
int64_t read<int64_t>() {
int64_t res;
scanf("%lld", &res);
return res;
}
template <>
void print<int64_t>(const int64_t& t) {
printf("%lld", t);
};
template <>
float read<float>() {
float res;
scanf("%f", &res);
return res;
}
template <>
void print<float>(const float& t) {
printf("%f", t);
};
template <>
double read<double>() {
double res;
scanf("%lf", &res);
return res;
}
template <>
void print<double>(const double& t) {
printf("%lf", t);
};
template <>
char read<char>() {
char res;
scanf("%c", &res);
return res;
}
template <>
void print<char>(const char& t) {
printf("%c", t);
};
namespace updateTypes {
template <typename T>
struct IncreaseBy {
public:
IncreaseBy(T value = T(0)) : value_(std::move(value)) {}
friend IncreaseBy<T> operator*(const IncreaseBy<T>& lh,
const IncreaseBy<T>& rh) {
return {lh.value_ + rh.value_};
}
T value_;
};
} // namespace updateTypes
template <typename UpdateType, typename BinaryFunctor>
struct UpdateApplier {};
template <typename T>
struct UpdateApplier<updateTypes::IncreaseBy<T>, std::plus<T>> {
static T apply(const T& v, const updateTypes::IncreaseBy<T>& upd,
size_t cnt) {
return v + cnt * upd.value_;
}
};
using std::vector;
template <typename ValueType, class AggregatingFunction, class UpdateType>
class SegmentTree {
public:
SegmentTree(const vector<ValueType>& initialValues,
AggregatingFunction aggregatingFunction)
: aggregatingFunction_(aggregatingFunction), size_(initialValues.size()) {
auto heapSize = (size_t(1) << calcHeight_(size_)) - 1;
valuesHeap_.resize(heapSize);
lazyUpdatesHeap_.resize(heapSize);
build_(begin(initialValues), end(initialValues), 0);
}
void updateElement(size_t i, UpdateType upd) { updateRange(i, i + 1, upd); }
void updateRange(size_t l, size_t r, UpdateType upd) {
if (l == r) return;
update_(l, r, upd, 0, 0, size_);
}
ValueType getValueOnSegment(size_t l, size_t r) const {
return calcValueOnSegment_(l, r, UpdateType(), 0, 0, size_);
}
private:
void build_(typename vector<ValueType>::const_iterator left,
typename vector<ValueType>::const_iterator right, size_t ind) {
if (right - left == 1) {
valuesHeap_[ind] = *left;
} else {
auto center = left + (right - left) / 2;
build_(left, center, leftChild_(ind));
build_(center, right, rightChild_(ind));
valuesHeap_[ind] = aggregatingFunction_(valuesHeap_[leftChild_(ind)],
valuesHeap_[rightChild_(ind)]);
}
}
void update_(size_t l, size_t r, const UpdateType& upd, size_t nodeInd,
size_t nodeLeft, size_t nodeRight) {
if (l == nodeLeft && r == nodeRight) {
lazyUpdatesHeap_[nodeInd] = upd * lazyUpdatesHeap_[nodeInd];
return;
}
lazyUpdatesHeap_[leftChild_(nodeInd)] =
lazyUpdatesHeap_[nodeInd] * lazyUpdatesHeap_[leftChild_(nodeInd)];
lazyUpdatesHeap_[rightChild_(nodeInd)] =
lazyUpdatesHeap_[nodeInd] * lazyUpdatesHeap_[rightChild_(nodeInd)];
lazyUpdatesHeap_[nodeInd] = UpdateType();
auto nodeCenter = (nodeLeft + nodeRight) / 2;
if (r <= nodeCenter) {
update_(l, r, upd, leftChild_(nodeInd), nodeLeft, nodeCenter);
} else if (l >= nodeCenter) {
update_(l, r, upd, rightChild_(nodeInd), nodeCenter, nodeRight);
} else {
update_(l, nodeCenter, upd, leftChild_(nodeInd), nodeLeft, nodeCenter);
update_(nodeCenter, r, upd, rightChild_(nodeInd), nodeCenter, nodeRight);
}
valuesHeap_[nodeInd] = aggregatingFunction_(
calcValueOnSegment_(nodeLeft, nodeCenter, {}, leftChild_(nodeInd),
nodeLeft, nodeCenter),
calcValueOnSegment_(nodeCenter, nodeRight, {}, rightChild_(nodeInd),
nodeCenter, nodeRight));
}
static size_t leftChild_(size_t ind) { return 2 * ind + 1; }
static size_t rightChild_(size_t ind) { return 2 * ind + 2; }
ValueType calcValueOnSegment_(size_t l, size_t r, UpdateType upd,
size_t nodeInd, size_t nodeLeft,
size_t nodeRight) const {
assert(l >= nodeLeft);
assert(r <= nodeRight);
upd = upd * lazyUpdatesHeap_[nodeInd];
if (l == nodeLeft && r == nodeRight)
return UpdateApplier<UpdateType, AggregatingFunction>::apply(
valuesHeap_[nodeInd], upd, r - l);
auto nodeCenter = (nodeLeft + nodeRight) / 2;
if (r <= nodeCenter)
return calcValueOnSegment_(l, r, upd, leftChild_(nodeInd), nodeLeft,
nodeCenter);
else if (l >= nodeCenter)
return calcValueOnSegment_(l, r, upd, rightChild_(nodeInd), nodeCenter,
nodeRight);
else
return aggregatingFunction_(
calcValueOnSegment_(l, nodeCenter, upd, leftChild_(nodeInd), nodeLeft,
nodeCenter),
calcValueOnSegment_(nodeCenter, r, upd, rightChild_(nodeInd),
nodeCenter, nodeRight));
}
int calcHeight_(size_t length) const {
int result = 1;
size_t maxLen = 1;
while (length > maxLen) {
maxLen *= 2;
result++;
}
return result;
}
private:
const AggregatingFunction aggregatingFunction_;
size_t size_;
vector<ValueType> valuesHeap_;
vector<UpdateType> lazyUpdatesHeap_;
};
template <typename ValueType, class AggregatingFunction, class UpdateType>
SegmentTree<ValueType, AggregatingFunction, UpdateType> makeSegmentTree(
const vector<ValueType>& initialValues,
AggregatingFunction aggregatingFunction, UpdateType dummy) {
return SegmentTree<ValueType, AggregatingFunction, UpdateType>(
initialValues, aggregatingFunction);
}
namespace internal {
template <typename ValueT>
class IterableRange {
public:
class iterator {
public:
iterator(ValueT v__) : v_(v__) {}
iterator& operator++() {
++v_;
return *this;
}
bool operator==(iterator rhs) const { return v_ == rhs.v_; }
bool operator!=(iterator rhs) const { return v_ != rhs.v_; }
ValueT operator*() const { return v_; }
ValueT operator->() const { return v_; }
private:
ValueT v_ = {};
};
IterableRange(ValueT begin__, ValueT end__)
: begin_value_(std::min(begin__, end__)), end_value_(end__) {}
iterator begin() const { return {begin_value_}; }
iterator end() const { return {end_value_}; }
private:
ValueT begin_value_ = {};
ValueT end_value_ = {};
};
} // namespace internal
template <typename ValueT>
internal::IterableRange<ValueT> range(ValueT end) {
return {{}, end};
}
template <typename ValueT>
internal::IterableRange<ValueT> range(ValueT begin, ValueT end) {
return {begin, end};
}
template <typename T>
void printVector(const std::vector<T>& out, std::string delimiter = " ") {
if (out.empty()) return;
for (size_t i = 0; i < out.size() - 1; ++i) std::cout << out[i] << delimiter;
std::cout << out.back();
}
using namespace std;
class Solver634C {
public:
void run();
};
void Solver634C::run() {
int nDays, repairLen, produceBeforeRepair, produceAfterRepair, nQueries;
cin >> nDays >> repairLen >> produceAfterRepair >> produceBeforeRepair >>
nQueries;
vector<int> result;
vector<int> nRequests(nDays, 0);
auto streeBefore =
makeSegmentTree(nRequests, plus<int>(), updateTypes::IncreaseBy<int>());
auto streeAfter =
makeSegmentTree(nRequests, plus<int>(), updateTypes::IncreaseBy<int>());
for (int i : range(nQueries)) {
int t;
cin >> t;
if (t == 1) {
int d, a;
cin >> d >> a;
--d;
auto currBefore = streeBefore.getValueOnSegment(d, d + 1);
auto incrBefore = min(a, produceBeforeRepair - currBefore);
streeBefore.updateElement(d, updateTypes::IncreaseBy<int>(incrBefore));
auto currAfter = streeAfter.getValueOnSegment(d, d + 1);
auto incrAfter = min(a, produceAfterRepair - currAfter);
streeAfter.updateElement(d, updateTypes::IncreaseBy<int>(incrAfter));
} else {
int p;
cin >> p;
--p;
auto fullfillBeforeRepair =
(p > 0) ? streeBefore.getValueOnSegment(0, p) : 0;
auto fullfillAfterRepair =
(nDays > p + repairLen)
? streeAfter.getValueOnSegment(p + repairLen, nDays)
: 0;
result.push_back(fullfillBeforeRepair + fullfillAfterRepair);
}
}
printVector(result, "\n");
}
int main() {
Solver634C solver;
solver.run();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long maxN = 2 * (long long)1e5 + 100;
long long fenw[2][maxN];
long long n;
void upd(long long ind, long long where, long long val) {
while (where <= n) {
fenw[ind][where] += val;
where = (where | (where - 1)) + 1;
}
}
long long get(long long ind, long long r) {
long long ans = 0;
while (r > 0) {
ans += fenw[ind][r];
r = r & (r - 1);
}
return ans;
}
long long get(long long ind, long long l, long long r) {
if (l > r) return 0;
if (r == 0) return 0;
return get(ind, r) - get(ind, l - 1);
}
long long k, a[2], q;
long long val[maxN];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k >> a[1] >> a[0] >> q;
for (long long i = 1; i <= q; i++) {
long long tp;
cin >> tp;
if (tp == 1) {
long long day, by;
cin >> day >> by;
for (long long j = 0; j < 2; j++) {
upd(j, day, -min(val[day], a[j]));
}
val[day] += by;
for (long long j = 0; j < 2; j++) {
upd(j, day, min(val[day], a[j]));
}
} else {
long long p;
cin >> p;
cout << get(1, p + k, n) + get(0, 1, p - 1) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int s[maxn];
int bit[2][maxn];
int low(int p) { return p & (-p); }
void merg(int u, int p, int n, int k) {
while (p <= n) {
bit[u][p] += k;
p = p + low(p);
}
}
int sum(int u, int p) {
int s = 0;
while (p) {
s += bit[u][p];
p = p - low(p);
}
return s;
}
int main() {
int i, n, a, b, k, q;
cin >> n >> k >> a >> b >> q;
for (i = 0; i < q; i++) {
int p;
scanf("%d", &p);
if (p == 1) {
int w1;
scanf("%d", &w1);
int w;
scanf("%d", &w);
if (s[w1] < a && s[w1] >= b) {
if (s[w1] + w >= a) {
merg(1, w1, n, a - s[w1]);
} else {
merg(1, w1, n, w);
}
s[w1] += w;
} else if (s[w1] < b) {
if ((s[w1] + w) >= b)
merg(0, w1, n, b - s[w1]);
else
merg(0, w1, n, w);
if (s[w1] + w >= a) {
merg(1, w1, n, a - s[w1]);
} else {
merg(1, w1, n, w);
}
s[w1] += w;
}
} else {
scanf("%d", &p);
int s = sum(0, p - 1);
if (p + k <= n) {
s += sum(1, n) - sum(1, p + k - 1);
}
printf("%d\n", s);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, D, A, B, Q, op, p, v;
int tree[2][200100], lo[200100], hi[200100];
void update(int *Tree, int p, int v) {
assert(p > 0);
while (p < 200100) {
Tree[p] += v;
p += p & -p;
}
}
int query(int *Tree, int p) {
int ret = 0;
while (p > 0) {
ret += Tree[p];
p -= p & (-p);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> D >> A >> B >> Q;
for (int q = 0; q < Q; q++) {
cin >> op;
if (op == 1) {
cin >> p >> v;
int lo2 = min(B, lo[p] + v);
update(tree[0], p, lo2 - lo[p]);
lo[p] = lo2;
int hi2 = min(A, hi[p] + v);
update(tree[1], p, hi2 - hi[p]);
hi[p] = hi2;
} else {
cin >> p;
cout << query(tree[0], p - 1) + query(tree[1], N) -
query(tree[1], p + D - 1)
<< "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, q, t, x, y;
int A[200005], B[200005];
int C[200005];
void insert1(int x, int y) {
for (int i = x; i <= 200000; i += (i & (-i))) B[i] += y;
}
void insert2(int x, int y) {
for (int i = x; i <= 200000; i += (i & (-i))) A[i] += y;
}
int q1(int x) {
int tmp = 0;
for (int i = x; i > 0; i -= (i & (-i))) tmp += B[i];
return tmp;
}
int q2(int x) {
int tmp = 0;
for (int i = x; i > 0; i -= (i & (-i))) tmp += A[i];
return tmp;
}
int main() {
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = (0); i < (q); i++) {
scanf("%d %d", &t, &x);
if (t == 1) {
if (t == 1) scanf("%d", &y);
if (C[x] < b) insert1(x, min(y, b - C[x]));
if (C[x] < a) insert2(x, min(y, a - C[x]));
C[x] += y;
} else {
printf("%d\n", q1(x - 1) + q2(200000) - q2(x + k - 1));
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.