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 |
|---|---|---|---|---|---|---|---|
p03103 | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); }
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
int arr1[n], arr2[n];
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
++i;
}
cout << res << '\n';
return 0;
} | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<long int, long int> a, pair<long int, long int> b) {
return (a.first < b.first);
}
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
long int arr1[n], arr2[n];
vector<pair<long int, int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
++i;
}
cout << res << '\n';
return 0;
} | [
"variable_declaration.type.widen.change"
] | 910,333 | 910,334 | u551519692 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); }
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
int arr1[n], arr2[n];
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
++i;
}
cout << res << '\n';
return 0;
} | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); }
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
long int arr1[n], arr2[n];
vector<pair<long int, long int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
++i;
}
cout << res << '\n';
return 0;
} | [
"variable_declaration.type.widen.change"
] | 910,333 | 910,335 | u551519692 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); }
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
int arr1[n], arr2[n];
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
i++;
}
cout << res << '\n';
return 0;
} | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); }
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
long int arr1[n], arr2[n];
vector<pair<long int, long int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
++i;
}
cout << res << '\n';
return 0;
} | [
"variable_declaration.type.widen.change"
] | 910,336 | 910,335 | u551519692 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); }
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
int arr1[n], arr2[n];
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
i++;
}
cout << res << '\n';
return 0;
} | #include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
bool sortit(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); }
int main() {
int n, m;
cin >> n >> m;
// insertion into two arrays
long int arr1[n], arr2[n];
vector<pair<long int, long int>> vec;
for (int i = 0; i < n; i++) {
cin >> arr1[i] >> arr2[i];
vec.push_back(make_pair(arr1[i], arr2[i]));
}
// sorting vector on basis of first element
sort(vec.begin(), vec.end(), sortit);
// main code
long long int res = 0;
int i = 0;
while (m != 0) {
if (vec[i].second < m) {
res += (vec[i].first) * (vec[i].second);
m = m - vec[i].second;
} else {
res += (vec[i].first) * m;
m = 0;
}
++i;
}
cout << res << '\n';
return 0;
} | [
"variable_declaration.type.widen.change"
] | 910,337 | 910,335 | u551519692 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> A(N);
vector<long long> B(N);
for (long long i = 0; i < N; i++) {
cin >> A.at(i) >> B.at(i);
}
vector<pair<long long, long long>> p(N);
for (long long i = 0; i < N; i++) {
p.at(i) = make_pair(A.at(i), B.at(i));
}
sort(p.begin(), p.end());
long long sum = 0;
long long cost = 0;
for (int i = 0; i < N; i++) {
sum += p[i].second;
cost += p[i].first * p[i].second;
if (sum > M) {
cost -= p[i].first * (sum - M);
cout << cost << endl;
break;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> A(N);
vector<long long> B(N);
for (long long i = 0; i < N; i++) {
cin >> A.at(i) >> B.at(i);
}
vector<pair<long long, long long>> p(N);
for (long long i = 0; i < N; i++) {
p.at(i) = make_pair(A.at(i), B.at(i));
}
sort(p.begin(), p.end());
long long sum = 0;
long long cost = 0;
for (int i = 0; i < N; i++) {
sum += p[i].second;
cost += p[i].first * p[i].second;
if (sum >= M) {
cost -= p[i].first * (sum - M);
cout << cost << endl;
break;
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,338 | 910,339 | u681084651 | cpp |
p03103 | #include "bits/stdc++.h"
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> prices(n);
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
prices[i] = make_pair(a, b);
}
sort(prices.begin(), prices.end());
int ans = 0;
for (int i = 0; i < n; ++i) {
int numToBuy = min(m, prices[i].second);
ans += numToBuy * prices[i].first;
m -= numToBuy;
if (m == 0)
break;
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> prices(n);
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
prices[i] = make_pair(a, b);
}
sort(prices.begin(), prices.end());
ll ans = 0;
for (int i = 0; i < n; ++i) {
ll numToBuy = min(m, prices[i].second);
ans += numToBuy * prices[i].first;
m -= numToBuy;
if (m == 0)
break;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 910,357 | 910,358 | u616461826 | cpp |
p03103 | using namespace std;
#include <bits/stdc++.h>
int main() {
long long N, M;
cin >> N >> M;
vector<pair<long long, long long>> A(N);
for (long long i = 0; i < N; i++) {
cin >> A.at(i).first >> A.at(i).second;
}
sort(A.begin(), A.end());
long long price = 0; //かかった金額
long long Juice = 0; //買った本数
for (long long i = 0; i < N; i++) {
if (Juice + A.at(i).second < M) {
Juice += A.at(i).second;
price += A.at(i).first * A.at(i).second;
} else {
while (Juice <= M) {
price += A.at(i).first;
Juice++;
}
}
}
cout << price << endl;
} | using namespace std;
#include <bits/stdc++.h>
int main() {
long long N, M;
cin >> N >> M;
vector<pair<long long, long long>> A(N);
for (long long i = 0; i < N; i++) {
cin >> A.at(i).first >> A.at(i).second;
}
sort(A.begin(), A.end());
long long price = 0; //かかった金額
long long Juice = 0; //買った本数
for (long long i = 0; i < N; i++) {
if (Juice + A.at(i).second < M) {
Juice += A.at(i).second;
price += A.at(i).first * A.at(i).second;
} else {
while (Juice < M) {
price += A.at(i).first;
Juice++;
}
}
}
cout << price << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 910,359 | 910,360 | u615258936 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
map<long long, long long> AB;
for (long long i = 0; i < N; ++i) {
long long a, b;
cin >> a >> b;
AB.insert(make_pair(a, b));
}
long long money = 0;
long long rest_drink = M; // 残り本数
for (auto itr = AB.begin(); itr != AB.end(); ++itr) {
if (rest_drink <= itr->second) {
money += itr->first * rest_drink;
break;
}
if (rest_drink > itr->second) {
money += itr->first * itr->second;
rest_drink = rest_drink - itr->second;
}
}
cout << money << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
multimap<long long, long long> AB;
for (long long i = 0; i < N; ++i) {
long long a, b;
cin >> a >> b;
AB.insert(make_pair(a, b));
}
long long money = 0;
long long rest_drink = M; // 残り本数
for (auto itr = AB.begin(); itr != AB.end(); ++itr) {
if (rest_drink <= itr->second) {
money += itr->first * rest_drink;
break;
}
if (rest_drink > itr->second) {
money += itr->first * itr->second;
rest_drink = rest_drink - itr->second;
}
}
cout << money << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 910,372 | 910,373 | u774160580 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long long int llint;
typedef pair<ll, ll> pa;
#define MM 1000000000
#define MOD MM + 7
#define MAX 101000
#define MAP 110
#define initial_value -1
#define Pair pair<int, int>
#define chmax(a, b) (a < b ? a = b : 0)
#define chmin(a, b) (a > b ? a = b : 0)
#define INF (1 << 29) // 536870912
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
ll N, M;
ll a, b;
vector<pa> P;
int main() {
cin >> N >> M;
ll num = M;
for (int i = 0; i < N; i++) {
cin >> a >> b;
P.push_back(pa(a, b));
}
sort(P.begin(), P.end());
ll ans = 0;
for (int i = 0; i < N; i++) {
if (num <= P[i].first) {
ans += num * P[i].second;
num = 0;
break;
} else {
ans += P[i].first * P[i].second;
num -= P[i].second;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long long int llint;
typedef pair<ll, ll> pa;
#define MM 1000000000
#define MOD MM + 7
#define MAX 101000
#define MAP 110
#define initial_value -1
#define Pair pair<int, int>
#define chmax(a, b) (a < b ? a = b : 0)
#define chmin(a, b) (a > b ? a = b : 0)
#define INF (1 << 29) // 536870912
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
ll N, M;
ll a, b;
vector<pa> P;
int main() {
cin >> N >> M;
ll num = M;
for (int i = 0; i < N; i++) {
cin >> a >> b;
P.push_back(pa(a, b));
}
sort(P.begin(), P.end());
ll ans = 0;
for (int i = 0; i < N; i++) {
if (num <= P[i].second) {
ans += num * P[i].first;
num = 0;
break;
} else {
ans += P[i].first * P[i].second;
num -= P[i].second;
}
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 910,383 | 910,384 | u342051078 | cpp |
p03103 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
using namespace std;
using ll = long long;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i != -1; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RBF(i, n) for (auto &i : n)
#define ABS(n) (n < 0 ? -n : n)
#define MIN(a, b) (a < b ? a : b)
#define MAX(a, b) (a > b ? a : b)
#define IN(n) (cin >> n)
#define OUT(n) (cout << n << "\n")
#define INF 1e9
#define ALL(v) (v).begin(), (v).end()
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> X(N);
REP(i, N) {
cin >> X[i].first;
cin >> X[i].second;
}
sort(ALL(X));
int cnt = M;
int ans = 0;
while (cnt > 0) {
static int i = 0;
if (cnt > X[i].second) {
ans += X[i].first * X[i].second;
cnt -= X[i].second;
} else {
ans += X[i].first * cnt;
cnt = 0;
}
++i;
}
OUT(ans);
} | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
using namespace std;
using ll = long long;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i != -1; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define RBF(i, n) for (auto &i : n)
#define ABS(n) (n < 0 ? -n : n)
#define MIN(a, b) (a < b ? a : b)
#define MAX(a, b) (a > b ? a : b)
#define IN(n) (cin >> n)
#define OUT(n) (cout << n << "\n")
#define INF 1e9
#define ALL(v) (v).begin(), (v).end()
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> X(N);
REP(i, N) {
cin >> X[i].first;
cin >> X[i].second;
}
sort(ALL(X));
ll cnt = M;
ll ans = 0;
while (cnt > 0) {
static int i = 0;
if (cnt > X[i].second) {
ans += X[i].first * X[i].second;
cnt -= X[i].second;
} else {
ans += X[i].first * cnt;
cnt = 0;
}
++i;
}
OUT(ans);
} | [
"variable_declaration.type.change"
] | 910,389 | 910,390 | u431929942 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
} else if (b == 0) {
return a;
} else {
if (a < b)
return gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
}
ll ketasum(ll n) {
ll sum = 0;
if (n < 0)
return 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
typedef pair<ll, ll> pair_t;
bool comp(const pair_t &a, const pair_t &b) { return a.first < b.first; }
void sort2vectors(vector<ll> &av, vector<ll> &bv) {
ll n = av.size();
vector<pair_t> p(n);
vector<ll> av2(n), bv2(n);
for (ll i = 0; i < n; i++)
p[i] = make_pair(av[i], bv[i]);
sort(p.begin(), p.end(), comp);
for (ll i = 0; i < n; i++) {
av2[i] = p[i].first;
bv2[i] = p[i].second;
}
av = av2;
bv = bv2;
}
int main() {
ll N, M;
cin >> N >> M;
vl A(N);
vl B(N);
REP(i, N) { cin >> A[i] >> B[i]; }
sort2vectors(A, B);
ll tmp = 0;
ll ans = 0;
REP(i, N) {
if (B[i] + tmp >= M) {
cout << ans + A[i] * (M - tmp) << endl;
} else {
ans += A[i] * B[i];
tmp += B[i];
}
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
ll gcd(ll a, ll b) {
if (a == 0) {
return b;
} else if (b == 0) {
return a;
} else {
if (a < b)
return gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
}
ll ketasum(ll n) {
ll sum = 0;
if (n < 0)
return 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
typedef pair<ll, ll> pair_t;
bool comp(const pair_t &a, const pair_t &b) { return a.first < b.first; }
void sort2vectors(vector<ll> &av, vector<ll> &bv) {
ll n = av.size();
vector<pair_t> p(n);
vector<ll> av2(n), bv2(n);
for (ll i = 0; i < n; i++)
p[i] = make_pair(av[i], bv[i]);
sort(p.begin(), p.end(), comp);
for (ll i = 0; i < n; i++) {
av2[i] = p[i].first;
bv2[i] = p[i].second;
}
av = av2;
bv = bv2;
}
int main() {
ll N, M;
cin >> N >> M;
vl A(N);
vl B(N);
REP(i, N) { cin >> A[i] >> B[i]; }
sort2vectors(A, B);
ll tmp = 0;
ll ans = 0;
REP(i, N) {
if (B[i] + tmp >= M) {
cout << ans + A[i] * (M - tmp) << endl;
break;
} else {
ans += A[i] * B[i];
tmp += B[i];
}
}
} | [
"control_flow.break.add"
] | 910,403 | 910,404 | u313994303 | cpp |
p03103 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 3e18 + 7
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
typedef vector<unsigned int> vec;
typedef vector<vec> mat;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline void add(T &a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const double PI = acos(-1.0);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<P> A(N);
REP(i, N) cin >> A[i].first >> A[i].second;
ll sum = 0;
VSORT(A);
REP(i, N) {
if (A[i].second >= M) {
sum += M * A[i].first;
break;
} else {
sum += A[i].first * A[i].second;
M -= A[i].second;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 3e18 + 7
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
typedef vector<unsigned int> vec;
typedef vector<vec> mat;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline void add(T &a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const double PI = acos(-1.0);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<LP> A(N);
REP(i, N) cin >> A[i].first >> A[i].second;
ll sum = 0;
VSORT(A);
REP(i, N) {
if (A[i].second >= M) {
sum += M * A[i].first;
break;
} else {
sum += A[i].first * A[i].second;
M -= A[i].second;
}
}
cout << sum << endl;
} | [
"variable_declaration.type.change"
] | 910,412 | 910,413 | u493750228 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> P(N);
for (int i = 0; i < N; i++) {
cin >> P.at(i).first >> P.at(i).second;
}
sort(P.begin(), P.end());
int sum = M, money = 0;
ll cost = 0;
for (int i = 0; i < N; i++) {
money = min(sum, P.at(i).second);
cost += money * P.at(i).first;
sum -= money;
if (sum == 0) {
break;
}
}
cout << cost << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> P(N);
for (int i = 0; i < N; i++) {
cin >> P.at(i).first >> P.at(i).second;
}
sort(P.begin(), P.end());
ll sum = M, money = 0;
ll cost = 0;
for (int i = 0; i < N; i++) {
money = min(sum, P.at(i).second);
cost += money * P.at(i).first;
sum -= money;
if (sum == 0) {
break;
}
}
cout << cost << endl;
} | [
"variable_declaration.type.change"
] | 910,414 | 910,415 | u822169805 | cpp |
p03103 | #include <bits/stdc++.h>
#define inf 0x3f3f3f3f
#define pb push_back
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<ull> vu;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
int n, m;
vpi v;
void read() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
v.pb({a, b});
}
}
bool cmp(pi a, pi b) { return a.first < b.first; }
void solve() {
sort(v.begin(), v.end(), cmp);
ll pr = 0;
for (int i = 0; i < n && m > 0; ++i) {
int nr = min(m, v[i].second);
pr += nr * v[i].first;
m -= nr;
}
cout << pr;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
// cin >> t; //please do not forget to comment this if there are no queries
while (t) {
--t;
read();
solve();
}
return 0;
}
| #include <bits/stdc++.h>
#define inf 0x3f3f3f3f
#define pb push_back
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<ull> vu;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
int n, m;
vpi v;
void read() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
v.pb({a, b});
}
}
bool cmp(pi a, pi b) { return a.first < b.first; }
void solve() {
sort(v.begin(), v.end(), cmp);
ll pr = 0;
for (int i = 0; i < n && m > 0; ++i) {
int nr = min(m, v[i].second);
pr += 1ll * nr * v[i].first;
m -= nr;
}
cout << pr;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
// cin >> t; //please do not forget to comment this if there are no queries
while (t) {
--t;
read();
solve();
}
return 0;
}
| [
"assignment.change"
] | 910,422 | 910,423 | u519883882 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define INF 999999999
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb(n) push_back(n)
#define Sort(n) sort(n.begin(), n.end())
#define Out(S) cout << S << endl
#define Vecpr vector<pair<int, int>>
int main() {
lli A, B, C, D = 0;
cin >> B >> A;
Vecpr P(B);
rep(i, B) cin >> P[i].first >> P[i].second;
Sort(P);
rep(i, B) {
if (A >= P[i].second) {
D += P[i].first * P[i].second;
A -= P[i].second;
} else {
D += P[i].first * A;
break;
}
}
Out(D);
} | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define INF 999999999
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb(n) push_back(n)
#define Sort(n) sort(n.begin(), n.end())
#define Out(S) cout << S << endl
#define Vecpr vector<pair<lli, lli>>
int main() {
lli A, B, C, D = 0;
cin >> B >> A;
Vecpr P(B);
rep(i, B) cin >> P[i].first >> P[i].second;
Sort(P);
rep(i, B) {
if (A >= P[i].second) {
D += P[i].first * P[i].second;
A -= P[i].second;
} else {
D += P[i].first * A;
break;
}
}
Out(D);
} | [
"preprocessor.define.value.change"
] | 910,430 | 910,431 | u618604643 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
long long int n, m;
long long int a, b;
vector<pair<long long int, long long int>> s;
int res = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
s.push_back(make_pair(a, b));
}
sort(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if (m == 0) {
break;
}
long long int can = min(s[i].second, m);
res += (can * s[i].first);
m -= can;
}
cout << res << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
long long int n, m;
long long int a, b;
vector<pair<long long int, long long int>> s;
long long int res = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
s.push_back(make_pair(a, b));
}
sort(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if (m == 0) {
break;
}
long long int can = min(s[i].second, m);
res += (can * s[i].first);
m -= can;
}
cout << res << '\n';
return 0;
} | [
"variable_declaration.type.widen.change"
] | 910,432 | 910,433 | u365058393 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
long long int n, m;
long long int a, b;
vector<pair<long long int, long long int>> s;
int res = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
s.push_back(make_pair(a, b));
}
sort(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if (m == 0) {
break;
}
int can = min(s[i].second, m);
res += (can * s[i].first);
m -= can;
}
cout << res << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
long long int n, m;
long long int a, b;
vector<pair<long long int, long long int>> s;
long long int res = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
s.push_back(make_pair(a, b));
}
sort(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if (m == 0) {
break;
}
long long int can = min(s[i].second, m);
res += (can * s[i].first);
m -= can;
}
cout << res << '\n';
return 0;
} | [
"variable_declaration.type.widen.change"
] | 910,434 | 910,433 | u365058393 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define int long long
int $(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
signed main() {
int a, b, d = 0;
cin >> a >> b;
vector<pair<int, int>> c(a);
for (int i = 0; i < a; i++)
cin >> c.at(i).first >> c.at(i).second;
sort(c.begin(), c.end());
for (int i = 0; b > 0; i++) {
if (b >= c.at(i).second) {
b -= c.at(i).second;
d += c.at(i).second * c.at(i).first;
} else {
d += b * c.at(i).first;
}
}
cout << d << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int $(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
signed main() {
int a, b, d = 0;
cin >> a >> b;
vector<pair<int, int>> c(a);
for (int i = 0; i < a; i++)
cin >> c.at(i).first >> c.at(i).second;
sort(c.begin(), c.end());
for (int i = 0; b > 0; i++) {
if (b >= c.at(i).second) {
b -= c.at(i).second;
d += c.at(i).second * c.at(i).first;
} else {
d += b * c.at(i).first;
break;
}
}
cout << d << endl;
}
| [
"control_flow.break.add"
] | 910,435 | 910,436 | u322177979 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 10;
using pq = pair<int, int>;
int main() {
int n, m;
priority_queue<pq, vector<pq>, greater<pq>> que;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
que.push(make_pair(a, b));
}
long long res = 0;
while (!que.empty()) {
pq p = que.top();
que.pop();
if (m - p.second > 0) {
res += p.first * p.second;
m -= p.second;
} else {
res += p.first * m;
break;
}
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 10;
using pq = pair<long, long>;
int main() {
int n, m;
priority_queue<pq, vector<pq>, greater<pq>> que;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
que.push(make_pair(a, b));
}
long long res = 0;
while (!que.empty()) {
pq p = que.top();
que.pop();
if (m - p.second > 0) {
res += p.first * p.second;
m -= p.second;
} else {
res += p.first * m;
break;
}
}
cout << res << endl;
} | [
"variable_declaration.type.primitive.change"
] | 910,440 | 910,441 | u835629653 | cpp |
p03103 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define swap(a, b) \
a ^= b; \
b ^= a; \
a ^= b;
#define chmax(a, b) \
{ \
if (a < b) \
a = b; \
}
#define chmin(a, b) \
{ \
if (a > b) \
a = b; \
}
using namespace std;
typedef long long ll;
ll gcd(ll, ll);
vector<bool> to_binary(int);
int sum(vector<int>);
int min(vector<int>);
int max(vector<int>);
ll nCr(ll n, ll r);
const ll INF = 1LL << 60;
ll nCr(ll n, ll r) {
ll res = 1;
for (int i = 0; i < r; i++) {
res *= (n - i);
}
for (int i = 1; i <= r; i++) {
res /= i;
}
return res;
}
int vsum(vector<int> v) {
int res = 0;
for (auto it = v.begin(); it != v.end(); it++)
res += *it;
return res;
}
int vmin(vector<int> v) {
int min = INT32_MAX;
for (auto it = v.begin(); it != v.end(); it++)
min = std::min(min, *it);
return min;
}
int vmax(vector<int> v) {
int max = 0;
for (auto it = v.begin(); it != v.end(); it++)
max = std::max(max, *it);
return max;
}
ll gcd(ll A, ll B) {
int r = A % B;
while (r != 0) {
A = B;
B = r;
r = A % B;
}
return B;
}
vector<bool> to_binary(int x) {
vector<bool> res;
while (x != 0) {
res.push_back(x % 2);
x /= 2;
}
return res;
}
typedef tuple<ll, ll> mtp;
bool mycomp(mtp x, mtp y) { return get<0>(x) < get<0>(y); }
int main(void) {
ll N, M;
cin >> N >> M;
vector<mtp> Stores(N);
int a, b;
rep(i, N) {
cin >> a >> b;
Stores[i] = (mtp)make_pair(a, b);
}
sort(Stores.begin(), Stores.end(), mycomp);
int ans = 0;
for (auto v : Stores) {
ans += get<0>(v) * std::min(get<1>(v), M);
M -= get<1>(v);
if (M <= 0)
break;
}
cout << ans << endl;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define swap(a, b) \
a ^= b; \
b ^= a; \
a ^= b;
#define chmax(a, b) \
{ \
if (a < b) \
a = b; \
}
#define chmin(a, b) \
{ \
if (a > b) \
a = b; \
}
using namespace std;
typedef long long ll;
ll gcd(ll, ll);
vector<bool> to_binary(int);
int sum(vector<int>);
int min(vector<int>);
int max(vector<int>);
ll nCr(ll n, ll r);
const ll INF = 1LL << 60;
ll nCr(ll n, ll r) {
ll res = 1;
for (int i = 0; i < r; i++) {
res *= (n - i);
}
for (int i = 1; i <= r; i++) {
res /= i;
}
return res;
}
int vsum(vector<int> v) {
int res = 0;
for (auto it = v.begin(); it != v.end(); it++)
res += *it;
return res;
}
int vmin(vector<int> v) {
int min = INT32_MAX;
for (auto it = v.begin(); it != v.end(); it++)
min = std::min(min, *it);
return min;
}
int vmax(vector<int> v) {
int max = 0;
for (auto it = v.begin(); it != v.end(); it++)
max = std::max(max, *it);
return max;
}
ll gcd(ll A, ll B) {
int r = A % B;
while (r != 0) {
A = B;
B = r;
r = A % B;
}
return B;
}
vector<bool> to_binary(int x) {
vector<bool> res;
while (x != 0) {
res.push_back(x % 2);
x /= 2;
}
return res;
}
typedef tuple<ll, ll> mtp;
bool mycomp(mtp x, mtp y) { return get<0>(x) < get<0>(y); }
int main(void) {
ll N, M;
cin >> N >> M;
vector<mtp> Stores(N);
int a, b;
rep(i, N) {
cin >> a >> b;
Stores[i] = (mtp)make_pair(a, b);
}
sort(Stores.begin(), Stores.end(), mycomp);
ll ans = 0;
for (auto v : Stores) {
ans += get<0>(v) * std::min(get<1>(v), M);
M -= get<1>(v);
if (M <= 0)
break;
}
cout << ans << endl;
}
| [
"variable_declaration.type.change"
] | 910,449 | 910,450 | u040251933 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef vector<int> VI;
const ll MOD = 1000000007;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
int main() {
int n, m;
cin >> n >> m;
vector<P> ab(n);
REP(i, n)
cin >> ab[i].first >> ab[i].second;
sort(ALL(ab));
int ans = 0;
REP(i, n) {
if (m - ab[i].second <= 0) {
ans += m * ab[i].first;
cout << ans;
return 0;
}
ans += ab[i].first * ab[i].second;
m -= ab[i].second;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef vector<int> VI;
const ll MOD = 1000000007;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
int main() {
int n, m;
cin >> n >> m;
vector<P> ab(n);
REP(i, n)
cin >> ab[i].first >> ab[i].second;
sort(ALL(ab));
ll ans = 0;
REP(i, n) {
if (m - ab[i].second <= 0) {
ans += m * ab[i].first;
cout << ans;
return 0;
}
ans += ab[i].first * ab[i].second;
m -= ab[i].second;
}
} | [
"variable_declaration.type.change"
] | 910,455 | 910,456 | u408650734 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
int main() {
int n;
cin >> n;
int m;
cin >> m;
vector<pair<long long int, int>> a(n);
for (int i = 0; i < n; i++) {
long long int c;
int b;
cin >> c >> b;
a[i] = {c, b};
}
sort(a.begin(), a.end());
int price = 0, bottle = 0;
for (int i = 0; i < n; i++) {
if (bottle + a[i].second > m) {
price += a[i].first * (m - bottle);
break;
} else {
bottle += a[i].second;
price += (a[i].first) * (a[i].second);
}
}
cout << price << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
int main() {
int n;
cin >> n;
int m;
cin >> m;
vector<pair<long long int, int>> a(n);
for (int i = 0; i < n; i++) {
long long int c;
int b;
cin >> c >> b;
a[i] = {c, b};
}
sort(a.begin(), a.end());
long long int price = 0, bottle = 0;
for (int i = 0; i < n; i++) {
if (bottle + a[i].second > m) {
price += a[i].first * (m - bottle);
break;
} else {
bottle += a[i].second;
price += (a[i].first) * (a[i].second);
}
}
cout << price << endl;
return 0;
}
| [
"variable_declaration.type.widen.change"
] | 910,464 | 910,465 | u264405855 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
const bool debug = false;
#define DEBUG if (debug == true)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ll n, m;
int main(void) {
cin >> n >> m;
vector<pair<ll, ll>> ab;
rep(i, n) {
ll tmpa, tmpb;
cin >> tmpa >> tmpb;
ab.push_back(make_pair(tmpa, tmpb));
}
sort(ab.begin(), ab.end());
ll cnt = 0, cur = 0;
ll res = 0;
while (true) {
if (res + ab[cur].second >= m) {
res += ab[cur].first * (m - cnt);
break;
} else {
res += ab[cur].first * ab[cur].second;
cnt += ab[cur].second;
cur++;
}
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
const bool debug = false;
#define DEBUG if (debug == true)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ll n, m;
int main(void) {
cin >> n >> m;
vector<pair<ll, ll>> ab;
rep(i, n) {
ll tmpa, tmpb;
cin >> tmpa >> tmpb;
ab.push_back(make_pair(tmpa, tmpb));
}
sort(ab.begin(), ab.end());
ll cnt = 0, cur = 0;
ll res = 0;
while (true) {
if (cnt + ab[cur].second >= m) {
res += ab[cur].first * (m - cnt);
break;
} else {
res += ab[cur].first * ab[cur].second;
cnt += ab[cur].second;
cur++;
}
}
cout << res << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 910,475 | 910,476 | u076566148 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define in insert
#define speed \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
const int INF = 1e9 + 5;
bool f(pair<ll, ll> l, pair<ll, ll> r) { return l.f < r.f; }
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
ll x, y;
cin >> x >> y;
v.pb(mp(x, y));
}
sort(v.begin(), v.end(), f);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (m > v[i].s) {
m -= v[i].s;
cnt += v[i].f * v[i].s;
} else {
cnt += m * v[i].f;
break;
}
}
cout << cnt;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define in insert
#define speed \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
const int INF = 1e9 + 5;
bool f(pair<ll, ll> l, pair<ll, ll> r) { return l.f < r.f; }
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
ll x, y;
cin >> x >> y;
v.pb(mp(x, y));
}
sort(v.begin(), v.end(), f);
ll cnt = 0;
for (int i = 0; i < n; i++) {
if (m > v[i].s) {
m -= v[i].s;
cnt += v[i].f * v[i].s;
} else {
cnt += m * v[i].f;
break;
}
}
cout << cnt;
} | [
"variable_declaration.type.change"
] | 910,482 | 910,483 | u843739531 | cpp |
p03103 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
vector<pair<ll, ll>> S(N);
for (int i = 0; i < N; ++i) {
ll a, b;
cin >> a >> b;
S[i].first = a;
S[i].second = b;
}
sort(S.begin(), S.end());
ll ans = 0LL;
int cnt = 0;
int j = 0;
while (true) {
if ((cnt + S[j].second) >= M) {
cnt = M;
ans += (M - cnt) * S[j].first;
break;
} else {
cnt += S[j].second;
ans += S[j].first * S[j].second;
++j;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
vector<pair<ll, ll>> S(N);
for (int i = 0; i < N; ++i) {
ll a, b;
cin >> a >> b;
S[i].first = a;
S[i].second = b;
}
sort(S.begin(), S.end());
ll ans = 0LL;
int cnt = 0;
int j = 0;
while (true) {
if ((cnt + S[j].second) >= M) {
ans += (M - cnt) * S[j].first;
break;
} else {
cnt += S[j].second;
ans += S[j].first * S[j].second;
++j;
}
}
cout << ans << endl;
return 0;
}
| [] | 910,484 | 910,485 | u577747009 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
vector<pair<int, int>> a(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i) >> B.at(i);
}
for (int i = 0; i < N; i++) {
a.at(i) = {A.at(i), B.at(i)};
}
sort(a.begin(), a.end());
int c = 0;
for (int i = 0; i < N; i++) {
if (M >= a.at(i).second) {
M -= a.at(i).second;
c += a.at(i).first * a.at(i).second;
} else {
c += M * a.at(i).first;
break;
}
}
cout << c << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
vector<pair<long int, long int>> a(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i) >> B.at(i);
}
for (int i = 0; i < N; i++) {
a.at(i) = {A.at(i), B.at(i)};
}
sort(a.begin(), a.end());
long int c = 0;
for (int i = 0; i < N; i++) {
if (M >= a.at(i).second) {
M -= a.at(i).second;
c += a.at(i).first * a.at(i).second;
} else {
c += M * a.at(i).first;
break;
}
}
cout << c << endl;
}
| [
"variable_declaration.type.widen.change"
] | 910,486 | 910,487 | u157677852 | cpp |
p03103 | #include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
using namespace std;
struct S_info {
int a, b;
};
int compare(const void *pEle1, const void *pEle2) {
const S_info *pmem1 = (const S_info *)pEle1;
const S_info *pmem2 = (const S_info *)pEle2;
return (pmem1->a - pmem2->a);
}
int main() {
int n, m;
cin >> n >> m;
S_info info[n];
for (int i = 0; i < n; i++) {
cin >> info[i].a >> info[i].b;
}
qsort(info, n, sizeof *info, compare);
long long int m_sum = 0;
int tmp = 0;
int index;
for (int i = 0; i < n; i++) {
tmp += info[i].b;
if (tmp >= m) {
tmp -= info[i].b;
index = i;
break;
}
m_sum += info[i].a * info[i].b;
}
if (tmp == m) {
cout << m_sum << endl;
} else {
cout << m_sum + (m - tmp) * info[index].a << endl;
}
return 0;
} | #include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
using namespace std;
struct S_info {
long long int a, b;
};
int compare(const void *pEle1, const void *pEle2) {
const S_info *pmem1 = (const S_info *)pEle1;
const S_info *pmem2 = (const S_info *)pEle2;
return (pmem1->a - pmem2->a);
}
int main() {
long long int n, m;
cin >> n >> m;
S_info info[n];
for (int i = 0; i < n; i++) {
cin >> info[i].a >> info[i].b;
}
qsort(info, n, sizeof *info, compare);
long long int m_sum = 0;
long long int tmp = 0;
int index;
for (int i = 0; i < n; i++) {
tmp += info[i].b;
if (tmp >= m) {
tmp -= info[i].b;
index = i;
break;
}
m_sum += info[i].a * info[i].b;
}
if (tmp == m) {
cout << m_sum << endl;
} else {
cout << m_sum + (m - tmp) * info[index].a << endl;
}
return 0;
} | [
"variable_declaration.type.widen.change"
] | 910,488 | 910,489 | u417660734 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
vector<pair<int, int>> drink(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
drink[i] = make_pair(a, b);
}
sort(drink.begin(), drink.end());
int k = 0;
while (m > 0) {
ans += (drink[k].first) * min(m, drink[k].second);
m -= drink[k].second;
k++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
long long ans = 0;
vector<pair<long, long>> drink(n);
for (int i = 0; i < n; i++) {
long a, b;
cin >> a >> b;
drink[i] = make_pair(a, b);
}
sort(drink.begin(), drink.end());
int k = 0;
while (m > 0) {
ans += (drink[k].first) * min(m, drink[k].second);
m -= drink[k].second;
k++;
}
cout << ans;
} | [
"variable_declaration.type.primitive.change"
] | 910,496 | 910,497 | u885523920 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long ans = 0;
vector<pair<int, int>> drink(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
drink[i] = make_pair(a, b);
}
sort(drink.begin(), drink.end());
int k = 0;
while (m > 0) {
ans += (drink[k].first) * min(m, drink[k].second);
m -= drink[k].second;
k++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
long long ans = 0;
vector<pair<long, long>> drink(n);
for (int i = 0; i < n; i++) {
long a, b;
cin >> a >> b;
drink[i] = make_pair(a, b);
}
sort(drink.begin(), drink.end());
int k = 0;
while (m > 0) {
ans += (drink[k].first) * min(m, drink[k].second);
m -= drink[k].second;
k++;
}
cout << ans;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,498 | 910,497 | u885523920 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<long long, long long>> shop;
int n, m;
cin >> n >> m;
int num = 0;
long long sum = 0;
for (auto i = 0; i < n; i++) {
pair<long long, long long> p;
long long a, b;
cin >> a >> b;
p.first = a;
p.second = b;
shop.push_back(p);
}
sort(shop.begin(), shop.end());
for (auto i = 0; i < n; i++) {
if (sum + shop[i].second >= m) {
sum += shop[i].first * (m - num);
break;
} else {
num += shop[i].second;
sum += shop[i].first * shop[i].second;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<long long, long long>> shop;
int n, m;
cin >> n >> m;
int num = 0;
long long sum = 0;
for (auto i = 0; i < n; i++) {
pair<long long, long long> p;
long long a, b;
cin >> a >> b;
p.first = a;
p.second = b;
shop.push_back(p);
}
sort(shop.begin(), shop.end());
for (auto i = 0; i < n; i++) {
if (num + shop[i].second >= m) {
sum += shop[i].first * (m - num);
break;
} else {
num += shop[i].second;
sum += shop[i].first * shop[i].second;
}
}
cout << sum << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 910,499 | 910,500 | u679245300 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
vector<pair<long long int, long long int>> ab;
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
ab.push_back(make_pair(a, b));
}
sort(ab.begin(), ab.end());
long long int count = 0;
long long int ans = 0;
int i = 0;
if (n == 1) {
ans = ab[i].first * m;
cout << ans << endl;
return 0;
}
while (count != m) {
if (m - count - ab[i].second > 0) {
count += ab[i].second;
ans += ab[i].first * ab[i].second;
} else if (m - count - ab[i].second < 0) {
int c = m - count;
ans += ab[i].first * c;
count = m;
}
i++;
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
vector<pair<long long int, long long int>> ab;
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
ab.push_back(make_pair(a, b));
}
sort(ab.begin(), ab.end());
long long int count = 0;
long long int ans = 0;
int i = 0;
if (n == 1) {
ans = ab[i].first * m;
cout << ans << endl;
return 0;
}
while (count != m) {
if (m - count - ab[i].second >= 0) {
count += ab[i].second;
ans += ab[i].first * ab[i].second;
} else if (m - count - ab[i].second < 0) {
int c = m - count;
ans += ab[i].first * c;
count = m;
}
i++;
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,501 | 910,502 | u115819033 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> AB(N);
for (int i = 0; i < N; i++) {
cin >> AB[i].first >> AB[i].second;
}
sort(AB.begin(), AB.end());
ll sum = 0;
ll cnt = 0;
int i = 0;
while (cnt < M) {
sum += AB[i].first * AB[i].second;
cnt += AB[i].second;
i++;
}
sum -= AB[i - 1].first * (M - cnt);
cout << sum << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> AB(N);
for (int i = 0; i < N; i++) {
cin >> AB[i].first >> AB[i].second;
}
sort(AB.begin(), AB.end());
ll sum = 0;
ll cnt = 0;
int i = 0;
while (cnt < M) {
sum += AB[i].first * AB[i].second;
cnt += AB[i].second;
i++;
}
sum -= AB[i - 1].first * (cnt - M);
cout << sum << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 910,509 | 910,510 | u904123392 | cpp |
p03103 | #include <algorithm>
#include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> AB(N);
for (int j = 0; j < N; j++) {
AB[j] = make_pair(A[j], B[j]);
}
long long sum;
sort(AB.begin(), AB.end());
// ABをAの小さい順にソート
for (int k = 0; k < N; k++) {
if (M > AB[k].second) {
sum += (long long)AB[k].first * AB[k].second;
M -= AB[k].second;
continue;
} else {
sum += (long long)AB[k].first * M;
break;
}
}
cout << sum << endl;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> AB(N);
for (int j = 0; j < N; j++) {
AB[j] = make_pair(A[j], B[j]);
}
long long sum = 0;
sort(AB.begin(), AB.end());
// ABをAの小さい順にソート
for (int k = 0; k < N; k++) {
if (M > AB[k].second) {
sum += (long long)AB[k].first * AB[k].second;
M -= AB[k].second;
continue;
} else {
sum += (long long)AB[k].first * M;
break;
}
}
cout << sum << endl;
}
| [
"variable_declaration.value.change"
] | 910,511 | 910,512 | u904123392 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i].first >> A[i].second;
}
sort(A.begin(), A.end());
int sum = 0;
long mon = 0;
int i = 0;
while (sum < M) {
sum += A[i].second;
mon += A[i].first * A[i].second;
i++;
}
mon -= A[i - 1].first * (sum - M);
cout << mon << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, M;
cin >> N >> M;
vector<pair<long, long>> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i].first >> A[i].second;
}
sort(A.begin(), A.end());
long sum = 0;
long mon = 0;
int i = 0;
while (sum < M) {
sum += A[i].second;
mon += A[i].first * A[i].second;
i++;
}
mon -= A[i - 1].first * (sum - M);
cout << mon << endl;
} | [
"variable_declaration.type.primitive.change"
] | 910,513 | 910,514 | u593555034 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
long long ans = 0;
cin >> n >> m;
vector<pair<int, int>> ab(n);
for (i = 0; i < n; i++) {
cin >> ab[i].first >> ab[i].second;
}
sort(ab.begin(), ab.end());
for (i = 0; i < n; i++) {
if (ab[i].second < m) {
ans += ab[i].first * ab[i].second;
m -= ab[i].second;
} else {
ans += ab[i].first * m;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
long long ans = 0;
cin >> n >> m;
vector<pair<long, long>> ab(n);
for (i = 0; i < n; i++) {
cin >> ab[i].first >> ab[i].second;
}
sort(ab.begin(), ab.end());
for (i = 0; i < n; i++) {
if (ab[i].second < m) {
ans += ab[i].first * ab[i].second;
m -= ab[i].second;
} else {
ans += ab[i].first * m;
break;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change"
] | 910,521 | 910,522 | u493122449 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> D(N);
for (int i = 0; i < N; i++) {
pair<int, int> P;
cin >> P.first >> P.second;
D[i] = P;
}
sort(D.begin(), D.end());
long long res = 0;
for (int i = 0; i < N; i++) {
int a = D[i].first, b = D[i].second;
if (b <= M) {
M -= b;
res += a * b;
} else {
res += a * M;
break;
}
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<long, int>> D(N);
for (int i = 0; i < N; i++) {
pair<long, int> P;
cin >> P.first >> P.second;
D[i] = P;
}
sort(D.begin(), D.end());
long long res = 0;
for (int i = 0; i < N; i++) {
long long a = D[i].first, b = D[i].second;
if (b <= M) {
M -= b;
res += a * b;
} else {
res += a * M;
break;
}
}
cout << res << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,523 | 910,524 | u813102292 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<std::pair<int, int>> shops;
for (int i = 0; i < n; i++) {
int a, b;
std::cin >> a >> b;
shops.push_back(std::pair<int, int>(a, b));
}
std::sort(shops.begin(), shops.end());
// std::cout << std::endl;
unsigned long long money = 0;
for (int i = 0; i < shops.size(); i++) {
int cost = shops[i].first;
int count = shops[i].second;
// std::cout << cost << ' ' << count << ' ' << m << std::endl;
if (count <= m) {
money = money + cost * count;
m = m - count;
} else {
money = money + cost * m;
break;
}
}
std::cout << std::endl << money << std::endl;
} | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<std::pair<int, int>> shops;
for (int i = 0; i < n; i++) {
int a, b;
std::cin >> a >> b;
shops.push_back(std::pair<int, int>(a, b));
}
std::sort(shops.begin(), shops.end());
// std::cout << std::endl;
long long money = 0;
for (int i = 0; i < shops.size(); i++) {
long long cost = shops[i].first;
long long count = shops[i].second;
// std::cout << cost << ' ' << count << ' ' << m << std::endl;
if (count < m) {
// std::cout << 'a' << std::endl;
money = money + cost * count;
m = m - count;
} else {
// std::cout << 'b' << std::endl;
money = money + cost * m;
break;
}
}
std::cout << std::endl << money << std::endl;
} | [
"variable_declaration.type.narrow.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,525 | 910,526 | u775347320 | cpp |
p03103 | #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define REPR(i, n) for (int(i) = (n); (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ALL(x) x.begin(), x.end()
#define REVERSE(x) reverse(x.begin(), x.end())
#define P pair<int, int>
typedef long long LL;
const int INF = 1000000007;
using namespace std;
int main() {
LL N, M;
cin >> N >> M;
LL A[N], B[N];
vector<P> drink(N);
REP(i, N) {
cin >> drink[i].first;
cin >> drink[i].second;
}
sort(ALL(drink));
LL sum = 0;
LL pay = 0;
LL cnt = 0;
for (int i = 0; sum < M; i++) {
if (sum + drink[i].second > M) {
cnt = i;
break;
} else {
sum += drink[i].second;
pay += drink[i].first * drink[i].second;
}
}
pay += (M - sum) * drink[cnt].first;
cout << pay;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define REPR(i, n) for (int(i) = (n); (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ALL(x) x.begin(), x.end()
#define REVERSE(x) reverse(x.begin(), x.end())
#define P pair<int, int>
typedef long long LL;
const int INF = 1000000007;
using namespace std;
int main() {
LL N, M;
cin >> N >> M;
LL A[N], B[N];
vector<pair<LL, LL>> drink(N);
REP(i, N) {
cin >> drink[i].first;
cin >> drink[i].second;
}
sort(ALL(drink));
LL sum = 0;
LL pay = 0;
LL cnt = 0;
for (int i = 0; sum < M; i++) {
if (sum + drink[i].second > M) {
cnt = i;
break;
} else {
sum += drink[i].second;
pay += drink[i].first * drink[i].second;
}
}
pay += (M - sum) * drink[cnt].first;
cout << pay;
} | [] | 910,531 | 910,532 | u709810602 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<pair<int, int>> drink(n);
for (int i = 0; i < n; i++) {
cin >> drink[i].first >> drink[i].second;
}
sort(drink.begin(), drink.end());
ll sum = 0;
for (int i = 0; i < n; i++) {
if (drink[i].second >= m) {
sum += (m * drink[i].first);
break;
} else {
sum += (drink[i].second * drink[i].first);
m -= drink[i].second;
}
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<pair<ll, ll>> drink(n);
for (int i = 0; i < n; i++) {
cin >> drink[i].first >> drink[i].second;
}
sort(drink.begin(), drink.end());
ll sum = 0;
for (int i = 0; i < n; i++) {
if (drink[i].second >= m) {
sum += (m * drink[i].first);
break;
} else {
sum += (drink[i].second * drink[i].first);
m -= drink[i].second;
}
}
cout << sum << endl;
return 0;
}
| [] | 910,551 | 910,552 | u488963488 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
ans += (long long)buy * AB[i].first;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
ans += (long long)buy * AB[i].first;
M -= buy;
}
cout << ans << endl;
return 0;
} | [
"assignment.add"
] | 910,553 | 910,554 | u130834452 | cpp |
p03103 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
vector<pair<int, int>> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
sort(p.begin(), p.end());
for (int i = 0; i < n; i++) {
ans += min(m, p[i].second) * p[i].first;
m -= min(m, p[i].second);
if (m == 0) {
break;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
vector<pair<int, int>> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
sort(p.begin(), p.end());
for (int i = 0; i < n; i++) {
ans += (long long)min(m, p[i].second) * p[i].first;
m -= min(m, p[i].second);
if (m == 0) {
break;
}
}
cout << ans << endl;
}
| [
"type_conversion.add"
] | 910,557 | 910,558 | u401900157 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 28;
vector<pair<int, int>> p;
long long ans;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
p.push_back({a, b});
}
sort(p.begin(), p.end());
int c = 0;
int i = 0;
while (c + p[i].second <= m) {
c += p[i].second;
ans += (long long)p[i].first * p[i].second;
i++;
}
ans += (long long)p[i].first * (m - c);
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 28;
vector<pair<int, int>> p;
long long ans;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
p.push_back({a, b});
}
sort(p.begin(), p.end());
int c = 0;
int i = 0;
while (c + p[i].second < m) {
c += p[i].second;
ans += (long long)p[i].first * p[i].second;
i++;
}
ans += (long long)p[i].first * (m - c);
cout << ans;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 910,561 | 910,562 | u362769442 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define Fastest \
ios_base ::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl "\n"
int main() {
Fastest
vector<pair<int, int>>
v;
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
ll sum = 0;
for (int i = 0; i < n; i++) {
if (v[i].second <= m) {
sum += v[i].first * 1LL * v[i].second;
m -= v[i].second;
} else {
sum += v[i].first * m;
break;
}
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define Fastest \
ios_base ::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl "\n"
int main() {
Fastest
vector<pair<int, int>>
v;
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
ll sum = 0;
for (int i = 0; i < n; i++) {
if (v[i].second <= m) {
sum += v[i].first * 1LL * v[i].second;
m -= v[i].second;
} else {
sum += v[i].first * 1LL * m;
break;
}
}
cout << sum << endl;
return 0;
}
| [
"assignment.change"
] | 910,563 | 910,564 | u720795206 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m, left;
long long ans;
cin >> n >> m;
vector<pair<int, int>> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i].first >> vec[i].second;
}
sort(vec.begin(), vec.end());
left = m;
ans = 0;
for (int i = 0; i < n; i++) {
if (vec[i].second <= left) {
ans += (long long)vec[i].first * vec[i].second;
left -= vec[i].second;
} else {
ans += vec[i].first * left;
break;
}
}
cout << ans << endl;
return 0;
}
/*
10 30 90
*/ | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m, left;
long long ans;
cin >> n >> m;
vector<pair<int, int>> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i].first >> vec[i].second;
}
sort(vec.begin(), vec.end());
left = m;
ans = 0;
for (int i = 0; i < n; i++) {
if (vec[i].second <= left) {
ans += (long long)vec[i].first * vec[i].second;
left -= vec[i].second;
} else {
ans += (long long)vec[i].first * left;
break;
}
}
cout << ans << endl;
return 0;
}
/*
10 30 90
*/ | [
"type_conversion.add"
] | 910,565 | 910,566 | u749475370 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> A(N);
for (int i = 0; i < N; i++) {
int tmp1, tmp2;
cin >> tmp1 >> tmp2;
A[i].first = tmp1;
A[i].second = tmp2;
}
// for (int i = 0; i < N; i++)
//{
// cout << i << "th" << A[i].first << endl;
//}
sort(A.begin(), A.end());
// for (int i = 0; i < N; i++)
// {
// cout << i << "th" << A[i].first << endl;
// }
// reverse(A.begin(), A.end());
// for (int i = 0; i < N; i++)
// {
// cout << i << "th" << A[i].first << endl;
// }
int i = -1;
long long cnt = 0;
while (M >= 0) {
i++;
int M_tmp = M;
M_tmp -= A[i].second;
if (M_tmp <= 0) {
cnt += (long long)M * A[i].first;
} else {
cnt += (long long)A[i].second * A[i].first;
}
M -= A[i].second;
}
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> A(N);
for (int i = 0; i < N; i++) {
int tmp1, tmp2;
cin >> tmp1 >> tmp2;
A[i].first = tmp1;
A[i].second = tmp2;
}
// for (int i = 0; i < N; i++)
//{
// cout << i << "th" << A[i].first << endl;
//}
sort(A.begin(), A.end());
// for (int i = 0; i < N; i++)
// {
// cout << i << "th" << A[i].first << endl;
// }
// reverse(A.begin(), A.end());
// for (int i = 0; i < N; i++)
// {
// cout << i << "th" << A[i].first << endl;
// }
int i = -1;
long long cnt = 0;
while (M > 0) {
i++;
int M_tmp = M;
M_tmp -= A[i].second;
if (M_tmp <= 0) {
cnt += (long long)M * A[i].first;
} else {
cnt += (long long)A[i].second * A[i].first;
}
M -= A[i].second;
}
cout << cnt << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 910,567 | 910,568 | u934246119 | cpp |
p03103 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> data_t;
int main() {
vector<data_t> a(114514);
int n, m, res = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
int j = 0;
sort(a.begin(), a.end());
while (m > 0) {
if (a[j].second < m) {
res += a[j].first * a[j].second;
m = m - a[j].second;
j++;
} else {
res += a[j].first * m;
m = 0;
}
}
cout << res << endl;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef pair<long long, int> data_t;
int main() {
vector<data_t> a(114514);
long long n, m, res = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
int j = 0;
sort(a.begin(), a.end());
while (m > 0) {
if (a[j].second <= m) {
res += a[j].first * a[j].second;
m = m - a[j].second;
j++;
} else {
res += a[j].first * m;
m = 0;
}
}
cout << res << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,572 | 910,573 | u266479350 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int A[N], B[N];
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
ans += buy * AB[i].first;
M -= buy;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int A[N], B[N];
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
ans += (long long)buy * AB[i].first;
M -= buy;
}
cout << ans << endl;
return 0;
} | [
"type_conversion.add"
] | 910,574 | 910,575 | u791220701 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
vector<pair<int, int>> li(n);
for (i = 0; i < n; i++) {
cin >> li[i].first >> li[i].second;
}
sort(li.begin(), li.end());
long long int ans = 0, mazai = 0;
for (i = 0; mazai < m; i++) {
ans += li[i].first * li[i].second;
mazai += li[i].second;
}
if (mazai > m) {
ans -= li[i - 1].first * (mazai - m);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
vector<pair<long long int, long long int>> li(n);
for (i = 0; i < n; i++) {
cin >> li[i].first >> li[i].second;
}
sort(li.begin(), li.end());
long long int ans = 0, mazai = 0;
for (i = 0; mazai < m; i++) {
ans += li[i].first * li[i].second;
mazai += li[i].second;
}
if (mazai > m) {
ans -= li[i - 1].first * (mazai - m);
}
cout << ans << endl;
} | [
"variable_declaration.type.widen.change"
] | 910,576 | 910,577 | u676496404 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
vector<pair<int, int>> li(n);
for (i = 0; i < n; i++) {
cin >> li[i].first >> li[i].second;
}
sort(li.begin(), li.end());
int ans = 0, mazai = 0;
for (i = 0; mazai < m; i++) {
ans += li[i].first * li[i].second;
mazai += li[i].second;
}
if (mazai > m) {
ans -= li[i - 1].first * (mazai - m);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
vector<pair<long long int, long long int>> li(n);
for (i = 0; i < n; i++) {
cin >> li[i].first >> li[i].second;
}
sort(li.begin(), li.end());
long long int ans = 0, mazai = 0;
for (i = 0; mazai < m; i++) {
ans += li[i].first * li[i].second;
mazai += li[i].second;
}
if (mazai > m) {
ans -= li[i - 1].first * (mazai - m);
}
cout << ans << endl;
} | [
"variable_declaration.type.widen.change"
] | 910,578 | 910,577 | u676496404 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, m;
struct elm {
int a, b;
} a[N];
bool operator<(const elm &l, const elm &r) {
return l.a < r.a || (l.a == r.a && l.b > r.b);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
scanf("%d%d", &a[i].a, &a[i].b);
typedef long long ll;
ll res = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n && m > 0; ++i) {
int mm = min(m, a[i].b);
res += 1LL * mm * a[i].a;
m -= mm;
}
printf("%I64d", res);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, m;
struct elm {
int a, b;
} a[N];
bool operator<(const elm &l, const elm &r) {
return l.a < r.a || (l.a == r.a && l.b > r.b);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
scanf("%d%d", &a[i].a, &a[i].b);
typedef long long ll;
ll res = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n && m > 0; ++i) {
int mm = min(m, a[i].b);
res += 1LL * mm * a[i].a;
m -= mm;
}
printf("%lld", res);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 910,581 | 910,582 | u286309545 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
cin >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0; // 円
int drinks = M;
for (int i = 0; i < N; ++i) {
int stock = AB[i].second;
int temp;
if (stock <= drinks) {
temp = stock;
} else {
temp = drinks;
}
drinks -= temp;
ans += AB[i].first * temp;
if (drinks == 0) {
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
cin >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0; // 円
int drinks = M;
for (int i = 0; i < N; ++i) {
int stock = AB[i].second;
int temp;
if (stock <= drinks) {
temp = stock;
} else {
temp = drinks;
}
drinks -= temp;
ans += AB[i].first * (long long)temp;
if (drinks == 0) {
break;
}
}
cout << ans << endl;
} | [
"type_conversion.add"
] | 910,589 | 910,590 | u307834890 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
cin >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0; // 円
int drinks = M;
for (int i = 0; i < N; ++i) {
int stock = AB[i].second;
int temp;
if (stock <= drinks) {
temp = stock;
} else {
temp = drinks;
}
drinks -= temp;
ans += AB[i].first;
if (drinks == 0) {
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
cin >> B[i];
}
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0; // 円
int drinks = M;
for (int i = 0; i < N; ++i) {
int stock = AB[i].second;
int temp;
if (stock <= drinks) {
temp = stock;
} else {
temp = drinks;
}
drinks -= temp;
ans += AB[i].first * (long long)temp;
if (drinks == 0) {
break;
}
}
cout << ans << endl;
} | [
"assignment.change"
] | 910,591 | 910,590 | u307834890 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i].first >> c[i].second;
}
sort(c.begin(), c.end());
int number = m;
int cost = 0;
for (int i = 0; i < n; i++) {
if (number - c[i].second >= 0) {
number -= c[i].second;
cost += c[i].first * c[i].second;
} else {
cost += c[i].first * number;
break;
}
}
cout << setprecision(20);
cout << cost << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<pair<long, long>> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i].first >> c[i].second;
}
sort(c.begin(), c.end());
long number = m;
long cost = 0;
for (int i = 0; i < n; i++) {
if (number - c[i].second >= 0) {
number -= c[i].second;
cost += c[i].first * c[i].second;
} else {
cost += c[i].first * number;
break;
}
}
cout << setprecision(20);
cout << cost << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,596 | 910,597 | u882039496 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int a, b;
vector<pair<int, int>> p(N);
for (int i = 0; i < N; i++) {
cin >> a >> b;
p[i] = make_pair(a, b);
}
sort(p.begin(), p.end());
int sum = 0;
for (int i = 0; i < N && M > 0; i++) {
if (p[i].second - M <= 0) {
M = M - p[i].second;
sum += p[i].first * p[i].second;
} else {
sum += p[i].first * M;
M = 0;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int a, b;
vector<pair<long, int>> p(N);
for (int i = 0; i < N; i++) {
cin >> a >> b;
p[i] = make_pair(a, b);
}
sort(p.begin(), p.end());
long sum = 0;
for (int i = 0; i < N && M > 0; i++) {
if (p[i].second - M <= 0) {
M = M - p[i].second;
sum += p[i].first * p[i].second;
} else {
sum += p[i].first * M;
M = 0;
}
}
cout << sum << endl;
} | [
"variable_declaration.type.primitive.change"
] | 910,598 | 910,599 | u423656246 | cpp |
p03103 | #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 main() {
int N, M;
cin >> N >> M;
vector<pair<ll, ll>> a(N);
rep(i, N) { cin >> a[i].first >> a[i].second; }
sort(a.begin(), a.end());
ll ans = 0;
rep(i, N) {
if (a[i].second <= M) {
ans += a[i].first * a[i].second;
M = M - a[i].second;
} else if (M == 0) {
cout << ans << endl;
break;
} else {
ans += a[i].first * M;
cout << ans << endl;
break;
}
}
}
| #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 main() {
int N, M;
cin >> N >> M;
vector<pair<ll, ll>> a(N);
rep(i, N) { cin >> a[i].first >> a[i].second; }
sort(a.begin(), a.end());
ll ans = 0;
rep(i, N) {
if (a[i].second < M) {
ans += a[i].first * a[i].second;
M = M - a[i].second;
} else if (M == 0) {
cout << ans << endl;
break;
} else {
ans += a[i].first * M;
cout << ans << endl;
break;
}
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,609 | 910,610 | u979078704 | cpp |
p03103 | #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 main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> a(N);
rep(i, N) { cin >> a[i].first >> a[i].second; }
sort(a.begin(), a.end());
int ans = 0;
rep(i, N) {
if (a[i].second <= M) {
ans += a[i].first * a[i].second;
M = M - a[i].second;
} else if (M == 0) {
cout << ans << endl;
break;
} else {
ans += a[i].first * M;
cout << ans << endl;
break;
}
}
} | #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 main() {
int N, M;
cin >> N >> M;
vector<pair<ll, ll>> a(N);
rep(i, N) { cin >> a[i].first >> a[i].second; }
sort(a.begin(), a.end());
ll ans = 0;
rep(i, N) {
if (a[i].second < M) {
ans += a[i].first * a[i].second;
M = M - a[i].second;
} else if (M == 0) {
cout << ans << endl;
break;
} else {
ans += a[i].first * M;
cout << ans << endl;
break;
}
}
}
| [
"variable_declaration.type.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,611 | 910,610 | u979078704 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
struct node {
long long int p, q;
};
bool comp(struct node x, struct node y) {
if (x.p < y.p)
return true;
else
return false;
}
int main()
{
long long int a, b, c, d, i, j, k, l;
cin >> a >> b;
struct node n[a];
for (i = 0; i < a; i++) {
cin >> n[i].p >> n[i].q;
}
sort(n, n + a, comp);
int cur = 0;
int price = 0;
for (i = 0; i < a; i++) {
if (cur < b) {
k = min(b - cur, n[i].q);
price += k * n[i].p;
cur += k;
}
}
cout << price;
}
| #include <bits/stdc++.h>
using namespace std;
struct node {
long long int p, q;
};
bool comp(struct node x, struct node y) {
if (x.p < y.p)
return true;
else
return false;
}
int main()
{
long long int a, b, c, d, i, j, k, l;
cin >> a >> b;
struct node n[a];
for (i = 0; i < a; i++) {
cin >> n[i].p >> n[i].q;
}
sort(n, n + a, comp);
long long int cur = 0;
long long int price = 0;
for (i = 0; i < a; i++) {
if (cur < b) {
k = min(b - cur, n[i].q);
price += k * n[i].p;
cur += k;
}
}
cout << price;
}
| [
"variable_declaration.type.widen.change"
] | 910,612 | 910,613 | u858841329 | cpp |
p03103 | #include <algorithm>
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
pair<int, int> a[110000];
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + n);
int ans = 0;
int dai = 0;
while (m != 0) {
if (m - a[dai].second > 0) {
m -= a[dai].second;
ans += a[dai].first * a[dai].second;
dai++;
} else {
ans += a[dai].first * m;
m = 0;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
pair<long int, long int> a[110000];
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + n);
long int ans = 0;
long int dai = 0;
while (m != 0) {
if (m - a[dai].second > 0) {
m -= a[dai].second;
ans += a[dai].first * a[dai].second;
dai++;
} else {
ans += a[dai].first * m;
m = 0;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.widen.change"
] | 910,621 | 910,622 | u740363301 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#define INF_LL 1LL << 60
#define ll long long
typedef pair<int, int> P;
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;
vector<P> pairs(n);
REP(i, n) {
int a, b;
cin >> a >> b;
pairs[i] = make_pair(b, a);
}
sort(pairs.begin(), pairs.end(), compare_by_b);
int now = 0;
int ans = 0;
REP(i, n) {
now += pairs[i].first;
if (now > m) {
ans += (pairs[i].second) * (m - (now - pairs[i].first));
break;
} else {
ans += pairs[i].second * pairs[i].first;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#define INF_LL 1LL << 60
#define ll long long
typedef pair<ll, ll> P;
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;
vector<P> pairs(n);
REP(i, n) {
int a, b;
cin >> a >> b;
pairs[i] = make_pair(b, a);
}
sort(pairs.begin(), pairs.end(), compare_by_b);
ll now = 0;
ll ans = 0;
REP(i, n) {
now += pairs[i].first;
if (now > m) {
ans += (pairs[i].second) * (m - (now - pairs[i].first));
break;
} else {
ans += pairs[i].second * pairs[i].first;
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 910,625 | 910,626 | u127768253 | cpp |
p03103 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
typedef long long ll;
const ll LL_MAX(1LL << 60);
#define rep(i, s, e) for (ll i = (s); i < (e); i++)
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<ll> a(n, 0), b(n, 0);
rep(i, 0, n) cin >> a[i] >> b[i];
map<ll, ll> s;
rep(i, 0, n) s.emplace(a[i], b[i]);
ll sum(0), unit(0);
for (auto i : s) {
if (unit >= m)
break;
if (unit + i.second <= m) {
sum += i.first * i.second;
unit += i.second;
// cout << unit << ' ' << sum << endl;
} else if (i.second > (m - unit)) {
sum += (m - unit) * i.first;
unit += (m - unit);
}
}
cout << sum << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
typedef long long ll;
const ll LL_MAX(1LL << 60);
#define rep(i, s, e) for (ll i = (s); i < (e); i++)
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<ll> a(n, 0), b(n, 0);
rep(i, 0, n) cin >> a[i] >> b[i];
multimap<ll, ll> s;
rep(i, 0, n) s.emplace(a[i], b[i]);
ll sum(0), unit(0);
for (auto i : s) {
if (unit >= m)
break;
if (unit + i.second <= m) {
sum += i.first * i.second;
unit += i.second;
// cout << unit << ' ' << sum << endl;
} else if (i.second > (m - unit)) {
sum += (m - unit) * i.first;
unit += (m - unit);
}
}
cout << sum << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 910,630 | 910,631 | u778668639 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i_length = (n); i < i_length; i++)
#define MOD 1000000007
#define ll long long
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> a;
rep(i, n) {
ll x, y;
cin >> x >> y;
a.push_back(make_pair(x, y));
}
sort(a.begin(), a.end());
// reverse(a.begin(), a.end());
ll ans = 0;
for (int i = 0; m > 0; i++) {
if (m > a[i].first) {
ans += a[i].first * a[i].second;
} else {
ans += a[i].first * m;
}
m -= a[i].second;
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i_length = (n); i < i_length; i++)
#define MOD 1000000007
#define ll long long
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> a;
rep(i, n) {
ll x, y;
cin >> x >> y;
a.push_back(make_pair(x, y));
}
sort(a.begin(), a.end());
// reverse(a.begin(), a.end());
ll ans = 0;
for (int i = 0; m > 0; i++) {
if (m > a[i].second) {
ans += a[i].first * a[i].second;
} else {
ans += a[i].first * m;
}
m -= a[i].second;
}
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 910,648 | 910,649 | u321761416 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, n) for (int i = (a); i < (n); i++)
#define repb(i, n) for (int i = (n - 1); i >= 0; i--)
#define repb2(i, a, n) for (int i = (n - 1); i >= (a); i--)
#define all(x) x.begin(), x.end()
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
inline void fastio() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
}
int main() {
fastio();
int N, M;
vector<pair<ll, ll>> X;
cin >> N >> M;
rep(i, N) {
int a, b;
cin >> a >> b;
X.push_back({a, b});
}
sort(all(X));
ll ans = 0;
for (auto &x : X) {
int price = x.first;
int bottles = x.second;
ll t = (bottles <= M) ? bottles : M; // 今回の購入本数
ans += t * price;
M -= t; // 残りの購入本数
if (!M) {
break;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, n) for (int i = (a); i < (n); i++)
#define repb(i, n) for (int i = (n - 1); i >= 0; i--)
#define repb2(i, a, n) for (int i = (n - 1); i >= (a); i--)
#define all(x) x.begin(), x.end()
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
inline void fastio() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
}
int main() {
fastio();
int N, M;
vector<pair<ll, ll>> X;
cin >> N >> M;
rep(i, N) {
int a, b;
cin >> a >> b;
X.push_back({a, b});
}
sort(all(X));
ll ans = 0;
for (auto &x : X) {
int price = x.first;
int bottles = x.second;
ll t = (bottles <= M) ? bottles : M; // 今回の購入本数
ans += t * price;
M -= t; // 残りの購入本数
if (!M) {
break;
}
}
co(ans);
} | [
"call.add"
] | 910,650 | 910,651 | u075520262 | cpp |
p03103 | #define rep(i, n) for (int i = 0; i < n; i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long llong;
struct Drink {
llong num;
llong price;
bool operator<(const Drink &another) const { return price < another.price; }
};
void solve() {
int N, M;
cin >> N >> M;
vector<Drink> drink(N);
rep(i, N) scanf("%lld%lld", &drink[i].price, &drink[i].num);
// 個数で昇順ソート
sort(drink.begin(), drink.end(),
[](const Drink &a, const Drink &b) { return a.num < b.num; });
llong res = 0;
rep(i, N) {
if (M <= 0)
break;
if (drink[i].num > M) {
res += M * drink[i].price;
} else if (drink[i].num <= M) {
res += drink[i].num * drink[i].price;
}
M -= drink[i].num;
}
cout << res << endl;
}
int main(void) {
solve();
return 0;
} | #define rep(i, n) for (int i = 0; i < n; i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long llong;
struct Drink {
llong num;
llong price;
bool operator<(const Drink &another) { return num < another.num; }
};
void solve() {
int N, M;
cin >> N >> M;
vector<Drink> drink(N);
rep(i, N) scanf("%lld%lld", &drink[i].price, &drink[i].num);
// 個数で昇順ソート
sort(drink.begin(), drink.end(),
[](const Drink &a, const Drink &b) { return a.price < b.price; });
llong res = 0;
rep(i, N) {
if (M <= 0)
break;
if (drink[i].num > M) {
res += M * drink[i].price;
} else if (drink[i].num <= M) {
res += drink[i].num * drink[i].price;
}
M -= drink[i].num;
}
cout << res << endl;
}
int main(void) {
solve();
return 0;
} | [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 910,652 | 910,653 | u863957421 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
int main(void) {
int n, m;
cin >> n >> m;
ll ans = 0;
vector<pair<int, int>> a;
rep(i, n) {
int x, y;
cin >> x >> y;
a.emplace_back(x, y);
}
sort(a.begin(), a.end());
int cnt = 0;
rep(i, n) {
if (cnt + a[i].second <= m) {
ans += a[i].first * a[i].second;
cnt += a[i].second;
} else {
while (cnt < m) {
ans += a[i].first;
cnt++;
}
}
if (cnt == m) {
break;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main(void) {
int n, m;
cin >> n >> m;
ll ans = 0;
vector<pair<ll, ll>> a;
rep(i, n) {
int x, y;
cin >> x >> y;
a.emplace_back(x, y);
}
sort(a.begin(), a.end());
int cnt = 0;
rep(i, n) {
if (cnt + a[i].second <= m) {
ans += (ll)a[i].first * a[i].second;
cnt += a[i].second;
} else {
while (cnt < m) {
ans += a[i].first;
cnt++;
}
}
if (cnt == m) {
break;
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.narrow.change"
] | 910,658 | 910,659 | u905170328 | cpp |
p03103 | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> mise(N);
int A, B;
for (int i = 0; i < N; i++) {
cin >> A >> B;
mise.at(i) = make_pair(A, B);
}
sort(mise.begin(), mise.end());
int ans = 0;
int honsu = M; // 0本を目指す、買うたびに減る
for (int i = 0; i < N; i++) {
if (mise.at(i).second <= honsu) {
ans += mise.at(i).first * mise.at(i).second;
honsu -= mise.at(i).second;
} else {
ans += mise.at(i).first * honsu;
cout << ans << endl;
return 0;
}
}
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> mise(N);
int A, B;
for (int i = 0; i < N; i++) {
cin >> A >> B;
mise.at(i) = make_pair(A, B);
}
sort(mise.begin(), mise.end());
int ans = 0;
int honsu = M; // 0本を目指す、買うたびに減る
for (int i = 0; i < N; i++) {
if (mise.at(i).second < honsu) {
ans += mise.at(i).first * mise.at(i).second;
honsu -= mise.at(i).second;
} else {
ans += mise.at(i).first * honsu;
cout << ans << endl;
return 0;
}
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,660 | 910,661 | u521652313 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n), b(n);
vector<pair<int, int>> ab(n);
rep(i, n) {
cin >> a.at(i) >> b.at(i);
ab.at(i) = make_pair(a.at(i), b.at(i));
}
sort(ab.begin(), ab.end());
int64_t ans = 0;
rep(i, n) {
int p = min(m, ab.at(i).second);
ans += p * ab.at(i).first;
m -= p;
}
cout << ans;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int64_t> a(n), b(n);
vector<pair<int64_t, int>> ab(n);
rep(i, n) {
cin >> a.at(i) >> b.at(i);
ab.at(i) = make_pair(a.at(i), b.at(i));
}
sort(ab.begin(), ab.end());
int64_t ans = 0;
rep(i, n) {
int p = min(m, ab.at(i).second);
ans += p * ab.at(i).first;
m -= p;
}
cout << ans;
} | [
"variable_declaration.type.primitive.change"
] | 910,664 | 910,665 | u009870106 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
set<pair<ll, ll>> pq;
ll n, m;
cin >> n >> m;
for (ll i = 0; i < n; i++) {
ll coin, num;
scanf("%lld %lld", &coin, &num);
pq.insert({coin, -num});
}
ll cnt = 0;
ll koyta_nilam = 0;
for (auto tmp : pq) {
ll curcoin = tmp.first;
ll curnum = -tmp.second;
if (curnum + koyta_nilam > m)
cnt += (m - koyta_nilam) * curcoin, koyta_nilam = m;
else
cnt += curnum * curcoin, koyta_nilam += curnum;
if (koyta_nilam == m)
break;
}
cout << cnt << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
multimap<ll, ll> pq;
ll n, m;
cin >> n >> m;
for (ll i = 0; i < n; i++) {
ll coin, num;
scanf("%lld %lld", &coin, &num);
pq.insert({coin, -num});
}
ll cnt = 0;
ll koyta_nilam = 0;
for (auto tmp : pq) {
ll curcoin = tmp.first;
ll curnum = -tmp.second;
if (curnum + koyta_nilam > m)
cnt += (m - koyta_nilam) * curcoin, koyta_nilam = m;
else
cnt += curnum * curcoin, koyta_nilam += curnum;
if (koyta_nilam == m)
break;
}
cout << cnt << endl;
}
| [
"variable_declaration.type.change"
] | 910,666 | 910,667 | u945133959 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define FORR(i, m, n) for (int i = (m); i >= (n); --i)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
const ll mod2 = 998244353;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> ab(n, vector<int>(2));
rep(i, n) cin >> ab[i][0] >> ab[i][1];
sort(ab.begin(), ab.end());
ll ans = 0;
rep(i, n) {
if (m > ab[i][1]) {
ans += ab[i][0] * ab[i][1];
m -= ab[i][1];
} else {
ans += ab[i][0] * m;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define FORR(i, m, n) for (int i = (m); i >= (n); --i)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
const ll mod2 = 998244353;
int main() {
int n, m;
cin >> n >> m;
vector<vector<ll>> ab(n, vector<ll>(2));
rep(i, n) cin >> ab[i][0] >> ab[i][1];
sort(ab.begin(), ab.end());
ll ans = 0;
rep(i, n) {
if (m > ab[i][1]) {
ans += ab[i][0] * ab[i][1];
m -= ab[i][1];
} else {
ans += ab[i][0] * m;
break;
}
}
cout << ans << endl;
} | [
"call.arguments.change"
] | 910,670 | 910,671 | u759721333 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> pair(n);
for (int i = 0; i < n; i++) {
cin >> pair[i].first >> pair[i].second;
}
int ans = 0;
sort(pair.begin(), pair.end());
int j = 0;
while (m != 0) {
if (pair[j].second <= m) {
ans += pair[j].first * pair[j].second;
m -= pair[j].second;
} else {
ans += pair[j].first * m;
m -= m;
}
j++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long, long>> pair(n);
for (int i = 0; i < n; i++) {
cin >> pair[i].first >> pair[i].second;
}
long long ans = 0;
sort(pair.begin(), pair.end());
int j = 0;
while (m != 0) {
if (pair[j].second <= m) {
ans += pair[j].first * pair[j].second;
m -= pair[j].second;
} else {
ans += pair[j].first * m;
m -= m;
}
j++;
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,672 | 910,673 | u964726243 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define inf 1000000007
int main() {
vector<pair<ll, ll>> a;
ll n, m, ans = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
ll x, z;
cin >> x >> z;
a.push_back(make_pair(x, z));
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
m -= a[i].second;
ans += a[i].second * a[i].first;
if (m <= 0) {
ans -= abs(m) * a[i].first;
}
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define inf 1000000007
int main() {
vector<pair<ll, ll>> a;
ll n, m, ans = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
ll x, z;
cin >> x >> z;
a.push_back(make_pair(x, z));
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
m -= a[i].second;
ans += a[i].second * a[i].first;
if (m <= 0) {
ans -= abs(m) * a[i].first;
break;
}
}
cout << ans;
} | [
"control_flow.break.add"
] | 910,674 | 910,675 | u166378830 | cpp |
p03103 | // #include <bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define irep(i, n) for (int i = n - 1; i >= 0; i--)
#define lrep(i, n) for (long long i = 0; i < n; i++)
typedef long long ll;
typedef vector<long long> llv;
typedef vector<vector<long long>> llvv;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
vector<pair<int, int>> ab(n);
rep(i, n) ab[i] = make_pair(a[i], b[i]);
sort(ab.begin(), ab.end());
ll cost = 0;
rep(i, n) {
ll buy = min(m, ab[i].second);
cost = (ll)ab[i].first * buy;
m -= buy;
}
cout << cost << endl;
} | // #include <bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define irep(i, n) for (int i = n - 1; i >= 0; i--)
#define lrep(i, n) for (long long i = 0; i < n; i++)
typedef long long ll;
typedef vector<long long> llv;
typedef vector<vector<long long>> llvv;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
vector<pair<int, int>> ab(n);
rep(i, n) ab[i] = make_pair(a[i], b[i]);
sort(ab.begin(), ab.end());
ll cost = 0;
rep(i, n) {
ll buy = min(m, ab[i].second);
cost += (ll)ab[i].first * buy;
m -= buy;
}
cout << cost << endl;
} | [
"assignment.value.change"
] | 910,683 | 910,684 | u379440427 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> AB(N, vector<int>(2));
for (int i = 0; i < N; i++) {
cin >> AB[i][0] >> AB[i][1];
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
if (AB[i][1] < M) {
ans += (long long)AB[i][0] * AB[i][1];
M -= AB[i][1];
} else {
ans += AB[i][0] * M;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> AB(N, vector<int>(2));
for (int i = 0; i < N; i++) {
cin >> AB[i][0] >> AB[i][1];
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
if (AB[i][1] < M) {
ans += (long long)AB[i][0] * AB[i][1];
M -= AB[i][1];
} else {
ans += (long long)AB[i][0] * M;
break;
}
}
cout << ans << endl;
} | [
"type_conversion.add"
] | 910,685 | 910,686 | u275786410 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(M);
for (int i = 0; i < N; i++)
cin >> A[i] >> B[i];
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
ans += (long long)buy * AB[i].first;
M -= buy;
if (M == 0)
break;
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++)
cin >> A[i] >> B[i];
vector<pair<int, int>> AB(N);
for (int i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
ans += (long long)buy * AB[i].first;
M -= buy;
if (M == 0)
break;
}
cout << ans << endl;
}
| [] | 910,707 | 910,708 | u640827947 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long sum, a, N, M, m, b;
cin >> N >> M;
m = M;
sum = 0;
vector<pair<long long, long long>> ans(N);
for (int i = 0; i < N; i++) {
cin >> a >> b;
ans.push_back(make_pair(a, b));
}
sort(ans.begin(), ans.end());
for (int i = 0; i < M; i++) {
if (m > ans[i].second) {
m -= ans[i].second;
sum += ans[i].first * ans[i].second;
} else {
sum += ans[i].first * m;
break;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long sum, a, N, M, m, b;
cin >> N >> M;
m = M;
sum = 0;
vector<pair<long long, long long>> ans(N);
for (int i = 0; i < N; i++) {
cin >> a >> b;
ans[i] = make_pair(a, b);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < M; i++) {
if (m > ans[i].second) {
m -= ans[i].second;
sum += ans[i].first * ans[i].second;
} else {
sum += ans[i].first * m;
break;
}
}
cout << sum << endl;
} | [
"call.arguments.change"
] | 910,713 | 910,714 | u902787159 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define repR(i, n) for (ll i = n; i >= 0; ++i)
#define FDS(i, n) for (ll i = 0; i < n; ++i)
#define FDSR(i, n) for (ll i = n; i >= 0; ++i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define FORR(i, m, n) for (ll i = m; i >= n; --i)
#define VSORT(v) sort(v.begin(), v.end());
#define VREV(v) reverse(v.begin(), v.end());
#define INF 999999999
#define itn ll
#define ednl endl
using namespace std;
typedef long long ll;
template <typename Typell> Typell G_C_D(Typell a, Typell b) {
if (a < 0)
a = -a;
if (b < 0)
b = -b;
while (b != 0) {
a %= b;
if (a == 0)
return b;
b %= a;
}
return a;
}
template <typename Typell> Typell G_C_D(const std::vector<Typell> &list) {
Typell a = list[0];
for (size_t i = 1; i < list.size(); ++i) {
a = G_C_D(a, list[i]);
}
return a;
}
template <typename Typell> Typell L_C_M(Typell a, Typell b) {
if (a == 0 && b == 0)
return 0;
return a / G_C_D(a, b) * b;
}
template <typename Typell> Typell L_C_M(const std::vector<Typell> &list) {
Typell a = list[0];
for (size_t i = 1; i < list.size(); ++i) {
a = L_C_M(a, list[i]);
}
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<int> B(N);
FDS(i, N) { cin >> A[i] >> B[i]; }
vector<pair<int, int>> AB(N);
FDS(i, N) { AB[i] = make_pair(A[i], B[i]); }
VSORT(AB); // pair型は前からsortされる
ll ans = 0;
FDS(i, N) {
int buy = min(M, AB[i].second); //買う数
ans += (ll)buy * AB[i].first;
M -= AB[i].second;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define repR(i, n) for (ll i = n; i >= 0; ++i)
#define FDS(i, n) for (ll i = 0; i < n; ++i)
#define FDSR(i, n) for (ll i = n; i >= 0; ++i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define FORR(i, m, n) for (ll i = m; i >= n; --i)
#define VSORT(v) sort(v.begin(), v.end());
#define VREV(v) reverse(v.begin(), v.end());
#define INF 999999999
#define itn ll
#define ednl endl
using namespace std;
typedef long long ll;
template <typename Typell> Typell G_C_D(Typell a, Typell b) {
if (a < 0)
a = -a;
if (b < 0)
b = -b;
while (b != 0) {
a %= b;
if (a == 0)
return b;
b %= a;
}
return a;
}
template <typename Typell> Typell G_C_D(const std::vector<Typell> &list) {
Typell a = list[0];
for (size_t i = 1; i < list.size(); ++i) {
a = G_C_D(a, list[i]);
}
return a;
}
template <typename Typell> Typell L_C_M(Typell a, Typell b) {
if (a == 0 && b == 0)
return 0;
return a / G_C_D(a, b) * b;
}
template <typename Typell> Typell L_C_M(const std::vector<Typell> &list) {
Typell a = list[0];
for (size_t i = 1; i < list.size(); ++i) {
a = L_C_M(a, list[i]);
}
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<int> B(N);
FDS(i, N) { cin >> A[i] >> B[i]; }
vector<pair<int, int>> AB(N);
FDS(i, N) { AB[i] = make_pair(A[i], B[i]); }
VSORT(AB); // pair型は前からsortされる
ll ans = 0;
FDS(i, N) {
int buy = min(M, AB[i].second); //買う数
ans += (ll)buy * AB[i].first;
M -= buy;
}
cout << ans << endl;
}
| [
"assignment.value.change"
] | 910,731 | 910,732 | u870797515 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<ll, int>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | [] | 910,733 | 910,737 | u784072785 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
int ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい" << endl;
if (m >= V[i].second)
ans += V[i].first * V[i].second, m -= V[i].second;
else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<ll, int>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 910,736 | 910,737 | u784072785 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<ll, ll>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | [] | 910,733 | 910,738 | u784072785 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
int ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい" << endl;
if (m >= V[i].second)
ans += V[i].first * V[i].second, m -= V[i].second;
else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<ll, ll>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 910,736 | 910,738 | u784072785 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> V(n, make_pair(0, 0));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define debug(x) cerr << #x << ':' << x << endl
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<ll, ll>> V(n, make_pair(0LL, 0LL));
REP(i, n) cin >> V[i].first >> V[i].second;
sort(ALL(V));
// REP(i,n) cout <<i << " "<< V[i].first << " " << V[i].second << endl;
ll ans = 0;
REP(i, n) {
// cout << i << "にいて，もう " << m << "個かいたい．お金はまだ"<<ans <<
// endl;
if (m >= V[i].second) {
ans += V[i].first * V[i].second;
m -= V[i].second;
} else {
ans += V[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.type.widen.change"
] | 910,733 | 910,739 | u784072785 | cpp |
p03103 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> Pi;
typedef long long int ll;
const int INF = (ll)(1 << 30) - 1;
const ll INFl = (ll)9223372036854775807;
const int MAX = 10000;
const ll MOD = (ll)1e9 + 7;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int n, m;
pair<int, int> ab[100100];
int main() {
cin >> n >> m;
ll ans = 0;
for (int i = 0; i < n; i++) {
int t, s;
cin >> t >> s;
ab[i] = make_pair(t, s);
}
sort(ab, ab + n);
for (int i = 0; i < n; i++) {
if (ab[i].second <= m) {
ans += ab[i].first * ab[i].second;
m -= ab[i].second;
} else {
ans += ab[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n1, n2) for (int i = n1; i < n2; i++)
#define speed_up \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> Pi;
typedef long long int ll;
const int INF = (ll)(1 << 30) - 1;
const ll INFl = (ll)9223372036854775807;
const int MAX = 10000;
const ll MOD = (ll)1e9 + 7;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
ll n, m;
pair<ll, ll> ab[100100];
int main() {
cin >> n >> m;
ll ans = 0;
for (int i = 0; i < n; i++) {
int t, s;
cin >> t >> s;
ab[i] = make_pair(t, s);
}
sort(ab, ab + n);
for (int i = 0; i < n; i++) {
if (ab[i].second <= m) {
ans += ab[i].first * ab[i].second;
m -= ab[i].second;
} else {
ans += ab[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 910,744 | 910,745 | u055303078 | cpp |
p03103 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> mz(n);
rep(i, n) {
int a, b;
cin >> a >> b;
mz[i] = make_pair(a, b);
}
sort(mz.begin(), mz.end());
int kane = 0, zai = 0;
rep(i, n) {
if (zai + mz[i].second <= m) {
kane += mz[i].first * mz[i].second;
zai += mz[i].second;
} else if (zai >= m)
break;
else {
kane += (m - zai) * mz[i].first;
zai += (m - zai);
}
}
cout << kane << endl;
}
| #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
int n, m;
cin >> n >> m;
vector<pair<ll, ll>> mz(n);
rep(i, n) {
ll a, b;
cin >> a >> b;
mz[i] = make_pair(a, b);
}
sort(mz.begin(), mz.end());
ll kane = 0, zai = 0;
rep(i, n) {
if (zai + mz[i].second <= m) {
kane += mz[i].first * mz[i].second;
zai += mz[i].second;
} else if (zai >= m)
break;
else {
kane += (m - zai) * mz[i].first;
zai += (m - zai);
}
}
cout << kane << endl;
}
| [
"variable_declaration.type.change"
] | 910,748 | 910,749 | u491279738 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <queue>
#include <sstream>
#include <stdexcept>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
vector<pair<ll, ll>> P;
// vectorをpairに入れてsortする
int main() {
ll n, m;
cin >> n >> m;
ll a, b;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b;
P.push_back({a, b}); // vectorにぶち込む
}
sort(P.begin(), P.end()); //ソートする、辞書順
for (int i = 0; i < n; i++) {
if (P[i].second <= m) {
ans += P[i].first * P[i].second; //価格
m -= P[i].second; // m弄る
} else {
ans += m * P[i].first; //個数
break;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <sstream>
#include <stdexcept>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
vector<pair<ll, ll>> P;
// vectorをpairに入れてsortする
int main() {
ll n, m;
cin >> n >> m;
ll a, b;
ll ans = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b;
P.push_back({a, b});
}
sort(P.begin(), P.end());
for (int i = 0; i < n; i++) {
if (P[i].second <= m) {
ans += P[i].first * P[i].second;
m -= P[i].second;
} else {
ans += m * P[i].first;
break;
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 910,761 | 910,762 | u139300044 | cpp |
p03103 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int MAX_N = 110000;
int N, M;
int A[MAX_N], B[MAX_N];
pair<int, int> itv[MAX_N];
int main() {
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> A[i] >> B[i];
itv[i].first = A[i];
itv[i].second = B[i];
}
sort(itv, itv + N);
ll sum = 0;
for (int i = 0; i < N; ++i) {
if (M - itv[i].second > 0) {
sum += itv[i].first * itv[i].second;
M -= itv[i].second;
} else {
sum += M * itv[i].first;
break;
}
}
cout << sum << endl;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int MAX_N = 110000;
int N, M;
int A[MAX_N], B[MAX_N];
pair<int, int> itv[MAX_N];
int main() {
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> A[i] >> B[i];
itv[i].first = A[i];
itv[i].second = B[i];
}
sort(itv, itv + N);
ll sum = 0;
for (int i = 0; i < N; ++i) {
if (M - itv[i].second > 0) {
sum += (ll)itv[i].first * itv[i].second;
M -= itv[i].second;
} else {
sum += (ll)M * itv[i].first;
break;
}
}
cout << sum << endl;
}
| [
"type_conversion.add"
] | 910,766 | 910,767 | u747390421 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> P(N);
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
P[i].first = A;
P[i].second = B;
}
sort(P.begin(), P.end());
int money = 0;
int count = 0;
for (int i = 0; i < N; i++) {
money += P[i].first * P[i].second;
count += P[i].second;
if (count >= M) {
money -= P[i].first * (count - M);
break;
}
}
cout << money;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
long int N, M;
cin >> N >> M;
vector<pair<long int, long int>> P(N);
for (int i = 0; i < N; i++) {
long int A, B;
cin >> A >> B;
P[i].first = A;
P[i].second = B;
}
sort(P.begin(), P.end());
long int money = 0;
long int count = 0;
for (int i = 0; i < N; i++) {
money += P[i].first * P[i].second;
count += P[i].second;
if (count >= M) {
money -= P[i].first * (count - M);
break;
}
}
cout << money;
}
| [
"variable_declaration.type.widen.change"
] | 910,770 | 910,771 | u969116807 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define MOD 1000000007
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define all(i) (i).begin(), (i).end()
#define rall(i) (i).begin(), (i).end(), greater<int>()
#define elif else if
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define fst first
#define sec second
template <typename T> void print(T x) { std::cout << x << '\n'; }
// typedef long long ll;
#define TENNINE 1000000005
#define TENFIVE 100005
//#define int long long
signed main() {
int N, M;
cin >> N >> M;
int a[N], b[N];
map<int, int> index; //値段、本数
rep(i, N) {
cin >> a[i] >> b[i];
index[a[i]] += b[i];
}
int rest = M;
int money = 0;
for (auto itr : index) {
if (itr.second > rest) {
money += itr.first * rest;
} else {
money += itr.first * itr.second;
rest -= itr.second;
}
if (rest == 0) {
break;
}
}
cout << money << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define MOD 1000000007
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define all(i) (i).begin(), (i).end()
#define rall(i) (i).begin(), (i).end(), greater<int>()
#define elif else if
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define fst first
#define sec second
template <typename T> void print(T x) { std::cout << x << '\n'; }
// typedef long long ll;
#define TENNINE 1000000005
#define TENFIVE 100005
//#define int long long
signed main() {
int N, M;
cin >> N >> M;
int a[N], b[N];
map<int, int> index; //値段、本数
rep(i, N) {
cin >> a[i] >> b[i];
index[a[i]] += b[i];
}
int rest = M;
int money = 0;
for (auto itr : index) {
if (itr.second > rest) {
money += itr.first * rest;
rest -= rest;
} else {
money += itr.first * itr.second;
rest -= itr.second;
}
if (rest == 0) {
break;
}
}
cout << money << endl;
return 0;
}
| [
"assignment.add"
] | 910,774 | 910,775 | u888717396 | cpp |
p03103 | #include <iostream>
#include <map>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
map<long int, long int> A;
long int a;
long int b;
for (int l = 0; l < N; l++) {
cin >> a >> b;
A.insert(make_pair(a, b));
}
long long sumMoney = 0;
for (auto i = A.begin(); i != A.end(); ++i) {
if (M > i->second) {
sumMoney += i->first * i->second;
M -= i->second;
} else {
sumMoney += i->first * M;
M = 0;
break;
}
}
cout << sumMoney << endl;
return 0;
} | #include <iostream>
#include <map>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
multimap<long int, long int> A;
long int a;
long int b;
for (int l = 0; l < N; l++) {
cin >> a >> b;
A.insert(make_pair(a, b));
}
long long sumMoney = 0;
for (auto i = A.begin(); i != A.end(); ++i) {
if (M > i->second) {
sumMoney += i->first * i->second;
M -= i->second;
} else {
sumMoney += i->first * M;
break;
}
}
cout << sumMoney << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 910,776 | 910,777 | u120564432 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<tuple<int, int>> data;
int data_a, data_b;
for (int i = 0; i < N; i++) {
cin >> data_a >> data_b;
data.emplace_back(data_a, data_b);
}
sort(begin(data), end(data));
long result = 0;
int pos = 0;
while (M != 0) {
if (M > get<1>(data[pos])) {
result += get<0>(data[pos]) * get<1>(data[pos]);
M -= get<1>(data[pos]);
} else {
result += get<0>(data[pos]) * M;
M = 0;
}
pos++;
}
cout << result << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<tuple<long, long>> data;
long data_a, data_b;
for (int i = 0; i < N; i++) {
cin >> data_a >> data_b;
data.emplace_back(data_a, data_b);
}
sort(begin(data), end(data));
long result = 0;
int pos = 0;
while (M != 0) {
if (M > get<1>(data[pos])) {
result += get<0>(data[pos]) * get<1>(data[pos]);
M -= get<1>(data[pos]);
} else {
result += get<0>(data[pos]) * M;
M = 0;
}
pos++;
}
cout << result << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 910,778 | 910,779 | u680707192 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> A(N);
for (int i = 0; i < N; i++) {
int B, C;
cin >> B >> C;
A[i] = make_pair(B, C);
}
sort(A.begin(), A.end());
int C = 0;
for (int i = 0; i < N; i++) {
if (M - A[i].second > 0) {
M = M - A[i].second;
C = C + A[i].first * A[i].second;
} else {
C = C + M * A[i].first;
break;
}
}
cout << C << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<long int, long int>> A(N);
for (int i = 0; i < N; i++) {
int B, C;
cin >> B >> C;
A[i] = make_pair(B, C);
}
sort(A.begin(), A.end());
long long int C = 0;
for (int i = 0; i < N; i++) {
if (M - A[i].second > 0) {
M = M - A[i].second;
C = C + A[i].first * A[i].second;
} else {
C = C + M * A[i].first;
break;
}
}
cout << C << endl;
} | [
"variable_declaration.type.widen.change"
] | 910,780 | 910,781 | u860597287 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// input
int N, M;
cin >> N >> M;
vector<pair<long int, int>> x(N);
for (int i = 0; i < N; i++) {
cin >> x[i].first >> x[i].first;
}
// compute
long int sum = 0l;
sort(x.begin(), x.end());
for (int i = 0; i < N; i++) {
if (M > x[i].second) {
sum += x[i].second * x[i].first;
M -= x[i].second;
} else if (M <= x[i].second) {
sum += M * x[i].first;
break;
}
}
cout << sum << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// input
int N, M;
cin >> N >> M;
vector<pair<long int, int>> x(N);
for (int i = 0; i < N; i++) {
cin >> x[i].first >> x[i].second;
}
// compute
long int sum = 0l;
sort(x.begin(), x.end());
for (int i = 0; i < N; i++) {
if (M > x[i].second) {
sum += x[i].second * x[i].first;
M -= x[i].second;
} else if (M <= x[i].second) {
sum += M * x[i].first;
break;
}
}
cout << sum << endl;
return 0;
} | [
"expression.operation.binary.change"
] | 910,782 | 910,783 | u254766083 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
vector<pair<int, int>> vc(n);
for (i = 0; i < n; i++) {
cin >> vc[i].first >> vc[i].second;
}
sort(vc.begin(), vc.end());
long price = 0;
for (i = 0; m > 0; i++) {
price += vc[i].first * min(m, vc[i].second);
m -= vc[i].second;
}
cout << price << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
int i;
cin >> n >> m;
vector<pair<long, long>> vc(n);
for (i = 0; i < n; i++) {
cin >> vc[i].first >> vc[i].second;
}
sort(vc.begin(), vc.end());
long price = 0;
for (i = 0; m > 0; i++) {
price += vc[i].first * min(m, vc[i].second);
m -= vc[i].second;
}
cout << price << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 910,784 | 910,785 | u653837719 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long costs[100000] = {};
map<int, int> mp;
for (int i = 0; i < n; ++i) {
cin >> costs[i];
int a;
cin >> a;
if (mp.find(costs[i]) == mp.end()) {
mp[costs[i]] += a;
costs[i] = 1.0e+9;
} else
mp[costs[i]] = a;
}
sort(costs, costs + n);
long long total = 0;
for (int i = 0; i < n; ++i) {
if (m > mp[costs[i]]) {
m -= mp[costs[i]];
total += mp[costs[i]] * costs[i];
} else {
total += costs[i] * m;
break;
}
}
cout << total << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long costs[100000] = {};
map<int, int> mp;
for (int i = 0; i < n; ++i) {
cin >> costs[i];
int a;
cin >> a;
if (mp.find(costs[i]) != mp.end()) {
mp[costs[i]] += a;
costs[i] = 1.0e+9;
} else
mp[costs[i]] = a;
}
sort(costs, costs + n);
long long total = 0;
for (int i = 0; i < n; ++i) {
if (m > mp[costs[i]]) {
m -= mp[costs[i]];
total += mp[costs[i]] * costs[i];
} else {
total += costs[i] * m;
break;
}
}
cout << total << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,788 | 910,789 | u691380397 | cpp |
p03103 | #pragma region _head
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#pragma region _define
#define f(i, a, b) for (LL i = a; i < b; i++)
#define f_vI(v, n) f(i, 0, n) cin >> v[i]
#define f_v2I(v1, v2, n) f(i, 0, n) cin >> v1[i] >> v2[i]
#define f_v3I(v1, v2, v3, n) f(i, 0, n) cin >> v1[i] >> v2[i] >> v3[i]
#define f_vO(v, n, option) f(i, 0, n) cout << v[i] << option;
#define all(a) a.begin(), a.end()
#define size(s) s.size()
#define check() cout << "! ! !"
#define endl "\n"
#define _y() cout << "Yes" << endl
#define _Y() cout << "YES" << endl
#define _n() cout << "No" << endl
#define _N() cout << "NO" << endl
#define INF 1 << 29
#pragma endregion
#pragma region _using
using namespace std;
using LL = long long;
using st = string;
using vi = vector<LL>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vc = vector<char>;
using vs = vector<st>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using si = stack<LL>;
using ss = stack<st>;
using pi = pair<LL, LL>;
using v_pi = vector<pi>;
#pragma endregion
#pragma region _graph
#define node 50 //グラフの最大位数 適宜変更
// bool graph[node][node]; bool visited[node] = { false };
#define link(a, b, m) \
f(i, 0, m) { \
cin >> a[i] >> b[i]; \
a[i]--; \
b[i]--; \
graph[a[i]][b[i]] = graph[b[i]][a[i]] = true; \
}
#pragma endregion
LL gcd(LL a, LL b) {
LL r;
while ((r = a % b) != 0) {
a = b;
b = r;
}
return b;
}
LL lcm(LL a, LL b) { return (a / gcd(a, b) * b); }
//階乗計算
LL factorial(LL n) {
LL a = 1, ret = 1;
while (a < n) {
a++;
ret *= a;
// ret %= 1000000007;
}
return ret;
}
#pragma endregion
/************************************************************************/
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vi A(n), B(n);
f_v2I(A, B, n);
v_pi p(n);
f(i, 0, n) { p[i] = {A[i], B[i]}; }
sort(all(p));
LL sum = 0;
int i = 0;
int memo;
while (true) {
sum += (p[i].first * p[i].second);
m -= p[i].second;
if (m <= 0) {
memo = p[i].first;
break;
}
i++;
}
sum -= (memo * m * (-1));
cout << sum;
return 0;
} | #pragma region _head
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#pragma region _define
#define f(i, a, b) for (LL i = a; i < b; i++)
#define f_vI(v, n) f(i, 0, n) cin >> v[i]
#define f_v2I(v1, v2, n) f(i, 0, n) cin >> v1[i] >> v2[i]
#define f_v3I(v1, v2, v3, n) f(i, 0, n) cin >> v1[i] >> v2[i] >> v3[i]
#define f_vO(v, n, option) f(i, 0, n) cout << v[i] << option;
#define all(a) a.begin(), a.end()
#define size(s) s.size()
#define check() cout << "! ! !"
#define endl "\n"
#define _y() cout << "Yes" << endl
#define _Y() cout << "YES" << endl
#define _n() cout << "No" << endl
#define _N() cout << "NO" << endl
#define INF 1 << 29
#pragma endregion
#pragma region _using
using namespace std;
using LL = long long;
using st = string;
using vi = vector<LL>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vc = vector<char>;
using vs = vector<st>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvvb = vector<vvb>;
using si = stack<LL>;
using ss = stack<st>;
using pi = pair<LL, LL>;
using v_pi = vector<pi>;
#pragma endregion
#pragma region _graph
#define node 50 //グラフの最大位数 適宜変更
// bool graph[node][node]; bool visited[node] = { false };
#define link(a, b, m) \
f(i, 0, m) { \
cin >> a[i] >> b[i]; \
a[i]--; \
b[i]--; \
graph[a[i]][b[i]] = graph[b[i]][a[i]] = true; \
}
#pragma endregion
LL gcd(LL a, LL b) {
LL r;
while ((r = a % b) != 0) {
a = b;
b = r;
}
return b;
}
LL lcm(LL a, LL b) { return (a / gcd(a, b) * b); }
//階乗計算
LL factorial(LL n) {
LL a = 1, ret = 1;
while (a < n) {
a++;
ret *= a;
// ret %= 1000000007;
}
return ret;
}
#pragma endregion
/************************************************************************/
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vi A(n), B(n);
f_v2I(A, B, n);
v_pi p(n);
f(i, 0, n) { p[i] = {A[i], B[i]}; }
sort(all(p));
LL sum = 0;
LL i = 0;
LL memo;
while (true) {
sum += (p[i].first * p[i].second);
m -= p[i].second;
if (m <= 0) {
memo = p[i].first;
break;
}
i++;
}
sum -= (memo * m * (-1));
cout << sum;
return 0;
} | [
"variable_declaration.type.change"
] | 910,808 | 910,809 | u987267288 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
struct drink {
int price;
int number;
};
int main() {
vector<drink> drinks;
int N, M;
cin >> N >> M;
int n, p;
for (int i = 0; i < N; i++) {
drink d;
cin >> d.price >> d.number;
drinks.push_back(d);
}
sort(drinks.begin(), drinks.end(),
[](const drink &x, const drink &y) { return x.price < y.price; });
long ans = 0;
int rem = M;
for (int i = 0; i < N; i++) {
drink d = drinks[i];
if (rem > d.number) {
ans += d.number * d.price;
rem -= d.number;
} else {
ans += rem * d.price;
break;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
struct drink {
int price;
int number;
};
int main() {
vector<drink> drinks;
int N, M;
cin >> N >> M;
int n, p;
for (int i = 0; i < N; i++) {
drink d;
cin >> d.price >> d.number;
drinks.push_back(d);
}
sort(drinks.begin(), drinks.end(),
[](const drink &x, const drink &y) { return x.price < y.price; });
long ans = 0;
int rem = M;
for (int i = 0; i < N; i++) {
drink d = drinks[i];
if (rem > d.number) {
ans += (long)d.number * d.price;
rem -= d.number;
} else {
ans += (long)rem * d.price;
break;
}
}
cout << ans << endl;
return 0;
} | [
"type_conversion.add"
] | 910,824 | 910,825 | u262733088 | cpp |
p03103 | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using lint = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
lint n, m, cnt = 0;
cin >> n >> m;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++)
cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
// for(int i=0;i<n;i++) cout<<v[i].first<<" "<<v[i].second<<endl;
for (int i = 0; i < n; i++) {
if (m - v[i].second <= 0) {
cnt += v[i].second * v[i].first;
m -= v[i].second;
if (m < 0)
cnt -= abs(m) * v[i].first;
break;
} else {
cnt += v[i].second * v[i].first;
m -= v[i].second;
if (m == 0)
break;
}
}
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using lint = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
lint n, m, cnt = 0;
cin >> n >> m;
vector<pair<lint, lint>> v(n);
for (int i = 0; i < n; i++)
cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
// for(int i=0;i<n;i++) cout<<v[i].first<<" "<<v[i].second<<endl;
for (int i = 0; i < n; i++) {
if (m - v[i].second <= 0) {
cnt += v[i].second * v[i].first;
m -= v[i].second;
if (m < 0)
cnt -= abs(m) * v[i].first;
break;
} else {
cnt += v[i].second * v[i].first;
m -= v[i].second;
if (m == 0)
break;
}
}
cout << cnt << endl;
return 0;
}
| [] | 910,826 | 910,827 | u298980954 | cpp |
p03103 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> shop(N);
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
shop[i] = make_pair(a, b);
}
sort(shop.begin(), shop.end());
int sum = 0;
long ans = 0;
for (int i = 0; i < N; i++) {
int count = M - sum < shop[i].second ? M - sum : shop[i].second;
sum += shop[i].second;
ans += count * shop[i].first;
if (sum >= M)
break;
}
cout << ans << endl;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<long, int>> shop(N);
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
shop[i] = make_pair(a, b);
}
sort(shop.begin(), shop.end());
int sum = 0;
long ans = 0;
for (int i = 0; i < N; i++) {
int count = M - sum < shop[i].second ? M - sum : shop[i].second;
sum += shop[i].second;
ans += count * shop[i].first;
if (sum >= M)
break;
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 910,828 | 910,829 | u450733728 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> P(N);
int A, B;
for (int i = 0; i < N; i++) {
cin >> A >> B;
P[i] = make_pair(A, B);
}
sort(P.begin(), P.end());
int ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, P[i].second);
ans += P[i].first * buy;
M -= buy;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> P(N);
int A, B;
for (int i = 0; i < N; i++) {
cin >> A >> B;
P[i] = make_pair(A, B);
}
sort(P.begin(), P.end());
long long ans = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, P[i].second);
ans += P[i].first * (long long)buy;
M -= buy;
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,830 | 910,831 | u319001729 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct SHOPINFO {
public:
int drincNum;
int drincPrice;
SHOPINFO() {
drincNum = 0;
drincPrice = 0;
}
SHOPINFO(int num, int price) {
drincNum = num;
drincPrice = price;
}
};
bool priceLow(SHOPINFO A, SHOPINFO B) {
if (A.drincPrice < B.drincPrice) {
return true;
}
return false;
}
int main(void) {
long long resultNum = 0;
int shop_N, need_M;
cin >> shop_N >> need_M;
vector<SHOPINFO> vShopInfo;
for (int i = 0; i < shop_N; ++i) {
SHOPINFO info;
cin >> info.drincPrice >> info.drincNum;
vShopInfo.push_back(info);
}
std::sort(vShopInfo.begin(), vShopInfo.end(), priceLow);
int buyNum = 0;
long long buyPrice = 0;
for (int i = 0; i < vShopInfo.size(); ++i) {
// 必要数以上になる
if (buyNum + vShopInfo.at(i).drincNum > need_M) {
//
int wantNum = need_M - buyNum;
buyPrice += wantNum * vShopInfo.at(i).drincPrice;
break;
}
// すべて買う
else {
buyPrice += vShopInfo.at(i).drincNum * vShopInfo.at(i).drincPrice;
buyNum += vShopInfo.at(i).drincNum;
}
}
cout << buyPrice << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct SHOPINFO {
public:
long long drincNum;
long long drincPrice;
SHOPINFO() {
drincNum = 0;
drincPrice = 0;
}
SHOPINFO(int num, int price) {
drincNum = num;
drincPrice = price;
}
};
bool priceLow(SHOPINFO A, SHOPINFO B) {
if (A.drincPrice < B.drincPrice) {
return true;
}
return false;
}
int main(void) {
long long resultNum = 0;
int shop_N, need_M;
cin >> shop_N >> need_M;
vector<SHOPINFO> vShopInfo;
for (int i = 0; i < shop_N; ++i) {
SHOPINFO info;
cin >> info.drincPrice >> info.drincNum;
vShopInfo.push_back(info);
}
std::sort(vShopInfo.begin(), vShopInfo.end(), priceLow);
int buyNum = 0;
long long buyPrice = 0;
for (int i = 0; i < vShopInfo.size(); ++i) {
// 必要数以上になる
if (buyNum + vShopInfo.at(i).drincNum > need_M) {
//
int wantNum = need_M - buyNum;
buyPrice += wantNum * vShopInfo.at(i).drincPrice;
break;
}
// すべて買う
else {
buyPrice += vShopInfo.at(i).drincNum * vShopInfo.at(i).drincPrice;
buyNum += vShopInfo.at(i).drincNum;
}
}
cout << buyPrice << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,834 | 910,835 | u376998218 | cpp |
p03099 | #include <bits/stdc++.h>
#define mset(a, b) memset(a, b, sizeof(a))
#define mcpy(a, b) memcpy(a, b, sizeof(a))
using namespace std;
typedef long long LL;
const int N = 405;
const int M = 100005;
const LL INF = 0x3f3f3f3f3f3f3f3f;
template <typename T> inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-')
flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
template <typename T> inline void cmin(T &x, T y) {
if (x > y)
x = y;
}
template <typename T> inline void cmax(T &x, T y) {
if (x < y)
x = y;
}
int tot, S, T, inq[N], pre[N];
LL dis[N];
queue<int> q;
struct Edge {
int v, w, nxt;
LL c;
} e[M << 1];
int first[N], eCnt;
inline void AddEdge(int u, int v, int w, LL c) {
e[++eCnt].v = v;
e[eCnt].w = w;
e[eCnt].c = c;
e[eCnt].nxt = first[u];
first[u] = eCnt;
}
inline void Add(int u, int v, int w, LL c) {
AddEdge(u, v, w, c);
AddEdge(v, u, 0, -c);
}
bool SPFA() {
for (int i = 1; i <= tot; ++i) {
dis[i] = -INF;
}
dis[S] = 0;
q.push(S);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = 0;
for (int i = first[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (e[i].w && dis[v] < dis[u] + e[i].c) {
dis[v] = dis[u] + e[i].c;
pre[v] = i;
if (!inq[v]) {
q.push(v);
inq[v] = 1;
}
}
}
}
return (dis[T] > -INF);
}
LL Update() {
int flow = 100;
for (int i = pre[T]; i; i = pre[e[i ^ 1].v]) {
cmin(flow, e[i].w);
}
for (int i = pre[T]; i; i = pre[e[i ^ 1].v]) {
e[i].w -= flow;
e[i ^ 1].w += flow;
}
return dis[T] * flow;
}
LL Costflow() {
LL mxcost = 0;
while (SPFA()) {
mxcost += Update();
}
return mxcost;
}
char qt[N];
int n, m, X[N], Y[N], qa[N], qb[N];
LL V[N];
int lx[N], rx[N], ly[N], ry[N];
LL Work(int x) {
mset(first, 0);
eCnt = 1;
S = 201, T = tot = 202;
for (int i = 1; i <= x; ++i) {
lx[i] = ly[i] = 1;
rx[i] = ry[i] = 100;
}
for (int i = 1; i <= m; ++i) {
if (qb[i] > x)
continue;
if (qt[i] == 'L') {
cmax(lx[qb[i] + 1], qa[i] + 1);
} else if (qt[i] == 'R') {
cmin(rx[x - qb[i]], qa[i] - 1);
} else if (qt[i] == 'D') {
cmax(ly[qb[i] + 1], qa[i] + 1);
} else if (qt[i] == 'U') {
cmin(ry[x - qb[i]], qa[i] - 1);
}
}
for (int i = 2; i <= x; ++i) {
cmax(lx[i], lx[i - 1]);
cmax(ly[i], ly[i - 1]);
}
for (int i = x - 1; i >= 1; --i) {
cmin(rx[i], rx[i + 1]);
cmin(ry[i], ry[i + 1]);
}
for (int i = 1; i <= n; ++i) {
Add(X[i], 100 + Y[i], 1, V[i]);
}
for (int i = 1; i <= x; ++i) {
if (lx[i] > rx[i] || ly[i] > ry[i])
return -INF;
Add(S, ++tot, 1, 0);
for (int j = lx[i]; j <= rx[i]; ++j) {
Add(tot, j, 1, 0);
}
Add(++tot, T, 1, 0);
for (int j = ly[i]; j <= ry[i]; ++j) {
Add(100 + j, tot, 1, 0);
}
}
return Costflow();
}
void init() {
read(n);
for (int i = 1; i <= n; ++i) {
read(X[i]);
read(Y[i]);
read(V[i]);
}
read(m);
for (int i = 1; i <= m; ++i) {
qt[i] = getchar();
read(qa[i]);
read(qb[i]);
}
}
void solve() {
LL ans = -INF;
for (int i = 1; i <= n; ++i) {
cmax(ans, Work(i));
}
printf("%lld\n", ans);
}
int main() {
init();
solve();
return 0;
}
| #include <bits/stdc++.h>
#define mset(a, b) memset(a, b, sizeof(a))
#define mcpy(a, b) memcpy(a, b, sizeof(a))
using namespace std;
typedef long long LL;
const int N = 405;
const int M = 100005;
const LL INF = 0x3f3f3f3f3f3f3f3f;
template <typename T> inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-')
flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
template <typename T> inline void cmin(T &x, T y) {
if (x > y)
x = y;
}
template <typename T> inline void cmax(T &x, T y) {
if (x < y)
x = y;
}
int tot, S, T, inq[N], pre[N];
LL dis[N];
queue<int> q;
struct Edge {
int v, w, nxt;
LL c;
} e[M << 1];
int first[N], eCnt;
inline void AddEdge(int u, int v, int w, LL c) {
e[++eCnt].v = v;
e[eCnt].w = w;
e[eCnt].c = c;
e[eCnt].nxt = first[u];
first[u] = eCnt;
}
inline void Add(int u, int v, int w, LL c) {
AddEdge(u, v, w, c);
AddEdge(v, u, 0, -c);
}
bool SPFA() {
for (int i = 1; i <= tot; ++i) {
dis[i] = -INF;
}
dis[S] = 0;
q.push(S);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = 0;
for (int i = first[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (e[i].w && dis[v] < dis[u] + e[i].c) {
dis[v] = dis[u] + e[i].c;
pre[v] = i;
if (!inq[v]) {
q.push(v);
inq[v] = 1;
}
}
}
}
return (dis[T] > -INF);
}
LL Update() {
int flow = 100;
for (int i = pre[T]; i; i = pre[e[i ^ 1].v]) {
cmin(flow, e[i].w);
}
for (int i = pre[T]; i; i = pre[e[i ^ 1].v]) {
e[i].w -= flow;
e[i ^ 1].w += flow;
}
return dis[T] * flow;
}
LL Costflow() {
LL mxcost = 0;
while (SPFA()) {
mxcost += Update();
}
return mxcost;
}
char qt[N];
int n, m, X[N], Y[N], qa[N], qb[N];
LL V[N];
int lx[N], rx[N], ly[N], ry[N];
LL Work(int x) {
mset(first, 0);
eCnt = 1;
S = 201, T = tot = 202;
for (int i = 1; i <= x; ++i) {
lx[i] = ly[i] = 1;
rx[i] = ry[i] = 100;
}
for (int i = 1; i <= m; ++i) {
if (qb[i] > x)
continue;
if (qt[i] == 'L') {
cmax(lx[qb[i] + 1], qa[i] + 1);
} else if (qt[i] == 'R') {
cmin(rx[x - qb[i]], qa[i] - 1);
} else if (qt[i] == 'D') {
cmax(ly[qb[i] + 1], qa[i] + 1);
} else if (qt[i] == 'U') {
cmin(ry[x - qb[i]], qa[i] - 1);
}
}
for (int i = 2; i <= x; ++i) {
cmax(lx[i], lx[i - 1]);
cmax(ly[i], ly[i - 1]);
}
for (int i = x - 1; i >= 1; --i) {
cmin(rx[i], rx[i + 1]);
cmin(ry[i], ry[i + 1]);
}
for (int i = 1; i <= n; ++i) {
Add(X[i], 100 + Y[i], 1, V[i]);
}
for (int i = 1; i <= x; ++i) {
if (lx[i] > rx[i] || ly[i] > ry[i])
return -INF;
Add(S, ++tot, 1, 0);
for (int j = lx[i]; j <= rx[i]; ++j) {
Add(tot, j, 1, 0);
}
Add(++tot, T, 1, 0);
for (int j = ly[i]; j <= ry[i]; ++j) {
Add(100 + j, tot, 1, 0);
}
}
return Costflow();
}
void init() {
read(n);
for (int i = 1; i <= n; ++i) {
read(X[i]);
read(Y[i]);
read(V[i]);
}
read(m);
for (int i = 1; i <= m; ++i) {
qt[i] = getchar();
read(qa[i]);
read(qb[i]);
}
}
void solve() {
LL ans = 0;
for (int i = 1; i <= n; ++i) {
cmax(ans, Work(i));
}
printf("%lld\n", ans);
}
int main() {
init();
solve();
return 0;
}
| [
"variable_declaration.value.change",
"expression.operation.unary.remove"
] | 910,844 | 910,845 | u873618015 | cpp |
p03099 | #include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v)
is >> x;
return is;
}
ostream &operator<<(ostream &os, const pair<char, int> &unit) {
return os << unit.first << "^" << unit.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i)
os << ' ' << v[i];
}
return os;
}
namespace Min25 {
#define _rep(_1, _2, _3, _4, name, ...) name
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, c) for (int i = int(a); i < int(b); i += int(c))
#define rep(...) _rep(__VA_ARGS__, rep4, rep3, rep2, _)(__VA_ARGS__)
using namespace std;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f80 = long double;
template <typename CapType, typename TotalCapType, typename CostType,
typename TotalCostType>
class CostScaling {
private:
static const int alpha = 8; // eps <- max(1, eps / alpha)
using cap_t = CapType;
using tcap_t = TotalCapType;
using cost_t = CostType; // > max{|C|} * (2 * |V|)
using tcost_t = TotalCostType;
static constexpr cost_t Inf = (tcap_t(1) << (sizeof(tcap_t) * 8 - 2)) - 1;
struct InputEdge {
int from, to;
cap_t b, c;
cost_t cost;
};
struct Edge {
int to, rev;
cap_t cap;
cost_t cost;
};
class Dinic {
public:
Dinic(int N, const vector<int> &ofs, vector<Edge> &edges,
vector<tcap_t> &capacity)
: N(N), ofs(ofs), edges(edges), capacity(capacity), last(N) {}
bool succeeded() {
// s -> u: capacity[u]
// u -> t: capacity[u + N]
tcap_t f = 0;
for (int u = 0; u < N; ++u)
f += capacity[u];
vector<int> que(N);
while (f) {
dist.assign(N, -1);
int qh = 0, qt = 0, lv = N;
for (int u = 0; u < N; ++u)
if (capacity[u] > 0)
que[qt++] = u, dist[u] = 0;
for (; qh < qt;) {
int u = que[qh++];
if (lv == N && capacity[u + N] > 0)
lv = dist[u];
if (dist[u] > lv)
break;
for (int ei = ofs[u]; ei < ofs[u + 1]; ++ei) {
int v = edges[ei].to;
if (edges[ei].cap > 0 && dist[v] == -1) {
que[qt++] = v, dist[v] = dist[u] + 1;
}
}
}
if (lv == N)
break;
for (int u = 0; u < N; ++u)
last[u] = ofs[u];
for (int u = 0; u < N; ++u)
if (capacity[u] > 0) {
auto df = block_flow(u, capacity[u]);
f -= df, capacity[u] -= df;
}
}
return f == 0;
}
private:
tcap_t block_flow(int u, tcap_t f) {
tcap_t ret = 0;
if (capacity[u + N] > 0) {
tcap_t df = min(f, capacity[u + N]);
capacity[u + N] -= df;
return df;
}
for (auto &ei = last[u]; ei < ofs[u + 1]; ++ei) {
auto &e = edges[ei];
int v = e.to;
if (e.cap == 0 || dist[v] <= dist[u])
continue;
cap_t df = block_flow(v, min<cap_t>(e.cap, f));
if (df == 0)
continue;
e.cap -= df, edges[e.rev].cap += df;
f -= df, ret += df;
if (f == 0)
break;
}
return ret;
}
int N;
const vector<int> &ofs;
vector<Edge> &edges;
vector<tcap_t> &capacity;
vector<int> last, dist;
};
public:
CostScaling(int N, int M = 0) : N(N), capacity(2 * N) {
if (M > 0)
in.reserve(M);
}
void add_directed_edge(int u, int v, cap_t b, cap_t c, cost_t cost) {
if (b > 0)
capacity[v] += b, capacity[u + N] += b;
else
capacity[u] += -b, capacity[v + N] += -b;
in.push_back({u, v, b, c, cost});
}
pair<bool, tcost_t> minimum_cost_circulation() {
construct();
if (!has_feasible_circulation())
return {false, 0};
const int cost_multiplier = 2 << __lg(N); // should be > |V|
cost_t eps = 0;
for (auto &e : edges)
e.cost *= cost_multiplier, eps = max(eps, e.cost);
while (eps > 1)
refine(eps = max<cost_t>(1, eps / alpha));
tcost_t ret = initial_cost;
for (auto &e : edges)
ret -= (e.cost / cost_multiplier) * e.cap;
return {true, ret / 2};
}
private:
void refine(const cost_t eps) {
auto cost_p = [&](int u, const Edge &e) {
return e.cost + potential[u] - potential[e.to];
};
for (int u = 0; u < N; ++u)
for (int i = ofs[u]; i < ofs[u + 1]; ++i) {
auto &e = edges[i];
if (cost_p(u, e) < 0)
edges[e.rev].cap += e.cap, e.cap = 0;
}
vector<tcap_t> excess(initial_excess);
for (auto &e : edges)
excess[e.to] -= e.cap;
vector<int> stack;
stack.reserve(N);
for (int u = 0; u < N; ++u)
if (excess[u] > 0)
stack.push_back(u);
auto residue = [&](const Edge &e) -> cap_t { return e.cap; };
auto push = [&](int u, Edge &e, cap_t df) {
e.cap -= df;
edges[e.rev].cap += df;
excess[e.to] += df;
excess[u] -= df;
if (excess[e.to] > 0 && excess[e.to] <= df) {
stack.push_back(e.to);
}
};
auto relabel = [&](int u, cost_t delta) { potential[u] -= delta + eps; };
auto relabel_in_advance = [&](int u) {
if (excess[u] != 0)
return false;
auto delta = Inf;
for (int ei = ofs[u]; ei < ofs[u + 1]; ++ei) {
auto &e = edges[ei];
if (residue(e) == 0)
continue;
if (cost_p(u, e) < 0)
return false;
else
delta = min<tcost_t>(delta, cost_p(u, e));
}
relabel(u, delta);
return true;
};
auto discharge = [&](int u) {
auto delta = Inf;
for (int ei = ofs[u]; ei < ofs[u + 1]; ++ei) {
auto &e = edges[ei];
if (residue(e) == 0)
continue;
if (cost_p(u, e) < 0) {
if (relabel_in_advance(e.to)) {
--ei;
continue; // modify ei (!)
}
cap_t df = min<tcap_t>(excess[u], residue(e));
push(u, e, df);
if (!excess[u])
return;
} else
delta = min<tcost_t>(delta, cost_p(u, e));
}
relabel(u, delta);
stack.push_back(u);
};
while (!stack.empty()) {
auto u = stack.back();
stack.pop_back();
discharge(u);
}
}
void construct() {
ofs.assign(N + 1, 0);
edges.resize(2 * in.size());
initial_excess.assign(N, 0);
initial_cost = 0;
potential.assign(N, 0);
for (auto &e : in)
ofs[e.from + 1]++, ofs[e.to + 1]++;
for (int i = 1; i <= N; ++i)
ofs[i] += ofs[i - 1];
for (auto &e : in) {
initial_excess[e.to] += e.c;
initial_excess[e.from] += -e.b;
initial_cost += tcost_t(e.cost) * (e.c + e.b);
edges[ofs[e.from]++] = {e.to, ofs[e.to], e.c - e.b, e.cost};
edges[ofs[e.to]++] = {e.from, ofs[e.from] - 1, 0, -e.cost};
}
for (int i = N; i > 0; --i)
ofs[i] = ofs[i - 1];
ofs[0] = 0;
}
bool has_feasible_circulation() {
return Dinic(N, ofs, edges, capacity).succeeded();
}
private:
int N;
vector<InputEdge> in;
vector<tcap_t> capacity;
vector<int> ofs;
vector<Edge> edges;
tcost_t initial_cost;
vector<tcap_t> initial_excess;
vector<tcost_t> potential;
};
using MCC = CostScaling<int64_t, int64_t, int64_t, int64_t>;
} // namespace Min25
#undef _rep
#undef rep
#undef rep2
#undef rep3
#undef rep4
struct MinCostMaxFlow {
Min25::MCC mcc1, mcc2;
MinCostMaxFlow(int n, int m) : mcc1(n, m), mcc2(n, m) {}
void addEdge(int u, int v, ll w) {
mcc1.add_directed_edge(u, v, 0, 1, 0);
mcc2.add_directed_edge(u, v, 0, 1, w);
}
pair<int, ll> mcmf() {
mcc1.add_directed_edge(1, 0, 0, 1e18, -1);
auto maxFlow = -mcc1.minimum_cost_circulation().second;
mcc2.add_directed_edge(1, 0, maxFlow, maxFlow, 0);
return make_pair(maxFlow, mcc2.minimum_cost_circulation().second);
}
};
template <class T> void chkMax(T &x, const T &y) {
if (y > x)
x = y;
}
template <class T> void chkMin(T &x, const T &y) {
if (y < x)
x = y;
}
const int N = 85, M = N * 4;
int n;
int x[N], y[N];
ll v[N];
int m;
char t[M];
int a[M], b[M];
int l[N], r[N], d[N], u[N];
int main() {
#ifdef LBT
freopen("test.in", "r", stdin);
int nol_cl = clock();
#endif
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> x[i] >> y[i] >> v[i];
cin >> m;
for (int i = 1; i <= m; ++i)
cin >> t[i] >> a[i] >> b[i];
ll ans = 0;
for (int k = 1; k <= n; ++k) {
fill(l + 1, l + k + 1, 1);
fill(r + 1, r + k + 1, 100);
fill(d + 1, d + k + 1, 1);
fill(u + 1, u + k + 1, 100);
for (int i = 1; i <= m; ++i) {
if (b[i] >= k)
continue;
if (t[i] == 'L')
chkMax(l[b[i] + 1], a[i] + 1);
else if (t[i] == 'R')
chkMin(r[k - b[i]], a[i] - 1);
else if (t[i] == 'D')
chkMax(d[b[i] + 1], a[i] + 1);
else
chkMin(u[k - b[i]], a[i] - 1);
}
for (int i = 2; i <= k; ++i)
chkMax(l[i], l[i - 1]);
for (int i = 2; i <= k; ++i)
chkMax(d[i], d[i - 1]);
for (int i = k - 1; i; --i)
chkMin(r[i], r[i + 1]);
for (int i = k - 1; i; --i)
chkMin(u[i], u[i + 1]);
int S = 0, T = 1; // 2 + N * 2 + K * 2
// k * 2 + n +
MinCostMaxFlow mcmf(n * 2 + k * 2 + 2, n + k * 2 + n * k * 2);
for (int i = 1; i <= n; ++i)
mcmf.addEdge(i * 2, i * 2 + 1, 1e15 - v[i]);
// max : n * 2 + 1, n * 2 + i
// cerr << n *2 + 1 << ' ';
for (int i = 1; i <= k; ++i) {
mcmf.addEdge(S, n * 2 + 1 + i, 0);
mcmf.addEdge(n * 2 + k + 1 + i, T, 0);
for (int j = 1; j <= n; ++j) {
if (l[i] <= x[j] && x[j] <= r[i])
mcmf.addEdge(n * 2 + 1 + i, j * 2, 0);
if (d[i] <= y[j] && y[j] <= u[i])
mcmf.addEdge(j * 2 + 1, n * 2 + k + 1 + i, 0);
}
}
auto val = mcmf.mcmf();
// cerr << val.first << ' ' << k << ' ' << val.second << '\n';
if (val.first == k)
chkMax(ans, ll(k * 1e15 - val.second));
}
cout << ans << '\n';
#ifdef LBT
LOG("Time: %dms\n", int((clock() - nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
return 0;
}
| #include <bits/stdc++.h>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v)
is >> x;
return is;
}
ostream &operator<<(ostream &os, const pair<char, int> &unit) {
return os << unit.first << "^" << unit.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i)
os << ' ' << v[i];
}
return os;
}
namespace Min25 {
#define _rep(_1, _2, _3, _4, name, ...) name
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, c) for (int i = int(a); i < int(b); i += int(c))
#define rep(...) _rep(__VA_ARGS__, rep4, rep3, rep2, _)(__VA_ARGS__)
using namespace std;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f80 = long double;
template <typename CapType, typename TotalCapType, typename CostType,
typename TotalCostType>
class CostScaling {
private:
static const int alpha = 8; // eps <- max(1, eps / alpha)
using cap_t = CapType;
using tcap_t = TotalCapType;
using cost_t = CostType; // > max{|C|} * (2 * |V|)
using tcost_t = TotalCostType;
static constexpr cost_t Inf = (tcap_t(1) << (sizeof(tcap_t) * 8 - 2)) - 1;
struct InputEdge {
int from, to;
cap_t b, c;
cost_t cost;
};
struct Edge {
int to, rev;
cap_t cap;
cost_t cost;
};
class Dinic {
public:
Dinic(int N, const vector<int> &ofs, vector<Edge> &edges,
vector<tcap_t> &capacity)
: N(N), ofs(ofs), edges(edges), capacity(capacity), last(N) {}
bool succeeded() {
// s -> u: capacity[u]
// u -> t: capacity[u + N]
tcap_t f = 0;
for (int u = 0; u < N; ++u)
f += capacity[u];
vector<int> que(N);
while (f) {
dist.assign(N, -1);
int qh = 0, qt = 0, lv = N;
for (int u = 0; u < N; ++u)
if (capacity[u] > 0)
que[qt++] = u, dist[u] = 0;
for (; qh < qt;) {
int u = que[qh++];
if (lv == N && capacity[u + N] > 0)
lv = dist[u];
if (dist[u] > lv)
break;
for (int ei = ofs[u]; ei < ofs[u + 1]; ++ei) {
int v = edges[ei].to;
if (edges[ei].cap > 0 && dist[v] == -1) {
que[qt++] = v, dist[v] = dist[u] + 1;
}
}
}
if (lv == N)
break;
for (int u = 0; u < N; ++u)
last[u] = ofs[u];
for (int u = 0; u < N; ++u)
if (capacity[u] > 0) {
auto df = block_flow(u, capacity[u]);
f -= df, capacity[u] -= df;
}
}
return f == 0;
}
private:
tcap_t block_flow(int u, tcap_t f) {
tcap_t ret = 0;
if (capacity[u + N] > 0) {
tcap_t df = min(f, capacity[u + N]);
capacity[u + N] -= df;
return df;
}
for (auto &ei = last[u]; ei < ofs[u + 1]; ++ei) {
auto &e = edges[ei];
int v = e.to;
if (e.cap == 0 || dist[v] <= dist[u])
continue;
cap_t df = block_flow(v, min<cap_t>(e.cap, f));
if (df == 0)
continue;
e.cap -= df, edges[e.rev].cap += df;
f -= df, ret += df;
if (f == 0)
break;
}
return ret;
}
int N;
const vector<int> &ofs;
vector<Edge> &edges;
vector<tcap_t> &capacity;
vector<int> last, dist;
};
public:
CostScaling(int N, int M = 0) : N(N), capacity(2 * N) {
if (M > 0)
in.reserve(M);
}
void add_directed_edge(int u, int v, cap_t b, cap_t c, cost_t cost) {
if (b > 0)
capacity[v] += b, capacity[u + N] += b;
else
capacity[u] += -b, capacity[v + N] += -b;
in.push_back({u, v, b, c, cost});
}
pair<bool, tcost_t> minimum_cost_circulation() {
construct();
if (!has_feasible_circulation())
return {false, 0};
const int cost_multiplier = 2 << __lg(N); // should be > |V|
cost_t eps = 0;
for (auto &e : edges)
e.cost *= cost_multiplier, eps = max(eps, e.cost);
while (eps > 1)
refine(eps = max<cost_t>(1, eps / alpha));
tcost_t ret = initial_cost;
for (auto &e : edges)
ret -= (e.cost / cost_multiplier) * e.cap;
return {true, ret / 2};
}
private:
void refine(const cost_t eps) {
auto cost_p = [&](int u, const Edge &e) {
return e.cost + potential[u] - potential[e.to];
};
for (int u = 0; u < N; ++u)
for (int i = ofs[u]; i < ofs[u + 1]; ++i) {
auto &e = edges[i];
if (cost_p(u, e) < 0)
edges[e.rev].cap += e.cap, e.cap = 0;
}
vector<tcap_t> excess(initial_excess);
for (auto &e : edges)
excess[e.to] -= e.cap;
vector<int> stack;
stack.reserve(N);
for (int u = 0; u < N; ++u)
if (excess[u] > 0)
stack.push_back(u);
auto residue = [&](const Edge &e) -> cap_t { return e.cap; };
auto push = [&](int u, Edge &e, cap_t df) {
e.cap -= df;
edges[e.rev].cap += df;
excess[e.to] += df;
excess[u] -= df;
if (excess[e.to] > 0 && excess[e.to] <= df) {
stack.push_back(e.to);
}
};
auto relabel = [&](int u, cost_t delta) { potential[u] -= delta + eps; };
auto relabel_in_advance = [&](int u) {
if (excess[u] != 0)
return false;
auto delta = Inf;
for (int ei = ofs[u]; ei < ofs[u + 1]; ++ei) {
auto &e = edges[ei];
if (residue(e) == 0)
continue;
if (cost_p(u, e) < 0)
return false;
else
delta = min<tcost_t>(delta, cost_p(u, e));
}
relabel(u, delta);
return true;
};
auto discharge = [&](int u) {
auto delta = Inf;
for (int ei = ofs[u]; ei < ofs[u + 1]; ++ei) {
auto &e = edges[ei];
if (residue(e) == 0)
continue;
if (cost_p(u, e) < 0) {
if (relabel_in_advance(e.to)) {
--ei;
continue; // modify ei (!)
}
cap_t df = min<tcap_t>(excess[u], residue(e));
push(u, e, df);
if (!excess[u])
return;
} else
delta = min<tcost_t>(delta, cost_p(u, e));
}
relabel(u, delta);
stack.push_back(u);
};
while (!stack.empty()) {
auto u = stack.back();
stack.pop_back();
discharge(u);
}
}
void construct() {
ofs.assign(N + 1, 0);
edges.resize(2 * in.size());
initial_excess.assign(N, 0);
initial_cost = 0;
potential.assign(N, 0);
for (auto &e : in)
ofs[e.from + 1]++, ofs[e.to + 1]++;
for (int i = 1; i <= N; ++i)
ofs[i] += ofs[i - 1];
for (auto &e : in) {
initial_excess[e.to] += e.c;
initial_excess[e.from] += -e.b;
initial_cost += tcost_t(e.cost) * (e.c + e.b);
edges[ofs[e.from]++] = {e.to, ofs[e.to], e.c - e.b, e.cost};
edges[ofs[e.to]++] = {e.from, ofs[e.from] - 1, 0, -e.cost};
}
for (int i = N; i > 0; --i)
ofs[i] = ofs[i - 1];
ofs[0] = 0;
}
bool has_feasible_circulation() {
return Dinic(N, ofs, edges, capacity).succeeded();
}
private:
int N;
vector<InputEdge> in;
vector<tcap_t> capacity;
vector<int> ofs;
vector<Edge> edges;
tcost_t initial_cost;
vector<tcap_t> initial_excess;
vector<tcost_t> potential;
};
using MCC = CostScaling<int64_t, int64_t, int64_t, int64_t>;
} // namespace Min25
#undef _rep
#undef rep
#undef rep2
#undef rep3
#undef rep4
struct MinCostMaxFlow {
Min25::MCC mcc1, mcc2;
MinCostMaxFlow(int n, int m) : mcc1(n, m), mcc2(n, m) {}
void addEdge(int u, int v, ll w) {
mcc1.add_directed_edge(u, v, 0, 1, 0);
mcc2.add_directed_edge(u, v, 0, 1, w);
}
pair<int, ll> mcmf() {
mcc1.add_directed_edge(1, 0, 0, 1e18, -1);
auto maxFlow = -mcc1.minimum_cost_circulation().second;
mcc2.add_directed_edge(1, 0, maxFlow, maxFlow, 0);
return make_pair(maxFlow, mcc2.minimum_cost_circulation().second);
}
};
template <class T> void chkMax(T &x, const T &y) {
if (y > x)
x = y;
}
template <class T> void chkMin(T &x, const T &y) {
if (y < x)
x = y;
}
const int N = 85, M = N * 4;
int n;
int x[N], y[N];
ll v[N];
int m;
char t[M];
int a[M], b[M];
int l[N], r[N], d[N], u[N];
int main() {
#ifdef LBT
freopen("test.in", "r", stdin);
int nol_cl = clock();
#endif
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> x[i] >> y[i] >> v[i];
cin >> m;
for (int i = 1; i <= m; ++i)
cin >> t[i] >> a[i] >> b[i];
ll ans = 0;
for (int k = 1; k <= n; ++k) {
fill(l + 1, l + k + 1, 1);
fill(r + 1, r + k + 1, 100);
fill(d + 1, d + k + 1, 1);
fill(u + 1, u + k + 1, 100);
for (int i = 1; i <= m; ++i) {
if (b[i] >= k)
continue;
if (t[i] == 'L')
chkMax(l[b[i] + 1], a[i] + 1);
else if (t[i] == 'R')
chkMin(r[k - b[i]], a[i] - 1);
else if (t[i] == 'D')
chkMax(d[b[i] + 1], a[i] + 1);
else
chkMin(u[k - b[i]], a[i] - 1);
}
for (int i = 2; i <= k; ++i)
chkMax(l[i], l[i - 1]);
for (int i = 2; i <= k; ++i)
chkMax(d[i], d[i - 1]);
for (int i = k - 1; i; --i)
chkMin(r[i], r[i + 1]);
for (int i = k - 1; i; --i)
chkMin(u[i], u[i + 1]);
int S = 0, T = 1; // 2 + N * 2 + K * 2
// k * 2 + n +
MinCostMaxFlow mcmf(n * 2 + k * 2 + 2, n + k * 2 + n * k * 2);
for (int i = 1; i <= n; ++i)
mcmf.addEdge(i * 2, i * 2 + 1, (ll)1e15 - v[i]);
// max : n * 2 + 1, n * 2 + i
// cerr << n *2 + 1 << ' ';
for (int i = 1; i <= k; ++i) {
mcmf.addEdge(S, n * 2 + 1 + i, 0);
mcmf.addEdge(n * 2 + k + 1 + i, T, 0);
for (int j = 1; j <= n; ++j) {
if (l[i] <= x[j] && x[j] <= r[i])
mcmf.addEdge(n * 2 + 1 + i, j * 2, 0);
if (d[i] <= y[j] && y[j] <= u[i])
mcmf.addEdge(j * 2 + 1, n * 2 + k + 1 + i, 0);
}
}
auto val = mcmf.mcmf();
// cerr << val.first << ' ' << k << ' ' << val.second << '\n';
if (val.first == k)
chkMax(ans, ll(k * (ll)1e15 - val.second));
}
cout << ans << '\n';
#ifdef LBT
LOG("Time: %dms\n", int((clock() - nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
return 0;
}
| [
"type_conversion.add"
] | 910,852 | 910,853 | u895067736 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.