problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define foreach(i, a) for (auto &i : a)
#define SELECTOR(_1, _2, _3, _4, SELECT, ...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__, _rep2, _rep1, _rep0)(__VA_ARGS__)
#define _rep0(i, n) for (ll i = 0; i < n; ++i)
#define _rep1(i, k, n) for (ll i = k; i < n; ++i)
#define _rep2(i, k, n, d) \
for (ll i = k; d != 0 && d > 0 ? i < n : i > n; i += d)
template <class T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template <class... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
void solve() {
ll Q;
cin >> Q;
ll cnt, a, B;
cin >> cnt >> a >> B;
multiset<ll> se;
auto itl = se.insert(a);
auto itr = itl;
ll score = 0;
rep(_, Q - 1) {
ll k;
cin >> k;
if (k == 1) {
ll a, b;
cin >> a >> b;
se.insert(a);
B += b;
if (cnt) {
if (a < *itl) {
score += *itl - a;
itl--;
} else {
score += a - *itr;
itr++;
}
} else {
if (a < *itl) {
score += *itl - a;
itr--;
} else if (*itl <= a < *itr) {
itl++;
itr--;
} else {
score += a - *itr;
itl++;
}
}
cnt ^= 1;
} else {
cout << *itl << ' ' << score + B << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define foreach(i, a) for (auto &i : a)
#define SELECTOR(_1, _2, _3, _4, SELECT, ...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__, _rep2, _rep1, _rep0)(__VA_ARGS__)
#define _rep0(i, n) for (ll i = 0; i < n; ++i)
#define _rep1(i, k, n) for (ll i = k; i < n; ++i)
#define _rep2(i, k, n, d) \
for (ll i = k; d != 0 && d > 0 ? i < n : i > n; i += d)
template <class T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template <class... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
void solve() {
ll Q;
cin >> Q;
ll cnt, a, B;
cin >> cnt >> a >> B;
multiset<ll> se;
auto itl = se.insert(a);
auto itr = itl;
ll score = 0;
rep(_, Q - 1) {
ll k;
cin >> k;
if (k == 1) {
ll a, b;
cin >> a >> b;
se.insert(a);
B += b;
if (cnt) {
if (a < *itl) {
score += *itl - a;
itl--;
} else {
score += a - *itr;
itr++;
}
} else {
if (a < *itl) {
score += *itl - a;
itr--;
} else if ((*itl <= a) && (a < *itr)) {
itl++;
itr--;
} else {
score += a - *itr;
itl++;
}
}
cnt ^= 1;
} else {
cout << *itl << ' ' << score + B << endl;
}
}
} | [
"control_flow.branch.if.condition.change"
] | 854,826 | 854,827 | u440566786 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
multiset<ll, greater<ll>> stl;
multiset<ll> str;
ll bsum = 0, ans = 0;
while (q--) {
ll a, b, c;
cin >> c;
if (c == 1) {
cin >> a >> b;
bsum += b;
if (stl.size() == 0) {
stl.insert(a);
continue;
}
ll lmx = *stl.begin();
if (a < lmx)
stl.insert(a);
else
str.insert(a);
ans += abs(lmx - a);
int lsz = stl.size(), rsz = str.size();
if (lsz == rsz + 2) {
str.insert(lmx);
stl.erase(stl.begin());
} else if (lsz + 1 == rsz) {
stl.insert(*str.begin());
str.erase(str.begin());
ans += *stl.begin() - lmx;
}
} else {
cout << *stl.begin() << ' ' << ans + bsum << '\n';
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
multiset<ll, greater<ll>> stl;
multiset<ll> str;
ll bsum = 0, ans = 0;
while (q--) {
ll a, b, c;
cin >> c;
if (c == 1) {
cin >> a >> b;
bsum += b;
if (stl.size() == 0) {
stl.insert(a);
continue;
}
ll lmx = *stl.begin();
if (a < lmx)
stl.insert(a);
else
str.insert(a);
ans += abs(lmx - a);
int lsz = stl.size(), rsz = str.size();
if (lsz == rsz + 2) {
str.insert(lmx);
stl.erase(stl.begin());
} else if (lsz + 1 == rsz) {
stl.insert(*str.begin());
str.erase(str.begin());
ans -= *stl.begin() - lmx;
}
} else {
cout << *stl.begin() << ' ' << ans + bsum << '\n';
}
}
return 0;
} | [
"expression.operator.change"
] | 854,828 | 854,829 | u334624175 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
multiset<ll, greater<ll>> stl;
multiset<ll> str;
ll bsum = 0, ans = 0;
while (q--) {
ll a, b, c;
cin >> c;
if (c == 1) {
cin >> a >> b;
bsum += b;
if (stl.size() == 0) {
stl.insert(a);
continue;
}
ll lmx = *stl.begin();
if (a < lmx)
stl.insert(a);
else
str.insert(a);
ans += abs(lmx - a);
int lsz = stl.size(), rsz = str.size();
if (lsz == rsz + 2) {
str.insert(lmx);
stl.erase(stl.begin());
} else if (lsz + 1 == rsz) {
stl.insert(*str.begin());
str.erase(str.begin());
ans += *stl.begin() - lmx;
}
} else {
cout << *stl.begin() << ' ' << ans + bsum << '\an';
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
multiset<ll, greater<ll>> stl;
multiset<ll> str;
ll bsum = 0, ans = 0;
while (q--) {
ll a, b, c;
cin >> c;
if (c == 1) {
cin >> a >> b;
bsum += b;
if (stl.size() == 0) {
stl.insert(a);
continue;
}
ll lmx = *stl.begin();
if (a < lmx)
stl.insert(a);
else
str.insert(a);
ans += abs(lmx - a);
int lsz = stl.size(), rsz = str.size();
if (lsz == rsz + 2) {
str.insert(lmx);
stl.erase(stl.begin());
} else if (lsz + 1 == rsz) {
stl.insert(*str.begin());
str.erase(str.begin());
ans -= *stl.begin() - lmx;
}
} else {
cout << *stl.begin() << ' ' << ans + bsum << '\n';
}
}
return 0;
} | [
"expression.operator.change",
"literal.string.change",
"io.output.change"
] | 854,830 | 854,829 | u334624175 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n, m) for (int i = (n); i < (m); i++)
#define rrep(i, n, m) for (int i = (n)-1; i >= (m); i--)
using namespace std;
using ll = long long;
int main() {
int q;
ll b_sum = 0;
cin >> q;
vector<ll> a_list;
priority_queue<ll, vector<ll>, greater<ll>> left_que;
priority_queue<ll, vector<ll>, less<ll>> right_que;
ll sum_a = 0;
rep(i, 0, q) {
int t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
b_sum += b;
ll l, r;
if (left_que.size() > 0) {
l = left_que.top();
r = right_que.top();
if (a < l or r < a)
sum_a += min(abs(l - a), abs(r - a));
}
left_que.push(a);
right_que.push(a);
l = left_que.top();
r = right_que.top();
if (l > r) {
left_que.pop();
right_que.pop();
left_que.push(r);
right_que.push(l);
}
// cout << sum_a << '*' << a << ' ' << b << ' ' << min(cand1, cand2) <<
// endl;
} else {
ll med_a = left_que.top();
cout << med_a << ' ' << sum_a + b_sum << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n, m) for (int i = (n); i < (m); i++)
#define rrep(i, n, m) for (int i = (n)-1; i >= (m); i--)
using namespace std;
using ll = long long;
int main() {
int q;
ll b_sum = 0;
cin >> q;
vector<ll> a_list;
priority_queue<ll, vector<ll>, less<ll>> left_que;
priority_queue<ll, vector<ll>, greater<ll>> right_que;
ll sum_a = 0;
rep(i, 0, q) {
int t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
b_sum += b;
ll l, r;
if (left_que.size() > 0) {
l = left_que.top();
r = right_que.top();
if (a < l or r < a)
sum_a += min(abs(l - a), abs(r - a));
}
left_que.push(a);
right_que.push(a);
l = left_que.top();
r = right_que.top();
if (l > r) {
left_que.pop();
right_que.pop();
left_que.push(r);
right_que.push(l);
}
// cout << sum_a << '*' << a << ' ' << b << ' ' << min(cand1, cand2) <<
// endl;
} else {
ll med_a = left_que.top();
cout << med_a << ' ' << sum_a + b_sum << endl;
}
}
return 0;
}
| [] | 854,831 | 854,832 | u052247353 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const ll INF = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
// const int MOD = 998244353;
// Lib
//
struct FloatingMedian {
priority_queue<ll> zen;
priority_queue<ll, vector<ll>, greater<ll>> kou;
long long zensum = 0;
long long kousum = 0;
ll const med() { return zen.top(); }
void push(ll n) {
if (zen.size() > kou.size()) {
// kou に
int t = zen.top();
if (n >= t) {
kou.push(n);
kousum += n;
} else {
zen.pop();
zensum -= t;
zen.push(n);
zensum += n;
kou.push(n);
kousum += t;
}
} else {
// zen に
if (zen.empty()) {
zen.push(n);
zensum += n;
} else {
int t = kou.top();
if (n <= t) {
zen.push(n);
zensum += n;
} else {
kou.pop();
kousum -= t;
kou.push(n);
kousum += n;
zen.push(t);
zensum += t;
}
}
}
}
};
int main() {
#ifdef MYLOCAL
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
#endif
int Q;
cin >> Q;
long long sum = 0;
FloatingMedian floatingmedian;
for (int i = 0; i < Q; ++i) {
ll type;
cin >> type;
if (type == 1) {
ll a, b;
cin >> a >> b;
floatingmedian.push(a);
sum += b;
} else {
ll x = floatingmedian.med();
ll tmp1 = x * floatingmedian.zen.size() - floatingmedian.zensum;
ll tmp2 = x * floatingmedian.kou.size() - floatingmedian.kousum;
ll res = tmp1 - tmp2 + sum;
cout << x << " " << res << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const ll INF = 1LL << 60;
const int INF32 = 1 << 29;
const int MOD = 1000000007;
// const int MOD = 998244353;
// Lib
//
struct FloatingMedian {
priority_queue<ll> zen;
priority_queue<ll, vector<ll>, greater<ll>> kou;
ll zensum = 0;
ll kousum = 0;
ll const med() { return zen.top(); }
void push(ll n) {
if (zen.size() > kou.size()) {
// kou に
int t = zen.top();
if (n >= t) {
kou.push(n);
kousum += n;
} else {
zen.pop();
zensum -= t;
zen.push(n);
zensum += n;
kou.push(t);
kousum += t;
}
} else {
// zen に
if (zen.empty()) {
zen.push(n);
zensum += n;
} else {
int t = kou.top();
if (n <= t) {
zen.push(n);
zensum += n;
} else {
kou.pop();
kousum -= t;
kou.push(n);
kousum += n;
zen.push(t);
zensum += t;
}
}
}
}
};
int main() {
#ifdef MYLOCAL
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
#endif
int Q;
cin >> Q;
long long sum = 0;
FloatingMedian floatingmedian;
for (int i = 0; i < Q; ++i) {
ll type;
cin >> type;
if (type == 1) {
ll a, b;
cin >> a >> b;
floatingmedian.push(a);
sum += b;
} else {
ll x = floatingmedian.med();
ll tmp1 = x * floatingmedian.zen.size() - floatingmedian.zensum;
ll tmp2 = x * floatingmedian.kou.size() - floatingmedian.kousum;
ll res = tmp1 - tmp2 + sum;
cout << x << " " << res << endl;
}
}
return 0;
}
| [
"variable_declaration.type.narrow.change",
"identifier.change",
"call.arguments.change"
] | 854,833 | 854,834 | u335667012 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
int main() {
int Q;
cin >> Q;
i64 mid = 0, left_sum = 0, right_sum = 0, b_sum = 0;
priority_queue<i64> left;
priority_queue<i64, vector<i64>, greater<i64>> right;
i64 q, a, b;
cin >> q >> a >> b;
b_sum += b;
mid = a;
bool flag = true;
for (int i = 1; i < Q; ++i) {
cin >> q;
if (q == 1) {
flag = !flag;
cin >> a >> b;
b_sum += b;
if (a >= mid) {
right.push(a);
right_sum += a;
if (flag) {
left.push(mid);
left_sum += mid;
mid = right.top();
right.pop();
right_sum -= mid;
}
} else {
left.push(a);
left_sum += a;
if (!flag) {
right.push(mid);
right_sum += mid;
mid = left.top();
left.pop();
left_sum -= mid;
}
}
} else {
if (flag) {
cout << mid << " " << left_sum - right_sum + b_sum << endl;
} else {
i64 mid2 = right.top();
cout << mid << " "
<< left_sum - (right_sum - mid2) + (mid2 - mid) + b_sum << endl;
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
int main() {
int Q;
cin >> Q;
i64 mid = 0, left_sum = 0, right_sum = 0, b_sum = 0;
priority_queue<i64> left;
priority_queue<i64, vector<i64>, greater<i64>> right;
i64 q, a, b;
cin >> q >> a >> b;
b_sum += b;
mid = a;
bool flag = true;
for (int i = 1; i < Q; ++i) {
cin >> q;
if (q == 1) {
flag = !flag;
cin >> a >> b;
b_sum += b;
if (a >= mid) {
right.push(a);
right_sum += a;
if (flag) {
left.push(mid);
left_sum += mid;
mid = right.top();
right.pop();
right_sum -= mid;
}
} else {
left.push(a);
left_sum += a;
if (!flag) {
right.push(mid);
right_sum += mid;
mid = left.top();
left.pop();
left_sum -= mid;
}
}
} else {
if (flag) {
cout << mid << " " << -left_sum + right_sum + b_sum << endl;
} else {
i64 mid2 = right.top();
cout << mid << " "
<< -left_sum + (right_sum - mid2) + (mid2 - mid) + b_sum << endl;
}
}
}
return 0;
}
| [
"expression.operation.binary.add"
] | 854,835 | 854,836 | u823112986 | cpp |
p03040 | #include <bits/stdc++.h>
namespace BST {
template <typename T> struct Node {
Node *lch, *rch;
T val;
T pri;
T sum;
int cnt;
Node() {}
Node(T val, T pri)
: lch(nullptr), rch(nullptr), val(val), pri(pri), sum(val), cnt(1) {}
};
template <typename T> struct NodePool {
std::vector<Node<T>> v;
std::mt19937 engine;
std::uniform_int_distribution<T> dist;
int pos;
NodePool(int size)
: v(size),
engine(std::chrono::steady_clock::now().time_since_epoch().count()),
dist(std::numeric_limits<T>::min(), std::numeric_limits<T>::max()),
pos(0) {}
Node<T> *alloc(T val) { return &(v[pos++] = Node<T>(val, dist(engine))); }
};
template <typename T> int count(Node<T> *t) { return t ? t->cnt : 0; }
template <typename T> int sum(Node<T> *t) { return t ? t->sum : 0; }
template <typename T> Node<T> *update(Node<T> *t) {
t->cnt = count(t->lch) + count(t->rch) + 1;
t->sum = sum(t->lch) + sum(t->rch) + t->val;
return t;
}
template <typename T> Node<T> *merge(Node<T> *l, Node<T> *r) {
if (!l || !r)
return l ? l : r;
if (l->pri > r->pri) {
l->rch = merge(l->rch, r);
return update(l);
} else {
r->lch = merge(l, r->lch);
return update(r);
}
}
// count-based: [0, k), [k, n)
template <typename T> std::pair<Node<T> *, Node<T> *> split(Node<T> *t, int k) {
if (!t)
return {nullptr, nullptr};
if (k <= count(t->lch)) {
auto s = split(t->lch, k);
t->lch = s.second;
return {s.first, update(t)};
} else {
auto s = split(t->rch, k - count(t->lch) - 1);
t->rch = s.first;
return {update(t), s.second};
}
}
template <typename T> T kth_element(Node<T> *t, const int k) {
if (!t)
return std::numeric_limits<T>::max();
if (k == count(t->lch))
return t->val;
if (k < count(t->lch))
return kth_element(t->lch, k);
else
return kth_element(t->rch, k - count(t->lch) - 1);
}
// returns index of lower_bound of x in t
template <typename T> int lower_bound(const Node<T> *const t, const T x) {
if (!t)
return 0;
if (x <= t->val)
return lower_bound(t->lch, x);
else
return count(t->lch) + 1 + lower_bound(t->rch, x);
}
template <typename T> int upper_bound(const Node<T> *const t, const T x) {
if (!t)
return 0;
if (x < t->val)
return upper_bound(t->lch, x);
else
return count(t->lch) + 1 + upper_bound(t->rch, x);
}
template <typename T> struct BinarySearchTree {
NodePool<T> pool;
Node<T> *root;
BinarySearchTree(int size) : pool(size), root(nullptr) {}
T kth_element(int k) const { return BST::kth_element(root, k); }
int size() const { return count(root); }
T sum(int a, int b) {
// [a, b)
auto s = split(root, a);
auto t = split(s.second, b - a);
auto ret = BST::sum(t.first);
root = merge(s.first, merge(t.first, t.second));
return ret;
}
};
// template <typename T>
// struct Treap : BinarySearchTree<T> {
// Treap(int size) : BinarySearchTree<T>(size) {}
// void insert(int k, T val) {
// auto s = split(root, k);
// root = merge(merge(s.first, pool.alloc(val)), s.second);
// }
// void erase(int k) {
// auto s = split(root, k);
// auto t = split(s, 1);
// root = merge(s.first, t.second);
// }
// };
template <typename T> struct OrderedMultiSet : public BinarySearchTree<T> {
OrderedMultiSet(int size) : BinarySearchTree<T>(size) {}
int count(const T val) const {
return upper_bound(this->root, val) - lower_bound(this->root, val);
}
void insert(const T val) {
int k = lower_bound(this->root, val);
auto s = split(this->root, k);
this->root = merge(merge(s.first, this->pool.alloc(val)), s.second);
}
void erase(const T val) {
int lb = lower_bound(this->root, val), ub = upper_bound(this->root, val);
if (lb == ub)
return;
auto s = split(this->root, lb);
auto t = split(s, ub - lb);
this->root = merge(s.first, t.second);
}
};
} // namespace BST
using i64 = long long;
using Tree = BST::OrderedMultiSet<i64>;
int main() {
int q;
std::cin >> q;
i64 sb = 0, sa = 0;
Tree tree(202020);
while (q--) {
int t;
std::cin >> t;
if (t == 1) {
i64 a, b;
std::cin >> a >> b;
sa += a;
sb += b;
tree.insert(a);
} else {
int c = tree.size();
i64 m = (c - 1) / 2;
auto x = tree.kth_element(m);
auto sl = tree.sum(0, m + 1);
auto sr = sa - sl;
auto ss = (m + 1) * x - sl + sr - (c - m - 1) * x;
std::cout << x << " " << ss + sb << std::endl;
}
}
} | #include <bits/stdc++.h>
namespace BST {
template <typename T> struct Node {
Node *lch, *rch;
T val;
T pri;
T sum;
int cnt;
Node() {}
Node(T val, T pri)
: lch(nullptr), rch(nullptr), val(val), pri(pri), sum(val), cnt(1) {}
};
template <typename T> struct NodePool {
std::vector<Node<T>> v;
std::mt19937 engine;
std::uniform_int_distribution<T> dist;
int pos;
NodePool(int size)
: v(size),
engine(std::chrono::steady_clock::now().time_since_epoch().count()),
dist(std::numeric_limits<T>::min(), std::numeric_limits<T>::max()),
pos(0) {}
Node<T> *alloc(T val) { return &(v[pos++] = Node<T>(val, dist(engine))); }
};
template <typename T> int count(Node<T> *t) { return t ? t->cnt : 0; }
template <typename T> T sum(Node<T> *t) { return t ? t->sum : 0; }
template <typename T> Node<T> *update(Node<T> *t) {
t->cnt = count(t->lch) + count(t->rch) + 1;
t->sum = sum(t->lch) + sum(t->rch) + t->val;
return t;
}
template <typename T> Node<T> *merge(Node<T> *l, Node<T> *r) {
if (!l || !r)
return l ? l : r;
if (l->pri > r->pri) {
l->rch = merge(l->rch, r);
return update(l);
} else {
r->lch = merge(l, r->lch);
return update(r);
}
}
// count-based: [0, k), [k, n)
template <typename T> std::pair<Node<T> *, Node<T> *> split(Node<T> *t, int k) {
if (!t)
return {nullptr, nullptr};
if (k <= count(t->lch)) {
auto s = split(t->lch, k);
t->lch = s.second;
return {s.first, update(t)};
} else {
auto s = split(t->rch, k - count(t->lch) - 1);
t->rch = s.first;
return {update(t), s.second};
}
}
template <typename T> T kth_element(Node<T> *t, const int k) {
if (!t)
return std::numeric_limits<T>::max();
if (k == count(t->lch))
return t->val;
if (k < count(t->lch))
return kth_element(t->lch, k);
else
return kth_element(t->rch, k - count(t->lch) - 1);
}
// returns index of lower_bound of x in t
template <typename T> int lower_bound(const Node<T> *const t, const T x) {
if (!t)
return 0;
if (x <= t->val)
return lower_bound(t->lch, x);
else
return count(t->lch) + 1 + lower_bound(t->rch, x);
}
template <typename T> int upper_bound(const Node<T> *const t, const T x) {
if (!t)
return 0;
if (x < t->val)
return upper_bound(t->lch, x);
else
return count(t->lch) + 1 + upper_bound(t->rch, x);
}
template <typename T> struct BinarySearchTree {
NodePool<T> pool;
Node<T> *root;
BinarySearchTree(int size) : pool(size), root(nullptr) {}
T kth_element(int k) const { return BST::kth_element(root, k); }
int size() const { return count(root); }
T sum(int a, int b) {
// [a, b)
auto s = split(root, a);
auto t = split(s.second, b - a);
auto ret = BST::sum(t.first);
root = merge(s.first, merge(t.first, t.second));
return ret;
}
};
// template <typename T>
// struct Treap : BinarySearchTree<T> {
// Treap(int size) : BinarySearchTree<T>(size) {}
// void insert(int k, T val) {
// auto s = split(root, k);
// root = merge(merge(s.first, pool.alloc(val)), s.second);
// }
// void erase(int k) {
// auto s = split(root, k);
// auto t = split(s, 1);
// root = merge(s.first, t.second);
// }
// };
template <typename T> struct OrderedMultiSet : public BinarySearchTree<T> {
OrderedMultiSet(int size) : BinarySearchTree<T>(size) {}
int count(const T val) const {
return upper_bound(this->root, val) - lower_bound(this->root, val);
}
void insert(const T val) {
int k = lower_bound(this->root, val);
auto s = split(this->root, k);
this->root = merge(merge(s.first, this->pool.alloc(val)), s.second);
}
void erase(const T val) {
int lb = lower_bound(this->root, val), ub = upper_bound(this->root, val);
if (lb == ub)
return;
auto s = split(this->root, lb);
auto t = split(s, ub - lb);
this->root = merge(s.first, t.second);
}
};
} // namespace BST
using i64 = long long;
using Tree = BST::OrderedMultiSet<i64>;
int main() {
int q;
std::cin >> q;
i64 sb = 0, sa = 0;
Tree tree(202020);
while (q--) {
int t;
std::cin >> t;
if (t == 1) {
i64 a, b;
std::cin >> a >> b;
sa += a;
sb += b;
tree.insert(a);
} else {
int c = tree.size();
i64 m = (c - 1) / 2;
auto x = tree.kth_element(m);
auto sl = tree.sum(0, m + 1);
auto sr = sa - sl;
auto ss = (m + 1) * x - sl + sr - (c - m - 1) * x;
std::cout << x << " " << ss + sb << std::endl;
}
}
}
| [] | 854,839 | 854,840 | u876875284 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
#define range(i, r) for (int i = 0; i < r; i++)
#define ranges(i, l, r) for (int i = l; i < r; i++)
#define vv(a, b, c, d) vector<vector<d>>(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int>>
#define vvl std::vector<std::vector<ll>>
#define MODs 1000000007;
#define MODn 1000000009;
typedef long long int ll;
using namespace std;
ll ans = 0;
multiset<ll> A, B;
void go(ll a) {
if (A.size() == 0) {
A.insert(a);
B.insert(a);
} else {
auto ita = A.end();
ita--;
if (*B.begin() <= a) {
ll after = *B.begin();
ans += a - after;
A.insert(*B.begin());
B.erase(*B.begin());
B.insert(a);
B.insert(a);
} else if (*ita >= a) {
ll before = *ita;
B.insert(*ita);
A.erase(*ita);
A.insert(a);
A.insert(a);
ans += before - a;
} else {
A.insert(a);
B.insert(a);
}
}
}
int main(int argc, char const *argv[]) {
ll Q, x, a, b;
ll bsum = 0;
std::cin >> Q;
for (int i = 0; i < Q; i++) {
std::cin >> x;
if (x == 1) {
std::cin >> a >> b;
bsum += b;
go(a);
} else {
auto ita = A.end();
ita--;
std::cout << *ita << " " << ans + bsum << '\n';
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
#define range(i, r) for (int i = 0; i < r; i++)
#define ranges(i, l, r) for (int i = l; i < r; i++)
#define vv(a, b, c, d) vector<vector<d>>(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int>>
#define vvl std::vector<std::vector<ll>>
#define MODs 1000000007;
#define MODn 1000000009;
typedef long long int ll;
using namespace std;
ll ans = 0;
multiset<ll> A, B;
void go(ll a) {
if (A.size() == 0) {
A.insert(a);
B.insert(a);
} else {
auto ita = A.end();
ita--;
if (*B.begin() <= a) {
ll after = *B.begin();
ans += a - after;
A.insert(*B.begin());
B.erase(B.begin());
B.insert(a);
B.insert(a);
} else if (*ita >= a) {
ll before = *ita;
B.insert(*ita);
A.erase(ita);
A.insert(a);
A.insert(a);
ans += before - a;
} else {
A.insert(a);
B.insert(a);
}
}
}
int main(int argc, char const *argv[]) {
ll Q, x, a, b;
ll bsum = 0;
std::cin >> Q;
for (int i = 0; i < Q; i++) {
std::cin >> x;
if (x == 1) {
std::cin >> a >> b;
bsum += b;
go(a);
} else {
auto ita = A.end();
ita--;
std::cout << *ita << " " << ans + bsum << '\n';
}
}
// std::cout << A.size() << B.size() << '\n';
return 0;
}
| [
"call.arguments.change"
] | 854,846 | 854,847 | u816587940 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = (0); i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
cin >> Q;
ll sm = 0;
priority_queue<ll> mpq;
priority_queue<ll, vector<ll>, greater<ll>> ppq;
ll msm = 0;
ll psm = 0;
rep(_, Q) {
int u;
cin >> u;
if (u == 1) {
ll a, b;
cin >> a >> b;
sm += b;
if (mpq.size() > ppq.size()) {
ll t = mpq.top();
if (a >= t) {
ppq.push(a);
psm += a;
} else {
mpq.pop();
msm -= t;
mpq.push(a);
msm += a;
ppq.push(t);
psm += t;
}
} else {
if (mpq.empty()) {
mpq.push(a);
msm += a;
} else {
ll t = ppq.top();
if (a <= t) {
ppq.push(a);
psm += a;
} else {
ppq.pop();
psm -= t;
ppq.push(a);
psm += a;
mpq.push(t);
msm += t;
}
}
}
} else {
ll x = mpq.top();
ll res = (x * (int)mpq.size() - msm) + (psm - x * (int)ppq.size()) + sm;
cout << x << " " << res << endl;
}
}
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = (0); i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int Q;
cin >> Q;
ll sm = 0;
priority_queue<ll> mpq;
priority_queue<ll, vector<ll>, greater<ll>> ppq;
ll msm = 0;
ll psm = 0;
rep(_, Q) {
int u;
cin >> u;
if (u == 1) {
ll a, b;
cin >> a >> b;
sm += b;
if (mpq.size() > ppq.size()) {
ll t = mpq.top();
if (a >= t) {
ppq.push(a);
psm += a;
} else {
mpq.pop();
msm -= t;
mpq.push(a);
msm += a;
ppq.push(t);
psm += t;
}
} else {
if (mpq.empty()) {
mpq.push(a);
msm += a;
} else {
ll t = ppq.top();
if (a <= t) {
mpq.push(a);
msm += a;
} else {
ppq.pop();
psm -= t;
ppq.push(a);
psm += a;
mpq.push(t);
msm += t;
}
}
}
} else {
ll x = mpq.top();
ll res = (x * (ll)mpq.size() - msm) + (psm - x * (ll)ppq.size()) + sm;
cout << x << " " << res << endl;
}
}
}
| [
"call.function.change",
"assignment.variable.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,852 | 854,853 | u755830696 | cpp |
p03040 | #include <iostream>
#include <set>
using namespace std;
int main() {
int q;
cin >> q;
long A = 0, B = 0;
multiset<int> ls, rs;
while (q--) {
int flag;
cin >> flag;
flag--;
if (flag) {
cout << *ls.rbegin() << ' ' << A + B << endl;
} else {
int a, b;
cin >> a >> b;
int precenter = a;
if (ls.size() != 0)
precenter = *ls.rbegin();
B += b;
if (ls.size() == 0)
ls.insert(a);
else if (a <= *ls.rbegin()) {
ls.insert(a);
if (ls.size() - 1 > rs.size()) {
rs.insert(*ls.rbegin());
auto itr = ls.end();
itr--;
ls.erase(itr);
}
} else {
rs.insert(a);
if (ls.size() < rs.size()) {
ls.insert(*rs.begin());
rs.erase(rs.begin());
}
}
A += abs(a - *ls.rbegin());
if (ls.size() & rs.size() == 0)
A += precenter - *ls.rbegin();
}
}
}
| #include <iostream>
#include <set>
using namespace std;
int main() {
int q;
cin >> q;
long A = 0, B = 0;
multiset<int> ls, rs;
while (q--) {
int flag;
cin >> flag;
flag--;
if (flag) {
cout << *ls.rbegin() << ' ' << A + B << endl;
} else {
int a, b;
cin >> a >> b;
int precenter = a;
if (ls.size() != 0)
precenter = *ls.rbegin();
B += b;
if (ls.size() == 0)
ls.insert(a);
else if (a <= *ls.rbegin()) {
ls.insert(a);
if (ls.size() - 1 > rs.size()) {
rs.insert(*ls.rbegin());
auto itr = ls.end();
itr--;
ls.erase(itr);
}
} else {
rs.insert(a);
if (ls.size() < rs.size()) {
ls.insert(*rs.begin());
rs.erase(rs.begin());
}
}
A += abs(a - *ls.rbegin());
if (ls.size() == rs.size())
A += precenter - *ls.rbegin();
}
}
}
| [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 854,854 | 854,855 | u687548330 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#define llint long long int
int main(void) {
int q;
std::cin >> q;
std::multiset<llint> lower;
std::multiset<llint> upper;
llint center = 1e12;
llint a_distance = 0;
llint b_total = 0;
for (int i = 0; i < q; i++) {
llint patt;
std::cin >> patt;
if (patt == 1) {
llint a, b;
std::cin >> a >> b;
b_total += b;
if (center == 1e12) {
center = a;
} else if (center < a) {
a_distance += a - center;
upper.insert(a);
} else {
a_distance += center - a;
lower.insert(a);
}
if (upper.size() > lower.size() + 1) {
llint prev_center = center;
lower.insert(center);
center = *(upper.begin());
upper.erase(upper.begin());
a_distance +=
(center - prev_center) * (lower.size() - 1 - upper.size());
} else if (upper.size() < lower.size()) {
llint prev_center = center;
upper.insert(center);
center = *(lower.rbegin());
lower.erase(std::prev(lower.end()));
a_distance +=
(prev_center - center) * (upper.size() + 1 - lower.size());
}
} else {
// output
std::cout << center << " " << a_distance + b_total << std::endl;
}
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#define llint long long int
int main(void) {
int q;
std::cin >> q;
std::multiset<llint> lower;
std::multiset<llint> upper;
llint center = 1e12;
llint a_distance = 0;
llint b_total = 0;
for (int i = 0; i < q; i++) {
llint patt;
std::cin >> patt;
if (patt == 1) {
llint a, b;
std::cin >> a >> b;
b_total += b;
if (center == 1e12) {
center = a;
} else if (center < a) {
a_distance += a - center;
upper.insert(a);
} else {
a_distance += center - a;
lower.insert(a);
}
if (upper.size() > lower.size() + 1) {
llint prev_center = center;
lower.insert(center);
center = *(upper.begin());
upper.erase(upper.begin());
a_distance +=
(center - prev_center) * (lower.size() - 1 - upper.size());
} else if (upper.size() < lower.size()) {
llint prev_center = center;
upper.insert(center);
center = *(lower.rbegin());
lower.erase(std::prev(lower.end()));
a_distance +=
(prev_center - center) * (upper.size() - lower.size() - 1);
}
} else {
// output
std::cout << center << " " << a_distance + b_total << std::endl;
// std::cout << a_distance << " " << b_total << std::endl;
}
}
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 854,857 | 854,858 | u679906187 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int q, t, a, b;
ll ans;
priority_queue<int> low;
priority_queue<int, vector<int>, greater<int>> high;
int main() {
scanf("%d%d%d%d", &q, &t, &a, &b);
ans += b;
low.push(a);
for (int i = 0; i < q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &a, &b);
ans += (ll)b + abs(low.top() - a);
if (a < low.top())
low.push(a);
else
high.push(a);
if (low.size() > high.size() + 1) {
high.push(low.top());
low.pop();
} else if (low.size() < high.size()) {
ans -= high.top() - low.top();
low.push(high.top());
high.pop();
}
} else
printf("%d %lld\n", low.top(), ans);
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int q, t, a, b;
ll ans;
priority_queue<int> low;
priority_queue<int, vector<int>, greater<int>> high;
int main() {
scanf("%d%d%d%d", &q, &t, &a, &b);
ans += b;
low.push(a);
for (int i = 0; i < q - 1; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &a, &b);
ans += (ll)b + abs(low.top() - a);
if (a < low.top())
low.push(a);
else
high.push(a);
if (low.size() > high.size() + 1) {
high.push(low.top());
low.pop();
} else if (low.size() < high.size()) {
ans -= high.top() - low.top();
low.push(high.top());
high.pop();
}
} else
printf("%d %lld\n", low.top(), ans);
}
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 854,861 | 854,862 | u309985845 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define MP make_pair
#define PB push_back
#define inf 1000000007
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int q;
cin >> q;
set<ll> st;
map<ll, int> mp;
ll sm = 0;
ll mid = 0;
ll s = 0;
int p = 1;
int cnt = -1;
rep(zz, q) {
int sss;
cin >> sss;
if (sss == 1) {
cnt++;
ll a, b;
cin >> a >> b;
sm += b;
st.insert(a);
mp[a]++;
if (zz == 0) {
mid = a;
} else {
if (mid <= a) {
if (cnt % 2 == 1) {
s += a - mid;
} else {
s += a - mid;
auto itr = st.lower_bound(mid);
if (p + 1 > mp[a]) {
ll pp = mid;
p = 1;
itr++;
mid = *itr;
s -= mid - pp;
} else {
p++;
}
}
} else {
s += mid - a;
if (cnt % 2 == 0) {
} else {
if (p - 1 == 0) {
auto itr = st.lower_bound(mid);
itr--;
mid = *itr;
p = mp[mid];
} else {
p--;
}
}
}
}
} else {
cout << mid << " " << s + sm << endl;
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define MP make_pair
#define PB push_back
#define inf 1000000007
#define mod 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int q;
cin >> q;
set<ll> st;
map<ll, int> mp;
ll sm = 0;
ll mid = 0;
ll s = 0;
int p = 1;
int cnt = -1;
rep(zz, q) {
int sss;
cin >> sss;
if (sss == 1) {
cnt++;
ll a, b;
cin >> a >> b;
sm += b;
st.insert(a);
mp[a]++;
if (zz == 0) {
mid = a;
} else {
if (mid <= a) {
if (cnt % 2 == 1) {
s += a - mid;
} else {
s += a - mid;
auto itr = st.lower_bound(mid);
if (p + 1 > mp[mid]) {
ll pp = mid;
p = 1;
itr++;
mid = *itr;
s -= mid - pp;
} else {
p++;
}
}
} else {
s += mid - a;
if (cnt % 2 == 0) {
} else {
if (p - 1 == 0) {
auto itr = st.lower_bound(mid);
itr--;
mid = *itr;
p = mp[mid];
} else {
p--;
}
}
}
}
} else {
cout << mid << " " << s + sm << endl;
}
}
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 854,863 | 854,864 | u007610006 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define N 200010
multiset<int> p, q;
multiset<int>::iterator it1, it2;
int main() {
int i, j, k, t, x, y, d;
LL ans, s, s1, s2;
scanf("%d", &t);
s = 0;
s1 = 0;
s2 = 0;
d = 0;
while (t--) {
scanf("%d", &k);
if (k == 1) {
scanf("%d%d", &x, &y);
d++;
if (d % 2) {
if (d == 1) {
q.insert(x);
s2 = s2 + x;
} else {
it1 = p.end();
it1--;
j = *it1;
if (x < j) {
q.erase(j);
s2 = s2 + j;
p.erase(it1);
s1 = s1 - j;
p.insert(x);
s1 = s1 + x;
} else {
q.insert(x);
s2 = s2 + x;
}
}
} else {
it2 = q.begin();
j = *it2;
if (x > j) {
p.insert(j);
s1 = s1 + j;
q.erase(it2);
s2 = s2 - j;
q.insert(x);
s2 = s2 + x;
} else {
p.insert(x);
s1 = s1 + x;
}
}
s = s + y;
} else if (k == 2) {
ans = s2 - s1 + s;
if (d % 2) {
it2 = q.begin();
j = *it2;
ans = ans - j;
printf("%d %lld\n", j, ans);
} else {
it1 = p.end();
it1--;
j = *it1;
printf("%d %lld\n", j, ans);
}
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define N 200010
multiset<int> p, q;
multiset<int>::iterator it1, it2;
int main() {
int i, j, k, t, x, y, d;
LL ans, s, s1, s2;
scanf("%d", &t);
s = 0;
s1 = 0;
s2 = 0;
d = 0;
while (t--) {
scanf("%d", &k);
if (k == 1) {
scanf("%d%d", &x, &y);
d++;
if (d % 2) {
if (d == 1) {
q.insert(x);
s2 = s2 + x;
} else {
it1 = p.end();
it1--;
j = *it1;
if (x < j) {
q.insert(j);
s2 = s2 + j;
p.erase(it1);
s1 = s1 - j;
p.insert(x);
s1 = s1 + x;
} else {
q.insert(x);
s2 = s2 + x;
}
}
} else {
it2 = q.begin();
j = *it2;
if (x > j) {
p.insert(j);
s1 = s1 + j;
q.erase(it2);
s2 = s2 - j;
q.insert(x);
s2 = s2 + x;
} else {
p.insert(x);
s1 = s1 + x;
}
}
s = s + y;
} else if (k == 2) {
ans = s2 - s1 + s;
if (d % 2) {
it2 = q.begin();
j = *it2;
ans = ans - j;
printf("%d %lld\n", j, ans);
} else {
it1 = p.end();
it1--;
j = *it1;
printf("%d %lld\n", j, ans);
}
}
}
return 0;
} | [
"call.function.change"
] | 854,865 | 854,866 | u189237887 | cpp |
p03040 | #include <cstdio>
#include <set>
int main() {
int q;
scanf("%d", &q);
long long b_sum = 0;
int n = 0;
std::multiset<int> l, r;
long long l_sum, r_sum;
int median = 0;
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int a, b;
scanf("%d %d", &a, &b);
b_sum += b;
if (n % 2 == 0) {
if (median < a) {
r.insert(a);
r_sum += a;
auto it = r.begin();
median = *it;
r.erase(it);
r_sum -= median;
} else {
l.insert(a);
l_sum += a;
auto it = l.rbegin();
median = *it;
l.erase((++it).base());
l_sum -= median;
}
} else {
if (median < a) {
l.insert(median);
l_sum += median;
r.insert(a);
r_sum += a;
} else {
l.insert(a);
l_sum += a;
r.insert(median);
r_sum += median;
median = *(l.rbegin());
}
}
n++;
} else {
printf("%d %lld\n", median, r_sum - l_sum + b_sum);
}
}
return 0;
}
| #include <cstdio>
#include <set>
int main() {
int q;
scanf("%d", &q);
long long b_sum = 0;
int n = 0;
std::multiset<int> l, r;
long long l_sum = 0, r_sum = 0;
int median = 0;
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int a, b;
scanf("%d %d", &a, &b);
b_sum += b;
if (n % 2 == 0) {
if (median < a) {
r.insert(a);
r_sum += a;
auto it = r.begin();
median = *it;
r.erase(it);
r_sum -= median;
} else {
l.insert(a);
l_sum += a;
auto it = l.rbegin();
median = *it;
l.erase((++it).base());
l_sum -= median;
}
} else {
if (median < a) {
l.insert(median);
l_sum += median;
r.insert(a);
r_sum += a;
} else {
l.insert(a);
l_sum += a;
r.insert(median);
r_sum += median;
median = *(l.rbegin());
}
}
n++;
} else {
printf("%d %lld\n", median, r_sum - l_sum + b_sum);
}
}
return 0;
}
| [
"variable_declaration.value.change"
] | 854,867 | 854,868 | u138454574 | cpp |
p03040 | #include <algorithm>
#include <cstdlib>
#include <stdio.h>
#include <vector>
using namespace std;
int main(void) {
// Your code here!
long Q;
scanf("%ld", &Q);
std::vector<long> A{0};
long x;
scanf("%ld", &x);
scanf("%ld", &A[0]);
long B;
scanf("%ld", &B);
long min = 0;
long l = 1;
for (long i = 1; i < Q; i++) {
long Query[3];
scanf("%ld", &Query[0]);
if (Query[0] == 1) {
scanf("%ld", &Query[1]);
scanf("%ld", &Query[2]);
l++;
if (l % 2 == 0) {
x = l / 2;
if (Query[1] < A[x - 1]) {
min = min + A[x - 1] - Query[1];
} else if (Query[1] > A[x]) {
min = min + Query[1] - A[x];
}
} else {
x = (l - 1) / 2;
min = min + abs(A[x] - Query[1]);
}
auto Ait = A.end();
Ait--;
if (*Ait <= Query[1]) {
A.push_back(Query[1]);
} else {
auto itr = upper_bound(A.begin(), A.end(), Query[1]);
itr = A.insert(itr, Query[1]);
}
B = B + Query[2];
} else {
x = (l - 1) / 2;
printf("%ld ", A[x]);
printf("%ld\n", min + B);
}
}
return 0;
} | #include <algorithm>
#include <cstdlib>
#include <stdio.h>
#include <vector>
using namespace std;
int main(void) {
// Your code here!
long Q;
scanf("%ld", &Q);
std::vector<long> A{0};
long x;
scanf("%ld", &x);
scanf("%ld", &A[0]);
long B;
scanf("%ld", &B);
long min = 0;
long l = 1;
for (long i = 1; i < Q; i++) {
long Query[3];
scanf("%ld", &Query[0]);
if (Query[0] == 1) {
scanf("%ld", &Query[1]);
scanf("%ld", &Query[2]);
l++;
if (l % 2 == 1) {
x = l / 2;
if (Query[1] < A[x - 1]) {
min = min + A[x - 1] - Query[1];
} else if (Query[1] > A[x]) {
min = min + Query[1] - A[x];
}
} else {
x = (l - 1) / 2;
min = min + abs(A[x] - Query[1]);
}
auto Ait = A.end();
Ait--;
if (*Ait <= Query[1]) {
A.push_back(Query[1]);
} else {
auto itr = upper_bound(A.begin(), A.end(), Query[1]);
itr = A.insert(itr, Query[1]);
}
B = B + Query[2];
} else {
x = (l - 1) / 2;
printf("%ld ", A[x]);
printf("%ld\n", min + B);
}
}
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 854,876 | 854,877 | u377265351 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
// const value
// const ll MOD = 1e9 + 7;
const ll INF = 1e15;
// const int dx[] = {0,1,0,-1};//{0,0,1,1,1,-1,-1,-1};
// const int dy[] = {1,0,-1,0};//{1,-1,0,1,-1,0,1,-1};
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline ll toLL(string s) {
ll v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, cmd;
cin >> n;
priority_queue<ll> left_que;
priority_queue<ll, vector<ll>, greater<ll>> right_que;
ll bsum = 0;
ll leftSum = 0;
ll rightSum = 0;
rep(query, n) {
cin >> cmd;
if (cmd == 1) {
ll a, b;
cin >> a >> b;
bsum += b;
if (left_que.size() == 0) {
left_que.push(a);
leftSum += a;
} else if (left_que.top() > a) {
left_que.push(a);
leftSum += a;
if (left_que.size() >= 1 + right_que.size()) {
ll tmp = left_que.top();
left_que.pop();
right_que.push(tmp);
leftSum -= tmp;
rightSum += tmp;
}
} else if (left_que.top() <= a) {
right_que.push(a);
rightSum += a;
if (right_que.size() >= left_que.size()) {
ll tmp = right_que.top();
right_que.pop();
left_que.push(tmp);
rightSum -= tmp;
leftSum += tmp;
}
}
} else if (cmd == 2) {
ll mid = left_que.top();
// cout << "left " << mid * ll(left_que.size()) - leftSum << ", right " <<
// - mid * ll(right_que.size()) + rightSum << ' ' << bsum << endl; cout
// << mid << endl;
cout << mid << ' '
<< mid * ll(left_que.size()) - leftSum - mid * ll(right_que.size()) +
rightSum + bsum
<< endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
// const value
// const ll MOD = 1e9 + 7;
const ll INF = 1e15;
// const int dx[] = {0,1,0,-1};//{0,0,1,1,1,-1,-1,-1};
// const int dy[] = {1,0,-1,0};//{1,-1,0,1,-1,0,1,-1};
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline ll toLL(string s) {
ll v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, cmd;
cin >> n;
priority_queue<ll> left_que;
priority_queue<ll, vector<ll>, greater<ll>> right_que;
ll bsum = 0;
ll leftSum = 0;
ll rightSum = 0;
rep(query, n) {
cin >> cmd;
if (cmd == 1) {
ll a, b;
cin >> a >> b;
bsum += b;
if (left_que.size() == 0) {
left_que.push(a);
leftSum += a;
} else if (left_que.top() > a) {
left_que.push(a);
leftSum += a;
// cout << "left" << endl;
if (left_que.size() > (1 + right_que.size())) {
ll tmp = left_que.top();
left_que.pop();
right_que.push(tmp);
leftSum -= tmp;
rightSum += tmp;
}
} else if (left_que.top() <= a) {
// cout << "right" << endl;
right_que.push(a);
rightSum += a;
if (right_que.size() > left_que.size()) {
ll tmp = right_que.top();
right_que.pop();
left_que.push(tmp);
rightSum -= tmp;
leftSum += tmp;
}
// cout << left_que.top() << ' '<< right_que.top();
}
} else if (cmd == 2) {
ll mid = left_que.top();
// cout << "left " << mid * ll(left_que.size()) - leftSum << ", right " <<
// - mid * ll(right_que.size()) + rightSum << ' ' << bsum << endl;
// cout << mid << endl;
cout << mid << ' '
<< mid * ll(left_que.size()) - leftSum - mid * ll(right_que.size()) +
rightSum + bsum
<< endl;
}
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.add"
] | 854,878 | 854,879 | u336011173 | cpp |
p03040 | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
int a;
cin >> a;
if (a == 1) {
//更新クエリ
ll b, c;
cin >> b >> c;
B += c;
if (i == 0) {
ls.push(b), rs.push(b);
anspos = b;
} else {
ll lvalue, rvalue;
lvalue = ls.top(), rvalue = rs.top();
if (lvalue <= b && b <= rvalue) {
ls.push(b), rs.push(b);
//最小値の更新はなし
//最小値をとる場所はbに更新する
anspos = lvalue;
} else if (b < lvalue) {
ll tmp1;
rs.push(ls.top()), ls.pop();
ls.push(b), ls.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
} else {
ll tmp1;
ls.push(rs.top()), rs.pop();
rs.push(b), rs.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
}
}
} else {
//求値クエリ
cout << anspos << " " << ans + B << endl;
}
}
return 0;
} | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
int a;
cin >> a;
if (a == 1) {
//更新クエリ
ll b, c;
cin >> b >> c;
B += c;
if (i == 0) {
ls.push(b), rs.push(b);
anspos = b;
} else {
ll lvalue, rvalue;
lvalue = ls.top(), rvalue = rs.top();
if (lvalue <= b && b <= rvalue) {
ls.push(b), rs.push(b);
//最小値の更新はなし
//最小値をとる場所はbに更新する
anspos = b;
} else if (b < lvalue) {
ll tmp1;
rs.push(ls.top()), ls.pop();
ls.push(b), ls.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
} else {
ll tmp1;
ls.push(rs.top()), rs.pop();
rs.push(b), rs.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
}
}
} else {
//求値クエリ
cout << anspos << " " << ans + B << endl;
}
}
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 854,894 | 854,895 | u107077805 | cpp |
p03040 | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
int a;
cin >> a;
if (a == 1) {
//更新クエリ
ll b, c;
cin >> b >> c;
B += c;
if (i == 0) {
ls.push(b), rs.push(b);
anspos = b;
} else {
ll lvalue, rvalue;
lvalue = ls.top(), rvalue = rs.top();
if (lvalue <= b && b <= rvalue) {
ls.push(b), rs.push(b);
//最小値の更新はなし
//最小値をとる場所はbに更新する
} else if (b < lvalue) {
ll tmp1;
rs.push(ls.top()), ls.pop();
ls.push(b), ls.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
} else {
ll tmp1;
ls.push(rs.top()), rs.pop();
rs.push(b), rs.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
}
}
} else {
//求値クエリ
cout << anspos << " " << ans + B << endl;
}
}
return 0;
} | #include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int Q;
ll B = 0;
priority_queue<ll> ls;
priority_queue<ll, vector<ll>, greater<ll>> rs;
ll ans = 0;
ll anspos = 0;
int main() {
cin >> Q;
for (int i = 0; i < Q; i++) {
int a;
cin >> a;
if (a == 1) {
//更新クエリ
ll b, c;
cin >> b >> c;
B += c;
if (i == 0) {
ls.push(b), rs.push(b);
anspos = b;
} else {
ll lvalue, rvalue;
lvalue = ls.top(), rvalue = rs.top();
if (lvalue <= b && b <= rvalue) {
ls.push(b), rs.push(b);
//最小値の更新はなし
//最小値をとる場所はbに更新する
anspos = b;
} else if (b < lvalue) {
ll tmp1;
rs.push(ls.top()), ls.pop();
ls.push(b), ls.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
} else {
ll tmp1;
ls.push(rs.top()), rs.pop();
rs.push(b), rs.push(b);
//もともとの更新前の中央値番の点と今回入力された点の間で差分更新を行う
ans += min(abs(lvalue - b), abs(b - rvalue));
//最小値をとる場所は*ls.end()に更新
anspos = ls.top();
}
}
} else {
//求値クエリ
cout << anspos << " " << ans + B << endl;
}
}
return 0;
} | [
"assignment.add"
] | 854,896 | 854,895 | u107077805 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll q, ans = 0;
cin >> q;
ll b = 0;
bool f = true;
ll mid = 0, mit = 0, l = 0, r = 0;
;
priority_queue<ll> fr;
priority_queue<ll, vector<ll>, greater<ll>> ba;
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (x == 1) {
ll A, B;
cin >> A >> B;
b += B;
if (f) {
f = false;
fr.emplace(A);
mid = A;
continue;
}
mit = mid;
if ((ll)fr.size() == (ll)ba.size()) {
if (ba.top() < A) {
ba.push(A);
fr.push(ba.top());
ba.pop();
mid = fr.top();
} else {
fr.push(A);
mid = fr.top();
}
} else {
if (fr.top() > A) {
fr.push(A);
ba.push(fr.top());
fr.pop();
mid = fr.top();
} else {
ba.push(A);
mid = fr.top();
}
}
ans += abs(mit - A);
if (mit > mid) {
ans -= ((ll)fr.size()) * (mit - mid);
ans += ((ll)ba.size()) * (mit - mid);
} else if (mit < mid) {
ans -= (mid - mit) * ((ll)ba.size() + 1);
ans += (mid - mit) * ((ll)fr.size() - 1);
}
ans %= mod;
} else {
cout << fr.top() << " " << ans + b << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(), (v).end()
ll mod = 1000000007;
ll INF = 1000000099;
signed main() {
ll q, ans = 0;
cin >> q;
ll b = 0;
bool f = true;
ll mid = 0, mit = 0, l = 0, r = 0;
;
priority_queue<ll> fr;
priority_queue<ll, vector<ll>, greater<ll>> ba;
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (x == 1) {
ll A, B;
cin >> A >> B;
b += B;
if (f) {
f = false;
fr.emplace(A);
mid = A;
continue;
}
mit = mid;
if ((ll)fr.size() == (ll)ba.size()) {
if (ba.top() < A) {
ba.push(A);
fr.push(ba.top());
ba.pop();
mid = fr.top();
} else {
fr.push(A);
mid = fr.top();
}
} else {
if (fr.top() > A) {
fr.push(A);
ba.push(fr.top());
fr.pop();
mid = fr.top();
} else {
ba.push(A);
mid = fr.top();
}
}
ans += abs(mit - A);
if (mit > mid) {
ans -= ((ll)fr.size()) * (mit - mid);
ans += ((ll)ba.size()) * (mit - mid);
} else if (mit < mid) {
ans -= (mid - mit) * ((ll)ba.size() + 1);
ans += (mid - mit) * ((ll)fr.size() - 1);
}
} else {
cout << fr.top() << " " << ans + b << endl;
}
}
} | [] | 854,904 | 854,905 | u317711717 | cpp |
p03040 | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, sampah;
scanf("%d %d", &x, &sampah);
b += sampah;
if (x <= *left.rbegin()) {
left.insert(x);
left_sum += x;
if (left.size() == right.size() + 2) {
int era = *left.rbegin();
left.erase(left.find(era));
right.insert(era);
left_sum -= era;
right_sum += era;
}
} else {
right.insert(x);
right_sum += x;
if (right.size() > left.size()) {
int era = *right.begin();
right.erase(right.find(era));
left.insert(era);
right_sum -= x;
left_sum += x;
}
}
long long med = *left.rbegin();
val = (med * left.size() - left_sum) + (right_sum - med * right.size());
}
if (t == 2) {
printf("%d %lld\n", *left.rbegin(), val + b);
}
}
return 0;
} | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, sampah;
scanf("%d %d", &x, &sampah);
b += sampah;
if (x <= *left.rbegin()) {
left.insert(x);
left_sum += x;
if (left.size() == right.size() + 2) {
int era = *left.rbegin();
left.erase(left.find(era));
right.insert(era);
left_sum -= era;
right_sum += era;
}
} else {
right.insert(x);
right_sum += x;
if (right.size() > left.size()) {
int era = *right.begin();
right.erase(right.find(era));
left.insert(era);
right_sum -= era;
left_sum += era;
}
}
long long med = *left.rbegin();
val = (med * left.size() - left_sum) + (right_sum - med * right.size());
}
if (t == 2) {
printf("%d %lld\n", *left.rbegin(), val + b);
}
}
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 854,908 | 854,909 | u153798346 | cpp |
p03040 | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, sampah;
scanf("%d %d", &x, &sampah);
b += sampah;
if (x <= *left.begin()) {
left.insert(x);
left_sum += x;
if (left.size() == right.size() + 2) {
int era = *left.rbegin();
left.erase(left.find(era));
right.insert(era);
left_sum -= era;
right_sum += era;
}
} else {
right.insert(x);
right_sum += x;
if (right.size() > left.size()) {
int era = *right.begin();
right.erase(right.find(era));
left.insert(era);
right_sum -= x;
left_sum += x;
}
}
long long med = *left.rbegin();
val = (med * left.size() - left_sum) + (right_sum - med * right.size());
}
if (t == 2) {
printf("%d %lld\n", *left.rbegin(), val + b);
}
}
return 0;
} | #include <set>
#include <stdio.h>
using namespace std;
int main() {
int qq;
scanf("%d", &qq);
qq--;
int tf, xf, sampahf;
scanf("%d %d %d", &tf, &xf, &sampahf);
multiset<int> left, right;
long long val = 0, left_sum = xf, right_sum = 0, b = sampahf;
left.insert(xf);
while (qq--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, sampah;
scanf("%d %d", &x, &sampah);
b += sampah;
if (x <= *left.rbegin()) {
left.insert(x);
left_sum += x;
if (left.size() == right.size() + 2) {
int era = *left.rbegin();
left.erase(left.find(era));
right.insert(era);
left_sum -= era;
right_sum += era;
}
} else {
right.insert(x);
right_sum += x;
if (right.size() > left.size()) {
int era = *right.begin();
right.erase(right.find(era));
left.insert(era);
right_sum -= era;
left_sum += era;
}
}
long long med = *left.rbegin();
val = (med * left.size() - left_sum) + (right_sum - med * right.size());
}
if (t == 2) {
printf("%d %lld\n", *left.rbegin(), val + b);
}
}
return 0;
} | [
"call.function.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change"
] | 854,910 | 854,909 | u153798346 | cpp |
p03040 | //
// main.cpp
// absolute minima
//
// Created by Dong Truong on 5/28/19.
// Copyright © 2019 Dong Truong. All rights reserved.
//
#include <fstream>
#include <iostream>
#include <queue>
#include <stdio.h>
using namespace std;
#define maxn 1000001
int q, kq;
priority_queue<int, vector<int>, greater<int>> r;
priority_queue<int, vector<int>, less<int>> l;
void xuly(int a) {
l.push(a);
r.push(a);
int x = l.top(), y = r.top();
if (x > y) {
l.pop();
r.pop();
kq = kq + x - y;
l.push(y);
r.push(x);
}
}
void sol() {
cin >> q;
int64_t i = 1;
while (i <= q) {
int o;
cin >> o;
if (o == 1) {
int a, b;
cin >> a >> b;
kq += b;
xuly(a);
} else {
// if ( (l.size()+r.size()) % 2 == 1)
cout << l.top() << " " << kq << "\n";
}
++i;
}
}
int main(int argc, const char *argv[]) {
// insert code here...
// std::cout << "Hello, World!\n";
// freopen("a.inp","r",stdin);
sol();
return 0;
}
| //
// main.cpp
// absolute minima
//
// Created by Dong Truong on 5/28/19.
// Copyright © 2019 Dong Truong. All rights reserved.
//
#include <fstream>
#include <iostream>
#include <queue>
#include <stdio.h>
using namespace std;
#define maxn 1000001
int q;
int64_t kq;
priority_queue<int, vector<int>, greater<int>> r;
priority_queue<int, vector<int>, less<int>> l;
void xuly(int a) {
l.push(a);
r.push(a);
int x = l.top(), y = r.top();
if (x > y) {
l.pop();
r.pop();
kq = kq + x - y;
l.push(y);
r.push(x);
}
}
void sol() {
cin >> q;
int64_t i = 1;
while (i <= q) {
int o;
cin >> o;
if (o == 1) {
int a, b;
cin >> a >> b;
kq += b;
xuly(a);
} else {
// if ( (l.size()+r.size()) % 2 == 1)
cout << l.top() << " " << kq << "\n";
}
++i;
}
}
int main(int argc, const char *argv[]) {
// insert code here...
// std::cout << "Hello, World!\n";
// freopen("a.inp","r",stdin);
sol();
return 0;
}
| [
"variable_declaration.type.change"
] | 854,913 | 854,914 | u293313826 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
priority_queue<long long, vector<long long>, greater<long long>> q2; //后半部分
priority_queue<long long, vector<long long>, less<long long>> q1; //前半部分
long long sum1, sum2; // qian hou
int main() {
long long sum1 = 0, sum2 = 0;
long long num = 0;
int op;
int q;
scanf("%d", &q);
while (q--) {
scanf("%d", &op);
if (op == 1) {
long long temp1, temp2;
scanf("%lld%lld", &temp1, &temp2);
num += temp2;
if (!q1.size() || temp1 <= q1.top())
q1.push(temp1), sum1 += temp1;
else
q2.push(temp1), sum2 += temp2;
//维持均匀
while (q1.size() < q2.size()) {
// cout<<"1";
long long temp;
temp = q2.top();
q2.pop();
q1.push(temp);
sum2 -= temp;
sum1 += temp;
}
while (q1.size() - 1 > q2.size()) {
// cout<<"2";
long long temp;
temp = q1.top();
q1.pop();
q2.push(temp);
sum1 -= temp;
sum2 += temp;
}
} else {
long long sum = q1.size() + q2.size();
long long ans;
if (q1.size() && q2.size())
ans = 1LL * q1.top() * q1.size() - sum1 + sum2 - q1.top() * q2.size() +
num;
else if (q1.size()) {
ans = num;
}
// cout<<num<<" ";
// cout<<sum1<<" "<<sum2<<q1.size()<<" "<<q2.size()<<endl;
printf("%lld %lld\n", q1.top(), ans);
}
}
}
| #include <bits/stdc++.h>
using namespace std;
priority_queue<long long, vector<long long>, greater<long long>> q2; //后半部分
priority_queue<long long, vector<long long>, less<long long>> q1; //前半部分
long long sum1, sum2; // qian hou
int main() {
long long sum1 = 0, sum2 = 0;
long long num = 0;
int op;
int q;
scanf("%d", &q);
while (q--) {
scanf("%d", &op);
if (op == 1) {
long long temp1, temp2;
scanf("%lld%lld", &temp1, &temp2);
num += temp2;
if (!q1.size() || temp1 < q1.top())
q1.push(temp1), sum1 += temp1;
else
q2.push(temp1), sum2 += temp1;
//维持均匀
while (q1.size() < q2.size()) {
// cout<<"*";
long long temp;
temp = q2.top();
q2.pop();
q1.push(temp);
sum2 -= temp;
sum1 += temp;
}
while (q1.size() - 1 > q2.size()) {
// cout<<"2";
long long temp;
temp = q1.top();
q1.pop();
q2.push(temp);
sum1 -= temp;
sum2 += temp;
}
} else {
long long sum = q1.size() + q2.size();
long long ans;
if (q1.size() && q2.size())
ans = 1LL * q1.top() * q1.size() - sum1 + sum2 - q1.top() * q2.size() +
num;
else if (q1.size()) {
ans = num;
}
// cout<<num<<" ";
// cout<<sum1<<" "<<sum2<<q1.size()<<" "<<q2.size()<<endl;
printf("%lld %lld\n", q1.top(), ans);
}
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change"
] | 854,915 | 854,916 | u818518063 | cpp |
p03040 | #include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
template <class Tp, class BinaryOperation1, class BinaryOperation2>
class segment_tree {
public:
using binary_operation1 = BinaryOperation1;
using binary_operation2 = BinaryOperation2;
using value_type = Tp;
private:
std::vector<value_type> c;
size_t m = 1;
binary_operation1 op1; // aggregate
binary_operation2 op2; // update
void init_resize(size_t n) {
m = 2 * n;
c.resize(m);
}
void init_aggregate() {
for (size_t i = m / 2; i-- > 1;)
c[i] = op1(c[i << 1], c[i << 1 | 1]);
}
public:
segment_tree(size_t n, BinaryOperation1 op1 = BinaryOperation1(),
BinaryOperation2 op2 = BinaryOperation2())
: op1(op1), op2(op2) {
init_resize(n);
c.assign(m, op1.identity);
}
segment_tree(size_t n, const Tp &e, BinaryOperation1 op1 = BinaryOperation1(),
BinaryOperation2 op2 = BinaryOperation2())
: op1(op1), op2(op2) {
init_resize(n);
for (size_t i = m / 2; i < m; ++i)
c[i] = e;
init_aggregate();
}
template <class ForwardIt>
segment_tree(ForwardIt first, ForwardIt last,
BinaryOperation1 op1 = BinaryOperation1(),
BinaryOperation2 op2 = BinaryOperation2())
: op1(op1), op2(op2) {
static_assert(
std::is_convertible<typename ForwardIt::value_type, Tp>::value, "");
init_resize(std::distance(first, last));
for (size_t i = m / 2; first != last; ++i)
c[i] = *first++;
init_aggregate();
}
void update(size_t i, Tp x) {
i += m / 2;
c[i] = op2(c[i], x);
while (i > 1) {
i >>= 1;
c[i] = op1(c[i << 1], c[i << 1 | 1]);
}
}
value_type aggregate(size_t l, size_t r) const {
value_type resl = op1.identity;
value_type resr = op1.identity;
l += m / 2;
r += m / 2;
while (l < r) {
if (l & 1)
resl = op1(resl, c[l++]);
if (r & 1)
resr = op1(c[--r], resr);
size_t j = __builtin_ctzll(l | r);
l >>= j;
r >>= j;
}
return op1(resl, resr);
}
value_type operator[](size_t k) const { return c[k + m / 2]; }
};
template <typename Tp> struct add {
Tp identity = 0;
Tp operator()(Tp x, Tp y, Tp k = 1) const { return x + y * k; }
};
struct query {
int type;
intmax_t a, b;
query() = default;
query(int t) : type(t) {}
query(int t, intmax_t a, intmax_t b) : type(t), a(a), b(b) {}
};
int main() {
size_t Q;
scanf("%zu", &Q);
std::vector<std::pair<intmax_t, size_t>> xs;
std::vector<query> qs;
for (size_t i = 0; i < Q; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
intmax_t a, b;
scanf("%jd %jd", &a, &b);
qs.emplace_back(1, a, b);
xs.emplace_back(a, i);
} else if (t == 2) {
qs.emplace_back(2);
} else {
assert(false);
}
}
size_t N = xs.size();
std::sort(xs.begin(), xs.end());
std::map<size_t, size_t> enc;
std::map<size_t, intmax_t> dec;
for (size_t i = 0; i < N; ++i) {
enc[xs[i].second] = i;
dec[i] = xs[i].first;
// fprintf(stderr, "enc[%zu]: %zu, dec[%zu]: %jd\n",
// xs[i].second, i, i, xs[i].first);
}
segment_tree<intmax_t, add<intmax_t>, add<intmax_t>> sum(N);
segment_tree<size_t, add<size_t>, add<size_t>> index(N);
intmax_t bs = 0;
size_t m = 0;
for (size_t i = 0; i < Q; ++i) {
auto const &q = qs[i];
if (q.type == 1) {
bs += q.b;
// sum[enc[i]] += q.a;
// ++index[enc[i]];
sum.update(enc[i], q.a);
index.update(enc[i], 1);
++m;
} else if (q.type == 2) {
size_t lb = 0;
size_t ub = N;
size_t isu = m / 2;
if (m == 1)
isu = 1;
while (ub - lb > 1) {
size_t mid = (lb + ub) >> 1;
size_t is = index.aggregate(0, mid);
// fprintf(stderr, "m: %zu, index.agg(0, %zu): %zu\n", m, mid, is);
((is < isu) ? lb : ub) = mid;
}
// fprintf(stderr, "ub: %zu\n", ub);
intmax_t rx = dec[lb];
intmax_t left = sum.aggregate(0, lb);
intmax_t right = sum.aggregate(lb, N);
intmax_t ry = bs;
ry += right - intmax_t(index.aggregate(lb, N)) * rx;
ry += intmax_t(index.aggregate(0, lb)) * rx - left;
printf("%jd %jd\n", rx, ry);
}
// for (size_t j = 0; j < N; ++j)
// fprintf(stderr, "%jd%c", sum[j], j+1<N? ' ':'\n');
// for (size_t j = 0; j < N; ++j)
// fprintf(stderr, "%zu%c", index[j], j+1<N? ' ':'\n');
}
}
| #include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
template <class Tp, class BinaryOperation1, class BinaryOperation2>
class segment_tree {
public:
using binary_operation1 = BinaryOperation1;
using binary_operation2 = BinaryOperation2;
using value_type = Tp;
private:
std::vector<value_type> c;
size_t m = 1;
binary_operation1 op1; // aggregate
binary_operation2 op2; // update
void init_resize(size_t n) {
m = 2 * n;
c.resize(m);
}
void init_aggregate() {
for (size_t i = m / 2; i-- > 1;)
c[i] = op1(c[i << 1], c[i << 1 | 1]);
}
public:
segment_tree(size_t n, BinaryOperation1 op1 = BinaryOperation1(),
BinaryOperation2 op2 = BinaryOperation2())
: op1(op1), op2(op2) {
init_resize(n);
c.assign(m, op1.identity);
}
segment_tree(size_t n, const Tp &e, BinaryOperation1 op1 = BinaryOperation1(),
BinaryOperation2 op2 = BinaryOperation2())
: op1(op1), op2(op2) {
init_resize(n);
for (size_t i = m / 2; i < m; ++i)
c[i] = e;
init_aggregate();
}
template <class ForwardIt>
segment_tree(ForwardIt first, ForwardIt last,
BinaryOperation1 op1 = BinaryOperation1(),
BinaryOperation2 op2 = BinaryOperation2())
: op1(op1), op2(op2) {
static_assert(
std::is_convertible<typename ForwardIt::value_type, Tp>::value, "");
init_resize(std::distance(first, last));
for (size_t i = m / 2; first != last; ++i)
c[i] = *first++;
init_aggregate();
}
void update(size_t i, Tp x) {
i += m / 2;
c[i] = op2(c[i], x);
while (i > 1) {
i >>= 1;
c[i] = op1(c[i << 1], c[i << 1 | 1]);
}
}
value_type aggregate(size_t l, size_t r) const {
value_type resl = op1.identity;
value_type resr = op1.identity;
l += m / 2;
r += m / 2;
while (l < r) {
if (l & 1)
resl = op1(resl, c[l++]);
if (r & 1)
resr = op1(c[--r], resr);
size_t j = __builtin_ctzll(l | r);
l >>= j;
r >>= j;
}
return op1(resl, resr);
}
value_type operator[](size_t k) const { return c[k + m / 2]; }
};
template <typename Tp> struct add {
Tp identity = 0;
Tp operator()(Tp x, Tp y, Tp k = 1) const { return x + y * k; }
};
struct query {
int type;
intmax_t a, b;
query() = default;
query(int t) : type(t) {}
query(int t, intmax_t a, intmax_t b) : type(t), a(a), b(b) {}
};
int main() {
size_t Q;
scanf("%zu", &Q);
std::vector<std::pair<intmax_t, size_t>> xs;
std::vector<query> qs;
for (size_t i = 0; i < Q; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
intmax_t a, b;
scanf("%jd %jd", &a, &b);
qs.emplace_back(1, a, b);
xs.emplace_back(a, i);
} else if (t == 2) {
qs.emplace_back(2);
} else {
assert(false);
}
}
size_t N = xs.size();
std::sort(xs.begin(), xs.end());
std::map<size_t, size_t> enc;
std::map<size_t, intmax_t> dec;
for (size_t i = 0; i < N; ++i) {
enc[xs[i].second] = i;
dec[i] = xs[i].first;
// fprintf(stderr, "enc[%zu]: %zu, dec[%zu]: %jd\n",
// xs[i].second, i, i, xs[i].first);
}
segment_tree<intmax_t, add<intmax_t>, add<intmax_t>> sum(N);
segment_tree<size_t, add<size_t>, add<size_t>> index(N);
intmax_t bs = 0;
size_t m = 0;
for (size_t i = 0; i < Q; ++i) {
auto const &q = qs[i];
if (q.type == 1) {
bs += q.b;
// sum[enc[i]] += q.a;
// ++index[enc[i]];
sum.update(enc[i], q.a);
index.update(enc[i], 1);
++m;
} else if (q.type == 2) {
size_t lb = 0;
size_t ub = N;
size_t isu = (m + 1) / 2;
if (m == 1)
isu = 1;
while (ub - lb > 1) {
size_t mid = (lb + ub) >> 1;
size_t is = index.aggregate(0, mid);
// fprintf(stderr, "m: %zu, index.agg(0, %zu): %zu\n", m, mid, is);
((is < isu) ? lb : ub) = mid;
}
// fprintf(stderr, "ub: %zu\n", ub);
intmax_t rx = dec[lb];
intmax_t left = sum.aggregate(0, lb);
intmax_t right = sum.aggregate(lb, N);
intmax_t ry = bs;
ry += right - intmax_t(index.aggregate(lb, N)) * rx;
ry += intmax_t(index.aggregate(0, lb)) * rx - left;
printf("%jd %jd\n", rx, ry);
}
// for (size_t j = 0; j < N; ++j)
// fprintf(stderr, "%jd%c", sum[j], j+1<N? ' ':'\n');
// for (size_t j = 0; j < N; ++j)
// fprintf(stderr, "%zu%c", index[j], j+1<N? ' ':'\n');
}
}
| [] | 854,920 | 854,921 | u352499693 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int main() {
int q = read();
priority_queue<int> l;
priority_queue<int, vector<int>, greater<int>> r;
long long ans = 0;
while (q--) {
int t = read();
if (t == 1) {
int a = read(), b = read();
ans += b;
l.push(a);
r.push(a);
if (l.top() > r.top()) {
int x = l.top();
l.pop();
int y = r.top();
r.pop();
ans += abs(x - y);
l.push(y);
r.push(x);
}
} else {
printf("%d %d\n", l.top(), ans);
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int main() {
int q = read();
priority_queue<int> l;
priority_queue<int, vector<int>, greater<int>> r;
long long ans = 0;
while (q--) {
int t = read();
if (t == 1) {
int a = read(), b = read();
ans += b;
l.push(a);
r.push(a);
if (l.top() > r.top()) {
int x = l.top();
l.pop();
int y = r.top();
r.pop();
ans += abs(x - y);
l.push(y);
r.push(x);
}
} else {
printf("%d %lld\n", l.top(), ans);
}
}
return 0;
} | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 854,922 | 854,923 | u855248478 | cpp |
p03040 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007LL;
int main(void) {
ll b;
multiset<ll> a1, a2;
int Q;
cin >> Q;
ll ans = 0LL;
for (int i = 0; i < Q; i++) {
int k;
cin >> k;
if (k == 1) {
ll one, two;
cin >> one >> two;
if (a1.empty()) {
a1.insert(one);
a2.insert(one);
} else {
ll l = *(a1.rbegin()), r = *(a2.begin());
if (one < l) {
a2.insert(l);
a1.erase(--(a1.end()));
a1.insert(one);
a1.insert(one);
ans = ans + l - one;
} else if (one > r) {
a1.insert(r);
a2.erase(a2.begin());
a2.insert(one);
a2.insert(one);
ans = ans - r + one;
} else {
a1.insert(one);
a2.insert(one);
}
}
b += two;
} else {
cout << *(a1.rbegin()) << " " << ans + b << endl;
}
}
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007LL;
int main(void) {
ll b = 0LL;
multiset<ll> a1, a2;
int Q;
cin >> Q;
ll ans = 0LL;
for (int i = 0; i < Q; i++) {
int k;
cin >> k;
if (k == 1) {
ll one, two;
cin >> one >> two;
if (a1.empty()) {
a1.insert(one);
a2.insert(one);
} else {
ll l = *(a1.rbegin()), r = *(a2.begin());
if (one < l) {
a2.insert(l);
a1.erase(--(a1.end()));
a1.insert(one);
a1.insert(one);
ans = ans + l - one;
} else if (one > r) {
a1.insert(r);
a2.erase(a2.begin());
a2.insert(one);
a2.insert(one);
ans = ans - r + one;
} else {
a1.insert(one);
a2.insert(one);
}
}
b += two;
} else {
cout << *(a1.rbegin()) << " " << ans + b << endl;
}
}
return 0;
}
| [
"variable_declaration.value.change"
] | 854,926 | 854,927 | u677149117 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define se second
#define fi first
#define mk(a, b) make_pair(a, b)
typedef pair<int, int> pii;
typedef long long ll;
int N;
set<pii> st;
set<pii>::iterator ite;
ll A, B = 0;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
int k;
cin >> k;
if (k == 1) {
int a, b;
cin >> a >> b;
B += b;
if (st.empty()) {
st.insert(mk(a, i));
st.insert(mk(a, -i));
A = 0;
ite = st.begin();
} else {
if (ite->fi == a) {
st.insert(mk(a, i));
st.insert(mk(a, -i));
} else if (a < ite->fi) {
st.insert(mk(a, i));
st.insert(mk(a, -i));
ll tmp = ite->fi;
ite--;
A += labs(tmp - a);
} else {
st.insert(mk(a, i));
st.insert(mk(a, -i));
ll tmp = ite->fi;
ite++;
A += labs(tmp - a);
A += labs(ite->fi - tmp);
}
}
} else
cout << ite->fi << " " << A + B << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define se second
#define fi first
#define mk(a, b) make_pair(a, b)
typedef pair<int, int> pii;
typedef long long ll;
int N;
set<pii> st;
set<pii>::iterator ite;
ll A, B = 0;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
int k;
cin >> k;
if (k == 1) {
int a, b;
cin >> a >> b;
B += b;
if (st.empty()) {
st.insert(mk(a, i));
st.insert(mk(a, -i));
A = 0;
ite = st.begin();
} else {
if (ite->fi == a) {
st.insert(mk(a, i));
st.insert(mk(a, -i));
} else if (a < ite->fi) {
st.insert(mk(a, i));
st.insert(mk(a, -i));
ll tmp = ite->fi;
ite--;
A += labs(tmp - a);
} else {
st.insert(mk(a, i));
st.insert(mk(a, -i));
ll tmp = ite->fi;
ite++;
A += labs(tmp - a);
A -= labs(ite->fi - tmp);
}
}
} else
cout << ite->fi << " " << A + B << endl;
}
return 0;
}
| [
"expression.operator.change"
] | 854,932 | 854,933 | u205655980 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, int a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]に値はいくつあるか
int get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
int nowa = node[a];
int nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
int ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
map<ll, int> mp;
map<int, ll> rmp;
class seg2 {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<ll> node; //セグ木本体
//コンストラクタ
seg2(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, ll a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]の合計値
ll get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
int nowa = node[a];
int nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
ll ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
vector<ll> a;
vector<ll> b;
bool op[200000];
int main() {
int q;
cin >> q;
segtree seg = segtree(200001);
seg2 sumseg = seg2(200001);
fill(op, op + 200000, false);
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
ll aa, bb;
cin >> aa >> bb;
a.push_back(aa);
b.push_back(bb);
} else {
op[i] = true;
}
}
//入力
vector<ll> tmp = a;
sort(tmp.begin(), tmp.end());
//座圧
for (int i = 0; i < tmp.size(); i++) {
mp[tmp[i]] = i + 1;
rmp[i + 1] = tmp[i];
}
int cnt = 0;
ll bsum = 0;
for (int i = 0; i < q; i++) {
if (op[i]) {
ll ans = bsum;
int ind = seg.find((cnt + 1) / 2);
ans += rmp[ind] * seg.get(0, ind) - sumseg.get(0, ind) +
sumseg.get(ind, 200001) - rmp[ind] * seg.get(ind, 200001);
// cerr<<ind<<" "<<seg.get(0,ind)<<" "<<seg.get(ind,200001)<<"
// "<<sumseg.get(0,ind)<<" "<<sumseg.get(ind,200001)<<endl;
cout << rmp[ind] << " " << ans << endl;
} else {
bsum += b[cnt];
seg.update(mp[a[cnt]], 1);
sumseg.update(mp[a[cnt]], a[cnt]);
cnt++;
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, int a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]に値はいくつあるか
int get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
int nowa = node[a];
int nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
int ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
map<ll, int> mp;
map<int, ll> rmp;
class seg2 {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<ll> node; //セグ木本体
//コンストラクタ
seg2(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, ll a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]の合計値
ll get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
ll nowa = node[a];
ll nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
ll ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
vector<ll> a;
vector<ll> b;
bool op[200000];
int main() {
int q;
cin >> q;
segtree seg = segtree(200001);
seg2 sumseg = seg2(200001);
fill(op, op + 200000, false);
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
ll aa, bb;
cin >> aa >> bb;
a.push_back(aa);
b.push_back(bb);
} else {
op[i] = true;
}
}
//入力
vector<ll> tmp = a;
sort(tmp.begin(), tmp.end());
//座圧
for (int i = 0; i < tmp.size(); i++) {
mp[tmp[i]] = i + 1;
rmp[i + 1] = tmp[i];
}
int cnt = 0;
ll bsum = 0;
for (int i = 0; i < q; i++) {
if (op[i]) {
ll ans = bsum;
int ind = seg.find((cnt + 1) / 2);
ans += rmp[ind] * seg.get(0, ind) - sumseg.get(0, ind) +
sumseg.get(ind, 200001) - rmp[ind] * seg.get(ind, 200001);
// cerr<<ind<<" "<<seg.get(0,ind)<<" "<<seg.get(ind,200001)<<"
// "<<sumseg.get(0,ind)<<" "<<sumseg.get(ind,200001)<<endl;
cout << rmp[ind] << " " << ans << endl;
} else {
bsum += b[cnt];
seg.update(mp[a[cnt]], 1);
sumseg.update(mp[a[cnt]], a[cnt]);
cnt++;
}
}
return 0;
} | [
"variable_declaration.type.change"
] | 854,934 | 854,935 | u863507492 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, int a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]に値はいくつあるか
int get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
int nowa = node[a];
int nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
int ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
map<ll, int> mp;
map<int, ll> rmp;
class seg2 {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<ll> node; //セグ木本体
//コンストラクタ
seg2(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, ll a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]の合計値
int get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
int nowa = node[a];
int nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
int ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
vector<ll> a;
vector<ll> b;
bool op[200000];
int main() {
int q;
cin >> q;
segtree seg = segtree(200001);
seg2 sumseg = seg2(200001);
fill(op, op + 200000, false);
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
ll aa, bb;
cin >> aa >> bb;
a.push_back(aa);
b.push_back(bb);
} else {
op[i] = true;
}
}
//入力
vector<ll> tmp = a;
sort(tmp.begin(), tmp.end());
//座圧
for (int i = 0; i < tmp.size(); i++) {
mp[tmp[i]] = i + 1;
rmp[i + 1] = tmp[i];
}
int cnt = 0;
ll bsum = 0;
for (int i = 0; i < q; i++) {
if (op[i]) {
ll ans = bsum;
int ind = seg.find((cnt + 1) / 2);
ans += rmp[ind] * seg.get(0, ind) - sumseg.get(0, ind) +
sumseg.get(ind, 200001) - rmp[ind] * seg.get(ind, 200001);
// cerr<<ind<<" "<<seg.get(0,ind)<<" "<<seg.get(ind,200001)<<"
// "<<sumseg.get(0,ind)<<" "<<sumseg.get(ind,200001)<<endl;
cout << rmp[ind] << " " << ans << endl;
} else {
bsum += b[cnt];
seg.update(mp[a[cnt]], 1);
sumseg.update(mp[a[cnt]], a[cnt]);
cnt++;
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
class segtree {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<int> node; //セグ木本体
//コンストラクタ
segtree(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, int a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]に値はいくつあるか
int get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
int nowa = node[a];
int nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
int ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
map<ll, int> mp;
map<int, ll> rmp;
class seg2 {
public:
int depth; //セグ木の深さ(最上部が0）
int size;
vector<ll> node; //セグ木本体
//コンストラクタ
seg2(int n) {
depth = 0;
size = 1;
while (n > size) {
size *= 2;
depth++;
}
size *= 2;
node.resize(size, 0);
//最下段に値を入れたあとに、下の段から順番に値を入れる
//値を入れるには自分の子の2値を参照する
/*
for(int i=0;i<n;i++)
node[i+(1<<depth)]=v[i];
for(int i=depth-1;i>=0;i--)
node[i]=calc(node[i*2],node[i*2+1]);*/
}
//値の更新
// node[k]にaを加える
void update(int k, ll a) {
k += (1 << depth); //セグ木上のインデックスに読み替え
node[k] += a;
while (k > 1) {
k /= 2;
node[k] = node[k * 2] + node[k * 2 + 1];
}
return;
}
//値の取得
//閉区間[a,b]の合計値
ll get(int a, int b) {
a += (1 << depth);
b += (1 << depth);
if (a == b)
return node[a];
ll nowa = node[a];
ll nowb = node[b];
while (a / 2 < b / 2) {
// cerr<<depth<<" "<<a<<" "<<b<<endl;
//左側はより右側を見る
if ((a & 1) == 0)
nowa += node[a + 1];
//右側はより左側を見る
if ((b & 1) == 1)
nowb += node[b - 1];
a /= 2;
b /= 2;
}
ll ret = nowa + nowb;
return ret;
}
// n番目のノードを探す
int find(int n) {
int ret = 1;
for (int i = 0; i < depth; i++) {
// cerr<<ret-(1<<i)<<" "<<node[ret]<<endl;
if (n <= node[ret * 2])
ret = ret * 2;
else {
if (node[ret * 2 + 1] == 0)
ret = ret * 2;
else {
n -= node[ret * 2];
ret = ret * 2 + 1;
}
}
}
return ret - (1 << depth);
}
};
vector<ll> a;
vector<ll> b;
bool op[200000];
int main() {
int q;
cin >> q;
segtree seg = segtree(200001);
seg2 sumseg = seg2(200001);
fill(op, op + 200000, false);
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
ll aa, bb;
cin >> aa >> bb;
a.push_back(aa);
b.push_back(bb);
} else {
op[i] = true;
}
}
//入力
vector<ll> tmp = a;
sort(tmp.begin(), tmp.end());
//座圧
for (int i = 0; i < tmp.size(); i++) {
mp[tmp[i]] = i + 1;
rmp[i + 1] = tmp[i];
}
int cnt = 0;
ll bsum = 0;
for (int i = 0; i < q; i++) {
if (op[i]) {
ll ans = bsum;
int ind = seg.find((cnt + 1) / 2);
ans += rmp[ind] * seg.get(0, ind) - sumseg.get(0, ind) +
sumseg.get(ind, 200001) - rmp[ind] * seg.get(ind, 200001);
// cerr<<ind<<" "<<seg.get(0,ind)<<" "<<seg.get(ind,200001)<<"
// "<<sumseg.get(0,ind)<<" "<<sumseg.get(ind,200001)<<endl;
cout << rmp[ind] << " " << ans << endl;
} else {
bsum += b[cnt];
seg.update(mp[a[cnt]], 1);
sumseg.update(mp[a[cnt]], a[cnt]);
cnt++;
}
}
return 0;
} | [
"variable_declaration.type.change"
] | 854,936 | 854,935 | u863507492 | cpp |
p03040 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR_LT(i, beg, end) for (int i = beg; i < end; i++)
#define FOR_LE(i, beg, end) for (int i = beg; i <= end; i++)
#define FOR_DW(i, beg, end) for (int i = beg; end <= i; i--)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
int64_t bsum = 0;
int64_t asum = 0;
multiset<int> lefts;
multiset<int> rights;
int count = 0;
FOR_LT(i, 0, q) {
int m;
cin >> m;
if (m == 1) {
count++;
int a, b;
cin >> a >> b;
bsum += b;
if (count == 1) {
lefts.insert(a);
rights.insert(a);
} else {
int64_t diff = 0;
if (a < *lefts.rbegin() || a < *rights.begin()) {
diff = min(abs(a - *lefts.rbegin()), abs(a - *rights.begin()));
}
asum += diff;
if (a < *lefts.rbegin()) {
lefts.insert(a);
lefts.insert(a);
rights.insert(*lefts.rbegin());
auto end_it = lefts.end();
end_it--;
lefts.erase(end_it);
} else if (*rights.begin() < a) {
rights.insert(a);
rights.insert(a);
lefts.insert(*rights.begin());
rights.erase(rights.begin());
} else {
lefts.insert(a);
rights.insert(a);
}
}
} else {
cout << (*lefts.rbegin()) << " " << (bsum + asum) << endl;
}
}
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR_LT(i, beg, end) for (int i = beg; i < end; i++)
#define FOR_LE(i, beg, end) for (int i = beg; i <= end; i++)
#define FOR_DW(i, beg, end) for (int i = beg; end <= i; i--)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
int64_t bsum = 0;
int64_t asum = 0;
multiset<int> lefts;
multiset<int> rights;
int count = 0;
FOR_LT(i, 0, q) {
int m;
cin >> m;
if (m == 1) {
count++;
int a, b;
cin >> a >> b;
bsum += b;
if (count == 1) {
lefts.insert(a);
rights.insert(a);
} else {
int64_t diff = 0;
if (a < *lefts.rbegin() || *rights.begin() < a) {
diff = min(abs(a - *lefts.rbegin()), abs(a - *rights.begin()));
}
asum += diff;
if (a < *lefts.rbegin()) {
lefts.insert(a);
lefts.insert(a);
rights.insert(*lefts.rbegin());
auto end_it = lefts.end();
end_it--;
lefts.erase(end_it);
} else if (*rights.begin() < a) {
rights.insert(a);
rights.insert(a);
lefts.insert(*rights.begin());
rights.erase(rights.begin());
} else {
lefts.insert(a);
rights.insert(a);
}
}
} else {
cout << (*lefts.rbegin()) << " " << (bsum + asum) << endl;
}
}
return 0;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 854,937 | 854,938 | u862095327 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if (x % 2) {
acnt += abs(*mid - a);
if (a <= *mid)
mid--;
} else {
if (x) {
if (a >= *mid) {
auto mids = mid;
mid++;
acnt -= (*mid - *mids);
acnt += a - *mid;
} else
acnt += *mid - a;
continue;
} else {
mid = qr.begin();
}
}
} else {
cout << *mid << " " << acnt + bcnt << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if (x % 2) {
acnt += abs(*mid - a);
if (a < *mid)
mid--;
} else {
if (x) {
if (a >= *mid) {
auto mids = mid;
mid++;
acnt -= (*mid - *mids);
acnt += a - *mids;
} else
acnt += *mid - a;
continue;
} else {
mid = qr.begin();
}
}
} else {
cout << *mid << " " << acnt + bcnt << endl;
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,941 | 854,940 | u045811375 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if (x % 2) {
acnt += abs(*mid - a);
if (a < *mid)
mid--;
} else {
if (x) {
if (a > *mid) {
auto mids = mid;
mid++;
acnt -= (*mid - *mids);
acnt += a - *mid;
} else
acnt += *mid - a;
continue;
} else {
mid = qr.begin();
}
}
} else {
cout << *mid << " " << acnt + bcnt << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll Q, a, b, j, x = -1, acnt = 0, bcnt = 0;
cin >> Q;
multiset<ll> qr;
auto mid = qr.end();
for (ll i = 0; i < Q; i++) {
cin >> j;
if (j - 2) {
x++;
cin >> a >> b;
bcnt += b;
qr.insert(a);
if (x % 2) {
acnt += abs(*mid - a);
if (a < *mid)
mid--;
} else {
if (x) {
if (a >= *mid) {
auto mids = mid;
mid++;
acnt -= (*mid - *mids);
acnt += a - *mids;
} else
acnt += *mid - a;
continue;
} else {
mid = qr.begin();
}
}
} else {
cout << *mid << " " << acnt + bcnt << endl;
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,942 | 854,940 | u045811375 | cpp |
p03040 |
//#pragma GCC optimize ("-O3")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <vector>
#ifdef _MSC_VER
#include <intrin.h>
#define popcnt __popcnt64
//# define __builtin_popcount __popcnt
#else
#define popcnt __builtin_popcountll
#endif
//#include "boost/variant.hpp"
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 60;
#define rep(i, N, M) for (ll i = N, i##_len = (M); i < i##_len; ++i)
#define rep_skip(i, N, M, ...) \
for (ll i = N, i##_len = (M); i < i##_len; i += (skip))
#define rrep(i, N, M) for (ll i = (M)-1, i##_len = (N - 1); i > i##_len; --i)
#define pb push_back
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
template <int n> struct tll_impl {
using type = decltype(tuple_cat(tuple<ll>(),
declval<typename tll_impl<n - 1>::type>()));
};
template <> struct tll_impl<1> { using type = tuple<ll>; };
template <int n> using tll = typename tll_impl<n>::type;
template <class T> constexpr ll SZ(T &v) { return static_cast<ll>(v.size()); };
template <int n, typename T> struct vec_t_impl {
using type = vector<typename vec_t_impl<n - 1, T>::type>;
};
template <typename T> struct vec_t_impl<1, T> { using type = vector<T>; };
template <int n, typename T> using vec_t = typename vec_t_impl<n, T>::type;
// check
static_assert(is_same<vec_t<3, ll>, vector<vector<vector<ll>>>>::value, "");
// decompose vector into basetype and dimension.
template <typename T> struct vec_dec {
static constexpr int dim = 0;
using type = T;
};
template <typename T> struct vec_dec<vector<T>> {
static constexpr int dim = vec_dec<T>::dim + 1;
using type = typename vec_dec<T>::type;
};
static_assert(is_same<typename vec_dec<vec_t<3, ll>>::type, ll>::value, "");
static_assert(vec_dec<vec_t<3, ll>>::dim == 3, "");
template <typename T = ll> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T = ll, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
// ex: auto dp = make_v<ll>(4,5) => vector<vector<ll>> dp(4,vector<ll>(5));
// check if T is vector
template <typename T> struct is_vector : std::false_type {};
template <typename T> struct is_vector<vector<T>> : std::true_type {};
static_assert(is_vector<vector<ll>>::value == true &&
is_vector<ll>::value == false,
"");
// check if T is vector
template <typename T> struct is_pair : std::false_type {};
template <typename T, typename S>
struct is_pair<pair<T, S>> : std::true_type {};
static_assert(is_pair<pll>::value == true && is_pair<ll>::value == false, "");
template <typename T, typename V,
typename enable_if<!is_vector<T>::value, nullptr_t>::type = nullptr>
void fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V,
typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void fill_v(T &t, const V &v) {
for (auto &&x : t)
fill_v(x, v);
}
// ex: fill_v(dp, INF);
template <typename T,
typename enable_if<!is_vector<T>::value && !is_pair<T>::value,
nullptr_t>::type = nullptr>
void read_v(T &x) {
cin >> x;
}
template <typename T,
typename enable_if<is_pair<T>::value, nullptr_t>::type = nullptr>
void read_v(T &x) {
read_v(x.first);
read_v(x.second);
}
template <typename T,
typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void read_v(T &x) {
rep(i, 0, x.size()) read_v(x[i]);
}
template <typename T, typename Delim_t = string,
typename enable_if<!is_vector<T>::value, nullptr_t>::type = nullptr>
void write_v(T &x, Delim_t delim = " ") {
cout << x << delim;
}
template <typename T, typename Delim_t = string,
typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void write_v(T &x, Delim_t delim = " ") {
rep(i, 0, x.size()) write_v(x[i]);
cout << endl;
}
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
template <typename T>
using pq_greater = priority_queue<T, vector<T>, greater<T>>;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define perm(c) \
sort(all(c)); \
for (bool c##perm = 1; c##perm; c##perm = next_permutation(all(c)))
template <typename T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <typename T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
vll seq(ll i, ll j) {
vll res(j - i);
rep(k, i, j) res[k] = i + k;
return res;
}
constexpr ll POW_0(ll x, ll y) {
if (y == 0)
return 1;
if (y == 1)
return x;
if (y == 2)
return x * x;
if (y % 2 == 0)
return POW_0(POW_0(x, y / 2), 2LL);
return ((POW_0(POW_0(x, y / 2), 2LL)) * (x));
}
constexpr ll POW(ll x, ll y, ll mod = MOD) {
if (mod == 0)
return POW_0(x, y);
if (y == 0)
return 1;
if (y == 1)
return x % mod;
if (y == 2)
return x * x % mod;
if (y % 2 == 0)
return POW(POW(x, y / 2, mod), 2LL, mod) % mod;
return ((POW(POW(x, y / 2, mod), 2LL, mod)) * (x % mod)) % mod;
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void sort_by(Inputs &inputs, Functor f) {
std::sort(std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void stable_sort_by(Inputs &inputs, Functor f) {
std::stable_sort(
std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
// ============================ Header =================================
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
ll q;
cin >> q;
ll sumb = 0;
ll sumal = 0;
ll sumar = 0;
set<ll> seta;
priority_queue<ll> pql;
pq_greater<ll> pqr;
ll cent = 0;
rep(i, 0, q) {
ll flag;
cin >> flag;
if (flag == 1) {
ll a, b;
cin >> a >> b;
sumb += b;
if (i == 0) {
pql.push(a);
cent = a;
sumal += a;
} else if (pqr.size() == pql.size()) {
ll l = pql.top();
ll r = pqr.top();
if (a <= l) {
cent = max(a, l);
pql.push(a);
sumal += a;
} else {
pqr.push(a);
sumal += a;
cent = pqr.top();
pqr.pop();
pql.push(cent);
sumar -= cent;
sumal += cent;
}
} else {
ll l = pql.top();
ll r = (pqr.size() == 0 ? 0 : pqr.top());
if (a < cent) {
pql.push(a);
sumal += a;
sumal -= pql.top();
sumar += pql.top();
pqr.push(pql.top());
pql.pop();
cent = pql.top();
} else {
pqr.push(a);
sumar += a;
}
}
} else {
cout << cent << " "
<< sumb + SZ(pql) * cent - sumal + sumar - SZ(pqr) * cent << endl;
}
}
return 0;
}
|
//#pragma GCC optimize ("-O3")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <vector>
#ifdef _MSC_VER
#include <intrin.h>
#define popcnt __popcnt64
//# define __builtin_popcount __popcnt
#else
#define popcnt __builtin_popcountll
#endif
//#include "boost/variant.hpp"
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 60;
#define rep(i, N, M) for (ll i = N, i##_len = (M); i < i##_len; ++i)
#define rep_skip(i, N, M, ...) \
for (ll i = N, i##_len = (M); i < i##_len; i += (skip))
#define rrep(i, N, M) for (ll i = (M)-1, i##_len = (N - 1); i > i##_len; --i)
#define pb push_back
typedef pair<double, double> pd;
typedef pair<ll, ll> pll;
template <int n> struct tll_impl {
using type = decltype(tuple_cat(tuple<ll>(),
declval<typename tll_impl<n - 1>::type>()));
};
template <> struct tll_impl<1> { using type = tuple<ll>; };
template <int n> using tll = typename tll_impl<n>::type;
template <class T> constexpr ll SZ(T &v) { return static_cast<ll>(v.size()); };
template <int n, typename T> struct vec_t_impl {
using type = vector<typename vec_t_impl<n - 1, T>::type>;
};
template <typename T> struct vec_t_impl<1, T> { using type = vector<T>; };
template <int n, typename T> using vec_t = typename vec_t_impl<n, T>::type;
// check
static_assert(is_same<vec_t<3, ll>, vector<vector<vector<ll>>>>::value, "");
// decompose vector into basetype and dimension.
template <typename T> struct vec_dec {
static constexpr int dim = 0;
using type = T;
};
template <typename T> struct vec_dec<vector<T>> {
static constexpr int dim = vec_dec<T>::dim + 1;
using type = typename vec_dec<T>::type;
};
static_assert(is_same<typename vec_dec<vec_t<3, ll>>::type, ll>::value, "");
static_assert(vec_dec<vec_t<3, ll>>::dim == 3, "");
template <typename T = ll> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T = ll, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
// ex: auto dp = make_v<ll>(4,5) => vector<vector<ll>> dp(4,vector<ll>(5));
// check if T is vector
template <typename T> struct is_vector : std::false_type {};
template <typename T> struct is_vector<vector<T>> : std::true_type {};
static_assert(is_vector<vector<ll>>::value == true &&
is_vector<ll>::value == false,
"");
// check if T is vector
template <typename T> struct is_pair : std::false_type {};
template <typename T, typename S>
struct is_pair<pair<T, S>> : std::true_type {};
static_assert(is_pair<pll>::value == true && is_pair<ll>::value == false, "");
template <typename T, typename V,
typename enable_if<!is_vector<T>::value, nullptr_t>::type = nullptr>
void fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V,
typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void fill_v(T &t, const V &v) {
for (auto &&x : t)
fill_v(x, v);
}
// ex: fill_v(dp, INF);
template <typename T,
typename enable_if<!is_vector<T>::value && !is_pair<T>::value,
nullptr_t>::type = nullptr>
void read_v(T &x) {
cin >> x;
}
template <typename T,
typename enable_if<is_pair<T>::value, nullptr_t>::type = nullptr>
void read_v(T &x) {
read_v(x.first);
read_v(x.second);
}
template <typename T,
typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void read_v(T &x) {
rep(i, 0, x.size()) read_v(x[i]);
}
template <typename T, typename Delim_t = string,
typename enable_if<!is_vector<T>::value, nullptr_t>::type = nullptr>
void write_v(T &x, Delim_t delim = " ") {
cout << x << delim;
}
template <typename T, typename Delim_t = string,
typename enable_if<is_vector<T>::value, nullptr_t>::type = nullptr>
void write_v(T &x, Delim_t delim = " ") {
rep(i, 0, x.size()) write_v(x[i]);
cout << endl;
}
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
template <typename T>
using pq_greater = priority_queue<T, vector<T>, greater<T>>;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define perm(c) \
sort(all(c)); \
for (bool c##perm = 1; c##perm; c##perm = next_permutation(all(c)))
template <typename T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <typename T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
vll seq(ll i, ll j) {
vll res(j - i);
rep(k, i, j) res[k] = i + k;
return res;
}
constexpr ll POW_0(ll x, ll y) {
if (y == 0)
return 1;
if (y == 1)
return x;
if (y == 2)
return x * x;
if (y % 2 == 0)
return POW_0(POW_0(x, y / 2), 2LL);
return ((POW_0(POW_0(x, y / 2), 2LL)) * (x));
}
constexpr ll POW(ll x, ll y, ll mod = MOD) {
if (mod == 0)
return POW_0(x, y);
if (y == 0)
return 1;
if (y == 1)
return x % mod;
if (y == 2)
return x * x % mod;
if (y % 2 == 0)
return POW(POW(x, y / 2, mod), 2LL, mod) % mod;
return ((POW(POW(x, y / 2, mod), 2LL, mod)) * (x % mod)) % mod;
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void sort_by(Inputs &inputs, Functor f) {
std::sort(std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
template <typename Inputs, typename Functor,
typename T = typename Inputs::value_type>
void stable_sort_by(Inputs &inputs, Functor f) {
std::stable_sort(
std::begin(inputs), std::end(inputs),
[&f](const T &lhs, const T &rhs) { return f(lhs) < f(rhs); });
}
// ============================ Header =================================
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
ll q;
cin >> q;
ll sumb = 0;
ll sumal = 0;
ll sumar = 0;
set<ll> seta;
priority_queue<ll> pql;
pq_greater<ll> pqr;
ll cent = 0;
rep(i, 0, q) {
ll flag;
cin >> flag;
if (flag == 1) {
ll a, b;
cin >> a >> b;
sumb += b;
if (i == 0) {
pql.push(a);
cent = a;
sumal += a;
} else if (pqr.size() == pql.size()) {
ll l = pql.top();
ll r = pqr.top();
if (a <= l) {
cent = max(a, l);
pql.push(a);
sumal += a;
} else {
pqr.push(a);
sumar += a;
cent = pqr.top();
pqr.pop();
pql.push(cent);
sumar -= cent;
sumal += cent;
}
} else {
ll l = pql.top();
ll r = (pqr.size() == 0 ? 0 : pqr.top());
if (a < cent) {
pql.push(a);
sumal += a;
sumal -= pql.top();
sumar += pql.top();
pqr.push(pql.top());
pql.pop();
cent = pql.top();
} else {
pqr.push(a);
sumar += a;
}
}
} else {
cout << cent << " "
<< sumb + SZ(pql) * cent - sumal + sumar - SZ(pqr) * cent << endl;
}
}
return 0;
}
| [
"assignment.variable.change",
"identifier.change"
] | 854,945 | 854,946 | u304121198 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
class BIT {
public:
int n;
vector<int> bit;
BIT(int n_) {
n = 1;
while (n < n_) {
n <<= 1;
}
bit.resize(n + 1);
}
// add v[a] + w
void add(int a, int w) {
a++;
if (a == 0 || a > n)
return;
for (int x = a; x <= n; x += x & -x)
bit[x] += w;
}
// [0, a)
int sum(int a) {
if (a == 0)
return 0;
int ret = 0;
for (int x = a; x > 0; x -= x & -x)
ret += bit[x];
return ret;
}
};
BIT r(202020);
struct N {
ll c, a, b, val;
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<N> ns(n);
int last = -1;
for (int i = 0; i < n; i++) {
cin >> ns[i].c;
if (ns[i].c == 1) {
cin >> ns[i].a >> ns[i].b;
} else {
}
}
map<ll, int> mp;
for (int i = 0; i < n; i++) {
if (ns[i].c == 1) {
mp[ns[i].a] = 0;
}
}
int c = 0;
vector<ll> inv(201010);
for (auto &v : mp) {
inv[c] = v.first;
v.second = c++;
}
vector<ll> v;
c = 0;
ll base = 0;
ll lnum = 0, rnum = 0, now = 0, x = 0, val = 0;
map<ll, int> num;
for (int i = 0; i < n; i++) {
if (ns[i].c == 1) {
r.add(mp[ns[i].a], 1);
c++;
base += ns[i].b;
v.push_back(ns[i].a);
num[ns[i].a]++;
if (i == 0) {
lnum = 0;
rnum = 0;
now = 1;
x = ns[i].a;
val = 0;
} else {
if (ns[i].a < x) {
lnum++;
} else if (ns[i].a == x) {
now++;
} else {
rnum++;
}
val += abs(x - ns[i].a);
}
} else {
ll li = 0, ri = 202020;
ll aim = (c + 1) / 2;
while (ri - li > 1) {
ll m = (li + ri) / 2;
if (r.sum(m) >= aim) {
ri = m;
} else {
li = m;
}
}
ll a = inv[li];
if (a < x) {
auto it = num.find(x);
while (true) {
if (it->first == a)
break;
it--;
val -= lnum * abs(it->first - x);
val += now * abs(it->first - x);
val += rnum * abs(it->first - x);
lnum -= it->second;
rnum += now;
now = it->second;
x = it->first;
}
cout << a << " " << base + val << endl;
} else if (a > x) {
auto it = num.find(x);
while (true) {
if (it->first == a)
break;
it++;
val -= lnum * abs(it->first - x);
val += now * abs(it->first - x);
val += rnum * abs(it->first - x);
lnum -= it->second;
rnum += now;
now = it->second;
x = it->first;
}
cout << a << " " << base + val << endl;
} else {
cout << a << " " << base + val << endl;
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
class BIT {
public:
int n;
vector<int> bit;
BIT(int n_) {
n = 1;
while (n < n_) {
n <<= 1;
}
bit.resize(n + 1);
}
// add v[a] + w
void add(int a, int w) {
a++;
if (a == 0 || a > n)
return;
for (int x = a; x <= n; x += x & -x)
bit[x] += w;
}
// [0, a)
int sum(int a) {
if (a == 0)
return 0;
int ret = 0;
for (int x = a; x > 0; x -= x & -x)
ret += bit[x];
return ret;
}
};
BIT r(202020);
struct N {
ll c, a, b, val;
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<N> ns(n);
int last = -1;
for (int i = 0; i < n; i++) {
cin >> ns[i].c;
if (ns[i].c == 1) {
cin >> ns[i].a >> ns[i].b;
} else {
}
}
map<ll, int> mp;
for (int i = 0; i < n; i++) {
if (ns[i].c == 1) {
mp[ns[i].a] = 0;
}
}
int c = 0;
vector<ll> inv(201010);
for (auto &v : mp) {
inv[c] = v.first;
v.second = c++;
}
vector<ll> v;
c = 0;
ll base = 0;
ll lnum = 0, rnum = 0, now = 0, x = 0, val = 0;
map<ll, int> num;
for (int i = 0; i < n; i++) {
if (ns[i].c == 1) {
r.add(mp[ns[i].a], 1);
c++;
base += ns[i].b;
v.push_back(ns[i].a);
num[ns[i].a]++;
if (i == 0) {
lnum = 0;
rnum = 0;
now = 1;
x = ns[i].a;
val = 0;
} else {
if (ns[i].a < x) {
lnum++;
} else if (ns[i].a == x) {
now++;
} else {
rnum++;
}
val += abs(x - ns[i].a);
}
} else {
ll li = 0, ri = 202020;
ll aim = (c + 1) / 2;
while (ri - li > 1) {
ll m = (li + ri) / 2;
if (r.sum(m) >= aim) {
ri = m;
} else {
li = m;
}
}
ll a = inv[li];
if (a < x) {
auto it = num.find(x);
while (true) {
if (it->first == a)
break;
it--;
val -= lnum * abs(it->first - x);
val += now * abs(it->first - x);
val += rnum * abs(it->first - x);
lnum -= it->second;
rnum += now;
now = it->second;
x = it->first;
}
cout << a << " " << base + val << endl;
} else if (a > x) {
auto it = num.find(x);
while (true) {
if (it->first == a)
break;
it++;
val -= rnum * abs(it->first - x);
val += now * abs(it->first - x);
val += lnum * abs(it->first - x);
rnum -= it->second;
lnum += now;
now = it->second;
x = it->first;
}
cout << a << " " << base + val << endl;
} else {
cout << a << " " << base + val << endl;
}
}
}
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"assignment.variable.change"
] | 854,949 | 854,950 | u656572785 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
int q, ans1, tot = 0, hs[N];
ll sum, s, sum1, sum2, si1, si2, t[N * 4], si[N * 4];
int opt[N], x[N], y[N];
void fix(int l, int r, int k, int x) {
if (l == r) {
t[k] += hs[l];
si[k]++;
return;
}
int m = l + r >> 1;
if (x <= m)
fix(l, m, k << 1, x);
else
fix(m + 1, r, k << 1 | 1, x);
t[k] = t[k << 1] + t[k << 1 | 1];
si[k] = si[k << 1] + si[k << 1 | 1];
}
ll query(int l, int r, int k) {
if (l == r) {
ans1 = hs[l];
return si1 * hs[l] - sum1 + sum2 - si2 * hs[l];
}
int m = l + r >> 1;
if (sum2 + si[k << 1 | 1] <= s / 2) {
sum2 += t[k << 1 | 1];
si2 += si[k << 1 | 1];
return query(l, m, k << 1);
} else {
sum1 += t[k << 1];
si1 += si[k << 1];
return query(m + 1, r, k << 1 | 1);
}
}
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &opt[i]);
if (opt[i] == 1)
scanf("%d%d", &x[i], &y[i]), hs[++tot] = x[i];
}
sort(hs + 1, hs + 1 + tot);
for (int i = 1; i <= q; i++) {
if (opt[i] == 1) {
s++;
fix(1, tot, 1, lower_bound(hs + 1, hs + 1 + tot, x[i]) - hs);
sum += y[i];
} else {
sum1 = sum2 = si1 = si2 = 0;
ll ans2 = query(1, tot, 1) + sum;
printf("%d %lld\n", ans1, ans2);
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
int q, ans1, tot = 0, hs[N];
ll sum, s, sum1, sum2, si1, si2, t[N * 4], si[N * 4];
int opt[N], x[N], y[N];
void fix(int l, int r, int k, int x) {
if (l == r) {
t[k] += hs[l];
si[k]++;
return;
}
int m = l + r >> 1;
if (x <= m)
fix(l, m, k << 1, x);
else
fix(m + 1, r, k << 1 | 1, x);
t[k] = t[k << 1] + t[k << 1 | 1];
si[k] = si[k << 1] + si[k << 1 | 1];
}
ll query(int l, int r, int k) {
if (l == r) {
ans1 = hs[l];
return si1 * hs[l] - sum1 + sum2 - si2 * hs[l];
}
int m = l + r >> 1;
if (si2 + si[k << 1 | 1] <= s / 2) {
sum2 += t[k << 1 | 1];
si2 += si[k << 1 | 1];
return query(l, m, k << 1);
} else {
sum1 += t[k << 1];
si1 += si[k << 1];
return query(m + 1, r, k << 1 | 1);
}
}
int main() {
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &opt[i]);
if (opt[i] == 1)
scanf("%d%d", &x[i], &y[i]), hs[++tot] = x[i];
}
sort(hs + 1, hs + 1 + tot);
for (int i = 1; i <= q; i++) {
if (opt[i] == 1) {
s++;
fix(1, tot, 1, lower_bound(hs + 1, hs + 1 + tot, x[i]) - hs);
sum += y[i];
} else {
sum1 = sum2 = si1 = si2 = 0;
ll ans2 = query(1, tot, 1) + sum;
printf("%d %lld\n", ans1, ans2);
}
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 854,951 | 854,952 | u676323984 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
typedef long long LL;
int N;
LL MOD = 1e9 + 7;
vector<int> v;
priority_queue<LL> mi;
priority_queue<LL, vector<LL>, greater<LL>> ma;
int main() {
int Q;
cin >> Q;
LL wa = 0;
LL aa = 0; //小さい方
LL bb = 0; //大きい方
int za = 0;
int zb = 0;
LL mid = 0;
REP(i, Q) {
int a;
cin >> a;
if (i == 0) {
int b, c;
cin >> b >> c;
mid = b;
wa += c;
continue;
}
if (a == 1) {
LL b, c;
cin >> b >> c;
wa += c;
if (mid < b) {
zb++;
mi.push(b);
bb += b;
} else {
za++;
ma.push(b);
aa += b;
}
if (zb + 1 < za) {
mi.push(mid);
bb += mid;
zb++;
mid = ma.top();
ma.pop();
za--;
aa -= mid;
}
if (za + 1 < zb) {
ma.push(mid);
aa += mid;
za++;
mid = mi.top();
mi.pop();
zb--;
bb -= mid;
}
} else {
LL ans = bb - aa + (za - zb) * mid;
if (za > zb) {
LL aaa = ma.top();
cout << aaa << " " << (ans + wa) << endl;
} else {
cout << mid << " " << (ans + wa) << endl;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
typedef long long LL;
int N;
LL MOD = 1e9 + 7;
vector<int> v;
priority_queue<LL> ma;
priority_queue<LL, vector<LL>, greater<LL>> mi;
int main() {
int Q;
cin >> Q;
LL wa = 0;
LL aa = 0; //小さい方
LL bb = 0; //大きい方
int za = 0;
int zb = 0;
LL mid = 0;
REP(i, Q) {
int a;
cin >> a;
if (i == 0) {
int b, c;
cin >> b >> c;
mid = b;
wa += c;
continue;
}
if (a == 1) {
LL b, c;
cin >> b >> c;
wa += c;
if (mid < b) {
zb++;
mi.push(b);
bb += b;
} else {
za++;
ma.push(b);
aa += b;
}
if (zb + 1 < za) {
mi.push(mid);
bb += mid;
zb++;
mid = ma.top();
ma.pop();
za--;
aa -= mid;
}
if (za + 1 < zb) {
ma.push(mid);
aa += mid;
za++;
mid = mi.top();
mi.pop();
zb--;
bb -= mid;
}
} else {
LL ans = bb - aa + (za - zb) * mid;
if (za > zb) {
LL aaa = ma.top();
cout << aaa << " " << (ans + wa) << endl;
} else {
cout << mid << " " << (ans + wa) << endl;
}
}
}
} | [
"identifier.change"
] | 854,953 | 854,954 | u723297297 | cpp |
p03040 | // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int q;
using ll = long long;
ll sum1 = 0, sum2 = 0;
priority_queue<int, vector<int>, greater<int>>
min_heap; // keeps larger than median
priority_queue<int> max_heap; // keeps smaller than median
void add(int a) {
if (max_heap.size() && a >= max_heap.top()) {
min_heap.push(a);
sum2 += a;
} else {
max_heap.push(a);
sum1 += a;
}
if (abs((int)max_heap.size() - (int)min_heap.size()) > 1) {
if (max_heap.size() > min_heap.size()) {
int temp = max_heap.top();
max_heap.pop();
sum1 -= temp;
min_heap.push(temp);
sum2 += temp;
} else {
int temp = min_heap.top();
min_heap.pop();
sum2 -= temp;
max_heap.push(temp);
sum1 += temp;
}
}
}
int main() {
#ifdef LOCAL
freopen("./input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> q;
int state, cnt = 0;
ll b;
for (int i = 0; i < q; i++) {
cin >> state;
if (state == 1) {
int x, y;
cnt++;
cin >> x >> y;
b += y;
add(x);
} else {
ll median;
if (max_heap.size() >= min_heap.size()) {
median = max_heap.top();
} else
median = min_heap.top();
cout << median << ' '
<< sum2 - sum1 +
median * ((int)max_heap.size() - (int)min_heap.size()) + b
<< endl;
}
}
return 0;
}
| // Created by sz
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int q;
using ll = long long;
ll sum1 = 0, sum2 = 0;
priority_queue<int, vector<int>, greater<int>>
min_heap; // keeps larger than median
priority_queue<int> max_heap; // keeps smaller than median
void add(int a) {
if (max_heap.size() && a >= max_heap.top()) {
min_heap.push(a);
sum2 += a;
} else {
max_heap.push(a);
sum1 += a;
}
if (abs((int)max_heap.size() - (int)min_heap.size()) > 1) {
if (max_heap.size() > min_heap.size()) {
int temp = max_heap.top();
max_heap.pop();
sum1 -= temp;
min_heap.push(temp);
sum2 += temp;
} else {
int temp = min_heap.top();
min_heap.pop();
sum2 -= temp;
max_heap.push(temp);
sum1 += temp;
}
}
}
int main() {
#ifdef LOCAL
freopen("./input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> q;
int state, cnt = 0;
ll b = 0;
for (int i = 0; i < q; i++) {
cin >> state;
if (state == 1) {
int x, y;
cnt++;
cin >> x >> y;
b += y;
add(x);
} else {
ll median;
if (max_heap.size() >= min_heap.size()) {
median = max_heap.top();
} else
median = min_heap.top();
cout << median << ' '
<< sum2 - sum1 +
median * ((int)max_heap.size() - (int)min_heap.size()) + b
<< endl;
}
}
return 0;
}
| [
"variable_declaration.value.change"
] | 854,963 | 854,964 | u041075929 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { cout << (*it) << " "; } \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { cout << "[" << (it)->F << " , " << (it)->S << "] "; } \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
priority_queue<li> pq[2];
li add_base = 0;
inline void swap() {
while (pq[0].top() > -pq[1].top()) {
li t0 = pq[0].top();
li t1 = -pq[1].top();
pq[0].pop();
pq[1].pop();
pq[0].push(t1);
pq[1].push(-t0);
}
}
inline void add(li a) {
if (sz(pq[0]) + sz(pq[1]) % 2 > 0) {
add_base += abs(a - pq[0].top());
} else {
if (a < pq[0].top()) {
add_base += pq[0].top() - a;
} else if (a > -pq[1].top()) {
add_base += a - (-pq[1].top());
}
}
pq[0].push(a);
while (sz(pq[0]) > sz(pq[1]) + 1) {
li pass = pq[0].top();
pq[0].pop();
pq[1].push(-pass);
}
if (!pq[1].empty()) {
swap();
}
}
int main() {
li q;
cin >> q;
li base = 0;
bool first = true;
rep(i, q) {
li type;
cin >> type;
if (type == 1) {
li a, b;
cin >> a >> b;
base += b;
if (first) {
pq[0].push(a);
first = false;
} else {
add(a);
}
} else {
cout << pq[0].top() << " " << base + add_base << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { cout << (*it) << " "; } \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { cout << "[" << (it)->F << " , " << (it)->S << "] "; } \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
priority_queue<li> pq[2];
li add_base = 0;
inline void swap() {
while (pq[0].top() > -pq[1].top()) {
li t0 = pq[0].top();
li t1 = -pq[1].top();
pq[0].pop();
pq[1].pop();
pq[0].push(t1);
pq[1].push(-t0);
}
}
inline void add(li a) {
if ((sz(pq[0]) + sz(pq[1])) % 2 > 0) {
add_base += abs(a - pq[0].top());
} else {
// p3(a, pq[0].top(), pq[1].top());
if (a < pq[0].top()) {
add_base += pq[0].top() - a;
} else if (a > -pq[1].top()) {
add_base += a - (-pq[1].top());
}
}
pq[0].push(a);
while (sz(pq[0]) > sz(pq[1]) + 1) {
li pass = pq[0].top();
pq[0].pop();
pq[1].push(-pass);
}
if (!pq[1].empty()) {
swap();
}
}
int main() {
li q;
cin >> q;
li base = 0;
bool first = true;
rep(i, q) {
li type;
cin >> type;
if (type == 1) {
li a, b;
cin >> a >> b;
base += b;
if (first) {
pq[0].push(a);
first = false;
} else {
add(a);
}
} else {
cout << pq[0].top() << " " << base + add_base << endl;
}
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 854,969 | 854,970 | u962966398 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
int main() {
int q;
cin >> q;
ll s0 = 0, s1 = 0;
priority_queue<ll> left;
priority_queue<ll, vector<ll>, greater<>> right;
left.push(-INF);
right.push(INF);
for (int i = 0; i < q; i++) {
int que;
cin >> que;
if (que == 1) {
ll a, b;
cin >> a >> b;
s1 += b;
if (left.size() == right.size()) {
if (a < left.top() || a > right.top())
s0 += min(left.top() - a, a - right.top());
} else {
s0 += abs(left.top() - a);
}
if (a >= right.top())
right.push(a);
else
left.push(a);
if (right.size() > left.size()) {
left.push(right.top());
right.pop();
} else if (left.size() > right.size() + 1) {
right.push(left.top());
left.pop();
}
} else {
cout << left.top() << " " << s0 + s1 << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
int main() {
int q;
cin >> q;
ll s0 = 0, s1 = 0;
priority_queue<ll> left;
priority_queue<ll, vector<ll>, greater<>> right;
left.push(-INF);
right.push(INF);
for (int i = 0; i < q; i++) {
int que;
cin >> que;
if (que == 1) {
ll a, b;
cin >> a >> b;
s1 += b;
if (left.size() == right.size()) {
if (a < left.top() || a > right.top())
s0 += min(abs(left.top() - a), abs(a - right.top()));
} else {
s0 += abs(left.top() - a);
}
if (a >= right.top())
right.push(a);
else
left.push(a);
if (right.size() > left.size()) {
left.push(right.top());
right.pop();
} else if (left.size() > right.size() + 1) {
right.push(left.top());
left.pop();
}
} else {
cout << left.top() << " " << s0 + s1 << endl;
}
}
return 0;
} | [
"call.arguments.add",
"call.add",
"call.arguments.change"
] | 854,978 | 854,979 | u853947407 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) for (ll i = (ll)(r); i < (ll)(n); i++)
#define rep(i, n) FOR(i, 0LL, n)
#define RFOR(i, r, n) for (ll i = (ll)(n - 1); i >= r; i--)
#define rrep(i, n) RFOR(i, 0LL, n)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define COUNT(a, y, x) upper_bound(all(a), y) - lower_bound(all(a), x)
#define UNIQUE(a) \
sort(all(a)); \
a.erase(unique(all(a)), a.end())
#define pb push_back
typedef long long int ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vs;
typedef map<ll, ll> MAP;
const ll inf = 1LL << 61;
const ll mod = 1000000007LL;
// const ll mod = 998244353LL;
ll n = 0, m = 0, ans = 0, tmp = 0, ma = -inf, mi = inf;
string s;
bool ok;
ll dx[9] = {0, 1, 0, -1, 0, 1, 1, -1, -1},
dy[9] = {0, 0, 1, 0, -1, 1, -1, 1, -1};
#define endl '\n'
#pragma endregion
#define MAX 222222
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
priority_queue<ll> pq1;
priority_queue<ll, vll, greater<ll>> pq2;
pq1.push(-inf);
pq2.push(inf);
while (n--) {
cin >> tmp;
if (tmp == 1) {
ll a, b;
cin >> a >> b;
ans += b;
ll x, y;
x = pq1.top();
y = pq2.top();
if (x == -inf)
x = a;
if (pq1.size() > pq2.size())
pq2.push(a);
else
pq1.push(a);
if (pq1.top() > pq2.top()) {
ll p1 = pq1.top(), p2 = pq2.top();
pq1.pop();
pq2.pop();
pq1.push(p2);
pq2.push(p1);
}
if (pq1.size() == pq2.size())
ans += abs(x - a);
else if (a < x && a > y)
ans += min(abs(a - x), abs(a - y));
} else
cout << pq1.top() << " " << ans << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#pragma region
using namespace std;
#define FOR(i, r, n) for (ll i = (ll)(r); i < (ll)(n); i++)
#define rep(i, n) FOR(i, 0LL, n)
#define RFOR(i, r, n) for (ll i = (ll)(n - 1); i >= r; i--)
#define rrep(i, n) RFOR(i, 0LL, n)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define COUNT(a, y, x) upper_bound(all(a), y) - lower_bound(all(a), x)
#define UNIQUE(a) \
sort(all(a)); \
a.erase(unique(all(a)), a.end())
#define pb push_back
typedef long long int ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vs;
typedef map<ll, ll> MAP;
const ll inf = 1LL << 61;
const ll mod = 1000000007LL;
// const ll mod = 998244353LL;
ll n = 0, m = 0, ans = 0, tmp = 0, ma = -inf, mi = inf;
string s;
bool ok;
ll dx[9] = {0, 1, 0, -1, 0, 1, 1, -1, -1},
dy[9] = {0, 0, 1, 0, -1, 1, -1, 1, -1};
#define endl '\n'
#pragma endregion
#define MAX 222222
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
priority_queue<ll> pq1;
priority_queue<ll, vll, greater<ll>> pq2;
pq1.push(-inf);
pq2.push(inf);
while (n--) {
cin >> tmp;
if (tmp == 1) {
ll a, b;
cin >> a >> b;
ans += b;
ll x, y;
x = pq1.top();
y = pq2.top();
if (x == -inf)
x = a;
if (pq1.size() > pq2.size())
pq2.push(a);
else
pq1.push(a);
if (pq1.top() > pq2.top()) {
ll p1 = pq1.top(), p2 = pq2.top();
pq1.pop();
pq2.pop();
pq1.push(p2);
pq2.push(p1);
}
if (pq1.size() == pq2.size())
ans += abs(x - a);
else if (a < x || a > y)
ans += min(abs(a - x), abs(a - y));
} else
cout << pq1.top() << " " << ans << endl;
}
return 0;
} | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 854,982 | 854,983 | u215122692 | cpp |
p03040 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF ((long long)1e18)
#define MOD ((int)1e9 + 7)
#define endl "\n"
#define yn(f) ((f) ? "Yes" : "No")
#define YN(f) ((f) ? "YES" : "NO")
#define MAX
signed main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
// cout<<fixed<<setprecision(10);
priority_queue<int> Q1;
priority_queue<int, vector<int>, greater<int>> Q2;
int Q, query, a, b, c, d;
int sum = 0, me = 0;
// Q1.push(-INF);
// Q2.push(INF);
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> query;
if (query == 1) {
cin >> a >> b;
sum += b;
if (Q1.size())
c = Q1.top();
else
c = -INF;
if (Q2.size())
d = Q2.top();
else
d = INF;
if (a <= c || Q1.size() == 0) { // cout<<"C"<<endl;
if (Q1.size())
me += c - a;
Q1.push(a);
} else { // cout<<"D"<<endl;
me += a - c;
Q2.push(a);
}
if (Q1.size() < Q2.size()) { // cout<<"A"<<endl;
int e = Q1.size() + 1, f = Q2.size() - 1;
me += (Q2.top() - Q1.top()) * e - (Q2.top() - Q1.top()) * f;
Q1.push(Q2.top());
Q2.pop();
} else if (Q1.size() > Q2.size() + 1) { // cout<<"B"<<endl;
int e = Q1.size() - 1, f = Q2.size() + 1;
Q2.push(Q1.top());
Q1.pop();
me += (Q2.top() - Q1.top()) * f - (Q2.top() - Q1.top()) * e;
}
} else {
cout << Q1.top() << " " << sum + me << endl;
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF ((long long)1e18)
#define MOD ((int)1e9 + 7)
#define endl "\n"
#define yn(f) ((f) ? "Yes" : "No")
#define YN(f) ((f) ? "YES" : "NO")
#define MAX
signed main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
// cout<<fixed<<setprecision(10);
priority_queue<int> Q1;
priority_queue<int, vector<int>, greater<int>> Q2;
int Q, query, a, b, c, d;
int sum = 0, me = 0;
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> query;
if (query == 1) {
cin >> a >> b;
sum += b;
if (Q1.size())
c = Q1.top();
else
c = -INF;
if (Q2.size())
d = Q2.top();
else
d = INF;
if (a <= c || Q1.size() == 0) { // cout<<"C"<<endl;
if (Q1.size())
me += c - a;
Q1.push(a);
} else { // cout<<"D"<<endl;
me += a - c;
Q2.push(a);
}
if (Q1.size() < Q2.size()) { // cout<<"A"<<endl;
int e = Q1.size() + 1, f = Q2.size() - 1;
me += (Q2.top() - Q1.top()) * f - (Q2.top() - Q1.top()) * e;
// cout<<Q2.top() - Q1.top()<<" "<<e<<" "<<Q2.top() - Q1.top()<<"
// "<<f<<" me "<<me<<endl;;
Q1.push(Q2.top());
Q2.pop();
} else if (Q1.size() > Q2.size() + 1) { // cout<<"B"<<endl;
int e = Q1.size() - 1, f = Q2.size() + 1;
Q2.push(Q1.top());
Q1.pop();
me += (Q2.top() - Q1.top()) * e - (Q2.top() - Q1.top()) * f;
}
} else {
cout << Q1.top() << " " << sum + me << endl;
}
}
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 854,984 | 854,985 | u233393801 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef pair<ll, P> P3;
typedef pair<P, P> PP;
const ll MOD = ll(1e9) + 7;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e5 + 5);
const double EPS = 1e-6;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define SORT(v) sort((v).begin(), (v).end())
#define SORTR(v) sort((v).rbegin(), (v).rend())
#define ALL(v) (v).begin(), (v).end()
int main() {
int Q;
cin >> Q;
ll bsum = 0, fmin = 0;
// 中央値の左右をもつ
multiset<ll> stl, str;
stl.insert(-IINF);
str.insert(IINF);
REP(i, Q) {
ll c, a = 0, b = 0;
cin >> c;
if (c == 1) {
cin >> a >> b;
bsum += b;
if (a >= *(--stl.end()) && a <= *str.begin()) {
stl.insert(a);
str.insert(a);
} else if (a > *str.begin()) {
fmin += a - *str.begin();
REP(j, 2) str.insert(a);
stl.insert(*str.begin());
str.erase(str.begin());
} else {
fmin += *--stl.end() - a;
REP(j, 2) stl.insert(a);
str.insert(*--str.end());
stl.erase(--stl.end());
}
} else {
cout << *str.begin() << " " << fmin + bsum << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef pair<ll, P> P3;
typedef pair<P, P> PP;
const ll MOD = ll(1e9) + 7;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e5 + 5);
const double EPS = 1e-6;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define SORT(v) sort((v).begin(), (v).end())
#define SORTR(v) sort((v).rbegin(), (v).rend())
#define ALL(v) (v).begin(), (v).end()
int main() {
int Q;
cin >> Q;
ll bsum = 0, fmin = 0;
// 中央値の左右をもつ
multiset<ll> stl, str;
stl.insert(-IINF);
str.insert(IINF);
REP(i, Q) {
ll c, a = 0, b = 0;
cin >> c;
if (c == 1) {
cin >> a >> b;
bsum += b;
if (a >= *(--stl.end()) && a <= *str.begin()) {
stl.insert(a);
str.insert(a);
} else if (a > *str.begin()) {
fmin += a - *str.begin();
REP(j, 2) str.insert(a);
stl.insert(*str.begin());
str.erase(str.begin());
} else {
fmin += *--stl.end() - a;
REP(j, 2) stl.insert(a);
str.insert(*--stl.end());
stl.erase(--stl.end());
}
} else {
cout << *--stl.end() << " " << fmin + bsum << endl;
}
}
return 0;
} | [
"identifier.change",
"call.arguments.change",
"io.output.change",
"call.add"
] | 854,991 | 854,990 | u271063202 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define start_routine() int begtime = clock();
#define end_routine() \
int endtime = clock(); \
cerr << endl \
<< "Time elapsed: " << (endtime - begtime) * 1000 / CLOCKS_PER_SEC \
<< " ms"; \
return 0
#define speed() cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
// #define exit(a, b) return cout << a, b;
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define print(stuff) cout << stuff << endl
#define len length
#define ret0 return 0
#define ret return
#define ll long long
#define ld long double
#define fi first
#define endl '\n'
#define se second
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define vl vector<ll>
#define sl set<ll>
#define pll pair<ll, ll>
#define mll map<ll, ll>
#define pq priority_queue<ll>
typedef tree<pll, null_type, less<pll>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#define inf (long long int)1e18
#define eps 0.000001
#define mod 1000000007
#define mod1 998244353
#define MAXN 200005
ll arr[MAXN] = {0}, aux[MAXN] = {0};
ll t[4 * MAXN] = {0}, t2[4 * MAXN] = {0};
void build(ll node, ll start, ll end) {
if (start == end) {
t[node] = arr[start];
return;
}
ll mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
t[node] = t[2 * node] + t[2 * node + 1];
}
void update(ll node, ll start, ll end, ll idx, ll val) {
if (start == end) {
aux[idx] = 1;
arr[idx] = val;
t[node] = val;
t2[node] = 1;
return;
}
ll mid = (start + end) / 2;
if (idx >= start && idx <= mid) {
update(2 * node, start, mid, idx, val);
} else {
update(2 * node + 1, mid + 1, end, idx, val);
}
t[node] = t[2 * node] + t[2 * node + 1];
t2[node] = t2[2 * node] + t2[2 * node + 1];
}
ll query(ll node, ll start, ll end, ll l, ll r) {
if (r < start || l > end || l > r) {
return 0; // range represented by node is completely outside the given range
} else if (l <= start && r >= end) {
return t[node]; // range represented by a node is completely inside the
// given range
}
// range represented by a node is partially inside and partially outside the
// given range
ll mid = (start + end) / 2;
ll p1 = query(2 * node, start, mid, l, r);
ll p2 = query(2 * node + 1, mid + 1, end, l, r);
return (p1 + p2);
}
ll query2(ll node, ll start, ll end, ll l, ll r) {
if (r < start || l > end || l > r) {
return 0; // range represented by node is completely outside the given range
} else if (l <= start && r >= end) {
return t2[node]; // range represented by a node is completely inside the
// given range
}
// range represented by a node is partially inside and partially outside the
// given range
ll mid = (start + end) / 2;
ll p1 = query2(2 * node, start, mid, l, r);
ll p2 = query2(2 * node + 1, mid + 1, end, l, r);
return (p1 + p2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll q;
cin >> q;
ll a[q];
ll ptr = 0;
ll queries[q][3];
for (ll i = 0; i < q; i++) {
ll x;
cin >> x;
if (x == 1) {
ll aa, b;
cin >> aa >> b;
a[ptr] = aa;
ptr++;
queries[i][0] = 1, queries[i][1] = aa, queries[i][2] = b;
} else if (x == 2) {
queries[i][0] = 2;
queries[i][1] = queries[i][2] = -1;
}
}
map<ll, vl> m;
map<ll, ll> pointer;
sort(a, a + ptr);
loop(i, 0, ptr) {
m[a[i]].pb(i);
pointer[a[i]] = 0;
}
indexed_set s;
ll io = 1;
ll constant = 0;
loop(i, 0, q) {
if (queries[i][0] == 1) {
s.insert(mp(queries[i][1], io));
io++;
constant += queries[i][2];
ll x = queries[i][1];
update(1, 0, q - 1, m[x][pointer[x]], x);
pointer[x]++;
} else if (queries[i][0] == 2) {
if (i == 0)
cout << 0 << " " << 0 << endl;
else {
// for(auto x: s){
// cout<<x.fi<<" ";
// }
// cout<<endl;
ll idx = s.size() / 2;
auto itr = s.find_by_order(idx);
ll val = (*itr).fi;
ll index_l = m[val][0];
ll index_r = m[val][m[val].size() - 1];
ll aaa = query(1, 0, q - 1, 0, index_l - 1);
ll bbb = query(1, 0, q - 1, index_r + 1, q - 1);
ll live_l = query2(1, 0, q - 1, 0, index_l - 1);
ll live_r = query2(1, 0, q - 1, index_r + 1, q - 1);
ll ans = -aaa + bbb + val * (live_l)-val * (live_r);
ans += constant;
cout << val << " " << ans << endl;
}
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define start_routine() int begtime = clock();
#define end_routine() \
int endtime = clock(); \
cerr << endl \
<< "Time elapsed: " << (endtime - begtime) * 1000 / CLOCKS_PER_SEC \
<< " ms"; \
return 0
#define speed() cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
// #define exit(a, b) return cout << a, b;
#define loop(i, a, b) for (ll i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define print(stuff) cout << stuff << endl
#define len length
#define ret0 return 0
#define ret return
#define ll long long
#define ld long double
#define fi first
#define endl '\n'
#define se second
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define vl vector<ll>
#define sl set<ll>
#define pll pair<ll, ll>
#define mll map<ll, ll>
#define pq priority_queue<ll>
typedef tree<pll, null_type, less<pll>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#define inf (long long int)1e18
#define eps 0.000001
#define mod 1000000007
#define mod1 998244353
#define MAXN 200005
ll arr[MAXN] = {0}, aux[MAXN] = {0};
ll t[4 * MAXN] = {0}, t2[4 * MAXN] = {0};
void build(ll node, ll start, ll end) {
if (start == end) {
t[node] = arr[start];
return;
}
ll mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
t[node] = t[2 * node] + t[2 * node + 1];
}
void update(ll node, ll start, ll end, ll idx, ll val) {
if (start == end) {
aux[idx] = 1;
arr[idx] = val;
t[node] = val;
t2[node] = 1;
return;
}
ll mid = (start + end) / 2;
if (idx >= start && idx <= mid) {
update(2 * node, start, mid, idx, val);
} else {
update(2 * node + 1, mid + 1, end, idx, val);
}
t[node] = t[2 * node] + t[2 * node + 1];
t2[node] = t2[2 * node] + t2[2 * node + 1];
}
ll query(ll node, ll start, ll end, ll l, ll r) {
if (r < start || l > end || l > r) {
return 0; // range represented by node is completely outside the given range
} else if (l <= start && r >= end) {
return t[node]; // range represented by a node is completely inside the
// given range
}
// range represented by a node is partially inside and partially outside the
// given range
ll mid = (start + end) / 2;
ll p1 = query(2 * node, start, mid, l, r);
ll p2 = query(2 * node + 1, mid + 1, end, l, r);
return (p1 + p2);
}
ll query2(ll node, ll start, ll end, ll l, ll r) {
if (r < start || l > end || l > r) {
return 0; // range represented by node is completely outside the given range
} else if (l <= start && r >= end) {
return t2[node]; // range represented by a node is completely inside the
// given range
}
// range represented by a node is partially inside and partially outside the
// given range
ll mid = (start + end) / 2;
ll p1 = query2(2 * node, start, mid, l, r);
ll p2 = query2(2 * node + 1, mid + 1, end, l, r);
return (p1 + p2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll q;
cin >> q;
ll a[q];
ll ptr = 0;
ll queries[q][3];
for (ll i = 0; i < q; i++) {
ll x;
cin >> x;
if (x == 1) {
ll aa, b;
cin >> aa >> b;
a[ptr] = aa;
ptr++;
queries[i][0] = 1, queries[i][1] = aa, queries[i][2] = b;
} else if (x == 2) {
queries[i][0] = 2;
queries[i][1] = queries[i][2] = -1;
}
}
map<ll, vl> m;
map<ll, ll> pointer;
sort(a, a + ptr);
loop(i, 0, ptr) {
m[a[i]].pb(i);
pointer[a[i]] = 0;
}
indexed_set s;
ll io = 1;
ll constant = 0;
loop(i, 0, q) {
if (queries[i][0] == 1) {
s.insert(mp(queries[i][1], io));
io++;
constant += queries[i][2];
ll x = queries[i][1];
update(1, 0, q - 1, m[x][pointer[x]], x);
pointer[x]++;
} else if (queries[i][0] == 2) {
if (i == 0)
cout << 0 << " " << 0 << endl;
else {
// for(auto x: s){
// cout<<x.fi<<" ";
// }
// cout<<endl;
ll idx = (s.size() - 1) / 2;
auto itr = s.find_by_order(idx);
ll val = (*itr).fi;
ll index_l = m[val][0];
ll index_r = m[val][m[val].size() - 1];
ll aaa = query(1, 0, q - 1, 0, index_l - 1);
ll bbb = query(1, 0, q - 1, index_r + 1, q - 1);
ll live_l = query2(1, 0, q - 1, 0, index_l - 1);
ll live_r = query2(1, 0, q - 1, index_r + 1, q - 1);
ll ans = -aaa + bbb + val * (live_l)-val * (live_r);
ans += constant;
cout << val << " " << ans << endl;
}
}
}
}
| [] | 854,996 | 854,997 | u851993789 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int Q;
int main() {
set<pii> st;
ll sumb = 0;
ll funa = 0;
pii cent = pii(0, 0);
cin >> Q;
for (int q = 0; q < Q; q++) {
int num, a, b;
cin >> num;
if (num == 1) {
cin >> a >> b;
sumb += b;
st.insert(pii(a, q));
if ((int)st.size() == 1) {
cent = pii(a, q);
}
// 前が奇数、今偶数
else if (st.size() % 2 == 0) {
if (cent <= pii(a, q)) {
funa += abs(cent.first - a);
} else {
funa += abs(cent.first - a);
auto it = --st.find(cent);
cent = *it;
}
}
// 前が偶数、今奇数
else {
if (cent >= pii(a, q)) {
funa += abs(cent.first - a);
} else {
funa += abs(cent.first - a);
auto it = ++st.find(cent);
funa += abs(it->first - cent.first);
cent = *it;
}
}
} else {
cout << cent.first << " " << funa + sumb << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int Q;
int main() {
set<pii> st;
ll sumb = 0;
ll funa = 0;
pii cent = pii(0, 0);
cin >> Q;
for (int q = 0; q < Q; q++) {
int num, a, b;
cin >> num;
if (num == 1) {
cin >> a >> b;
sumb += b;
st.insert(pii(a, q));
if ((int)st.size() == 1) {
cent = pii(a, q);
}
// 前が奇数、今偶数
else if (st.size() % 2 == 0) {
if (cent <= pii(a, q)) {
funa += abs(cent.first - a);
} else {
funa += abs(cent.first - a);
auto it = --st.find(cent);
// funa -= abs(it->first - cent.first);
cent = *it;
}
}
// 前が偶数、今奇数
else {
if (cent >= pii(a, q)) {
funa += abs(cent.first - a);
} else {
funa += abs(cent.first - a);
auto it = ++st.find(cent);
funa -= abs(it->first - cent.first);
cent = *it;
}
}
} else {
cout << cent.first << " " << funa + sumb << endl;
}
}
return 0;
}
| [
"expression.operator.change"
] | 855,004 | 855,005 | u489053642 | cpp |
p03040 | #if 1
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
#define uint unsigned long long
constexpr int MOD = 1000000007;
// constexpr int MOD = 998244353;
constexpr int INF = 1145141919810893;
//
struct Edge {
int next;
int w = 1;
};
template <class T> struct Vertex {
std::vector<Edge> edges;
T val = {};
};
template <class T> struct Graph {
std::vector<Vertex<T>> vertex;
public:
Graph(size_t n = 0) : vertex(n) {}
void setArray(int u, int v, int w = 1) {
vertex[u].edges.push_back(Edge{v, w});
}
void setConnect(int u, int v, int w = 1) {
setArray(u, v, w);
setArray(v, u, w);
}
T &val(int u) { return vertex[u].val; }
void dfsImpl(int pos, int prev,
std::function<void(int now, int next, int w)> func) {
for (auto &e : vertex[pos].edges) {
if (e.next == prev)
continue;
func(pos, e.next, e.w);
dfsImpl(e.next, pos, func);
}
}
void dfs(int pos, std::function<void(int now, int next, int w)> func) {
dfsImpl(pos, -1, func);
}
// graph.dfs(0, [](Vertex<int>& now, Vertex<int>& next, int w) {});
pair<int, int> radiusImpl(int pos) {
int farestID = -1;
int far = -1;
val(pos) = 0;
dfs(pos, [&](int now, int next, int w) {
val(next) = 1 + val(now);
if (val(next) > far) {
far = val(next);
farestID = next;
}
});
return {farestID, far};
}
int radius() {
if (vertex.size() <= 1)
return 0;
auto res = radiusImpl(0);
res = radiusImpl(res.first);
return res.second;
}
};
//////////////////////////////////
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
std::vector<int> divisor(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
////////////////////////
#define LOADVEC(type, name, N) \
std::vector<type> name(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
cin >> name[nnn]; \
}
#define LOADVEC2(type, name0, name1, N) \
std::vector<type> name0(N), name1(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
cin >> name0[nnn]; \
cin >> name1[nnn]; \
}
#define LOADVEC3(type, name0, name1, name2, N) \
std::vector<type> name0(N), name1(N), name2(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
cin >> name0[nnn]; \
cin >> name1[nnn]; \
cin >> name2[nnn]; \
}
#define LOAD(type, name) \
type name; \
cin >> name;
void proc();
signed main() {
ios::sync_with_stdio(false);
proc();
return 0;
}
/*
--------------------------------------------------------
--------------------------------------------------------
--------------- template ----------------------
--------------------------------------------------------
--------------------------------------------------------
*/
void proc() {
std::multiset<int> L, R;
LOAD(int, N);
int q0, a0, b0;
cin >> q0 >> a0 >> b0;
L.insert(a0);
R.insert(a0);
int sum = b0;
int min = 0;
bool first = true;
for (int i = 1; i < N; ++i) {
int q, a, b;
cin >> q;
if (q == 1) {
cin >> a >> b;
if (a < *L.rbegin()) {
min += *(--L.end()) - a;
R.insert(*(--L.end()));
L.erase(--L.end());
L.insert(a);
L.insert(a);
}
if (a <= *R.begin()) {
L.insert(a);
R.insert(a);
} else {
min += a - *R.begin();
L.insert(*R.begin());
R.erase(R.begin());
R.insert(a);
R.insert(a);
}
sum += b;
} else {
cout << *(--L.end()) << " " << sum + min << endl;
first = true;
}
}
}
#endif
| #if 1
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
#define uint unsigned long long
constexpr int MOD = 1000000007;
// constexpr int MOD = 998244353;
constexpr int INF = 1145141919810893;
//
struct Edge {
int next;
int w = 1;
};
template <class T> struct Vertex {
std::vector<Edge> edges;
T val = {};
};
template <class T> struct Graph {
std::vector<Vertex<T>> vertex;
public:
Graph(size_t n = 0) : vertex(n) {}
void setArray(int u, int v, int w = 1) {
vertex[u].edges.push_back(Edge{v, w});
}
void setConnect(int u, int v, int w = 1) {
setArray(u, v, w);
setArray(v, u, w);
}
T &val(int u) { return vertex[u].val; }
void dfsImpl(int pos, int prev,
std::function<void(int now, int next, int w)> func) {
for (auto &e : vertex[pos].edges) {
if (e.next == prev)
continue;
func(pos, e.next, e.w);
dfsImpl(e.next, pos, func);
}
}
void dfs(int pos, std::function<void(int now, int next, int w)> func) {
dfsImpl(pos, -1, func);
}
// graph.dfs(0, [](Vertex<int>& now, Vertex<int>& next, int w) {});
pair<int, int> radiusImpl(int pos) {
int farestID = -1;
int far = -1;
val(pos) = 0;
dfs(pos, [&](int now, int next, int w) {
val(next) = 1 + val(now);
if (val(next) > far) {
far = val(next);
farestID = next;
}
});
return {farestID, far};
}
int radius() {
if (vertex.size() <= 1)
return 0;
auto res = radiusImpl(0);
res = radiusImpl(res.first);
return res.second;
}
};
//////////////////////////////////
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
std::vector<int> divisor(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
////////////////////////
#define LOADVEC(type, name, N) \
std::vector<type> name(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
cin >> name[nnn]; \
}
#define LOADVEC2(type, name0, name1, N) \
std::vector<type> name0(N), name1(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
cin >> name0[nnn]; \
cin >> name1[nnn]; \
}
#define LOADVEC3(type, name0, name1, name2, N) \
std::vector<type> name0(N), name1(N), name2(N); \
for (int nnn = 0; nnn < N; ++nnn) { \
cin >> name0[nnn]; \
cin >> name1[nnn]; \
cin >> name2[nnn]; \
}
#define LOAD(type, name) \
type name; \
cin >> name;
void proc();
signed main() {
ios::sync_with_stdio(false);
proc();
return 0;
}
/*
--------------------------------------------------------
--------------------------------------------------------
--------------- template ----------------------
--------------------------------------------------------
--------------------------------------------------------
*/
void proc() {
std::multiset<int> L, R;
LOAD(int, N);
int q0, a0, b0;
cin >> q0 >> a0 >> b0;
L.insert(a0);
R.insert(a0);
int sum = b0;
int min = 0;
bool first = true;
for (int i = 1; i < N; ++i) {
int q, a, b;
cin >> q;
if (q == 1) {
cin >> a >> b;
if (a < *L.rbegin()) {
min += *(--L.end()) - a;
R.insert(*(--L.end()));
L.erase(--L.end());
L.insert(a);
L.insert(a);
} else if (a <= *R.begin()) {
L.insert(a);
R.insert(a);
} else {
min += a - *R.begin();
L.insert(*R.begin());
R.erase(R.begin());
R.insert(a);
R.insert(a);
}
sum += b;
} else {
cout << *(--L.end()) << " " << sum + min << endl;
first = true;
}
}
}
#endif
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 855,009 | 855,010 | u154068540 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int main() {
int Q;
cin >> Q;
long long ans = 0;
int a = 0;
vector<long long> ans1;
vector<long long> ans2;
priority_queue<long long> que1;
priority_queue<long long, vector<long long>, greater<long long>> que2;
for (int q = 0; q < Q; q++) {
int c;
cin >> c;
if (c == 1) {
long long a, b;
cin >> a >> b;
ans += b;
if (q == 0) {
que1.push(a);
que2.push(a);
} else {
if (a < que1.top()) {
ans += que1.top() - a;
que2.push(que1.top());
que1.pop();
que1.push(a);
que1.push(a);
}
if (a > que2.top()) {
ans += a - que2.top();
que1.push(que2.top());
que2.pop();
que2.push(a);
que2.push(a);
} else {
que1.push(a);
que2.push(a);
}
}
} else {
ans1.push_back(que1.top());
ans2.push_back(ans);
a++;
}
}
for (int i = 0; i < a; i++)
cout << ans1[i] << " " << ans2[i] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int Q;
cin >> Q;
long long ans = 0;
int a = 0;
vector<long long> ans1;
vector<long long> ans2;
priority_queue<long long> que1;
priority_queue<long long, vector<long long>, greater<long long>> que2;
for (int q = 0; q < Q; q++) {
int c;
cin >> c;
if (c == 1) {
long long a, b;
cin >> a >> b;
ans += b;
if (q == 0) {
que1.push(a);
que2.push(a);
} else {
if (a < que1.top()) {
ans += que1.top() - a;
que2.push(que1.top());
que1.pop();
que1.push(a);
que1.push(a);
} else if (a > que2.top()) {
ans += a - que2.top();
que1.push(que2.top());
que2.pop();
que2.push(a);
que2.push(a);
} else {
que1.push(a);
que2.push(a);
}
}
// printf("que1.top=%lld,que2.top=%lld\n",que1.top(),que2.top());
} else {
ans1.push_back(que1.top());
ans2.push_back(ans);
a++;
}
}
for (int i = 0; i < a; i++)
cout << ans1[i] << " " << ans2[i] << endl;
return 0;
} | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 855,015 | 855,016 | u573082373 | cpp |
p03040 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define INF 1e15
ll Q;
ll f, x, xa, bb, al, ah;
ll i, j, k, l;
vector<ll> anss;
priority_queue<ll, vector<ll>, greater<ll>> aqh;
priority_queue<ll> aql;
int main() {
scanf("%lld", &Q);
j = 0;
f = 0;
x = 0;
aql.push(-INF);
aqh.push(INF);
fornum(i, 0, Q) {
ll q;
scanf("%lld", &q);
if (q == 1) {
ll a, b;
scanf("%lld%lld", &a, &b);
bb += b;
if (aql.size() == aqh.size()) {
ll qa = aqh.top();
if (qa < a) {
aqh.pop();
aqh.push(a);
aql.push(qa);
ah -= qa - x;
al += x - qa;
ah += a - x;
} else {
aql.push(a);
al += x - a;
}
} else {
ll qa = aql.top();
if (a < qa) {
aql.pop();
aql.push(a);
aqh.push(qa);
al -= x - qa;
ah += qa - x;
al += x - a;
} else {
aqh.push(a);
ah += x - a;
}
}
ll nx = aql.top();
al += (aql.size() - 1) * (nx - x);
ah -= (aqh.size() - 1) * (nx - x);
x = nx;
j++;
} else {
if (j == 0) {
printf("-1000000000 0\n");
} else {
printf("%lld %lld\n", x, al + ah + bb);
}
}
// printf("b%lld %lld\n", aql.top(), aqh.top());
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define INF 1e15
ll Q;
ll f, x, xa, bb, al, ah;
ll i, j, k, l;
vector<ll> anss;
priority_queue<ll, vector<ll>, greater<ll>> aqh;
priority_queue<ll> aql;
int main() {
scanf("%lld", &Q);
j = 0;
f = 0;
x = 0;
aql.push(-INF);
aqh.push(INF);
fornum(i, 0, Q) {
ll q;
scanf("%lld", &q);
if (q == 1) {
ll a, b;
scanf("%lld%lld", &a, &b);
bb += b;
if (aql.size() == aqh.size()) {
ll qa = aqh.top();
if (qa < a) {
aqh.pop();
aqh.push(a);
aql.push(qa);
ah -= qa - x;
al += x - qa;
ah += a - x;
} else {
aql.push(a);
al += x - a;
}
} else {
ll qa = aql.top();
if (a < qa) {
aql.pop();
aql.push(a);
aqh.push(qa);
al -= x - qa;
ah += qa - x;
al += x - a;
} else {
aqh.push(a);
ah += a - x;
}
}
ll nx = aql.top();
al += (aql.size() - 1) * (nx - x);
ah -= (aqh.size() - 1) * (nx - x);
x = nx;
j++;
} else {
if (j == 0) {
printf("-1000000000 0\n");
} else {
printf("%lld %lld\n", x, al + ah + bb);
}
}
// printf("b%lld %lld\n", aql.top(), aqh.top());
}
return 0;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 855,017 | 855,018 | u259396003 | cpp |
p03040 | #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
//#define cerr if(false) cerr
#ifdef DEBUG
#define show(...) cerr << #__VA_ARGS__ << " = ", debug(__VA_ARGS__);
#else
#define show(...) 42
#endif
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> a) {
os << '(' << a.first << ',' << a.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto x : v)
os << x << ' ';
return os;
}
void debug() { cerr << '\n'; }
template <typename H, typename... T> void debug(H a, T... b) {
cerr << a;
if (sizeof...(b))
cerr << ", ";
debug(b...);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
multiset<ll> st1, st2;
ll x = 0, y = 0;
ll sum = 0;
int t = 0;
rep(i, q) {
int k;
cin >> k;
if (k == 1) {
ll a, b;
cin >> a >> b;
sum += b;
st2.insert(a);
y += a;
if (t % 2 == 0) {
auto itr = st2.end();
itr--;
x += *itr;
y -= *itr;
st1.insert(*itr);
st2.erase(itr);
} else {
auto itr1 = st1.begin();
auto itr2 = st2.end();
itr2--;
if (*itr1 < *itr2) {
x += *itr2;
y -= *itr2;
x -= *itr1;
y += *itr1;
st1.insert(*itr1);
st2.erase(itr1);
st2.insert(*itr2);
st1.erase(itr2);
}
}
t++;
} else {
ll num;
if (st1.size() == st2.size()) {
num = *(--st2.end());
} else {
num = *st1.begin();
}
show(num);
ll a = (ll)st1.size();
ll b = (ll)st2.size();
cout << num << " " << abs(x - a * num) + abs(y - b * num) + sum << "\n";
}
}
}
| #include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
//#define cerr if(false) cerr
#ifdef DEBUG
#define show(...) cerr << #__VA_ARGS__ << " = ", debug(__VA_ARGS__);
#else
#define show(...) 42
#endif
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> a) {
os << '(' << a.first << ',' << a.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto x : v)
os << x << ' ';
return os;
}
void debug() { cerr << '\n'; }
template <typename H, typename... T> void debug(H a, T... b) {
cerr << a;
if (sizeof...(b))
cerr << ", ";
debug(b...);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
multiset<ll> st1, st2;
ll x = 0, y = 0;
ll sum = 0;
int t = 0;
rep(i, q) {
int k;
cin >> k;
if (k == 1) {
ll a, b;
cin >> a >> b;
sum += b;
st2.insert(a);
y += a;
if (t % 2 == 0) {
auto itr = st2.end();
itr--;
x += *itr;
y -= *itr;
st1.insert(*itr);
st2.erase(itr);
} else {
auto itr1 = st1.begin();
auto itr2 = st2.end();
itr2--;
if (*itr1 < *itr2) {
x += *itr2;
y -= *itr2;
x -= *itr1;
y += *itr1;
st1.insert(*itr2);
st2.erase(itr2);
st2.insert(*itr1);
st1.erase(itr1);
}
}
t++;
} else {
ll num;
if (st1.size() == st2.size()) {
num = *(--st2.end());
} else {
num = *st1.begin();
}
show(num);
ll a = (ll)st1.size();
ll b = (ll)st2.size();
cout << num << " " << abs(x - a * num) + abs(y - b * num) + sum << "\n";
}
}
}
| [
"call.remove",
"identifier.change",
"call.add"
] | 855,029 | 855,030 | u628047647 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define rep(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
ll lmax(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll lmin(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
ll q;
cin >> q;
priority_queue<ll> q1;
priority_queue<ll, vector<ll>, greater<ll>> q2;
ll sum1 = 0, sum2 = 0;
ll sb = 0;
rep(i, 0, q) {
ll e;
cin >> e;
if (e == 1) {
ll a, b;
cin >> a >> b;
sb += b;
if (q1.size() == 0) {
q1.push(a);
sum1 += a;
continue;
}
if (q2.size() == 0) {
ll u = q1.top();
if (a <= u) {
q1.pop();
q1.push(a);
sum1 = a;
sum2 = u;
q2.push(u);
} else {
q2.push(a);
sum2 += a;
continue;
}
}
ll s = q1.top(), t = q2.top();
if (a <= s) {
q1.push(a);
sum1 += a;
if (q1.size() == q2.size() + 2) {
ll ss = q1.top();
q1.pop();
sum1 -= ss;
q2.push(ss);
sum2 += ss;
}
} else if (a >= t) {
q2.push(a);
sum2 += a;
if (q2.size() == q1.size() + 1) {
ll ss = q2.top();
q2.pop();
sum2 -= ss;
q1.push(ss);
sum1 += ss;
}
} else {
if (q1.size() == q2.size()) {
q1.push(a);
sum1 += a;
} else if (q1.size() == q2.size() + 1) {
q2.push(a);
sum2 += a;
}
}
} else if (e == 2) {
ll r = q1.top();
// cout<<r<<" "<<sum1<<" "<<sum2<<endl;
ll ans = 0;
ans += sum2 - (sum1 - r);
if (q1.size() == q2.size())
ans -= r;
ans += sb;
cout << r << " " << ans << endl;
}
// cout<<q1.top()<<" "<<q2.top()<<endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define rep(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
ll lmax(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll lmin(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
ll q;
cin >> q;
priority_queue<ll> q1;
priority_queue<ll, vector<ll>, greater<ll>> q2;
ll sum1 = 0, sum2 = 0;
ll sb = 0;
rep(i, 0, q) {
ll e;
cin >> e;
if (e == 1) {
ll a, b;
cin >> a >> b;
sb += b;
if (q1.size() == 0) {
q1.push(a);
sum1 += a;
continue;
}
if (q2.size() == 0) {
ll u = q1.top();
if (a <= u) {
q1.pop();
q1.push(a);
sum1 = a;
sum2 = u;
q2.push(u);
continue;
} else {
q2.push(a);
sum2 += a;
continue;
}
}
ll s = q1.top(), t = q2.top();
if (a <= s) {
q1.push(a);
sum1 += a;
if (q1.size() == q2.size() + 2) {
ll ss = q1.top();
q1.pop();
sum1 -= ss;
q2.push(ss);
sum2 += ss;
}
} else if (a >= t) {
q2.push(a);
sum2 += a;
if (q2.size() == q1.size() + 1) {
ll ss = q2.top();
q2.pop();
sum2 -= ss;
q1.push(ss);
sum1 += ss;
}
} else {
if (q1.size() == q2.size()) {
q1.push(a);
sum1 += a;
} else if (q1.size() == q2.size() + 1) {
q2.push(a);
sum2 += a;
}
}
} else if (e == 2) {
ll r = q1.top();
// cout<<r<<" "<<sum1<<" "<<sum2<<endl;
ll ans = 0;
ans += sum2 - (sum1 - r);
if (q1.size() == q2.size())
ans -= r;
ans += sb;
cout << r << " " << ans << endl;
}
// cout<<q1.top()<<" "<<q2.top()<<endl;
}
}
| [] | 855,034 | 855,035 | u357265888 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define rep(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
ll lmax(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll lmin(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
ll q;
cin >> q;
priority_queue<ll> q1;
priority_queue<ll, vector<ll>, greater<ll>> q2;
ll sum1 = 0, sum2 = 0;
ll sb = 0;
rep(i, 0, q) {
ll e;
cin >> e;
if (e == 1) {
ll a, b;
cin >> a >> b;
sb += b;
if (q1.size() == 0) {
q1.push(a);
sum1 += a;
continue;
}
if (q2.size() == 0) {
ll u = q1.top();
if (a <= u) {
q1.pop();
q1.push(a);
sum1 = a;
sum2 = u;
q2.push(u);
} else {
q2.push(b);
sum2 += b;
continue;
}
}
ll s = q1.top(), t = q2.top();
if (a <= s) {
q1.push(a);
sum1 += a;
if (q1.size() == q2.size() + 2) {
ll ss = q1.top();
q1.pop();
sum1 -= ss;
q2.push(ss);
sum2 += ss;
}
} else if (a >= t) {
q2.push(a);
sum2 += a;
if (q2.size() == q1.size() + 1) {
ll ss = q2.top();
q2.pop();
sum2 -= ss;
q1.push(ss);
sum1 += ss;
}
} else {
if (q1.size() == q2.size()) {
q1.push(a);
sum1 += a;
} else if (q1.size() == q2.size() + 1) {
q2.push(a);
sum2 += a;
}
}
} else if (e == 2) {
ll r = q1.top();
ll ans = 0;
ans += sum2 - (sum1 - r);
if (q1.size() == q2.size())
ans -= r;
ans += sb;
cout << r << " " << ans << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<ll, pll> plpl;
typedef tuple<ll, ll, ll> tl;
ll mod = 1000000007;
ll mod2 = 998244353;
ll inf = 1000000000000000000;
#define rep(i, m, n) for (int i = m; i < n; i++)
#define rrep(i, n, m) for (int i = n; i >= m; i--)
ll lmax(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll lmin(ll a, ll b) {
if (a < b)
return a;
else
return b;
}
int main() {
ll q;
cin >> q;
priority_queue<ll> q1;
priority_queue<ll, vector<ll>, greater<ll>> q2;
ll sum1 = 0, sum2 = 0;
ll sb = 0;
rep(i, 0, q) {
ll e;
cin >> e;
if (e == 1) {
ll a, b;
cin >> a >> b;
sb += b;
if (q1.size() == 0) {
q1.push(a);
sum1 += a;
continue;
}
if (q2.size() == 0) {
ll u = q1.top();
if (a <= u) {
q1.pop();
q1.push(a);
sum1 = a;
sum2 = u;
q2.push(u);
continue;
} else {
q2.push(a);
sum2 += a;
continue;
}
}
ll s = q1.top(), t = q2.top();
if (a <= s) {
q1.push(a);
sum1 += a;
if (q1.size() == q2.size() + 2) {
ll ss = q1.top();
q1.pop();
sum1 -= ss;
q2.push(ss);
sum2 += ss;
}
} else if (a >= t) {
q2.push(a);
sum2 += a;
if (q2.size() == q1.size() + 1) {
ll ss = q2.top();
q2.pop();
sum2 -= ss;
q1.push(ss);
sum1 += ss;
}
} else {
if (q1.size() == q2.size()) {
q1.push(a);
sum1 += a;
} else if (q1.size() == q2.size() + 1) {
q2.push(a);
sum2 += a;
}
}
} else if (e == 2) {
ll r = q1.top();
// cout<<r<<" "<<sum1<<" "<<sum2<<endl;
ll ans = 0;
ans += sum2 - (sum1 - r);
if (q1.size() == q2.size())
ans -= r;
ans += sb;
cout << r << " " << ans << endl;
}
// cout<<q1.top()<<" "<<q2.top()<<endl;
}
}
| [
"identifier.change",
"call.arguments.change",
"assignment.value.change"
] | 855,036 | 855,035 | u357265888 | cpp |
p03039 | #include <iostream>
#include <stdio.h>
#include <unordered_map>
#include <vector>
using namespace std;
using namespace std;
long long mod = 1e9 + 7;
long long GetValue(long long n, long long m) {
long long ans = 0;
for (long long i = 1; i < n; i++) {
ans = (ans + i * (n - i)) % mod;
}
ans = ans * (m * m) % mod;
return ans;
}
typedef long long ll;
void exgcd(ll a, ll b, ll &d, ll &x, ll &y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
ll inv(ll a, ll p) {
ll d, x, y;
exgcd(a, p, d, x, y);
return d == 1 ? (x + p) % p : -1;
}
long long F(long long a, long long p) { return inv(a, p); }
long long C(long long n, long long m) {
if (n == 0) {
return 1;
}
long long ans = 1;
for (long long i = 1; i <= m; i++) {
ans = ans * (n - i + 1) * F(i, mod) % mod;
}
return ans;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long long ans = 0, mod = 1e9 + 7;
ans = GetValue(n, m) + GetValue(m, n);
if (ans >= mod) {
ans -= mod;
}
ans = ans * C(n * m - 2, k - 2) % mod;
printf("%lld\n", ans);
return 0;
}
| #include <iostream>
#include <stdio.h>
#include <unordered_map>
#include <vector>
using namespace std;
using namespace std;
long long mod = 1e9 + 7;
long long GetValue(long long n, long long m) {
long long ans = 0;
for (long long i = 1; i < n; i++) {
ans = (ans + i * (n - i)) % mod;
}
ans = ans * (m * m) % mod;
return ans;
}
typedef long long ll;
void exgcd(ll a, ll b, ll &d, ll &x, ll &y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
ll inv(ll a, ll p) {
ll d, x, y;
exgcd(a, p, d, x, y);
return d == 1 ? (x % p + p) % p : p - 1;
}
long long F(long long a, long long p) { return inv(a, p); }
long long C(long long n, long long m) {
if (n == 0) {
return 1;
}
long long ans = 1;
for (long long i = 1; i <= m; i++) {
ans = ans * (n - i + 1) % mod * F(i, mod) % mod;
}
return ans;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long long ans = 0, mod = 1e9 + 7;
ans = GetValue(n, m) + GetValue(m, n);
if (ans >= mod) {
ans -= mod;
}
ans = ans * C(n * m - 2, k - 2) % mod;
printf("%lld\n", ans);
return 0;
}
| [
"function.return_value.change",
"assignment.change"
] | 855,041 | 855,042 | u647903912 | cpp |
p03039 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define VV vector
#define pb push_back
#define bitc __builtin_popcountl
#define m_p make_pair
#define inf 1000000000000000000ll
#define MAXN 1000001
#define eps 0.0000000001
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
string char_to_str(char c) {
string tem(1, c);
return tem;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T> // usage rand<long long>()
T rand() {
return uniform_int_distribution<T>()(rng);
}
// string to integer stuuu()
// string to long long stoll()
// string.substr(position,length);
// integer to string to_string();
//////////////
#define S second
#define F first
#define int long long
///////
long long modinverse(long long a, long long b) {
long long b0 = b, t, q;
long long x0 = 0, x1 = 1;
if (b == 1)
return 1;
while (a > 1) {
q = a / b;
t = b, b = a % b, a = t;
t = x0, x0 = x1 - q * x0, x1 = t;
}
if (x1 < 0)
x1 += b0;
return x1;
}
signed main() {
fastio;
#ifdef ANIKET_GOYAL
freopen("inputf.in", "r", stdin);
freopen("outputf.in", "w", stdout);
#endif
int mo = 1000000007;
int n, k, m;
cin >> n >> m >> k;
int fac[200001];
int ifac[200001];
fac[0] = 1;
ifac[0] = modinverse(fac[0], mo);
for (int i = 1; i < 200001; ++i) {
fac[i] = (fac[i - 1] * i) % mo;
ifac[i] = modinverse(fac[i], mo);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
ans += ((m - j) * (((i * (i - 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (m * ((((n - i) * (n - i + 1)) / 2) % mo)) % mo;
ans %= mo;
ans += ((n - i) * (((j * (j - 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (n * ((((m - j) * (m - j + 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (i * ((((j) * (j - 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (j * ((((i) * (i - 1)) / 2) % mo)) % mo;
ans %= mo;
// cout<<ans<<" ";
}
}
ans *= modinverse(2, mo);
int nu = n * m - 2;
int de = k - 2;
// cout<<((fac[nu]*((ifac[nu-de]*ifac[de])%mo))%mo)<<"\n";
cout << (ans * ((fac[nu] * ((ifac[nu - de] * ifac[de]) % mo)) % mo)) % mo;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define VV vector
#define pb push_back
#define bitc __builtin_popcountl
#define m_p make_pair
#define inf 1000000000000000000ll
#define MAXN 1000001
#define eps 0.0000000001
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
string char_to_str(char c) {
string tem(1, c);
return tem;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T> // usage rand<long long>()
T rand() {
return uniform_int_distribution<T>()(rng);
}
// string to integer stuuu()
// string to long long stoll()
// string.substr(position,length);
// integer to string to_string();
//////////////
#define S second
#define F first
#define int long long
///////
long long modinverse(long long a, long long b) {
long long b0 = b, t, q;
long long x0 = 0, x1 = 1;
if (b == 1)
return 1;
while (a > 1) {
q = a / b;
t = b, b = a % b, a = t;
t = x0, x0 = x1 - q * x0, x1 = t;
}
if (x1 < 0)
x1 += b0;
return x1;
}
signed main() {
fastio;
#ifdef ANIKET_GOYAL
freopen("inputf.in", "r", stdin);
freopen("outputf.in", "w", stdout);
#endif
int mo = 1000000007;
int n, k, m;
cin >> n >> m >> k;
int fac[200001];
int ifac[200001];
fac[0] = 1;
ifac[0] = modinverse(fac[0], mo);
for (int i = 1; i < 200001; ++i) {
fac[i] = (fac[i - 1] * i) % mo;
ifac[i] = modinverse(fac[i], mo);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
ans += ((m - j) * (((i * (i - 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (m * ((((n - i) * (n - i + 1)) / 2) % mo)) % mo;
ans %= mo;
ans += ((n - i) * (((j * (j - 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (n * ((((m - j) * (m - j + 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (i * ((((j) * (j - 1)) / 2) % mo)) % mo;
ans %= mo;
ans += (j * ((((i) * (i - 1)) / 2) % mo)) % mo;
ans %= mo;
// cout<<ans<<" ";
}
}
ans *= modinverse(2, mo);
ans %= mo;
int nu = n * m - 2;
int de = k - 2;
// cout<<((fac[nu]*((ifac[nu-de]*ifac[de])%mo))%mo)<<"\n";
cout << (ans * ((fac[nu] * ((ifac[nu - de] * ifac[de]) % mo)) % mo)) % mo;
} | [
"assignment.add"
] | 855,047 | 855,048 | u883546077 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
int m;
long long sum1, sum2, dlt;
priority_queue<int> q1;
priority_queue<int, vector<int>, greater<int>> q2;
int main() {
int ord, x, d;
m = read();
while (m--) {
ord = read();
if (ord == 2) {
d = q1.top();
long long ans =
1ll * d * q1.size() - sum1 + sum2 - 1ll * d * q2.size() + dlt;
printf("%d %lld\n", q1.top(), ans);
} else {
x = read();
d = read();
dlt += d;
if (q2.empty())
q1.push(x), sum1 += x;
else {
if (d <= q2.top())
q1.push(x), sum1 += x;
else
q2.push(x), sum2 += x;
}
if (q1.size() > q2.size() + 1) {
x = q1.top();
sum1 -= x;
q1.pop();
q2.push(x);
sum2 += x;
}
if (q1.size() + 1 < q2.size()) {
x = q2.top();
sum2 -= x;
q2.pop();
q1.push(x);
sum1 += x;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
int m;
long long sum1, sum2, dlt;
priority_queue<int> q1;
priority_queue<int, vector<int>, greater<int>> q2;
int main() {
int ord, x, d;
m = read();
while (m--) {
ord = read();
if (ord == 2) {
d = q1.top();
long long ans =
1ll * d * q1.size() - sum1 + sum2 - 1ll * d * q2.size() + dlt;
printf("%d %lld\n", q1.top(), ans);
} else {
x = read();
d = read();
dlt += d;
if (q2.empty())
q1.push(x), sum1 += x;
else {
if (x <= q2.top())
q1.push(x), sum1 += x;
else
q2.push(x), sum2 += x;
}
while (q1.size() > q2.size() + 1) {
x = q1.top();
sum1 -= x;
q1.pop();
q2.push(x);
sum2 += x;
}
while (q1.size() < q2.size()) {
x = q2.top();
sum2 -= x;
q2.pop();
q1.push(x);
sum1 += x;
}
}
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.while.replace.add",
"control_flow.loop.if.replace.remove",
"expression.operation.binary.remove"
] | 855,055 | 855,054 | u522606865 | cpp |
p03040 | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
using ll = long long;
typedef pair<int, int> P;
const ll Mod = 1000000007;
int main() {
int Q;
cin >> Q;
multiset<ll> Set;
int _1, aa, bb;
cin >> _1 >> aa >> bb;
ll bsum = bb;
ll asum = 0;
Set.insert(aa);
auto itr = Set.begin();
ll left = 0;
ll right = 0;
for (int i = 0; i < Q - 1; i++) {
int mode;
cin >> mode;
if (mode == 1) {
ll a, b;
cin >> a >> b;
bsum += b;
if ((int)Set.size() % 2 == 0) {
Set.insert(a);
if (a >= *itr) {
auto itr2 = next(itr, 1);
asum += (ll)(*itr2 - *itr) * (left + 1);
asum -= (ll)(*itr2 - *itr) * (right);
left++;
itr = itr2;
} else {
left++;
}
asum += abs((ll)*itr - a);
} else {
Set.insert(a);
if (a < *itr) {
auto itr2 = prev(itr, 1);
asum -= (ll)(*itr - *itr2) * (left);
asum += (ll)(*itr - *itr2) * (right + 1);
left++;
itr = itr2;
} else {
right++;
}
asum += abs((ll)(*itr) - a);
}
} else if (mode == 2) {
ll ans = asum + bsum;
ll x = (ll)(*itr);
cout << x << " " << ans << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
using ll = long long;
typedef pair<int, int> P;
const ll Mod = 1000000007;
int main() {
int Q;
cin >> Q;
multiset<ll> Set;
int _1, aa, bb;
cin >> _1 >> aa >> bb;
ll bsum = bb;
ll asum = 0;
Set.insert(aa);
auto itr = Set.begin();
ll left = 0;
ll right = 0;
for (int i = 0; i < Q - 1; i++) {
int mode;
cin >> mode;
if (mode == 1) {
ll a, b;
cin >> a >> b;
bsum += b;
if ((int)Set.size() % 2 == 0) {
Set.insert(a);
if (a >= *itr) {
auto itr2 = next(itr, 1);
asum += (ll)(*itr2 - *itr) * (left + 1);
asum -= (ll)(*itr2 - *itr) * (right);
left++;
itr = itr2;
} else {
left++;
}
asum += abs((ll)*itr - a);
} else {
Set.insert(a);
if (a < *itr) {
auto itr2 = prev(itr, 1);
asum -= (ll)(*itr - *itr2) * (left);
asum += (ll)(*itr - *itr2) * (right + 1);
right++;
itr = itr2;
} else {
right++;
}
asum += abs((ll)(*itr) - a);
}
} else if (mode == 2) {
ll ans = asum + bsum;
ll x = (ll)(*itr);
cout << x << " " << ans << endl;
}
}
return 0;
} | [
"identifier.change"
] | 855,057 | 855,058 | u083494782 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl = vector<ll>;
using VV = vector<vector<int>>;
using VVl = vector<vector<ll>>;
int main() {
int q;
cin >> q;
multiset<ll> s;
s.insert(-INFll);
ll sub = 0;
ll ans = 0;
auto it = s.begin();
for (int i = 0; i < q; ++i) {
int c;
cin >> c;
if (c == 1) {
ll a, b;
cin >> a >> b;
sub += b;
s.insert(a);
if (s.size() == 2) {
it++; // ok
} else {
if (s.size() % 2 == 1) {
ans += abs(a - *it);
if (*it > a) {
it--;
}
} else {
if (*it <= a)
it++;
else
it--;
ans += abs(a - *(it));
}
}
} else {
cout << *it << " " << ans + sub << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
using ll = long long;
const int INF = 1 << 30;
const ll INFll = 1LL << 62;
const int mod = int(1e9) + 7;
// const int mod=998244353;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using ld = long double;
using V = vector<int>;
using Vl = vector<ll>;
using VV = vector<vector<int>>;
using VVl = vector<vector<ll>>;
int main() {
int q;
cin >> q;
multiset<ll> s;
s.insert(-INFll);
ll sub = 0;
ll ans = 0;
auto it = s.begin();
for (int i = 0; i < q; ++i) {
int c;
cin >> c;
if (c == 1) {
ll a, b;
cin >> a >> b;
sub += b;
s.insert(a);
if (s.size() == 2) {
it++; // ok
} else {
if (s.size() % 2 == 1) {
ans += abs(a - *it);
if (*it > a) {
it--;
}
} else {
if (*it <= a)
it++;
ans += abs(a - *(it));
}
}
} else {
cout << *it << " " << ans + sub << endl;
}
}
}
| [
"control_flow.branch.else.remove",
"expression.unary.arithmetic.remove"
] | 855,061 | 855,062 | u525008368 | cpp |
p03040 | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
ll c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
ll med = a1;
ll suml = 0;
ll sumr = 0;
vector<ll> ans1;
vector<ll> ans2;
for (int i = 2; i <= q; i++) {
int c;
cin >> c;
if (c == 1) {
int a, b;
cin >> a >> b;
if (!valid) {
//左右の個数が等しい
if (*msl.rbegin() >= a) {
int x = *msl.rbegin();
msl.erase(msl.find(x));
msl.insert(a);
med = x;
suml = suml - x + a;
} else if (*msr.begin() <= a) {
int x = *msr.begin();
msr.erase(msr.find(x));
msr.insert(a);
med = a;
sumr = sumr - x + a;
} else {
med = a;
}
valid = true;
} else {
if (a <= med) {
msl.insert(a);
msr.insert(med);
suml += a;
sumr += med;
} else {
msl.insert(med);
msr.insert(a);
suml += med;
sumr += a;
}
valid = false;
}
sumb += b;
} else {
if (valid) {
ans1.push_back(med);
ans2.push_back(sumr - suml + sumb);
} else {
ans1.push_back(*msl.rbegin());
ans2.push_back(sumr - suml + sumb);
}
}
}
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i] << " " << ans2[i] << endl;
}
return 0;
} | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
ll c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
ll med = a1;
ll suml = 0;
ll sumr = 0;
vector<ll> ans1;
vector<ll> ans2;
for (int i = 2; i <= q; i++) {
int c;
cin >> c;
if (c == 1) {
int a, b;
cin >> a >> b;
if (!valid) {
//左右の個数が等しい
if (*msl.rbegin() >= a) {
int x = *msl.rbegin();
msl.erase(msl.find(x));
msl.insert(a);
med = x;
suml = suml - x + a;
} else if (*msr.begin() <= a) {
int x = *msr.begin();
msr.erase(msr.find(x));
msr.insert(a);
med = x;
sumr = sumr - x + a;
} else {
med = a;
}
valid = true;
} else {
if (a <= med) {
msl.insert(a);
msr.insert(med);
suml += a;
sumr += med;
} else {
msl.insert(med);
msr.insert(a);
suml += med;
sumr += a;
}
valid = false;
}
sumb += b;
} else {
if (valid) {
ans1.push_back(med);
ans2.push_back(sumr - suml + sumb);
} else {
ans1.push_back(*msl.rbegin());
ans2.push_back(sumr - suml + sumb);
}
}
}
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i] << " " << ans2[i] << endl;
}
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 855,065 | 855,066 | u540315049 | cpp |
p03040 | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
int c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
int med = a1;
ll suml = 0;
ll sumr = 0;
vector<ll> ans1;
vector<ll> ans2;
for (int i = 2; i <= q; i++) {
int c;
cin >> c;
if (c == 1) {
int a, b;
cin >> a >> b;
if (!valid) {
//左右の個数が等しい
if (*msl.rbegin() >= a) {
int x = *msl.rbegin();
msl.erase(msl.find(x));
msl.insert(a);
med = x;
suml = suml - x + a;
} else if (*msr.begin() <= a) {
int x = *msr.begin();
msr.erase(msr.find(x));
msr.insert(a);
med = a;
sumr = sumr - x + a;
} else {
med = a;
}
valid = true;
} else {
if (a <= med) {
msl.insert(a);
msr.insert(med);
suml += a;
sumr += med;
} else {
msl.insert(med);
msr.insert(a);
suml += med;
sumr += a;
}
valid = false;
}
sumb += b;
} else {
if (valid) {
ans1.push_back(med);
ans2.push_back(sumr - suml + sumb);
} else {
ans1.push_back(*msl.rbegin());
ans2.push_back(sumr - suml + sumb);
}
}
}
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i] << " " << ans2[i] << endl;
}
return 0;
} | #include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
multiset<ll> msl;
multiset<ll> msr;
int main() {
int q;
cin >> q;
ll sumb = 0;
ll suma = 0;
bool valid = true; // medがvalidか
ll c1, a1, b1;
cin >> c1 >> a1 >> b1;
sumb += b1;
ll med = a1;
ll suml = 0;
ll sumr = 0;
vector<ll> ans1;
vector<ll> ans2;
for (int i = 2; i <= q; i++) {
int c;
cin >> c;
if (c == 1) {
int a, b;
cin >> a >> b;
if (!valid) {
//左右の個数が等しい
if (*msl.rbegin() >= a) {
int x = *msl.rbegin();
msl.erase(msl.find(x));
msl.insert(a);
med = x;
suml = suml - x + a;
} else if (*msr.begin() <= a) {
int x = *msr.begin();
msr.erase(msr.find(x));
msr.insert(a);
med = x;
sumr = sumr - x + a;
} else {
med = a;
}
valid = true;
} else {
if (a <= med) {
msl.insert(a);
msr.insert(med);
suml += a;
sumr += med;
} else {
msl.insert(med);
msr.insert(a);
suml += med;
sumr += a;
}
valid = false;
}
sumb += b;
} else {
if (valid) {
ans1.push_back(med);
ans2.push_back(sumr - suml + sumb);
} else {
ans1.push_back(*msl.rbegin());
ans2.push_back(sumr - suml + sumb);
}
}
}
for (int i = 0; i < ans1.size(); i++) {
cout << ans1[i] << " " << ans2[i] << endl;
}
return 0;
} | [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change"
] | 855,067 | 855,066 | u540315049 | cpp |
p03040 | #include <bits/stdc++.h>
// #include <atcoder/all>
using namespace std;
// using namespace atcoder;
#define rp(i, k, n) for (int i = k; i < n; i++)
using ll = long long;
using ld = double;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7ll;
const double PI = 3.14159265358979323846;
int main() {
int q;
cin >> q;
priority_queue<ll> left;
priority_queue<ll, vector<ll>, greater<ll>> right;
ll lsum = 0;
ll rsum = 0;
ll b_sum = 0;
while (q--) {
int type;
cin >> type;
if (type == 1) {
ll a, b;
cin >> a >> b;
b_sum += b;
if (left.empty()) {
left.push(a);
lsum += a;
} else if (left.size() > right.size()) {
if (a <= left.top()) {
// left.top()をrightに移す
lsum -= left.top();
rsum += left.top();
right.push(left.top());
left.pop();
// aをleftに
lsum += a;
left.push(a);
} else {
right.push(a);
rsum += a;
}
} else if (left.size() <= right.size()) {
if (a <= left.top()) {
lsum += a;
left.push(a);
} else {
// right.top()をleftに移す
lsum += right.top();
rsum -= right.top();
left.push(right.top());
right.pop();
// aをrightに
rsum += a;
right.push(a);
}
}
}
if (type == 2) {
ll res = b_sum;
ll med = left.top();
res += rsum - med * (int)right.size();
res += med * (int)left.size() - lsum;
printf("%lld %lld\n", med, res);
}
}
return 0;
}
| #include <bits/stdc++.h>
// #include <atcoder/all>
using namespace std;
// using namespace atcoder;
#define rp(i, k, n) for (int i = k; i < n; i++)
using ll = long long;
using ld = double;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7ll;
const double PI = 3.14159265358979323846;
int main() {
int q;
cin >> q;
priority_queue<ll> left;
priority_queue<ll, vector<ll>, greater<ll>> right;
ll lsum = 0;
ll rsum = 0;
ll b_sum = 0;
while (q--) {
int type;
cin >> type;
if (type == 1) {
ll a, b;
cin >> a >> b;
b_sum += b;
if (left.empty()) {
left.push(a);
lsum += a;
} else if (left.size() > right.size()) {
if (a < left.top()) {
// left.top()をrightに移す
lsum -= left.top();
rsum += left.top();
right.push(left.top());
left.pop();
// aをleftに
lsum += a;
left.push(a);
} else {
right.push(a);
rsum += a;
}
} else if (left.size() <= right.size()) {
if (a <= right.top()) {
lsum += a;
left.push(a);
} else {
// right.top()をleftに移す
lsum += right.top();
rsum -= right.top();
left.push(right.top());
right.pop();
// aをrightに
rsum += a;
right.push(a);
}
}
}
if (type == 2) {
ll res = b_sum;
ll med = left.top();
res += rsum - med * (int)right.size();
res += med * (int)left.size() - lsum;
printf("%lld %lld\n", med, res);
}
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"call.function.change"
] | 855,070 | 855,071 | u575653048 | cpp |
p03040 | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldouble = long double;
// BDD,ZDD,kdtree, bdtree,bicalc, bolonoy, doloney, tree,
// chinesemod,segmenttree,daikusutora, saidairyuu, 2bugurahu, heirokenshutu,
// topologicalsort, kyourenketuseibun
#define REP(i, a, b) for (ll i = a; i < b; ++i)
#define PRI(s) cout << s << endl
#define PRIY PRI("Yes")
#define PRIN PRI("No")
int main() {
ll Q;
cin >> Q;
multiset<ll> L, R;
ll center = -1;
ll B = 0;
ll size = 0;
ll suml = 0, sumr = 0;
REP(i, 0, Q) {
ll t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
B += b;
if (size == 0) {
center = a;
} else if (size % 2 == 0) {
if (*L.rbegin() <= a) {
if (a <= *R.begin()) {
center = a;
} else {
center = *R.begin();
sumr -= *R.begin();
R.erase(R.begin());
sumr += a;
R.insert(a);
}
} else {
center = *L.rbegin();
suml -= *L.rbegin();
L.erase(L.rbegin().base());
suml += a;
L.insert(a);
}
} else {
if (a <= center) {
suml += a;
sumr += center;
L.insert(a);
R.insert(center);
} else {
suml += center;
sumr += a;
L.insert(center);
R.insert(a);
}
center = -1;
}
++size;
} else {
PRI(((center == -1) ? *L.rbegin() : center) << " " << sumr - suml + B);
}
}
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldouble = long double;
// BDD,ZDD,kdtree, bdtree,bicalc, bolonoy, doloney, tree,
// chinesemod,segmenttree,daikusutora, saidairyuu, 2bugurahu, heirokenshutu,
// topologicalsort, kyourenketuseibun
#define REP(i, a, b) for (ll i = a; i < b; ++i)
#define PRI(s) cout << s << endl
#define PRIY PRI("Yes")
#define PRIN PRI("No")
int main() {
ll Q;
cin >> Q;
multiset<ll> L, R;
ll center = -1;
ll B = 0;
ll size = 0;
ll suml = 0, sumr = 0;
REP(i, 0, Q) {
ll t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
B += b;
if (size == 0) {
center = a;
} else if (size % 2 == 0) {
if (*L.rbegin() <= a) {
if (a <= *R.begin()) {
center = a;
} else {
center = *R.begin();
sumr -= *R.begin();
R.erase(R.begin());
sumr += a;
R.insert(a);
}
} else {
center = *L.rbegin();
suml -= *L.rbegin();
L.erase((++L.rbegin()).base());
suml += a;
L.insert(a);
}
} else {
if (a <= center) {
suml += a;
sumr += center;
L.insert(a);
R.insert(center);
} else {
suml += center;
sumr += a;
L.insert(center);
R.insert(a);
}
center = -1;
}
++size;
} else {
PRI(((center == -1) ? *L.rbegin() : center) << " " << sumr - suml + B);
}
}
return 0;
}
| [
"call.arguments.change"
] | 855,074 | 855,075 | u539145601 | cpp |
p03040 | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, b) FOR(i, 0, b)
#define RFO(i, a, b) for (int i = ((b)-1); i >= (a); i--)
#define RF0(i, b) RFO(i, 0, b)
#define fi first
#define se second
#define debug(x) cout << #x << ": " << x << '\n';
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> void Print(vector<T> v) {
F0R(i, v.size()) { cout << v[i] << ' '; }
cout << newl;
}
#if 1
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int Q;
cin >> Q;
deque<int> as;
// asの要素数でみて中央にある値をmとする。
// ただし要素数が偶数のとき、手前よりのものをmとする。
auto mi = [&]() { return (as.size() - 1) / 2; };
// mより手前の値の合計と、奥の値の合計
i64 ls = 0, hs = 0;
i64 bs = 0;
F0R(i, Q) {
int q;
cin >> q;
i64 x = as.size() ? as[mi()] : 0;
if (q == 1) {
int a, b;
cin >> a >> b;
auto where = lower_bound(rng(as), a);
if (as.size()) {
bool insLeft, odd = as.size() & 1;
insLeft = where - as.begin() <= mi();
as.insert(where, a);
if (insLeft) {
ls += a;
if (odd) {
hs += x;
ls -= as[mi()];
} else {
// 中央値は引き続き中央値
}
} else {
hs += a;
if (odd) {
// 中央値は引き続き中央値
} else {
ls -= x;
ls += as[mi()];
}
}
} else {
as.insert(where, a);
}
bs += b;
} else {
i64 f = bs;
f += x * mi() - ls;
f += hs - x * (as.size() - mi() - 1);
/*
F0R(j, as.size()) {
f += abs(x - as[j]);
}
*/
cout << x << ' ' << f << newl;
}
}
}
#endif
| #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, b) FOR(i, 0, b)
#define RFO(i, a, b) for (int i = ((b)-1); i >= (a); i--)
#define RF0(i, b) RFO(i, 0, b)
#define fi first
#define se second
#define debug(x) cout << #x << ": " << x << '\n';
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> void Print(vector<T> v) {
F0R(i, v.size()) { cout << v[i] << ' '; }
cout << newl;
}
#if 1
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int Q;
cin >> Q;
deque<int> as;
// asの要素数でみて中央にある値をmとする。
// ただし要素数が偶数のとき、手前よりのものをmとする。
auto mi = [&]() { return (as.size() - 1) / 2; };
// mより手前の値の合計と、奥の値の合計
i64 ls = 0, hs = 0;
i64 bs = 0;
F0R(i, Q) {
int q;
cin >> q;
i64 x = as.size() ? as[mi()] : 0;
if (q == 1) {
int a, b;
cin >> a >> b;
auto where = lower_bound(rng(as), a);
if (as.size()) {
bool insLeft, odd = as.size() & 1;
insLeft = where - as.begin() <= mi();
as.insert(where, a);
if (insLeft) {
ls += a;
if (odd) {
hs += x;
ls -= as[mi()];
} else {
// 中央値は引き続き中央値
}
} else {
hs += a;
if (odd) {
// 中央値は引き続き中央値
} else {
ls += x;
hs -= as[mi()];
}
}
// debug(hs);
// debug(ls);
} else {
as.insert(where, a);
}
bs += b;
} else {
i64 f = bs;
//*
f += x * mi() - ls;
f += hs - x * (as.size() - mi() - 1);
//*/
/*
F0R(j, as.size()) {
f += abs(x - as[j]);
}
//*/
cout << x << ' ' << f << newl;
}
}
}
#endif
| [
"assignment.change",
"expression.operator.change"
] | 855,087 | 855,088 | u211255607 | cpp |
p03040 | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, b) FOR(i, 0, b)
#define RFO(i, a, b) for (int i = ((b)-1); i >= (a); i--)
#define RF0(i, b) RFO(i, 0, b)
#define fi first
#define se second
#define debug(x) cout << #x << ": " << x << '\n';
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> void Print(vector<T> v) {
F0R(i, v.size()) { cout << v[i] << ' '; }
cout << newl;
}
#if 1
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int Q;
cin >> Q;
vector<int> as;
// asの要素数でみて中央にある値をmとする。
// ただし要素数が偶数のとき、手前よりのものをmとする。
auto mi = [&]() { return (as.size() - 1) / 2; };
// mより手前の値の合計と、奥の値の合計
i64 ls = 0, hs = 0;
i64 bs = 0;
F0R(i, Q) {
int q;
cin >> q;
i64 x = as.size() ? as[mi()] : 0;
if (q == 1) {
int a, b;
cin >> a >> b;
auto where = lower_bound(rng(as), a);
if (as.size()) {
bool insLeft, odd = as.size() & 1;
insLeft = where - as.begin() <= mi();
as.insert(where, a);
if (insLeft) {
ls += a;
if (odd) {
hs += x;
ls -= as[mi()];
} else {
// 中央値は引き続き中央値
}
} else {
hs += a;
if (odd) {
// 中央値は引き続き中央値
} else {
ls -= x;
ls += as[mi()];
}
}
} else {
as.insert(where, a);
}
bs += b;
} else {
i64 f = bs;
f += x * mi() - ls;
f += hs - x * (as.size() - mi() - 1);
/*
F0R(j, as.size()) {
f += abs(x - as[j]);
}
*/
cout << x << ' ' << f << newl;
}
}
}
#endif
| #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, b) FOR(i, 0, b)
#define RFO(i, a, b) for (int i = ((b)-1); i >= (a); i--)
#define RF0(i, b) RFO(i, 0, b)
#define fi first
#define se second
#define debug(x) cout << #x << ": " << x << '\n';
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> void Print(vector<T> v) {
F0R(i, v.size()) { cout << v[i] << ' '; }
cout << newl;
}
#if 1
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int Q;
cin >> Q;
deque<int> as;
// asの要素数でみて中央にある値をmとする。
// ただし要素数が偶数のとき、手前よりのものをmとする。
auto mi = [&]() { return (as.size() - 1) / 2; };
// mより手前の値の合計と、奥の値の合計
i64 ls = 0, hs = 0;
i64 bs = 0;
F0R(i, Q) {
int q;
cin >> q;
i64 x = as.size() ? as[mi()] : 0;
if (q == 1) {
int a, b;
cin >> a >> b;
auto where = lower_bound(rng(as), a);
if (as.size()) {
bool insLeft, odd = as.size() & 1;
insLeft = where - as.begin() <= mi();
as.insert(where, a);
if (insLeft) {
ls += a;
if (odd) {
hs += x;
ls -= as[mi()];
} else {
// 中央値は引き続き中央値
}
} else {
hs += a;
if (odd) {
// 中央値は引き続き中央値
} else {
ls += x;
hs -= as[mi()];
}
}
// debug(hs);
// debug(ls);
} else {
as.insert(where, a);
}
bs += b;
} else {
i64 f = bs;
//*
f += x * mi() - ls;
f += hs - x * (as.size() - mi() - 1);
//*/
/*
F0R(j, as.size()) {
f += abs(x - as[j]);
}
//*/
cout << x << ' ' << f << newl;
}
}
}
#endif
| [
"variable_declaration.type.change",
"assignment.change",
"expression.operator.change"
] | 855,089 | 855,088 | u211255607 | cpp |
p03040 | #include <algorithm>
#include <bits/stdc++.h>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
using edge = struct {
ll to;
ll cost;
};
using point = struct {
ll x;
ll y;
};
typedef string str;
typedef std::pair<ll, ll> pl;
typedef std::pair<ll, pl> pl3;
typedef std::map<string, ll> msl;
typedef std::map<char, ll> mcl;
typedef std::map<ll, ll> mll;
typedef std::vector<ll> vl;
typedef std::vector<pl> vpl;
typedef std::vector<point> vxy;
typedef std::vector<pl3> vpl3;
typedef std::priority_queue<ll> pq;
typedef std::priority_queue<ll, vl, greater<ll>>
pql; // priority queue taking from the lower value.
typedef std::vector<edge> gr;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
const ll INF = MOD * MOD;
const long double EPS = 1e-9;
const long double PI = 3.14159265358979323846;
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define revrep(i, n) for (ll(i) = n - 1; (i) >= 0; (i)--)
#define For(i, a, b) for (ll(i) = (a); (i) < (b); (i)++)
#define revFor(i, b, a) for (ll(i) = (b)-1; (i) >= (a); (i)--)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isUpper(c) ('a' - c > 0)
#define isNum(c) (0 <= (c) - '0' && (c) - '0' <= 9)
#define toLower(c) char((c) + 0x20)
#define toUpper(c) char((c)-0x20)
#define pb push_back
#define mp make_pair
#define pr(a) cout << (a)
#define prl(a) cout << (a) << endl
#define prl2(a, b) cout << (a) << " " << (b) << endl
#define prl3(a, b, c) cout << (a) << " " << (b) << " " << (c) << endl
#define prl4(a, b, c, d) \
cout << (a) << " " << (b) << " " << (c) << " " << (d) << endl
#define prs(a) cout << (a) << " "
#define yn(condition) \
if ((condition)) \
prl("Yes"); \
else \
prl("No");
#define YN(condition) \
if ((condition)) \
prl("YES"); \
else \
prl("NO");
#define in1(a) cin >> (a)
#define in2(a, b) cin >> (a) >> (b)
#define in3(a, b, c) cin >> (a) >> (b) >> (c)
#define in4(a, b, c, d) cin >> (a) >> (b) >> (c) >> (d)
#define e1 first
#define e2 second
#define ctol(c) ll((c)) - ll('0')
#define ltos(n) to_string((n))
#define items(kv, v) for (auto &(kv) : (v))
#define ndig(N, n) ctol(ll(ltos((N))[ll(ltos((N)).length()) - (n)]))
#define rsort(a, n) sort(a, a + n, greater<>())
#define Forchar(c, a, z) for (char(c) = (a); (c) <= (z); (c)++)
#define cntchar(s, c) count(all((s)), c)
#define substring(s, start, end) s.substr((start), (end) - (start) + 1)
#define prl_nd(num, digits) \
cout << fixed << setprecision(digits) << (num) << endl;
#define XOR(a, b) (a) ^ (b)
#define prl_time(s) \
prl3("Elapsed Time:", 1000.0 * (clock() - s) / CLOCKS_PER_SEC, "[ms]");
#define char_to_str(c) string(1, (c))
#define bin_expression(n, dig) bitset<(dig)>(n)
#define DEBUG(x) cerr << #x << ": " << (x) << endl
#define DEBUG_VEC(v) \
cerr << #v << ": "; \
rep(__i, (v).size()) cerr << ((v)[__i]) << ", "; \
cerr << endl
struct MaxFlow {
struct F_edge {
ll to, rev, capacity;
F_edge(ll to, ll rev, ll capacity) : to(to), rev(rev), capacity(capacity) {}
};
typedef vector<F_edge> F_edges;
vector<F_edges> graph;
ll n_vertex;
// level is the shortest path to get a given node from the source node.
vl level, iter;
MaxFlow(ll n_vertex) : n_vertex(n_vertex) { graph.resize(n_vertex); }
void add_edge(ll from, ll to, ll capacity) {
graph[from].pb({to, ll(graph[to].size()), capacity});
graph[to].pb({from, ll(graph[from].size()) - 1, 0});
}
void bfs(ll source) {
level = vl(n_vertex, -1);
level[source] = 0;
queue<ll> q;
q.push(source);
while (!q.empty()) {
ll vertex = q.front();
q.pop();
rep(i, graph[vertex].size()) {
ll target = graph[vertex][i].to;
ll cap_target = graph[vertex][i].capacity;
// if the flow can be into the target node, implement below.
if (cap_target > 0 && level[target] < 0) {
level[target] = level[vertex] + 1;
q.push(target);
}
}
}
}
ll dfs(ll vertex, ll sink, ll flow) {
if (vertex == sink)
return flow;
for (ll &i = iter[vertex]; i < graph[vertex].size(); i++) {
ll target = graph[vertex][i].to;
ll cap_target = graph[vertex][i].capacity;
ll rev_target = graph[vertex][i].rev;
// if capasitiy is not full yet and target is farther,
// then assign current flow
if (cap_target > 0 && level[vertex] < level[target]) {
ll d = dfs(target, sink, min(cap_target, flow));
if (d > 0) { // if the flow successfully reaches the sink, reduce the
// flow from the capacity
graph[vertex][i].capacity -= d;
graph[target][rev_target].capacity += d;
return d;
}
}
}
return 0;
}
ll dinic(ll source, ll sink) {
ll flow = 0;
while (true) {
bfs(source);
// if there is no path leading to the sink, the maximum flow is 0.
if (level[sink] < 0)
return flow;
iter = vl(n_vertex, 0);
ll f;
while ((f = dfs(source, sink, INF)) > 0)
flow += f;
}
}
};
class UnionFind {
vl parents, set_size;
public:
UnionFind() {}
UnionFind(ll n) {
parents = set_size = vl(n);
rep(i, n) {
parents[i] = i;
set_size[i] = 1LL;
}
}
ll root_find(ll x) {
if (parents[x] == x)
return x;
return parents[x] = root_find(parents[x]);
}
void unite(ll x, ll y) {
x = root_find(x);
y = root_find(y);
if (x == y)
return;
if (set_size[x] < set_size[y]) {
parents[y] = x;
set_size[x] += set_size[y];
} else {
parents[x] = y;
set_size[y] += set_size[x];
}
}
bool is_same(ll x, ll y) { // connected or not
return root_find(x) == root_find(y);
}
ll size(ll x) { return set_size[root_find(x)]; }
};
/*
class LCA{
public:
ll N, logN;
vl depth, len;
gr tree[200005]; // global declaration later.
vector<vl> parents;
LCA(ll n){
N = n;
logN = 0;
while (N > (1LL << logN)) logN++;
depth = vl(N); len = vl(N);
parents = vector<vl>(logN, vl(N));
init(0, -1, 0, 0);
build();
}
void init(ll source, ll parent, ll d, ll l){
depth[source] = d;
parents[0][source] = parent;
len[source] = l;
rep(i, tree[source].size()){
ll target = tree[source][i].to;
ll cost = tree[source][i].cost;
if (target == parent) continue;
init(target, source, d + 1, cost + l);
}
}
void build(){
rep(k, logN - 1) rep(n, N){
// if there is no parent, -1.
// otherwise, the parent of the parent is the parent.
if (parents[k][n] < 0) parents[k + 1][n] = -1;
else parents[k + 1][n] = parents[k][parents[k][n]];
}
}
ll query(ll u, ll v){
if (depth[u] > depth[v]) swap(u, v);
rep(k, logN) if ((depth[v] - depth[u]) >> k & 1) v = parents[k][v];
if (u == v) return u;
revrep(k, logN){
if (parents[k][u] != parents[k][v]){
u = parents[k][u]; v = parents[k][v];
}
}
return parents[0][u];
}
ll distance(ll u, ll v){
ll w = query(u, v);
return len[u] + len[v] - 2 * len[w];
}
};
*/
struct BIT {
ll n;
vl tree_dat;
BIT(ll n) : tree_dat(n + 1, 0), n(n){};
// x: 1001 1010 1100 1011 1101 1111
// x & - x: 0001 0010 0100 0001 0001 0001
// ->: 1010 1100 10000 1100 1100 10000
ll update_func(ll val, ll dat) {
// if maximum -> max(val, dat)
// return max(val, dat);
// if cumulative sum
return val + dat;
}
ll query(ll i) {
/*
e.g.) i = 10101
itr1. 10101 -> 10100
itr2. 10100 -> 10000
itr3. 10000 -> 00000 (break)
*/
ll ret = 0;
for (ll j = i - 1; j >= 0; j = (j & (j + 1)) - 1) {
ret = update_func(ret, tree_dat[j]);
}
return ret;
}
ll lower_bound(ll key) {
if (key <= 0)
return 0;
ll left = 0, right = 1;
while (right <= n)
right *= 2;
for (ll i = right; i > 0; i /= 2) {
if (left + i <= n && tree_dat[left + i - 1] < key) {
key -= tree_dat[left + i - 1];
left += i;
}
}
return left;
}
void update(ll i, ll val) {
/*
e.g.) i = 10101, n = 11111
itr1. 10101 -> 10110
itr2. 10110 -> 11000
itr3. 11000 -> 100000 (break)
*/
if (i < 0)
return;
for (ll j = i; j < n; j |= j + 1) {
tree_dat[j] = update_func(val, tree_dat[j]);
}
}
};
ll gcd(ll m, ll n) {
ll a = max(m, n);
ll b = min(m, n);
while (b != 1 && b != 0) {
a %= b;
swap(a, b);
}
return b == 1 ? 1 : a;
}
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
ll power_mod(ll a, ll power, ll mod) {
ll value = 1;
while (power != 0) {
if (power & 1)
value = (value * a) % mod;
a = (a * a) % mod;
power = power >> 1;
}
return value % mod;
}
ll modinv(ll a, ll mod) { return power_mod(a, mod - 2, mod); }
ll power_normal(ll a, ll power) {
ll value = 1;
while (power != 0) {
if (power & 1)
value = value * a;
a = a * a;
power = power >> 1;
}
return value;
}
ll comb_memo[55][55];
ll pascal_triangle(ll n) {
comb_memo[0][0] = 1;
For(i, 1, n + 1) rep(j, i + 1) {
comb_memo[i][j] += comb_memo[i - 1][j];
if (j > 0)
comb_memo[i][j] += comb_memo[i - 1][j - 1];
}
}
ll combination(ll n, ll r, ll mod) {
if (n == r && n == 0)
return 1;
else if (n <= 0 || r < 0 || r > n)
return 0;
ll numerator = 1;
ll denomenator = 1;
for (ll i = 0; i < r; i++) {
(numerator *= ll(n - i)) %= mod;
(denomenator *= modinv(i + 1, mod)) %= mod;
}
return (numerator * denomenator) % mod;
}
ll combination_memo(ll n, ll r, ll pre, ll mod) {
// pre = nCr-1
// return nCr
if (n == r && n == 0)
return 1;
else if (n <= 0 || r < 0 || r > n)
return 0;
ll numerator = ll(n - r + 1) % mod;
ll denomenator = modinv(r, mod) % mod;
ll val = (numerator * denomenator) % mod;
val *= pre;
return val % mod;
}
ll combination_no_mod(ll n, ll r) {
if (n == r && n == 0)
return 1;
else if (n <= 0 || r < 0 || r > n)
return 0;
ll numerator = 1;
ll denomenator = 1;
for (ll i = 0; i < r; i++) {
numerator *= n - i;
denomenator *= i + 1;
ll g = gcd(numerator, denomenator);
numerator /= g;
denomenator /= g;
}
return numerator;
}
ld log_combination(ll n, ll r) {
if (n == r && n == 0)
return 0;
else if (n <= 0 || r < 0 || r > n)
return -INF;
ld val = 0;
for (ll i = 0; i < r; i++) {
val += log(n - i);
val -= log(i + 1);
}
return val;
}
ll bin_search(ll key, ll A[], ll left, ll right) {
// return the index idx where A[idx] = key.
// A[left] is start and A[right] is end..
// In other words, A[right], not A[right - 1], must be defined.
while (right >= left) {
ll mid = left + (right - left) / 2;
if (A[mid] == key)
return mid;
else if (A[mid] > key)
right = mid - 1;
else if (A[mid] < key)
left = mid + 1;
}
return -1;
}
/*
ll bin_search_temp(ll left, ll right, callable judge){
while(right > left){
// when seeking lower bound
ll mid = (right + left) / 2;
if (judge(mid)) right = mid;
else left = mid + 1;
// when seeking upper bound
ll mid = (right + left + 1) / 2;
if (judge(mid)) left = mid;
else right = mid - 1;
}
return right;
}
trinary_search
ld left = 0; ld right = p;
while(abs(right - left) > EPS){
ld left2 = (2 * left + right) / 3.0;
ld right2 = (left + 2 * right) / 3.0;
ld f1 = tak_func(left2);
ld f2 = tak_func(right2);
if (f1 <= f2) right = right2;
else if (f2 <= f1) left = left2;
}
*/
ll lower_bound_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value right instead of -1.
if (A[left] >= key)
return left;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == left) {
if (A[left] < key && key <= A[left + 1])
return left + 1;
else
return -1;
}
if (A[mid - 1] < key && key <= A[mid])
return mid;
else if (A[mid - 1] >= key)
right = mid - 1;
else if (A[mid] < key)
left = mid;
}
return -1; // all the elements < key
}
ll inf_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value right instead of -1.
if (A[left] > key)
return left;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == left) {
if (A[left] <= key && key < A[left + 1])
return left + 1;
else
return -1;
}
if (A[mid - 1] <= key && key < A[mid])
return mid;
else if (A[mid - 1] > key)
right = mid - 1;
else if (A[mid] <= key)
left = mid;
}
return -1; // all the elements <= key
}
ll upper_bound_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value left instead of -1.
if (A[right] <= key)
return right;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == right) {
if (A[right - 1] <= key && key < A[right])
return right - 1;
else
return -1;
}
if (A[mid] <= key && key < A[mid + 1])
return mid;
else if (A[mid] > key)
right = mid;
else if (A[mid + 1] <= key)
left = mid + 1;
}
return -1; // all the elements > key
}
ll sup_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value left instead of -1.
if (A[right] < key)
return right;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == right) {
if (A[right - 1] < key && key <= A[right])
return right - 1;
else
return -1;
}
if (A[mid] < key && key <= A[mid + 1])
return mid;
else if (A[mid] >= key)
right = mid;
else if (A[mid + 1] < key)
left = mid + 1;
}
return -1; // all the elements >= key
}
ll bin_search_vector(ll key, vl v, ll left, ll right) {
// return the index idx where v[idx] = key.
// v[left] is start and v[right] is end..
// In other words, v[right], not v[right - 1], must be defined.
while (right >= left) {
ll mid = left + (right - left) / 2;
if (v[mid] == key)
return mid;
else if (v[mid] > key)
right = mid - 1;
else if (v[mid] < key)
left = mid + 1;
}
return -1;
}
ll lower_bound_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N - 1] < key <= v[N]
// N == -1 if all the elements < key
return lower_bound(all(v), key) - v.begin();
}
ll inf_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N - 1] <= key < v[N] <= key + 1
// N == -1 if all the elements <= key
return lower_bound(all(v), key + 1) - v.begin();
}
ll upper_bound_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N] <= key < v[N + 1]
// N == -1 if all the elements > key
return upper_bound(all(v), key) - v.begin(); // (- 1)
}
ll sup_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N] <= key - 1 < key <= v[N + 1]
// N == -1 if all the elements >= key
return upper_bound(all(v), key - 1) - v.begin() - 1;
}
ll fact(ll n) {
if (n == 0)
return 1;
return n * fact(n - 1);
}
bool is_prime(ll n) {
if (n <= 1)
return false;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
ll bool_sum(ll a1, ll a2) {
if (a1 == 1 || a2 == 1)
return 1;
return 0;
}
mll prime_factorization(ll n) {
ll i = 2;
mll table;
while (i * i <= n) {
while (n % i == 0) {
table[i]++;
n /= i;
}
i++;
}
if (n > 1)
table[n] = 1;
return table;
}
vl divisor_table(ll n) {
vl table;
ll i = 1;
while (i * i <= n) {
if (n % i == 0) {
table.pb(i);
if (i * i != n)
table.pb(n / i);
}
i++;
}
sort(all(table));
return table;
}
ll char_to_idx(char c) {
ll idx = 0;
Forchar(cc, 'a', 'z') {
if (c == cc)
return idx;
else
idx++;
}
}
bool is_cross(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3, ll x4, ll y4) {
ll val1 = (x1 - x2) * (y3 - y1) + (y1 - y2) * (x1 - x3);
ll val2 = (x1 - x2) * (y4 - y1) + (y1 - y2) * (x1 - x4);
ll val3 = (x3 - x4) * (y1 - y3) + (y3 - y4) * (x3 - x1);
ll val4 = (x3 - x4) * (y2 - y3) + (y3 - y4) * (x3 - x2);
return val1 * val2 < 0 && val3 * val4 < 0;
}
ld space_of_triangle(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3) {
ll v1 = x2 - x1;
ll u1 = y2 - y1;
ll v2 = x3 - x1;
ll u2 = y3 - y1;
ld s = ld(v1 * u2 - u1 * v2) / ld(2);
return abs(s);
}
ll next_combination(ll sub) {
/*
ll n, k; ll bit = (1 << k) - 1;
for (; bit < (1 << n); bit = next_combination(bit)){
bool ith = bit & (1 << i);
procedures...
}
*/
ll x = sub & -sub, y = sub + x;
return (((sub & ~y) / x) >> 1) | y;
}
vl z_algorithm(str s) {
ll n = s.length();
vl res(n);
res[0] = n;
ll i1 = 1, i2 = 0;
while (i1 < n) {
while (i1 + i2 < n && s[i2] == s[i1 + i2])
++i2;
res[i1] = i2;
if (i2 == 0) {
++i1;
continue;
}
ll i3 = 1;
while (i1 + i3 < n && i3 + res[i3] < i2) {
res[i1 + i3] = res[i3];
++i3;
}
i1 += i3, i2 -= i3;
}
return res;
}
ll big_number_mod(str s, ll mod) {
ll l = s.length();
ll idx = 0;
ll val = 0;
ll tenth = 1;
while (idx < l) {
ll m = ctol(s[l - 1 - idx]);
val += (m * tenth) % mod;
val %= mod;
tenth *= 10;
tenth %= mod;
idx++;
}
return val;
}
ll string_to_ll(str s) {
ll l = s.length();
ll idx = 0;
ll val = 0;
ll tenth = 1;
while (idx < l) {
ll m = ctol(s[l - 1 - idx]);
val += (m * tenth);
tenth *= 10;
idx++;
}
return val;
}
str reflected_string(str s) {
str t, u;
ll n = s.length();
t = s;
reverse(all(t));
u = substring(t, 0, n - 2) + s + substring(t, 1, n - 1);
return u;
}
ld distance_between_point_line(ll xl1, ll yl1, ll xl2, ll yl2, ll xp, ll yp) {
ll a = yl2 - yl1;
ll b = -xl2 + xl1;
ll c = -a * xl2 - b * yl2;
return abs(ld(a * xp + b * yp + c)) / ld(sqrt(a * a + b * b));
}
ll inversion_number(vl a, ll a_max) {
/*
Paramters
---------
a: vector<ll>
All the elements must be non-negative.
Prefably the elements are compressed to reduce the computational cost.
a_max: ll
The maximum value of the vector a or the value bigger than the value
stated previously.
*/
BIT bit(a_max + 1);
ll val = 0;
rep(i, a.size()) {
// i is the number of elements that have lower index than a[i].
// call the number of elements that have lower value than a[i]
// by subtracting these two, the residual number is the number of elements
// that have larger value
val += i - bit.query(a[i]);
bit.update(a[i], 1);
}
return val;
}
template <typename T> vector<T> compress(vector<T> v) {
// sort and remove all the duplicated values
sort(all(v));
v.erase(unique(all(v)), v.end());
return v;
}
template <typename T> map<T, ll> dict(const vector<T> &v) {
map<T, ll> d;
rep(i, v.size()) d[v[i]] = i;
return d;
}
/*
const ll N_VERTEX = 310;
ll a, b, t;
ll dist[N_VERTEX][N_VERTEX];
void warshall_floyd(ll n){
// rep(i, n) rep(j, n) dist[i][j] = INF * (i != j);
rep(k, n) rep(i, n) rep(j, n) dist[i][j] = min(dist[i][j], dist[i][k] +
dist[k][j]);
}
int main(void){
in2(n, m);
rep(i, n) rep(j, n) dist[i][j] = INF * (i != j);
rep(i, m){
in3(a, b, t);
a--; b--;
dist[a][b] = t;
dist[b][a] = t;
}
warshall_floyd(n);
}
const ll N_VERTEX = 310;
gr graph[N_VERTEX];
ll dist[N_VERTEX], a, b, t, n, m;
void dijkstra(ll start, ll n) {
priority_queue<pl, vector<pl>, greater<pl>> edge_costs;
fill(dist, dist + n, INF);
dist[start] = 0;
edge_costs.push(pl(0, start));
while (!edge_costs.empty()) {
pl edge_cost = edge_costs.top();
edge_costs.pop();
ll idx = edge_cost.second;
ll cost = edge_cost.first;
if (dist[idx] < cost) continue;
rep(i, graph[idx].size()){
edge e = graph[idx][i];
if (dist[e.to] > dist[idx] + e.cost){
dist[e.to] = dist[idx] + e.cost;
edge_costs.push(pl(dist[e.to], e.to));
}
}
}
}
int main(void){
in2(n, m);
rep(i, m){
in3(a, b, t);
a--; b--;
G[a].pb({b, t});
G[b].pb({a, t});
}
dijkstra(0, n);
}
# ABC061D
bool bellman_ford(ll start, ll n, ll goal){
// if there is a closed circuit, it returns false. (when goal == -1)
// if the distance to goal cannot be obtained, it returns false (when goal
!= -1) fill(dist, dist + n, INF); dist[start] = 0; rep(i, n) rep(v, n) rep(k,
graph[v].size()){ edge e = graph[v][k]; if (dist[e.to] > dist[v] + e.cost){
dist[e.to] = dist[v] + e.cost;
if (i == n - 1 && (e.to == goal || goal == -1)) return false;
}
}
return true;
}
*/
/*
# 1. The usage of map pair
map<pl, ll> cnt;
cnt[{i, j}] = 0;
items(kv, cnt){
prl2(kv.first, kv.second);
}
# 2. The usage of next_permutation and combination (factorial search)
ll a[8];
rep(i, 8) a[i] = i;
sort(a, a + 8);
do{
}while(next_permutation(a, a+n));
// here, combination
ll n, r;
ll i1, i2, ..., ir;
For(i1, n - r, n) For(i2, n - r - 1, i1) ... For(ir, n - 2 * r + 1, irr){
process;}
# 3. bit search
ll n;
in1(n);
const ll base = 3;
ll upper = power_normal(base, n);
rep(i, upper){
ll tmp = i;
rep(j, n){
rep(k, base) if (tmp % base == k) prl(k);
tmp /= base;
}
}
# 4. imos method
// used when we would like to count the number which
// shows how many times the numbers between l and r belongs to smt.
// This method is composed of three process.
ll n, m, s[MAX_M], l, r;
in2(n, m);
rep(i, m) s[i] = 0;
// 1st step
rep(i, n){
in3(l, r, c);
l--; r--; // if l starts from 1.
s[l] += c; s[r + 1] -= c;
}
// 2nd step
rep(i, m - 1) s[i + 1] += s[i];
// 3rd step: judgement...
#5. shakutori method (syakutori)
// 1. strech right side while the condition is met.
// 2. renew the answer
// 3. increments left side
// 4. Back to 1. (l <= r must be satisfied all the time.)
ll l = 0; ll r = 0;
while (l < n){
r = max(r, l);
if (l == r) r++;
while(r < n && cond) r++;
answer += r - l; l++;
}
prl(answer);
#6. priority queue
pq q;
ll answer = 0;
ll v;
rep(i, n) q.push(a[i]);
rep(i, m){
v = q.top(); q.pop(); // get the top value and dump the value from queue
v /= 2; q.push(v); // add the new value
}
while(!q.empty()){
answer += q.top();
q.pop();
}
#7. The shortest path between the k-th edge and another edge (Tree)
ll depth[MAX_N];
gr tree[MAX_N];
void path(ll source, ll parent, ll all_cost){
depth[source] = all_cost;
items(e, tree[source]){
if (e.to == parent) continue;
dfs(e.to, source, all_cost + e.cost);
}
}
ll n, k, a, b, c;
in2(n, k);
rep(i, n - 1){
in3(a, b, c);
a--; b--;
tree[a].pb({b, c});
tree[b].pb({a, c});
}
k--;
dfs(k, -1, 0);
#10. Visiting Subtree using recurrent function (ABC138D)
gr tree[MAX_N];
ll c[MAX_N];
bool visited[MAX_N];
void dfs(ll source, ll parent, ll val){
visited[source] = true;
c[source] += val;
rep(i, tree[source].size()){
rep(i, m){ll res = n % match[i].e1;}
ll vertex = tree[source][i].to;
if (vertex == parent) continue;
dfs(vertex, source, c[source]);
}
}
#11. bfs ABC146D, ABC007C
1. first create a tree.
2. start searching from a node.
3. do some processes and push nodes connected with a given target node in
BFS.
4. repeat a series of procedure until queue is empty.
queue<pl> q;
void bfs(ll source, ll parents){
ll n_edge = G[source].size();
if (parents != -1) dist[source] = min(dist[source], dist[parents] + 1);
if (visited[source]) return;
visited[source] = true;
rep(idx, n_edge){
ll target = G[source][idx].to;
if (target == parents) continue;
q.push(mp(target, source));
}
}
q.push(mp(sg.e1, -1));
while(!q.empty()){
pl source = q.front(); q.pop();
bfs(source.e1, source.e2);
}
#12. grid to distance matrix (dx, dy)
ll w, h;
ll pos_to_idx(ll x, ll y){
return y * w + x;
}
pl idx_to_pos(ll idx){
return mp(idx % w, idx / w);
}
int main(void){
in2(h, w);
rep(y, h){
in1(s);
rep(x, w){
if (s[x] == '#') wall[x][y] = true;
else wall[x][y] = false;
}
}
rep(i1, h * w)rep(i2, h * w) dist[i1][i2] = INF * (i1 != i2);
rep(x, w)rep(y, h){
ll idx1 = pos_to_idx(x, y); ll idx2;
if (wall[x][y]) continue;
if (x != 0 && !wall[x - 1][y]){
idx2 = pos_to_idx(x - 1, y);
// if warshall floyd
dist[idx1][idx2] = 1;
// if dijkstra
// graph[idx1].pb({idx2, 1});
}
if (x != w - 1 && !wall[x + 1][y]){
idx2 = pos_to_idx(x + 1, y);
dist[idx1][idx2] = 1;
// graph[idx1].pb({idx2, 1});
}
if (y != 0 && !wall[x][y - 1]){
idx2 = pos_to_idx(x, y - 1);
dist[idx1][idx2] = 1;
// graph[idx1].pb({idx2, 1});
}
if (y != h - 1 && !wall[x][y + 1]){
idx2 = pos_to_idx(x, y + 1);
dist[idx1][idx2] = 1;
// graph[idx1].pb({idx2, 1});
}
}
}
*/
/*
# the operators regarding bit
& (AND), | (OR), ^ (XOR)
- (REVERSE), >> (SMALLER SHIFT)
<< (BIGGER SHIFT)
x1: 0000 0001 0010 0101 0110 0111 0111
x2: xxxx 0001 0011 0100 0101 1000 0110
x1 & x2: 0000 0001 0010 0100 0100 0000 0110
x: 1001 1010 1100 1011 1101 1111
x & - x: 0001 0010 0100 0001 0001 0001
sum: 1010 1100 10000 1100 1100 10000
x << y is x * 2 ** y
x >> y is rep(i, y) x = x // 2
Let S be a bit sequence and i be a non-negative integer
S & (1 << i) -> if true, i in S
S | (1 << i) -> S union {i}
S & -(1 << i) -> S - {i}
__builtin_popcount(S) -> the number of elements in S
S = 0 -> S is an empty set
S = (1 << n) - 1 -> S includes all the elements up to the n-th
#Conditional Operator
condition ? true : false;
#iterator
type declaration: auto
value reference: *itr
increment: itr++
decrement: itr--
substitution of value: *itr = smt
*/
const ll MAX_N = 200005;
bool okay = false;
ll answer = 0;
ll q;
void solve() {
vl ts(q), as(q), bs(q);
rep(i, q) {
in1(ts[i]);
if (ts[i] == 1)
in2(as[i], bs[i]);
}
vl vs(as);
vs.pb(-MOD);
vs.pb(MOD);
vs = compress(vs);
mll d = dict(vs);
BIT bit1(vs.size() + 1);
BIT bit2(vs.size() + 1);
ll b_tot = 0, idx = 0;
rep(i, q) {
if (ts[i] == 1) {
bit1.update(d[as[i]], 1);
bit2.update(d[as[i]], as[i]);
b_tot += bs[i];
idx++;
} else {
ll lb = bit1.lower_bound((idx + 1) / 2);
ll med = vs[lb];
ll b2 = bit2.query(vs.size()) - bit2.query(lb + 1);
ll b1 = bit1.query(vs.size()) - bit1.query(lb + 1);
ll bl = bit1.query(lb) - bit2.query(lb);
ll fm = b2 - med * b1 + med * bl;
prl2(med, b_tot + fm);
}
}
// check negative MOD
// check index flow
// check overwrite of the input variables
}
int main(void) {
in1(q);
// assert(n <= 400);
solve();
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
using edge = struct {
ll to;
ll cost;
};
using point = struct {
ll x;
ll y;
};
typedef string str;
typedef std::pair<ll, ll> pl;
typedef std::pair<ll, pl> pl3;
typedef std::map<string, ll> msl;
typedef std::map<char, ll> mcl;
typedef std::map<ll, ll> mll;
typedef std::vector<ll> vl;
typedef std::vector<pl> vpl;
typedef std::vector<point> vxy;
typedef std::vector<pl3> vpl3;
typedef std::priority_queue<ll> pq;
typedef std::priority_queue<ll, vl, greater<ll>>
pql; // priority queue taking from the lower value.
typedef std::vector<edge> gr;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
const ll INF = MOD * MOD;
const long double EPS = 1e-9;
const long double PI = 3.14159265358979323846;
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define revrep(i, n) for (ll(i) = n - 1; (i) >= 0; (i)--)
#define For(i, a, b) for (ll(i) = (a); (i) < (b); (i)++)
#define revFor(i, b, a) for (ll(i) = (b)-1; (i) >= (a); (i)--)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isUpper(c) ('a' - c > 0)
#define isNum(c) (0 <= (c) - '0' && (c) - '0' <= 9)
#define toLower(c) char((c) + 0x20)
#define toUpper(c) char((c)-0x20)
#define pb push_back
#define mp make_pair
#define pr(a) cout << (a)
#define prl(a) cout << (a) << endl
#define prl2(a, b) cout << (a) << " " << (b) << endl
#define prl3(a, b, c) cout << (a) << " " << (b) << " " << (c) << endl
#define prl4(a, b, c, d) \
cout << (a) << " " << (b) << " " << (c) << " " << (d) << endl
#define prs(a) cout << (a) << " "
#define yn(condition) \
if ((condition)) \
prl("Yes"); \
else \
prl("No");
#define YN(condition) \
if ((condition)) \
prl("YES"); \
else \
prl("NO");
#define in1(a) cin >> (a)
#define in2(a, b) cin >> (a) >> (b)
#define in3(a, b, c) cin >> (a) >> (b) >> (c)
#define in4(a, b, c, d) cin >> (a) >> (b) >> (c) >> (d)
#define e1 first
#define e2 second
#define ctol(c) ll((c)) - ll('0')
#define ltos(n) to_string((n))
#define items(kv, v) for (auto &(kv) : (v))
#define ndig(N, n) ctol(ll(ltos((N))[ll(ltos((N)).length()) - (n)]))
#define rsort(a, n) sort(a, a + n, greater<>())
#define Forchar(c, a, z) for (char(c) = (a); (c) <= (z); (c)++)
#define cntchar(s, c) count(all((s)), c)
#define substring(s, start, end) s.substr((start), (end) - (start) + 1)
#define prl_nd(num, digits) \
cout << fixed << setprecision(digits) << (num) << endl;
#define XOR(a, b) (a) ^ (b)
#define prl_time(s) \
prl3("Elapsed Time:", 1000.0 * (clock() - s) / CLOCKS_PER_SEC, "[ms]");
#define char_to_str(c) string(1, (c))
#define bin_expression(n, dig) bitset<(dig)>(n)
#define DEBUG(x) cerr << #x << ": " << (x) << endl
#define DEBUG_VEC(v) \
cerr << #v << ": "; \
rep(__i, (v).size()) cerr << ((v)[__i]) << ", "; \
cerr << endl
struct MaxFlow {
struct F_edge {
ll to, rev, capacity;
F_edge(ll to, ll rev, ll capacity) : to(to), rev(rev), capacity(capacity) {}
};
typedef vector<F_edge> F_edges;
vector<F_edges> graph;
ll n_vertex;
// level is the shortest path to get a given node from the source node.
vl level, iter;
MaxFlow(ll n_vertex) : n_vertex(n_vertex) { graph.resize(n_vertex); }
void add_edge(ll from, ll to, ll capacity) {
graph[from].pb({to, ll(graph[to].size()), capacity});
graph[to].pb({from, ll(graph[from].size()) - 1, 0});
}
void bfs(ll source) {
level = vl(n_vertex, -1);
level[source] = 0;
queue<ll> q;
q.push(source);
while (!q.empty()) {
ll vertex = q.front();
q.pop();
rep(i, graph[vertex].size()) {
ll target = graph[vertex][i].to;
ll cap_target = graph[vertex][i].capacity;
// if the flow can be into the target node, implement below.
if (cap_target > 0 && level[target] < 0) {
level[target] = level[vertex] + 1;
q.push(target);
}
}
}
}
ll dfs(ll vertex, ll sink, ll flow) {
if (vertex == sink)
return flow;
for (ll &i = iter[vertex]; i < graph[vertex].size(); i++) {
ll target = graph[vertex][i].to;
ll cap_target = graph[vertex][i].capacity;
ll rev_target = graph[vertex][i].rev;
// if capasitiy is not full yet and target is farther,
// then assign current flow
if (cap_target > 0 && level[vertex] < level[target]) {
ll d = dfs(target, sink, min(cap_target, flow));
if (d > 0) { // if the flow successfully reaches the sink, reduce the
// flow from the capacity
graph[vertex][i].capacity -= d;
graph[target][rev_target].capacity += d;
return d;
}
}
}
return 0;
}
ll dinic(ll source, ll sink) {
ll flow = 0;
while (true) {
bfs(source);
// if there is no path leading to the sink, the maximum flow is 0.
if (level[sink] < 0)
return flow;
iter = vl(n_vertex, 0);
ll f;
while ((f = dfs(source, sink, INF)) > 0)
flow += f;
}
}
};
class UnionFind {
vl parents, set_size;
public:
UnionFind() {}
UnionFind(ll n) {
parents = set_size = vl(n);
rep(i, n) {
parents[i] = i;
set_size[i] = 1LL;
}
}
ll root_find(ll x) {
if (parents[x] == x)
return x;
return parents[x] = root_find(parents[x]);
}
void unite(ll x, ll y) {
x = root_find(x);
y = root_find(y);
if (x == y)
return;
if (set_size[x] < set_size[y]) {
parents[y] = x;
set_size[x] += set_size[y];
} else {
parents[x] = y;
set_size[y] += set_size[x];
}
}
bool is_same(ll x, ll y) { // connected or not
return root_find(x) == root_find(y);
}
ll size(ll x) { return set_size[root_find(x)]; }
};
/*
class LCA{
public:
ll N, logN;
vl depth, len;
gr tree[200005]; // global declaration later.
vector<vl> parents;
LCA(ll n){
N = n;
logN = 0;
while (N > (1LL << logN)) logN++;
depth = vl(N); len = vl(N);
parents = vector<vl>(logN, vl(N));
init(0, -1, 0, 0);
build();
}
void init(ll source, ll parent, ll d, ll l){
depth[source] = d;
parents[0][source] = parent;
len[source] = l;
rep(i, tree[source].size()){
ll target = tree[source][i].to;
ll cost = tree[source][i].cost;
if (target == parent) continue;
init(target, source, d + 1, cost + l);
}
}
void build(){
rep(k, logN - 1) rep(n, N){
// if there is no parent, -1.
// otherwise, the parent of the parent is the parent.
if (parents[k][n] < 0) parents[k + 1][n] = -1;
else parents[k + 1][n] = parents[k][parents[k][n]];
}
}
ll query(ll u, ll v){
if (depth[u] > depth[v]) swap(u, v);
rep(k, logN) if ((depth[v] - depth[u]) >> k & 1) v = parents[k][v];
if (u == v) return u;
revrep(k, logN){
if (parents[k][u] != parents[k][v]){
u = parents[k][u]; v = parents[k][v];
}
}
return parents[0][u];
}
ll distance(ll u, ll v){
ll w = query(u, v);
return len[u] + len[v] - 2 * len[w];
}
};
*/
struct BIT {
ll n;
vl tree_dat;
BIT(ll n) : tree_dat(n + 1, 0), n(n){};
// x: 1001 1010 1100 1011 1101 1111
// x & - x: 0001 0010 0100 0001 0001 0001
// ->: 1010 1100 10000 1100 1100 10000
ll update_func(ll val, ll dat) {
// if maximum -> max(val, dat)
// return max(val, dat);
// if cumulative sum
return val + dat;
}
ll query(ll i) {
/*
e.g.) i = 10101
itr1. 10101 -> 10100
itr2. 10100 -> 10000
itr3. 10000 -> 00000 (break)
*/
ll ret = 0;
for (ll j = i - 1; j >= 0; j = (j & (j + 1)) - 1) {
ret = update_func(ret, tree_dat[j]);
}
return ret;
}
ll lower_bound(ll key) {
if (key <= 0)
return 0;
ll left = 0, right = 1;
while (right <= n)
right *= 2;
for (ll i = right; i > 0; i /= 2) {
if (left + i <= n && tree_dat[left + i - 1] < key) {
key -= tree_dat[left + i - 1];
left += i;
}
}
return left;
}
void update(ll i, ll val) {
/*
e.g.) i = 10101, n = 11111
itr1. 10101 -> 10110
itr2. 10110 -> 11000
itr3. 11000 -> 100000 (break)
*/
if (i < 0)
return;
for (ll j = i; j < n; j |= j + 1) {
tree_dat[j] = update_func(val, tree_dat[j]);
}
}
};
ll gcd(ll m, ll n) {
ll a = max(m, n);
ll b = min(m, n);
while (b != 1 && b != 0) {
a %= b;
swap(a, b);
}
return b == 1 ? 1 : a;
}
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
ll power_mod(ll a, ll power, ll mod) {
ll value = 1;
while (power != 0) {
if (power & 1)
value = (value * a) % mod;
a = (a * a) % mod;
power = power >> 1;
}
return value % mod;
}
ll modinv(ll a, ll mod) { return power_mod(a, mod - 2, mod); }
ll power_normal(ll a, ll power) {
ll value = 1;
while (power != 0) {
if (power & 1)
value = value * a;
a = a * a;
power = power >> 1;
}
return value;
}
ll comb_memo[55][55];
ll pascal_triangle(ll n) {
comb_memo[0][0] = 1;
For(i, 1, n + 1) rep(j, i + 1) {
comb_memo[i][j] += comb_memo[i - 1][j];
if (j > 0)
comb_memo[i][j] += comb_memo[i - 1][j - 1];
}
}
ll combination(ll n, ll r, ll mod) {
if (n == r && n == 0)
return 1;
else if (n <= 0 || r < 0 || r > n)
return 0;
ll numerator = 1;
ll denomenator = 1;
for (ll i = 0; i < r; i++) {
(numerator *= ll(n - i)) %= mod;
(denomenator *= modinv(i + 1, mod)) %= mod;
}
return (numerator * denomenator) % mod;
}
ll combination_memo(ll n, ll r, ll pre, ll mod) {
// pre = nCr-1
// return nCr
if (n == r && n == 0)
return 1;
else if (n <= 0 || r < 0 || r > n)
return 0;
ll numerator = ll(n - r + 1) % mod;
ll denomenator = modinv(r, mod) % mod;
ll val = (numerator * denomenator) % mod;
val *= pre;
return val % mod;
}
ll combination_no_mod(ll n, ll r) {
if (n == r && n == 0)
return 1;
else if (n <= 0 || r < 0 || r > n)
return 0;
ll numerator = 1;
ll denomenator = 1;
for (ll i = 0; i < r; i++) {
numerator *= n - i;
denomenator *= i + 1;
ll g = gcd(numerator, denomenator);
numerator /= g;
denomenator /= g;
}
return numerator;
}
ld log_combination(ll n, ll r) {
if (n == r && n == 0)
return 0;
else if (n <= 0 || r < 0 || r > n)
return -INF;
ld val = 0;
for (ll i = 0; i < r; i++) {
val += log(n - i);
val -= log(i + 1);
}
return val;
}
ll bin_search(ll key, ll A[], ll left, ll right) {
// return the index idx where A[idx] = key.
// A[left] is start and A[right] is end..
// In other words, A[right], not A[right - 1], must be defined.
while (right >= left) {
ll mid = left + (right - left) / 2;
if (A[mid] == key)
return mid;
else if (A[mid] > key)
right = mid - 1;
else if (A[mid] < key)
left = mid + 1;
}
return -1;
}
/*
ll bin_search_temp(ll left, ll right, callable judge){
while(right > left){
// when seeking lower bound
ll mid = (right + left) / 2;
if (judge(mid)) right = mid;
else left = mid + 1;
// when seeking upper bound
ll mid = (right + left + 1) / 2;
if (judge(mid)) left = mid;
else right = mid - 1;
}
return right;
}
trinary_search
ld left = 0; ld right = p;
while(abs(right - left) > EPS){
ld left2 = (2 * left + right) / 3.0;
ld right2 = (left + 2 * right) / 3.0;
ld f1 = tak_func(left2);
ld f2 = tak_func(right2);
if (f1 <= f2) right = right2;
else if (f2 <= f1) left = left2;
}
*/
ll lower_bound_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value right instead of -1.
if (A[left] >= key)
return left;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == left) {
if (A[left] < key && key <= A[left + 1])
return left + 1;
else
return -1;
}
if (A[mid - 1] < key && key <= A[mid])
return mid;
else if (A[mid - 1] >= key)
right = mid - 1;
else if (A[mid] < key)
left = mid;
}
return -1; // all the elements < key
}
ll inf_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value right instead of -1.
if (A[left] > key)
return left;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == left) {
if (A[left] <= key && key < A[left + 1])
return left + 1;
else
return -1;
}
if (A[mid - 1] <= key && key < A[mid])
return mid;
else if (A[mid - 1] > key)
right = mid - 1;
else if (A[mid] <= key)
left = mid;
}
return -1; // all the elements <= key
}
ll upper_bound_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value left instead of -1.
if (A[right] <= key)
return right;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == right) {
if (A[right - 1] <= key && key < A[right])
return right - 1;
else
return -1;
}
if (A[mid] <= key && key < A[mid + 1])
return mid;
else if (A[mid] > key)
right = mid;
else if (A[mid + 1] <= key)
left = mid + 1;
}
return -1; // all the elements > key
}
ll sup_bin_search_temp(ll key, ll A[], ll left, ll right) {
// Pay attention to the return value -1.
// For example, sometimes you may want the value left instead of -1.
if (A[right] < key)
return right;
ll mid = left + (right - left) / 2;
while (right >= left) {
mid = left + (right - left) / 2;
if (mid == right) {
if (A[right - 1] < key && key <= A[right])
return right - 1;
else
return -1;
}
if (A[mid] < key && key <= A[mid + 1])
return mid;
else if (A[mid] >= key)
right = mid;
else if (A[mid + 1] < key)
left = mid + 1;
}
return -1; // all the elements >= key
}
ll bin_search_vector(ll key, vl v, ll left, ll right) {
// return the index idx where v[idx] = key.
// v[left] is start and v[right] is end..
// In other words, v[right], not v[right - 1], must be defined.
while (right >= left) {
ll mid = left + (right - left) / 2;
if (v[mid] == key)
return mid;
else if (v[mid] > key)
right = mid - 1;
else if (v[mid] < key)
left = mid + 1;
}
return -1;
}
ll lower_bound_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N - 1] < key <= v[N]
// N == -1 if all the elements < key
return lower_bound(all(v), key) - v.begin();
}
ll inf_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N - 1] <= key < v[N] <= key + 1
// N == -1 if all the elements <= key
return lower_bound(all(v), key + 1) - v.begin();
}
ll upper_bound_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N] <= key < v[N + 1]
// N == -1 if all the elements > key
return upper_bound(all(v), key) - v.begin(); // (- 1)
}
ll sup_bin_search_vector(ll key, vl v) {
// the return value N satisfies
// v[N] <= key - 1 < key <= v[N + 1]
// N == -1 if all the elements >= key
return upper_bound(all(v), key - 1) - v.begin() - 1;
}
ll fact(ll n) {
if (n == 0)
return 1;
return n * fact(n - 1);
}
bool is_prime(ll n) {
if (n <= 1)
return false;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
ll bool_sum(ll a1, ll a2) {
if (a1 == 1 || a2 == 1)
return 1;
return 0;
}
mll prime_factorization(ll n) {
ll i = 2;
mll table;
while (i * i <= n) {
while (n % i == 0) {
table[i]++;
n /= i;
}
i++;
}
if (n > 1)
table[n] = 1;
return table;
}
vl divisor_table(ll n) {
vl table;
ll i = 1;
while (i * i <= n) {
if (n % i == 0) {
table.pb(i);
if (i * i != n)
table.pb(n / i);
}
i++;
}
sort(all(table));
return table;
}
ll char_to_idx(char c) {
ll idx = 0;
Forchar(cc, 'a', 'z') {
if (c == cc)
return idx;
else
idx++;
}
}
bool is_cross(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3, ll x4, ll y4) {
ll val1 = (x1 - x2) * (y3 - y1) + (y1 - y2) * (x1 - x3);
ll val2 = (x1 - x2) * (y4 - y1) + (y1 - y2) * (x1 - x4);
ll val3 = (x3 - x4) * (y1 - y3) + (y3 - y4) * (x3 - x1);
ll val4 = (x3 - x4) * (y2 - y3) + (y3 - y4) * (x3 - x2);
return val1 * val2 < 0 && val3 * val4 < 0;
}
ld space_of_triangle(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3) {
ll v1 = x2 - x1;
ll u1 = y2 - y1;
ll v2 = x3 - x1;
ll u2 = y3 - y1;
ld s = ld(v1 * u2 - u1 * v2) / ld(2);
return abs(s);
}
ll next_combination(ll sub) {
/*
ll n, k; ll bit = (1 << k) - 1;
for (; bit < (1 << n); bit = next_combination(bit)){
bool ith = bit & (1 << i);
procedures...
}
*/
ll x = sub & -sub, y = sub + x;
return (((sub & ~y) / x) >> 1) | y;
}
vl z_algorithm(str s) {
ll n = s.length();
vl res(n);
res[0] = n;
ll i1 = 1, i2 = 0;
while (i1 < n) {
while (i1 + i2 < n && s[i2] == s[i1 + i2])
++i2;
res[i1] = i2;
if (i2 == 0) {
++i1;
continue;
}
ll i3 = 1;
while (i1 + i3 < n && i3 + res[i3] < i2) {
res[i1 + i3] = res[i3];
++i3;
}
i1 += i3, i2 -= i3;
}
return res;
}
ll big_number_mod(str s, ll mod) {
ll l = s.length();
ll idx = 0;
ll val = 0;
ll tenth = 1;
while (idx < l) {
ll m = ctol(s[l - 1 - idx]);
val += (m * tenth) % mod;
val %= mod;
tenth *= 10;
tenth %= mod;
idx++;
}
return val;
}
ll string_to_ll(str s) {
ll l = s.length();
ll idx = 0;
ll val = 0;
ll tenth = 1;
while (idx < l) {
ll m = ctol(s[l - 1 - idx]);
val += (m * tenth);
tenth *= 10;
idx++;
}
return val;
}
str reflected_string(str s) {
str t, u;
ll n = s.length();
t = s;
reverse(all(t));
u = substring(t, 0, n - 2) + s + substring(t, 1, n - 1);
return u;
}
ld distance_between_point_line(ll xl1, ll yl1, ll xl2, ll yl2, ll xp, ll yp) {
ll a = yl2 - yl1;
ll b = -xl2 + xl1;
ll c = -a * xl2 - b * yl2;
return abs(ld(a * xp + b * yp + c)) / ld(sqrt(a * a + b * b));
}
ll inversion_number(vl a, ll a_max) {
/*
Paramters
---------
a: vector<ll>
All the elements must be non-negative.
Prefably the elements are compressed to reduce the computational cost.
a_max: ll
The maximum value of the vector a or the value bigger than the value
stated previously.
*/
BIT bit(a_max + 1);
ll val = 0;
rep(i, a.size()) {
// i is the number of elements that have lower index than a[i].
// call the number of elements that have lower value than a[i]
// by subtracting these two, the residual number is the number of elements
// that have larger value
val += i - bit.query(a[i]);
bit.update(a[i], 1);
}
return val;
}
template <typename T> vector<T> compress(vector<T> v) {
// sort and remove all the duplicated values
sort(all(v));
v.erase(unique(all(v)), v.end());
return v;
}
template <typename T> map<T, ll> dict(const vector<T> &v) {
map<T, ll> d;
rep(i, v.size()) d[v[i]] = i;
return d;
}
/*
const ll N_VERTEX = 310;
ll a, b, t;
ll dist[N_VERTEX][N_VERTEX];
void warshall_floyd(ll n){
// rep(i, n) rep(j, n) dist[i][j] = INF * (i != j);
rep(k, n) rep(i, n) rep(j, n) dist[i][j] = min(dist[i][j], dist[i][k] +
dist[k][j]);
}
int main(void){
in2(n, m);
rep(i, n) rep(j, n) dist[i][j] = INF * (i != j);
rep(i, m){
in3(a, b, t);
a--; b--;
dist[a][b] = t;
dist[b][a] = t;
}
warshall_floyd(n);
}
const ll N_VERTEX = 310;
gr graph[N_VERTEX];
ll dist[N_VERTEX], a, b, t, n, m;
void dijkstra(ll start, ll n) {
priority_queue<pl, vector<pl>, greater<pl>> edge_costs;
fill(dist, dist + n, INF);
dist[start] = 0;
edge_costs.push(pl(0, start));
while (!edge_costs.empty()) {
pl edge_cost = edge_costs.top();
edge_costs.pop();
ll idx = edge_cost.second;
ll cost = edge_cost.first;
if (dist[idx] < cost) continue;
rep(i, graph[idx].size()){
edge e = graph[idx][i];
if (dist[e.to] > dist[idx] + e.cost){
dist[e.to] = dist[idx] + e.cost;
edge_costs.push(pl(dist[e.to], e.to));
}
}
}
}
int main(void){
in2(n, m);
rep(i, m){
in3(a, b, t);
a--; b--;
G[a].pb({b, t});
G[b].pb({a, t});
}
dijkstra(0, n);
}
# ABC061D
bool bellman_ford(ll start, ll n, ll goal){
// if there is a closed circuit, it returns false. (when goal == -1)
// if the distance to goal cannot be obtained, it returns false (when goal
!= -1) fill(dist, dist + n, INF); dist[start] = 0; rep(i, n) rep(v, n) rep(k,
graph[v].size()){ edge e = graph[v][k]; if (dist[e.to] > dist[v] + e.cost){
dist[e.to] = dist[v] + e.cost;
if (i == n - 1 && (e.to == goal || goal == -1)) return false;
}
}
return true;
}
*/
/*
# 1. The usage of map pair
map<pl, ll> cnt;
cnt[{i, j}] = 0;
items(kv, cnt){
prl2(kv.first, kv.second);
}
# 2. The usage of next_permutation and combination (factorial search)
ll a[8];
rep(i, 8) a[i] = i;
sort(a, a + 8);
do{
}while(next_permutation(a, a+n));
// here, combination
ll n, r;
ll i1, i2, ..., ir;
For(i1, n - r, n) For(i2, n - r - 1, i1) ... For(ir, n - 2 * r + 1, irr){
process;}
# 3. bit search
ll n;
in1(n);
const ll base = 3;
ll upper = power_normal(base, n);
rep(i, upper){
ll tmp = i;
rep(j, n){
rep(k, base) if (tmp % base == k) prl(k);
tmp /= base;
}
}
# 4. imos method
// used when we would like to count the number which
// shows how many times the numbers between l and r belongs to smt.
// This method is composed of three process.
ll n, m, s[MAX_M], l, r;
in2(n, m);
rep(i, m) s[i] = 0;
// 1st step
rep(i, n){
in3(l, r, c);
l--; r--; // if l starts from 1.
s[l] += c; s[r + 1] -= c;
}
// 2nd step
rep(i, m - 1) s[i + 1] += s[i];
// 3rd step: judgement...
#5. shakutori method (syakutori)
// 1. strech right side while the condition is met.
// 2. renew the answer
// 3. increments left side
// 4. Back to 1. (l <= r must be satisfied all the time.)
ll l = 0; ll r = 0;
while (l < n){
r = max(r, l);
if (l == r) r++;
while(r < n && cond) r++;
answer += r - l; l++;
}
prl(answer);
#6. priority queue
pq q;
ll answer = 0;
ll v;
rep(i, n) q.push(a[i]);
rep(i, m){
v = q.top(); q.pop(); // get the top value and dump the value from queue
v /= 2; q.push(v); // add the new value
}
while(!q.empty()){
answer += q.top();
q.pop();
}
#7. The shortest path between the k-th edge and another edge (Tree)
ll depth[MAX_N];
gr tree[MAX_N];
void path(ll source, ll parent, ll all_cost){
depth[source] = all_cost;
items(e, tree[source]){
if (e.to == parent) continue;
dfs(e.to, source, all_cost + e.cost);
}
}
ll n, k, a, b, c;
in2(n, k);
rep(i, n - 1){
in3(a, b, c);
a--; b--;
tree[a].pb({b, c});
tree[b].pb({a, c});
}
k--;
dfs(k, -1, 0);
#10. Visiting Subtree using recurrent function (ABC138D)
gr tree[MAX_N];
ll c[MAX_N];
bool visited[MAX_N];
void dfs(ll source, ll parent, ll val){
visited[source] = true;
c[source] += val;
rep(i, tree[source].size()){
rep(i, m){ll res = n % match[i].e1;}
ll vertex = tree[source][i].to;
if (vertex == parent) continue;
dfs(vertex, source, c[source]);
}
}
#11. bfs ABC146D, ABC007C
1. first create a tree.
2. start searching from a node.
3. do some processes and push nodes connected with a given target node in
BFS.
4. repeat a series of procedure until queue is empty.
queue<pl> q;
void bfs(ll source, ll parents){
ll n_edge = G[source].size();
if (parents != -1) dist[source] = min(dist[source], dist[parents] + 1);
if (visited[source]) return;
visited[source] = true;
rep(idx, n_edge){
ll target = G[source][idx].to;
if (target == parents) continue;
q.push(mp(target, source));
}
}
q.push(mp(sg.e1, -1));
while(!q.empty()){
pl source = q.front(); q.pop();
bfs(source.e1, source.e2);
}
#12. grid to distance matrix (dx, dy)
ll w, h;
ll pos_to_idx(ll x, ll y){
return y * w + x;
}
pl idx_to_pos(ll idx){
return mp(idx % w, idx / w);
}
int main(void){
in2(h, w);
rep(y, h){
in1(s);
rep(x, w){
if (s[x] == '#') wall[x][y] = true;
else wall[x][y] = false;
}
}
rep(i1, h * w)rep(i2, h * w) dist[i1][i2] = INF * (i1 != i2);
rep(x, w)rep(y, h){
ll idx1 = pos_to_idx(x, y); ll idx2;
if (wall[x][y]) continue;
if (x != 0 && !wall[x - 1][y]){
idx2 = pos_to_idx(x - 1, y);
// if warshall floyd
dist[idx1][idx2] = 1;
// if dijkstra
// graph[idx1].pb({idx2, 1});
}
if (x != w - 1 && !wall[x + 1][y]){
idx2 = pos_to_idx(x + 1, y);
dist[idx1][idx2] = 1;
// graph[idx1].pb({idx2, 1});
}
if (y != 0 && !wall[x][y - 1]){
idx2 = pos_to_idx(x, y - 1);
dist[idx1][idx2] = 1;
// graph[idx1].pb({idx2, 1});
}
if (y != h - 1 && !wall[x][y + 1]){
idx2 = pos_to_idx(x, y + 1);
dist[idx1][idx2] = 1;
// graph[idx1].pb({idx2, 1});
}
}
}
*/
/*
# the operators regarding bit
& (AND), | (OR), ^ (XOR)
- (REVERSE), >> (SMALLER SHIFT)
<< (BIGGER SHIFT)
x1: 0000 0001 0010 0101 0110 0111 0111
x2: xxxx 0001 0011 0100 0101 1000 0110
x1 & x2: 0000 0001 0010 0100 0100 0000 0110
x: 1001 1010 1100 1011 1101 1111
x & - x: 0001 0010 0100 0001 0001 0001
sum: 1010 1100 10000 1100 1100 10000
x << y is x * 2 ** y
x >> y is rep(i, y) x = x // 2
Let S be a bit sequence and i be a non-negative integer
S & (1 << i) -> if true, i in S
S | (1 << i) -> S union {i}
S & -(1 << i) -> S - {i}
__builtin_popcount(S) -> the number of elements in S
S = 0 -> S is an empty set
S = (1 << n) - 1 -> S includes all the elements up to the n-th
#Conditional Operator
condition ? true : false;
#iterator
type declaration: auto
value reference: *itr
increment: itr++
decrement: itr--
substitution of value: *itr = smt
*/
const ll MAX_N = 200005;
bool okay = false;
ll answer = 0;
ll q;
void solve() {
vl ts(q), as(q), bs(q);
rep(i, q) {
in1(ts[i]);
if (ts[i] == 1)
in2(as[i], bs[i]);
}
vl vs(as);
vs.pb(-MOD);
vs.pb(MOD);
vs = compress(vs);
mll d = dict(vs);
BIT bit1(vs.size() + 1);
BIT bit2(vs.size() + 1);
ll b_tot = 0, idx = 0;
rep(i, q) {
if (ts[i] == 1) {
bit1.update(d[as[i]], 1);
bit2.update(d[as[i]], as[i]);
b_tot += bs[i];
idx++;
} else {
ll lb = bit1.lower_bound((idx + 1) / 2);
ll med = vs[lb];
ll b2 = bit2.query(vs.size()) - bit2.query(lb + 1);
ll b1 = bit1.query(vs.size()) - bit1.query(lb + 1);
ll bl = med * bit1.query(lb) - bit2.query(lb);
ll fm = b2 - med * b1 + bl;
prl2(med, b_tot + fm);
}
}
// check negative MOD
// check index flow
// check overwrite of the input variables
}
int main(void) {
in1(q);
// assert(n <= 400);
solve();
return 0;
} | [
"expression.operation.binary.remove"
] | 855,090 | 855,091 | u767543103 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, int a = -1, int b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<ll> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res += abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
}
else {
cout << median << " " << res << "\n";
}
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, int a = -1, int b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<int> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res = res + abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
}
else {
cout << median << " " << res << "\n";
}
}
} | [
"assignment.value.change",
"assignment.change"
] | 855,094 | 855,095 | u190018920 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, ll a = -1, ll b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<ll> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res += abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
} else {
cout << median << " " << res << "\n";
}
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, int a = -1, int b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<int> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res = res + abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
}
else {
cout << median << " " << res << "\n";
}
}
} | [
"assignment.value.change",
"assignment.change"
] | 855,096 | 855,095 | u190018920 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, int a = -1, int b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<ll> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res += abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
}
else {
cout << median << " " << res << "\n";
}
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, int a = -1, int b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<int> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res += (ll)abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
}
else {
cout << median << " " << res << "\n";
}
}
} | [
"type_conversion.add"
] | 855,094 | 855,097 | u190018920 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, ll a = -1, ll b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<ll> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res += abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
} else {
cout << median << " " << res << "\n";
}
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, double> Pid;
typedef pair<double, int> Pdi;
typedef pair<ll, int> Pl;
typedef pair<int, pair<int, int>> PP;
const double PI = 3.1415926535897932; // acos(-1)
const double EPS = 1e-15;
const int INF = 1001001001;
const int mod = 1e+9 + 7;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define chadd(x, y) x = (x + y) % mod
template <typename T> struct Compress {
vector<T> xs;
Compress() = default;
Compress(const vector<T> &vs) { add(vs); }
Compress(const initializer_list<vector<T>> &vs) {
for (auto &p : vs)
add(p);
}
// vs内の座標をすべて追加
void add(const vector<T> &vs) { copy(begin(vs), end(vs), back_inserter(xs)); }
void add(const T &x) { xs.emplace_back(x); }
void build() {
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
}
// vs内の座標を座標圧縮したものを返す
vector<int> get(const vector<T> &vs) const {
vector<int> ret;
transform(begin(vs), end(vs), back_inserter(ret), [&](const T &x) {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
});
return ret;
}
// 座標xを座標圧縮したものを返す (x が xs 内で何番目にあるかを返す)
int get(const T &x) const {
return lower_bound(begin(xs), end(xs), x) - begin(xs);
}
// 座標圧縮後のkが示す実際の座標を返す
const T &operator[](int k) const { return xs[k]; }
};
template <typename Monoid> struct SegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
int sz;
vector<Monoid> seg;
const F f; // モノイドに対して二項演算を行う関数オブジェクト
const Monoid M1;
SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) {
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; --k) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
void update(int k, const Monoid &x) {
k += sz;
seg[k] = x;
while (k >>= 1) {
seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
}
}
Monoid query(int a, int b) {
Monoid L = M1, R = M1;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1)
L = f(L, seg[a++]);
if (b & 1)
R = f(seg[--b], R);
}
return f(L, R);
}
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
struct Query {
int query, a, b;
Query() = default;
Query(int query, int a = -1, int b = -1) : query(query), a(a), b(b) {}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
vector<Query> input(q);
Compress<int> compress;
for (int i = 0; i < q; ++i) {
int query;
cin >> query;
if (query == 1) {
int a, b;
cin >> a >> b;
input[i] = Query(query, a, b);
compress.add(a);
} else
input[i] = Query(query);
}
compress.build();
SegmentTree<int> seg(
q, [](int a, int b) { return a + b; }, 0);
int median = input[0].a;
ll res = input[0].b;
int c = compress.get(median);
seg.update(c, 1);
int left_cnt = 0, right_cnt = 0;
int cnt = 1;
int median_cnt = 1;
for (int i = 1; i < q; ++i) {
if (input[i].query == 1) {
int a = input[i].a, b = input[i].b;
int compressed_a = compress.get(a);
seg.update(compressed_a, seg[compressed_a] + 1);
++cnt;
int lb = 0, ub = q;
int comparision = ceil((double)cnt / 2);
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (seg.query(0, mid) >= comparision)
ub = mid;
else
lb = mid;
}
int now_median = compress[lb];
if (now_median < median) {
ll dif = median - now_median;
res += dif * (right_cnt + median_cnt);
res -= dif * left_cnt;
} else if (now_median > median) {
ll dif = now_median - median;
res += dif * (left_cnt + median_cnt);
res -= dif * right_cnt;
}
median = now_median;
res += (ll)abs(median - a) + b;
median_cnt = seg[lb];
left_cnt = seg.query(0, lb);
right_cnt = seg.query(ub, q);
}
else {
cout << median << " " << res << "\n";
}
}
} | [
"type_conversion.add"
] | 855,096 | 855,097 | u190018920 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
int Q;
priority_queue<int> q_right;
priority_queue<int, vector<int>, greater<int>> q_left;
int f = 1;
long long cum = 0;
void add() {
int a, b;
cin >> a >> b;
cum += (long long)b;
if (f) { //最初だけは両方にaをpushしておく
q_left.push(a);
q_right.push(a);
f = 0;
} else {
int left_max = q_left.top();
int right_min = q_right.top();
if (left_max <= a and a <= right_min) {
//最大値は変わらないし、left,right両方にaを追加すればよい
q_left.push(a);
q_right.push(a);
} else if (a < left_max) {
// left_max - aだけ最小値は増える
cum += (long long)(left_max - a);
// q_leftに2回aをpushし、新しい最大値をq_rightに移し替える
q_left.push(a);
q_left.push(a);
q_right.push(q_left.top());
q_left.pop();
} else {
cum += (long long)(a - right_min);
q_right.push(a);
q_right.push(a);
q_left.push(q_right.top());
q_right.pop();
}
}
}
void getmin() { cout << q_left.top() << " " << cum << endl; }
int main(void) {
cin >> Q;
for (int i = 0; i < Q; i++) {
int com;
cin >> com;
(com == 1) ? add() : getmin();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int Q;
priority_queue<int> q_left;
priority_queue<int, vector<int>, greater<int>> q_right;
int f = 1;
long long cum = 0;
void add() {
int a, b;
cin >> a >> b;
cum += (long long)b;
if (f) { //最初だけは両方にaをpushしておく
q_left.push(a);
q_right.push(a);
f = 0;
} else {
int left_max = q_left.top();
int right_min = q_right.top();
if (left_max <= a and a <= right_min) {
//最大値は変わらないし、left,right両方にaを追加すればよい
q_left.push(a);
q_right.push(a);
} else if (a < left_max) {
// left_max - aだけ最小値は増える
cum += (long long)(left_max - a);
// q_leftに2回aをpushし、新しい最大値をq_rightに移し替える
q_left.push(a);
q_left.push(a);
q_right.push(q_left.top());
q_left.pop();
} else {
cum += (long long)(a - right_min);
q_right.push(a);
q_right.push(a);
q_left.push(q_right.top());
q_right.pop();
}
}
}
void getmin() { cout << q_left.top() << " " << cum << endl; }
int main(void) {
cin >> Q;
for (int i = 0; i < Q; i++) {
int com;
cin >> com;
(com == 1) ? add() : getmin();
}
return 0;
} | [
"identifier.change"
] | 855,098 | 855,099 | u426397594 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef vector<vector<int>> vv;
typedef pair<int, int> P;
// input
int Q;
int n;
ll asum, bsum, midsum;
multiset<int> s;
multiset<int>::iterator itr;
void input() { cin >> Q; }
void param_init() {
int q, a, b;
cin >> q >> a >> b;
n = 1;
asum = a;
bsum = b;
midsum = a;
s.insert(a);
itr = s.find(a);
}
void query1() {
int a, b;
cin >> a >> b;
asum += a;
bsum += b;
s.insert(a);
if (a < *itr) {
midsum += a;
if (n % 2 == 1)
midsum -= *(itr--);
} else {
if (n % 2 == 0)
midsum += *(++itr);
}
n++;
}
void query2() {
ll x = *itr;
ll fx = bsum;
fx += (n + 1) / 2 * (*itr) - midsum;
fx += (asum - midsum) - n / 2 * (*itr);
printf("%ld %ld\n", x, fx);
}
int main() {
input();
param_init();
rep(i, Q - 1) {
int q;
cin >> q;
if (q == 1)
query1();
else
query2();
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef vector<vector<int>> vv;
typedef pair<int, int> P;
// input
int Q;
ll n;
ll asum, bsum, midsum;
multiset<ll> s;
multiset<ll>::iterator itr;
void input() { cin >> Q; }
void param_init() {
int q, a, b;
cin >> q >> a >> b;
n = 1;
asum = a;
bsum = b;
midsum = a;
s.insert(a);
itr = s.find(a);
}
void query1() {
int a, b;
cin >> a >> b;
asum += a;
bsum += b;
s.insert(a);
if (a < *itr) {
midsum += a;
if (n % 2 == 1)
midsum -= *(itr--);
} else {
if (n % 2 == 0)
midsum += *(++itr);
}
n++;
}
void query2() {
ll x = *itr;
ll fx = bsum;
fx += (n + 1) / 2 * (*itr) - midsum;
fx += (asum - midsum) - n / 2 * (*itr);
printf("%ld %ld\n", x, fx);
}
int main() {
input();
param_init();
rep(i, Q - 1) {
int q;
cin >> q;
if (q == 1)
query1();
else
query2();
}
}
| [
"variable_declaration.type.change"
] | 855,102 | 855,103 | u671861352 | cpp |
p03040 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define debugA cerr << "AAAAA" << endl
#define debug_ cerr << "-------------" << endl
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
cout << v[i] << " "; \
} \
cout << endl;
#define debug_vec2(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
for (int j = 0; j < v[i].size(); j++) { \
cout << v[i][j] << " "; \
} \
cout << endl; \
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
using Graph = vector<vector<int>>;
using P = pair<int, int>;
using P1 = pair<int, pair<int, int>>; // クラスカル法とかで、{cost, {from,
// to}}的に使う。
const ll INF = 1001001001001001001;
const double pi = acos(-1);
int main() {
int n;
cin >> n;
ll tmp = 0;
ll ans = 0;
vector<ll> vec;
priority_queue<int, vector<int>, greater<int>> que1;
priority_queue<int, vector<int>, less<int>> que2;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == 1) {
ll b, c;
cin >> b >> c;
tmp += c;
que1.push(b);
que2.push(b);
if (que1.top() > que2.top()) {
int x = que1.top();
int y = que2.top();
que1.pop();
que2.pop();
que2.push(x);
que1.push(y);
ans += abs(x - y);
}
} else {
cout << que1.top() << " " << ans + tmp << endl;
}
}
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define debugA cerr << "AAAAA" << endl
#define debug_ cerr << "-------------" << endl
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
cout << v[i] << " "; \
} \
cout << endl;
#define debug_vec2(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
for (int j = 0; j < v[i].size(); j++) { \
cout << v[i][j] << " "; \
} \
cout << endl; \
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
using Graph = vector<vector<int>>;
using P = pair<int, int>;
using P1 = pair<int, pair<int, int>>; // クラスカル法とかで、{cost, {from,
// to}}的に使う。
const ll INF = 1001001001001001001;
const double pi = acos(-1);
int main() {
int n;
cin >> n;
ll tmp = 0;
ll ans = 0;
vector<ll> vec;
priority_queue<int, vector<int>, greater<int>> que2;
priority_queue<int, vector<int>, less<int>> que1;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == 1) {
ll b, c;
cin >> b >> c;
tmp += c;
que1.push(b);
que2.push(b);
if (que1.top() > que2.top()) {
int x = que1.top();
int y = que2.top();
que1.pop();
que2.pop();
que2.push(x);
que1.push(y);
ans += abs(x - y);
}
} else {
cout << que1.top() << " " << ans + tmp << endl;
}
}
return 0;
}
| [
"identifier.change"
] | 855,104 | 855,105 | u275934251 | cpp |
p03040 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define debugA cerr << "AAAAA" << endl
#define debug_ cerr << "-------------" << endl
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
cout << v[i] << " "; \
} \
cout << endl;
#define debug_vec2(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
for (int j = 0; j < v[i].size(); j++) { \
cout << v[i][j] << " "; \
} \
cout << endl; \
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
using Graph = vector<vector<int>>;
using P = pair<int, int>;
using P1 = pair<int, pair<int, int>>; // クラスカル法とかで、{cost, {from,
// to}}的に使う。
const ll INF = 1001001001001001001;
const double pi = acos(-1);
int main() {
int n;
cin >> n;
ll tmp = 0;
ll ans = 0;
vector<ll> vec;
priority_queue<int, vector<int>, greater<int>> que1;
priority_queue<int, vector<int>, less<int>> que2;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == 1) {
ll b, c;
cin >> b >> c;
tmp += c;
que1.push(b);
que2.push(b);
if (que1.top() > que2.top()) {
int x = que1.top();
int y = que2.top();
que1.pop();
que2.pop();
que2.push(x);
que1.push(y);
ans += abs(x - y);
}
} else {
cout << que1.top() << " " << ans << endl;
}
}
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define debugA cerr << "AAAAA" << endl
#define debug_ cerr << "-------------" << endl
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
cout << v[i] << " "; \
} \
cout << endl;
#define debug_vec2(v) \
cout << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
for (int j = 0; j < v[i].size(); j++) { \
cout << v[i][j] << " "; \
} \
cout << endl; \
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
using Graph = vector<vector<int>>;
using P = pair<int, int>;
using P1 = pair<int, pair<int, int>>; // クラスカル法とかで、{cost, {from,
// to}}的に使う。
const ll INF = 1001001001001001001;
const double pi = acos(-1);
int main() {
int n;
cin >> n;
ll tmp = 0;
ll ans = 0;
vector<ll> vec;
priority_queue<int, vector<int>, greater<int>> que2;
priority_queue<int, vector<int>, less<int>> que1;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == 1) {
ll b, c;
cin >> b >> c;
tmp += c;
que1.push(b);
que2.push(b);
if (que1.top() > que2.top()) {
int x = que1.top();
int y = que2.top();
que1.pop();
que2.pop();
que2.push(x);
que1.push(y);
ans += abs(x - y);
}
} else {
cout << que1.top() << " " << ans + tmp << endl;
}
}
return 0;
}
| [
"identifier.change"
] | 855,106 | 855,105 | u275934251 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define chmax(a, b) a = max(a, b);
#define chmin(a, b) a = min(a, b);
using namespace std;
using ll = long long;
using P = pair<int, int>;
// Binary Indexed Tree (Fenwick Tree)
// https://youtu.be/lyHk98daDJo?t=7960
template <typename T> struct BIT {
int n;
vector<T> d;
BIT(int n = 0) : n(n), d(n + 1) {}
void add(int i, T x = 1) {
for (i++; i <= n; i += i & -i) {
d[i] += x;
}
}
T sum(int i) {
T x = 0;
for (i++; i; i -= i & -i) {
x += d[i];
}
return x;
}
T sum(int l, int r) { return sum(r - 1) - sum(l - 1); }
};
int main() {
int q_num;
cin >> q_num;
vector<tuple<int, int, int>> q;
ll fmin;
int lmin;
vector<int> tor;
rep(i, q_num) {
int t;
cin >> t;
if (t == 1) {
int a, b;
cin >> a >> b;
if (i == 0) {
fmin = b;
lmin = a;
} else
q.emplace_back(t, a, b);
tor.push_back(a);
} else
q.emplace_back(t, 0, 0);
}
tor.push_back(-1001001001);
sort(tor.begin(), tor.end());
tor.erase(unique(tor.begin(), tor.end()), tor.end());
map<int, int> toc;
for (int i = 0; i < tor.size(); i++)
toc[tor[i]] = i;
BIT<int> bt(tor.size());
bt.add(0, -1);
bt.add(toc[lmin], 2);
for (auto p : q) {
int t, a, b;
tie(t, a, b) = p;
if (t == 2) {
cout << lmin << ' ' << fmin << endl;
continue;
}
bt.add(0, -1);
bt.add(toc[a], 2);
int nl;
{
int l = -1, r = tor.size();
while (r - l > 1) {
int c = (l + r) / 2;
if (bt.sum(c) >= 0)
r = c;
else
l = c;
}
nl = tor[r];
}
if (nl < lmin) {
fmin += lmin - nl;
}
lmin = nl;
fmin += abs(a - lmin) + b;
}
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define chmax(a, b) a = max(a, b);
#define chmin(a, b) a = min(a, b);
using namespace std;
using ll = long long;
using P = pair<int, int>;
// Binary Indexed Tree (Fenwick Tree)
// https://youtu.be/lyHk98daDJo?t=7960
template <typename T> struct BIT {
int n;
vector<T> d;
BIT(int n = 0) : n(n), d(n + 1) {}
void add(int i, T x = 1) {
for (i++; i <= n; i += i & -i) {
d[i] += x;
}
}
T sum(int i) {
T x = 0;
for (i++; i; i -= i & -i) {
x += d[i];
}
return x;
}
T sum(int l, int r) { return sum(r - 1) - sum(l - 1); }
};
int main() {
int q_num;
cin >> q_num;
vector<tuple<int, int, int>> q;
ll fmin;
int lmin;
vector<int> tor;
rep(i, q_num) {
int t;
cin >> t;
if (t == 1) {
int a, b;
cin >> a >> b;
if (i == 0) {
fmin = b;
lmin = a;
} else
q.emplace_back(t, a, b);
tor.push_back(a);
} else
q.emplace_back(t, 0, 0);
}
tor.push_back(-1001001001);
sort(tor.begin(), tor.end());
tor.erase(unique(tor.begin(), tor.end()), tor.end());
map<int, int> toc;
for (int i = 0; i < tor.size(); i++)
toc[tor[i]] = i;
BIT<int> bt(tor.size());
bt.add(0, -1);
bt.add(toc[lmin], 2);
for (auto p : q) {
int t, a, b;
tie(t, a, b) = p;
if (t == 2) {
cout << lmin << ' ' << fmin << endl;
continue;
}
bt.add(0, -1);
bt.add(toc[a], 2);
int nl;
{
int l = -1, r = tor.size();
while (r - l > 1) {
int c = (l + r) / 2;
if (bt.sum(c) >= 0)
r = c;
else
l = c;
}
nl = tor[r];
}
if (nl < lmin) {
fmin += lmin - nl;
}
lmin = nl;
fmin += abs<ll>(a - lmin) + b;
}
}
| [] | 855,112 | 855,113 | u539692012 | cpp |
p03040 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define bit(n, k) (((ll)n >> (ll)k) & 1) /*nのk bit目*/
const long long INF = 1e+18 + 1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
const ll MOD = 1000000007LL;
// const ll MOD=998244353LL;
// const ll MAX_V=114514LL;
const ll MAX = 510000LL;
string abc = "abcdefghijklmnopqrstuvwxyz";
string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
vl dx = {-1, -1, -1, 0, 0, 1, 1, 1};
vl dy = {1, -1, 0, 1, -1, 1, 0, -1};
ll q;
ll sumb, sumL, sumR;
priority_queue<ll> L;
priority_queue<ll, vl, greater<ll>> R;
int main() {
cin >> q;
for (; q--;) {
ll id;
cin >> id;
if (id == 1) {
ll a, b;
cin >> a >> b;
sumb += b;
if (!R.empty() && R.top() <= a)
R.push(a), sumR += a;
else
L.push(a), sumL += a;
ll dim = (L.size() + R.size()) % 2;
while (R.size() + dim < L.size()) {
ll now = L.top();
sumL -= now;
sumR += now;
R.push(now);
L.pop();
}
while (R.size() + dim > L.size()) {
ll now = R.top();
sumR -= now;
sumL += now;
L.push(now);
R.pop();
}
} else {
ll now = L.top();
cout << now << " "
<< sumb + (sumR - now * R.size()) + (now * L.size() - sumL) << endl;
}
}
} | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define bit(n, k) (((ll)n >> (ll)k) & 1) /*nのk bit目*/
const long long INF = 1e+18 + 1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
const ll MOD = 1000000007LL;
// const ll MOD=998244353LL;
// const ll MAX_V=114514LL;
const ll MAX = 510000LL;
string abc = "abcdefghijklmnopqrstuvwxyz";
string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
vl dx = {-1, -1, -1, 0, 0, 1, 1, 1};
vl dy = {1, -1, 0, 1, -1, 1, 0, -1};
ll q;
ll sumb, sumL, sumR;
priority_queue<ll> L;
priority_queue<ll, vl, greater<ll>> R;
int main() {
cin >> q;
for (; q--;) {
ll id;
cin >> id;
if (id == 1) {
ll a, b;
cin >> a >> b;
sumb += b;
if (!R.empty() && R.top() <= a)
R.push(a), sumR += a;
else
L.push(a), sumL += a;
ll dim = (L.size() + R.size()) % 2;
while (R.size() + dim < L.size()) {
ll now = L.top();
sumL -= now;
sumR += now;
R.push(now);
L.pop();
}
while (R.size() + dim > L.size()) {
ll now = R.top();
sumR -= now;
sumL += now;
L.push(now);
R.pop();
}
} else {
ll now = L.top();
cout << now << " "
<< sumb + (sumR - now * (ll)R.size()) + (now * (ll)L.size() - sumL)
<< endl;
}
}
} | [
"type_conversion.add"
] | 855,123 | 855,124 | u614128939 | cpp |
p03040 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define F first
#define S second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef tree<pii, null_type, less<pii>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
struct Set {
multiset<int> st;
ll s = 0;
void add(int x) {
s += x;
st.insert(x);
}
int pop_back() {
int val = *(--st.end());
s -= val;
st.erase(--st.end());
return val;
}
int pop_front() {
int val = *st.begin();
s -= val;
st.erase(st.begin());
return val;
}
int back() { return *st.begin(); }
int front() { return *(--st.end()); }
int size() { return st.size(); }
bool empty() { return st.empty(); }
void dbg() {
cout << "sum " << s << '\n';
for (int i : st) {
cout << i << ' ';
}
cout << '\n';
}
};
Set A, B;
void add(int x) {
if (!B.empty() && B.front() <= x) {
B.add(x);
} else {
A.add(x);
}
while (A.size() - B.size() > 1) {
B.add(A.pop_back());
}
while (A.size() < B.size()) {
A.add(B.pop_front());
}
// cout << "A ";
// A.dbg();
// cout << "B ";
// B.dbg();
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
ll C = 0;
int q;
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int a, b;
cin >> a >> b;
add(a);
C += b;
} else {
ll val = A.back();
cout << val << ' ' << val * A.size() - val * B.size() - A.s + B.s + C
<< '\n';
}
}
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define F first
#define S second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef tree<pii, null_type, less<pii>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
struct Set {
multiset<int> st;
ll s = 0;
void add(int x) {
s += x;
st.insert(x);
}
int pop_back() {
int val = *(--st.end());
s -= val;
st.erase(--st.end());
return val;
}
int pop_front() {
int val = *st.begin();
s -= val;
st.erase(st.begin());
return val;
}
int front() { return *st.begin(); }
int back() { return *(--st.end()); }
int size() { return st.size(); }
bool empty() { return st.empty(); }
void dbg() {
cout << "sum " << s << '\n';
for (int i : st) {
cout << i << ' ';
}
cout << '\n';
}
};
Set A, B;
void add(int x) {
if (!B.empty() && B.front() <= x) {
B.add(x);
} else {
A.add(x);
}
while (A.size() - B.size() > 1) {
B.add(A.pop_back());
}
while (A.size() < B.size()) {
A.add(B.pop_front());
}
// cout << "A ";
// A.dbg();
// cout << "B ";
// B.dbg();
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
ll C = 0;
int q;
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int a, b;
cin >> a >> b;
add(a);
C += b;
} else {
ll val = A.back();
cout << val << ' ' << val * A.size() - val * B.size() - A.s + B.s + C
<< '\n';
}
}
}
| [] | 855,125 | 855,126 | u322084037 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
constexpr long mod = 1000000007;
priority_queue<long> q1, q2;
long c() {
if (!q1.size() && !q2.size())
return 0;
if (!q2.size())
return q1.top();
if (!q1.size())
return -q2.top();
long a = q1.top(), b = -q2.top();
long m = q1.size(), n = q2.size();
if ((m + n) % 2)
return m > n ? a : b;
return a;
}
long myabs(long a) { return a > 0 ? a : -a; }
int main(void) {
long bsum = 0;
long q1s = 0, q2s = 0;
q1.push(0);
q1.pop();
q2.push(0);
q2.pop();
long q;
cin >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
long a, b;
cin >> a >> b;
bsum += b;
long m = c();
if (m < a) {
q2.push(-a);
q2s += a;
} else {
q1.push(a);
q1s += a;
}
while (myabs(q1.size() - q2.size()) >= 2) {
if (q1.size() < q2.size()) {
q2s -= -q2.top();
q1s += -q2.top();
q1.push(-q2.top()), q2.pop();
}
if (q1.size() > q2.size()) {
q1s -= q1.top();
q2s += q1.top();
q2.push(-q1.top()), q1.pop();
}
}
/* cout << '!' << q1.top() << ',' << q1.size() << ' ' << q2.top() << ','
* << q2.size() << ' ' << myabs(q1.size()-q2.size()) << endl; */
} else if (type == 2) {
long m = c();
cout << m << ' '
<< (m * (signed long)(q1.size() - q2.size()) + q1s + q2s + bsum)
<< endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
constexpr long mod = 1000000007;
priority_queue<long> q1, q2;
long c() {
if (!q1.size() && !q2.size())
return 0;
if (!q2.size())
return q1.top();
if (!q1.size())
return -q2.top();
long a = q1.top(), b = -q2.top();
long m = q1.size(), n = q2.size();
if ((m + n) % 2)
return m > n ? a : b;
return a;
}
long myabs(long a) { return a > 0 ? a : -a; }
int main(void) {
long bsum = 0;
long q1s = 0, q2s = 0;
q1.push(0);
q1.pop();
q2.push(0);
q2.pop();
long q;
cin >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
long a, b;
cin >> a >> b;
bsum += b;
long m = c();
if (m < a) {
q2.push(-a);
q2s += a;
} else {
q1.push(a);
q1s += a;
}
while (myabs(q1.size() - q2.size()) >= 2) {
if (q1.size() < q2.size()) {
q2s -= -q2.top();
q1s += -q2.top();
q1.push(-q2.top()), q2.pop();
}
if (q1.size() > q2.size()) {
q1s -= q1.top();
q2s += q1.top();
q2.push(-q1.top()), q1.pop();
}
}
/* cout << '!' << q1.top() << ',' << q1.size() << ' ' << q2.top() << ','
* << q2.size() << ' ' << endl; */
} else if (type == 2) {
long m = c();
/* cout << q1s << ' ' << q2s << ' ' << bsum << endl; */
cout << m << ' '
<< (m * (signed long)(q1.size() - q2.size()) - q1s + q2s + bsum)
<< endl;
}
}
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"io.output.change"
] | 855,129 | 855,130 | u056944756 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MAX_N = 200000;
int bit[MAX_N + 1] = {0}, n;
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int search(int k) {
ll ok = 200000, ng = -1;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (sum(mid) >= k)
ok = mid;
else
ng = mid;
}
return ok;
}
int main() {
int q, Q[200001][3];
cin >> q;
n = MAX_N;
vector<P> A;
vec B(200001, -1), C(200001);
rep(i, q) {
int c, a, b;
cin >> c;
Q[i][0] = c;
if (c == 1)
cin >> a >> b, Q[i][1] = a, Q[i][2] = b, A.push_back(P(a, i));
}
sort(all(A));
rep(i, A.size()) B[A[i].second] = i + 1;
rep(i, B.size()) if (B[i] != -1) C[B[i]] = i;
ll ans = 0, x, c = 0;
rep(i, q) {
if (Q[i][0] == 1) {
c++;
if (c == 1)
;
else if (c % 2 == 0)
ans += abs(Q[i][1] - Q[C[search(c / 2)]][1]);
else {
int a = Q[C[search(c / 2)]][1], b = Q[C[search(c / 2 + 1)]][1];
if (Q[i][1] < a)
ans += abs(Q[i][1] - a);
if (b < Q[i][q])
ans += abs(Q[i][1] - b);
}
add(B[i], 1);
x = Q[C[search((c + 1) / 2)]][1];
ans += Q[i][2];
} else {
cout << x << " " << ans << "\n";
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
const int MAX_N = 200000;
int bit[MAX_N + 1] = {0}, n;
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int search(int k) {
ll ok = 200000, ng = -1;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (sum(mid) >= k)
ok = mid;
else
ng = mid;
}
return ok;
}
int main() {
int q, Q[200001][3];
cin >> q;
n = MAX_N;
vector<P> A;
vec B(200001, -1), C(200001);
rep(i, q) {
int c, a, b;
cin >> c;
Q[i][0] = c;
if (c == 1)
cin >> a >> b, Q[i][1] = a, Q[i][2] = b, A.push_back(P(a, i));
}
sort(all(A));
rep(i, A.size()) B[A[i].second] = i + 1;
rep(i, B.size()) if (B[i] != -1) C[B[i]] = i;
ll ans = 0, x, c = 0;
rep(i, q) {
if (Q[i][0] == 1) {
c++;
if (c == 1)
;
else if (c % 2 == 0)
ans += abs(Q[i][1] - Q[C[search(c / 2)]][1]);
else {
int a = Q[C[search(c / 2)]][1], b = Q[C[search(c / 2 + 1)]][1];
if (Q[i][1] < a)
ans += abs(Q[i][1] - a);
if (b < Q[i][1])
ans += abs(Q[i][1] - b);
}
add(B[i], 1);
x = Q[C[search((c + 1) / 2)]][1];
ans += Q[i][2];
} else {
cout << x << " " << ans << "\n";
}
}
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 855,131 | 855,132 | u441296840 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define FOR(i, m, n) for (int i = int(m); i < int(n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define VI vector<int>
#define VP vector<pair<int, int>>
#define VPP vector<pair<int, pair<int, int>>>
#define VLL vector<long long>
#define VVI vector<vector<int>>
#define VVLL vector<vector<long long>>
#define VC vector<char>
#define VS vector<string>
#define VVC vector<vector<char>>
#define VB vector<bool>
#define VVB vector<vector<bool>>
#define fore(i, a) for (auto &i : a)
typedef pair<int, int> P;
template <typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = 1 << 30;
const ll INFL = 1LL << 60;
const ll mod = 1000000007;
int main() {
int q;
cin >> q;
min_priority_queue<ll> r;
priority_queue<ll> l;
ll rsum = 0;
ll lsum = 0;
ll sum = 0;
REP(qi, q) {
int a;
cin >> a;
if (a == 1) {
ll b, c;
cin >> b >> c;
sum += c;
if (l.size() < 2 || r.top() > b) {
l.push(b);
lsum += b;
} else {
r.push(b);
rsum += b;
}
if (l.size() < r.size()) {
ll i = r.top();
r.pop();
l.push(i);
rsum -= i;
lsum += i;
} else if (l.size() >= r.size() + 2) {
ll i = l.top();
l.pop();
r.push(i);
lsum -= i;
rsum += i;
}
} else {
ll a = l.top();
ll ans = (a * (ll)l.size() - lsum) + (rsum - a * (ll)r.size()) + sum;
cout << a << ' ' << ans << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define FOR(i, m, n) for (int i = int(m); i < int(n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define VI vector<int>
#define VP vector<pair<int, int>>
#define VPP vector<pair<int, pair<int, int>>>
#define VLL vector<long long>
#define VVI vector<vector<int>>
#define VVLL vector<vector<long long>>
#define VC vector<char>
#define VS vector<string>
#define VVC vector<vector<char>>
#define VB vector<bool>
#define VVB vector<vector<bool>>
#define fore(i, a) for (auto &i : a)
typedef pair<int, int> P;
template <typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int INF = 1 << 30;
const ll INFL = 1LL << 60;
const ll mod = 1000000007;
int main() {
int q;
cin >> q;
min_priority_queue<ll> r;
priority_queue<ll> l;
ll rsum = 0;
ll lsum = 0;
ll sum = 0;
REP(qi, q) {
int a;
cin >> a;
if (a == 1) {
ll b, c;
cin >> b >> c;
sum += c;
if (l.size() < 1 || l.top() > b) {
l.push(b);
lsum += b;
} else {
r.push(b);
rsum += b;
}
if (l.size() < r.size()) {
ll i = r.top();
r.pop();
l.push(i);
rsum -= i;
lsum += i;
} else if (l.size() >= r.size() + 2) {
ll i = l.top();
l.pop();
r.push(i);
lsum -= i;
rsum += i;
}
} else {
ll a = l.top();
ll ans = (a * (ll)l.size() - lsum) + (rsum - a * (ll)r.size()) + sum;
cout << a << ' ' << ans << endl;
}
}
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 855,139 | 855,140 | u856232850 | cpp |
p03040 | #include <cmath>
#include <iostream>
#include <set>
using namespace std;
int main() {
int Q;
cin >> Q;
multiset<int> S;
long sum_l = 0, sum_r = 0, sum_b = 0;
int q, a, b;
cin >> q >> a >> b;
S.insert(a);
sum_b += b;
auto it = S.begin();
for (int i = 1; i < Q; i++) {
cin >> q;
if (q == 1) {
cin >> a >> b;
S.insert(a);
if (*it > a) {
sum_l += a;
int old_val = *it;
it--;
sum_r += old_val;
sum_l -= *it;
} else {
sum_r += a;
}
if (S.size() % 2 == 1) {
int old_val = *it;
it++;
sum_l += old_val;
sum_r -= *it;
}
sum_b += b;
} else {
cout << *it << " " << sum_r - sum_l - (S.size() % 2 == 0) + sum_b << endl;
}
}
} | #include <cmath>
#include <iostream>
#include <set>
using namespace std;
int main() {
int Q;
cin >> Q;
multiset<int> S;
long sum_l = 0, sum_r = 0, sum_b = 0;
int q, a, b;
cin >> q >> a >> b;
S.insert(a);
sum_b += b;
auto it = S.begin();
for (int i = 1; i < Q; i++) {
cin >> q;
if (q == 1) {
cin >> a >> b;
S.insert(a);
if (*it > a) {
sum_l += a;
int old_val = *it;
it--;
sum_r += old_val;
sum_l -= *it;
} else {
sum_r += a;
}
if (S.size() % 2 == 1) {
int old_val = *it;
it++;
sum_l += old_val;
sum_r -= *it;
}
sum_b += b;
} else {
cout << *it << " " << sum_r - sum_l - (S.size() % 2 == 0) * (*it) + sum_b
<< endl;
}
}
} | [
"expression.operation.binary.add"
] | 855,141 | 855,142 | u521712919 | cpp |
p03040 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for (int i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};
int main() {
ll q;
cin >> q;
set<ll, greater<ll>> st1;
set<ll> st2;
ll ans = 0;
rep(i, q) {
ll t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
ans += b;
if (st1.empty()) {
st1.insert(a);
st2.insert(a);
} else {
ll l = *st1.begin();
ll r = *st2.begin();
if (a < l || r < a)
ans += min(abs(l - a), abs(r - a));
if (a < l) {
st1.erase(st1.begin());
st2.insert(l);
st1.insert(a);
st1.insert(a);
} else if (a > r) {
st2.erase(st2.begin());
st1.insert(r);
st2.insert(a);
st2.insert(a);
} else {
st1.insert(a);
st2.insert(a);
}
}
} else {
cout << *st1.begin() << ' ' << ans << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for (int i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};
int main() {
ll q;
cin >> q;
multiset<ll, greater<ll>> st1;
multiset<ll> st2;
ll ans = 0;
rep(i, q) {
ll t;
cin >> t;
if (t == 1) {
ll a, b;
cin >> a >> b;
ans += b;
if (st1.empty()) {
st1.insert(a);
st2.insert(a);
} else {
ll l = *st1.begin();
ll r = *st2.begin();
if (a < l || r < a)
ans += min(abs(l - a), abs(r - a));
if (a < l) {
st1.erase(st1.begin());
st2.insert(l);
st1.insert(a);
st1.insert(a);
} else if (a > r) {
st2.erase(st2.begin());
st1.insert(r);
st2.insert(a);
st2.insert(a);
} else {
st1.insert(a);
st2.insert(a);
}
}
} else {
cout << *st1.begin() << ' ' << ans << endl;
}
}
} | [
"variable_declaration.type.change"
] | 855,147 | 855,148 | u134678977 | cpp |
p03040 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(), (V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
inline void Yes(bool condition) {
if (condition)
PRINT("Yes");
else
PRINT("No");
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class itr> void array_output(itr start, itr goal) {
string ans = "", k = " ";
for (auto i = start; i != goal; i++)
ans += to_string(*i) + k;
if (!ans.empty())
ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) { return a ? gcd(b % a, a) : b; }
const ll INF = 1e18;
const ll MOD = 1000000007;
typedef pair<ll, ll> P;
const ll MAX = 20000;
constexpr ll nx[8] = {1, 0, -1, 0, -1, -1, 1, 1};
constexpr ll ny[8] = {0, 1, 0, -1, -1, 1, -1, 1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll q;
cin >> q;
ll c = 0, lc = 0, rc = 0, x, res = 0;
priority_queue<ll> l;
priority_queue<ll, vector<ll>, greater<ll>> r;
rep(i, q) {
ll f, a, b;
cin >> f;
if (lc == 0) {
cin >> a >> b;
c += b;
l.push(a);
x = a;
lc++;
continue;
} else if (rc == 0) {
if (f == 1) {
cin >> a >> b;
c += b;
rc++;
if (l.top() <= a) {
r.push(a);
res += abs(x - a);
} else {
r.push(l.top());
l.pop();
l.push(a);
res += abs(x - a);
x = a;
}
} else {
cout << x << " " << res + c << '\n';
}
} else if (f == 1) {
cin >> a >> b;
c += b;
if ((lc + rc) % 2 == 0) {
lc++;
if (r.top() <= a) {
l.push(r.top());
r.pop();
r.push(a);
} else
l.push(a);
res += abs(l.top() - x);
x = l.top();
} else {
rc++;
if (l.top() >= a) {
r.push(l.top());
l.pop();
l.push(a);
} else
r.push(a);
res += abs(l.top() - a) + abs(l.top() - x);
x = l.top();
}
} else
cout << x << " " << res + c << '\n';
}
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(), (V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
inline void Yes(bool condition) {
if (condition)
PRINT("Yes");
else
PRINT("No");
}
template <class itr> void cins(itr first, itr last) {
for (auto i = first; i != last; i++) {
cin >> (*i);
}
}
template <class itr> void array_output(itr start, itr goal) {
string ans = "", k = " ";
for (auto i = start; i != goal; i++)
ans += to_string(*i) + k;
if (!ans.empty())
ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) { return a ? gcd(b % a, a) : b; }
const ll INF = 1e18;
const ll MOD = 1000000007;
typedef pair<ll, ll> P;
const ll MAX = 20000;
constexpr ll nx[8] = {1, 0, -1, 0, -1, -1, 1, 1};
constexpr ll ny[8] = {0, 1, 0, -1, -1, 1, -1, 1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll q;
cin >> q;
ll c = 0, lc = 0, rc = 0, x, res = 0;
priority_queue<ll> l;
priority_queue<ll, vector<ll>, greater<ll>> r;
rep(i, q) {
ll f, a, b;
cin >> f;
if (lc == 0) {
cin >> a >> b;
c += b;
l.push(a);
x = a;
lc++;
continue;
} else if (rc == 0) {
if (f == 1) {
cin >> a >> b;
c += b;
rc++;
if (l.top() <= a) {
r.push(a);
res += abs(x - a);
} else {
r.push(l.top());
l.pop();
l.push(a);
res += abs(x - a);
x = a;
}
} else {
cout << x << " " << res + c << '\n';
}
} else if (f == 1) {
cin >> a >> b;
c += b;
if ((lc + rc) % 2 == 0) {
lc++;
if (r.top() <= a) {
l.push(r.top());
r.pop();
r.push(a);
} else
l.push(a);
res += abs(l.top() - a);
x = l.top();
} else {
rc++;
if (l.top() >= a) {
r.push(l.top());
l.pop();
l.push(a);
} else
r.push(a);
res += abs(l.top() - a) + abs(l.top() - x);
x = l.top();
}
} else
cout << x << " " << res + c << '\n';
}
} | [
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 855,161 | 855,162 | u892687772 | cpp |
p03040 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000003
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
//グラフ関連
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to,
ll cap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
G[to].push_back(
Edge(from, cap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
class UnionFind {
vector<int> data;
int num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
num--;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
int numSet() { return num; }
};
// nCr,nPr,modの逆元
class Combination {
public:
Array fact;
Array inv;
ll mod;
// modの逆元
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
//約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
//最大公約数
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
//最小公倍数
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
//繰り返し自乗法
ll pow2(ll x, ll n) { // x^n 計算量O(logn)
ll ans = 1ll;
while (n > 0) {
if ((n & 1) == 1) {
ans = ans * x % MOD;
}
x = x * x % MOD; //一周する度にx, x^2, x^4, x^8となる
n >>= 1; //桁をずらす n = n >> 1
}
return ans;
}
// input
ll N, A, B, C, D, Q;
string S;
int main() {
multiset<ll> left, right;
ll sum_a = 0, sum_b = 0;
bool flag = true;
ll a0 = 0;
cin >> Q;
REP(i, Q) {
ll q;
cin >> q;
if (q == 2) {
cout << a0 << " " << sum_a + sum_b << endl;
} else {
ll a, b;
cin >> a >> b;
if (flag) {
left.insert(a);
a0 = a;
sum_b = b;
flag = false;
} else {
sum_b += b;
if (a < a0) {
left.insert(a);
sum_a += abs(a - a0);
if (left.size() > right.size() + 1) {
// left->right
right.insert(*(--left.end()));
left.erase(--left.end());
}
ll a1 = *(--left.end());
if (left.size() != right.size())
sum_a += abs(a1 - a0);
a0 = a1;
} else {
right.insert(a);
sum_a += abs(a - a0);
if (right.size() > left.size()) {
// right->left
left.insert(*(right.begin()));
right.erase(right.begin());
}
ll a1 = *(--left.end());
if (left.size() != right.size())
sum_a += abs(a1 - a0);
a0 = a1;
}
/*
cout << endl << "right: ";
for (auto i : left) {
cout <<i << " ";
}
cout << endl<<"left: ";
for (auto i : right) {
cout <<i << " ";
}
cout << endl;
*/
}
}
}
return 0;
}
| #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000003
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
//グラフ関連
struct Edge { //グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to,
ll cap) { //最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
G[to].push_back(
Edge(from, cap, (ll)G[from].size() - 1)); //最小カットの場合逆辺は0にする
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph &G, ll s, ll t) {
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
class UnionFind {
vector<int> data;
int num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
num--;
}
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
int numSet() { return num; }
};
// nCr,nPr,modの逆元
class Combination {
public:
Array fact;
Array inv;
ll mod;
// modの逆元
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
bool compare_by_b(pair<ll, ll> a, pair<ll, ll> b) { //降順second
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
bool compare_by_a(pair<ll, ll> a, pair<ll, ll> b) { //降順first
if (a.first != b.first) {
return a.first > b.first;
} else {
return a.second > b.second;
}
}
//約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
//最大公約数
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
//最小公倍数
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
//繰り返し自乗法
ll pow2(ll x, ll n) { // x^n 計算量O(logn)
ll ans = 1ll;
while (n > 0) {
if ((n & 1) == 1) {
ans = ans * x % MOD;
}
x = x * x % MOD; //一周する度にx, x^2, x^4, x^8となる
n >>= 1; //桁をずらす n = n >> 1
}
return ans;
}
// input
ll N, A, B, C, D, Q;
string S;
int main() {
multiset<ll> left, right;
ll sum_a = 0, sum_b = 0;
bool flag = true;
ll a0 = 0;
cin >> Q;
REP(i, Q) {
ll q;
cin >> q;
if (q == 2) {
cout << a0 << " " << sum_a + sum_b << endl;
} else {
ll a, b;
cin >> a >> b;
if (flag) {
left.insert(a);
a0 = a;
sum_b = b;
flag = false;
} else {
sum_b += b;
if (a < a0) {
left.insert(a);
sum_a += abs(a - a0);
if (left.size() > right.size() + 1) {
// left->right
right.insert(*(--left.end()));
left.erase(--left.end());
}
ll a1 = *(--left.end());
if (left.size() != right.size())
sum_a -= abs(a1 - a0);
a0 = a1;
} else {
right.insert(a);
sum_a += abs(a - a0);
if (right.size() > left.size()) {
// right->left
left.insert(*(right.begin()));
right.erase(right.begin());
}
ll a1 = *(--left.end());
if (left.size() != right.size())
sum_a -= abs(a1 - a0);
a0 = a1;
}
/*
cout << endl << "right: ";
for (auto i : left) {
cout <<i << " ";
}
cout << endl<<"left: ";
for (auto i : right) {
cout <<i << " ";
}
cout << endl;
*/
}
}
}
return 0;
}
| [
"expression.operator.change"
] | 855,163 | 855,164 | u712993629 | cpp |
p03040 | #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
using P = pair<long long, long long>;
typedef unsigned long long ull;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const double pi = acos(-1);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll sumb = 0, summae = 0, sumato = 0;
priority_queue<ll> mae;
priority_queue<ll, vector<ll>, greater<ll>> ato;
rep(i, n) {
int s;
cin >> s;
if (s == 1) {
ll a, b;
cin >> a >> b;
sumb += b;
if (mae.size() > ato.size()) {
int t = mae.top();
if (t > a) {
mae.pop();
summae -= t;
mae.push(a);
summae += a;
ato.push(t);
sumato += t;
} else {
ato.push(t);
sumato += t;
}
} else {
if (mae.empty()) {
mae.push(a);
summae += a;
} else {
int t = ato.top();
if (a < t) {
mae.push(a);
summae += a;
} else {
ato.pop();
sumato -= t;
ato.push(a);
sumato += a;
mae.push(t);
summae += t;
}
}
}
} else {
ll x = mae.top();
ll res = (x * mae.size() - summae) + (sumato - x * ato.size()) + sumb;
cout << x << " " << res << endl;
}
}
}
| #include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
using P = pair<long long, long long>;
typedef unsigned long long ull;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const double pi = acos(-1);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll sumb = 0, summae = 0, sumato = 0;
priority_queue<ll> mae;
priority_queue<ll, vector<ll>, greater<ll>> ato;
rep(i, n) {
int s;
cin >> s;
if (s == 1) {
ll a, b;
cin >> a >> b;
sumb += b;
if (mae.size() > ato.size()) {
ll t = mae.top();
if (t > a) {
mae.pop();
summae -= t;
mae.push(a);
summae += a;
ato.push(t);
sumato += t;
} else {
ato.push(a);
sumato += a;
}
} else {
if (mae.empty()) {
mae.push(a);
summae += a;
} else {
ll t = ato.top();
if (a < t) {
mae.push(a);
summae += a;
} else {
ato.pop();
sumato -= t;
ato.push(a);
sumato += a;
mae.push(t);
summae += t;
}
}
}
} else {
ll x = mae.top();
ll res = (x * mae.size() - summae) + (sumato - x * ato.size()) + sumb;
cout << x << " " << res << endl;
}
}
}
| [
"variable_declaration.type.change",
"identifier.change",
"call.arguments.change",
"assignment.value.change"
] | 855,165 | 855,166 | u371149954 | cpp |
p03040 | #include <bits/stdc++.h>
#define ALL(v) std::begin(v), std::end(v)
using lint = long long;
using ld = long double;
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout.setf(std::ios_base::fixed);
std::cout.precision(15);
lint q;
std::cin >> q;
std::multiset<lint> left, right;
lint ans = 0;
while (q--) {
lint c;
std::cin >> c;
if (c == 1) {
lint a, b;
std::cin >> a >> b;
ans += b;
left.insert(a), right.insert(a);
lint x = *left.rbegin(), y = *right.begin();
if (x > y) {
ans += x - y;
left.erase(std::prev(left.end())), right.erase(right.begin());
left.insert(y), right.insert(x);
}
}
if (c == 2) {
std::cout << *left.begin() << ' ' << ans << '\n';
}
}
}
| #include <bits/stdc++.h>
#define ALL(v) std::begin(v), std::end(v)
using lint = long long;
using ld = long double;
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout.setf(std::ios_base::fixed);
std::cout.precision(15);
lint q;
std::cin >> q;
std::multiset<lint> left, right;
lint ans = 0;
while (q--) {
lint c;
std::cin >> c;
if (c == 1) {
lint a, b;
std::cin >> a >> b;
ans += b;
left.insert(a), right.insert(a);
lint x = *left.rbegin(), y = *right.begin();
if (x > y) {
ans += x - y;
left.erase(std::prev(left.end())), right.erase(right.begin());
left.insert(y), right.insert(x);
}
}
if (c == 2) {
std::cout << *left.rbegin() << ' ' << ans << '\n';
}
}
}
| [
"call.function.change",
"expression.operation.binary.change"
] | 855,171 | 855,172 | u846041485 | cpp |
p03040 | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll q, a, b, c, sum = 0;
cin >> q;
vector<pair<ll, ll>> ans;
multiset<ll> mi, ma;
ll le = 0, ri = 0;
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> c;
sum += c;
if (mi.empty()) {
mi.insert(b);
continue;
}
if (ma.empty()) {
ll x = *(mi.begin());
if (b < x) {
mi.erase(x);
mi.insert(b);
ma.insert(x);
ri += x - b;
} else {
ma.insert(b);
ri += b - x;
}
continue;
}
ll x = *(--mi.end()), y = *ma.begin();
if (x <= b || b <= y) {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.insert(b);
ri -= b * niko;
le -= b * niko;
} else {
ma.insert(b);
ri += b - x;
}
} else if (b < x) {
if (ma.size() == mi.size()) {
mi.insert(b);
le += b - x;
} else {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.erase(mi.lower_bound(x));
ri += x;
ma.insert(x);
mi.insert(b);
le += b;
c = *(--mi.end());
niko++;
ri -= c * niko;
le -= c * niko;
}
} else {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
ri += b;
ma.insert(b);
ri -= y;
ma.erase(ma.begin());
mi.insert(y);
ri -= niko * y;
le -= niko * y;
} else {
ma.insert(b);
ri += b - x;
}
}
} else {
ans.push_back({*(--mi.end()), ri - le + sum});
}
}
for (auto &i : ans) {
cout << i.first << " " << i.second << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll q, a, b, c, sum = 0;
cin >> q;
vector<pair<ll, ll>> ans;
multiset<ll> mi, ma;
ll le = 0, ri = 0;
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> c;
sum += c;
if (mi.empty()) {
mi.insert(b);
continue;
}
if (ma.empty()) {
ll x = *(mi.begin());
if (b < x) {
mi.erase(x);
mi.insert(b);
ma.insert(x);
ri += x - b;
} else {
ma.insert(b);
ri += b - x;
}
continue;
}
ll x = *(--mi.end()), y = *ma.begin();
if (x <= b && b <= y) {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.insert(b);
ri -= b * niko;
le -= b * niko;
} else {
ma.insert(b);
ri += b - x;
}
} else if (b < x) {
if (ma.size() == mi.size()) {
mi.insert(b);
le += b - x;
} else {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.erase(mi.lower_bound(x));
ri += x;
ma.insert(x);
mi.insert(b);
le += b;
c = *(--mi.end());
niko++;
ri -= c * niko;
le -= c * niko;
}
} else {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
ri += b;
ma.insert(b);
ri -= y;
ma.erase(ma.begin());
mi.insert(y);
ri -= niko * y;
le -= niko * y;
} else {
ma.insert(b);
ri += b - x;
}
}
} else {
ans.push_back({*(--mi.end()), ri - le + sum});
}
}
for (auto &i : ans) {
cout << i.first << " " << i.second << endl;
}
return 0;
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 855,173 | 855,174 | u192903163 | cpp |
p03040 | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll q, a, b, c, sum = 0;
cin >> q;
vector<pair<ll, ll>> ans;
multiset<ll> mi, ma;
ll le = 0, ri = 0;
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> c;
sum += c;
if (mi.empty()) {
mi.insert(b);
continue;
}
if (ma.empty()) {
ll x = *(mi.begin());
if (b < x) {
mi.erase(x);
mi.insert(b);
ma.insert(x);
ri += x - b;
} else {
ma.insert(b);
ri += b - x;
}
continue;
}
ll x = *(--mi.end()), y = *ma.begin();
if (x <= b || b <= y) {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.insert(b);
ri -= b * niko;
le -= b * niko;
} else {
ma.insert(b);
ri += b - x;
}
} else if (b < x) {
if (ma.size() == mi.size()) {
mi.insert(b);
le += b - x;
} else {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.erase(mi.find(x));
ri += x;
ma.insert(x);
mi.insert(b);
le += b;
c = *(--mi.end());
niko++;
ri -= c * niko;
le -= c * niko;
}
} else {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
ri += b;
ma.insert(b);
ri -= y;
ma.erase(ma.begin());
mi.insert(y);
ri -= niko * y;
le -= niko * y;
} else {
ma.insert(b);
ri += b - x;
}
}
} else {
ans.push_back({*(--mi.end()), ri - le + sum});
}
}
for (auto &i : ans) {
cout << i.first << " " << i.second << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll q, a, b, c, sum = 0;
cin >> q;
vector<pair<ll, ll>> ans;
multiset<ll> mi, ma;
ll le = 0, ri = 0;
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> c;
sum += c;
if (mi.empty()) {
mi.insert(b);
continue;
}
if (ma.empty()) {
ll x = *(mi.begin());
if (b < x) {
mi.erase(x);
mi.insert(b);
ma.insert(x);
ri += x - b;
} else {
ma.insert(b);
ri += b - x;
}
continue;
}
ll x = *(--mi.end()), y = *ma.begin();
if (x <= b && b <= y) {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.insert(b);
ri -= b * niko;
le -= b * niko;
} else {
ma.insert(b);
ri += b - x;
}
} else if (b < x) {
if (ma.size() == mi.size()) {
mi.insert(b);
le += b - x;
} else {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.erase(mi.lower_bound(x));
ri += x;
ma.insert(x);
mi.insert(b);
le += b;
c = *(--mi.end());
niko++;
ri -= c * niko;
le -= c * niko;
}
} else {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
ri += b;
ma.insert(b);
ri -= y;
ma.erase(ma.begin());
mi.insert(y);
ri -= niko * y;
le -= niko * y;
} else {
ma.insert(b);
ri += b - x;
}
}
} else {
ans.push_back({*(--mi.end()), ri - le + sum});
}
}
for (auto &i : ans) {
cout << i.first << " " << i.second << endl;
}
return 0;
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change",
"call.arguments.change"
] | 855,175 | 855,174 | u192903163 | cpp |
p03040 | #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll q, a, b, c, sum = 0;
cin >> q;
vector<pair<ll, ll>> ans;
multiset<ll> mi, ma;
ll le = 0, ri = 0;
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> c;
sum += c;
if (mi.empty()) {
mi.insert(b);
continue;
}
if (ma.empty()) {
ll x = *(mi.begin());
if (b < x) {
mi.erase(x);
mi.insert(b);
ma.insert(x);
ri += x - b;
} else {
ma.insert(b);
ri += b - x;
}
continue;
}
ll x = *(--mi.end()), y = *ma.begin();
if (x <= b || b <= y) {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * y;
mi.insert(b);
ri -= b * niko;
le -= b * niko;
} else {
ma.insert(b);
ri += b - x;
}
} else if (b < x) {
if (ma.size() == mi.size()) {
mi.insert(b);
le += b - x;
} else {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.erase(mi.find(x));
ri += x;
ma.insert(x);
mi.insert(b);
le += b;
c = *(--mi.end());
niko++;
ri -= c * niko;
le -= c * niko;
}
} else {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
ri += b;
ma.insert(b);
ri -= y;
ma.erase(ma.begin());
mi.insert(y);
ri -= niko * y;
le -= niko * y;
} else {
ma.insert(b);
ri += b - x;
}
}
} else {
ans.push_back({*(--mi.end()), ri - le + sum});
}
}
for (auto &i : ans) {
cout << i.first << " " << i.second << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define be(v) (v).begin(), (v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod = 1000000007;
#define doublecout(a) cout << fixed << setprecision(10) << a << endl;
vector<vector<int>> v(1000);
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll q, a, b, c, sum = 0;
cin >> q;
vector<pair<ll, ll>> ans;
multiset<ll> mi, ma;
ll le = 0, ri = 0;
while (q--) {
cin >> a;
if (a == 1) {
cin >> b >> c;
sum += c;
if (mi.empty()) {
mi.insert(b);
continue;
}
if (ma.empty()) {
ll x = *(mi.begin());
if (b < x) {
mi.erase(x);
mi.insert(b);
ma.insert(x);
ri += x - b;
} else {
ma.insert(b);
ri += b - x;
}
continue;
}
ll x = *(--mi.end()), y = *ma.begin();
if (x <= b && b <= y) {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.insert(b);
ri -= b * niko;
le -= b * niko;
} else {
ma.insert(b);
ri += b - x;
}
} else if (b < x) {
if (ma.size() == mi.size()) {
mi.insert(b);
le += b - x;
} else {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
mi.erase(mi.lower_bound(x));
ri += x;
ma.insert(x);
mi.insert(b);
le += b;
c = *(--mi.end());
niko++;
ri -= c * niko;
le -= c * niko;
}
} else {
if (ma.size() == mi.size()) {
ll niko = ma.size();
ri += niko * x;
le += niko * x;
ri += b;
ma.insert(b);
ri -= y;
ma.erase(ma.begin());
mi.insert(y);
ri -= niko * y;
le -= niko * y;
} else {
ma.insert(b);
ri += b - x;
}
}
} else {
ans.push_back({*(--mi.end()), ri - le + sum});
}
}
for (auto &i : ans) {
cout << i.first << " " << i.second << endl;
}
return 0;
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 855,176 | 855,174 | u192903163 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s[k - 1] -= 32;
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s[k - 1] += 32;
cout << s << endl;
} | [
"expression.operator.change"
] | 855,187 | 855,188 | u225777148 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s.at(k) = s.at(k) - ('A' - 'a');
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
s.at(k - 1) = s.at(k - 1) - ('A' - 'a');
cout << s << endl;
} | [
"assignment.change"
] | 855,198 | 855,199 | u668010224 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
string S;
cin >> S;
S[K - 1] = S[K - 1] - ' ';
cout << S << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, K;
cin >> N >> K;
string S;
cin >> S;
S[K - 1] = S[K - 1] + ' ';
cout << S << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 855,224 | 855,225 | u018916376 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
char s = S.at(K - 1);
s += 32;
S.at(K - 1) = 's';
cout << S << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
char s = S.at(K - 1);
s += 32;
S.at(K - 1) = s;
cout << S << endl;
}
| [] | 855,226 | 855,227 | u279848598 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
S.at(K) = tolower(S.at(K - 1));
cout << S << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
S.at(K - 1) = tolower(S.at(K - 1));
cout << S << endl;
}
| [
"assignment.change"
] | 855,245 | 855,246 | u223555291 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
if (S[K - 1] = 'A') {
S[K - 1] = 'a';
} else if (S[K - 1] = 'B') {
S[K - 1] = 'b';
} else {
S[K - 1] = 'c';
}
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K >> S;
if (S[K - 1] == 'A') {
S[K - 1] = 'a';
} else if (S[K - 1] == 'B') {
S[K - 1] = 'b';
} else {
S[K - 1] = 'c';
}
cout << S << endl;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 855,249 | 855,250 | u740002394 | cpp |
p03041 | // HEADER FILES AND NAMESPACES
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
// DEFINE STATEMENTS
#define num1 1000000007
#define num2 998244353
#define REP(i, a, n) for (ll i = a; i < n; i++)
#define REPd(i, a, n) for (ll i = a; i >= n; i--)
#define pb push_back
#define pob pop_back
#define f first
#define s second
#define fix(f, n) std::fixed << std::setprecision(n) << f
#define all(x) x.begin(), x.end()
#define M_PI 3.14159265358979323846
#define epsilon (double)(0.000000001)
typedef long long ll;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpll;
typedef vector<int> vii;
// DEBUG FUNCTIONS
#ifndef ONLINE_JUDGE
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
template <typename T> void __p(T a) { cout << a; }
template <typename T, typename F> void __p(pair<T, F> a) {
cout << "{";
__p(a.first);
cout << ",";
__p(a.second);
cout << "}";
}
template <typename T> void __p(std::vector<T> a) {
cout << "{";
for (auto it = a.begin(); it < a.end(); it++)
__p(*it), cout << ",}"[it + 1 == a.end()];
}
template <typename T, typename... Arg> void __p(T a1, Arg... a) {
__p(a1);
__p(a...);
}
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : ";
__p(arg1);
cout << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
int bracket = 0, i = 0;
for (;; i++)
if (names[i] == ',' && bracket == 0)
break;
else if (names[i] == '(')
bracket++;
else if (names[i] == ')')
bracket--;
const char *comma = names + i;
cout.write(names, comma - names) << " : ";
__p(arg1);
cout << " | ";
__f(comma + 1, args...);
}
#define trace(...) \
cout << "Line:" << __LINE__ << " ", __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...)
#define error(...)
#endif
// DEBUG FUNCTIONS END
// CUSTOM HASH TO SPEED UP UNORDERED MAP AND TO AVOID FORCED CLASHES
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
mt19937_64 rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // FOR RANDOM NUMBER GENERATION
ll mod_exp(ll a, ll b, ll c) {
ll res = 1;
a = a % c;
while (b > 0) {
if (b % 2 == 1)
res = (res * a) % c;
b /= 2;
a = (a * a) % c;
}
return res;
}
ll mymod(ll a, ll b) { return ((a % b) + b) % b; }
ll gcdExtended(ll, ll, ll *, ll *);
ll modInverse(ll a, ll m) {
ll x, y;
ll g = gcdExtended(a, m, &x, &y);
g++; // this line was added just to remove compiler warning
ll res = (x % m + m) % m;
return res;
}
ll gcdExtended(ll a, ll b, ll *x, ll *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
ll x1, y1;
ll gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k;
cin >> n >> k;
string s;
cin >> s;
s[k] = s[k] + 32;
cout << s << "\n";
return 0;
}
| // HEADER FILES AND NAMESPACES
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag,
tree_order_statistics_node_update>;
// DEFINE STATEMENTS
#define num1 1000000007
#define num2 998244353
#define REP(i, a, n) for (ll i = a; i < n; i++)
#define REPd(i, a, n) for (ll i = a; i >= n; i--)
#define pb push_back
#define pob pop_back
#define f first
#define s second
#define fix(f, n) std::fixed << std::setprecision(n) << f
#define all(x) x.begin(), x.end()
#define M_PI 3.14159265358979323846
#define epsilon (double)(0.000000001)
typedef long long ll;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpll;
typedef vector<int> vii;
// DEBUG FUNCTIONS
#ifndef ONLINE_JUDGE
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
template <typename T> void __p(T a) { cout << a; }
template <typename T, typename F> void __p(pair<T, F> a) {
cout << "{";
__p(a.first);
cout << ",";
__p(a.second);
cout << "}";
}
template <typename T> void __p(std::vector<T> a) {
cout << "{";
for (auto it = a.begin(); it < a.end(); it++)
__p(*it), cout << ",}"[it + 1 == a.end()];
}
template <typename T, typename... Arg> void __p(T a1, Arg... a) {
__p(a1);
__p(a...);
}
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cout << name << " : ";
__p(arg1);
cout << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
int bracket = 0, i = 0;
for (;; i++)
if (names[i] == ',' && bracket == 0)
break;
else if (names[i] == '(')
bracket++;
else if (names[i] == ')')
bracket--;
const char *comma = names + i;
cout.write(names, comma - names) << " : ";
__p(arg1);
cout << " | ";
__f(comma + 1, args...);
}
#define trace(...) \
cout << "Line:" << __LINE__ << " ", __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...)
#define error(...)
#endif
// DEBUG FUNCTIONS END
// CUSTOM HASH TO SPEED UP UNORDERED MAP AND TO AVOID FORCED CLASHES
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
mt19937_64 rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // FOR RANDOM NUMBER GENERATION
ll mod_exp(ll a, ll b, ll c) {
ll res = 1;
a = a % c;
while (b > 0) {
if (b % 2 == 1)
res = (res * a) % c;
b /= 2;
a = (a * a) % c;
}
return res;
}
ll mymod(ll a, ll b) { return ((a % b) + b) % b; }
ll gcdExtended(ll, ll, ll *, ll *);
ll modInverse(ll a, ll m) {
ll x, y;
ll g = gcdExtended(a, m, &x, &y);
g++; // this line was added just to remove compiler warning
ll res = (x % m + m) % m;
return res;
}
ll gcdExtended(ll a, ll b, ll *x, ll *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
ll x1, y1;
ll gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k;
cin >> n >> k;
string s;
cin >> s;
s[k - 1] = s[k - 1] + 32;
cout << s << "\n";
return 0;
}
| [
"assignment.change"
] | 855,253 | 855,254 | u729073980 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, k;
cin >> n >> k >> s;
string b = "ABC";
string l = "abc";
for (int i = 0; i < 3; i++) {
if (s.at(k - 1) == b.at(i)) {
s.at(k - 1) = l.at(i);
}
break;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, k;
cin >> n >> k >> s;
string b = "ABC";
string l = "abc";
for (int i = 0; i < 3; i++) {
if (s.at(k - 1) == b.at(i)) {
s.at(k - 1) = l.at(i);
}
}
cout << s << endl;
} | [] | 855,255 | 855,256 | u694766284 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
if (s.at(k - 1) = 'A') {
s.at(k - 1) = 'a';
} else if (s.at(k - 1) = 'B') {
s.at(k - 1) = 'b';
} else {
s.at(k - 1) = 'c';
}
cout << s;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
if (s.at(k - 1) == 'A') {
s.at(k - 1) = 'a';
} else if (s.at(k - 1) == 'B') {
s.at(k - 1) = 'b';
} else {
s.at(k - 1) = 'c';
}
cout << s;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 855,282 | 855,283 | u166378830 | cpp |
p03041 | //#include<bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
const int N = 200005;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
s[k] = tolower(s[k]);
cout << s;
return 0;
}
| //#include<bits/stdc++.h>
#include <iostream>
using namespace std;
typedef long long ll;
const int N = 200005;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
s[k - 1] = tolower(s[k - 1]);
cout << s;
return 0;
}
| [
"assignment.change"
] | 855,290 | 855,291 | u023228586 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
void Main() {
ll N, K;
cin >> N >> K;
string S;
cin >> S;
// tolower + transform
transform(S.begin() + (K - 1), S.begin() + K, S.begin(),
[](unsigned char c) { return std::tolower(c); });
cout << S << endl;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
void Main() {
ll N, K;
cin >> N >> K;
string S;
cin >> S;
// tolower + transform
transform(S.begin() + (K - 1), S.begin() + K, S.begin() + (K - 1),
[](unsigned char c) { return std::tolower(c); });
cout << S << endl;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
}
| [
"expression.operation.binary.add"
] | 855,315 | 855,316 | u891847179 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
b--;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b - 1) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
b--;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| [
"expression.operation.binary.remove"
] | 855,317 | 855,318 | u751515087 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s;
cin >> a >> b >> s;
b--;
if (s.at(b) == 'A') {
s.at(b) = 'a';
}
else if (s.at(b) == 'B') {
s.at(b) = 'b';
}
else if (s.at(b) == 'C') {
s.at(b) = 'c';
}
cout << s << endl;
}
| [
"expression.unary.arithmetic.add"
] | 855,319 | 855,318 | u751515087 | cpp |
p03041 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
const ll INF = 1e18;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main(int argc, char const *argv[]) {
int n, k;
string s;
cin >> n >> k >> s;
char c = s[k - 1] - 26;
s[k - 1] = c;
cout << s << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
const ll INF = 1e18;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main(int argc, char const *argv[]) {
int n, k;
string s;
cin >> n >> k >> s;
char c = s[k - 1] + 32;
s[k - 1] = c;
cout << s << endl;
return 0;
}
| [] | 855,322 | 855,323 | u406237526 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.