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 |
|---|---|---|---|---|---|---|---|
p03037 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define up(i, a, b) for (register int i = (a); i <= (b); i++)
#define down(i, a, b) for (register int i = (a); i >= (b); i--)
#define mem(x, y) memset(x, (y), sizeof x)
#define ff first
#define ss second
#define mp(x, y) make_pair(x, y)
#define pb(x) emplace_back(x)
#define sc(a) scanf("%d", &a)
#define scl(a) scanf("%lld", &a)
#define scs(a) scanf("%s", a)
#define pr(a, b) printf("%d%c", a, b)
#define prl(a, b) printf("%lld%c", a, b)
#define PQ priority_queue
#define ld long double
#define all(v) v.begin(), v.end()
#define IOS ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
typedef pair<int, int> pii;
typedef map<int, int> mii;
typedef vector<int> V;
pii a[100010];
int main() {
IOS;
int n, m;
cin >> m >> n;
up(i, 1, n) cin >> a[i].ff >> a[i].ss;
sort(a + 1, a + 1 + n);
int l = 0, r = 1e9;
up(i, 1, n) l = max(l, a[i].ff), r = min(r, a[i].ss);
cout << r - l + 1 << "\n";
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define up(i, a, b) for (register int i = (a); i <= (b); i++)
#define down(i, a, b) for (register int i = (a); i >= (b); i--)
#define mem(x, y) memset(x, (y), sizeof x)
#define ff first
#define ss second
#define mp(x, y) make_pair(x, y)
#define pb(x) emplace_back(x)
#define sc(a) scanf("%d", &a)
#define scl(a) scanf("%lld", &a)
#define scs(a) scanf("%s", a)
#define pr(a, b) printf("%d%c", a, b)
#define prl(a, b) printf("%lld%c", a, b)
#define PQ priority_queue
#define ld long double
#define all(v) v.begin(), v.end()
#define IOS ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
typedef pair<int, int> pii;
typedef map<int, int> mii;
typedef vector<int> V;
pii a[100010];
int main() {
IOS;
int n, m;
cin >> m >> n;
up(i, 1, n) cin >> a[i].ff >> a[i].ss;
sort(a + 1, a + 1 + n);
int l = 0, r = 1e9;
up(i, 1, n) l = max(l, a[i].ff), r = min(r, a[i].ss);
cout << max(0, r - l + 1) << "\n";
} | [
"call.add",
"call.arguments.change"
] | 852,622 | 852,623 | u084557456 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int a = 0x7fffffff, b;
int main() {
cin >> n >> m;
for (int x, y, i = 0; i < m; ++i) {
cin >> x >> y;
if (y < a)
a = y;
if (x > b)
b = x;
}
cout << a - b + 1;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, m;
int a = 0x7fffffff, b;
int main() {
cin >> n >> m;
for (int x, y, i = 0; i < m; ++i) {
cin >> x >> y;
if (y < a)
a = y;
if (x > b)
b = x;
}
cout << max(0, a - b + 1);
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 852,628 | 852,629 | u676842959 | cpp |
p03037 | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define LL long long
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPA(i, n) for (int i = 1; i < (n); ++i)
#define PII pair<int, int>
#define PLI pair<long long, int>
#define MOD ((int)1e9 + 7)
#define INF ((int)1e9)
#define INFLL ((LL)1e18)
#define ALL(x) (x).begin(), (x).end()
#define ctoi(x) (x - 'a')
#define CTOI(x) (x - 'A')
#define BIT(x) (1 << (x))
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int ln = 0;
int hn = N;
REP(i, M) {
int l, r;
cin >> l >> r;
ln = max(ln, l);
hn = min(r, hn);
}
cout << hn - ln + 1 << endl;
return 0;
}
| #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define LL long long
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPA(i, n) for (int i = 1; i < (n); ++i)
#define PII pair<int, int>
#define PLI pair<long long, int>
#define MOD ((int)1e9 + 7)
#define INF ((int)1e9)
#define INFLL ((LL)1e18)
#define ALL(x) (x).begin(), (x).end()
#define ctoi(x) (x - 'a')
#define CTOI(x) (x - 'A')
#define BIT(x) (1 << (x))
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int ln = 0;
int hn = N;
REP(i, M) {
int l, r;
cin >> l >> r;
ln = max(ln, l);
hn = min(r, hn);
}
cout << max(0, hn - ln + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 852,638 | 852,639 | u493610446 | cpp |
p03037 | #include <algorithm>
#include <climits>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define MAX 1000000007
using namespace std;
#define ll long long
#define dbg if (0)
#define ISRANGE(val, lo, hi) ((lo <= val) && (val < hi))
int main() {
ll ans, n, m;
cin >> n >> m;
ll Lmax, Rmin;
for (int i = 0; i < n; i++) {
ll l, r;
cin >> l >> r;
Lmax = max(Lmax, l);
Rmin = min(Rmin, r);
}
ans = max(0LL, Rmin - Lmax + 1);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define MAX 1000000007
using namespace std;
#define ll long long
#define dbg if (0)
#define ISRANGE(val, lo, hi) ((lo <= val) && (val < hi))
int main() {
ll ans, n, m;
cin >> n >> m;
ll Lmax = 0, Rmin = MAX;
for (int i = 0; i < m; i++) {
ll l, r;
cin >> l >> r;
Lmax = max(Lmax, l);
Rmin = min(Rmin, r);
}
ans = max(0LL, Rmin - Lmax + 1);
cout << ans << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 852,644 | 852,645 | u828752458 | cpp |
p03037 | #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(xi, x) for (auto &&xi : x)
// Note: we can use rep(i,N) or rep(i,from,to)
// typedef
using ll = long long;
template <class T> using vec = vector<T>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
// Constants
// Shorter repr for frequently used terms
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
// Algorithms
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase(unique(all(v)), v.end())
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
template <class T> pair<T, size_t> max(vector<T> &x) {
auto it = max_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> pair<T, size_t> min(vector<T> &x) {
auto it = min_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> inline bool chmax(T &maxval, const T &newval) {
if (maxval < newval) {
maxval = newval;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &minval, const T &newval) {
if (minval > newval) {
minval = newval;
return 1;
}
return 0;
}
// Utilities
// Grid world utilities
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
#define inside(H, W, y, x) 0 <= (x) && (x) < (W) && 0 <= (y) && (y) < (H)
inline int in() {
int x;
cin >> x;
return x;
} // read int from cin
inline ll IN() {
ll x;
cin >> x;
return x;
} // read ll from cin
// Debug
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
// Paste snippets here!!
//
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // Magic for faster cin
int N, M;
cin >> N >> M;
vi L(M);
vi R(M);
rep(i, M) cin >> L[i] >> R[i];
int a = 1;
int b = N;
rep(i, M) {
a = max(a, L[i]);
b = min(b, R[i]);
}
cout << b - a + 1 << endl;
return 0;
}
| #include <bits/stdc++.h> // include all standard C++ libraries
using namespace std;
// Loops
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(xi, x) for (auto &&xi : x)
// Note: we can use rep(i,N) or rep(i,from,to)
// typedef
using ll = long long;
template <class T> using vec = vector<T>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
// Constants
// Shorter repr for frequently used terms
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
// Algorithms
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase(unique(all(v)), v.end())
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
template <class T> pair<T, size_t> max(vector<T> &x) {
auto it = max_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> pair<T, size_t> min(vector<T> &x) {
auto it = min_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> inline bool chmax(T &maxval, const T &newval) {
if (maxval < newval) {
maxval = newval;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &minval, const T &newval) {
if (minval > newval) {
minval = newval;
return 1;
}
return 0;
}
// Utilities
// Grid world utilities
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
#define inside(H, W, y, x) 0 <= (x) && (x) < (W) && 0 <= (y) && (y) < (H)
inline int in() {
int x;
cin >> x;
return x;
} // read int from cin
inline ll IN() {
ll x;
cin >> x;
return x;
} // read ll from cin
// Debug
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
// Paste snippets here!!
//
int main() {
cin.tie(0);
ios::sync_with_stdio(false); // Magic for faster cin
int N, M;
cin >> N >> M;
vi L(M);
vi R(M);
rep(i, M) cin >> L[i] >> R[i];
int a = 1;
int b = N;
rep(i, M) {
a = max(a, L[i]);
b = min(b, R[i]);
}
cout << max(b - a + 1, 0) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 852,648 | 852,649 | u292813062 | cpp |
p03037 | #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define INF 2140000000
const long long MOD = 1000000007;
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
scanf("%d%d", &n, &m);
int left = 1, right = n;
int i;
for (i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
left = MAX(left, l);
right = MIN(right, r);
}
printf("%d\n", right - left + 1);
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define INF 2140000000
const long long MOD = 1000000007;
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
scanf("%d%d", &n, &m);
int left = 1, right = n;
int i;
for (i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
left = MAX(left, l);
right = MIN(right, r);
}
printf("%d\n", MAX(0, right - left + 1));
return 0;
}
| [
"call.arguments.add",
"call.arguments.change"
] | 852,654 | 852,655 | u209713918 | cpp |
p03037 | #include <iostream>
using namespace std;
int main() {
int n, m, min, max;
int a, b;
min = 1;
cin >> n >> m;
max = n;
for (int i = 0; i < m; i++) {
cin >> a >> b;
if (min < a) {
min = a;
}
if (b < max) {
max = b;
}
}
if (min < max) {
cout << max - min + 1 << endl;
} else {
cout << '0' << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int n, m, min, max;
int a, b;
min = 1;
cin >> n >> m;
max = n;
for (int i = 0; i < m; i++) {
cin >> a >> b;
if (min < a) {
min = a;
}
if (b < max) {
max = b;
}
}
if (min <= max) {
cout << max - min + 1 << endl;
} else {
cout << '0' << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 852,656 | 852,657 | u382826454 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
int N, M;
cin >> N >> M;
int left = 0;
int right = N - 1;
for (int i = 0; i < M; ++i) {
int l, r;
cin >> l >> r;
--l, --r;
left = max(left, l);
right = min(right, r);
}
int res = max(0, right - left);
++res;
cout << res << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
int N, M;
cin >> N >> M;
int left = 0;
int right = N - 1;
for (int i = 0; i < M; ++i) {
int l, r;
cin >> l >> r;
--l, --r;
left = max(left, l);
right = min(right, r);
}
int res = max(0, 1 + right - left);
cout << res << endl;
}
| [
"expression.unary.arithmetic.remove"
] | 852,664 | 852,665 | u600896094 | cpp |
p03037 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, m;
int l[200000], r[200000];
signed main() {
cin >> n >> m;
int mi = n, mx = 0;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
mi = min(mi, r[i]);
mx = max(mx, l[i]);
}
int ans = mi - mx + 1;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
// const ll mod = 1000000007;
int n, m;
int l[200000], r[200000];
signed main() {
cin >> n >> m;
int mi = n, mx = 0;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
mi = min(mi, r[i]);
mx = max(mx, l[i]);
}
int ans = max(mi - mx + 1, 0);
cout << ans << endl;
} | [
"call.add",
"call.arguments.add"
] | 852,668 | 852,669 | u263858205 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
int L[101000];
int R[101000];
cin >> N >> M;
int maxl = 0;
int minr = 1000000;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
if (maxl < L[i]) {
maxl = L[i];
}
if (minr > R[i]) {
minr = R[i];
}
}
cout << minr - maxl + 1 << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
int L[101000];
int R[101000];
cin >> N >> M;
int maxl = 0;
int minr = 1000000;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
if (maxl < L[i]) {
maxl = L[i];
}
if (minr > R[i]) {
minr = R[i];
}
}
cout << max(0, minr - maxl + 1) << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 852,674 | 852,675 | u982234424 | cpp |
p03037 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int N, M;
cin >> N >> M;
int l = 0, r = N;
for (int i = 0; i < M; i++) {
int Li, Ri;
cin >> Li >> Ri;
l = max(l, Li);
r = min(r, Ri);
}
cout << r - l + 1 << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int N, M;
cin >> N >> M;
int l = 0, r = N;
for (int i = 0; i < M; i++) {
int Li, Ri;
cin >> Li >> Ri;
l = max(l, Li);
r = min(r, Ri);
}
cout << max(0, r - l + 1) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 852,678 | 852,679 | u050706842 | cpp |
p03033 | #include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm(c++17)
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <string> //文字列
#include <unordered_map> //イテレータあるけど順序保持しないmap
#include <unordered_set> //イテレータあるけど順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) x.begin(), x.end() // sortなどの引数を省略したい
#define SIZE(x) ll(x.size()) // sizeをsize_tからllに直しておく
//定数
#define INF 1000000000000 // 10^12:極めて大きい値,∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange(素数列挙などで使用)
//略記
#define PB push_back // vectorヘの挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define Umap unordered_map
#define Uset unordered_set
//最後のところの処理がいい加減になっていた、こういう詰めの甘い実装がダメなんだよカス
signed main() {
//入力の高速化用のコード
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n, q;
cin >> n >> q;
vector<vector<ll>> xst(n);
REP(i, n) {
ll s, t, x;
cin >> s >> t >> x;
xst[i] = {x, s, t};
}
sort(ALL(xst));
vector<ll> d(q);
REP(i, q) cin >> d[i];
vector<deque<ll>> ans_sectl(q);
vector<deque<ll>> ans_sectr(q);
REP(i, n) {
ll s, t, x;
x = xst[i][0];
s = xst[i][1];
t = xst[i][2];
ll L = (lower_bound(ALL(d), s - x) - d.begin());
ll R = (upper_bound(ALL(d), t - x - 1) - d.begin()) - 1;
// lower,upper気を付ける
// 2RE
if (L > R) {
ans_sectl[L].PB(i);
ans_sectr[R].PB(i);
}
// cout << L << " " << R << endl;
}
//複数存在する場合もあるので、map
map<ll, ll> ans;
REP(i, q) {
ll sl = SIZE(ans_sectl[i]);
ll sr = SIZE(ans_sectr[i]);
REP(_, sl) {
ans[*(ans_sectl[i].begin())] += 1;
ans_sectl[i].pop_front();
}
//削除しておく
while (!ans.empty()) {
if (ans.begin()->S == 0) {
ans.erase(ans.begin());
} else {
break;
}
}
if (ans.empty()) {
cout << -1 << "\n";
} else {
cout << xst[ans.begin()->F][0] << "\n";
}
REP(_, sr) {
ans[*(ans_sectr[i].begin())] -= 1;
ans_sectr[i].pop_front();
}
}
} | #include <algorithm> //sort,二分探索,など
#include <bitset> //固定長bit集合
#include <cmath> //pow,logなど
#include <complex> //複素数
#include <deque> //両端アクセスのキュー
#include <functional> //sortのgreater
#include <iomanip> //setprecision(浮動小数点の出力の誤差)
#include <iostream> //入出力
#include <iterator> //集合演算(積集合,和集合,差集合など)
#include <map> //map(辞書)
#include <numeric> //iota(整数列の生成),gcdとlcm(c++17)
#include <queue> //キュー
#include <set> //集合
#include <stack> //スタック
#include <string> //文字列
#include <unordered_map> //イテレータあるけど順序保持しないmap
#include <unordered_set> //イテレータあるけど順序保持しないset
#include <utility> //pair
#include <vector> //可変長配列
using namespace std;
typedef long long ll;
//マクロ
// forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) x.begin(), x.end() // sortなどの引数を省略したい
#define SIZE(x) ll(x.size()) // sizeをsize_tからllに直しておく
//定数
#define INF 1000000000000 // 10^12:極めて大きい値,∞
#define MOD 1000000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange(素数列挙などで使用)
//略記
#define PB push_back // vectorヘの挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define Umap unordered_map
#define Uset unordered_set
//最後のところの処理がいい加減になっていた、こういう詰めの甘い実装がダメなんだよカス
signed main() {
//入力の高速化用のコード
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n, q;
cin >> n >> q;
vector<vector<ll>> xst(n);
REP(i, n) {
ll s, t, x;
cin >> s >> t >> x;
xst[i] = {x, s, t};
}
sort(ALL(xst));
vector<ll> d(q);
REP(i, q) cin >> d[i];
vector<deque<ll>> ans_sectl(q);
vector<deque<ll>> ans_sectr(q);
REP(i, n) {
ll s, t, x;
x = xst[i][0];
s = xst[i][1];
t = xst[i][2];
ll L = (lower_bound(ALL(d), s - x) - d.begin());
ll R = (upper_bound(ALL(d), t - x - 1) - d.begin()) - 1;
// lower,upper気を付ける
// 2RE
if (L <= R) {
ans_sectl[L].PB(i);
ans_sectr[R].PB(i);
}
// cout << L << " " << R << endl;
}
//複数存在する場合もあるので、map
map<ll, ll> ans;
REP(i, q) {
ll sl = SIZE(ans_sectl[i]);
ll sr = SIZE(ans_sectr[i]);
REP(_, sl) {
ans[*(ans_sectl[i].begin())] += 1;
ans_sectl[i].pop_front();
}
//削除しておく
while (!ans.empty()) {
if (ans.begin()->S == 0) {
ans.erase(ans.begin());
} else {
break;
}
}
if (ans.empty()) {
cout << -1 << "\n";
} else {
cout << xst[ans.begin()->F][0] << "\n";
}
REP(_, sr) {
ans[*(ans_sectr[i].begin())] -= 1;
ans_sectr[i].pop_front();
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 852,692 | 852,693 | u989345508 | cpp |
p03033 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
class LazySegmentTree {
// TODO: Change Monid and Operator, their identity, their product, and the
// action.
using Monoid = ll;
const Monoid INI_MONOID = 1e18;
Monoid monoid_product(const Monoid &a, const Monoid &b) { return min(a, b); }
using Operator = ll;
const Operator INI_OPERATOR = 1e18;
// p(q(a)) (i.e., not q(p(a)))
Operator operator_product(const Operator &p, const Operator &q) {
return min(p, q);
}
// a |-> b = (p, n)(a)
// n: Length of the range.
Monoid act(const Operator &p, int n, const Monoid &a) { return min(p, a); }
int num;
vector<Monoid> dat_mono;
vector<Operator> dat_op;
public:
LazySegmentTree(int n) {
num = 1;
while (num < n)
num *= 2;
dat_mono = vector<Monoid>(2 * num, INI_MONOID);
dat_op = vector<Operator>(2 * num, INI_OPERATOR);
}
LazySegmentTree(const vector<Monoid> &m) : LazySegmentTree(m.size()) {
int n = m.size();
for (int i = 0; i < n; i++) {
dat_mono[num - 1 + i] = m[i];
}
for (int i = num - 2; i >= 0; i--) {
dat_mono[i] = monoid_product(dat_mono[2 * i + 1], dat_mono[2 * i + 2]);
}
}
// Apply the operator q to the range [a, b).
// k: The index of the node.
// Call like apply(q, a, b)
void apply(Operator q, int a, int b, int k = 0, int left = 0,
int right = -1) {
if (right < 0)
right = num;
if (right <= a || b <= left)
return;
if (a <= left && right <= b) {
dat_mono[k] = act(q, right - left, dat_mono[k]);
dat_op[k] = operator_product(q, dat_op[k]);
return;
}
apply(dat_op[k], left, left + (right - left) / 2, 2 * k + 1, left,
left + (right - left) / 2); // Left side
apply(dat_op[k], left + (right - left) / 2, right, 2 * k + 2,
left + (right - left) / 2, right); // Right side
dat_op[k] = INI_OPERATOR;
apply(q, a, b, 2 * k + 1, left, left + (right - left) / 2); // Left side
apply(q, a, b, 2 * k + 2, left + (right - left) / 2, right); // Right side
dat_mono[k] = monoid_product(dat_mono[2 * k + 1], dat_mono[2 * k + 2]);
}
// Get the value of the range [a, b).
// k: The index of the node.
// [left, right): The range corresponds to the k-th node.
// Call like getval(a, b).
Monoid getval(int a, int b, int k = 0, int left = 0, int right = -1) {
if (right < 0)
right = num;
if (right <= a || b <= left)
return INI_MONOID;
if (a <= left && right <= b)
return dat_mono[k];
Monoid vleft =
getval(a, b, 2 * k + 1, left, left + (right - left) / 2); // Left side
Monoid vright =
getval(a, b, 2 * k + 2, left + (right - left) / 2, right); // Right side
return act(dat_op[k], max(0, min(b, right) - max(a, left)),
monoid_product(vleft, vright));
}
};
int main() {
int n, q;
cin >> n >> q;
vector<int> le(n), ri(n), x(n);
for (int i = 0; i < n; i++) {
int s, t;
cin >> s >> t >> x[i];
le[i] = s - x[i];
ri[i] = t - x[i];
}
vector<int> d(q);
for (int i = 0; i < q; i++) {
cin >> d[i];
}
LazySegmentTree seg(q);
for (int i = 0; i < n; i++) {
int lo = -1, hi = q;
while (hi - lo > 1) {
int mid = lo + (hi - lo) / 2;
if (d[mid] <= le[i])
lo = mid;
else
hi = mid;
}
int left = lo;
lo = -1, hi = q;
while (hi - lo > 1) {
int mid = lo + (hi - lo) / 2;
if (d[mid] < ri[i])
lo = mid;
else
hi = mid;
}
int right = hi;
seg.apply(x[i], left, right);
}
vector<int> ans(q);
for (int i = 0; i < q; i++) {
ll val = seg.getval(i, i + 1);
if (val >= 1e18)
ans[i] = -1;
else
ans[i] = val;
}
for (int i = 0; i < q; i++)
cout << ans[i] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
class LazySegmentTree {
// TODO: Change Monid and Operator, their identity, their product, and the
// action.
using Monoid = ll;
const Monoid INI_MONOID = 1e18;
Monoid monoid_product(const Monoid &a, const Monoid &b) { return min(a, b); }
using Operator = ll;
const Operator INI_OPERATOR = 1e18;
// p(q(a)) (i.e., not q(p(a)))
Operator operator_product(const Operator &p, const Operator &q) {
return min(p, q);
}
// a |-> b = (p, n)(a)
// n: Length of the range.
Monoid act(const Operator &p, int n, const Monoid &a) { return min(p, a); }
int num;
vector<Monoid> dat_mono;
vector<Operator> dat_op;
public:
LazySegmentTree(int n) {
num = 1;
while (num < n)
num *= 2;
dat_mono = vector<Monoid>(2 * num, INI_MONOID);
dat_op = vector<Operator>(2 * num, INI_OPERATOR);
}
LazySegmentTree(const vector<Monoid> &m) : LazySegmentTree(m.size()) {
int n = m.size();
for (int i = 0; i < n; i++) {
dat_mono[num - 1 + i] = m[i];
}
for (int i = num - 2; i >= 0; i--) {
dat_mono[i] = monoid_product(dat_mono[2 * i + 1], dat_mono[2 * i + 2]);
}
}
// Apply the operator q to the range [a, b).
// k: The index of the node.
// Call like apply(q, a, b)
void apply(Operator q, int a, int b, int k = 0, int left = 0,
int right = -1) {
if (right < 0)
right = num;
if (right <= a || b <= left)
return;
if (a <= left && right <= b) {
dat_mono[k] = act(q, right - left, dat_mono[k]);
dat_op[k] = operator_product(q, dat_op[k]);
return;
}
apply(dat_op[k], left, left + (right - left) / 2, 2 * k + 1, left,
left + (right - left) / 2); // Left side
apply(dat_op[k], left + (right - left) / 2, right, 2 * k + 2,
left + (right - left) / 2, right); // Right side
dat_op[k] = INI_OPERATOR;
apply(q, a, b, 2 * k + 1, left, left + (right - left) / 2); // Left side
apply(q, a, b, 2 * k + 2, left + (right - left) / 2, right); // Right side
dat_mono[k] = monoid_product(dat_mono[2 * k + 1], dat_mono[2 * k + 2]);
}
// Get the value of the range [a, b).
// k: The index of the node.
// [left, right): The range corresponds to the k-th node.
// Call like getval(a, b).
Monoid getval(int a, int b, int k = 0, int left = 0, int right = -1) {
if (right < 0)
right = num;
if (right <= a || b <= left)
return INI_MONOID;
if (a <= left && right <= b)
return dat_mono[k];
Monoid vleft =
getval(a, b, 2 * k + 1, left, left + (right - left) / 2); // Left side
Monoid vright =
getval(a, b, 2 * k + 2, left + (right - left) / 2, right); // Right side
return act(dat_op[k], max(0, min(b, right) - max(a, left)),
monoid_product(vleft, vright));
}
};
int main() {
int n, q;
cin >> n >> q;
vector<int> le(n), ri(n), x(n);
for (int i = 0; i < n; i++) {
int s, t;
cin >> s >> t >> x[i];
le[i] = s - x[i];
ri[i] = t - x[i];
}
vector<int> d(q);
for (int i = 0; i < q; i++) {
cin >> d[i];
}
LazySegmentTree seg(q);
for (int i = 0; i < n; i++) {
int lo = -1, hi = q;
while (hi - lo > 1) {
int mid = lo + (hi - lo) / 2;
if (d[mid] < le[i])
lo = mid;
else
hi = mid;
}
int left = hi;
lo = -1, hi = q;
while (hi - lo > 1) {
int mid = lo + (hi - lo) / 2;
if (d[mid] < ri[i])
lo = mid;
else
hi = mid;
}
int right = hi;
seg.apply(x[i], left, right);
}
vector<int> ans(q);
for (int i = 0; i < q; i++) {
ll val = seg.getval(i, i + 1);
if (val >= 1e18)
ans[i] = -1;
else
ans[i] = val;
}
for (int i = 0; i < q; i++)
cout << ans[i] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"variable_declaration.value.change",
"identifier.change"
] | 852,718 | 852,719 | u843522325 | cpp |
p03033 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<double> vd;
typedef vector<vd> vdd;
typedef pair<double, double> pd;
typedef vector<pd> vpd;
#define FOR(i, x, y) for (ll i = (ll)x; i < (ll)y; ++i)
#define REP(i, y) FOR(i, 0, y)
#define RFOR(i, x, y) for (ll i = (ll)x; i >= (ll)y; --i)
#define RREP(i, x) RFOR(i, x, 0)
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define debug_print(x...) \
cerr << "line " << __LINE__ << " : "; \
debug_print_in(x);
template <typename First> void debug_print_in(First first) {
cerr << first << endl;
return;
}
template <typename First, typename... Rest>
void debug_print_in(First first, Rest... rest) {
cerr << first << " ";
debug_print_in(rest...);
return;
}
void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
template <typename First> void OUT(First first) {
cout << first << endl;
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
template <class t, class u> t chmax(t &a, u b) {
if (a < b)
a = b;
return a;
};
template <class t, class u> t chmin(t &a, u b) {
if (a > b)
a = b;
return a;
};
int popcount(int t) { return __builtin_popcount(t); } // GCC
int popcount(ll t) { return __builtin_popcountll(t); } // GCC
template <typename T> void vec_print(vector<T> VEC) {
REP(i, VEC.size()) { cerr << VEC[i] << " "; }
cerr << endl;
};
template <typename T>
void mat_print(vector<vector<T>> MAT){
REP(i, MAT.size()){REP(j, MAT[i].size()){cerr << MAT[i][j] << " ";
}
cerr << endl;
}
}
;
constexpr int INF = (1 << 30);
constexpr ll INFLL = 1LL << 62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9) + 7);
template <typename DATA> class Sparse_Segment_Tree {
public:
ll n_;
unordered_map<ll, DATA> lazy2;
using F = function<DATA(DATA, DATA)>;
const F f;
const DATA init;
Sparse_Segment_Tree(const F &f, const DATA init) : f(f), init(init) {
n_ = 1;
return;
};
~Sparse_Segment_Tree(void) { return; };
ll get_hash(ll l, ll r) { return l * 2000000001 + r; }
//[a,b)の範囲に対してxを作用させる
void rangeupdate2(ll a, ll b, DATA x, ll l, ll r) {
if (a <= l && r <= b) {
if (lazy2.find(get_hash(l, r)) == lazy2.end()) {
lazy2[get_hash(l, r)] = init;
} else {
lazy2[get_hash(l, r)] = f(lazy2[get_hash(l, r)], x);
}
} else {
if (a < (l + r) / 2)
rangeupdate2(a, b, x, l, (l + r) / 2);
if ((l + r) / 2 < b)
rangeupdate2(a, b, x, (l + r) / 2, r);
}
return;
}
void rangeupdate2(ll a, ll b, DATA x) {
while (n_ <= b)
n_ <<= 1;
rangeupdate2(a, b, x, 0, n_);
return;
}
DATA pointquery(ll a, ll l, ll r) {
DATA tmp = init;
if (lazy2.find(get_hash(l, r)) != lazy2.end())
tmp = lazy2[get_hash(l, r)];
if (r - l <= 1)
return tmp;
if (a < (l + r) / 2)
return f(tmp, pointquery(a, l, (l + r) / 2));
return f(tmp, pointquery(a, (l + r) / 2, r));
};
DATA pointquery(ll a) {
if (a < 0) {
fprintf(stderr, "Segment_Tree Search Space Error\n");
fprintf(stderr, "Desired:\n");
fprintf(stderr, "%lld <= %lld\n", 0, a);
exit(0);
} else if (n_ <= a) {
return init;
}
return pointquery(a, 0, n_);
};
};
int main() {
cin.tie(0); // cut the cin and cout (default, std::flush is performed after
// std::cin)
ios::sync_with_stdio(
false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll N, Q;
cin >> N >> Q;
auto f = [](ll a, ll b) { return min(a, b); };
Sparse_Segment_Tree<ll> que(f, 0);
ll Shift = 1000000001;
ll S, T, X;
REP(i, N) {
cin >> S >> T >> X;
que.rangeupdate2(S - X + Shift, T - X + Shift, X - Shift);
}
ll D;
REP(i, Q) {
cin >> D;
ll X = que.pointquery(D + Shift) + Shift;
if (X == Shift)
X = -1;
cout << X << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<double> vd;
typedef vector<vd> vdd;
typedef pair<double, double> pd;
typedef vector<pd> vpd;
#define FOR(i, x, y) for (ll i = (ll)x; i < (ll)y; ++i)
#define REP(i, y) FOR(i, 0, y)
#define RFOR(i, x, y) for (ll i = (ll)x; i >= (ll)y; --i)
#define RREP(i, x) RFOR(i, x, 0)
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define debug_print(x...) \
cerr << "line " << __LINE__ << " : "; \
debug_print_in(x);
template <typename First> void debug_print_in(First first) {
cerr << first << endl;
return;
}
template <typename First, typename... Rest>
void debug_print_in(First first, Rest... rest) {
cerr << first << " ";
debug_print_in(rest...);
return;
}
void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
template <typename First> void OUT(First first) {
cout << first << endl;
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
template <class t, class u> t chmax(t &a, u b) {
if (a < b)
a = b;
return a;
};
template <class t, class u> t chmin(t &a, u b) {
if (a > b)
a = b;
return a;
};
int popcount(int t) { return __builtin_popcount(t); } // GCC
int popcount(ll t) { return __builtin_popcountll(t); } // GCC
template <typename T> void vec_print(vector<T> VEC) {
REP(i, VEC.size()) { cerr << VEC[i] << " "; }
cerr << endl;
};
template <typename T>
void mat_print(vector<vector<T>> MAT){
REP(i, MAT.size()){REP(j, MAT[i].size()){cerr << MAT[i][j] << " ";
}
cerr << endl;
}
}
;
constexpr int INF = (1 << 30);
constexpr ll INFLL = 1LL << 62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9) + 7);
template <typename DATA> class Sparse_Segment_Tree {
public:
ll n_;
unordered_map<ll, DATA> lazy2;
using F = function<DATA(DATA, DATA)>;
const F f;
const DATA init;
Sparse_Segment_Tree(const F &f, const DATA init) : f(f), init(init) {
n_ = 1;
return;
};
~Sparse_Segment_Tree(void) { return; };
ll get_hash(ll l, ll r) { return l * 2000000001 + r; }
//[a,b)の範囲に対してxを作用させる
void rangeupdate2(ll a, ll b, DATA x, ll l, ll r) {
if (a <= l && r <= b) {
if (lazy2.find(get_hash(l, r)) == lazy2.end()) {
lazy2[get_hash(l, r)] = x;
} else {
lazy2[get_hash(l, r)] = f(lazy2[get_hash(l, r)], x);
}
} else {
if (a < (l + r) / 2)
rangeupdate2(a, b, x, l, (l + r) / 2);
if ((l + r) / 2 < b)
rangeupdate2(a, b, x, (l + r) / 2, r);
}
return;
}
void rangeupdate2(ll a, ll b, DATA x) {
while (n_ <= b)
n_ <<= 1;
rangeupdate2(a, b, x, 0, n_);
return;
}
DATA pointquery(ll a, ll l, ll r) {
DATA tmp = init;
if (lazy2.find(get_hash(l, r)) != lazy2.end())
tmp = lazy2[get_hash(l, r)];
if (r - l <= 1)
return tmp;
if (a < (l + r) / 2)
return f(tmp, pointquery(a, l, (l + r) / 2));
return f(tmp, pointquery(a, (l + r) / 2, r));
};
DATA pointquery(ll a) {
if (a < 0) {
fprintf(stderr, "Segment_Tree Search Space Error\n");
fprintf(stderr, "Desired:\n");
fprintf(stderr, "%lld <= %lld\n", 0, a);
exit(0);
} else if (n_ <= a) {
return init;
}
return pointquery(a, 0, n_);
};
};
int main() {
cin.tie(0); // cut the cin and cout (default, std::flush is performed after
// std::cin)
ios::sync_with_stdio(
false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll N, Q;
cin >> N >> Q;
auto f = [](ll a, ll b) { return min(a, b); };
Sparse_Segment_Tree<ll> que(f, 0);
ll Shift = 1000000001;
ll S, T, X;
REP(i, N) {
cin >> S >> T >> X;
que.rangeupdate2(S - X + Shift, T - X + Shift, X - Shift);
}
ll D;
REP(i, Q) {
cin >> D;
ll X = que.pointquery(D + Shift) + Shift;
if (X == Shift)
X = -1;
cout << X << "\n";
}
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 852,725 | 852,726 | u355335354 | cpp |
p03033 | #include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
template <typename T> map<T, int> coordinate_compression(vector<T> x) {
int n = x.size();
vector<int> y(n);
iota(y.begin(), y.end(), 0);
sort(y.begin(), y.end(), [&](int i, int j) { return x[i] < x[j]; });
map<T, int> res;
for (int i : y)
if (!res.count(x[i])) {
int j = res.size();
res[x[i]] = j;
}
return res;
}
// Dual Segment Tree
template <class OM = int> struct DST {
int n, lev;
vector<OM> lz;
virtual OM h(OM, OM) = 0;
const OM e0;
DST(int n_, const OM &e0) : e0(e0) {
for (n = 1, lev = 0; n < n_; n <<= 1, ++lev)
;
lz.assign(n << 1, e0);
}
inline void push(int k) {
for (int i = lev; i > 0; --i) {
int j = k >> i;
if (lz[j] == e0)
continue;
lz[(j << 1) | 0] = h(lz[(j << 1) | 0], lz[j]);
lz[(j << 1) | 1] = h(lz[(j << 1) | 1], lz[j]);
lz[j] = e0;
}
}
// [l, r)
// l, r: 0-indexed
void update(int l, int r, const OM &x) {
push(l += n);
push(r += n - 1);
for (++r; l < r; l >>= 1, r >>= 1) {
if (l & 1)
lz[l] = h(lz[l], x), l++;
if (r & 1)
--r, lz[r] = h(lz[r], x);
}
}
// k: 0-indexed
OM query(int k) {
push(k += n);
return lz[k];
}
void dump(int);
};
// Range Update Query (RUQ)
template <class OM> struct RUQ : DST<OM> {
RUQ(int n, OM e0 = numeric_limits<OM>::max()) : DST<OM>(n, e0) {}
OM h(OM a, OM b) override { return b; }
};
// Range Add Query (RAQ)
template <class OM> struct RAQ : DST<OM> {
RAQ(int n, OM e0 = 0) : DST<OM>(n, e0) {}
OM h(OM a, OM b) override { return a + b; }
};
// print for debug
template <class M> void DST<M>::dump(int time) {
if (~time)
cerr << "time = " << time << endl;
for (int i = 1; i <= (1LL << lev); i <<= 1) {
for (int j = 0; j < i; ++j) {
cerr << " " << lz[j + i];
}
cerr << endl;
}
cerr << endl;
}
int N, Q;
int S[200010], T[200010], X[200010], D[200010];
void _main() {
cin >> N >> Q;
vector<int> v;
REP(i, N) {
cin >> S[i] >> T[i] >> X[i];
v.push_back(max(0LL, S[i] - X[i]));
v.push_back(max(0LL, T[i] - X[i]));
}
REP(i, Q) {
cin >> D[i];
v.push_back(D[i]);
}
auto cc = coordinate_compression(v);
vector<int> ord(N);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(), [&](int i, int j) { return S[i] > S[j]; });
RUQ<int> ruq(cc.size(), -1);
REP(i, N) {
int j = ord[i];
ruq.update(cc[S[j] - X[j]], cc[T[j] - X[j]], j);
}
REP(i, Q) {
int j = ruq.query(cc[D[i]]);
if (j == -1)
cout << -1 << endl;
else
cout << X[j] << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(10);
_main();
return 0;
} | #include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
template <typename T> map<T, int> coordinate_compression(vector<T> x) {
int n = x.size();
vector<int> y(n);
iota(y.begin(), y.end(), 0);
sort(y.begin(), y.end(), [&](int i, int j) { return x[i] < x[j]; });
map<T, int> res;
for (int i : y)
if (!res.count(x[i])) {
int j = res.size();
res[x[i]] = j;
}
return res;
}
// Dual Segment Tree
template <class OM = int> struct DST {
int n, lev;
vector<OM> lz;
virtual OM h(OM, OM) = 0;
const OM e0;
DST(int n_, const OM &e0) : e0(e0) {
for (n = 1, lev = 0; n < n_; n <<= 1, ++lev)
;
lz.assign(n << 1, e0);
}
inline void push(int k) {
for (int i = lev; i > 0; --i) {
int j = k >> i;
if (lz[j] == e0)
continue;
lz[(j << 1) | 0] = h(lz[(j << 1) | 0], lz[j]);
lz[(j << 1) | 1] = h(lz[(j << 1) | 1], lz[j]);
lz[j] = e0;
}
}
// [l, r)
// l, r: 0-indexed
void update(int l, int r, const OM &x) {
push(l += n);
push(r += n - 1);
for (++r; l < r; l >>= 1, r >>= 1) {
if (l & 1)
lz[l] = h(lz[l], x), l++;
if (r & 1)
--r, lz[r] = h(lz[r], x);
}
}
// k: 0-indexed
OM query(int k) {
push(k += n);
return lz[k];
}
void dump(int);
};
// Range Update Query (RUQ)
template <class OM> struct RUQ : DST<OM> {
RUQ(int n, OM e0 = numeric_limits<OM>::max()) : DST<OM>(n, e0) {}
OM h(OM a, OM b) override { return b; }
};
// Range Add Query (RAQ)
template <class OM> struct RAQ : DST<OM> {
RAQ(int n, OM e0 = 0) : DST<OM>(n, e0) {}
OM h(OM a, OM b) override { return a + b; }
};
// print for debug
template <class M> void DST<M>::dump(int time) {
if (~time)
cerr << "time = " << time << endl;
for (int i = 1; i <= (1LL << lev); i <<= 1) {
for (int j = 0; j < i; ++j) {
cerr << " " << lz[j + i];
}
cerr << endl;
}
cerr << endl;
}
int N, Q;
int S[200010], T[200010], X[200010], D[200010];
void _main() {
cin >> N >> Q;
vector<int> v;
REP(i, N) {
cin >> S[i] >> T[i] >> X[i];
v.push_back(max(0LL, S[i] - X[i]));
v.push_back(max(0LL, T[i] - X[i]));
}
REP(i, Q) {
cin >> D[i];
v.push_back(D[i]);
}
auto cc = coordinate_compression(v);
vector<int> ord(N);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(), [&](int i, int j) { return X[i] > X[j]; });
RUQ<int> ruq(cc.size(), -1);
REP(i, N) {
int j = ord[i];
ruq.update(cc[S[j] - X[j]], cc[T[j] - X[j]], j);
}
REP(i, Q) {
int j = ruq.query(cc[D[i]]);
if (j == -1)
cout << -1 << endl;
else
cout << X[j] << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(10);
_main();
return 0;
} | [
"identifier.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 852,727 | 852,728 | u141642872 | cpp |
p03033 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<pair<ll, ll>>> vvpll;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 100010;
int main() {
ll n, q;
cin >> n >> q;
vector<pair<ll, pair<ll, ll>>> p(n);
rep(i, n) {
ll s, t, x;
cin >> s >> t >> x;
s -= x;
t -= x;
p[i] = make_pair(x, make_pair(s, t));
}
sort(all(p));
set<pair<ll, ll>> st;
rep(i, q) {
ll d;
cin >> d;
st.insert(make_pair(d, i));
}
vl ans(q, -1);
rep(i, n) {
ll x = p[i].first;
ll l = p[i].second.first;
ll r = p[i].second.second;
auto it = st.lower_bound(make_pair(l, -1));
while (it != st.end()) {
if (it->first >= r) {
break;
}
ans[it->second] = x;
st.erase(it);
it++;
}
}
rep(i, q) { out(ans[i]); }
re0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<pair<ll, ll>>> vvpll;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 100010;
int main() {
ll n, q;
cin >> n >> q;
vector<pair<ll, pair<ll, ll>>> p(n);
rep(i, n) {
ll s, t, x;
cin >> s >> t >> x;
s -= x;
t -= x;
p[i] = make_pair(x, make_pair(s, t));
}
sort(all(p));
set<pair<ll, ll>> st;
rep(i, q) {
ll d;
cin >> d;
st.insert(make_pair(d, i));
}
vl ans(q, -1);
rep(i, n) {
ll x = p[i].first;
ll l = p[i].second.first;
ll r = p[i].second.second;
auto it = st.lower_bound(make_pair(l, -1));
while (it != st.end()) {
if (it->first >= r) {
break;
}
ans[it->second] = x;
st.erase(it++);
}
}
rep(i, q) { out(ans[i]); }
re0;
} | [
"call.arguments.change",
"expression.unary.arithmetic.remove"
] | 852,747 | 852,748 | u828388155 | cpp |
p03033 |
#include <time.h>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream> // ifstream, ofstream
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <omp.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string>
#include <vector>
typedef int64_t ll;
using namespace std;
const ll INF = 1e10;
struct Construction {
ll s;
ll t;
ll position;
};
bool operator<(const Construction &a, const Construction &b) {
return a.position < b.position;
}
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <functional>
#include <iostream>
#include <limits>
class SegmentTree_range {
public:
SegmentTree_range(int64_t size, const int64_t *d);
SegmentTree_range(const SegmentTree_range &t);
SegmentTree_range &operator=(const SegmentTree_range &t);
int64_t get(const int64_t address) const;
void change(const int64_t a, const int64_t b,
const int64_t value); //[a,b]の値をvalueに更新
virtual ~SegmentTree_range();
protected:
struct unit {
bool need_further = true;
int64_t value;
};
int64_t max_depth;
int64_t get(const int64_t address, const int64_t ptr, const int64_t range_min,
const int64_t range_max) const;
// calcminからよばれる内部処理 [a,b]について、配列番号ptrのものを探索
// 配列番号ptrが指す範囲は、[range_min,range_max]
void change(const int64_t a, const int64_t b, const int64_t value,
const int64_t ptr, const int64_t range_min,
const int64_t range_max);
int64_t size;
unit *data;
};
SegmentTree_range::SegmentTree_range(int64_t dsize, const int64_t *d) {
// TODO 自動生成されたコンストラクター・スタブ
for (int i = 63; i >= 0; i--) {
if (dsize & ((uint64_t)1 << i)) {
max_depth = i + 1;
break;
}
}
this->size = ((uint64_t)1 << (max_depth));
data = new unit[2 * size - 1];
for (int64_t i = 0; i < dsize; i++) {
data[size - 1 + i].value = d[i];
data[size - 1 + i].need_further = false;
}
for (int64_t i = dsize; i < size; i++) {
data[size - 1 + i].value = std::numeric_limits<int64_t>::max();
data[size - 1 + i].need_further = false;
}
for (int64_t i = size - 2; i >= 0; i--) {
if ((!data[2 * i + 1].need_further) && (!data[2 * i + 2].need_further) &&
data[2 * i + 1].value == data[2 * i + 2].value) {
data[i].need_further = false;
data[i].value = data[2 * i + 1].value;
} else {
data[i].need_further = true;
}
}
}
SegmentTree_range::SegmentTree_range(const SegmentTree_range &t) {
if (&t == this) {
max_depth = 1;
size = 1;
data = new unit[1];
data[0].value = 0;
data[0].need_further = false;
} else {
max_depth = t.max_depth;
size = t.size;
data = new unit[2 * size - 1];
for (int64_t i = 0; i < (2 * size - 1); i++) {
data[i].need_further = t.data[i].need_further;
data[i].value = t.data[i].value;
}
}
}
SegmentTree_range &SegmentTree_range::operator=(const SegmentTree_range &t) {
if (&t != this) {
delete[] data;
max_depth = t.max_depth;
size = t.size;
data = new unit[2 * size - 1];
for (int64_t i = 0; i < (2 * size - 1); i++) {
data[i].need_further = t.data[i].need_further;
data[i].value = t.data[i].value;
}
}
return *this;
}
int64_t SegmentTree_range::get(const int64_t address) const {
return get(address, 0, 0, size - 1);
}
int64_t SegmentTree_range::get(const int64_t address, const int64_t ptr,
const int64_t range_min,
const int64_t range_max) const {
if (data[ptr].need_further) {
int64_t border = (range_max + range_min - 1) / 2;
if (address <= border) {
return get(address, 2 * ptr + 1, range_min, border);
} else {
return get(address, 2 * ptr + 2, border + 1, range_max);
}
} else {
return data[ptr].value;
}
}
void SegmentTree_range::change(const int64_t a, const int64_t b,
const int64_t value) {
change(a, b, value, 0, 0, size - 1);
}
void SegmentTree_range::change(const int64_t a, const int64_t b,
const int64_t value, const int64_t ptr,
const int64_t range_min,
const int64_t range_max) {
int64_t border = (range_max + range_min - 1) / 2;
if (a <= range_min && b >= range_max) {
data[ptr].need_further = false;
data[ptr].value = value;
} else {
if (!data[ptr].need_further) {
data[2 * ptr + 1].need_further = false;
data[2 * ptr + 2].need_further = false;
data[2 * ptr + 1].value = data[ptr].value;
data[2 * ptr + 2].value = data[ptr].value;
}
data[ptr].need_further = true;
if (b <= border) {
change(a, b, value, 2 * ptr + 1, range_min, border);
} else if (a >= border + 1) {
change(a, b, value, 2 * ptr + 2, border + 1, range_max);
} else {
change(a, border, value, 2 * ptr + 1, range_min, border);
change(border + 1, b, value, 2 * ptr + 2, border + 1, range_max);
}
}
}
SegmentTree_range::~SegmentTree_range() {}
int main() {
ll n, q;
cin >> n >> q;
vector<Construction> con;
for (ll i1 = 0; i1 < n; i1++) {
ll s, t, x;
cin >> s >> t >> x;
con.push_back(Construction{s, t, x});
}
sort(con.begin(), con.end());
reverse(con.begin(), con.end());
vector<ll> d;
ll temp[q];
for (int i1 = 0; i1 < q; i1++) {
ll temp;
cin >> temp;
d.push_back(temp);
}
for (ll i1 = 0; i1 < q; i1++) {
temp[i1] = -1;
}
SegmentTree_range ans(q, temp);
for (auto i1 = con.begin(); i1 != con.end(); i1++) {
ll time_beginning = (i1->s) - (i1->position);
ll time_end = (i1->t) - (i1->position);
if (time_beginning > d[q - 1]) {
continue;
}
auto begin_iter = lower_bound(d.begin(), d.end(), time_beginning);
auto end_iter = lower_bound(d.begin(), d.end(), time_end);
ll begin_index = distance(d.begin(), begin_iter);
ll end_index = distance(d.begin(), end_iter);
if (time_end > d[q - 1]) {
end_index = q;
}
if (end_index < begin_index) {
continue;
}
ans.change(begin_index, end_index - 1, i1->position);
}
for (ll i1 = 0; i1 < q; i1++) {
cout << ans.get(i1) << endl;
}
}
|
#include <time.h>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream> // ifstream, ofstream
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <omp.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string>
#include <vector>
typedef int64_t ll;
using namespace std;
const ll INF = 1e10;
struct Construction {
ll s;
ll t;
ll position;
};
bool operator<(const Construction &a, const Construction &b) {
return a.position < b.position;
}
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <functional>
#include <iostream>
#include <limits>
class SegmentTree_range {
public:
SegmentTree_range(int64_t size, const int64_t *d);
SegmentTree_range(const SegmentTree_range &t);
SegmentTree_range &operator=(const SegmentTree_range &t);
int64_t get(const int64_t address) const;
void change(const int64_t a, const int64_t b,
const int64_t value); //[a,b]の値をvalueに更新
virtual ~SegmentTree_range();
protected:
struct unit {
bool need_further = true;
int64_t value;
};
int64_t max_depth;
int64_t get(const int64_t address, const int64_t ptr, const int64_t range_min,
const int64_t range_max) const;
// calcminからよばれる内部処理 [a,b]について、配列番号ptrのものを探索
// 配列番号ptrが指す範囲は、[range_min,range_max]
void change(const int64_t a, const int64_t b, const int64_t value,
const int64_t ptr, const int64_t range_min,
const int64_t range_max);
int64_t size;
unit *data;
};
SegmentTree_range::SegmentTree_range(int64_t dsize, const int64_t *d) {
// TODO 自動生成されたコンストラクター・スタブ
for (int i = 63; i >= 0; i--) {
if (dsize & ((uint64_t)1 << i)) {
max_depth = i + 1;
break;
}
}
this->size = ((uint64_t)1 << (max_depth));
data = new unit[2 * size - 1];
for (int64_t i = 0; i < dsize; i++) {
data[size - 1 + i].value = d[i];
data[size - 1 + i].need_further = false;
}
for (int64_t i = dsize; i < size; i++) {
data[size - 1 + i].value = std::numeric_limits<int64_t>::max();
data[size - 1 + i].need_further = false;
}
for (int64_t i = size - 2; i >= 0; i--) {
if ((!data[2 * i + 1].need_further) && (!data[2 * i + 2].need_further) &&
data[2 * i + 1].value == data[2 * i + 2].value) {
data[i].need_further = false;
data[i].value = data[2 * i + 1].value;
} else {
data[i].need_further = true;
}
}
}
SegmentTree_range::SegmentTree_range(const SegmentTree_range &t) {
if (&t == this) {
max_depth = 1;
size = 1;
data = new unit[1];
data[0].value = 0;
data[0].need_further = false;
} else {
max_depth = t.max_depth;
size = t.size;
data = new unit[2 * size - 1];
for (int64_t i = 0; i < (2 * size - 1); i++) {
data[i].need_further = t.data[i].need_further;
data[i].value = t.data[i].value;
}
}
}
SegmentTree_range &SegmentTree_range::operator=(const SegmentTree_range &t) {
if (&t != this) {
delete[] data;
max_depth = t.max_depth;
size = t.size;
data = new unit[2 * size - 1];
for (int64_t i = 0; i < (2 * size - 1); i++) {
data[i].need_further = t.data[i].need_further;
data[i].value = t.data[i].value;
}
}
return *this;
}
int64_t SegmentTree_range::get(const int64_t address) const {
return get(address, 0, 0, size - 1);
}
int64_t SegmentTree_range::get(const int64_t address, const int64_t ptr,
const int64_t range_min,
const int64_t range_max) const {
if (data[ptr].need_further) {
int64_t border = (range_max + range_min - 1) / 2;
if (address <= border) {
return get(address, 2 * ptr + 1, range_min, border);
} else {
return get(address, 2 * ptr + 2, border + 1, range_max);
}
} else {
return data[ptr].value;
}
}
void SegmentTree_range::change(const int64_t a, const int64_t b,
const int64_t value) {
change(a, b, value, 0, 0, size - 1);
}
void SegmentTree_range::change(const int64_t a, const int64_t b,
const int64_t value, const int64_t ptr,
const int64_t range_min,
const int64_t range_max) {
int64_t border = (range_max + range_min - 1) / 2;
if (a <= range_min && b >= range_max) {
data[ptr].need_further = false;
data[ptr].value = value;
} else {
if (!data[ptr].need_further) {
data[2 * ptr + 1].need_further = false;
data[2 * ptr + 2].need_further = false;
data[2 * ptr + 1].value = data[ptr].value;
data[2 * ptr + 2].value = data[ptr].value;
}
data[ptr].need_further = true;
if (b <= border) {
change(a, b, value, 2 * ptr + 1, range_min, border);
} else if (a >= border + 1) {
change(a, b, value, 2 * ptr + 2, border + 1, range_max);
} else {
change(a, border, value, 2 * ptr + 1, range_min, border);
change(border + 1, b, value, 2 * ptr + 2, border + 1, range_max);
}
}
}
SegmentTree_range::~SegmentTree_range() {}
int main() {
ll n, q;
cin >> n >> q;
vector<Construction> con;
for (ll i1 = 0; i1 < n; i1++) {
ll s, t, x;
cin >> s >> t >> x;
con.push_back(Construction{s, t, x});
}
sort(con.begin(), con.end());
reverse(con.begin(), con.end());
vector<ll> d;
ll temp[q];
for (int i1 = 0; i1 < q; i1++) {
ll temp;
cin >> temp;
d.push_back(temp);
}
for (ll i1 = 0; i1 < q; i1++) {
temp[i1] = -1;
}
SegmentTree_range ans(q, temp);
for (auto i1 = con.begin(); i1 != con.end(); i1++) {
ll time_beginning = (i1->s) - (i1->position);
ll time_end = (i1->t) - (i1->position);
if (time_beginning > d[q - 1]) {
continue;
}
auto begin_iter = lower_bound(d.begin(), d.end(), time_beginning);
auto end_iter = lower_bound(d.begin(), d.end(), time_end);
ll begin_index = distance(d.begin(), begin_iter);
ll end_index = distance(d.begin(), end_iter);
if (time_end > d[q - 1]) {
end_index = q;
}
if (end_index - 1 < begin_index) {
continue;
}
ans.change(begin_index, end_index - 1, i1->position);
}
for (ll i1 = 0; i1 < q; i1++) {
cout << ans.get(i1) << endl;
}
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 852,757 | 852,758 | u279976468 | cpp |
p03033 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb emplace_back
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
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;
}
using namespace std;
using P = pair<int, int>;
void solve() {
int n, q;
cin >> n >> q;
int a, b, c;
vector<pair<int, P>> v;
set<pair<int, int>> st;
rep(i, n) {
cin >> a >> b >> c;
v.eb(c, P{a - c, b - c});
}
sort(v.begin(), v.end());
rep(i, q) {
int d;
cin >> d;
st.emplace(d, i);
}
vector<int> ans(q, -1);
rep(i, n) {
auto itr = st.lower_bound(make_pair(v[i].second.first, -1));
while (!st.empty()) {
if (v[i].second.second > itr->first)
ans[itr->second] = v[i].first;
else
break;
st.erase(itr++);
}
}
rep(i, q) cout << ans[i] << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb emplace_back
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
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;
}
using namespace std;
using P = pair<int, int>;
void solve() {
int n, q;
cin >> n >> q;
int a, b, c;
vector<pair<int, P>> v;
set<pair<int, int>> st;
rep(i, n) {
cin >> a >> b >> c;
v.eb(c, P{a - c, b - c});
}
sort(v.begin(), v.end());
rep(i, q) {
int d;
cin >> d;
st.emplace(d, i);
}
vector<int> ans(q, -1);
rep(i, n) {
auto itr = st.lower_bound(make_pair(v[i].second.first, -1));
while (itr != st.end()) {
if (v[i].second.second > itr->first)
ans[itr->second] = v[i].first;
else
break;
st.erase(itr++);
}
}
rep(i, q) cout << ans[i] << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| [
"control_flow.loop.condition.change",
"call.function.change"
] | 852,791 | 852,792 | u698883164 | cpp |
p03033 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#define F first
#define S second
using namespace std;
typedef long long ll;
const ll M = 4e18;
struct st {
ll s, e, i;
};
bool operator<(st p, st q) { return p.i > q.i; }
bool cmp(st p, st q) { return p.s < q.s; }
ll n, Q;
st a[200005];
priority_queue<st> pq;
int main() {
scanf("%lld%lld", &n, &Q);
for (ll i = 0; i < n; i++) {
scanf("%lld%lld%lld", &a[i].s, &a[i].e, &a[i].i);
a[i].s -= a[i].i;
a[i].e -= a[i].i;
}
sort(a, a + n, cmp);
ll j = 0;
pq.push({0, M, M});
for (ll i = 0; i < Q; i++) {
ll t;
scanf("%lld", &t);
for (; a[j].s <= t; j++) {
pq.push(a[j]);
}
while (pq.top().e <= t)
pq.pop();
if (pq.top().i != M)
printf("%lld\n", pq.top().i);
else
printf("-1\n");
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#define F first
#define S second
using namespace std;
typedef long long ll;
const ll M = 4e18;
struct st {
ll s, e, i;
};
bool operator<(st p, st q) { return p.i > q.i; }
bool cmp(st p, st q) { return p.s < q.s; }
ll n, Q;
st a[200005];
priority_queue<st> pq;
int main() {
scanf("%lld%lld", &n, &Q);
for (ll i = 0; i < n; i++) {
scanf("%lld%lld%lld", &a[i].s, &a[i].e, &a[i].i);
a[i].s -= a[i].i;
a[i].e -= a[i].i;
}
sort(a, a + n, cmp);
ll j = 0;
pq.push({0, M, M});
for (ll i = 0; i < Q; i++) {
ll t;
scanf("%lld", &t);
for (; j < n && a[j].s <= t; j++) {
pq.push(a[j]);
}
while (pq.top().e <= t)
pq.pop();
if (pq.top().i != M)
printf("%lld\n", pq.top().i);
else
printf("-1\n");
}
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 852,799 | 852,800 | u307227472 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<P> al;
for (int i = 0; i < n; i++) {
ll a;
cin >> a;
al.push_back(P(a, 1));
}
for (int i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
al.push_back(P(c, b));
}
sort(al.begin(), al.end());
reverse(al.begin(), al.end());
ll curr_cnt = 0;
ll ans = 0;
for (auto num_cnt : al) {
int num = num_cnt.first;
int cnt = num_cnt.second;
if (cnt + curr_cnt <= n) {
ans += num * cnt;
curr_cnt += cnt;
} else {
int rem = n - curr_cnt;
ans += rem * num;
break;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<P> al;
for (int i = 0; i < n; i++) {
ll a;
cin >> a;
al.push_back(P(a, 1));
}
for (int i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
al.push_back(P(c, b));
}
sort(al.begin(), al.end());
reverse(al.begin(), al.end());
ll curr_cnt = 0;
ll ans = 0;
for (auto num_cnt : al) {
ll num = num_cnt.first;
ll cnt = num_cnt.second;
if (cnt + curr_cnt <= n) {
ans += num * cnt;
curr_cnt += cnt;
} else {
ll rem = n - curr_cnt;
ans += rem * num;
break;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 852,821 | 852,822 | u493520238 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
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;
}
using namespace std;
#define int long long
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define P pair<ll, ll>
#define sz(x) (ll) x.size()
#define ALL(x) (x).begin(), (x).end()
#define ALLR(x) (x).rbegin(), (x).rend()
#define VE vector<ll>
#define COUT(x) cout << (x) << endl
#define MA map<ll, ll>
#define SE set<ll>
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, VE, greater<ll>>
#define COUT(x) cout << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define EPS (1e-10)
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
bool prime(ll n) {
for (ll i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
map<ll, ll> prime_factor(ll n) {
map<ll, ll> ret;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
// const long long MOD = 1000000007;
const long long MOD = 998244353;
const long long INF = 1LL << 60;
const long double PI = 3.14159265359;
const int MAX_N = 100010;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
VE a(n);
rep(i, n) cin >> a[i];
vector<P> tmp(m);
rep(i, m) {
int b, c;
cin >> b >> c;
tmp[i] = make_pair(c, b);
}
sort(ALL(tmp));
sort(ALL(a));
vector<int> ans;
int now = 0;
rep(i, n) {
if (tmp[now].second == 0)
now++;
if (now >= m)
break;
ans.push_back(tmp[now].first);
tmp[now].second--;
}
sort(ALLR(ans));
rep(i, n) {
if (i >= ans.size())
break;
if (ans[i] > a[i]) {
a[i] = ans[i];
} else
break;
}
int sum = 0;
rep(i, n) sum += a[i];
cout << sum << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
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;
}
using namespace std;
#define int long long
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define P pair<ll, ll>
#define sz(x) (ll) x.size()
#define ALL(x) (x).begin(), (x).end()
#define ALLR(x) (x).rbegin(), (x).rend()
#define VE vector<ll>
#define COUT(x) cout << (x) << endl
#define MA map<ll, ll>
#define SE set<ll>
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, VE, greater<ll>>
#define COUT(x) cout << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define EPS (1e-10)
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
bool prime(ll n) {
for (ll i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
map<ll, ll> prime_factor(ll n) {
map<ll, ll> ret;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
// const long long MOD = 1000000007;
const long long MOD = 998244353;
const long long INF = 1LL << 60;
const long double PI = 3.14159265359;
const int MAX_N = 100010;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
VE a(n);
rep(i, n) cin >> a[i];
vector<P> tmp(m);
rep(i, m) {
int b, c;
cin >> b >> c;
tmp[i] = make_pair(c, b);
}
sort(ALLR(tmp));
sort(ALL(a));
vector<int> ans;
int now = 0;
rep(i, n) {
if (tmp[now].second == 0)
now++;
if (now >= m)
break;
ans.push_back(tmp[now].first);
tmp[now].second--;
}
sort(ALLR(ans));
rep(i, n) {
if (i >= ans.size())
break;
if (ans[i] > a[i]) {
a[i] = ans[i];
} else
break;
}
int sum = 0;
rep(i, n) sum += a[i];
cout << sum << endl;
return 0;
} | [
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 852,825 | 852,826 | u809967037 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < n; i++)
bool compair(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first > b.first;
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
vector<pair<ll, ll>> b(m);
rep(i, n) cin >> b[i].first >> b[i].second;
sort(b.begin(), b.end(), compair);
vector<ll> c(n);
int j = 0;
rep(i, n) {
if (b[j].first > 0) {
c[i] = b[j].second;
b[j].first--;
} else {
if (j == m - 1)
c[i] = 0;
else {
j++;
c[i] = b[j].second;
b[j].first--;
}
}
}
ll ans = 0;
rep(i, n) ans += max(a[i], c[i]);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < n; i++)
bool compair(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first > b.first;
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
vector<pair<ll, ll>> b(m);
rep(i, m) cin >> b[i].first >> b[i].second;
sort(b.begin(), b.end(), compair);
vector<ll> c(n);
int j = 0;
rep(i, n) {
if (b[j].first > 0) {
c[i] = b[j].second;
b[j].first--;
} else {
if (j == m - 1)
c[i] = 0;
else {
j++;
c[i] = b[j].second;
b[j].first--;
}
}
}
ll ans = 0;
rep(i, n) ans += max(a[i], c[i]);
cout << ans << endl;
} | [
"identifier.change",
"call.arguments.change"
] | 852,827 | 852,828 | u105533331 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
// TYPEDEF
// ----------------------------------------
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> Pair;
typedef vector<ll> vll;
typedef vector<vector<ll>> Graph;
typedef vector<string> vs;
typedef vector<pair<ll, ll>> Pll;
typedef queue<ll> qll;
// REPEAT
// ----------------------------------------
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define REPA(i, a) \
for (ll i = 0; i < (ll)(a.size()); i++) \
;
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define COUT(a) cout << (a) << endl;
#define ENDL(a) cout << endl;
#define COUTA(i, a) \
for (ll i = 0; i < (ll)(a.size()); i++) { \
cout << (a)[i] << " "; \
} \
cout << endl;
// UTIL
// ----------------------------------------
#define pb push_back
#define paired make_pair
#define ALL(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) sort((a).rbegin(), (a).rend())
// DEBUG
// ----------------------------------------
#ifdef _DEBUG
#define debug(x) cout << "[debug] " << #x << ": " << x << endl
#else
#define debug(x)
#endif
template <typename T> void debugV(const vector<T> v) {
#ifdef _DEBUG
rep(i, v.size()) { cout << i << ":" << v[i] << " "; }
cout << endl;
#else
(void)v;
#endif
}
// BIT FLAG
// ----------------------------------------
const unsigned int BIT_FLAG_0 = (1 << 0); // 0000 0000 0000 0001
const unsigned int BIT_FLAG_1 = (1 << 1); // 0000 0000 0000 0010
const unsigned int BIT_FLAG_2 = (1 << 2); // 0000 0000 0000 0100
const unsigned int BIT_FLAG_3 = (1 << 3); // 0000 0000 0000 1000
const unsigned int BIT_FLAG_4 = (1 << 4); // 0000 0000 0001 0000
const unsigned int BIT_FLAG_5 = (1 << 5); // 0000 0000 0010 0000
const unsigned int BIT_FLAG_6 = (1 << 6); // 0000 0000 0100 0000
const unsigned int BIT_FLAG_7 = (1 << 7); // 0000 0000 1000 0000
const unsigned int BIT_FLAG_8 = (1 << 8); // 0000 0001 0000 0000
const unsigned int BIT_FLAG_9 = (1 << 9); // 0000 0010 0000 0000
const unsigned int BIT_FLAG_10 = (1 << 10); // 0000 0100 0000 0000
const unsigned int BIT_FLAG_11 = (1 << 11); // 0000 1000 0000 0000
// CONST
// ----------------------------------------
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr double PI = 3.14159265358979323846; // or M_PI
constexpr int MOD = 1000000007;
void Main() {
ll n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> a;
vector<Pair> cb;
ll total = 0;
REP(i, n) {
ll a_in;
cin >> a_in;
a.push(a_in);
total += a_in;
}
REP(i, m) {
ll b_in, c_in;
cin >> b_in >> c_in;
cb.emplace_back(c_in, b_in);
}
sort(cb.begin(), cb.end(), greater<Pair>());
// REP(i, m) {
// std::cout << cb[i].first << " " << cb[i].second << endl;
// }
ll index = 0;
ll count = 1;
REP(i, n) {
ll target = a.top();
if (target < cb[index].first) {
a.pop();
a.push(cb[index].first);
total = total - target + cb[index].first;
if (count == cb[index].second) {
index++;
count = 1;
}
count++;
} else {
break;
}
}
COUT(total);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
/*
4 3
1 2
2 3
2 4
2 10
1 100
3 1
*/
| #include <bits/stdc++.h>
using namespace std;
// TYPEDEF
// ----------------------------------------
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> Pair;
typedef vector<ll> vll;
typedef vector<vector<ll>> Graph;
typedef vector<string> vs;
typedef vector<pair<ll, ll>> Pll;
typedef queue<ll> qll;
// REPEAT
// ----------------------------------------
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define REPA(i, a) \
for (ll i = 0; i < (ll)(a.size()); i++) \
;
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define COUT(a) cout << (a) << endl;
#define ENDL(a) cout << endl;
#define COUTA(i, a) \
for (ll i = 0; i < (ll)(a.size()); i++) { \
cout << (a)[i] << " "; \
} \
cout << endl;
// UTIL
// ----------------------------------------
#define pb push_back
#define paired make_pair
#define ALL(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) sort((a).rbegin(), (a).rend())
// DEBUG
// ----------------------------------------
#ifdef _DEBUG
#define debug(x) cout << "[debug] " << #x << ": " << x << endl
#else
#define debug(x)
#endif
template <typename T> void debugV(const vector<T> v) {
#ifdef _DEBUG
rep(i, v.size()) { cout << i << ":" << v[i] << " "; }
cout << endl;
#else
(void)v;
#endif
}
// BIT FLAG
// ----------------------------------------
const unsigned int BIT_FLAG_0 = (1 << 0); // 0000 0000 0000 0001
const unsigned int BIT_FLAG_1 = (1 << 1); // 0000 0000 0000 0010
const unsigned int BIT_FLAG_2 = (1 << 2); // 0000 0000 0000 0100
const unsigned int BIT_FLAG_3 = (1 << 3); // 0000 0000 0000 1000
const unsigned int BIT_FLAG_4 = (1 << 4); // 0000 0000 0001 0000
const unsigned int BIT_FLAG_5 = (1 << 5); // 0000 0000 0010 0000
const unsigned int BIT_FLAG_6 = (1 << 6); // 0000 0000 0100 0000
const unsigned int BIT_FLAG_7 = (1 << 7); // 0000 0000 1000 0000
const unsigned int BIT_FLAG_8 = (1 << 8); // 0000 0001 0000 0000
const unsigned int BIT_FLAG_9 = (1 << 9); // 0000 0010 0000 0000
const unsigned int BIT_FLAG_10 = (1 << 10); // 0000 0100 0000 0000
const unsigned int BIT_FLAG_11 = (1 << 11); // 0000 1000 0000 0000
// CONST
// ----------------------------------------
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr double PI = 3.14159265358979323846; // or M_PI
constexpr int MOD = 1000000007;
void Main() {
ll n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> a;
vector<Pair> cb;
ll total = 0;
REP(i, n) {
ll a_in;
cin >> a_in;
a.push(a_in);
total += a_in;
}
REP(i, m) {
ll b_in, c_in;
cin >> b_in >> c_in;
cb.emplace_back(c_in, b_in);
}
sort(cb.begin(), cb.end(), greater<Pair>());
// REP(i, m) {
// std::cout << cb[i].first << " " << cb[i].second << endl;
// }
ll index = 0;
ll count = 1;
REP(i, n) {
ll target = a.top();
// cout << index << " " << target << " " << cb[index].first << endl;
if (target < cb[index].first) {
a.pop();
a.push(cb[index].first);
total = total - target + cb[index].first;
if (count == cb[index].second) {
// cout << "count " << count << " " << cb[index].second << endl;
index++;
count = 0;
}
// COUT(a.top());
count++;
} else {
// COUT(i);
break;
}
}
COUT(total);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
/*
4 3
1 2
2 3
2 4
2 10
1 100
3 1
*/
| [
"literal.number.change",
"assignment.value.change"
] | 852,829 | 852,830 | u644224332 | cpp |
p03038 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define arr array
using namespace std;
const int e = 2e6 + 69;
const ll mod = 1e9 + 7;
ll a[e];
arr<int, 2> b[e];
// beginner 1999 127
int main() {
int n, m;
cin >> n >> m;
multiset<arr<int, 2>, greater<arr<int, 2>>> cur;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cur.insert({a[i], 1});
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
cur.insert({y, x});
}
int dem = n;
ll ans = 0;
/*for(auto j : cur){
cout << j[1] <<" "<<j[0] <<"\n";
}*/
for (auto j : cur) {
ans += min(dem, j[1]) * j[0];
dem -= min(dem, j[1]);
if (dem == 0) {
cout << ans;
return 0;
}
}
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define arr array
using namespace std;
const int e = 2e6 + 69;
const ll mod = 1e9 + 7;
ll a[e];
arr<int, 2> b[e];
// beginner 1999 127
int main() {
int n, m;
cin >> n >> m;
multiset<arr<int, 2>, greater<arr<int, 2>>> cur;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cur.insert({a[i], 1});
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
cur.insert({y, x});
}
int dem = n;
ll ans = 0;
/*for(auto j : cur){
cout << j[0] <<" "<<j[1] <<"\n";
}*/
for (auto j : cur) {
ans += 1LL * min(dem, j[1]) * j[0];
dem -= min(dem, j[1]);
if (dem == 0) {
cout << ans;
return 0;
}
}
}
| [
"assignment.change"
] | 852,835 | 852,836 | u424316992 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using pint = pair<int, int>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
int main() {
int n, m;
cin >> n >> m;
priority_queue<pint> q;
rep(i, n) {
int a;
cin >> a;
q.push(make_pair(a, 1));
}
rep(i, m) {
int b, c;
cin >> b >> c;
q.push(make_pair(c, b));
}
int ans = 0;
rep(i, n) {
auto p = q.top();
ans += p.first;
q.pop();
if (p.second > 1) {
p.second--;
q.push(p);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using pint = pair<int, int>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
int main() {
int n, m;
cin >> n >> m;
priority_queue<pint> q;
rep(i, n) {
int a;
cin >> a;
q.push(make_pair(a, 1));
}
rep(i, m) {
int b, c;
cin >> b >> c;
q.push(make_pair(c, b));
}
ll ans = 0;
rep(i, n) {
auto p = q.top();
ans += p.first;
q.pop();
if (p.second > 1) {
p.second--;
q.push(p);
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 852,859 | 852,860 | u825601908 | cpp |
p03038 | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
vector<vector<ll>> bc(m, vector<ll>(2));
rep(i, n) { cin >> a[i]; }
rep(i, m) { cin >> bc[i][1] >> bc[i][0]; }
sort(bc.begin(), bc.end());
sort(a.begin(), a.end());
int k = 0;
rep(i, m) {
if (a[k] >= bc[m - i - 1][0]) {
break;
}
rep(j, bc[m - i - 1][1]) {
if (a[k] >= bc[m - i - 1][0]) {
break;
}
a[k] = bc[m - i - 1][0];
++k;
if (k == n - 1) {
break;
}
}
}
ll ans = 0;
rep(i, n) {
ans += a[i];
// cout << a[i] << endl;
}
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
vector<vector<ll>> bc(m, vector<ll>(2));
rep(i, n) { cin >> a[i]; }
rep(i, m) { cin >> bc[i][1] >> bc[i][0]; }
sort(bc.begin(), bc.end());
sort(a.begin(), a.end());
int k = 0;
rep(i, m) {
if (a[k] >= bc[m - i - 1][0]) {
break;
}
rep(j, bc[m - i - 1][1]) {
if (a[k] >= bc[m - i - 1][0]) {
break;
}
a[k] = bc[m - i - 1][0];
++k;
if (k == n) {
break;
}
}
}
ll ans = 0;
rep(i, n) {
ans += a[i];
// cout << a[i] << endl;
}
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 852,863 | 852,864 | u992471673 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
using graph = vector<vector<int>>;
using pii = pair<int, int>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define all(x) (x).begin(), (x).end()
#define size(x) ((ll)(x).size())
#define MAX(x) *max_element(all(x))
#define MIN(x) *min_element(all(x))
#define INF 1000000000000
#define M 10000007
#define MAXR 100000
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define FIND(x, y) find(all(x), y) != x.end()
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 (b < a) {
a = b;
return true;
}
return false;
}
struct uf {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
vector<int> rcount;
uf(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
const int MOD = 1000000007;
using mint = Fp<MOD>;
int main() {
int n, m;
cin >> n >> m;
vector<pii> b(m);
priority_queue<int, vector<int>, greater<int>> a;
rep(i, n) {
int l;
cin >> l;
a.push(l);
}
rep(i, m) cin >> b[i].s >> b[i].f;
sort(b.rbegin(), b.rend());
rep(i, n) {
while (b[i].s != 0) {
if (a.top() < b[i].f) {
a.push(b[i].f);
a.pop();
b[i].s--;
} else
goto label;
}
}
label:
ll ans = 0;
while (size(a) != 0) {
ans += a.top();
a.pop();
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
using graph = vector<vector<int>>;
using pii = pair<int, int>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define all(x) (x).begin(), (x).end()
#define size(x) ((ll)(x).size())
#define MAX(x) *max_element(all(x))
#define MIN(x) *min_element(all(x))
#define INF 1000000000000
#define M 10000007
#define MAXR 100000
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define FIND(x, y) find(all(x), y) != x.end()
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 (b < a) {
a = b;
return true;
}
return false;
}
struct uf {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
vector<int> rcount;
uf(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
const int MOD = 1000000007;
using mint = Fp<MOD>;
int main() {
int n, m;
cin >> n >> m;
vector<pii> b(m);
priority_queue<int, vector<int>, greater<int>> a;
rep(i, n) {
int l;
cin >> l;
a.push(l);
}
rep(i, m) cin >> b[i].s >> b[i].f;
sort(b.rbegin(), b.rend());
rep(i, m) {
while (b[i].s != 0) {
if (a.top() < b[i].f) {
a.push(b[i].f);
a.pop();
b[i].s--;
} else
goto label;
}
}
label:
ll ans = 0;
while (size(a) != 0) {
ans += a.top();
a.pop();
}
cout << ans << endl;
}
| [] | 852,868 | 852,869 | u425848474 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long> v;
vector<pair<long long, int>> cards;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (int i = 0; i < m; i++) {
int x;
long long y;
cin >> x >> y;
cards.push_back({y, x});
}
sort(cards.rbegin(), cards.rend());
int p = 0;
for (int i = 0; i < m; i++) {
int indx = upper_bound(v.begin(), v.end(), cards[i].first) - v.begin();
if (indx <= p) {
break;
} else {
for (int q = p; q < min(indx, p + cards[i].second); q++) {
v[q] = cards[i].first;
}
p = min(indx, p + cards[i].second);
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = ans + v[i];
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long> v;
vector<pair<long long, int>> cards;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (int i = 0; i < m; i++) {
int x;
long long y;
cin >> x >> y;
cards.push_back({y, x});
}
sort(cards.rbegin(), cards.rend());
int p = 0;
for (int i = 0; i < m; i++) {
int indx = upper_bound(v.begin() + p, v.end(), cards[i].first) - v.begin();
if (indx <= p) {
break;
} else {
for (int q = p; q < min(indx, p + cards[i].second); q++) {
v[q] = cards[i].first;
}
p = min(indx, p + cards[i].second);
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = ans + v[i];
}
cout << ans;
return 0;
} | [
"assignment.change"
] | 852,870 | 852,871 | u041775325 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
//マクロ
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x))
#define INF 1000000000000 // 10^12
#define MOD 10000007 // 10^9+7
#define PB push_back
#define MP make_pair
#define F first
#define S second
int main(int argc, char const *argv[]) {
int n, m;
cin >> n >> m;
priority_queue<pair<ll, ll>> que;
REP(i, n) {
ll a;
cin >> a;
que.push(make_pair(a, 1));
}
REP(i, m) {
ll b, c;
cin >> b >> c;
que.push(make_pair(c, b));
}
ll ans = 0;
REP(i, n) {
auto p = que.top();
if (p.S != 1)
que.push(make_pair(p.F, p.S - 1));
ans += p.F;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
//マクロ
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x))
#define INF 1000000000000 // 10^12
#define MOD 10000007 // 10^9+7
#define PB push_back
#define MP make_pair
#define F first
#define S second
int main(int argc, char const *argv[]) {
int n, m;
cin >> n >> m;
priority_queue<pair<ll, ll>> que;
REP(i, n) {
ll a;
cin >> a;
que.push(make_pair(a, 1));
}
REP(i, m) {
ll b, c;
cin >> b >> c;
que.push(make_pair(c, b));
}
ll ans = 0;
REP(i, n) {
auto p = que.top();
que.pop();
if (p.S != 1)
que.push(make_pair(p.F, p.S - 1));
ans += p.F;
}
cout << ans << endl;
return 0;
}
| [
"call.add"
] | 852,872 | 852,873 | u053035261 | cpp |
p03038 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define LL long long
typedef pair<LL, LL> P;
bool pairCompare(const P &firstElof, const P &secondElof) {
return firstElof.second > secondElof.second;
}
int main(void) {
IOS int n, m;
cin >> n >> m;
vector<LL> a(n);
vector<P> bc(m);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> bc[i].first >> bc[i].second;
}
sort(a.begin(), a.end());
sort(bc.begin(), bc.end(), pairCompare);
int cnt = 0;
for (int i = 0; i < m; i++) {
if (a[cnt] < bc[i].second)
break;
for (int j = 0; j < bc[i].first; j++) {
if (a[cnt] < bc[i].second) {
a[cnt] = bc[i].second;
cnt++;
if (cnt == n)
break;
} else
continue;
}
if (cnt == n)
break;
}
/*
for(int i = 0; i < n; i++) {
cerr << a[i] << endl;
}
*/
LL ans = accumulate(a.begin(), a.end(), 0LL);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define LL long long
typedef pair<LL, LL> P;
bool pairCompare(const P &firstElof, const P &secondElof) {
return firstElof.second > secondElof.second;
}
int main(void) {
IOS int n, m;
cin >> n >> m;
vector<LL> a(n);
vector<P> bc(m);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> bc[i].first >> bc[i].second;
}
sort(a.begin(), a.end());
sort(bc.begin(), bc.end(), pairCompare);
int cnt = 0;
for (int i = 0; i < m; i++) {
if (a[cnt] >= bc[i].second)
break;
for (int j = 0; j < bc[i].first; j++) {
if (a[cnt] < bc[i].second) {
a[cnt] = bc[i].second;
cnt++;
if (cnt == n)
break;
} else
continue;
}
if (cnt == n)
break;
}
/*
for(int i = 0; i < n; i++) {
cerr << a[i] << endl;
}
*/
LL ans = accumulate(a.begin(), a.end(), 0LL);
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 852,908 | 852,909 | u330661451 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
//#define int long long
// signed main(){
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a;
for (int i = 0; i < n; i++) {
int ta;
cin >> ta;
a.emplace_back(ta);
}
sort(a.begin(), a.end());
vector<pair<int, int>> cb(m);
for (int i = 0; i < m; i++) {
cin >> cb[i].second >> cb[i].first;
}
sort(cb.begin(), cb.end());
int idx = 0;
bool cont = false;
for (int i = 0; i < m; i++) {
for (int j = 0; j < cb[i].second; j++) {
a.emplace_back(cb[i].first);
idx++;
if (idx > n) {
cont = true;
break;
}
}
if (cont)
break;
}
sort(a.rbegin(), a.rend());
ll count = 0;
for (int i = 0; i < n; i++) {
count += a[i];
}
cout << count << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
//#define int long long
// signed main(){
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a;
for (int i = 0; i < n; i++) {
int ta;
cin >> ta;
a.emplace_back(ta);
}
sort(a.begin(), a.end());
vector<pair<int, int>> cb(m);
for (int i = 0; i < m; i++) {
cin >> cb[i].second >> cb[i].first;
}
sort(cb.rbegin(), cb.rend());
int idx = 0;
bool cont = false;
for (int i = 0; i < m; i++) {
for (int j = 0; j < cb[i].second; j++) {
a.emplace_back(cb[i].first);
idx++;
if (idx > n) {
cont = true;
break;
}
}
if (cont)
break;
}
sort(a.rbegin(), a.rend());
ll count = 0;
for (int i = 0; i < n; i++) {
count += a[i];
}
cout << count << "\n";
return 0;
} | [
"call.function.change",
"call.arguments.change"
] | 852,910 | 852,911 | u568501780 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
scanf("%d %d", &N, &M);
vector<pair<int, int>> cards;
for (int i = 0; i < N; i++) {
int a;
scanf("%d", &a);
cards.push_back(pair<int, int>(a, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
scanf("%d %d", &b, &c);
cards.push_back(pair<int, int>(c, b));
}
sort(cards.rbegin(), cards.rend());
int cnt = N, index = 0;
long max_value = 0;
while (cnt > 0) {
pair<int, int> p = cards[index];
if (cnt >= p.second) {
max_value += (long)p.first * p.second;
} else {
max_value += p.first * cnt;
}
cnt -= p.second;
index++;
}
printf("%ld", max_value);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
scanf("%d %d", &N, &M);
vector<pair<int, int>> cards;
for (int i = 0; i < N; i++) {
int a;
scanf("%d", &a);
cards.push_back(pair<int, int>(a, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
scanf("%d %d", &b, &c);
cards.push_back(pair<int, int>(c, b));
}
sort(cards.rbegin(), cards.rend());
int cnt = N, index = 0;
long max_value = 0;
while (cnt > 0) {
pair<int, int> p = cards[index];
if (cnt >= p.second) {
max_value += (long)p.first * p.second;
} else {
max_value += (long)p.first * cnt;
}
cnt -= p.second;
index++;
}
printf("%ld", max_value);
return 0;
} | [
"type_conversion.add"
] | 852,912 | 852,913 | u316549668 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
scanf("%d %d", &N, &M);
vector<pair<int, int>> cards;
for (int i = 0; i < N; i++) {
int a;
scanf("%d", &a);
cards.push_back(pair<int, int>(a, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
scanf("%d %d", &b, &c);
cards.push_back(pair<int, int>(c, b));
}
sort(cards.rbegin(), cards.rend());
int cnt = N, index = 0;
long max_value = 0;
while (cnt <= 0) {
pair<int, int> p = cards[index];
if (cnt >= p.second) {
max_value += (long)p.first * p.second;
} else {
max_value += p.first * cnt;
}
cnt -= p.second;
index++;
}
printf("%ld", max_value);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
scanf("%d %d", &N, &M);
vector<pair<int, int>> cards;
for (int i = 0; i < N; i++) {
int a;
scanf("%d", &a);
cards.push_back(pair<int, int>(a, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
scanf("%d %d", &b, &c);
cards.push_back(pair<int, int>(c, b));
}
sort(cards.rbegin(), cards.rend());
int cnt = N, index = 0;
long max_value = 0;
while (cnt > 0) {
pair<int, int> p = cards[index];
if (cnt >= p.second) {
max_value += (long)p.first * p.second;
} else {
max_value += (long)p.first * cnt;
}
cnt -= p.second;
index++;
}
printf("%ld", max_value);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 852,914 | 852,913 | u316549668 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using P = pair<int, int>;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
ll ans = 0;
vector<P> d;
rep(i, m) {
int b, c;
cin >> b >> c;
d.push_back(make_pair(c, b));
}
sort(d.rbegin(), d.rend());
int j = 0;
rep(i, n) {
if (d[j].second <= 0)
j++;
if (j >= n)
break;
if (a[i] < d[j].first) {
a[i] = d[j].first;
d[j].second--;
}
// cout << a[i] << "\n";
}
rep(i, n) { ans += a[i]; }
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using P = pair<int, int>;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
ll ans = 0;
vector<P> d;
rep(i, m) {
int b, c;
cin >> b >> c;
d.push_back(make_pair(c, b));
}
sort(d.rbegin(), d.rend());
int j = 0;
rep(i, n) {
if (d[j].second <= 0)
j++;
if (j >= m)
break;
if (a[i] < d[j].first) {
a[i] = d[j].first;
d[j].second--;
}
// cout << a[i] << "\n";
}
rep(i, n) { ans += a[i]; }
cout << ans << "\n";
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 852,929 | 852,930 | u358859892 | cpp |
p03038 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << endl
int main() {
int n, m, t;
cin >> n >> m;
map<int, ll, greater<int>> map1;
REP(i, n) {
cin >> t;
map1[t]++;
}
int b, c;
REP(i, m) {
cin >> b >> c;
map1[c] += b;
}
ll ans = 0;
int count = n;
for (const auto &x : map1) {
int y = x.first;
ll z = x.second;
if (count >= z) {
ans += y * z;
count -= z;
} else {
ans += y * count;
break;
}
}
COUT(ans);
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << endl
int main() {
int n, m, t;
cin >> n >> m;
map<int, ll, greater<ll>> map1;
REP(i, n) {
cin >> t;
map1[t]++;
}
int b, c;
REP(i, m) {
cin >> b >> c;
map1[c] += b;
}
ll ans = 0;
int count = n;
for (const auto &x : map1) {
ll y = x.first;
ll z = x.second;
if (count >= z) {
ans += y * z;
count -= z;
} else {
ans += y * count;
break;
}
}
COUT(ans);
return 0;
} | [
"variable_declaration.type.change"
] | 852,941 | 852,942 | u459105164 | cpp |
p03038 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << endl
int main() {
int n, m, t;
cin >> n >> m;
map<int, ll, greater<int>> map1;
REP(i, n) {
cin >> t;
map1[t]++;
}
int b, c;
REP(i, m) {
cin >> b >> c;
map1[c] += b;
}
ll ans = 0;
int count = n;
for (const auto &x : map1) {
int y = x.first;
ll z = x.second;
if (count >= z) {
ans += y * z;
count -= z;
} else {
ans += y * count;
break;
}
}
COUT(ans);
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << endl
int main() {
int n, m, t;
cin >> n >> m;
map<ll, ll, greater<ll>> map1;
REP(i, n) {
cin >> t;
map1[t]++;
}
int b, c;
REP(i, m) {
cin >> b >> c;
map1[c] += b;
}
ll ans = 0;
ll count = n;
for (const auto &x : map1) {
ll y = x.first;
ll z = x.second;
if (count >= z) {
ans += y * z;
count -= z;
} else {
ans += y * count;
break;
}
}
COUT(ans);
return 0;
} | [
"variable_declaration.type.change"
] | 852,941 | 852,943 | u459105164 | cpp |
p03038 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << endl
int main() {
int n, m, t;
cin >> n >> m;
map<int, ll, greater<int>> map1;
REP(i, n) {
cin >> t;
map1[t]++;
}
int b, c;
REP(i, m) {
cin >> b >> c;
map1[c] += b;
}
ll ans = 0;
int count = n;
for (const auto &x : map1) {
int y = x.first;
ll z = x.second;
if (count >= z) {
ans += y * z;
count -= z;
} else {
ans += y * count;
break;
}
}
COUT(ans);
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define ALL(v) (v.begin(), v.end())
#define COUT(x) cout << (x) << endl
int main() {
ll n, m, t;
cin >> n >> m;
map<ll, ll, greater<ll>> map1;
REP(i, n) {
cin >> t;
map1[t]++;
}
ll b, c;
REP(i, m) {
cin >> b >> c;
map1[c] += b;
}
ll ans = 0;
ll count = n;
for (const auto &x : map1) {
ll y = x.first;
ll z = x.second;
if (count >= z) {
ans += y * z;
count -= z;
} else {
ans += y * count;
break;
}
}
COUT(ans);
return 0;
} | [
"variable_declaration.type.change"
] | 852,941 | 852,944 | u459105164 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
map<int, ll> mp;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
mp[c] += b;
}
ll ans = 0;
for (int i = 0; i < n; i++) {
auto it = mp.rbegin();
if (it->first > a[i]) {
a[i] = it->first;
it->second--;
if (it->second == 0)
mp.erase(it->first);
}
ans += a[i];
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
map<int, ll> mp;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
mp[c] += b;
}
ll ans = 0;
for (int i = 0; i < n; i++) {
auto it = mp.rbegin();
if (mp.size() && it->first > a[i]) {
a[i] = it->first;
it->second--;
if (it->second == 0)
mp.erase(it->first);
}
ans += a[i];
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 852,945 | 852,946 | u804999113 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef struct BC {
int B;
int C;
BC(int b_, int c_) {
B = b_;
C = c_;
}
bool operator<(const BC &other) const { return C < other.C; }
bool operator>(const BC &other) const { return C > other.C; }
} bc_t;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> A;
vector<bc_t> D;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
A.push_back(a);
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
D.push_back(BC(b, c));
}
sort(D.begin(), D.end(), greater<bc_t>());
sort(A.begin(), A.end());
bool fin = false;
int idx = 0;
for (int i = 0; i < M && !fin; i++) {
for (int j = idx; j < max(N, idx + D[i].B); j++) {
if (D[i].C <= A[j]) {
fin = true;
break;
} else {
A[j] = D[i].C;
}
}
idx += D[i].B;
if (idx >= N) {
break;
}
}
long long ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef struct BC {
int B;
int C;
BC(int b_, int c_) {
B = b_;
C = c_;
}
bool operator<(const BC &other) const { return C < other.C; }
bool operator>(const BC &other) const { return C > other.C; }
} bc_t;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> A;
vector<bc_t> D;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
A.push_back(a);
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
D.push_back(BC(b, c));
}
sort(D.begin(), D.end(), greater<bc_t>());
sort(A.begin(), A.end());
bool fin = false;
int idx = 0;
for (int i = 0; i < M && !fin; i++) {
for (int j = idx; j < min(N, idx + D[i].B); j++) {
if (D[i].C <= A[j]) {
fin = true;
break;
} else {
A[j] = D[i].C;
}
}
idx += D[i].B;
if (idx >= N) {
break;
}
}
long long ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 852,949 | 852,950 | u018916376 | cpp |
p03038 | #pragma region header
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
#pragma region header
using namespace std;
using lint = long long;
using ld = long double;
using ulint = unsigned long long;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
constexpr lint mod = 1000000007;
constexpr long double pi = 3.141592653589793238462643383279;
#pragma endregion
// ========================================================================
// define
#define INF (lint)10000000000000000;
#define mod (int)1000000007
#pragma endregion
int main() {
lint n, m;
cin >> n >> m;
vector<lint> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<lint, lint>> d(m);
for (int i = 0; i < m; i++)
cin >> d[i].second >> d[i].first;
sort(d.begin(), d.end());
lint cnt = 0;
for (auto s : d) {
for (int i = 0; i < s.second; i++) {
if (cnt > n)
goto Cyan;
a.emplace_back(s.first);
cnt++;
}
}
Cyan:;
sort(a.rbegin(), a.rend());
lint ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
} | #pragma region header
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
#pragma region header
using namespace std;
using lint = long long;
using ld = long double;
using ulint = unsigned long long;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
constexpr lint mod = 1000000007;
constexpr long double pi = 3.141592653589793238462643383279;
#pragma endregion
// ========================================================================
// define
#define INF (lint)10000000000000000;
#define mod (int)1000000007
#pragma endregion
int main() {
lint n, m;
cin >> n >> m;
vector<lint> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<lint, lint>> d(m);
for (int i = 0; i < m; i++)
cin >> d[i].second >> d[i].first;
sort(d.rbegin(), d.rend());
lint cnt = 0;
for (auto s : d) {
for (int i = 0; i < s.second; i++) {
if (cnt > n)
goto Cyan;
a.emplace_back(s.first);
cnt++;
}
}
Cyan:;
sort(a.rbegin(), a.rend());
lint ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
} | [
"call.function.change",
"call.arguments.change"
] | 852,956 | 852,957 | u926006934 | cpp |
p03038 | #pragma region header
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
#pragma region header
using namespace std;
using lint = long long;
using ld = long double;
using ulint = unsigned long long;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
constexpr lint mod = 1000000007;
constexpr long double pi = 3.141592653589793238462643383279;
#pragma endregion
// ========================================================================
// define
#define INF (lint)10000000000000000;
#define mod (int)1000000007
#pragma endregion
int main() {
lint n, m;
cin >> n >> m;
vector<lint> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<lint, lint>> d(m);
for (int i = 0; i < m; i++)
cin >> d[i].second >> d[i].first;
sort(d.begin(), d.end());
lint cnt = 0;
for (auto s : d) {
for (int i = 0; i < s.second; i++) {
if (cnt >= m)
goto Cyan;
a.emplace_back(s.first);
cnt++;
}
}
Cyan:;
sort(a.rbegin(), a.rend());
lint ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
} | #pragma region header
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
#pragma region header
using namespace std;
using lint = long long;
using ld = long double;
using ulint = unsigned long long;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
constexpr lint mod = 1000000007;
constexpr long double pi = 3.141592653589793238462643383279;
#pragma endregion
// ========================================================================
// define
#define INF (lint)10000000000000000;
#define mod (int)1000000007
#pragma endregion
int main() {
lint n, m;
cin >> n >> m;
vector<lint> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<lint, lint>> d(m);
for (int i = 0; i < m; i++)
cin >> d[i].second >> d[i].first;
sort(d.rbegin(), d.rend());
lint cnt = 0;
for (auto s : d) {
for (int i = 0; i < s.second; i++) {
if (cnt > n)
goto Cyan;
a.emplace_back(s.first);
cnt++;
}
}
Cyan:;
sort(a.rbegin(), a.rend());
lint ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
} | [
"call.function.change",
"call.arguments.change",
"control_flow.loop.for.condition.change"
] | 852,958 | 852,957 | u926006934 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define P pair<ll, ll>
typedef vector<int> vec;
typedef vector<vec> mat;
bool f(P x, P y) {
if (x.first != y.first)
return x.second > y.second;
else
return x.first <= y.first;
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
P b[m];
rep(i, m) cin >> b[i].first >> b[i].second;
sort(a, a + n);
sort(b, b + m, f);
ll ans = 0;
ll idx = 0;
rep(i, n) {
if (idx < m) {
if (a[i] < b[idx].second) {
ans += b[idx].second;
b[idx].first--;
} else {
ans += a[i];
idx = m;
}
} else {
ans += a[i];
}
if (b[idx].first == 0)
idx++;
}
// rep(i, m){
// cout << b[i].first << " " << b[i].second << endl;
// }
cout << ans << endl;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define P pair<ll, ll>
typedef vector<int> vec;
typedef vector<vec> mat;
bool f(P x, P y) {
if (x.second != y.second)
return x.second > y.second;
else
return x.first < y.first;
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
P b[m];
rep(i, m) cin >> b[i].first >> b[i].second;
sort(a, a + n);
sort(b, b + m, f);
ll ans = 0;
ll idx = 0;
rep(i, n) {
if (idx < m) {
if (a[i] < b[idx].second) {
ans += b[idx].second;
b[idx].first--;
} else {
ans += a[i];
idx = m;
}
} else {
ans += a[i];
}
if (b[idx].first == 0)
idx++;
}
// rep(i, m){
// cout << b[i].first << " " << b[i].second << endl;
// }
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 852,970 | 852,969 | u416773418 | cpp |
p03038 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define P pair<ll, ll>
typedef vector<int> vec;
typedef vector<vec> mat;
bool f(P x, P y) {
if (x.first != y.first)
return x.second > y.second;
else
return x.first >= y.first;
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
P b[m];
rep(i, m) cin >> b[i].first >> b[i].second;
sort(a, a + n);
sort(b, b + m, f);
ll ans = 0;
ll idx = 0;
rep(i, n) {
if (idx < m) {
if (a[i] < b[idx].second) {
ans += b[idx].second;
b[idx].first--;
} else {
ans += a[i];
idx = m;
}
} else {
ans += a[i];
}
if (b[idx].first == 0)
idx++;
}
// rep(i, m){
// cout << b[i].first << " " << b[i].second << endl;
// }
cout << ans << endl;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define P pair<ll, ll>
typedef vector<int> vec;
typedef vector<vec> mat;
bool f(P x, P y) {
if (x.second != y.second)
return x.second > y.second;
else
return x.first < y.first;
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
P b[m];
rep(i, m) cin >> b[i].first >> b[i].second;
sort(a, a + n);
sort(b, b + m, f);
ll ans = 0;
ll idx = 0;
rep(i, n) {
if (idx < m) {
if (a[i] < b[idx].second) {
ans += b[idx].second;
b[idx].first--;
} else {
ans += a[i];
idx = m;
}
} else {
ans += a[i];
}
if (b[idx].first == 0)
idx++;
}
// rep(i, m){
// cout << b[i].first << " " << b[i].second << endl;
// }
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 852,971 | 852,969 | u416773418 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a, i, j, v) \
for (ll k = i; k <= j; k++) { \
a[k] = v; \
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a;
vector<ll> b;
vector<ll> c;
ll tmp;
REP(i, n) {
cin >> tmp;
a.push_back(tmp);
}
REP(i, m) {
cin >> tmp;
b.push_back(tmp);
cin >> tmp;
c.push_back(tmp);
}
sort(ALL(a));
// 書き換えるべき場面
// 最小値がそのカードの値未満である限り
// 書き換える部分は同じ値になるので、書き換え枚数ぶんのc + それ以外のsum
map<ll, ll> mp;
REP(i, m) {
ll tmp_b = b[i];
ll tmp_c = c[i];
mp[tmp_c] = tmp_b;
}
map<ll, ll>::reverse_iterator rit = mp.rbegin();
vector<ll> r;
// 小さい順から、書き換えられる限り書き換える
REP(i, n) {
if ((rit != mp.rend()) && (a[i] < rit->first)) {
r.push_back(rit->first);
mp[rit->first]--;
if (mp[rit->first] == 0) {
rit++;
}
} else {
r.push_back(a[i]);
}
}
ll res = 0;
REP(i, n) { res += r[i]; }
cout << res << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a, i, j, v) \
for (ll k = i; k <= j; k++) { \
a[k] = v; \
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a;
vector<ll> b;
vector<ll> c;
ll tmp;
REP(i, n) {
cin >> tmp;
a.push_back(tmp);
}
REP(i, m) {
cin >> tmp;
b.push_back(tmp);
cin >> tmp;
c.push_back(tmp);
}
sort(ALL(a));
// 書き換えるべき場面
// 最小値がそのカードの値未満である限り
// 書き換える部分は同じ値になるので、書き換え枚数ぶんのc + それ以外のsum
map<ll, ll> mp;
REP(i, m) {
ll tmp_b = b[i];
ll tmp_c = c[i];
mp[tmp_c] += tmp_b;
}
map<ll, ll>::reverse_iterator rit = mp.rbegin();
vector<ll> r;
// 小さい順から、書き換えられる限り書き換える
REP(i, n) {
if ((rit != mp.rend()) && (a[i] < rit->first)) {
r.push_back(rit->first);
mp[rit->first]--;
if (mp[rit->first] == 0) {
rit++;
}
} else {
r.push_back(a[i]);
}
}
ll res = 0;
REP(i, n) { res += r[i]; }
cout << res << endl;
return 0;
} | [
"assignment.value.change"
] | 852,972 | 852,973 | u358055446 | cpp |
p03038 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
void solve() {
int n, m;
cin >> n >> m;
priority_queue<pair<int, int>> a;
rep(i, n) {
int x;
cin >> x;
a.push(make_pair(x, 1));
}
rep(i, m) {
int b, c;
cin >> b >> c;
a.push(make_pair(c, b));
}
ll ans = 0;
int count = 0;
int i = 0;
while (i < n) {
pair<int, int> p = a.top();
a.pop();
if (n - i < p.second) {
ans += p.first * (n - i);
break;
} else {
ans += p.first * p.second;
i += p.second;
}
}
cout << ans << endl;
}
int main() {
solve();
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
void solve() {
int n, m;
cin >> n >> m;
priority_queue<pair<int, int>> a;
rep(i, n) {
int x;
cin >> x;
a.push(make_pair(x, 1));
}
rep(i, m) {
int b, c;
cin >> b >> c;
a.push(make_pair(c, b));
}
ll ans = 0;
int count = 0;
int i = 0;
while (i < n) {
pair<int, int> p = a.top();
a.pop();
if (n - i < p.second) {
ans += (ll)p.first * (n - i);
break;
} else {
ans += (ll)p.first * p.second;
i += p.second;
}
}
cout << ans << endl;
}
int main() {
solve();
return 0;
} | [
"type_conversion.add"
] | 852,980 | 852,981 | u280175105 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> que;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
que.push(a);
}
vector<pair<int, int>> v;
for (int i = 0; i < N; i++) {
int B, C;
cin >> B >> C;
v.push_back({C, B});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < M; i++) {
int B = v[i].second;
int C = v[i].first;
while (B--) {
if (C > que.top()) {
que.pop();
que.push(C);
} else {
break;
}
}
}
ll ans = 0;
while (!que.empty())
ans += que.top(), que.pop();
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> que;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
que.push(a);
}
vector<pair<int, int>> v;
for (int i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
v.push_back({C, B});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < M; i++) {
int B = v[i].second;
int C = v[i].first;
while (B--) {
if (C > que.top()) {
que.pop();
que.push(C);
} else {
break;
}
}
}
ll ans = 0;
while (!que.empty())
ans += que.top(), que.pop();
cout << ans << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 852,988 | 852,989 | u580402951 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
map<ll, ll> mp;
for (int i = 0; i < N; i++) {
int A;
cin >> A;
mp[A]++;
}
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
mp[b] += a;
}
vector<pair<int, int>> p;
for (auto a : mp)
p.push_back(a);
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
ll ans = 0;
int cnt = 0;
int i = 0;
while (1) {
if (cnt + p[i].second <= N) {
ans += p[i].first * p[i].second;
cnt += p[i].second;
} else {
ans + p[i].first *(N - cnt);
break;
}
i++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
map<ll, ll> mp;
for (int i = 0; i < N; i++) {
int A;
cin >> A;
mp[A]++;
}
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
mp[b] += a;
}
vector<pair<ll, ll>> p;
for (auto a : mp)
p.push_back(a);
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
ll ans = 0;
int cnt = 0;
int i = 0;
while (1) {
if (cnt + p[i].second <= N) {
ans += p[i].first * p[i].second;
cnt += p[i].second;
} else {
ans += p[i].first * max(N - cnt, 0);
break;
}
i++;
}
cout << ans << endl;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change",
"call.add",
"call.arguments.add"
] | 852,990 | 852,991 | u580402951 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long sum = 0;
vector<int> a(n);
vector<pair<int, int>> b(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
for (int i = 0; i < m; i++) {
cin >> b.at(i).second >> b.at(i).first;
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
reverse(a.begin(), a.end());
int aind = 0, bind = 0, limit = n;
bool che = true;
while (limit > 0) {
limit--;
if (b.at(bind).first > a.at(aind) && bind < m && che == true) {
sum += b.at(bind).first;
b.at(bind).second--;
if (b.at(bind).second == 0 && bind < m) {
if (bind == m - 1) {
che = false;
} else {
bind++;
}
}
} else if (aind < n - 1) {
sum += a.at(aind);
aind++;
}
// cout << bind << endl;
/*for(int i=0;i<n;i++){
cout << "," <<a.at(i);
}
cout << endl;*/
}
/*for(int i=0;i<n;i++){
//cout << a.at(i) << endl;
sum += a.at(i);
}*/
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long sum = 0;
vector<int> a(n);
vector<pair<int, int>> b(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
for (int i = 0; i < m; i++) {
cin >> b.at(i).second >> b.at(i).first;
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
reverse(a.begin(), a.end());
int aind = 0, bind = 0, limit = n;
bool che = true;
while (limit > 0) {
limit--;
if (b.at(bind).first > a.at(aind) && bind < m && che == true) {
sum += b.at(bind).first;
b.at(bind).second--;
if (b.at(bind).second == 0 && bind < m) {
if (bind == m - 1) {
che = false;
} else {
bind++;
}
}
} else if (aind < n) {
sum += a.at(aind);
aind++;
}
// cout << bind << endl;
/*for(int i=0;i<n;i++){
cout << "," <<a.at(i);
}
cout << endl;*/
}
/*for(int i=0;i<n;i++){
//cout << a.at(i) << endl;
sum += a.at(i);
}*/
cout << sum << endl;
} | [
"expression.operation.binary.remove"
] | 853,003 | 853,004 | u770067864 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#include <cstdlib>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a.at(i);
vector<pair<ll, ll>> sousa;
rep(i, m) {
ll b, c;
cin >> b >> c;
sousa.push_back(make_pair(c, b));
}
sort(sousa.rbegin(), sousa.rend());
sort(a.begin(), a.end());
int count = 0;
int i = 0;
while (i < n) {
if (count >= m)
break;
ll b, c;
b = sousa.at(count).second;
c = sousa.at(count).first;
int change = 0;
while (a.at(i) < c && change < b) {
a.at(i) = c;
i++;
change++;
}
if (!change)
break;
count++;
}
ll ans = 0;
rep(i, n) ans += a.at(i);
cout << ans;
// rep(i,n) cout << a.at(i) << " ";
} | #include <bits/stdc++.h>
using namespace std;
#include <cstdlib>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a.at(i);
vector<pair<ll, ll>> sousa;
rep(i, m) {
ll b, c;
cin >> b >> c;
sousa.push_back(make_pair(c, b));
}
sort(sousa.rbegin(), sousa.rend());
sort(a.begin(), a.end());
int count = 0;
int i = 0;
while (i < n) {
if (count >= m)
break;
ll b, c;
b = sousa.at(count).second;
c = sousa.at(count).first;
int change = 0;
while (i < n && a.at(i) < c && change < b) {
a.at(i) = c;
i++;
change++;
}
if (!change)
break;
count++;
}
ll ans = 0;
rep(i, n) ans += a.at(i);
cout << ans;
// rep(i,n) cout << a.at(i) << " ";
} | [
"control_flow.loop.condition.change"
] | 853,019 | 853,020 | u748819456 | cpp |
p03038 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ull = long long unsigned;
using P = pair<int, int>;
const int INF = 1001001;
const int NMAX = 8;
int main() {
int n, m;
cin >> n >> m;
priority_queue<int, vector<int>, greater<int>> a;
rep(i, n) {
int temp;
cin >> temp;
a.push(temp);
}
vector<P> v(m);
rep(i, m) {
int b1, c1;
cin >> b1 >> c1;
v[i] = make_pair(c1, b1);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
rep(i, m) {
int c = v[i].first;
int b = v[i].second;
rep(j, b) {
int p = a.top();
// cout<<b<<'b'<<c<<'c'<<endl;
// cout<<*it1<<'i'<<endl;
if (p >= c)
break;
a.pop();
a.push(c);
}
}
int ans = 0;
while (!a.empty()) {
int now = a.top();
a.pop();
ans += now;
// cout<<now<<'a'<<endl;
}
cout << ans;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ull = long long unsigned;
using P = pair<int, int>;
const int INF = 1001001;
const int NMAX = 8;
int main() {
int n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> a;
rep(i, n) {
ll temp;
cin >> temp;
a.push(temp);
}
vector<P> v(m);
rep(i, m) {
int b1, c1;
cin >> b1 >> c1;
v[i] = make_pair(c1, b1);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
rep(i, m) {
int c = v[i].first;
int b = v[i].second;
rep(j, b) {
int p = a.top();
// cout<<b<<'b'<<c<<'c'<<endl;
// cout<<*it1<<'i'<<endl;
if (p >= c)
break;
a.pop();
a.push(c);
}
}
ll ans = 0;
while (!a.empty()) {
int now = a.top();
a.pop();
ans += now;
// cout<<now<<'a'<<endl;
}
cout << ans;
}
| [
"variable_declaration.type.change"
] | 853,025 | 853,026 | u289381123 | cpp |
p03038 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
priority_queue<P> q;
rep(i, n) {
cin >> a[i];
q.push(P(a[i], 1));
}
rep(i, m) {
int b, c;
cin >> b >> c;
q.push(P(c, b));
}
int ans = 0;
rep(i, n) {
P temp = q.top();
q.pop();
ans += temp.first;
if (temp.second == 1)
continue;
temp.second--;
q.push(temp);
}
cout << ans;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
priority_queue<P> q;
rep(i, n) {
cin >> a[i];
q.push(P(a[i], 1));
}
rep(i, m) {
int b, c;
cin >> b >> c;
q.push(P(c, b));
}
ll ans = 0;
rep(i, n) {
P temp = q.top();
q.pop();
ans += temp.first;
if (temp.second == 1)
continue;
temp.second--;
q.push(temp);
}
cout << ans;
}
| [
"variable_declaration.type.change"
] | 853,027 | 853,028 | u289381123 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
/*for(int i=0; i<n; i++){
cout << a.at(i) << endl;
}
cout << endl;*/
vector<tuple<int, int>> bc(m);
int b, c;
for (int i = 0; i < m; i++) {
cin >> b >> c;
bc.at(i) = make_tuple(c, b);
}
sort(bc.begin(), bc.end(), greater<>());
/*for(int i=0; i<m; i++){
cout << get<0>(bc.at(i)) << ' ' << get<1>(bc.at(i)) << endl;
}
cout << endl;*/
int i = 0, j = 0;
while (1) {
if (a.at(i) < get<0>(bc.at(j))) {
a.at(i) = get<0>(bc.at(j));
get<1>(bc.at(j))--;
if (get<1>(bc.at(j)) == 0)
j++;
}
i++;
if (i == n - 1)
break;
// cout << get<0>(bc.at(0)) << ' ' << get<1>(bc.at(0)) << endl;
// cout << a.at(i) << endl;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
ans += a.at(i);
// cout << ans << endl;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
/*for(int i=0; i<n; i++){
cout << a.at(i) << endl;
}
cout << endl;*/
vector<tuple<int, int>> bc(m);
int b, c;
for (int i = 0; i < m; i++) {
cin >> b >> c;
bc.at(i) = make_tuple(c, b);
}
sort(bc.begin(), bc.end(), greater<>());
/*for(int i=0; i<m; i++){
cout << get<0>(bc.at(i)) << ' ' << get<1>(bc.at(i)) << endl;
}
cout << endl;*/
int i = 0, j = 0;
while (1) {
if (a.at(i) < get<0>(bc.at(j))) {
a.at(i) = get<0>(bc.at(j));
get<1>(bc.at(j))--;
if (get<1>(bc.at(j)) == 0)
j++;
}
i++;
if (i == n || j == m)
break;
// cout << get<0>(bc.at(0)) << ' ' << get<1>(bc.at(0)) << endl;
// cout << a.at(i) << endl;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
ans += a.at(i);
// cout << ans << endl;
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 853,044 | 853,045 | u291332466 | cpp |
p03038 | #include <bits/stdc++.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
ll total = 0;
vector<ll> a(n);
vector<P> p(n);
rep(i, n) {
cin >> a[i];
total += a[i];
}
// cout << "total "<<total <<endl;
rep(i, m) {
ll b, c;
cin >> b >> c;
p[i] = make_pair(c, b);
}
sort(a.begin(), a.end());
// for(auto v:a) cout << v << endl;
sort(p.rbegin(), p.rend());
// for(auto v:p) cout << v.first << endl;
vector<ll> d;
for (auto v : p) {
rep(i, v.second) d.push_back(v.first);
if (d.size() > n)
break;
}
// for(auto v:d) cout <<v<< endl;
rep(i, n) {
// cout << a[i] << " " << d[i] << endl;
if (a[i] > d[i])
break;
total += (d[i] - a[i]);
a[i] = d[i];
}
cout << total << endl;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
ll total = 0;
vector<int> a(n);
vector<P> p(m);
rep(i, n) {
cin >> a[i];
total += a[i];
}
// cout << "total "<<total <<endl;
rep(i, m) {
int b, c;
cin >> b >> c;
p[i] = make_pair(c, b);
}
sort(a.begin(), a.end());
// for(auto v:a) cout << v << endl;
sort(p.rbegin(), p.rend());
// for(auto v:p) cout << v.first << endl;
vector<int> d;
for (auto v : p) {
rep(i, v.second) d.push_back(v.first);
if (d.size() > n)
break;
}
// for(auto v:d) cout <<v<< endl;
rep(i, n) {
// cout << a[i] << " " << d[i] << endl;
if (a[i] > d[i])
break;
total += (d[i] - a[i]);
a[i] = d[i];
}
cout << total << endl;
} | [
"variable_declaration.type.change"
] | 853,046 | 853,047 | u563170985 | cpp |
p03038 |
#include <bits/stdc++.h>
using namespace std;
#define ios \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ll long long
#define endl '\n'
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
ios;
int n, m;
cin >> n >> m;
int a[n];
priority_queue<pair<int, int>> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.push(mp(a[i], 1));
}
vector<int> b(m), c(m);
for (int i = 0; i < m; i++) {
cin >> b[i] >> c[i];
s.push(mp(c[i], b[i]));
}
int ans = 0;
for (int i = 0; i < n; i++) {
priority_queue<pair<int, int>>::value_type it;
it = s.top();
s.pop();
ans += it.first;
if (it.second > 1) {
it.second--;
s.push(it);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ios \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ll long long
#define endl '\n'
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
ios;
int n, m;
cin >> n >> m;
int a[n];
priority_queue<pair<int, int>> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.push(mp(a[i], 1));
}
vector<int> b(m), c(m);
for (int i = 0; i < m; i++) {
cin >> b[i] >> c[i];
s.push(mp(c[i], b[i]));
}
ll ans = 0;
for (int i = 0; i < n; i++) {
priority_queue<pair<int, int>>::value_type it;
it = s.top();
s.pop();
ans += it.first;
if (it.second > 1) {
it.second--;
s.push(it);
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.change"
] | 853,055 | 853,056 | u572033996 | cpp |
p03038 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
int n = 0;
for (auto e : vec)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::set<T> &st) {
int n = 0;
for (auto e : st)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::map<T, U> &mp) {
int n = 0;
for (auto e : mp)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
for (T &e : vec)
is >> e;
return is;
}
#ifdef LOCAL
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
std::cerr << head;
if (sizeof...(Tail) != 0)
std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;
int main() {
int N, M;
cin >> N >> M;
vector<int64> A(N);
cin >> A;
sort(A.begin(), A.end());
vector<pair<int64, int64>> p(M);
for (int i = 0; i < M; i++) {
cin >> p[i].first >> p[i].second;
}
sort(p.begin(), p.end(), [](const auto &x, const auto &y) {
if (x.second == y.second)
return x.first > y.first;
else
return x.second > y.second;
});
debug(p);
int idx = 0;
int64 ans = 0;
for (int i = 0; i < M; i++) {
int b = p[i].first;
while (b != 0 && A[idx] < p[i].second) {
idx++;
b--;
ans += p[i].second;
}
debug(ans);
}
for (int i = idx; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
int n = 0;
for (auto e : vec)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::set<T> &st) {
int n = 0;
for (auto e : st)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::map<T, U> &mp) {
int n = 0;
for (auto e : mp)
os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
for (T &e : vec)
is >> e;
return is;
}
#ifdef LOCAL
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
std::cerr << head;
if (sizeof...(Tail) != 0)
std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;
int main() {
int N, M;
cin >> N >> M;
vector<int64> A(N);
cin >> A;
sort(A.begin(), A.end());
vector<pair<int64, int64>> p(M);
for (int i = 0; i < M; i++) {
cin >> p[i].first >> p[i].second;
}
sort(p.begin(), p.end(), [](const auto &x, const auto &y) {
if (x.second == y.second)
return x.first > y.first;
else
return x.second > y.second;
});
debug(p);
int idx = 0;
int64 ans = 0;
for (int i = 0; i < M; i++) {
int b = p[i].first;
while (b != 0 && A[idx] < p[i].second && idx < N) {
idx++;
b--;
ans += p[i].second;
}
debug(ans);
}
for (int i = idx; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change"
] | 853,062 | 853,063 | u721166818 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), C(M);
vector<int> B(M);
rep(i, N) cin >> A[i];
rep(i, M) cin >> B[i] >> C[i];
priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>>
BC;
rep(i, M) BC.push(make_pair(C[i], B[i]));
int cnt = 0;
vector<ll> D;
while (!BC.empty() && cnt < N) {
auto p = BC.top();
for (int i = 0; i < p.second && cnt < N; i++) {
D.push_back(p.first);
cnt++;
}
BC.pop();
}
sort(A.begin(), A.end());
sort(D.begin(), D.end(), greater<ll>());
rep(i, D.size()) {
if (A[i] <= D[i])
A[i] = D[i];
else
break;
}
cout << accumulate(A.begin(), A.end(), 0LL) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), C(M);
vector<int> B(M);
rep(i, N) cin >> A[i];
rep(i, M) cin >> B[i] >> C[i];
priority_queue<pair<ll, int>, vector<pair<ll, int>>, less<pair<ll, int>>> BC;
rep(i, M) BC.push(make_pair(C[i], B[i]));
int cnt = 0;
vector<ll> D;
while (!BC.empty() && cnt < N) {
auto p = BC.top();
for (int i = 0; i < p.second && cnt < N; i++) {
D.push_back(p.first);
cnt++;
}
BC.pop();
}
sort(A.begin(), A.end());
sort(D.begin(), D.end(), greater<ll>());
rep(i, D.size()) {
if (A[i] < D[i])
A[i] = D[i];
else
break;
}
cout << accumulate(A.begin(), A.end(), 0LL) << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 853,064 | 853,065 | u137747137 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), C(M);
vector<int> B(M);
rep(i, N) cin >> A[i];
rep(i, M) cin >> B[i] >> C[i];
priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>>
BC;
rep(i, M) BC.push(make_pair(C[i], B[i]));
int cnt = 0;
vector<ll> D;
while (!BC.empty() && cnt < N) {
auto p = BC.top();
for (int i = 0; i < p.second && cnt < N; i++) {
D.push_back(p.first);
cnt++;
}
BC.pop();
}
sort(A.begin(), A.end());
sort(D.begin(), D.end(), greater<ll>());
rep(i, D.size()) {
if (A[i] < D[i])
A[i] = D[i];
else
break;
}
cout << accumulate(A.begin(), A.end(), 0LL) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), C(M);
vector<int> B(M);
rep(i, N) cin >> A[i];
rep(i, M) cin >> B[i] >> C[i];
priority_queue<pair<ll, int>, vector<pair<ll, int>>, less<pair<ll, int>>> BC;
rep(i, M) BC.push(make_pair(C[i], B[i]));
int cnt = 0;
vector<ll> D;
while (!BC.empty() && cnt < N) {
auto p = BC.top();
for (int i = 0; i < p.second && cnt < N; i++) {
D.push_back(p.first);
cnt++;
}
BC.pop();
}
sort(A.begin(), A.end());
sort(D.begin(), D.end(), greater<ll>());
rep(i, D.size()) {
if (A[i] < D[i])
A[i] = D[i];
else
break;
}
cout << accumulate(A.begin(), A.end(), 0LL) << endl;
return 0;
} | [] | 853,066 | 853,065 | u137747137 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(), (x).end()
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const ll dx[8] = {0, -1, 0, 1, 1, -1, 1, -1};
using Graph = vector<vector<int>>;
const double pi = acos(-1);
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD>;
vector<bool> seen, finished;
int pos = -1;
int ca = 0;
int f = 0;
void dfs(const Graph &G, int v, int p) {
seen[v] = true;
for (auto nv : G[v]) {
if (nv == p)
continue;
if (finished[nv])
continue;
if (seen[nv] && !finished[nv]) {
pos = nv;
f++;
return;
}
dfs(G, nv, v);
// サイクル検出したならば真っ直ぐに抜けていく
if (pos != -1) {
return;
}
}
finished[v] = true;
}
mint calc(long long N, long long K) {
mint res = 1;
for (long long n = 0; n < K; ++n) {
res *= (N - n);
res /= (n + 1);
}
return res;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll N) : par(N) { //最初は全てが根であるとして初期化
for (ll i = 0; i < N; i++)
par[i] = i;
}
ll root(ll x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(ll x, ll y) { // xとyの木を併合
ll rx = root(x); // xの根をrx
ll ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(ll x, ll y) { // 2つのデータx, yが属する木が同じならtrueを返す
ll rx = root(x);
ll ry = root(y);
return rx == ry;
}
};
int main() {
ll n, m;
cin >> n >> m;
ll a[n] = {};
map<ll, ll, greater<ll>> bc;
rep(i, n) cin >> a[i];
rep(i, m) {
ll b, c;
cin >> b >> c;
bc[c] = b;
}
sort(a, a + n);
ll mm = 0;
for (auto p : bc) {
ll b = p.se;
ll c = p.fi;
rep(i, b) {
if (a[mm] < c) {
a[mm] = c;
mm++;
} else {
goto w;
}
}
}
w:
ll ans = 0;
rep(i, n) { ans += a[i]; }
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(), (x).end()
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const ll dx[8] = {0, -1, 0, 1, 1, -1, 1, -1};
using Graph = vector<vector<int>>;
const double pi = acos(-1);
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD>;
vector<bool> seen, finished;
int pos = -1;
int ca = 0;
int f = 0;
void dfs(const Graph &G, int v, int p) {
seen[v] = true;
for (auto nv : G[v]) {
if (nv == p)
continue;
if (finished[nv])
continue;
if (seen[nv] && !finished[nv]) {
pos = nv;
f++;
return;
}
dfs(G, nv, v);
// サイクル検出したならば真っ直ぐに抜けていく
if (pos != -1) {
return;
}
}
finished[v] = true;
}
mint calc(long long N, long long K) {
mint res = 1;
for (long long n = 0; n < K; ++n) {
res *= (N - n);
res /= (n + 1);
}
return res;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll N) : par(N) { //最初は全てが根であるとして初期化
for (ll i = 0; i < N; i++)
par[i] = i;
}
ll root(ll x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(ll x, ll y) { // xとyの木を併合
ll rx = root(x); // xの根をrx
ll ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(ll x, ll y) { // 2つのデータx, yが属する木が同じならtrueを返す
ll rx = root(x);
ll ry = root(y);
return rx == ry;
}
};
int main() {
ll n, m;
cin >> n >> m;
ll a[n] = {};
map<ll, ll, greater<ll>> bc;
rep(i, n) cin >> a[i];
rep(i, m) {
ll b, c;
cin >> b >> c;
bc[c] += b;
}
sort(a, a + n);
ll mm = 0;
for (auto p : bc) {
ll b = p.se;
ll c = p.fi;
rep(i, b) {
if (a[mm] < c) {
a[mm] = c;
mm++;
} else {
goto w;
}
}
}
w:
ll ans = 0;
rep(i, n) { ans += a[i]; }
cout << ans << endl;
}
| [
"assignment.value.change"
] | 853,075 | 853,076 | u722640678 | cpp |
p03038 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
bool compare_by_b(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
int main() {
int N, M;
cin >> N >> M;
int A[N];
for (int i = 0; i < N; i++)
scanf("%d", &A[i]);
vector<pair<int, int>> s;
int B[M], C[M];
for (int i = 0; i < M; i++) {
cin >> B[i] >> C[i];
pair<int, int> tmp;
tmp.first = B[i];
tmp.second = C[i];
s.push_back(tmp);
}
// for(int i = 0; i < M; i++)cout << s[i].first << "&" << s[i].second << " ";
sort(s.begin(), s.end(), compare_by_b);
sort(A, A + N);
vector<int> bnc;
int nbnc = 0;
for (int i = 0; i < N && nbnc < M; i++) {
for (int j = 0; j < s[nbnc].first; j++) {
bnc.push_back(s[nbnc].second);
i++;
}
i--;
nbnc++;
}
cout << endl;
// for(int i = 0; i < bnc.size(); i++)cout << bnc[i] << ",";
int ans = 0;
for (int i = 0; i < N; i++) {
if (i < bnc.size()) {
if (bnc[i] > A[i])
A[i] = bnc[i];
}
ans += A[i];
}
cout << ans;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
bool compare_by_b(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
int main() {
int N, M;
cin >> N >> M;
int A[N];
for (int i = 0; i < N; i++)
scanf("%d", &A[i]);
vector<pair<int, int>> s;
int B[M], C[M];
for (int i = 0; i < M; i++) {
cin >> B[i] >> C[i];
pair<int, int> tmp;
tmp.first = B[i];
tmp.second = C[i];
s.push_back(tmp);
}
// for(int i = 0; i < M; i++)cout << s[i].first << "&" << s[i].second << " ";
sort(s.begin(), s.end(), compare_by_b);
sort(A, A + N);
vector<long> bnc;
int nbnc = 0;
for (int i = 0; i < N && nbnc < M; i++) {
for (int j = 0; j < s[nbnc].first; j++) {
bnc.push_back(s[nbnc].second);
i++;
}
i--;
nbnc++;
}
cout << endl;
// for(int i = 0; i < bnc.size(); i++)cout << bnc[i] << ",";
long ans = 0;
for (int i = 0; i < N; i++) {
if (i < bnc.size()) {
if (bnc[i] > A[i])
A[i] = bnc[i];
}
ans += A[i];
}
cout << ans;
} | [
"variable_declaration.type.primitive.change"
] | 853,079 | 853,080 | u969116807 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
using namespace std;
using int_greater_PQ = priority_queue<int, vector<int>, greater<int>>;
int main() {
int N, M;
cin >> N >> M;
int_greater_PQ A;
for (size_t i = 0; i < N; i++) {
int a;
cin >> a;
A.push(a);
}
multimap<int, int, greater<int>> BC;
for (size_t i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
BC.emplace(C, B);
}
for (const auto &bc : BC) {
int C = bc.first, B = bc.second;
while (B > 0) {
if (C > A.top()) {
A.pop();
A.push(C);
} else {
goto KIRISUTE;
}
--B;
}
}
KIRISUTE:
int ans = 0;
while (!A.empty()) {
ans += A.top();
A.pop();
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
using namespace std;
using int_greater_PQ = priority_queue<int, vector<int>, greater<int>>;
int main() {
int N, M;
cin >> N >> M;
int_greater_PQ A;
for (size_t i = 0; i < N; i++) {
int a;
cin >> a;
A.push(a);
}
multimap<int, int, greater<int>> BC;
for (size_t i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
BC.emplace(C, B);
}
for (const auto &bc : BC) {
int C = bc.first, B = bc.second;
while (B > 0) {
if (C > A.top()) {
A.pop();
A.push(C);
} else {
goto KIRISUTE;
}
--B;
}
}
KIRISUTE:
long ans = 0;
while (!A.empty()) {
ans += A.top();
A.pop();
}
cout << ans << endl;
return 0;
} | [
"assignment.variable.change"
] | 853,090 | 853,091 | u272632379 | cpp |
p03038 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define F first
#define S second
#define B begin()
#define E end()
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
const int BIG = 1e5 + 7;
int l[BIG], r[BIG];
pair<int, int> p[BIG];
int rep[BIG];
bool cmp(pair<int, int> x, pair<int, int> y) { return x.S > y.S; }
int main() {
FASTIO
int n, m;
cin >> n >> m;
vector<int> a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.pb(x);
}
for (int i = 0; i < m; i++)
cin >> p[i].F >> p[i].S;
sort(p, p + m, cmp);
sort(a.B, a.E);
int start = 0, sum = 0;
for (int i = 0; i < m; i++) {
if (sum > n)
break;
int cnt = 0;
for (int j = start; j < n; j++) {
if (a[j] >= p[i].S || cnt == p[i].F)
break;
a[j] = p[i].S;
start = j + 1;
cnt++;
sum++;
}
}
int ans = 0;
for (int i = 0; i < n; i++)
ans += a[i];
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define F first
#define S second
#define B begin()
#define E end()
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
const int BIG = 1e5 + 7;
int l[BIG], r[BIG];
pair<int, int> p[BIG];
int rep[BIG];
bool cmp(pair<int, int> x, pair<int, int> y) { return x.S > y.S; }
int main() {
FASTIO
int n, m;
cin >> n >> m;
vector<int> a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.pb(x);
}
for (int i = 0; i < m; i++)
cin >> p[i].F >> p[i].S;
sort(p, p + m, cmp);
sort(a.B, a.E);
int start = 0, sum = 0;
for (int i = 0; i < m; i++) {
if (sum > n)
break;
int cnt = 0;
for (int j = start; j < n; j++) {
if (a[j] >= p[i].S || cnt == p[i].F)
break;
a[j] = p[i].S;
start = j + 1;
cnt++;
sum++;
}
}
ll ans = 0;
for (int i = 0; i < n; i++)
ans += a[i];
cout << ans;
return 0;
}
| [
"variable_declaration.type.change"
] | 853,092 | 853,093 | u802045251 | cpp |
p03038 | #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define f first
#define s second
#define pb push_back
#define pp push
#define RETURN exit(0)
#define pow(x, y) (int)(pow(x, y))
#define ceil(x) (int)(ceil(x))
#ifndef ONLINE_JUDGE
#define debug(x) cout << x << endl;
#else
#define debug(x) 42
#endif
const int MAX = 1e7;
const int MOD = 1e9 + 7;
const int MAAX = 1e15;
const long double EPS = 1e-6;
const int N = 1e6;
int power(int x, int y) {
if (y == 0)
return 1;
int a = power(x, y / 2) % MOD;
if (y % 2 == 0)
return a * a % MOD;
else
return x * a % MOD * a % MOD;
}
long double sq(int x) {
long double s = 0, e = x, mid;
while (e - s >= EPS) {
mid = (s + e) / 2;
if (mid * mid <= x) {
s = mid;
} else {
e = mid - EPS;
}
}
return s;
}
vector<int> primes;
bool visted[N + 5];
void sieve() {
visted[0] = visted[1] = 1;
for (int i = 2; i * i <= N; i++) {
if (visted[i] == 0) {
primes.pb(i);
for (int j = i * i; j <= N; j += i) {
visted[j] = 1;
}
}
}
for (int i = sqrt(N) + 1; i <= N; i++) {
if (visted[i] == 0)
primes.pb(i);
}
return;
}
int n, m;
pair<int, int> c[100010];
int arr[100010];
in main() {
// freopen("in.in","r",stdin);
// freopen("out.out","w",stdout);
int tc = 1;
// sieve();
// scanf("%lld",&tc);
while (tc--) {
cin >> n >> m;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < m; i++) {
cin >> c[i].s >> c[i].f;
c[i].f *= -1;
}
sort(c, c + m);
int x = 0;
int mx = 0;
for (int i = 0; i < n && x < m; i++) {
sum -= arr[i];
sum += c[x].f * -1;
c[x].s--;
if (c[x].s == 0)
x++;
mx = max(mx, sum);
}
cout << mx << endl;
}
RETURN;
}
| #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define f first
#define s second
#define pb push_back
#define pp push
#define RETURN exit(0)
#define pow(x, y) (int)(pow(x, y))
#define ceil(x) (int)(ceil(x))
#ifndef ONLINE_JUDGE
#define debug(x) cout << x << endl;
#else
#define debug(x) 42
#endif
const int MAX = 1e7;
const int MOD = 1e9 + 7;
const int MAAX = 1e15;
const long double EPS = 1e-6;
const int N = 1e6;
int power(int x, int y) {
if (y == 0)
return 1;
int a = power(x, y / 2) % MOD;
if (y % 2 == 0)
return a * a % MOD;
else
return x * a % MOD * a % MOD;
}
long double sq(int x) {
long double s = 0, e = x, mid;
while (e - s >= EPS) {
mid = (s + e) / 2;
if (mid * mid <= x) {
s = mid;
} else {
e = mid - EPS;
}
}
return s;
}
vector<int> primes;
bool visted[N + 5];
void sieve() {
visted[0] = visted[1] = 1;
for (int i = 2; i * i <= N; i++) {
if (visted[i] == 0) {
primes.pb(i);
for (int j = i * i; j <= N; j += i) {
visted[j] = 1;
}
}
}
for (int i = sqrt(N) + 1; i <= N; i++) {
if (visted[i] == 0)
primes.pb(i);
}
return;
}
int n, m;
pair<int, int> c[100010];
int arr[100010];
in main() {
// freopen("in.in","r",stdin);
// freopen("out.out","w",stdout);
int tc = 1;
// sieve();
// scanf("%lld",&tc);
while (tc--) {
cin >> n >> m;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < m; i++) {
cin >> c[i].s >> c[i].f;
c[i].f *= -1;
}
sort(c, c + m);
int x = 0;
int mx = sum;
for (int i = 0; i < n && x < m; i++) {
sum -= arr[i];
sum += c[x].f * -1;
c[x].s--;
if (c[x].s == 0)
x++;
mx = max(mx, sum);
}
cout << mx << endl;
}
RETURN;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 853,104 | 853,105 | u956319190 | cpp |
p03038 | #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define f first
#define s second
#define pb push_back
#define pp push
#define RETURN exit(0)
#define pow(x, y) (int)(pow(x, y))
#define ceil(x) (int)(ceil(x))
#ifndef ONLINE_JUDGE
#define debug(x) cout << x << endl;
#else
#define debug(x) 42
#endif
const int MAX = 1e7;
const int MOD = 1e9 + 7;
const int MAAX = 1e15;
const long double EPS = 1e-6;
const int N = 1e6;
int power(int x, int y) {
if (y == 0)
return 1;
int a = power(x, y / 2) % MOD;
if (y % 2 == 0)
return a * a % MOD;
else
return x * a % MOD * a % MOD;
}
long double sq(int x) {
long double s = 0, e = x, mid;
while (e - s >= EPS) {
mid = (s + e) / 2;
if (mid * mid <= x) {
s = mid;
} else {
e = mid - EPS;
}
}
return s;
}
vector<int> primes;
bool visted[N + 5];
void sieve() {
visted[0] = visted[1] = 1;
for (int i = 2; i * i <= N; i++) {
if (visted[i] == 0) {
primes.pb(i);
for (int j = i * i; j <= N; j += i) {
visted[j] = 1;
}
}
}
for (int i = sqrt(N) + 1; i <= N; i++) {
if (visted[i] == 0)
primes.pb(i);
}
return;
}
int n, m;
pair<int, int> c[100010];
int arr[100010];
in main() {
// freopen("in.in","r",stdin);
// freopen("out.out","w",stdout);
int tc = 1;
// sieve();
// scanf("%lld",&tc);
while (tc--) {
cin >> n >> m;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < m; i++) {
cin >> c[i].s >> c[i].f;
c[i].f *= -1;
}
sort(c, c + n);
int x = 0;
int mx = 0;
for (int i = 0; i < n && x < m; i++) {
sum -= arr[i];
sum += c[x].f * -1;
c[x].s--;
if (c[x].s == 0)
x++;
mx = max(mx, sum);
}
cout << mx << endl;
}
RETURN;
}
| #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define f first
#define s second
#define pb push_back
#define pp push
#define RETURN exit(0)
#define pow(x, y) (int)(pow(x, y))
#define ceil(x) (int)(ceil(x))
#ifndef ONLINE_JUDGE
#define debug(x) cout << x << endl;
#else
#define debug(x) 42
#endif
const int MAX = 1e7;
const int MOD = 1e9 + 7;
const int MAAX = 1e15;
const long double EPS = 1e-6;
const int N = 1e6;
int power(int x, int y) {
if (y == 0)
return 1;
int a = power(x, y / 2) % MOD;
if (y % 2 == 0)
return a * a % MOD;
else
return x * a % MOD * a % MOD;
}
long double sq(int x) {
long double s = 0, e = x, mid;
while (e - s >= EPS) {
mid = (s + e) / 2;
if (mid * mid <= x) {
s = mid;
} else {
e = mid - EPS;
}
}
return s;
}
vector<int> primes;
bool visted[N + 5];
void sieve() {
visted[0] = visted[1] = 1;
for (int i = 2; i * i <= N; i++) {
if (visted[i] == 0) {
primes.pb(i);
for (int j = i * i; j <= N; j += i) {
visted[j] = 1;
}
}
}
for (int i = sqrt(N) + 1; i <= N; i++) {
if (visted[i] == 0)
primes.pb(i);
}
return;
}
int n, m;
pair<int, int> c[100010];
int arr[100010];
in main() {
// freopen("in.in","r",stdin);
// freopen("out.out","w",stdout);
int tc = 1;
// sieve();
// scanf("%lld",&tc);
while (tc--) {
cin >> n >> m;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < m; i++) {
cin >> c[i].s >> c[i].f;
c[i].f *= -1;
}
sort(c, c + m);
int x = 0;
int mx = sum;
for (int i = 0; i < n && x < m; i++) {
sum -= arr[i];
sum += c[x].f * -1;
c[x].s--;
if (c[x].s == 0)
x++;
mx = max(mx, sum);
}
cout << mx << endl;
}
RETURN;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 853,106 | 853,105 | u956319190 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A;
ll sum = 0;
for (int i = 0; i < N; i++) {
ll _in;
cin >> _in;
sum += _in;
A.push_back(_in);
}
sort(A.begin(), A.end());
// point, count
vector<pair<ll, ll>> B;
for (int i = 0; i < M; i++) {
ll in_count, in_point;
cin >> in_count >> in_point;
B.push_back(make_pair(in_point, in_count));
}
sort(B.begin(), B.end());
int A_i = 0;
for (int i = 0; i < M; i++) {
if (A_i < N) {
pair<ll, ll> b = B[M - 1 - i];
for (int j = 0; j < b.second; j++) {
if (A[A_i] < b.first) {
sum += b.first - A[A_i];
A_i++;
} else {
break;
}
}
} else {
break;
}
}
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A;
ll sum = 0;
for (int i = 0; i < N; i++) {
ll _in;
cin >> _in;
sum += _in;
A.push_back(_in);
}
sort(A.begin(), A.end());
// point, count
vector<pair<ll, ll>> B;
for (int i = 0; i < M; i++) {
ll in_count, in_point;
cin >> in_count >> in_point;
B.push_back(make_pair(in_point, in_count));
}
sort(B.begin(), B.end());
int A_i = 0;
for (int i = 0; i < M; i++) {
if (A_i < N) {
pair<ll, ll> b = B[M - 1 - i];
for (int j = 0; j < b.second; j++) {
if (A_i < N && A[A_i] < b.first) {
sum += b.first - A[A_i];
A_i++;
} else {
break;
}
}
} else {
break;
}
}
cout << sum << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 853,109 | 853,110 | u303453927 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef pair<int, int> P;
constexpr ll mod = 998244353;
int main() {
int n, m;
cin >> n >> m;
map<ll, ll> mp;
rep(i, n) {
int a;
cin >> a;
mp[-a]++;
}
rep(i, m) {
int b, c;
cin >> b >> c;
mp[-c] += b;
}
ll res = 0;
ll cnt = 0;
for (auto e : mp) {
ll num = e.second;
ll a = -e.first;
if (cnt + num <= n)
res += num * a, cnt += num;
else {
ll d = max(0LL, n - (cnt + num));
res += a * d;
cnt += d;
}
// out << res << " " << cnt << endl;
}
// cout << cnt << endl;
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef pair<int, int> P;
constexpr ll mod = 998244353;
int main() {
int n, m;
cin >> n >> m;
map<ll, ll> mp;
rep(i, n) {
int a;
cin >> a;
mp[-a]++;
}
rep(i, m) {
int b, c;
cin >> b >> c;
mp[-c] += b;
}
ll res = 0;
ll cnt = 0;
for (auto e : mp) {
ll num = e.second;
ll a = -e.first;
if (cnt + num <= n)
res += num * a, cnt += num;
else {
ll d = max(0LL, n - cnt);
res += a * d;
cnt += d;
}
// out << res << " " << cnt << endl;
}
// cout << cnt << endl;
cout << res << endl;
return 0;
} | [
"call.arguments.change"
] | 853,142 | 853,143 | u108540384 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
typedef long long ll;
using pii = pair<int, int>;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
rep(i, n) {
int tmp;
cin >> tmp;
mp[tmp]++;
}
rep(i, m) {
int b, c;
cin >> b >> c;
mp[c] += b;
}
ll cnt = 0;
ll ans = 0;
for (auto it = mp.end(); it != mp.begin(); --it) {
if (it == mp.end())
continue;
// cout << (*it).first << " " << (*it).second << endl;
if (cnt + (*it).second <= n) {
cnt += (*it).second;
ans += (ll)(*it).first * (*it).second;
} else {
ans += (ll)(n - cnt) * (*it).first;
break;
}
// cout << ans << endl;
}
auto it = mp.begin();
if (cnt < n) {
ans += (ll)(n - cnt) * (*it).first;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
typedef long long ll;
using pii = pair<int, int>;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
rep(i, n) {
int tmp;
cin >> tmp;
mp[tmp]++;
}
rep(i, m) {
int b, c;
cin >> b >> c;
mp[c] += b;
}
ll cnt = 0;
ll ans = 0;
for (auto it = mp.end(); it != mp.begin(); --it) {
if (it == mp.end())
continue;
// cout << (*it).first << " " << (*it).second << endl;
if (cnt + (*it).second <= n) {
cnt += (*it).second;
ans += (ll)(*it).first * (*it).second;
} else {
ans += (ll)(n - cnt) * (*it).first;
cnt = n;
break;
}
// cout << ans << endl;
}
auto it = mp.begin();
// cout << cnt << endl;
if (cnt < n) {
ans += (ll)(n - cnt) * (*it).first;
}
cout << ans << endl;
}
| [
"assignment.add"
] | 853,144 | 853,145 | u277556971 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int i, j;
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> P(M);
for (i = 0; i < N; i++)
cin >> A[i];
//都合上，BとCを逆順に入力している
for (i = 0; i < M; i++)
cin >> P[i].second >> P[i].first;
// Aを降順にソート．Pをfirstでソート
sort(A.begin(), A.end());
sort(P.begin(), P.end(), greater<pair<int, int>>());
long long int sum = 0;
// Pを追っていく添字変数j
j = 0;
for (i = 0; i < N; i++) {
//選んだカードの方が大きければそっちを足す
if (A[i] < P[j].first) {
sum += P[j].first;
//選べる回数を一回減らす．B[j]--と同値
P[j].second--;
//選べる上限に達したら次の操作に移る
if (P[j].second == 0)
j++;
}
//選べるカードより元の数字の方が大きい
else
sum += A[i];
}
cout << sum << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int i, j;
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> P(M + 1);
for (i = 0; i < N; i++)
cin >> A[i];
//都合上，BとCを逆順に入力している
for (i = 0; i < M; i++)
cin >> P[i].second >> P[i].first;
// Aを降順にソート．Pをfirstでソート
sort(A.begin(), A.end());
sort(P.begin(), P.end(), greater<pair<int, int>>());
long long int sum = 0;
// Pを追っていく添字変数j
j = 0;
for (i = 0; i < N; i++) {
//選んだカードの方が大きければそっちを足す
if (A[i] < P[j].first) {
sum += P[j].first;
//選べる回数を一回減らす．B[j]--と同値
P[j].second--;
//選べる上限に達したら次の操作に移る
if (P[j].second == 0)
j++;
}
//選べるカードより元の数字の方が大きい
else
sum += A[i];
}
cout << sum << endl;
return 0;
}
| [
"assignment.change"
] | 853,151 | 853,152 | u537852947 | cpp |
p03038 | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
bool my_compare(pair<ll, ll> a, pair<ll, ll> b) {
// 基本はfirstで比較
if (a.first != b.first) {
return a.first > b.first; // 降順
}
// それ以外はsecondで比較
if (a.second != b.second) {
return a.second > b.second;
} else {
// どちらも同じ
return true;
}
}
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> CB(M);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++) {
cin >> CB[i].second >> CB[i].first;
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end(), my_compare);
ll cur_min = A[0], cur_min_idx = 0, replace_size, replace_num;
for (int i = 0; i < M; i++) {
replace_size = CB[i].second;
replace_num = CB[i].first;
if (cur_min < replace_num) {
ll upper =
(cur_min_idx + replace_size < N) ? cur_min_idx + replace_size : N;
for (int j = cur_min_idx; j < upper && A[j] < replace_num; j++) {
A[j] = replace_num;
}
if (upper == N)
break;
cur_min_idx = upper;
cur_min = A[cur_min_idx];
} else {
break;
}
}
ll ans;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
bool my_compare(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first) {
return a.first > b.first;
}
if (a.second != b.second) {
return a.second > b.second;
} else {
return false;
}
}
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> CB(M);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++) {
cin >> CB[i].second >> CB[i].first;
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end(), my_compare);
ll cur_min = A[0], cur_min_idx = 0, replace_size, replace_num;
for (int i = 0; i < M; i++) {
replace_size = CB[i].second;
replace_num = CB[i].first;
if (cur_min < replace_num) {
ll upper =
(cur_min_idx + replace_size < N) ? cur_min_idx + replace_size : N;
for (int j = cur_min_idx; j < upper && A[j] < replace_num; j++) {
A[j] = replace_num;
}
if (upper == N)
break;
cur_min_idx = upper;
cur_min = A[cur_min_idx];
} else {
break;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"function.return_value.change",
"variable_declaration.value.change"
] | 853,155 | 853,154 | u178536051 | cpp |
p03038 | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define REPR(i, n) for (int i = n - 1; 0 <= i; i--)
#define FOR(i, s, e) for (int i = s; i <= e; i++)
#define FORR(i, s, e) for (int i = s; e <= i; i--)
#define LLI long long int
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N);
vector<pair<int, int>> v;
REP(i, N) { cin >> a[i]; }
SORT(a);
REP(i, M) {
int b, c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.rbegin(), v.rend());
int sum = 0;
int idx = 0;
REP(i, M) {
REP(j, v[i].second) {
if (N <= idx) {
i = M;
break;
}
if (a[idx] < v[i].first) {
a[idx] = v[i].first;
}
idx++;
}
}
REP(i, a.size()) { sum += a[i]; }
cout << sum;
return 0;
} | #include <algorithm>
#include <climits>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define dlog(str) cout << "====" << str << endl;
#define INF 999999999
#define REP(i, n) for (int i = 0, i##_l = (n); i < i##_l; i++)
#define REPR(i, n) for (int i = n - 1; 0 <= i; i--)
#define FOR(i, s, e) for (int i = s; i <= e; i++)
#define FORR(i, s, e) for (int i = s; e <= i; i--)
#define LLI long long int
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define bit(a, shift) ((a>>shift)&1))
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
// int 2.14E±9 lli 9.2E±18 double 1.7E±380
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N);
vector<pair<int, int>> v;
REP(i, N) { cin >> a[i]; }
SORT(a);
REP(i, M) {
int b, c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.rbegin(), v.rend());
LLI sum = 0;
int idx = 0;
REP(i, M) {
REP(j, v[i].second) {
if (N <= idx) {
i = M;
break;
}
if (a[idx] < v[i].first) {
a[idx] = v[i].first;
}
idx++;
}
}
REP(i, a.size()) { sum += a[i]; }
cout << sum;
return 0;
} | [
"variable_declaration.type.change"
] | 853,163 | 853,164 | u840105874 | cpp |
p03038 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(a) a.begin(), a.end()
#define fi first
#define se second
#define RNG(x, a, n) &((x)[a]), &((x)[n])
typedef pair<int, int> PII;
typedef long long ll;
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;
}
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const long double PI = (acos(-1));
const long double EPS = 0.0000000001;
int n, m, cnt, ans;
ll a[100005];
ll b[100005], c[100005];
vector<pair<ll, ll>> vec;
int main() {
cin >> n >> m;
rep(i, n) cin >> a[i];
rep(i, m) { cin >> b[i] >> c[i]; }
rep(i, n) vec.push_back(make_pair(a[i], 1));
rep(i, m) vec.push_back(make_pair(c[i], b[i]));
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
int i = 0;
while (cnt < n) {
while (cnt < n && vec[i].se > 0) {
ans += vec[i].fi;
vec[i].se--;
cnt++;
}
i++;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(a) a.begin(), a.end()
#define fi first
#define se second
#define RNG(x, a, n) &((x)[a]), &((x)[n])
typedef pair<int, int> PII;
typedef long long ll;
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;
}
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const long double PI = (acos(-1));
const long double EPS = 0.0000000001;
ll n, m, cnt, ans;
ll a[100005];
ll b[100005], c[100005];
vector<pair<ll, ll>> vec;
int main() {
cin >> n >> m;
rep(i, n) cin >> a[i];
rep(i, m) { cin >> b[i] >> c[i]; }
rep(i, n) vec.push_back(make_pair(a[i], 1));
rep(i, m) vec.push_back(make_pair(c[i], b[i]));
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
int i = 0;
while (cnt < n) {
while (cnt < n && vec[i].se > 0) {
ans += vec[i].fi;
vec[i].se--;
cnt++;
}
i++;
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 853,167 | 853,168 | u519950235 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int n, m, cnt = 0;
scanf("%d %d", &n, &m);
vector<int> v(2 * n);
vector<pair<int, int>> p(m);
rep(i, n) scanf("%d", &v[i]);
rep(i, m) scanf("%d %d", &p[i].second, &p[i].first);
sort(p.begin(), p.end());
for (int i = m - 1; i < 0 && cnt < n; --i)
rep(j, p[i].second) {
v[n + cnt++] = p[i].first;
if (cnt == n)
break;
}
sort(v.begin(), v.end(), greater<int>());
long long ans = 0;
rep(i, n) ans += v[i];
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int n, m, cnt = 0;
scanf("%d %d", &n, &m);
vector<int> v(2 * n);
vector<pair<int, int>> p(m);
rep(i, n) scanf("%d", &v[i]);
rep(i, m) scanf("%d %d", &p[i].second, &p[i].first);
sort(p.begin(), p.end());
for (int i = m - 1; i >= 0 && cnt < n; --i)
rep(j, p[i].second) {
v[n + cnt++] = p[i].first;
if (cnt == n)
break;
}
sort(v.begin(), v.end(), greater<int>());
long long ans = 0;
rep(i, n) ans += v[i];
cout << ans;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 853,172 | 853,173 | u983711104 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) { cin >> A[i]; }
sort(A.begin(), A.end());
typedef pair<ll, ll> P;
vector<P> BC(M);
ll b, c;
rep(i, M) {
cin >> b >> c;
// BC[i] = P{b,c};
BC[i] = P{1, 1};
}
sort(BC.begin(), BC.end(), [](P p1, P p2) { return p1.second >= p2.second; });
vector<ll> new_num(N);
ll ind = 0;
rep(i, M) {
b = BC[i].first;
c = BC[i].second;
rep(j, b) {
new_num[ind] = c;
++ind;
if (ind == N)
break;
}
if (ind == N)
break;
}
ll ans = 0;
rep(i, N) { ans += A[i]; }
ll max_ans = ans;
rep(i, N) {
ans -= A[i];
ans += new_num[i];
max_ans = max(ans, max_ans);
}
cout << max_ans << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) { cin >> A[i]; }
sort(A.begin(), A.end());
typedef pair<ll, ll> P;
vector<P> BC(M);
ll b, c;
rep(i, M) {
cin >> b >> c;
BC[i] = P{b, c};
}
sort(BC.begin(), BC.end(), [](P p1, P p2) { return p1.second > p2.second; });
vector<ll> new_num(N);
ll ind = 0;
rep(i, M) {
b = BC[i].first;
c = BC[i].second;
rep(j, b) {
new_num[ind] = c;
++ind;
if (ind == N)
break;
}
if (ind == N)
break;
}
ll ans = 0;
rep(i, N) { ans += A[i]; }
ll max_ans = ans;
rep(i, N) {
ans -= A[i];
ans += new_num[i];
max_ans = max(ans, max_ans);
}
cout << max_ans << "\n";
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 853,190 | 853,189 | u821284362 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
int n, m, cnt = 0, tmp;
ll ans = 0;
pair<int, int> a[200000];
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = 1;
}
for (int i = 0; i < m; i++) {
cin >> a[i + n].second >> a[i + n].first;
}
sort(a, a + n + m);
ll num = n;
for (int i = n + m - 1; i >= 0; i--) {
if (num > a[i].second) {
ans += a[i].first * a[i].second;
num -= a[i].second;
} else {
ans += a[i].first * num;
break;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string.h>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
int n, m, cnt = 0, tmp;
ll ans = 0;
pair<ll, ll> a[200000];
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = 1;
}
for (int i = 0; i < m; i++) {
cin >> a[i + n].second >> a[i + n].first;
}
sort(a, a + n + m);
ll num = n;
for (int i = n + m - 1; i >= 0; i--) {
if (num > a[i].second) {
ans += a[i].first * a[i].second;
num -= a[i].second;
} else {
ans += a[i].first * num;
break;
}
}
cout << ans << endl;
return 0;
}
| [] | 853,193 | 853,194 | u831873811 | cpp |
p03038 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll;
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
static const int MAX = 100;
static const int INF = (1 << 23);
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a;
rep(i, n) {
ll a1;
cin >> a1;
a.push_back(a1);
}
vector<pair<ll, ll>> v;
rep(i, m) {
ll b1, c1;
cin >> b1 >> c1;
v.push_back({c1, b1});
}
sort(v.rbegin(), v.rend());
sort(a.begin(), a.end());
ll vk = 0;
ll ans = 0;
ll ai = 0;
while (ai < n) {
if (a[ai] >= v[vk].first || vk >= v.size()) {
ans += a[ai];
ai++;
} else {
ll vkse = v[vk].second;
while (vkse > 0) {
if (a[ai] > v[vk].first)
break;
else {
ans += v[vk].first;
vkse--;
ai++;
}
}
vk++;
}
// cout<<ans<<endl;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef int long long ll;
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
static const int MAX = 100;
static const int INF = (1 << 23);
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a;
rep(i, n) {
ll a1;
cin >> a1;
a.push_back(a1);
}
vector<pair<ll, ll>> v;
rep(i, m) {
ll b1, c1;
cin >> b1 >> c1;
v.push_back({c1, b1});
}
sort(v.rbegin(), v.rend());
sort(a.begin(), a.end());
ll vk = 0;
ll ans = 0;
ll ai = 0;
while (ai < n) {
if (a[ai] >= v[vk].first || vk >= v.size()) {
ans += a[ai];
ai++;
} else {
ll vkse = v[vk].second;
while (vkse > 0) {
if (a[ai] > v[vk].first || ai >= n)
break;
else {
ans += v[vk].first;
vkse--;
ai++;
}
}
vk++;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 853,197 | 853,198 | u031448582 | cpp |
p03038 | /**
* Title:
* Url:
*/
#include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define ll long long
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<int, int>> bc(m);
for (int i = 0; i < m; i++) {
int bi, ci;
cin >> bi >> ci;
bc.push_back(make_pair(ci, bi));
}
// O(MlogM)
sort(bc.begin(), bc.end(), std::greater<pair<int, int>>());
vector<int> d(n, 0);
int counter = 0;
for (auto bci : bc) {
// O(max(M, N))
if (counter >= n)
break;
for (int i = 0; i < bci.second; i++) {
if (counter >= n)
break;
d[i] = bci.first;
counter++;
}
}
// O(NlogN)
sort(a.begin(), a.end());
ll sum = 0;
// O(N)
for (int i = 0; i < n; i++) {
if (a[i] >= d[i]) {
sum += a[i];
} else {
sum += d[i];
}
}
// O(NlogN+MlogM)
cout << sum << endl;
return 0;
} | /**
* Title:
* Url:
*/
#include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define ll long long
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<int, int>> bc(m);
for (int i = 0; i < m; i++) {
int bi, ci;
cin >> bi >> ci;
bc.push_back(make_pair(ci, bi));
}
// O(MlogM)
sort(bc.begin(), bc.end(), std::greater<pair<int, int>>());
vector<int> d(n, 0);
int counter = 0;
for (auto bci : bc) {
// O(max(M, N))
if (counter >= n)
break;
for (int i = 0; i < bci.second; i++) {
if (counter >= n)
break;
d[counter] = bci.first;
counter++;
}
}
// O(NlogN)
sort(a.begin(), a.end());
ll sum = 0;
// O(N)
for (int i = 0; i < n; i++) {
if (a[i] >= d[i]) {
sum += a[i];
} else {
sum += d[i];
}
}
// O(NlogN+MlogM)
cout << sum << endl;
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 853,201 | 853,202 | u036744414 | cpp |
p03038 | #include <bits/stdc++.h>
#include <cmath>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define sz(x) ll(x.size())
typedef long long ll;
// typedef pair<int, int> P;
typedef pair<ll, ll> P;
// const double INF = 1e10;
const ll INF = 1001001001;
#define mins(x, y) x = min(x, y)
#define maxs(x, y) x = max(x, y)
typedef tuple<string, int, int> T;
int main() {
int n, m;
cin >> n >> m;
vector<ll> cards(n);
rep(i, n) { cin >> cards[i]; }
sort(cards.begin(), cards.end());
vector<P> changes(m);
rep(i, m) {
ll b, c;
cin >> b >> c;
changes.emplace_back(c, b);
}
sort(changes.rbegin(), changes.rend());
int it = 0;
[&] {
for (auto p : changes) {
for (int i = 0; i < p.second; i++) {
if (cards[it] >= p.first)
return;
cards[it] = p.first;
it++;
if (it == n - 1) {
return;
}
}
}
}();
cout << accumulate(cards.begin(), cards.end(), 0ll) << endl;
}
| #include <bits/stdc++.h>
#include <cmath>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define sz(x) ll(x.size())
typedef long long ll;
// typedef pair<int, int> P;
typedef pair<ll, ll> P;
// const double INF = 1e10;
const ll INF = 1001001001;
#define mins(x, y) x = min(x, y)
#define maxs(x, y) x = max(x, y)
typedef tuple<string, int, int> T;
int main() {
int n, m;
cin >> n >> m;
vector<ll> cards(n);
rep(i, n) { cin >> cards[i]; }
sort(cards.begin(), cards.end());
vector<P> changes(m);
rep(i, m) {
ll b, c;
cin >> b >> c;
changes.emplace_back(c, b);
}
sort(changes.rbegin(), changes.rend());
int it = 0;
[&] {
for (auto p : changes) {
for (int i = 0; i < p.second; i++) {
if (cards[it] >= p.first)
return;
cards[it] = p.first;
it++;
if (it == n) {
return;
}
}
}
}();
cout << accumulate(cards.begin(), cards.end(), 0ll) << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 853,203 | 853,204 | u564182781 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define int long long
typedef long long ll;
typedef pair<int, int> P;
signed main() {
int n, m;
cin >> n >> m;
priority_queue<int> que;
rep(i, n) {
int a;
cin >> a;
que.push(-a);
}
vector<P> v;
rep(i, m) {
int b, c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.begin(), v.end(), greater<P>());
bool flag = true;
rep(i, m) {
P p = v[i];
rep(j, p.second) {
int v = que.top();
v = -v;
que.pop();
if (v < p.first)
que.push(-p.first);
else {
que.push(-v);
flag = true;
break;
}
}
if (flag)
break;
}
int ans = 0;
while (!que.empty()) {
int v = que.top();
v = -v;
que.pop();
ans += v;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define int long long
typedef long long ll;
typedef pair<int, int> P;
signed main() {
int n, m;
cin >> n >> m;
priority_queue<int> que;
rep(i, n) {
int a;
cin >> a;
que.push(-a);
}
vector<P> v;
rep(i, m) {
int b, c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.begin(), v.end(), greater<P>());
bool flag = false;
rep(i, m) {
P p = v[i];
rep(j, p.second) {
int v = que.top();
v = -v;
que.pop();
if (v < p.first)
que.push(-p.first);
else {
que.push(-v);
flag = true;
break;
}
}
if (flag)
break;
}
int ans = 0;
while (!que.empty()) {
int v = que.top();
v = -v;
que.pop();
// cout << v << endl;
ans += v;
}
cout << ans << endl;
} | [
"misc.opposites",
"variable_declaration.value.change"
] | 853,211 | 853,212 | u224590796 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
#define LLI long long int
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A.begin(), A.end());
vector<pair<int, int>> CB(M);
for (int i = 0; i < M; i++) {
cin >> CB[i].second >> CB[i].first;
}
sort(CB.begin(), CB.end(), greater<pair<int, int>>());
int i = 0, j = 0;
while (i < N && j < M && A[i] < CB[j].first) {
A[i] = CB[j].first;
i++;
CB[j].second--;
if (CB[j].second == 0)
j++;
}
int ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
#define LLI long long int
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
sort(A.begin(), A.end());
vector<pair<int, int>> CB(M);
for (int i = 0; i < M; i++) {
cin >> CB[i].second >> CB[i].first;
}
sort(CB.begin(), CB.end(), greater<pair<int, int>>());
int i = 0, j = 0;
while (i < N && j < M && A[i] < CB[j].first) {
A[i] = CB[j].first;
i++;
CB[j].second--;
if (CB[j].second == 0)
j++;
}
LLI ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 853,217 | 853,218 | u537874719 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> card(n + m);
for (int i = 0; i < n; i++) {
cin >> card.at(i).first;
card.at(i).second = 1;
}
for (int i = 0; i < m; i++) {
cin >> card.at(i + n).second >> card.at(i + n).first;
}
sort(card.begin(), card.end());
reverse(card.begin(), card.end());
int num = 0;
long sum = 0;
for (int i = 0; i < (n + m); i++) {
int newest = card.at(i).first;
sum += card.at(i).first * card.at(i).second;
num += card.at(i).second;
if (num >= n) {
sum -= (num - n) * newest;
break;
}
}
cout << sum;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
vector<pair<long, long>> card(n + m);
for (int i = 0; i < n; i++) {
cin >> card.at(i).first;
card.at(i).second = 1;
}
for (int i = 0; i < m; i++) {
cin >> card.at(i + n).second >> card.at(i + n).first;
}
sort(card.begin(), card.end());
reverse(card.begin(), card.end());
long num = 0;
long sum = 0;
for (int i = 0; i < (n + m); i++) {
int newest = card.at(i).first;
sum += card.at(i).first * card.at(i).second;
num += card.at(i).second;
if (num >= n) {
sum -= (num - n) * newest;
break;
}
}
cout << sum;
} | [
"variable_declaration.type.primitive.change"
] | 853,223 | 853,224 | u820236331 | cpp |
p03038 | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
/*
1, 2, 3
2, 5
5, 2, 3 = 10
2, 5, 3 = 10
*/
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
REP(i, 0, N) cin >> A[i];
vector<pair<int, int>> CB(M);
REP(i, 0, M) cin >> CB[i].second >> CB[i].first;
sort(ALL(A), greater<int>());
sort(ALL(CB), greater<pair<int, int>>());
ll ans = 0;
int ai = 0, cbi = 0;
REP(i, 0, N) {
if (A[ai] > CB[cbi].first) {
ans += A[ai++];
} else {
ans += CB[cbi].first;
CB[cbi].second--;
if (CB[cbi].second == 0)
cbi++;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
/*
1, 2, 3
2, 5
5, 2, 3 = 10
2, 5, 3 = 10
*/
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
REP(i, 0, N) cin >> A[i];
vector<pair<int, int>> CB(M);
REP(i, 0, M) cin >> CB[i].second >> CB[i].first;
sort(ALL(A), greater<int>());
sort(ALL(CB), greater<pair<int, int>>());
ll ans = 0;
int ai = 0, cbi = 0;
REP(i, 0, N) {
if (cbi == M || A[ai] > CB[cbi].first) {
ans += A[ai++];
} else {
ans += CB[cbi].first;
CB[cbi].second--;
if (CB[cbi].second == 0)
cbi++;
}
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 853,229 | 853,230 | u483992368 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
#define debug(x) \
cout << "DEBUG" \
<< " " << #x << ":" << x << '\n'
//↓0-originか1-originでn回繰り返し
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++) // 0-indexed昇順
#define rep1(i, n) for (int i = 1; i <= ((int)(n)); i++) // 1-indexed昇順
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--) // 0-indexed降順
#define rrep1(i, n) for (int i = ((int)(n)); i >= 1; i--) // 1-indexed降順
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vii; // 2次元配列
typedef vector<ll> vll;
typedef pair<int, int> PII;
template <typename T> using vec = vector<T>;
template <class T> using maxheap = std::priority_queue<T>;
template <class T>
using minheap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T, class U> inline bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &a, const U &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ld PI = acos(-1.0L);
const ll infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;
const int mod = 1000000007;
// const int mod = 998244353;
/*FUNCs=================================================*/
/*MAIN==================================================*/
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false); // cin cout 高速化
// cout << fixed << setprecision(10);
ll n, m;
cin >> n >> m;
vll a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vec<pair<ll, ll>> bc(m);
rep(i, m) cin >> bc[i].second >> bc[i].first;
sort(all(bc));
reverse(all(bc));
vll new_card(n);
ll idx = -1;
for (int i = 0; i < m; ++i) {
idx += bc[i].second;
if (idx >= n) {
idx = n;
chmax(new_card[idx], bc[i].first);
break;
} else
chmax(new_card[idx], bc[i].first);
}
// for(auto d : new_card) debug(d);
ll cnt = 0;
ll new_card_max = 0;
for (int i = n - 1; i >= 0; --i) {
chmax(new_card_max, new_card[i]);
// debug(new_card_max);
if (new_card_max < a[i])
cnt += a[i];
else
cnt += new_card_max;
}
cout << cnt << '\n';
} | #include <bits/stdc++.h>
using namespace std;
#define debug(x) \
cout << "DEBUG" \
<< " " << #x << ":" << x << '\n'
//↓0-originか1-originでn回繰り返し
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++) // 0-indexed昇順
#define rep1(i, n) for (int i = 1; i <= ((int)(n)); i++) // 1-indexed昇順
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--) // 0-indexed降順
#define rrep1(i, n) for (int i = ((int)(n)); i >= 1; i--) // 1-indexed降順
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vii; // 2次元配列
typedef vector<ll> vll;
typedef pair<int, int> PII;
template <typename T> using vec = vector<T>;
template <class T> using maxheap = std::priority_queue<T>;
template <class T>
using minheap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T, class U> inline bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &a, const U &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ld PI = acos(-1.0L);
const ll infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;
const int mod = 1000000007;
// const int mod = 998244353;
/*FUNCs=================================================*/
/*MAIN==================================================*/
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false); // cin cout 高速化
// cout << fixed << setprecision(10);
ll n, m;
cin >> n >> m;
vll a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vec<pair<ll, ll>> bc(m);
rep(i, m) cin >> bc[i].second >> bc[i].first;
sort(all(bc));
reverse(all(bc));
vll new_card(n);
ll idx = -1;
for (int i = 0; i < m; ++i) {
idx += bc[i].second;
if (idx >= n - 1) {
idx = n - 1;
chmax(new_card[idx], bc[i].first);
break;
} else
chmax(new_card[idx], bc[i].first);
}
// for(auto d : new_card) debug(d);
ll cnt = 0;
ll new_card_max = 0;
for (int i = n - 1; i >= 0; --i) {
chmax(new_card_max, new_card[i]);
// debug(new_card_max);
if (new_card_max < a[i])
cnt += a[i];
else
cnt += new_card_max;
}
cout << cnt << '\n';
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"assignment.change"
] | 853,235 | 853,236 | u457985479 | cpp |
p03038 | #include <bits/stdc++.h>
#include <numeric>
#include <vector>
using namespace std;
template <typename T> std::vector<size_t> argsort(T array) {
vector<size_t> indices(array.size());
std::iota(indices.begin(), indices.end(), 0); // range
std::sort(indices.begin(), indices.end(),
[&array](size_t i1, size_t i2) { return array[i1] < array[i2]; });
return indices;
}
void solve(long long N, long long M, std::vector<long long> A,
std::vector<long long> B, std::vector<long long> C) {
std::sort(A.begin(), A.end()); // Aは破壊的にソート
std::vector<size_t> sorted_idx = argsort(C); // Cはargsort
long long idx = 0;
bool break_flag = false;
for (auto i = M - 1; i >= 0; i--) {
for (auto j = 0; j < B[sorted_idx[i]]; j++) {
if (idx < N - 1 && A[idx] < C[sorted_idx[i]]) {
A[idx] = C[sorted_idx[i]];
idx += 1;
} else {
break_flag = true;
break;
}
}
if (break_flag)
break;
}
long long sum = 0;
for (int i = 0; i < N; i++) {
sum += A[i];
}
printf("%lld\n", sum);
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
std::vector<long long> A(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
std::vector<long long> B(M);
std::vector<long long> C(M);
for (int i = 0; i < M; i++) {
scanf("%lld", &B[i]);
scanf("%lld", &C[i]);
}
solve(N, M, std::move(A), std::move(B), std::move(C));
return 0;
}
| #include <bits/stdc++.h>
#include <numeric>
#include <vector>
using namespace std;
template <typename T> std::vector<size_t> argsort(T array) {
vector<size_t> indices(array.size());
std::iota(indices.begin(), indices.end(), 0); // range
std::sort(indices.begin(), indices.end(),
[&array](size_t i1, size_t i2) { return array[i1] < array[i2]; });
return indices;
}
void solve(long long N, long long M, std::vector<long long> A,
std::vector<long long> B, std::vector<long long> C) {
std::sort(A.begin(), A.end()); // Aは破壊的にソート
std::vector<size_t> sorted_idx = argsort(C); // Cはargsort
long long idx = 0;
bool break_flag = false;
for (auto i = M - 1; i >= 0; i--) {
for (auto j = 0; j < B[sorted_idx[i]]; j++) {
if (idx <= N - 1 && A[idx] < C[sorted_idx[i]]) {
A[idx] = C[sorted_idx[i]];
idx += 1;
} else {
break_flag = true;
break;
}
}
if (break_flag)
break;
}
long long sum = 0;
for (int i = 0; i < N; i++) {
sum += A[i];
}
printf("%lld\n", sum);
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
std::vector<long long> A(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &A[i]);
}
std::vector<long long> B(M);
std::vector<long long> C(M);
for (int i = 0; i < M; i++) {
scanf("%lld", &B[i]);
scanf("%lld", &C[i]);
}
solve(N, M, std::move(A), std::move(B), std::move(C));
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 853,239 | 853,240 | u794543767 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> v;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
v.push_back(make_pair(a, 1));
}
for (int i = 0; i < m; ++i) {
int b, c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.begin(), v.end(), greater<>());
long long ans = 0;
int cnt = 0;
for (int i = 0; i < n + m && cnt < n; ++i) {
if (cnt + v[i].second >= n) {
ans += v[i].first * (n - cnt);
break;
}
ans += (long long)v[i].first * v[i].second;
cnt += v[i].second;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long long, int>> v;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
v.push_back(make_pair(a, 1));
}
for (int i = 0; i < m; ++i) {
int b, c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.begin(), v.end(), greater<>());
long long ans = 0;
int cnt = 0;
for (int i = 0; i < n + m && cnt < n; ++i) {
if (cnt + v[i].second >= n) {
ans += v[i].first * (n - cnt);
break;
}
ans += v[i].first * v[i].second;
cnt += v[i].second;
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,247 | 853,248 | u320241053 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
priority_queue<int, vector<int>> pq;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
pq.push(a);
}
priority_queue<pair<int, int>> cb;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
cb.push(make_pair(c, b));
}
long long sum = 0;
int cnt = 0;
int a_max = pq.top();
pq.pop();
int c_max = cb.top().first;
int b = cb.top().second;
cb.pop();
while (cnt < n) {
if (a_max >= c_max) {
sum += a_max;
a_max = pq.top();
pq.pop();
cnt++;
} else {
if (b + cnt <= n) {
sum += c_max * b;
cnt += b;
} else {
sum += c_max * (n - cnt);
cnt = n;
}
if (!cb.empty()) {
c_max = cb.top().first;
b = cb.top().second;
cb.pop();
} else {
c_max = 0;
b = 0;
}
}
}
cout << sum << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
priority_queue<int, vector<int>> pq;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
pq.push(a);
}
priority_queue<pair<int, int>> cb;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
cb.push(make_pair(c, b));
}
long long sum = 0;
int cnt = 0;
int a_max = pq.top();
pq.pop();
long long c_max = cb.top().first;
long long b = cb.top().second;
cb.pop();
while (cnt < n) {
if (a_max >= c_max) {
sum += a_max;
a_max = pq.top();
pq.pop();
cnt++;
} else {
if (b + cnt <= n) {
sum += c_max * b;
cnt += b;
} else {
sum += c_max * (n - cnt);
cnt = n;
}
if (!cb.empty()) {
c_max = cb.top().first;
b = cb.top().second;
cb.pop();
} else {
c_max = 0;
b = 0;
}
}
}
cout << sum << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,253 | 853,254 | u156778176 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a;
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a;
mp[a]++;
}
int b, c;
for (int i = 0; i < m; i++) {
cin >> b >> c;
mp[c] += b;
}
long long ans = 0, sum = 0;
for (map<int, int>::reverse_iterator it = mp.rbegin(); it != mp.rend();
it++) {
if (sum >= n)
continue;
ans += it->first * min((int)(n - sum), (int)it->second);
sum += it->second;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a;
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a;
mp[a]++;
}
int b, c;
for (int i = 0; i < m; i++) {
cin >> b >> c;
mp[c] += b;
}
long long ans = 0, sum = 0;
for (map<int, int>::reverse_iterator it = mp.rbegin(); it != mp.rend();
it++) {
if (sum >= n)
continue;
ans += it->first * min((long long)(n - sum), (long long)it->second);
sum += it->second;
}
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,255 | 853,256 | u142234618 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long int s, t, a[100010], b[100010], c[100010];
cin >> s >> t;
for (int i = 0; i < s; i++)
cin >> a[i];
for (int i = 0; i < t; i++) {
cin >> b[i] >> c[i];
}
vector<pair<long long, long long>> p;
for (int i = 0; i < s; i++) {
p.push_back({a[i], 1});
}
for (int i = 0; i < t; i++) {
p.push_back({c[i], b[i]});
}
sort(p.begin(), p.end(), greater<pair<long long int, long long int>>());
int ans = 0, res = 0;
for (auto i : p) {
if (ans + i.second <= s) {
res += i.first * i.second;
ans += i.second;
} else {
res += i.first * (s - ans);
ans = s;
break;
}
}
cout << res << endl;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long int s, t, a[100010], b[100010], c[100010];
cin >> s >> t;
for (int i = 0; i < s; i++)
cin >> a[i];
for (int i = 0; i < t; i++) {
cin >> b[i] >> c[i];
}
vector<pair<long long int, long long int>> p;
for (int i = 0; i < s; i++) {
p.push_back({a[i], 1});
}
for (int i = 0; i < t; i++) {
p.push_back({c[i], b[i]});
}
sort(p.begin(), p.end(), greater<pair<long long int, long long int>>());
long long int ans = 0, res = 0;
for (auto i : p) {
if (ans + i.second <= s) {
res += i.first * i.second;
ans += i.second;
} else {
res += i.first * (s - ans);
ans = s;
break;
}
}
cout << res << endl;
}
| [
"variable_declaration.type.widen.change"
] | 853,269 | 853,270 | u530329977 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int n, m;
cin >> n >> m;
ll s = 0;
vector<pair<ll, ll>> p(m + n);
for (int i = 0; i < m + n; i++) {
if (i < n) {
ll a;
cin >> a;
p[i] = make_pair(a, 1);
} else {
ll b, c;
cin >> b >> c;
p[i] = make_pair(c, b);
}
}
sort(p.begin(), p.end());
int j = 0;
for (int i = m + n - 1; i > 0; i--) {
int t1 = p[i].first, t2 = p[i].second;
if (j + t2 <= n)
s += t1 * t2;
else
s += t1 * (n - j);
j += t2;
if (j >= n)
break;
}
cout << s << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int n, m;
cin >> n >> m;
ll s = 0;
vector<pair<ll, ll>> p(m + n);
for (int i = 0; i < m + n; i++) {
if (i < n) {
ll a;
cin >> a;
p[i] = make_pair(a, 1);
} else {
ll b, c;
cin >> b >> c;
p[i] = make_pair(c, b);
}
}
sort(p.begin(), p.end());
int j = 0;
for (int i = m + n - 1; i > 0; i--) {
ll t1 = p[i].first, t2 = p[i].second;
if (j + t2 <= n)
s += t1 * t2;
else
s += t1 * (n - j);
j += t2;
if (j >= n)
break;
}
cout << s << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 853,284 | 853,285 | u588744968 | cpp |
p03038 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int N, M;
priority_queue<pair<int, int>> que;
int main() {
cin >> N >> M;
int A[N];
int B[M];
int C[M];
vector<int> cands;
for (int i = 0; i < N; i++) {
cin >> A[i];
que.push(make_pair(A[i], 1));
}
for (int i = 0; i < M; i++) {
cin >> B[i] >> C[i];
que.push(make_pair(C[i], B[i]));
}
int ans = 0;
rep(i, N) {
pair<int, int> target = que.top();
que.pop();
if (target.second > 1) {
que.push(make_pair(target.first, target.second - 1));
}
ans += target.first;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int N, M;
priority_queue<pair<int, int>> que;
int main() {
cin >> N >> M;
int A[N];
int B[M];
int C[M];
vector<int> cands;
for (int i = 0; i < N; i++) {
cin >> A[i];
que.push(make_pair(A[i], 1));
}
for (int i = 0; i < M; i++) {
cin >> B[i] >> C[i];
que.push(make_pair(C[i], B[i]));
}
long long ans = 0;
rep(i, N) {
pair<int, int> target = que.top();
que.pop();
if (target.second > 1) {
que.push(make_pair(target.first, target.second - 1));
}
ans += target.first;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 853,290 | 853,291 | u298628832 | cpp |
p03038 | // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back;
#define X first;
#define Y second;
#define pii pair<int, int>;
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
ll poww(ll a, ll b, ll md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
int main() {
int N, M;
vector<pair<int, int>> np;
cin >> N >> M;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
np.push_back(pair<int, int>(a, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
np.push_back(pair<int, int>(c, b));
}
sort(np.begin(), np.end(), greater<pair<int, int>>());
int ans = 0;
int nans = 0;
for (int i = 0; i < np.size(); i++) {
int n = np[i].first;
int nn = np[i].second;
if (nans + nn < N) {
ans += nn * n;
nans += nn;
} else {
ans += (N - nans) * n;
break;
}
}
cout << ans << endl;
}
| // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back;
#define X first;
#define Y second;
#define pii pair<int, int>;
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define int long long
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
ll poww(ll a, ll b, ll md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
signed main() {
int N, M;
vector<pair<int, int>> np;
cin >> N >> M;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
np.push_back(pair<int, int>(a, 1));
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
np.push_back(pair<int, int>(c, b));
}
sort(np.begin(), np.end(), greater<pair<int, int>>());
int ans = 0;
int nans = 0;
for (int i = 0; i < np.size(); i++) {
int n = np[i].first;
int nn = np[i].second;
if (nans + nn < N) {
ans += nn * n;
nans += nn;
} else {
ans += (N - nans) * n;
break;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 853,292 | 853,293 | u433132072 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<pair<int, int>> v(m);
for (int i = 0; i < m; ++i) {
int b, c;
cin >> b >> c;
v[i] = {c, b};
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
vector<int> vv;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < v[i].second; ++j) {
if (vv.size() == n)
goto BREAK;
vv.push_back(v[i].first);
}
}
BREAK:
ll ans = 0;
for (int i = 0; i < n; ++i) {
if (i < vv.size()) {
a[i] = max(a[i], vv[i]);
}
ans += (ll)a[i];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<pair<int, ll>> v(m);
for (int i = 0; i < m; ++i) {
int b;
ll c;
cin >> b >> c;
v[i] = {c, b};
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
vector<ll> vv;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < v[i].second; ++j) {
if (vv.size() == n)
goto BREAK;
vv.push_back(v[i].first);
}
}
BREAK:
ll ans = 0;
for (int i = 0; i < n; ++i) {
if (i < vv.size()) {
a[i] = max(a[i], vv[i]);
}
ans += (ll)a[i];
}
cout << ans << endl;
} | [] | 853,300 | 853,301 | u402472923 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef set<int> si;
typedef pair<int, int> pii;
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define per(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define F first
#define S second
const int INF = 987654321;
const ll MOD = 1000000007LL;
ll ipow(ll base, ll exp) {
ll result = 1LL;
for (;;) {
if (exp & 1)
result *= base;
exp >>= 1;
if (!exp)
break;
base *= base;
}
return result;
}
// const long double PI = (acos(-1));
// const long double EPS = 0.0000000001;
int n, m;
vi a;
map<ll, ll> record;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("in.txt", "r", stdin);
cin >> n >> m;
a.resize(n);
rep(i, 0, n) { cin >> a[i]; }
rep(i, 0, m) {
ll b, c;
cin >> b >> c;
if (record.find(c) != record.end()) {
record[c] += b;
record[c] = max(record[c], (ll)n);
} else {
record[c] = b;
}
}
ll cnt = n;
auto it = record.rbegin();
while (cnt > 0 && it != record.rend()) {
ll b = it->S;
ll c = it->F;
// cout << b << " : " << c << endl;
for (int i = 0; i < b; ++i) {
a.pb(c);
}
cnt -= b;
it++;
}
sort(all(a));
ll total = 0;
per(i, sz(a) - n, sz(a)) { total += (ll)a[i]; }
cout << total << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef set<int> si;
typedef pair<int, int> pii;
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define per(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define F first
#define S second
const int INF = 987654321;
const ll MOD = 1000000007LL;
ll ipow(ll base, ll exp) {
ll result = 1LL;
for (;;) {
if (exp & 1)
result *= base;
exp >>= 1;
if (!exp)
break;
base *= base;
}
return result;
}
// const long double PI = (acos(-1));
// const long double EPS = 0.0000000001;
int n, m;
vi a;
map<ll, ll> record;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("in.txt", "r", stdin);
cin >> n >> m;
a.resize(n);
rep(i, 0, n) { cin >> a[i]; }
rep(i, 0, m) {
ll b, c;
cin >> b >> c;
if (record.find(c) != record.end()) {
record[c] += b;
record[c] = min(record[c], (ll)n);
} else {
record[c] = b;
}
}
ll cnt = n;
auto it = record.rbegin();
while (cnt > 0 && it != record.rend()) {
ll b = it->S;
ll c = it->F;
// cout << b << " : " << c << endl;
for (int i = 0; i < b; ++i) {
a.pb(c);
}
cnt -= b;
it++;
}
sort(all(a));
ll total = 0;
per(i, sz(a) - n, sz(a)) { total += (ll)a[i]; }
cout << total << endl;
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 853,302 | 853,303 | u035566695 | cpp |
p03038 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
vector<P> p(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (int i = 0; i < m; i++) {
ll x, y;
cin >> x >> y;
p[i] = P(y, x);
}
sort(p.begin(), p.end());
bool flag = false;
ll ans = 0;
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < p[i].second && j < a.size(); j++) {
if (a[0] < p[i].first) {
ans += p[i].first;
a.erase(a.begin());
} else {
if (j == 0)
flag = true;
break;
}
}
if (flag)
break;
}
for (int i = 0; i < a.size(); i++) {
ans += a[i];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
vector<P> p(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (int i = 0; i < m; i++) {
ll x, y;
cin >> x >> y;
p[i] = P(y, x);
}
sort(p.begin(), p.end());
bool flag = false;
ll ans = 0;
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < p[i].second && !a.empty(); j++) {
if (a[0] < p[i].first) {
ans += p[i].first;
a.erase(a.begin());
} else {
if (j == 0)
flag = true;
break;
}
}
if (flag)
break;
}
for (int i = 0; i < a.size(); i++) {
ans += a[i];
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.function.change"
] | 853,312 | 853,313 | u351265848 | cpp |
p03038 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
typedef long long ll;
int i;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), B(M), C(M);
rep(i, N) cin >> A[i];
priority_queue<pair<int, int>> g;
rep(i, N) g.push(make_pair(A[i], 1));
rep(i, M) {
cin >> B[i] >> C[i];
g.push(make_pair(C[i], B[i]));
}
int ans = 0;
rep(i, N) {
auto p = g.top();
g.pop();
ans += p.first;
if (p.second > 1) {
p.second--;
g.push(p);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
typedef long long ll;
int i;
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), B(M), C(M);
rep(i, N) cin >> A[i];
priority_queue<pair<int, int>> g;
rep(i, N) g.push(make_pair(A[i], 1));
rep(i, M) {
cin >> B[i] >> C[i];
g.push(make_pair(C[i], B[i]));
}
ll ans = 0;
rep(i, N) {
auto p = g.top();
g.pop();
ans += p.first;
if (p.second > 1) {
p.second--;
g.push(p);
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.change"
] | 853,314 | 853,315 | u979078704 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
typedef long long ll;
const ll INF = 1e17;
const ll BIG = 1000000007;
struct pea {
int b;
int c;
};
bool cmp(pea x, pea y) { return x.c < y.c; }
int main() {
int N, M;
cin >> N >> M;
int a[200000];
pea s[200000];
for (int i = 0; i < N; i++) {
cin >> a[i];
}
sort(a, a + N);
for (int j = 0; j < M; j++) {
cin >> s[j].b >> s[j].c;
}
sort(s, s + M, cmp);
int j = M - 1;
for (int i = 0; i < N; i++) {
if (s[j].c > a[i]) {
a[i] = s[j].c;
} else {
break;
}
s[j].b--;
if (s[j].b == 0) {
j--;
}
if (j < 0) {
break;
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
ans += a[i];
}
cout << ans;
system("PAUSE");
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
typedef long long ll;
const ll INF = 1e17;
const ll BIG = 1000000007;
struct pea {
ll b;
ll c;
};
bool cmp(pea x, pea y) { return x.c < y.c; }
int main() {
int N, M;
cin >> N >> M;
ll a[200000];
pea s[200000];
for (int i = 0; i < N; i++) {
cin >> a[i];
}
sort(a, a + N);
for (int j = 0; j < M; j++) {
cin >> s[j].b >> s[j].c;
}
sort(s, s + M, cmp);
int j = M - 1;
for (int i = 0; i < N; i++) {
if (s[j].c > a[i]) {
a[i] = s[j].c;
} else {
break;
}
s[j].b--;
if (s[j].b == 0) {
j--;
}
if (j < 0) {
break;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += a[i];
}
cout << ans;
system("PAUSE");
} | [
"variable_declaration.type.change"
] | 853,316 | 853,317 | u004411048 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first < b.first;
}
}
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll b;
ll c;
sort(a.begin(), a.end());
vector<pair<ll, ll>> pairs;
for (int i = 0; i < m; i++) {
pair<ll, ll> mypair;
cin >> b;
cin >> c;
mypair = make_pair(b, c);
pairs.push_back(mypair);
}
sort(pairs.begin(), pairs.end(), compare_by_second);
/*for (int i = 0; i < m; i++)
{
cout << pairs[i].first << " " << pairs[i].second << endl;
}*/
vector<ll> changer(n);
for (int i = 0; i < n; i++) {
changer[i] = 0;
}
int index = 0;
int pair_index = 0;
while (index < n && pair_index < m) {
while (pairs[pair_index].first > 0) {
changer[index] = pairs[pair_index].second;
pairs[pair_index].first--;
index++;
}
pair_index++;
}
index = 0;
int index_changer = 0;
while (index < n && index_changer < n) {
if (a[index] < changer[index_changer]) {
a[index] = changer[index_changer];
index++;
index_changer++;
} else {
index++;
}
}
ll sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
cout << sum << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first < b.first;
}
}
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll b;
ll c;
sort(a.begin(), a.end());
vector<pair<ll, ll>> pairs;
for (int i = 0; i < m; i++) {
pair<ll, ll> mypair;
cin >> b;
cin >> c;
mypair = make_pair(b, c);
pairs.push_back(mypair);
}
sort(pairs.begin(), pairs.end(), compare_by_second);
/*for (int i = 0; i < m; i++)
{
cout << pairs[i].first << " " << pairs[i].second << endl;
}*/
vector<ll> changer(n);
for (int i = 0; i < n; i++) {
changer[i] = 0;
}
int index = 0;
int pair_index = 0;
while (index < n && pair_index < m) {
while (pairs[pair_index].first > 0 && index < n) {
changer[index] = pairs[pair_index].second;
pairs[pair_index].first--;
index++;
}
pair_index++;
}
index = 0;
int index_changer = 0;
while (index < n && index_changer < n) {
if (a[index] < changer[index_changer]) {
a[index] = changer[index_changer];
index++;
index_changer++;
} else {
index++;
}
}
ll sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
cout << sum << endl;
} | [
"control_flow.loop.condition.change"
] | 853,321 | 853,322 | u397070717 | cpp |
p03038 | #include <bits/stdc++.h>
#define rt "\n"
#define sp " "
#define test1 cout << "test1" << endl;
#define test2 cout << "test2" << endl;
#define fixprecision(n) \
fixed; \
cout << setprecision(n)
#define kyopro \
ios::sync_with_stdio(false); \
cin.tie(NULL);
#define MOD 1000000007
#define rep(i, s, N) for (ll i{s}; i < N; i++)
using namespace std;
using ll = long long;
using iikae = ll &;
using ld = long double;
using P = pair<ll, ll>;
int main() {
kyopro;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
for (auto &&a : A) {
cin >> a;
}
vector<P> kakikae(M);
ll kakikaesize{};
for (auto &&youso : kakikae) {
cin >> youso.second >> youso.first;
kakikaesize += youso.first;
}
sort(A.begin(), A.end());
sort(kakikae.begin(), kakikae.end(), greater<P>());
for (auto &&a : kakikae) {
// cout << a.first << sp << a.second << rt;
}
ll ranguresu{};
ll ima{};
rep(i, 0, min(N, kakikaesize)) {
if (A.at(i) >= kakikae.at(ima).first) {
// cout << kakikae.at(ima).first;
break;
}
A.at(i) = kakikae.at(ima).first;
ranguresu++;
if (ranguresu >= kakikae.at(ima).second) {
ima++;
ranguresu = 0;
}
}
ll sum{};
rep(i, 0, N) { sum += A.at(i); }
cout << sum << rt;
} | #include <bits/stdc++.h>
#define rt "\n"
#define sp " "
#define test1 cout << "test1" << endl;
#define test2 cout << "test2" << endl;
#define fixprecision(n) \
fixed; \
cout << setprecision(n)
#define kyopro \
ios::sync_with_stdio(false); \
cin.tie(NULL);
#define MOD 1000000007
#define rep(i, s, N) for (ll i{s}; i < N; i++)
using namespace std;
using ll = long long;
using iikae = ll &;
using ld = long double;
using P = pair<ll, ll>;
int main() {
// kyopro;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
for (auto &&a : A) {
cin >> a;
}
vector<P> kakikae(M);
ll kakikaesize{};
for (auto &&youso : kakikae) {
cin >> youso.second >> youso.first;
kakikaesize += youso.second;
}
sort(A.begin(), A.end());
sort(kakikae.begin(), kakikae.end(), greater<P>());
for (auto &&a : kakikae) {
// cout << a.first << sp << a.second << rt;
}
ll ranguresu{};
ll ima{};
rep(i, 0, min(N, kakikaesize)) {
// cout << ima << rt;
if (A.at(i) >= kakikae.at(ima).first) {
// cout << kakikae.at(ima).first;
break;
}
A.at(i) = kakikae.at(ima).first;
ranguresu++;
if (ranguresu >= kakikae.at(ima).second) {
ima++;
ranguresu = 0;
}
}
ll sum{};
rep(i, 0, N) { sum += A.at(i); }
cout << sum << rt;
} | [
"assignment.value.change"
] | 853,333 | 853,334 | u936790121 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool compare_by_second(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first > b.first;
}
int main() {
int n, m;
cin >> n >> m;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<long long, long long>> bc(m);
for (int i = 0; i < m; i++) {
cin >> bc[i].first >> bc[i].second;
}
sort(bc.begin(), bc.end(), compare_by_second);
int sum = 0;
// vector<int> array(1);
for (int i = 0; i < m; i++) {
sum += bc[i].first;
for (int j = 0; j < bc[i].first; j++) {
a.emplace_back(bc[i].second);
}
if (sum > n)
break;
}
sort(a.begin(), a.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[n + sum - 1];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool compare_by_second(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first > b.first;
}
int main() {
int n, m;
cin >> n >> m;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<long long, long long>> bc(m);
for (int i = 0; i < m; i++) {
cin >> bc[i].first >> bc[i].second;
}
sort(bc.begin(), bc.end(), compare_by_second);
int sum = 0;
// vector<int> array(1);
for (int i = 0; i < m; i++) {
sum += bc[i].first;
for (int j = 0; j < bc[i].first; j++) {
a.push_back(bc[i].second);
}
if (sum > n)
break;
}
sort(a.begin(), a.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[n + sum - 1 - i];
}
cout << ans << endl;
return 0;
} | [
"call.function.change",
"assignment.change"
] | 853,344 | 853,345 | u313043608 | cpp |
p03038 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool compare_by_second(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first > b.first;
}
int main() {
int n, m;
cin >> n >> m;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<long long, long long>> bc(m);
for (int i = 0; i < m; i++) {
cin >> bc[i].first >> bc[i].second;
}
sort(bc.begin(), bc.end(), compare_by_second);
int sum = 0;
// vector<int> array(1);
for (int i = 0; i < m; i++) {
sum += bc[i].first;
for (int j = 0; j < bc[i].first; j++) {
a.push_back(bc[i].second);
}
if (sum > n)
break;
}
sort(a.begin(), a.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[n + sum - 1];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool compare_by_second(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first > b.first;
}
int main() {
int n, m;
cin >> n >> m;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<long long, long long>> bc(m);
for (int i = 0; i < m; i++) {
cin >> bc[i].first >> bc[i].second;
}
sort(bc.begin(), bc.end(), compare_by_second);
int sum = 0;
// vector<int> array(1);
for (int i = 0; i < m; i++) {
sum += bc[i].first;
for (int j = 0; j < bc[i].first; j++) {
a.push_back(bc[i].second);
}
if (sum > n)
break;
}
sort(a.begin(), a.end());
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[n + sum - 1 - i];
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 853,346 | 853,345 | u313043608 | cpp |
p03038 | #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
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;
}
// INT_MAX 2,147,483,647 = 2*1.0e9
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) cin >> A[i];
vector<pair<ll, ll>> BC(M);
rep(i, M) {
ll B, C;
cin >> B >> C;
BC.push_back(make_pair(C, B));
}
sort(A.begin(), A.end());
sort(BC.rbegin(), BC.rend());
int pos = 0;
bool done = false;
for (int i = 0; i < M; i++) {
pair<ll, ll> cp = BC[i];
ll cpc = cp.first;
ll cpb = cp.second;
for (int j = 0; j < cpb; j++) {
if (A[pos] < cpc) {
A[pos] = cpc;
pos += 1;
} else {
done = true;
break;
}
if (pos == N - 1) {
done = true;
break;
}
}
if (done)
break;
}
ll ans = 0;
for (int i = 0; i < N; i++)
ans += A[i];
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <deque>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
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;
}
// INT_MAX 2,147,483,647 = 2*1.0e9
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) cin >> A[i];
vector<pair<ll, ll>> BC(M);
rep(i, M) {
ll B, C;
cin >> B >> C;
BC.push_back(make_pair(C, B));
}
sort(A.begin(), A.end());
sort(BC.rbegin(), BC.rend());
int pos = 0;
bool done = false;
for (int i = 0; i < M; i++) {
pair<ll, ll> cp = BC[i];
ll cpc = cp.first;
ll cpb = cp.second;
for (int j = 0; j < cpb; j++) {
if (A[pos] < cpc) {
A[pos] = cpc;
pos += 1;
} else {
done = true;
break;
}
if (pos == N) {
done = true;
break;
}
}
if (done)
break;
}
ll ans = 0;
for (int i = 0; i < N; i++)
ans += A[i];
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 853,351 | 853,352 | u561443723 | cpp |
p03038 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define lpsbd(i, s, b, d) for (size_t i = (s); i < (b); i += (d))
#define lpsb(i, s, b) for (size_t i = (s); i < (b); i++)
#define lpn(i, n) for (size_t i = 0; i < (n); i++)
#define fa(i, x) for (auto &i : x)
#define vcd(t, n, d) vector<t>(n, d)
#define vc(t, n) vector<t>(n)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ull = unsigned long long;
using p = pair<int, int>;
const ull MOD = 1000000007;
int main(void) {
int N, M, B, C;
cin >> N >> M;
auto A = vc(int, N);
int ans = 0;
fa(i, A) {
cin >> i;
ans += i;
}
sort(all(A));
auto cb = vc(p, M);
fa(i, cb) cin >> i.second >> i.first;
sort(all(cb), greater<p>());
auto D = vcd(int, N, -1);
int c = 0;
fa(i, cb) for (; c < N && i.second; i.second--) D[c++] = i.first;
// D.resize(c);
int i;
for (i = 0; i < c && A[i] <= D[i]; i++)
ans += D[i] - A[i];
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define lpsbd(i, s, b, d) for (size_t i = (s); i < (b); i += (d))
#define lpsb(i, s, b) for (size_t i = (s); i < (b); i++)
#define lpn(i, n) for (size_t i = 0; i < (n); i++)
#define fa(i, x) for (auto &i : x)
#define vcd(t, n, d) vector<t>(n, d)
#define vc(t, n) vector<t>(n)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ull = unsigned long long;
using p = pair<int, int>;
const ull MOD = 1000000007;
int main(void) {
int N, M, B, C;
cin >> N >> M;
auto A = vc(int, N);
ull ans = 0;
fa(i, A) {
cin >> i;
ans += i;
}
sort(all(A));
auto cb = vc(p, M);
fa(i, cb) cin >> i.second >> i.first;
sort(all(cb), greater<p>());
auto D = vcd(int, N, -1);
int c = 0;
fa(i, cb) for (; c < N && i.second; i.second--) D[c++] = i.first;
// D.resize(c);
int i;
for (i = 0; i < c && A[i] <= D[i]; i++)
ans += D[i] - A[i];
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 853,353 | 853,354 | u330913290 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.