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 |
|---|---|---|---|---|---|---|---|
p03102 | #include <iostream>
using namespace std;
long long calc(const int A[], const int B[], int N) {
long long sum = 0;
for (int i = 0; i < N; i++) {
// cout << "A*B: " << A[i] * B[i] << endl;
sum += A[i] * B[i];
}
// cout << "sum: " << sum << endl;
return sum;
}
int main(int argc, char const *argv[]) {
unsigned long long N, M, C, ret = 0;
cin >> N >> M >> C;
int B[M], A[N][M];
for (int i = 0; i < M; i++) {
cin >> B[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < M; i++) {
long long tmp = calc(A[i], B, N) + C;
if (tmp > 0) {
ret++;
}
}
cout << ret;
return 0;
} | #include <iostream>
using namespace std;
long long calc(const int A[], const int B[], int N) {
long long sum = 0;
for (int i = 0; i < N; i++) {
sum += A[i] * B[i];
}
return sum;
}
int main(int argc, char const *argv[]) {
int N, M, C, ret = 0;
cin >> N >> M >> C;
int B[M], A[N][M];
for (int i = 0; i < M; i++) {
cin >> B[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < N; i++) {
long long tmp = calc(A[i], B, M) + C;
if (tmp > 0) {
ret++;
}
}
cout << ret;
return 0;
} | [
"variable_declaration.type.primitive.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 909,815 | 909,813 | u481487723 | cpp |
p03102 | #include <cstdio>
#include <iostream>
using namespace std;
int n, m, c;
int a[25][25];
int b[25];
int main() {
int cnt = 0;
scanf("%d%d%d", &n, &m, &c);
for (int i = 1; i <= m; i++)
scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i <= n; i++) {
int sum = 0;
for (int j = 1; j <= m; j++) {
sum += a[i][j] * b[j];
}
if ((sum - c) > 0)
cnt++;
sum = 0;
}
printf("%d", cnt / 2);
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int n, m, c;
int a[25][25];
int b[25];
int main() {
int cnt = 0;
scanf("%d%d%d", &n, &m, &c);
// cout<<"c="<<c<<endl;
for (int i = 1; i <= m; i++)
scanf("%d", &b[i]);
// for(int i=1;i<=m;i++)
// cout<<b[i]<<" ";
// cout<<endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
// for(int i=0;i<n;i++)
// {
// for(int j=0;j<m;j++)
// {
// cout<<a[i][j]<<" ";
// }
// cout<<endl;
// }
for (int i = 1; i <= n; i++) {
int sum = 0;
for (int j = 1; j <= m; j++) {
// cout<<"a="<<a[i][j]<<" "<<"b="<<b[j]<<endl;
sum = sum + a[i][j] * b[j];
// cout<<sum<<endl;
}
// cout<<"sum="<<sum<<endl;
if ((sum + c) > 0)
cnt++;
sum = 0;
}
printf("%d", cnt);
return 0;
} | [
"assignment.value.change",
"assignment.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 909,818 | 909,819 | u276626173 | cpp |
p03102 | #include <bits/stdc++.h>
#define inf 1 << 30
#define p5 100007
#define p6 1000007
#define PI acos(-1)
#define M 1000000007
#define sc scanf
#define ss second
#define ff first
#define pf printf
#define scin(x) sc("%d", &(x))
#define scin2(x, y) sc("d", &(x), &(y))
#define READ(f) freopen(f, "r", stdin)
#define WRITE(f) freopen(f, "w", stdout)
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define FastRead \
ios_base::sync_with_stdio(0); \
cin.tie(0)
// int month[]={31,28,31,30,31,30,31,31,30,31,30,31};
// int dx[5] = {1, -1, 0, 0 };
// int dy[5] = {0, 0, 1, -1};
using namespace std;
int main() {
int n, m, c, i, j;
cin >> n >> m >> c;
int ar[m];
for (j = 0; j < m; j++) {
cin >> ar[j];
}
int cnt = 0;
for (i = 0; i < n; i++) {
int s = 0;
for (j = 0; j < m; j++) {
int a;
cin >> a;
s = ar[j] * a;
}
s = s + c;
if (s > 0)
cnt++;
}
cout << cnt << endl;
return 0;
}
// CsE91971@%Cou
| #include <bits/stdc++.h>
#define inf 1 << 30
#define p5 100007
#define p6 1000007
#define PI acos(-1)
#define M 1000000007
#define sc scanf
#define ss second
#define ff first
#define pf printf
#define scin(x) sc("%d", &(x))
#define scin2(x, y) sc("d", &(x), &(y))
#define READ(f) freopen(f, "r", stdin)
#define WRITE(f) freopen(f, "w", stdout)
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pp pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define FastRead \
ios_base::sync_with_stdio(0); \
cin.tie(0)
// int month[]={31,28,31,30,31,30,31,31,30,31,30,31};
// int dx[5] = {1, -1, 0, 0 };
// int dy[5] = {0, 0, 1, -1};
using namespace std;
int main() {
int n, m, c, i, j;
cin >> n >> m >> c;
int ar[m];
for (j = 0; j < m; j++) {
cin >> ar[j];
}
int cnt = 0;
for (i = 0; i < n; i++) {
int s = 0;
for (j = 0; j < m; j++) {
int a;
cin >> a;
s = s + ar[j] * a;
}
s = s + c;
if (s > 0)
cnt++;
}
cout << cnt << endl;
return 0;
}
// CsE91971@%Cou
| [
"assignment.change"
] | 909,826 | 909,827 | u668288277 | cpp |
p03102 | #include <iostream>
using namespace std;
int main() {
int n, m, c, ans = 0;
cin >> n >> m >> c;
int b[m], a[n][m];
for (int i = 0; i < m; ++i)
cin >> b[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][m];
}
}
for (int i = 0; i < n; ++i) {
long long int d = 0;
for (int j = 0; j < m; ++j) {
d += a[i][m] * b[j];
}
d += c;
if (d > 0)
ans++;
}
cout << ans << endl;
} | #include <iostream>
using namespace std;
int main() {
int n, m, c, ans = 0;
cin >> n >> m >> c;
int b[m], a[n][m];
for (int i = 0; i < m; ++i)
cin >> b[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; ++i) {
long long int d = 0;
for (int j = 0; j < m; ++j) {
d += a[i][j] * b[j];
}
d += c;
if (d > 0)
ans++;
}
cout << ans << endl;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 909,828 | 909,829 | u021083776 | cpp |
p03102 | #include <iostream>
using namespace std;
int main() {
int N, M, C, sum, ans = 0;
cin >> N >> M >> C;
int B[M];
for (int i = 0; i < M; i++) {
cin >> B[i];
}
int A[N][M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < N; i++) {
sum = 0;
for (int j = 0; j < M; j++) {
sum += A[N][M] * B[M];
}
sum += C;
if (sum > 0) {
ans++;
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, M, C, sum, ans = 0;
cin >> N >> M >> C;
int B[M];
for (int i = 0; i < M; i++) {
cin >> B[i];
}
int A[N][M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < N; i++) {
sum = 0;
for (int j = 0; j < M; j++) {
sum += A[i][j] * B[j];
}
sum += C;
if (sum > 0) {
ans++;
}
}
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 909,833 | 909,834 | u274317341 | cpp |
p03102 | #include <iostream>
using namespace std;
int main() {
int N, M, C;
int A[21][21] = {0};
int B[21] = {0};
int count;
int right = 0;
cin >> N >> M >> C;
for (int i = 0; i < M; ++i) {
cin >> B[i];
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
cin >> A[i][j];
}
}
for (int i = 0; i < N; ++i) {
count = 0;
for (int j = 0; j < N; ++j) {
count += A[i][j] * B[j];
}
count += C;
if (count > 0) {
right++;
}
}
cout << right << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, M, C;
int A[21][21] = {0};
int B[21] = {0};
int count;
int right = 0;
cin >> N >> M >> C;
for (int i = 0; i < M; ++i) {
cin >> B[i];
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
cin >> A[i][j];
}
}
for (int i = 0; i < N; ++i) {
count = 0;
for (int j = 0; j < M; ++j) {
count += A[i][j] * B[j];
}
count += C;
if (count > 0) {
right++;
}
}
cout << right << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 909,835 | 909,836 | u318150500 | cpp |
p03102 | #include <algorithm>
#include <cstdio>
int main(int argc, char const *argv[]) {
int n, m, c;
scanf("%d %d %d", &n, &m, &c);
int a[n][m];
int b[m];
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int ans = 0;
int check = 0;
for (int i = 0; i < n; i++) {
check = 0;
for (int j = 0; j < m; j++) {
check += a[i][j] * b[m];
}
if (check + c > 0)
ans++;
}
printf("%d", ans);
return 0;
}
| #include <algorithm>
#include <cstdio>
int main(int argc, char const *argv[]) {
int n, m, c;
scanf("%d %d %d", &n, &m, &c);
int a[n][m];
int b[m];
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int ans = 0;
int check = 0;
for (int i = 0; i < n; i++) {
check = 0;
for (int j = 0; j < m; j++) {
check += a[i][j] * b[j];
}
if (check + c > 0)
ans++;
}
printf("%d", ans);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 909,837 | 909,838 | u117345342 | cpp |
p03102 | #include <algorithm>
#include <cstdio>
int main(int argc, char const *argv[]) {
int n, m, c;
scanf("%d %d %d", &n, &m, &c);
int a[n][m];
int b[m];
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int ans = 0;
int check = 0;
for (int i = 0; i < n; i++) {
check = 0;
for (int j = 0; j < m; j++) {
check += a[i][j] * b[m];
}
if (check + c >= 0)
ans++;
}
printf("%d", ans);
return 0;
} | #include <algorithm>
#include <cstdio>
int main(int argc, char const *argv[]) {
int n, m, c;
scanf("%d %d %d", &n, &m, &c);
int a[n][m];
int b[m];
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int ans = 0;
int check = 0;
for (int i = 0; i < n; i++) {
check = 0;
for (int j = 0; j < m; j++) {
check += a[i][j] * b[j];
}
if (check + c > 0)
ans++;
}
printf("%d", ans);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 909,839 | 909,838 | u117345342 | cpp |
p03102 | #include <stdio.h>
using namespace std;
int main() {
int n, m, c, totl = 0;
int b[30], a;
scanf("%d%d%d", &n, &m, &c);
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
scanf("%d", &a);
sum += a * b[j];
}
if (sum > 0) {
totl++;
}
}
printf("%d\n", totl);
} | #include <stdio.h>
using namespace std;
int main() {
int n, m, c, totl = 0;
int b[30], a;
scanf("%d%d%d", &n, &m, &c);
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
scanf("%d", &a);
sum += a * b[j];
}
sum += c;
if (sum > 0) {
totl++;
}
}
printf("%d\n", totl);
} | [
"assignment.add"
] | 909,842 | 909,843 | u684491393 | cpp |
p03102 | #include <bits/stdc++.h>
using namespace std;
/*{{{*/ // template
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long LINF = numeric_limits<long long>::max() / 3;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr << #x << ":" << x << endl
#define debug2(x, y) cerr << #x << "," << #y ":" << x << "," << y << endl
// struct fin{ fin(){ cin.tie(0); ios::sync_with_stdio(false); } } fin_;
struct Double {
double d;
explicit Double(double x) : d(x) {}
};
ostream &operator<<(ostream &os, const Double x) {
os << fixed << setprecision(20) << x.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
os << "{";
for (T v : st)
os << v << ",";
os << "}";
return os;
}
template <typename T, typename U> inline void chmax(T &x, U y) {
if (y > x)
x = y;
}
template <typename T, typename U> inline void chmin(T &x, U y) {
if (y < x)
x = y;
}
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// constexpr double eps = 1e-14;
constexpr double eps = 1e-10;
constexpr ll mod = 1e9 + 7;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
/*}}}*/
int main() {
int n, m;
cin >> n >> m;
int c;
cin >> c;
vector<int> b(n);
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < m; i++)
cin >> b[i];
rep(i, n) {
rep(j, m) { cin >> a[i][j]; }
}
ll ans = 0;
rep(i, n) {
ll p = c;
rep(j, m) p += a[i][j] * b[j];
if (p > 0)
ans++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
/*{{{*/ // template
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long LINF = numeric_limits<long long>::max() / 3;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr << #x << ":" << x << endl
#define debug2(x, y) cerr << #x << "," << #y ":" << x << "," << y << endl
// struct fin{ fin(){ cin.tie(0); ios::sync_with_stdio(false); } } fin_;
struct Double {
double d;
explicit Double(double x) : d(x) {}
};
ostream &operator<<(ostream &os, const Double x) {
os << fixed << setprecision(20) << x.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
os << "{";
for (T v : st)
os << v << ",";
os << "}";
return os;
}
template <typename T, typename U> inline void chmax(T &x, U y) {
if (y > x)
x = y;
}
template <typename T, typename U> inline void chmin(T &x, U y) {
if (y < x)
x = y;
}
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// constexpr double eps = 1e-14;
constexpr double eps = 1e-10;
constexpr ll mod = 1e9 + 7;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
/*}}}*/
int main() {
int n, m;
cin >> n >> m;
int c;
cin >> c;
vector<int> b(m);
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < m; i++)
cin >> b[i];
rep(i, n) {
rep(j, m) { cin >> a[i][j]; }
}
ll ans = 0;
rep(i, n) {
ll p = c;
rep(j, m) p += a[i][j] * b[j];
if (p > 0)
ans++;
}
cout << ans << endl;
}
| [] | 909,849 | 909,850 | u013750540 | cpp |
p03102 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int M;
int C;
cin >> N >> M >> C;
vector<int> vec(M);
int B;
for (int x = 0; x < M; x++) {
// int B;
cin >> B;
vec.at(x) = B;
}
// cout << vec.at(0) << endl;
long answer;
long chech;
long nyuryoku;
for (int y = 0; y < N; y++) {
chech = 0;
for (int z = 0; z < M; z++) {
nyuryoku = 0;
cin >> nyuryoku;
chech = chech + nyuryoku * vec.at(z);
}
if (chech > -C) {
answer = answer + 1;
}
}
cout << answer << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int M;
int C;
cin >> N >> M >> C;
vector<int> vec(M);
int B;
for (int x = 0; x < M; x++) {
cin >> B;
vec.at(x) = B;
}
long answer = 0;
long chech;
long nyuryoku;
for (int y = 0; y < N; y++) {
chech = 0;
for (int z = 0; z < M; z++) {
nyuryoku = 0;
cin >> nyuryoku;
chech = chech + nyuryoku * vec.at(z);
}
if (chech > -C) {
answer++;
}
}
cout << answer << endl;
}
| [
"variable_declaration.value.change",
"expression.operation.binary.remove"
] | 909,860 | 909,861 | u813182149 | cpp |
p03102 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m, c;
cin >> n >> m >> c;
vector<int> B(m);
for (int i = 0; i < m; i++) {
cin >> B[i];
}
int cnt = 0;
for (int i = 0; i < n; i++) {
vector<int> a(m);
int sum = c;
for (int j = 0; j < m; j++) {
cin >> a[j];
sum += a[j] * B[j];
if (sum > 0)
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m, c;
cin >> n >> m >> c;
vector<int> B(m);
for (int i = 0; i < m; i++) {
cin >> B[i];
}
int cnt = 0;
for (int i = 0; i < n; i++) {
vector<int> a(m);
int sum = c;
for (int j = 0; j < m; j++) {
cin >> a[j];
sum += a[j] * B[j];
}
if (sum > 0)
cnt++;
}
cout << cnt << endl;
return 0;
}
| [] | 909,879 | 909,880 | u568419568 | cpp |
p03103 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define print(x) cout << x << endl
#define rep(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SUM(vec) accumulate(all(vec), 0LL)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define test(a) cout << (#a) << ':' << (a) << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
ll inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
}
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
}
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
}
bool isOk(ll key, ll value) { return key < value; }
int binary_search(vector<ll> a, ll key) {
ll ok = a.size();
ll ng = -1;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOk(key, a[mid]))
ok = mid;
else
ng = mid;
}
return ok;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<pair<int, int>> ab(n);
rep(i, n) cin >> ab[i].fi >> ab[i].se;
sort(all(ab));
ll ans = 0;
for (int i = 0; m > 0 && i < n; ++i) {
ans += ab[i].fi * min(m, ab[i].se);
m -= ab[i].se;
}
print(ans);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(), (x).end()
#define print(x) cout << x << endl
#define rep(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SUM(vec) accumulate(all(vec), 0LL)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define test(a) cout << (#a) << ':' << (a) << endl
const int INF = 1e9 + 7;
const ll INFL = 9 * 1e18;
ll inline digit(ll num) {
int tmp = 0;
while (num) {
tmp++;
num /= 10;
}
return tmp;
}
template <typename T> inline T digitSum(T num) {
T sum = 0;
while (num) {
sum += num % 10;
num /= 10;
}
return sum;
} // 各桁の和
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> inline T lcm(T a, T b) {
T g = gcd(a, b);
return a / g * b;
}
template <typename T> inline T power(T a, T b) {
T tmp = 1;
rep(i, b) { tmp *= a; }
return tmp;
}
bool isOk(ll key, ll value) { return key < value; }
int binary_search(vector<ll> a, ll key) {
ll ok = a.size();
ll ng = -1;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOk(key, a[mid]))
ok = mid;
else
ng = mid;
}
return ok;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
#define int ll
int n, m;
cin >> n >> m;
vector<pair<int, int>> ab(n);
rep(i, n) cin >> ab[i].fi >> ab[i].se;
sort(all(ab));
ll ans = 0;
for (int i = 0; m > 0 && i < n; ++i) {
ans += ab[i].fi * min(m, ab[i].se);
m -= ab[i].se;
}
print(ans);
return 0;
}
| [] | 909,885 | 909,886 | u184572586 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
map<int, int> d;
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
d[A] = B;
}
long long int ans = 0;
for (auto [A, B] : d) {
long long int b = min(M, B);
ans += A * b;
M -= b;
if (!M) {
cout << ans << endl;
return 0;
}
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
map<int, int> d;
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
d[A] += B;
}
long long int ans = 0;
for (auto [A, B] : d) {
long long int b = min(M, B);
ans += A * b;
M -= b;
if (!M) {
cout << ans << endl;
return 0;
}
}
return 0;
} | [
"assignment.value.change"
] | 909,889 | 909,890 | u879226168 | cpp |
p03103 | #include <algorithm>
#include <bits/stdc++.h>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
typedef long long ll;
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());
ll ans = 0;
for (int i = 0; i < n; i++) {
if (m == 0) {
break;
}
ans += (min(m, a[i].second) * a[i].first);
m -= min(m, a[i].second);
}
cout << ans;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
ll ans = 0;
for (int i = 0; i < n; i++) {
if (m == 0) {
break;
}
ans += (min(m, a[i].second) * a[i].first);
m -= min(m, a[i].second);
}
cout << ans;
} | [
"variable_declaration.type.change"
] | 909,893 | 909,894 | u290006620 | 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, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> ab;
rep(i, n) {
ll a, b;
cin >> a >> b;
ab.push_back(make_pair(a, b));
}
sort(all(ab));
ll ans = 0;
rep(i, n) {
if (m <= 0) {
break;
}
if (ab[i].second <= m) {
ans += ab[i].first * ab[i].second;
} else {
ans += ab[i].first * m;
}
m = max(0LL, m - ab[i].second);
i++;
}
cout << ans << '\n';
return 0;
}
| #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, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> ab;
rep(i, n) {
ll a, b;
cin >> a >> b;
ab.push_back(make_pair(a, b));
}
sort(all(ab));
ll ans = 0;
rep(i, n) {
if (m <= 0) {
break;
}
if (ab[i].second <= m) {
ans += ab[i].first * ab[i].second;
} else {
ans += ab[i].first * m;
}
m = max(0LL, m - ab[i].second);
}
cout << ans << '\n';
return 0;
}
| [
"expression.unary.arithmetic.remove"
] | 909,907 | 909,908 | u119171625 | 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] >> 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.begin());
long long ans = 0;
for (int i = 0; i < N; i++) {
int b = min(M, AB[i].second);
ans += (long long)b * AB[i].first;
M -= b;
}
cout << ans << endl;
return 0;
}
| #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] >> 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 b = min(M, AB[i].second);
ans += (long long)b * AB[i].first;
M -= b;
}
cout << ans << endl;
return 0;
}
| [
"call.function.change",
"call.arguments.change"
] | 909,923 | 909,924 | u896053584 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
} //最大公約数
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
} //最小公倍数
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
} //コンビネーション
int nHr(int a, int b) { return nCr(a + b - 1, b); } // 重複組み合わせ
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
} //階乗
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
} // a~bまでの階乗
int dsum(int x) {
int r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
} //数字の各位の和
int dsumb(int x, int b) {
int r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
} // b進数の各位の和？
int sankaku(int x) { return ((1 + x) * x) / 2; } //三角数 xまでの和
//以下long long ver
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long lldsum(long long x) {
long long r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
long long lldsumb(long long x, long long b) {
long long r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
long long llsankaku(long long x) { return ((1 + x) * x) / 2; }
// double
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
typedef pair<int, int> ii;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define forr(i, a, b) \
; \
for (int i = (a); i < (b); i++)
#define clean(arr, val) memset(arr, val, sizeof(arr))
#define forn(i, n) forr(i, 0, n)
#define PB push_back
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<pll> vpll;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
string alpha = "abcdefghijklmnopqrstuvwxyz";
string ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
bool chmin(int a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
bool chmax(int a, int b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define SORT(c) sort((c).begin(), (c).end());
#define ANS(ans) cout << (ans) << endl;
/*CODE START HERE*/
int main() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> v(n);
forn(i, n) {
long long a, b;
cin >> a >> b;
v.at(i) = make_pair(a, b);
}
long long less = m;
long long cost = 0;
SORT(v);
for (int i = 0; less > 0; i++) {
cost += v.at(i).first * min(v.at(i).second, less);
less -= min(v.at(i).first, less);
}
ANS(cost);
} | #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
} //最大公約数
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
} //最小公倍数
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
} //コンビネーション
int nHr(int a, int b) { return nCr(a + b - 1, b); } // 重複組み合わせ
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
} //階乗
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
} // a~bまでの階乗
int dsum(int x) {
int r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
} //数字の各位の和
int dsumb(int x, int b) {
int r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
} // b進数の各位の和？
int sankaku(int x) { return ((1 + x) * x) / 2; } //三角数 xまでの和
//以下long long ver
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long lldsum(long long x) {
long long r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
long long lldsumb(long long x, long long b) {
long long r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
long long llsankaku(long long x) { return ((1 + x) * x) / 2; }
// double
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
typedef pair<int, int> ii;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define forr(i, a, b) \
; \
for (int i = (a); i < (b); i++)
#define clean(arr, val) memset(arr, val, sizeof(arr))
#define forn(i, n) forr(i, 0, n)
#define PB push_back
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<pll> vpll;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
string alpha = "abcdefghijklmnopqrstuvwxyz";
string ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
bool chmin(int a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
bool chmax(int a, int b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define SORT(c) sort((c).begin(), (c).end());
#define ANS(ans) cout << (ans) << endl;
/*CODE START HERE*/
int main() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> v(n);
forn(i, n) {
long long a, b;
cin >> a >> b;
v.at(i) = make_pair(a, b);
}
long long less = m;
long long cost = 0;
SORT(v);
for (int i = 0; less > 0 || i < n; i++) {
cost += v.at(i).first * min(v.at(i).second, less);
less -= min(v.at(i).second, less);
}
ANS(cost);
} | [
"control_flow.loop.for.condition.change",
"assignment.value.change",
"call.arguments.change"
] | 909,925 | 909,926 | u946082956 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
} //最大公約数
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
} //最小公倍数
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
} //コンビネーション
int nHr(int a, int b) { return nCr(a + b - 1, b); } // 重複組み合わせ
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
} //階乗
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
} // a~bまでの階乗
int dsum(int x) {
int r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
} //数字の各位の和
int dsumb(int x, int b) {
int r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
} // b進数の各位の和？
int sankaku(int x) { return ((1 + x) * x) / 2; } //三角数 xまでの和
//以下long long ver
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long lldsum(long long x) {
long long r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
long long lldsumb(long long x, long long b) {
long long r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
long long llsankaku(long long x) { return ((1 + x) * x) / 2; }
// double
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
typedef pair<int, int> ii;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define forr(i, a, b) \
; \
for (int i = (a); i < (b); i++)
#define clean(arr, val) memset(arr, val, sizeof(arr))
#define forn(i, n) forr(i, 0, n)
#define PB push_back
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<pll> vpll;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
string alpha = "abcdefghijklmnopqrstuvwxyz";
string ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
bool chmin(int a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
bool chmax(int a, int b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define SORT(c) sort((c).begin(), (c).end());
#define ANS(ans) cout << (ans) << endl;
/*CODE START HERE*/
int main() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> v(n);
forn(i, n) {
long long a, b;
cin >> a >> b;
v.at(i) = make_pair(a, b);
}
long long less = m;
long long cost = 0;
SORT(v);
for (int i = 0; less > 0 || i < n; i++) {
cost += v.at(i).first * min(v.at(i).second, less);
less -= min(v.at(i).first, less);
}
ANS(cost);
} | #include <bits/stdc++.h>
using namespace std;
#define inf 1072114514
#define llinf 4154118101919364364
#define mod 1000000007
#define pi 3.1415926535897932384
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
} //最大公約数
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
} //最小公倍数
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
} //コンビネーション
int nHr(int a, int b) { return nCr(a + b - 1, b); } // 重複組み合わせ
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
} //階乗
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
} // a~bまでの階乗
int dsum(int x) {
int r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
} //数字の各位の和
int dsumb(int x, int b) {
int r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
} // b進数の各位の和？
int sankaku(int x) { return ((1 + x) * x) / 2; } //三角数 xまでの和
//以下long long ver
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long lldsum(long long x) {
long long r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
long long lldsumb(long long x, long long b) {
long long r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
long long llsankaku(long long x) { return ((1 + x) * x) / 2; }
// double
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
typedef pair<int, int> ii;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
#define forr(i, a, b) \
; \
for (int i = (a); i < (b); i++)
#define clean(arr, val) memset(arr, val, sizeof(arr))
#define forn(i, n) forr(i, 0, n)
#define PB push_back
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<pll> vpll;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
bool is_prime(int x) {
if (x <= 1)
return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
string alpha = "abcdefghijklmnopqrstuvwxyz";
string ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
bool chmin(int a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
bool chmax(int a, int b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define SORT(c) sort((c).begin(), (c).end());
#define ANS(ans) cout << (ans) << endl;
/*CODE START HERE*/
int main() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> v(n);
forn(i, n) {
long long a, b;
cin >> a >> b;
v.at(i) = make_pair(a, b);
}
long long less = m;
long long cost = 0;
SORT(v);
for (int i = 0; less > 0 || i < n; i++) {
cost += v.at(i).first * min(v.at(i).second, less);
less -= min(v.at(i).second, less);
}
ANS(cost);
} | [
"assignment.value.change",
"call.arguments.change"
] | 909,927 | 909,926 | u946082956 | cpp |
p03103 | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pf(n) printf("%d\n", n)
#define pff(a, b) printf("%d %d\n", a, b);
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1001001001;
const double PI = acos(-1);
int main() {
ll n, m;
cin >> n >> m;
vector<p> ab(n);
rep(i, n) cin >> ab[i].first >> ab[i].second;
sort(ab.begin(), ab.end());
ll mone = 0;
for (int i = 0; m > 0; i++) {
if (ab[i].second >= m) {
mone += ab[i].first * m;
m = 0;
} else {
m -= ab[i].second;
mone += ab[i].first * ab[i].second;
}
}
pf(mone);
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pf(n) printf("%lld\n", n)
#define pff(a, b) printf("%d %d\n", a, b);
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1001001001;
const double PI = acos(-1);
int main() {
ll n, m;
cin >> n >> m;
vector<p> ab(n);
rep(i, n) cin >> ab[i].first >> ab[i].second;
sort(ab.begin(), ab.end());
ll mone = 0;
for (int i = 0; m > 0; i++) {
if (ab[i].second >= m) {
mone += ab[i].first * m;
m = 0;
} else {
m -= ab[i].second;
mone += ab[i].first * ab[i].second;
}
}
pf(mone);
return 0;
} | [
"preprocessor.define.value.change"
] | 909,932 | 909,933 | u770486670 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
int ia, ib;
cin >> ia >> ib;
a[i] = make_pair(ia, ib);
}
sort(a.begin(), a.end());
ll ans = 0;
for (int i = 0; m > 0; i++) {
ans += a[i].first * min(a[i].second, m);
m -= a[i].second;
}
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> a(n);
for (int i = 0; i < n; i++) {
int ia, ib;
cin >> ia >> ib;
a[i] = make_pair(ia, ib);
}
sort(a.begin(), a.end());
ll ans = 0;
for (int i = 0; m > 0; i++) {
ans += a[i].first * min(a[i].second, m);
m -= a[i].second;
}
cout << ans << "\n";
return 0;
}
| [
"variable_declaration.type.change"
] | 909,939 | 909,940 | u288035794 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
int main(void) {
int N, M;
scanf("%d %d", &N, &M);
pair<int, int> shops[100100];
for (int i = 0; i < N; i++) {
int A, B;
scanf("%d %d", &A, &B);
shops[i] = make_pair(A, B);
}
sort(shops, shops + N);
long long ans = 0;
int i = 0;
while (M > 0) {
// cout << shops[i].first << " " << shops[i].second << "\n";
ans += shops[i].first * min(shops[i].second, M);
M -= shops[i].second;
i++;
}
printf("%lld\n", ans);
return 0;
}
| #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
int main(void) {
int N, M;
scanf("%d %d", &N, &M);
pair<int, int> shops[100100];
for (int i = 0; i < N; i++) {
int A, B;
scanf("%d %d", &A, &B);
shops[i] = make_pair(A, B);
}
sort(shops, shops + N);
long long ans = 0;
int i = 0;
while (M > 0) {
// cout << shops[i].first << " " << shops[i].second << "\n";
ans += (long long)shops[i].first * min(shops[i].second, M);
M -= shops[i].second;
i++;
}
printf("%lld\n", ans);
return 0;
}
| [
"type_conversion.add"
] | 909,941 | 909,942 | u684448032 | cpp |
p03103 | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) { return (!b ? a : gcd(b, a % b)); }
bool cmp(int a, int b) { return a > b; }
const ll mod = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod) {
if (k == 0)
return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1)
r = r * n % mod;
return r;
}
void solve() {
ll n, m;
cin >> n >> m;
vector<pii> p;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
p.push_back({a, b});
}
sort(p.begin(), p.end());
int cnt = 0;
ll ans = 0;
for (int i = 0; i < n; i++) {
if (p[i].second + cnt <= m) {
cnt += p[i].second;
ans += (p[i].second * p[i].first);
} else {
ans += (m - cnt) * p[i].first;
break;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) { return (!b ? a : gcd(b, a % b)); }
bool cmp(int a, int b) { return a > b; }
const ll mod = 1e9 + 7;
const int INF32 = 1 << 30;
const ll INF64 = 1LL << 60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod) {
if (k == 0)
return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1)
r = r * n % mod;
return r;
}
void solve() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> p;
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
p.push_back({a, b});
}
sort(p.begin(), p.end());
int cnt = 0;
ll ans = 0;
for (int i = 0; i < n; i++) {
if (p[i].second + cnt <= m) {
cnt += p[i].second;
ans += (p[i].second * p[i].first);
} else {
ans += (m - cnt) * p[i].first;
break;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
} | [] | 909,943 | 909,944 | u633066470 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
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 ans = 0;
for (int i = 0; i < N; i++) {
if (drink[i].second < M) {
ans += drink[i].first * drink[i].second;
M -= drink[i].second;
} else {
ans += drink[i].first * M;
break;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
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 ans = 0;
for (int i = 0; i < N; i++) {
if (drink[i].second < M) {
ans += drink[i].first * drink[i].second;
M -= drink[i].second;
} else {
ans += drink[i].first * M;
break;
}
}
cout << ans << endl;
}
| [] | 909,949 | 909,950 | u986480146 | cpp |
p03103 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> d(n);
for (int i = 0; i < n; i++) {
cin >> d[i].first >> d[i].second;
}
sort(all(d));
ll ans = 0;
for (int i = 0; i < n; i++) {
if (d[i].second >= m) {
ans += d[i].first * m;
break;
}
ans += d[i].first * d[i].second;
m -= d[i].second;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> d(n);
for (int i = 0; i < n; i++) {
cin >> d[i].first >> d[i].second;
}
sort(all(d));
ll ans = 0;
for (int i = 0; i < n; i++) {
if (d[i].second >= m) {
ans += d[i].first * m;
break;
}
ans += d[i].first * d[i].second;
m -= d[i].second;
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 909,955 | 909,956 | u654240084 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> pa(n);
for (int i = 0; i < n; i++) {
cin >> pa[i].first >> pa[i].second;
}
sort(pa.begin(), pa.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if (pa[i].second < m) {
ans += pa[i].first * pa[i].second;
m -= pa[i].second;
} else { // m <= pa[i].second
ans += pa[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> pa(n);
for (ll i = 0; i < n; i++) {
cin >> pa[i].first >> pa[i].second;
}
sort(pa.begin(), pa.end());
ll ans = 0;
for (ll i = 0; i < n; i++) {
if (pa[i].second < m) {
ans += pa[i].first * pa[i].second;
m -= pa[i].second;
} else { // m <= pa[i].second
ans += pa[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 909,959 | 909,960 | u221391729 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int ans = 0;
long long int m, n, a, b;
cin >> n >> m;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
for (auto x : v) {
if (x.second <= m) {
ans += x.first * x.second;
m -= x.second;
} else {
ans += x.first * m;
m = 0;
break;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int ans = 0;
long long m, n, a, b;
cin >> n >> m;
vector<pair<long long, long long>> v;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
sort(v.begin(), v.end());
for (auto x : v) {
if (x.second <= m) {
ans += x.first * x.second;
m -= x.second;
} else {
ans += x.first * m;
m = 0;
break;
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.narrow.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 909,961 | 909,962 | u861658976 | cpp |
p03103 | //#pragma GCC target("avx2")
//#pragma GCC optimization("O3")
//#pragma GCC optimization("unroll-loops")
// assert(q==w) если q!=w --> runtime error
#include <bits/stdc++.h>
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define ub upper_bound
#define lb lower_bound
#define bit __builtin_popcount
#define memset(x) memset(x, 0, sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<int>> matrix;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const ll maxn = 2e5 + 123;
const ll inf = 1e9 + 123;
const ll linf = 1e18 + 123;
const ll mod = 1e9 + 7;
const double eps = 1e-9;
const double pi = acos(-1);
int dx[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int dy[8] = {1, 0, 0, -1, 1, 1, -1, -1};
pii a[maxn];
int main() {
boost();
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i].F >> a[i].S;
}
sort(a + 1, a + 1 + n);
ll ans = 0;
for (int i = 1; i <= n; i++) {
if (m < a[i].S) {
ans += m * a[i].F;
m = 0;
} else {
ans += a[i].F * a[i].S;
m -= a[i].S;
}
}
cout << ans;
exit(0);
}
| //#pragma GCC target("avx2")
//#pragma GCC optimization("O3")
//#pragma GCC optimization("unroll-loops")
// assert(q==w) если q!=w --> runtime error
#include <bits/stdc++.h>
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define ub upper_bound
#define lb lower_bound
#define bit __builtin_popcount
#define memset(x) memset(x, 0, sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<int>> matrix;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const ll maxn = 2e5 + 123;
const ll inf = 1e9 + 123;
const ll linf = 1e18 + 123;
const ll mod = 1e9 + 7;
const double eps = 1e-9;
const double pi = acos(-1);
int dx[8] = {0, 1, -1, 0, 1, -1, 1, -1};
int dy[8] = {1, 0, 0, -1, 1, 1, -1, -1};
pll a[maxn];
int main() {
boost();
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i].F >> a[i].S;
}
sort(a + 1, a + 1 + n);
ll ans = 0;
for (int i = 1; i <= n; i++) {
if (m < a[i].S) {
ans += m * a[i].F;
m = 0;
} else {
ans += a[i].F * a[i].S;
m -= a[i].S;
}
}
cout << ans;
exit(0);
}
| [
"variable_declaration.type.change"
] | 909,963 | 909,964 | u863370423 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
p.push_back(make_pair(a, b));
}
sort(p.begin(), p.end());
long long cnt = 0, price = 0;
for (int i = 0; i < n; i++) {
tie(a, b) = p[i];
// cout << a << ' ' << b << endl;
if (cnt + b <= m) {
cnt += b;
price += a * b;
} else {
price += a * (m - cnt);
break;
}
// cout << cnt << ' ' << price << endl;
}
cout << price << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p;
long long a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
p.push_back(make_pair(a, b));
}
sort(p.begin(), p.end());
long long cnt = 0, price = 0;
for (int i = 0; i < n; i++) {
tie(a, b) = p[i];
// cout << a << ' ' << b << endl;
if (cnt + b <= m) {
cnt += b;
price += a * b;
} else {
price += a * (m - cnt);
break;
}
// cout << cnt << ' ' << price << endl;
}
cout << price << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 909,967 | 909,968 | u569361260 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int64_t, int64_t>> vec(N);
for (int i = 0; i < N; i++) {
int64_t O, P;
cin >> O >> P;
vec.at(i) = make_pair(O, P);
}
sort(vec.begin(), vec.end());
int64_t total = 0;
int64_t ans = 0;
int i = 0;
bool shokai = false;
while (true) {
if (vec.at(i).second >= M) {
shokai = true;
break;
} else {
total += vec.at(i).second;
ans += vec.at(i).first * vec.at(i).second;
if (total + vec.at(i + 1).second > M) {
break;
} else {
i++;
}
}
}
if (shokai) {
ans += (M - total) * vec.at(i).first;
} else {
ans += (M - total) * vec.at(i + 1).first;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int64_t, int64_t>> vec(N);
for (int i = 0; i < N; i++) {
int64_t O, P;
cin >> O >> P;
vec.at(i) = make_pair(O, P);
}
sort(vec.begin(), vec.end());
int64_t total = 0;
int64_t ans = 0;
int i = 0;
bool shokai = false;
while (true) {
if (vec.at(i).second >= M) {
shokai = true;
break;
} else {
total += vec.at(i).second;
ans += vec.at(i).first * vec.at(i).second;
if (total + vec.at(i + 1).second >= M) {
break;
} else {
i++;
}
}
}
if (shokai) {
ans += (M - total) * vec.at(i).first;
} else {
ans += (M - total) * vec.at(i + 1).first;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 909,973 | 909,974 | u538283043 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int64_t, int64_t>> vec(N);
for (int i = 0; i < N; i++) {
int64_t O, P;
cin >> O >> P;
vec.at(i) = make_pair(O, P);
}
sort(vec.begin(), vec.end());
int64_t total = 0;
int64_t ans = 0;
int i = 0;
bool shokai = false;
while (true) {
if (vec.at(i).first >= M) {
shokai = true;
break;
} else {
total += vec.at(i).second;
ans += vec.at(i).first * vec.at(i).second;
if (total + vec.at(i + 1).second > M) {
break;
} else {
i++;
}
}
}
if (shokai) {
ans += (M - total) * vec.at(i).first;
} else {
ans += (M - total) * vec.at(i + 1).first;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int64_t, int64_t>> vec(N);
for (int i = 0; i < N; i++) {
int64_t O, P;
cin >> O >> P;
vec.at(i) = make_pair(O, P);
}
sort(vec.begin(), vec.end());
int64_t total = 0;
int64_t ans = 0;
int i = 0;
bool shokai = false;
while (true) {
if (vec.at(i).second >= M) {
shokai = true;
break;
} else {
total += vec.at(i).second;
ans += vec.at(i).first * vec.at(i).second;
if (total + vec.at(i + 1).second >= M) {
break;
} else {
i++;
}
}
}
if (shokai) {
ans += (M - total) * vec.at(i).first;
} else {
ans += (M - total) * vec.at(i + 1).first;
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change"
] | 909,975 | 909,974 | u538283043 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
int INF = 1e9 + 7;
int mod = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
int N, M;
cin >> N >> M;
vector<P> AB(N);
for (int i = 0; i < N; i++) {
cin >> AB[i].first >> AB[i].second;
}
sort(AB.begin(), AB.end());
int ans = 0;
int cnt = 0;
while (M) {
if (M >= AB[cnt].second) {
M -= AB[cnt].second;
ans += AB[cnt].first * AB[cnt].second;
cnt++;
} else {
ans += AB[cnt].first * M;
M = 0;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e9 + 7;
int mod = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int N, M;
cin >> N >> M;
vector<P> AB(N);
for (int i = 0; i < N; i++) {
cin >> AB[i].first >> AB[i].second;
}
sort(AB.begin(), AB.end());
int ans = 0;
int cnt = 0;
while (M) {
if (M >= AB[cnt].second) {
M -= AB[cnt].second;
ans += AB[cnt].first * AB[cnt].second;
cnt++;
} else {
ans += AB[cnt].first * M;
M = 0;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 909,976 | 909,977 | u237390401 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) {
int a1, a2;
cin >> a1 >> a2;
a.at(i) = make_pair(a1, a2);
}
sort(a.begin(), a.end());
long long k = 0, h = 0;
for (int i = 0; i < n; i++) {
long long f = a.at(i).first, s = a.at(i).second;
if (h + s > m) {
k += f * (m - h);
h = m;
} else {
k += f * s;
h += m;
}
if (h == m) {
break;
}
}
cout << k << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) {
int a1, a2;
cin >> a1 >> a2;
a.at(i) = make_pair(a1, a2);
}
sort(a.begin(), a.end());
long long k = 0, h = 0;
for (int i = 0; i < n; i++) {
long long f = a.at(i).first, s = a.at(i).second;
if (h + s > m) {
k += f * (m - h);
h = m;
} else {
k += f * s;
h += s;
}
if (h == m) {
break;
}
}
cout << k << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change"
] | 909,980 | 909,981 | u323864528 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) {
int a1, a2;
cin >> a1 >> a2;
a.at(i) = make_pair(a1, a2);
}
sort(a.begin(), a.end());
long long k = 0, h = 0;
for (int i = 0; i < n; i++) {
long long f = a.at(i).first, s = a.at(i).second;
if (h + s > m) {
k += f * (m - h - s);
h = m;
} else {
k += f * s;
h += m;
}
if (h == m) {
break;
}
}
cout << k << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) {
int a1, a2;
cin >> a1 >> a2;
a.at(i) = make_pair(a1, a2);
}
sort(a.begin(), a.end());
long long k = 0, h = 0;
for (int i = 0; i < n; i++) {
long long f = a.at(i).first, s = a.at(i).second;
if (h + s > m) {
k += f * (m - h);
h = m;
} else {
k += f * s;
h += s;
}
if (h == m) {
break;
}
}
cout << k << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.value.change",
"identifier.change"
] | 909,982 | 909,981 | u323864528 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long k;
cin >> k;
map<long long, long long> map1;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
long long b;
cin >> b;
map1.insert(pair<long long, long long>(a, b));
}
long long ans = 0;
for (auto &x : map1) {
if (x.second < k) {
ans += (x.first) * (x.second);
k -= x.second;
} else {
ans += (x.first) * k;
break;
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long k;
cin >> k;
multimap<long long, long long> map1;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
long long b;
cin >> b;
map1.insert(pair<long long, long long>(a, b));
}
long long ans = 0;
for (auto &x : map1) {
if (x.second < k) {
ans += (x.first) * (x.second);
k -= x.second;
} else {
ans += (x.first) * k;
break;
}
}
cout << ans;
return 0;
}
| [
"variable_declaration.type.change"
] | 909,985 | 909,986 | u616038992 | cpp |
p03103 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REP2(i, x, n) for (int i = x; i < (n); ++i)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int, int>;
static const double PI = acos(-1);
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> drink(n);
REP(i, n) {
int a, b;
cin >> a >> b;
drink[i].first = a;
drink[i].second = b;
}
sort(ALL(drink));
ll ans = 0;
REP(i, n) {
if (m >= drink[i].second) {
ans += drink[i].first * drink[i].second;
m -= drink[i].second;
if (m == 0)
break;
} else {
ans += drink[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REP2(i, x, n) for (int i = x; i < (n); ++i)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int, int>;
static const double PI = acos(-1);
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> drink(n);
REP(i, n) {
int a, b;
cin >> a >> b;
drink[i].first = a;
drink[i].second = b;
}
sort(ALL(drink));
ll ans = 0;
REP(i, n) {
if (m >= drink[i].second) {
ans += (ll)drink[i].first * drink[i].second;
m -= drink[i].second;
if (m == 0)
break;
} else {
ans += (ll)drink[i].first * m;
break;
}
}
cout << ans << endl;
return 0;
}
| [
"type_conversion.add"
] | 909,994 | 909,995 | u849151695 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <cmath>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <vector>
#define rip(i, n) for (ll i = 0; i < n; i++)
#define Rip(i, n) for (ll i = 1; i <= n; i++)
#define all(V) V.begin(), V.end()
#define ll long long
#define ld long double
#define MOD 1000000007
#define mod 998244353
#define sec setprecision
#define Pair pair<ll, ll>
#define _CRT_SECURE_NO_WARNINGS
#pragma target("avx")
#pragma optimize("O3")
#pragma optimize("unroll-loops")
constexpr double eps = 1e-9;
constexpr double pi = 3.141592653589793238462643383279;
using namespace std;
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll pow(ll x, ll n) {
x %= mod;
if (n == 0)
return 1;
if (n % 2 == 0)
return (pow((x * x) % mod, n / 2) % mod);
else
return (x * pow(x, n - 1)) % mod;
}
int main() {
int n, m;
cin >> n >> m;
vector<Pair> a(n);
rip(i, n) cin >> a[i].first >> a[i].second;
sort(all(a));
int count = 0;
int money = 0;
rip(i, n) {
if (count + a[i].second <= m) {
money += a[i].second * a[i].first;
count += a[i].second;
} else {
money += a[i].first * (m - count);
break;
}
}
cout << money << endl;
} | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <cmath>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <vector>
#define rip(i, n) for (ll i = 0; i < n; i++)
#define Rip(i, n) for (ll i = 1; i <= n; i++)
#define all(V) V.begin(), V.end()
#define ll long long
#define ld long double
#define MOD 1000000007
#define mod 998244353
#define sec setprecision
#define Pair pair<ll, ll>
#define _CRT_SECURE_NO_WARNINGS
#pragma target("avx")
#pragma optimize("O3")
#pragma optimize("unroll-loops")
constexpr double eps = 1e-9;
constexpr double pi = 3.141592653589793238462643383279;
using namespace std;
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll pow(ll x, ll n) {
x %= mod;
if (n == 0)
return 1;
if (n % 2 == 0)
return (pow((x * x) % mod, n / 2) % mod);
else
return (x * pow(x, n - 1)) % mod;
}
int main() {
ll n, m;
cin >> n >> m;
vector<Pair> a(n);
rip(i, n) cin >> a[i].first >> a[i].second;
sort(all(a));
ll count = 0;
ll money = 0;
rip(i, n) {
if (count + a[i].second <= m) {
money += a[i].second * a[i].first;
count += a[i].second;
} else {
money += a[i].first * (m - count);
break;
}
}
cout << money << endl;
} | [
"variable_declaration.type.change"
] | 909,996 | 909,997 | u586052522 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
map<long long, long long> kaz;
for (int i = 0; i < N; i++) {
long long a, b;
cin >> a >> b;
kaz[a] = b;
}
long long sum = 0;
for (auto &x : kaz) {
if (x.second < M) {
sum += x.first * x.second;
M -= x.second;
} else {
sum += x.first * M;
break;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
map<long long, long long> kaz;
for (int i = 0; i < N; i++) {
long long a, b;
cin >> a >> b;
kaz[a] += b;
}
long long sum = 0;
for (auto &x : kaz) {
if (x.second < M) {
sum += x.first * x.second;
M -= x.second;
} else {
sum += x.first * M;
break;
}
}
cout << sum << endl;
} | [
"assignment.value.change"
] | 910,004 | 910,005 | u642497480 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD = 1000000007;
using namespace std;
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;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ostream &operator<<(ostream &st, const ModInt<MOD> a) {
st << a.get();
return st;
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
template <typename T, int FAC_MAX> struct Comb {
vector<T> fac, ifac;
Comb() {
fac.resize(FAC_MAX, 1);
ifac.resize(FAC_MAX, 1);
FOR(i, 1, FAC_MAX - 1) fac[i] = fac[i - 1] * i;
ifac[FAC_MAX - 1] = T(1) / fac[FAC_MAX - 1];
for (int i = FAC_MAX - 2; i >= 1; i--)
ifac[i] = ifac[i + 1] * T(i + 1);
}
T aPb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b];
}
T aCb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b] * ifac[b];
}
T nHk(int n, int k) {
if (n == 0 && k == 0)
return T(1);
if (n <= 0 || k < 0)
return 0;
return aCb(n + k - 1, k);
} // nHk = (n+k-1)Ck : n is separator
T pairCombination(int n) {
if (n % 2 == 1)
return T(0);
return fac[n] * ifac[n / 2] / (T(2) ^ (n / 2));
}
// combination of paris for n
};
typedef ModInt<1000000007> mint;
bool isPrime(int x) {
int i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
int main(void) {
// Your code here!
int n, m;
cin >> n >> m;
map<int, int> mp;
rep(i, n) {
int a, b;
cin >> a >> b;
mp[a] += b;
}
ll ans = 0;
ll cnt = 0;
for (auto x : mp) {
if (cnt + x.second > m) {
ans += x.first * (m - cnt);
break;
} else {
ans += x.first * x.second;
cnt += x.second;
}
}
cout << ans << endl;
}
// 基本的にはlong long を使いましょう | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD = 1000000007;
using namespace std;
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;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ostream &operator<<(ostream &st, const ModInt<MOD> a) {
st << a.get();
return st;
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
template <typename T, int FAC_MAX> struct Comb {
vector<T> fac, ifac;
Comb() {
fac.resize(FAC_MAX, 1);
ifac.resize(FAC_MAX, 1);
FOR(i, 1, FAC_MAX - 1) fac[i] = fac[i - 1] * i;
ifac[FAC_MAX - 1] = T(1) / fac[FAC_MAX - 1];
for (int i = FAC_MAX - 2; i >= 1; i--)
ifac[i] = ifac[i + 1] * T(i + 1);
}
T aPb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b];
}
T aCb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b] * ifac[b];
}
T nHk(int n, int k) {
if (n == 0 && k == 0)
return T(1);
if (n <= 0 || k < 0)
return 0;
return aCb(n + k - 1, k);
} // nHk = (n+k-1)Ck : n is separator
T pairCombination(int n) {
if (n % 2 == 1)
return T(0);
return fac[n] * ifac[n / 2] / (T(2) ^ (n / 2));
}
// combination of paris for n
};
typedef ModInt<1000000007> mint;
bool isPrime(int x) {
int i;
if (x < 2)
return 0;
else if (x == 2)
return 1;
if (x % 2 == 0)
return 0;
for (i = 3; i * i <= x; i += 2)
if (x % i == 0)
return 0;
return 1;
}
int main(void) {
// Your code here!
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
rep(i, n) {
ll a, b;
cin >> a >> b;
mp[a] += b;
}
ll ans = 0;
ll cnt = 0;
for (auto x : mp) {
if (cnt + x.second > m) {
ans += x.first * (m - cnt);
break;
} else {
ans += x.first * x.second;
cnt += x.second;
}
}
cout << ans << endl;
}
// 基本的にはlong long を使いましょう | [
"variable_declaration.type.change"
] | 910,014 | 910,015 | u852862907 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD = 1000000007;
using namespace std;
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;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ostream &operator<<(ostream &st, const ModInt<MOD> a) {
st << a.get();
return st;
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
template <typename T, int FAC_MAX> struct Comb {
vector<T> fac, ifac;
Comb() {
fac.resize(FAC_MAX, 1);
ifac.resize(FAC_MAX, 1);
FOR(i, 1, FAC_MAX - 1) fac[i] = fac[i - 1] * i;
ifac[FAC_MAX - 1] = T(1) / fac[FAC_MAX - 1];
for (int i = FAC_MAX - 2; i >= 1; i--)
ifac[i] = ifac[i + 1] * T(i + 1);
}
T aPb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b];
}
T aCb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b] * ifac[b];
}
T nHk(int n, int k) {
if (n == 0 && k == 0)
return T(1);
if (n <= 0 || k < 0)
return 0;
return aCb(n + k - 1, k);
} // nHk = (n+k-1)Ck : n is separator
T pairCombination(int n) {
if (n % 2 == 1)
return T(0);
return fac[n] * ifac[n / 2] / (T(2) ^ (n / 2));
}
// combination of paris for n
};
typedef ModInt<1000000007> mint;
ll n, m;
using pll = pair<ll, ll>;
int main(void) {
// Your code here!
cin >> n >> m;
vector<pll> v(n);
rep(i, n) { cin >> v[i].first >> v[i].second; }
sort(v.begin(), v.end());
int price = 0;
for (int i = 0; i < n && m > 0; ++i) {
price += v[i].first * min(m, v[i].second);
m -= min(m, v[i].second);
}
cout << price << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD = 1000000007;
using namespace std;
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;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ostream &operator<<(ostream &st, const ModInt<MOD> a) {
st << a.get();
return st;
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
template <typename T, int FAC_MAX> struct Comb {
vector<T> fac, ifac;
Comb() {
fac.resize(FAC_MAX, 1);
ifac.resize(FAC_MAX, 1);
FOR(i, 1, FAC_MAX - 1) fac[i] = fac[i - 1] * i;
ifac[FAC_MAX - 1] = T(1) / fac[FAC_MAX - 1];
for (int i = FAC_MAX - 2; i >= 1; i--)
ifac[i] = ifac[i + 1] * T(i + 1);
}
T aPb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b];
}
T aCb(int a, int b) {
if (b < 0 || a < b)
return T(0);
return fac[a] * ifac[a - b] * ifac[b];
}
T nHk(int n, int k) {
if (n == 0 && k == 0)
return T(1);
if (n <= 0 || k < 0)
return 0;
return aCb(n + k - 1, k);
} // nHk = (n+k-1)Ck : n is separator
T pairCombination(int n) {
if (n % 2 == 1)
return T(0);
return fac[n] * ifac[n / 2] / (T(2) ^ (n / 2));
}
// combination of paris for n
};
typedef ModInt<1000000007> mint;
ll n, m;
using pll = pair<ll, ll>;
int main(void) {
// Your code here!
cin >> n >> m;
vector<pll> v(n);
rep(i, n) { cin >> v[i].first >> v[i].second; }
sort(v.begin(), v.end());
ll price = 0;
for (ll i = 0; i < n && m > 0; ++i) {
price += v[i].first * min(m, v[i].second);
m -= min(m, v[i].second);
}
cout << price << endl;
}
| [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 910,016 | 910,017 | u852862907 | cpp |
p03103 | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
#define rep(i, m, n) for (int i = m; i < n; i++)
#define co(n) cout << n << endl
#define all(n) (n).begin(), (n).end()
#define pb(n, m) n.push_back(m)
#define pi(n, m) n.insert(n.begin(), m);
#define ee(n) n.erase(n.end() - 1)
#define eb(n) n.erase(n.begin())
using namespace std;
// using bint=boost::multiprecision::cpp_int;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, m, c = 0;
cin >> n >> m;
vector<pair<int, int>> p(n);
rep(i, 0, n) cin >> p[i].first >> p[i].second;
sort(all(p));
rep(i, 0, n) {
int a = p[i].first, b = p[i].second;
if (m >= b) {
c += a * b;
m -= b;
continue;
}
c += a * m;
break;
}
co(c);
return 0;
} | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
#define rep(i, m, n) for (int i = m; i < n; i++)
#define co(n) cout << n << endl
#define all(n) (n).begin(), (n).end()
#define pb(n, m) n.push_back(m)
#define pi(n, m) n.insert(n.begin(), m);
#define ee(n) n.erase(n.end() - 1)
#define eb(n) n.erase(n.begin())
using namespace std;
// using bint=boost::multiprecision::cpp_int;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, m, c = 0;
cin >> n >> m;
vector<pair<int, int>> p(n);
rep(i, 0, n) cin >> p[i].first >> p[i].second;
sort(all(p));
rep(i, 0, n) {
ll a = p[i].first, b = p[i].second;
if (m >= b) {
c += a * b;
m -= b;
continue;
}
c += a * m;
break;
}
co(c);
return 0;
} | [
"variable_declaration.type.change"
] | 910,029 | 910,030 | u558115145 | cpp |
p03103 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define MOD 1000000007 // 10^9+7
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
const int INF = numeric_limits<int>::max();
// 負の数にも対応した % 演算
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0)
res += m;
return res;
}
// greatest common divisor
long long gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
// least common multiple
long long lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll factorial(ll n) {
ll res = 1;
for (ll i = 1; i <= n; i++) {
res *= i;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<PLL> a(n);
rep(i, n) {
int A, B;
cin >> A >> B;
a[i] = make_pair(A, B);
}
sort(a.begin(), a.end());
int ans = 0;
int i = 0;
while (m > 0) {
if (a[i].second <= m) {
m -= a[i].second;
ans += a[i].first * a[i].second;
} else {
ans += a[i].first * m;
break;
}
i++;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define MOD 1000000007 // 10^9+7
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
const int INF = numeric_limits<int>::max();
// 負の数にも対応した % 演算
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0)
res += m;
return res;
}
// greatest common divisor
long long gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
// least common multiple
long long lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll factorial(ll n) {
ll res = 1;
for (ll i = 1; i <= n; i++) {
res *= i;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<PLL> a(n);
rep(i, n) {
int A, B;
cin >> A >> B;
a[i] = make_pair(A, B);
}
sort(a.begin(), a.end());
ll ans = 0;
int i = 0;
while (m > 0) {
if (a[i].second <= m) {
m -= a[i].second;
ans += a[i].first * a[i].second;
} else {
ans += a[i].first * m;
break;
}
i++;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 910,034 | 910,035 | u366581326 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
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());
long long ans = 0;
for (int i = 0; i < n; ++i) {
int buy = min(m, p[i].second);
ans += buy * p[i].first;
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);
for (int i = 0; i < n; ++i)
cin >> p[i].first >> p[i].second;
sort(p.begin(), p.end());
long long ans = 0;
for (int i = 0; i < n; ++i) {
long long buy = min(m, p[i].second);
ans += buy * p[i].first;
m -= buy;
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,046 | 910,047 | u348398921 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef map<int, int> mii;
typedef map<ll, ll> mll;
typedef vector<pii> vii;
typedef vector<pll> vll;
#define fi first
#define se second
#define pi 3.141592653589793
#define mod 1e9 + 7
#define pb push_back
#define all(v) v.begin(), v.end()
#define rall(v) v.begin(), v.end(), greater<ll>()
#define tc \
int t; \
cin >> t; \
while (t--)
#define pqmax priority_queue<int>
#define pqmin priority_queue<int, vi, greater<int>>
#define fast_io ios_base::sync_with_stdio(0), cin.tie(NULL)
#define tc_g \
int tt; \
cin >> tt; \
for (int ti = 1; ti <= tt; ti++)
#define case_g "Case #" << ti << ": "
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_multiset;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef tree<int, int, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_map;
using namespace std;
int main() {
ll n, m, quan, price;
cin >> n >> m;
vector<pair<int, int>> moni(n);
for (int i = 0; i < n; ++i) {
cin >> price >> quan;
moni[i] = {price, quan};
}
sort(moni.begin(), moni.end());
int ans = 0;
price = 0;
for (auto mon : moni) {
if ((ans + mon.second) <= m) {
ans += mon.second;
price += (mon.first * mon.second);
} else {
ll diff = m - ans;
price += (mon.first * diff);
break;
}
}
cout << price;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef map<int, int> mii;
typedef map<ll, ll> mll;
typedef vector<pii> vii;
typedef vector<pll> vll;
#define fi first
#define se second
#define pi 3.141592653589793
#define mod 1e9 + 7
#define pb push_back
#define all(v) v.begin(), v.end()
#define rall(v) v.begin(), v.end(), greater<ll>()
#define tc \
int t; \
cin >> t; \
while (t--)
#define pqmax priority_queue<int>
#define pqmin priority_queue<int, vi, greater<int>>
#define fast_io ios_base::sync_with_stdio(0), cin.tie(NULL)
#define tc_g \
int tt; \
cin >> tt; \
for (int ti = 1; ti <= tt; ti++)
#define case_g "Case #" << ti << ": "
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_multiset;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef tree<int, int, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_map;
using namespace std;
int main() {
ll n, m, quan, price;
cin >> n >> m;
vector<pair<ll, ll>> moni(n);
for (ll i = 0; i < n; ++i) {
cin >> price >> quan;
moni[i] = {price, quan};
}
sort(moni.begin(), moni.end());
ll ans = 0;
price = 0;
for (auto mon : moni) {
if ((ans + mon.second) <= m) {
ans += mon.second;
price += (mon.first * mon.second);
} else {
ll diff = m - ans;
price += (mon.first * diff);
break;
}
}
cout << price;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 910,054 | 910,055 | u688862905 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M, wa = 0, hako = 0, las = 0;
cin >> N >> M;
vector<vector<long long>> A(N, vector<long long>(2));
for (int i = 0; i < N; i++) {
cin >> A.at(i).at(0) >> A.at(i).at(1);
}
sort(A.begin(), A.end());
for (int i = 0; i < N; i++) {
if ((hako + A.at(i).at(1)) < M) {
hako += A.at(i).at(1);
wa += A.at(i).at(0) * A.at(i).at(1);
} else if ((hako + A.at(i).at(1)) > M && hako < M) {
las = M - hako;
wa += A.at(i).at(0) * las;
break;
}
}
cout << wa << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M, wa = 0, hako = 0, las = 0;
cin >> N >> M;
vector<vector<long long>> A(N, vector<long long>(2));
for (int i = 0; i < N; i++) {
cin >> A.at(i).at(0) >> A.at(i).at(1);
}
sort(A.begin(), A.end());
for (int i = 0; i < N; i++) {
if ((hako + A.at(i).at(1)) <= M) {
hako += A.at(i).at(1);
wa += A.at(i).at(0) * A.at(i).at(1);
} else if ((hako + A.at(i).at(1)) > M && hako < M) {
las = M - hako;
wa += A.at(i).at(0) * las;
break;
}
}
cout << wa << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,072 | 910,073 | u799751074 | cpp |
p03103 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n), b(m);
rep(i, n) cin >> a[i] >> b[i];
vector<pair<int, int>> pa(n);
rep(i, n) pa[i] = make_pair(a[i], b[i]);
sort(pa.begin(), pa.end());
ll ans = 0;
rep(i, n) {
int buy = min(m, pa[i].second);
ans += (ll)buy * pa[i].first;
m -= buy;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
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>> pa(n);
rep(i, n) pa[i] = make_pair(a[i], b[i]);
sort(pa.begin(), pa.end());
ll ans = 0;
rep(i, n) {
int buy = min(m, pa[i].second);
ans += (ll)buy * pa[i].first;
m -= buy;
}
cout << ans << endl;
return 0;
}
| [] | 910,074 | 910,075 | u448922807 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define arep(i, x, n) for (int i = int(x); i < (int)(n); i++)
#define rep(i, n) for (long long i = 0; i < n; ++i)
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9 + 7
using ll = long long;
using P = pair<int, int>;
using lP = pair<ll, ll>;
using fP = pair<double, double>;
ll const mod = 998244353;
const ll MAX = 300000;
using vi = vector<int>;
using vc = vector<char>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvp = vector<vector<P>>;
int main() {
int n, m;
cin >> n >> m;
vector<P> ab(n);
rep(i, n) cin >> ab[i].first >> ab[i].second;
sort(ab.begin(), ab.end());
ll ans = 0;
rep(i, n) {
if (m - ab[i].second <= 0) {
ans += ab[i].first * m;
break;
} else
ans += ab[i].first * ab[i].second;
m -= ab[i].second;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define arep(i, x, n) for (int i = int(x); i < (int)(n); i++)
#define rep(i, n) for (long long i = 0; i < n; ++i)
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9 + 7
using ll = long long;
using P = pair<int, int>;
using lP = pair<ll, ll>;
using fP = pair<double, double>;
ll const mod = 998244353;
const ll MAX = 300000;
using vi = vector<int>;
using vc = vector<char>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvp = vector<vector<P>>;
int main() {
int n, m;
cin >> n >> m;
vector<P> ab(n);
rep(i, n) cin >> ab[i].first >> ab[i].second;
sort(ab.begin(), ab.end());
ll ans = 0;
rep(i, n) {
if (m - ab[i].second <= 0) {
ans += (ll)ab[i].first * m;
break;
} else
ans += (ll)ab[i].first * ab[i].second;
m -= ab[i].second;
}
cout << ans << endl;
return 0;
} | [
"type_conversion.add"
] | 910,079 | 910,080 | u395287054 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, M;
cin >> N >> M;
vector<pair<long long int, long long int>> mise(N);
for (int i = 0; i < M; i++) {
cin >> mise[i].first >> mise[i].second;
}
sort(mise.begin(), mise.end());
long long int okane = 0;
long long int honsuu = 0;
for (int i = 0; i < N; i++) {
if (honsuu + mise[i].second <= M) {
okane += mise[i].first * mise[i].second;
if (honsuu + mise[i].second == M) {
cout << okane << endl;
return 0;
}
} else {
okane += mise[i].first * (M - honsuu);
cout << okane << endl;
return 0;
}
honsuu += mise[i].second;
}
cout << okane << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, M;
cin >> N >> M;
vector<pair<long long int, long long int>> mise(N);
for (long long int i = 0; i < N; i++) {
cin >> mise[i].first >> mise[i].second;
}
sort(mise.begin(), mise.end());
long long int okane = 0;
long long int honsuu = 0;
for (long long int i = 0; i < N; i++) {
if (honsuu + mise[i].second <= M) {
okane += mise[i].first * mise[i].second;
if (honsuu + mise[i].second == M) {
cout << okane << endl;
return 0;
}
} else {
okane += mise[i].first * (M - honsuu);
cout << okane << endl;
return 0;
}
honsuu += mise[i].second;
}
cout << okane << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 910,083 | 910,084 | u406647332 | cpp |
p03103 | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
vector<int> bitSearch(int bit, int n) {
vector<int> S;
rep(i, n) if (bit & (1 << i)) S.push_back(i);
return S;
}
int h, w;
vector<string> field(h);
bool seen[100][100];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int cnt = 0;
int dfs(int y, int x, int &cnt) {
cnt++;
seen[y][x] = true;
rep(i, 4) {
int ny = y + dy[i], nx = x + dx[i];
if (ny < 0 || ny >= h || nx < 0 || nx >= w)
continue;
if (field[ny][nx] != '#')
continue;
if (seen[ny][nx])
continue;
cnt++;
dfs(ny, nx, cnt);
}
return cnt;
}
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
rep(i, n) {
ll a, b;
cin >> a >> b;
mp[a] = b;
}
ll res = 0;
for (auto p : mp) {
if (m <= 0)
break;
res += (p.first * min(p.second, m));
m -= min(m, p.second);
}
cout << res << endl;
}
| #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
vector<int> bitSearch(int bit, int n) {
vector<int> S;
rep(i, n) if (bit & (1 << i)) S.push_back(i);
return S;
}
int h, w;
vector<string> field(h);
bool seen[100][100];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int cnt = 0;
int dfs(int y, int x, int &cnt) {
cnt++;
seen[y][x] = true;
rep(i, 4) {
int ny = y + dy[i], nx = x + dx[i];
if (ny < 0 || ny >= h || nx < 0 || nx >= w)
continue;
if (field[ny][nx] != '#')
continue;
if (seen[ny][nx])
continue;
cnt++;
dfs(ny, nx, cnt);
}
return cnt;
}
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
rep(i, n) {
ll a, b;
cin >> a >> b;
mp[a] += b;
}
ll res = 0;
for (auto p : mp) {
if (m <= 0)
break;
res += (p.first * min(p.second, m));
m -= min(m, p.second);
}
cout << res << endl;
}
| [
"assignment.value.change"
] | 910,087 | 910,088 | u516525290 | cpp |
p03103 | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
vector<int> bitSearch(int bit, int n) {
vector<int> S;
rep(i, n) if (bit & (1 << i)) S.push_back(i);
return S;
}
int h, w;
vector<string> field(h);
bool seen[100][100];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int cnt = 0;
int dfs(int y, int x, int &cnt) {
cnt++;
seen[y][x] = true;
rep(i, 4) {
int ny = y + dy[i], nx = x + dx[i];
if (ny < 0 || ny >= h || nx < 0 || nx >= w)
continue;
if (field[ny][nx] != '#')
continue;
if (seen[ny][nx])
continue;
cnt++;
dfs(ny, nx, cnt);
}
return cnt;
}
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
rep(i, n) {
ll a, b;
cin >> a >> b;
mp[a] = b;
}
ll res = 0;
for (auto p : mp) {
if (m <= 0)
break;
res += (p.first * min(p.second, m));
m -= p.second;
}
cout << res << endl;
}
| #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
vector<int> bitSearch(int bit, int n) {
vector<int> S;
rep(i, n) if (bit & (1 << i)) S.push_back(i);
return S;
}
int h, w;
vector<string> field(h);
bool seen[100][100];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int cnt = 0;
int dfs(int y, int x, int &cnt) {
cnt++;
seen[y][x] = true;
rep(i, 4) {
int ny = y + dy[i], nx = x + dx[i];
if (ny < 0 || ny >= h || nx < 0 || nx >= w)
continue;
if (field[ny][nx] != '#')
continue;
if (seen[ny][nx])
continue;
cnt++;
dfs(ny, nx, cnt);
}
return cnt;
}
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
rep(i, n) {
ll a, b;
cin >> a >> b;
mp[a] += b;
}
ll res = 0;
for (auto p : mp) {
if (m <= 0)
break;
res += (p.first * min(p.second, m));
m -= min(m, p.second);
}
cout << res << endl;
}
| [
"assignment.value.change",
"call.add",
"call.arguments.change"
] | 910,089 | 910,088 | u516525290 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<P> g(n);
rep(i, n) { cin >> g[i].fi >> g[i].se; }
sort(begin(g), end(g));
ll ans = 0;
rep(i, n) {
if (g[i].se <= m) {
ans += g[i].fi * g[i].se;
m -= g[i].se;
} else {
ans += g[i].fi * m;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<P> g(n);
rep(i, n) { cin >> g[i].fi >> g[i].se; }
sort(begin(g), end(g));
ll ans = 0;
rep(i, n) {
if (g[i].se <= m) {
ans += g[i].fi * g[i].se;
m -= g[i].se;
} else {
ans += g[i].fi * m;
break;
}
}
cout << ans << endl;
} | [
"control_flow.break.add"
] | 910,090 | 910,091 | u340010271 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<P> g(n);
rep(i, n) { cin >> g[i].fi >> g[i].se; }
sort(begin(g), end(g));
ll ans = 0;
rep(i, n) {
if (g[i].se <= m) {
ans += g[i].fi * g[i].se;
m -= g[i].se;
} else {
ans += g[i].fi * m;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<P> g(n);
rep(i, n) { cin >> g[i].fi >> g[i].se; }
sort(begin(g), end(g));
ll ans = 0;
rep(i, n) {
if (g[i].se <= m) {
ans += g[i].fi * g[i].se;
m -= g[i].se;
} else {
ans += g[i].fi * m;
break;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 910,092 | 910,091 | u340010271 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define contains(v, t) (find(v.begin(), v.end(), t) != v.end())
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> ma;
rep(i, n) {
int a, b;
cin >> a >> b;
ma[a] = b;
}
ll c = 0;
ll ans = 0;
for (auto itr = ma.begin(); itr != ma.end(); itr++) {
if (c + itr->second <= m) {
// 全部買う
ans += itr->first * itr->second;
c += itr->second;
if (c == m) {
cout << ans;
return 0;
}
} else {
// 必要な分だけ買う
ans += itr->first * (m - c);
cout << ans;
return 0;
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define contains(v, t) (find(v.begin(), v.end(), t) != v.end())
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> ma;
rep(i, n) {
int a, b;
cin >> a >> b;
ma[a] += b;
}
ll c = 0;
ll ans = 0;
for (auto itr = ma.begin(); itr != ma.end(); itr++) {
if (c + itr->second <= m) {
// 全部買う
ans += itr->first * itr->second;
c += itr->second;
if (c == m) {
cout << ans;
return 0;
}
} else {
// 必要な分だけ買う
ans += itr->first * (m - c);
cout << ans;
return 0;
}
}
}
| [
"assignment.value.change"
] | 910,098 | 910,099 | u459025138 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define contains(v, t) (find(v.begin(), v.end(), t) != v.end())
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> ma;
rep(i, n) {
int a, b;
cin >> a >> b;
ma[a] = b;
}
ll c = 0;
ll ans = 0;
for (auto itr = ma.begin(); itr != ma.end(); itr++) {
if (c + itr->second <= m) {
// 全部買う
ans += itr->first * itr->second;
c += itr->second;
if (c == m) {
cout << ans;
return 0;
}
} else {
// 必要な分だけ買う
ans += itr->first * (m - c);
cout << ans;
return 0;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define contains(v, t) (find(v.begin(), v.end(), t) != v.end())
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> ma;
rep(i, n) {
int a, b;
cin >> a >> b;
ma[a] += b;
}
ll c = 0;
ll ans = 0;
for (auto itr = ma.begin(); itr != ma.end(); itr++) {
if (c + itr->second <= m) {
// 全部買う
ans += itr->first * itr->second;
c += itr->second;
if (c == m) {
cout << ans;
return 0;
}
} else {
// 必要な分だけ買う
ans += itr->first * (m - c);
cout << ans;
return 0;
}
}
}
| [
"assignment.value.change"
] | 910,100 | 910,099 | u459025138 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define contains(v, t) (find(v.begin(), v.end(), t) != v.end())
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
int n, m;
cin >> n >> m;
map<int, int> ma;
rep(i, n) {
int a, b;
cin >> a >> b;
ma[a] = b;
}
ll c = 0;
ll ans = 0;
for (auto itr = ma.begin(); itr != ma.end(); itr++) {
if (c + itr->second <= m) {
// 全部買う
ans += itr->first * itr->second;
c += itr->second;
if (c == m) {
cout << ans;
return 0;
}
} else {
// 必要な分だけ買う
ans += itr->first * (m - c);
cout << ans;
return 0;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define contains(v, t) (find(v.begin(), v.end(), t) != v.end())
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> ma;
rep(i, n) {
int a, b;
cin >> a >> b;
ma[a] += b;
}
ll c = 0;
ll ans = 0;
for (auto itr = ma.begin(); itr != ma.end(); itr++) {
if (c + itr->second <= m) {
// 全部買う
ans += itr->first * itr->second;
c += itr->second;
if (c == m) {
cout << ans;
return 0;
}
} else {
// 必要な分だけ買う
ans += itr->first * (m - c);
cout << ans;
return 0;
}
}
}
| [
"variable_declaration.type.change",
"assignment.value.change"
] | 910,101 | 910,099 | u459025138 | cpp |
p03103 | // Jai Bhole Ki
#include <bits/stdc++.h>
using namespace std;
#define fast \
static int fastline = []() { \
std::ios::sync_with_stdio(false); \
cin.tie(NULL); \
return 0; \
}();
#define ll long long
#define LL unsigned ll
#define pb push_back
#define pi pair<ll, ll>
#define debug(x) cout << x << "\n";
#define debug cout << "debugged\n";
#define minval -2e9
#define maxval 2e9
long double PI = 3.14159265358979323846;
const ll M = 1e9 + 7;
const ll inf = 1e18;
const ll ms = 2e5 + 5;
fast;
ll n, m, c, ans;
void solve() {
cin >> n >> m;
map<ll, ll> mp;
for (ll i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
mp[a] = b;
}
for (auto it : mp) {
if (m) {
ll temp = min(it.second, m);
ans += temp * it.first;
m -= temp;
} else
break;
}
cout << ans << endl;
}
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// int t;cin>>t;while(t--)
{ solve(); }
return 0;
} | // Jai Bhole Ki
#include <bits/stdc++.h>
using namespace std;
#define fast \
static int fastline = []() { \
std::ios::sync_with_stdio(false); \
cin.tie(NULL); \
return 0; \
}();
#define ll long long
#define LL unsigned ll
#define pb push_back
#define pi pair<ll, ll>
#define debug(x) cout << x << "\n";
#define debug cout << "debugged\n";
#define minval -2e9
#define maxval 2e9
long double PI = 3.14159265358979323846;
const ll M = 1e9 + 7;
const ll inf = 1e18;
const ll ms = 2e5 + 5;
fast;
ll n, m, c, ans;
void solve() {
cin >> n >> m;
map<ll, ll> mp;
for (ll i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
mp[a] += b;
}
for (auto it : mp) {
if (m) {
ll temp = min(it.second, m);
ans += temp * it.first;
m -= temp;
} else
break;
}
cout << ans << endl;
}
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// int t;cin>>t;while(t--)
{ solve(); }
return 0;
}
| [
"assignment.value.change"
] | 910,102 | 910,103 | u526639495 | cpp |
p03103 | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> ab(n);
rep(i, n) {
int a, b;
cin >> a >> b;
ab[i].first = a;
ab[i].second = b;
}
//////////////
sort(all(ab));
// cout<<ab[0].first;
ll sum = 0; //買った本数
ll ans = 0;
rep(i, n) {
if ((sum + ab[i].second) < m) {
sum += ab[i].second;
ans += ab[i].first * ab[i].second;
} else {
int c = m - sum;
ans += c * ab[i].first;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using namespace std;
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> ab(n);
rep(i, n) {
ll a, b;
cin >> a >> b;
ab[i].first = a;
ab[i].second = b;
}
//////////////
sort(all(ab));
// cout<<ab[0].first;
ll sum = 0; //買った本数
ll ans = 0;
rep(i, n) {
if ((sum + ab[i].second) < m) {
sum += ab[i].second;
ans += ab[i].first * ab[i].second;
} else {
ll c = m - sum;
ans += c * ab[i].first;
break;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 910,109 | 910,110 | u531461815 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<int, int> d[n];
for (int i = 0; i < n; i++)
cin >> d[i].first >> d[i].second;
sort(d, d + n);
long long sum = 0;
for (int i = 0; m > 0; i++) {
if (m >= d[i].second) {
sum += d[i].second * d[i].first;
m -= d[i].second;
} else {
sum += m * d[i].first;
m = 0;
}
}
cout << sum;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<long long, long long> d[n];
for (int i = 0; i < n; i++)
cin >> d[i].first >> d[i].second;
sort(d, d + n);
long long sum = 0;
for (int i = 0; m > 0; i++) {
if (m >= d[i].second) {
sum += d[i].second * d[i].first;
m -= d[i].second;
} else {
sum += m * d[i].first;
m = 0;
}
}
cout << sum;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,115 | 910,116 | u297195722 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<int, int> d[n];
for (int i = 0; i < n; i++)
cin >> d[i].first >> d[i].second;
sort(d, d + n);
long long sum = 0;
for (int i = 0; m > 0; i++) {
if (m >= d[i].second) {
sum += d[i].second * d[i].first;
m -= d[i].second;
} else {
sum += m * d[i].second;
m = 0;
}
}
cout << sum;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<long long, long long> d[n];
for (int i = 0; i < n; i++)
cin >> d[i].first >> d[i].second;
sort(d, d + n);
long long sum = 0;
for (int i = 0; m > 0; i++) {
if (m >= d[i].second) {
sum += d[i].second * d[i].first;
m -= d[i].second;
} else {
sum += m * d[i].first;
m = 0;
}
}
cout << sum;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 910,117 | 910,116 | u297195722 | cpp |
p03103 | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(X, Y, Z) for (ll(X) = (Y); (X) < (Z); (X)++)
#define REV(X, Y, Z) for (ll(X) = (Y); (X) > (Z); (X)--)
using namespace std;
using ll = long long;
using dll = deque<ll>;
using pll = pair<ll, ll>;
using qll = queue<ll>;
using usll = unordered_set<ll>;
using umll = unordered_map<ll, ll>;
using sll = stack<int>;
using vll = vector<ll>;
using vvll = vector<vll>;
constexpr ll kMod = 1e9 + 7;
ll gcd(ll a, ll b) {
if (a < b) {
return gcd(b, a);
}
ll c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
void init() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
int main() {
init();
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> V(N);
REP(i, 0, N) {
ll a, b;
cin >> a >> b;
V[i] = pair<ll, ll>(a, b);
}
sort(V.begin(), V.end(), less<>());
ll cost = 0;
ll remain = M;
REP(i, 0, V.size()) {
if (remain >= V[i].second) {
remain -= V[i].second;
cost += V[i].second * V[i].first;
} else {
cost += V[i].first * remain;
cout << cost << endl;
return 0;
}
}
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define REP(X, Y, Z) for (ll(X) = (Y); (X) < (Z); (X)++)
#define REV(X, Y, Z) for (ll(X) = (Y); (X) > (Z); (X)--)
using namespace std;
using ll = long long;
using dll = deque<ll>;
using pll = pair<ll, ll>;
using qll = queue<ll>;
using usll = unordered_set<ll>;
using umll = unordered_map<ll, ll>;
using sll = stack<int>;
using vll = vector<ll>;
using vvll = vector<vll>;
constexpr ll kMod = 1e9 + 7;
ll gcd(ll a, ll b) {
if (a < b) {
return gcd(b, a);
}
ll c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
void init() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
int main() {
init();
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> V(N);
REP(i, 0, N) {
ll a, b;
cin >> a >> b;
V[i] = pair<ll, ll>(a, b);
}
sort(V.begin(), V.end(), less<>());
ll cost = 0;
ll remain = M;
REP(i, 0, V.size()) {
if (remain > V[i].second) {
remain -= V[i].second;
cost += V[i].second * V[i].first;
} else {
cost += V[i].first * remain;
cout << cost << endl;
return 0;
}
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,118 | 910,119 | u840713046 | cpp |
p03103 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define ll long long
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());
int ans = 0;
for (int i = 0; i < n; i++) {
ans += ab[i][0] * min(ab[i][1], m);
m -= ab[i][1];
if (m <= 0)
break;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
int main() {
ll n, m;
cin >> n >> m;
vector<vector<ll>> ab(n, vector<ll>(2));
for (ll i = 0; i < n; i++) {
cin >> ab[i][0] >> ab[i][1];
}
sort(ab.begin(), ab.end());
ll ans = 0;
for (ll i = 0; i < n; i++) {
ans += ab[i][0] * min(ab[i][1], m);
m -= ab[i][1];
if (m <= 0)
break;
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change",
"call.arguments.change",
"control_flow.loop.for.initializer.change"
] | 910,126 | 910,127 | u476027087 | cpp |
p03103 | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
int n, m;
cin >> n >> m;
P memo[n];
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
memo[i] = make_pair(a, b);
}
sort(memo, memo + n);
ll ans = 0;
for (int i = 0; i < n; i++) {
int a = min(m, memo[i].second);
ans += memo[i].first * a;
m -= a;
if (m == 0)
break;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
ll n, m;
cin >> n >> m;
llP memo[n];
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
memo[i] = make_pair(a, b);
}
sort(memo, memo + n);
ll ans = 0;
for (int i = 0; i < n; i++) {
ll a = min(m, memo[i].second);
ans += memo[i].first * a;
m -= a;
if (m == 0)
break;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 910,132 | 910,133 | u201553784 | cpp |
p03103 | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
int n, m;
cin >> n >> m;
P memo[m];
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
memo[i] = make_pair(a, b);
}
sort(memo, memo + n);
ll ans = 0;
for (int i = 0; i < n; i++) {
int a = min(m, memo[i].second);
ans += memo[i].first * a;
m -= a;
if (m == 0)
break;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
int main() {
ll n, m;
cin >> n >> m;
llP memo[n];
for (int i = 0; i < n; i++) {
ll a, b;
cin >> a >> b;
memo[i] = make_pair(a, b);
}
sort(memo, memo + n);
ll ans = 0;
for (int i = 0; i < n; i++) {
ll a = min(m, memo[i].second);
ans += memo[i].first * a;
m -= a;
if (m == 0)
break;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change",
"identifier.change",
"variable_declaration.array_dimensions.change"
] | 910,134 | 910,133 | u201553784 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
int main() {
int n, m;
cin >> n >> m;
vector<pii> x(n);
rep(i, n) {
ll a, b;
cin >> a >> b;
x[i].first = a;
x[i].second = b;
}
ll ans = 0;
sort(x.begin(), x.end());
ll i = 0;
while (m > 0 && i < n) {
if (m - x[i].second >= 0) {
ans += x[i].first * x[i].second;
m -= x[i].second;
} else {
ans += x[i].first * m;
}
i++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using pii = pair<ll, ll>;
int main() {
int n, m;
cin >> n >> m;
vector<pii> x(n);
rep(i, n) {
ll a, b;
cin >> a >> b;
x[i].first = a;
x[i].second = b;
}
ll ans = 0;
sort(x.begin(), x.end());
ll i = 0;
while (m > 0 && i < n) {
if (m - x[i].second >= 0) {
ans += x[i].first * x[i].second;
m -= x[i].second;
} else {
ans += x[i].first * m;
break;
}
i++;
}
cout << ans << endl;
} | [
"control_flow.break.add"
] | 910,139 | 910,140 | u816145694 | cpp |
p03103 | #include <algorithm>
#include <cctype>
#include <iostream>
#include <math.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> d(n);
rep(i, n) {
int a, b;
cin >> a >> b;
d[i] = make_pair(a, b);
}
sort(d.begin(), d.end());
ll ans = 0;
rep(i, n) {
int now = min(m, d[i].second);
m -= now;
ans += d[i].first * now;
if (m <= 0) {
cout << ans << endl;
return 0;
}
}
}
| #include <algorithm>
#include <cctype>
#include <iostream>
#include <math.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<pair<ll, int>> d(n);
rep(i, n) {
int a, b;
cin >> a >> b;
d[i] = make_pair(a, b);
}
sort(d.begin(), d.end());
ll ans = 0;
rep(i, n) {
int now = min(m, d[i].second);
m -= now;
ans += d[i].first * now;
if (m <= 0) {
cout << ans << endl;
return 0;
}
}
}
| [] | 910,141 | 910,142 | u745267317 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
long long ans = 0;
cin >> n >> m;
vector<pair<int, int>> AB(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
AB[i] = make_pair(a, b);
}
sort(AB.begin(), AB.end());
for (int i = 0;; i++) {
if (AB[i].second >= m) {
ans += AB[i].first * m;
cout << ans << endl;
return 0;
}
ans += AB[i].first * AB[i].second;
m -= AB[i].second;
}
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
long long ans = 0;
cin >> n >> m;
vector<pair<long long, long long>> AB(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
AB[i] = make_pair(a, b);
}
sort(AB.begin(), AB.end());
for (int i = 0;; i++) {
if (AB[i].second >= m) {
ans += AB[i].first * m;
cout << ans << endl;
return 0;
}
ans += AB[i].first * AB[i].second;
m -= AB[i].second;
}
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,143 | 910,144 | u234365185 | cpp |
p03103 | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define lb long double
#define pb push_back
#define price first
#define drinks second
#define qwerty3 ->first
#define qwerty4 ->second
#define umap unordered_map
#define uset unordered_set
#define pii pair<ll, ll>
using namespace std;
const int N = 100005;
const ll M = 1000000007;
const lb PI = acos(-1);
ll n, m;
pii a[N];
bool inline cmp(pii a, pii b) { return a.price < b.price; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
ll i, money = 0;
cin >> n >> m;
for (i = 1; i <= n; i++)
cin >> a[i].price >> a[i].drinks;
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) {
if (m >= a[i].drinks)
m -= a[i].drinks, money += a[i].drinks * a[i].price;
else
money += m * a[i].price;
}
cout << money;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define lb long double
#define pb push_back
#define price first
#define drinks second
#define qwerty3 ->first
#define qwerty4 ->second
#define umap unordered_map
#define uset unordered_set
#define pii pair<ll, ll>
using namespace std;
const int N = 100005;
const ll M = 1000000007;
const lb PI = acos(-1);
ll n, m;
pii a[N];
bool inline cmp(pii a, pii b) { return a.price < b.price; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
ll i, money = 0;
cin >> n >> m;
for (i = 1; i <= n; i++)
cin >> a[i].price >> a[i].drinks;
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n && m; i++) {
if (m >= a[i].drinks)
m -= a[i].drinks, money += a[i].drinks * a[i].price;
else
money += m * a[i].price, m = 0;
}
cout << money;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 910,145 | 910,146 | u916060970 | cpp |
p03103 | #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <limits>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
vector<pair<long long, int>> c_info;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N, M;
cin >> N >> M;
c_info.assign(M, make_pair(0, 0));
for (int i = 0; i < N; i++) {
cin >> c_info[i].first >> c_info[i].second;
}
sort(c_info.begin(), c_info.end());
long long result = 0;
int idx = 0;
while (M > 0) {
int buy_cnt = min(M, c_info[idx].second);
M -= buy_cnt;
result += buy_cnt * c_info[idx].first;
idx++;
}
cout << result;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iostream>
#include <limits>
#include <numeric>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
vector<pair<long long, int>> c_info;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N, M;
cin >> N >> M;
c_info.assign(N, make_pair(0, 0));
for (int i = 0; i < N; i++) {
cin >> c_info[i].first >> c_info[i].second;
}
sort(c_info.begin(), c_info.end());
long long result = 0;
int idx = 0;
while (M > 0) {
int buy_cnt = min(M, c_info[idx].second);
M -= buy_cnt;
result += buy_cnt * c_info[idx].first;
idx++;
}
cout << result;
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 910,154 | 910,155 | u557207741 | cpp |
p03103 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
int main() {
ll n, m;
cin >> n >> m;
vector<pair<int, int>> vec(n);
rep(i, n) { cin >> vec[i].first >> vec[i].second; }
sort(all(vec));
ll cnt = 0, sum = 0;
for (int i = 0; i < n; i++) {
if (cnt + vec[i].second > m) {
sum += vec[i].first * (m - cnt);
cout << sum << endl;
return 0;
} else {
sum += vec[i].first * vec[i].second;
m -= vec[i].second;
}
}
} | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> vec(n);
rep(i, n) { cin >> vec[i].first >> vec[i].second; }
sort(all(vec));
ll cnt = 0, sum = 0;
for (int i = 0; i < n; i++) {
if (cnt + vec[i].second >= m) {
sum += vec[i].first * (m - cnt);
cout << sum << endl;
return 0;
} else {
sum += vec[i].first * vec[i].second;
cnt += vec[i].second;
}
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 910,163 | 910,161 | u168684371 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> lis;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (lis.count(a))
lis[a] += b;
else
lis[a] = b;
}
long long ans = 0;
int count = 0;
for (auto l : lis) {
auto k = l.first;
auto v = l.second;
if (v > m - count) {
ans += k * (m - count);
count = m;
} else {
count += v;
ans += k * v;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<long long, int> lis;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (lis.count(a))
lis[a] += b;
else
lis[a] = b;
}
long long ans = 0;
int count = 0;
for (auto l : lis) {
auto k = l.first;
auto v = l.second;
if (v > m - count) {
ans += k * (m - count);
count = m;
} else {
count += v;
ans += k * v;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,174 | 910,175 | u732578115 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long int ll;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> P(N);
rep(i, N) { cin >> P.at(i).first >> P.at(i).second; }
sort(P.begin(), P.end());
ll cnt = 0, m = 0;
while (cnt < M) {
rep(i, N) {
int t = M - cnt;
if (t <= P.at(i).second) {
cnt += t;
m += t * P.at(i).first;
} else {
cnt += P.at(i).second;
m += P.at(i).first * P.at(i).second;
}
}
}
cout << m << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long int ll;
int main() {
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> P(N);
rep(i, N) { cin >> P.at(i).first >> P.at(i).second; }
sort(P.begin(), P.end());
ll cnt = 0, m = 0;
while (cnt < M) {
rep(i, N) {
ll t = M - cnt;
if (t <= P.at(i).second) {
cnt += t;
m += t * P.at(i).first;
} else {
cnt += P.at(i).second;
m += P.at(i).first * P.at(i).second;
}
}
}
cout << m << endl;
}
| [
"variable_declaration.type.change"
] | 910,189 | 910,190 | u089241640 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
int main(int argc, char *argv[]) {
int n, m;
std::cin >> n >> m;
std::vector<std::pair<int, int>> s(n);
for (int i = 0; i < n; ++i)
std::cin >> s.at(i).first >> s.at(i).second;
std::stable_sort(s.begin(), s.end());
int sum = 0;
for (auto &v : s) {
if (v.second >= m) {
std::cout << sum + (v.first * m) << std::endl;
return 0;
}
sum += v.first * v.second;
m -= v.second;
}
return 1;
}
| #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
int main(int argc, char *argv[]) {
long n, m;
std::cin >> n >> m;
std::vector<std::pair<long, int>> s(n);
for (int i = 0; i < n; ++i)
std::cin >> s.at(i).first >> s.at(i).second;
std::stable_sort(s.begin(), s.end());
long sum = 0;
for (auto &v : s) {
if (v.second >= m) {
std::cout << sum + (v.first * m) << std::endl;
return 0;
}
sum += v.first * v.second;
m -= v.second;
}
return 1;
}
| [
"variable_declaration.type.primitive.change"
] | 910,204 | 910,203 | u089888152 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
long long int a, b;
cin >> n >> m;
std::map<long long int, long long int> map;
for (int i = 0; i < n; i++) {
cin >> a >> b;
map.emplace(a, b);
}
long long int sum = 0;
for (auto itr = map.begin(); itr != map.end(); itr++) {
if (itr->second < m) {
sum += itr->first * itr->second;
m -= itr->second;
} else {
sum += itr->first * m;
break;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
long long int a, b;
cin >> n >> m;
std::multimap<long long int, long long int> map;
for (int i = 0; i < n; i++) {
cin >> a >> b;
map.emplace(a, b);
}
long long int sum = 0;
for (auto itr = map.begin(); itr != map.end(); itr++) {
if (itr->second < m) {
sum += itr->first * itr->second;
m -= itr->second;
} else {
sum += itr->first * m;
break;
}
}
cout << sum << endl;
} | [] | 910,224 | 910,225 | u485821416 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
long long int a, b;
cin >> n >> m;
std::map<long long int, long long int> map;
for (int i = 0; i < n; i++) {
cin >> a >> b;
map.emplace(a, b);
}
long long int sum = 0;
for (auto itr = map.begin(); itr != map.end(); itr++) {
if (itr->second <= m) {
sum += itr->first * itr->second;
m -= itr->second;
} else {
sum += itr->first * m;
break;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
long long int a, b;
cin >> n >> m;
std::multimap<long long int, long long int> map;
for (int i = 0; i < n; i++) {
cin >> a >> b;
map.emplace(a, b);
}
long long int sum = 0;
for (auto itr = map.begin(); itr != map.end(); itr++) {
if (itr->second < m) {
sum += itr->first * itr->second;
m -= itr->second;
} else {
sum += itr->first * m;
break;
}
}
cout << sum << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 910,226 | 910,225 | u485821416 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i > 0; i++)
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<tuple<int, int>> memo;
rep(i, n) {
int a, b;
cin >> a >> b;
memo.push_back(make_tuple(a, b));
}
sort(memo.begin(), memo.end());
int need = m;
ll ans = 0;
rep(i, n) {
if (need >= get<1>(memo[i])) {
ans += get<0>(memo[i]) * get<1>(memo[i]);
need -= get<1>(memo[i]);
} else {
ans += get<0>(memo[i]) * need;
need = 0;
}
if (need == 0)
break;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i > 0; i++)
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<tuple<ll, ll>> memo;
rep(i, n) {
ll a, b;
cin >> a >> b;
memo.push_back(make_tuple(a, b));
}
sort(memo.begin(), memo.end());
ll need = m;
ll ans = 0;
rep(i, n) {
if (need >= get<1>(memo[i])) {
ans += get<0>(memo[i]) * get<1>(memo[i]);
need -= get<1>(memo[i]);
} else {
ans += get<0>(memo[i]) * need;
need = 0;
}
if (need == 0)
break;
}
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 910,229 | 910,230 | u297398560 | cpp |
p03103 | #pragma region
#include <bits/stdc++.h>
using namespace std;
inline void ci(void) { return; }
template <typename First, typename... Rest>
void ci(First &first, Rest &...rest) {
cin >> first;
ci(rest...);
return;
}
inline void co(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest> void co(First first, Rest... rest) {
cout << first << " ";
co(rest...);
return;
}
#define ll long long
#define ld long double
#define st string
#define dl double
#define wh while
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define tp tuple
#define ft first
#define sc second
#define ve vector
#define tos to_string
#define len length
#define rt return 0
#define gcd __gcd
#define lcm(n, m) n *m / gcd(n, m)
#define np next_permutation
#define repi(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) repi(i, 0, n)
#define repill(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define repll(i, n) repill(i, 0, n)
#define sz(v) ((int)(v).size())
#define each(i, n) for (auto &&i : n)
#define so(n) sort(n.begin(), n.end())
#define rev(n) reverse(n.begin(), n.end())
#define sp(n) cout << fixed << setprecision(n)
#pragma endregion
// sqrt ルート, int 2*10^9, gcd 最大公約数
int main() {
ll N, M, a = 0, b = 0, c = 0, d = 0;
ci(N, M);
ve<pair<ll, ll>> A(N);
rep(i, N) {
ci(a, b);
A.at(i) = mp(a, b);
}
so(A);
repll(i, N) {
if (c + A.at(i).sc < M) {
c += A.at(i).ft * A.at(i).sc;
d += A.at(i).sc;
} else {
c += A.at(i).ft * (M - d);
co(c);
rt;
}
}
} | #pragma region
#include <bits/stdc++.h>
using namespace std;
inline void ci(void) { return; }
template <typename First, typename... Rest>
void ci(First &first, Rest &...rest) {
cin >> first;
ci(rest...);
return;
}
inline void co(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest> void co(First first, Rest... rest) {
cout << first << " ";
co(rest...);
return;
}
#define ll long long
#define ld long double
#define st string
#define dl double
#define wh while
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define tp tuple
#define ft first
#define sc second
#define ve vector
#define tos to_string
#define len length
#define rt return 0
#define gcd __gcd
#define lcm(n, m) n *m / gcd(n, m)
#define np next_permutation
#define repi(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) repi(i, 0, n)
#define repill(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define repll(i, n) repill(i, 0, n)
#define sz(v) ((int)(v).size())
#define each(i, n) for (auto &&i : n)
#define so(n) sort(n.begin(), n.end())
#define rev(n) reverse(n.begin(), n.end())
#define sp(n) cout << fixed << setprecision(n)
#pragma endregion
// sqrt ルート, int 2*10^9, gcd 最大公約数
int main() {
ll N, M, a = 0, b = 0, c = 0, d = 0;
ci(N, M);
ve<pair<ll, ll>> A(N);
rep(i, N) {
ci(a, b);
A.at(i) = mp(a, b);
}
so(A);
repll(i, N) {
if (d + A.at(i).sc < M) {
c += A.at(i).ft * A.at(i).sc;
d += A.at(i).sc;
} else {
c += A.at(i).ft * (M - d);
co(c);
rt;
}
}
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 910,235 | 910,236 | u449573758 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, l, r) for (ll i = (l); i < (r); i++)
#define repp(i, l, r, k) for (ll i = (l); i < (r); i += (k))
int main() {
int n, m;
ll ans = 0;
cin >> n >> m;
vector<pair<int, int>> vc(n);
rep(i, 0, n) cin >> vc[i].first >> vc[i].second;
sort(vc.begin(), vc.end());
rep(i, 0, n) {
if (vc[i].second >= m) {
ans += vc[i].first * m;
break;
} else {
m -= vc[i].second;
ans += vc[i].first * vc[i].second;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, l, r) for (ll i = (l); i < (r); i++)
#define repp(i, l, r, k) for (ll i = (l); i < (r); i += (k))
int main() {
ll n, m;
ll ans = 0;
cin >> n >> m;
vector<pair<ll, ll>> vc(n);
rep(i, 0, n) cin >> vc[i].first >> vc[i].second;
sort(vc.begin(), vc.end());
rep(i, 0, n) {
if (vc[i].second >= m) {
ans += vc[i].first * m;
break;
} else {
m -= vc[i].second;
ans += vc[i].first * vc[i].second;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.change"
] | 910,240 | 910,241 | u200060866 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (ll i = 1; i <= (n); ++i)
#define pii pair<int, int>
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
int inf = 1000001000;
ll INF = 100000000000000000;
ll MOD = 1000000007;
// g++ code.cpp ./a.out
int main() {
ll n, m;
cin >> n >> m;
vector<pii> p;
rep(i, n) {
ll a, b;
cin >> a >> b;
p.push_back(make_pair(a, b));
}
sort(p.begin(), p.end());
ll ans = 0;
rep(i, n) {
if (p[i].first < m) {
ans += p[i].first * p[i].second;
m -= p[i].second;
} else {
ans += p[i].first * m;
cout << ans << endl;
return 0;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (ll i = 1; i <= (n); ++i)
#define pll pair<ll, ll>
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
int inf = 1000001000;
ll INF = 100000000000000000;
ll MOD = 1000000007;
// g++ code.cpp ./a.out
int main() {
ll n, m;
cin >> n >> m;
vector<pll> p;
rep(i, n) {
ll a, b;
cin >> a >> b;
p.push_back(make_pair(a, b));
}
sort(p.begin(), p.end());
ll ans = 0;
rep(i, n) {
if (p[i].second < m) {
ans += p[i].first * p[i].second;
m -= p[i].second;
} else {
ans += p[i].first * m;
cout << ans << endl;
return 0;
}
}
}
| [
"identifier.change",
"preprocessor.define.value.change",
"control_flow.branch.if.condition.change"
] | 910,244 | 910,243 | u510383220 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define ll long long
#define pp pair<int, int>
// int 2×10の9乗
int main() {
int n, m;
cin >> n >> m;
vector<pp> a(n);
rep(i, n) cin >> a[i].first >> a[i].second;
sort(a.begin(), a.end());
ll ans = 0;
rep(i, n) {
if (m >= a[i].second) {
ans += a[i].first * a[i].second;
m -= a[i].second;
} else {
ans += a[i].first * m, m = 0;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define ll long long
#define pp pair<int, int>
// int 2×10の9乗
int main() {
int n, m;
cin >> n >> m;
vector<pair<long, long>> a(n);
rep(i, n) cin >> a[i].first >> a[i].second;
sort(a.begin(), a.end());
ll ans = 0;
rep(i, n) {
if (m >= a[i].second) {
ans += a[i].first * a[i].second;
m -= a[i].second;
} else {
ans += a[i].first * m, m = 0;
}
}
cout << ans << endl;
}
| [] | 910,245 | 910,246 | u510383220 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<P> ab;
rep(i, n) {
int a, b;
cin >> a >> b;
ab.push_back(make_pair(a, b));
}
sort(ab.begin(), ab.end());
ll ans = 0;
rep(i, n) {
ans += ab[i].first * min(ab[i].second, m);
m -= ab[i].second;
if (m <= 0)
break;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<P> ab;
rep(i, n) {
int a, b;
cin >> a >> b;
ab.push_back(make_pair(a, b));
}
sort(ab.begin(), ab.end());
ll ans = 0;
rep(i, n) {
ans += (ll)ab[i].first * min(ab[i].second, m);
m -= ab[i].second;
if (m <= 0)
break;
}
cout << ans << endl;
} | [
"type_conversion.add"
] | 910,250 | 910,251 | u068713120 | cpp |
p03103 | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < n; i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
ll sum = 0;
int count = 0;
cin >> N >> M;
vector<pair<int, int>> data(N);
rep(i, N) { cin >> data[i].first >> data[i].second; }
sort(data.begin(), data.end());
rep(i, N) {
count += data[i].second;
if (count <= M) {
sum += data[i].first * data[i].second;
} else {
int amari = M - (count - data[i].second);
sum += data[i].first * amari;
break;
}
}
cout << sum << endl;
} | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < n; i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
ll sum = 0;
int count = 0;
cin >> N >> M;
vector<pair<ll, int>> data(N);
rep(i, N) { cin >> data[i].first >> data[i].second; }
sort(data.begin(), data.end());
rep(i, N) {
count += data[i].second;
if (count <= M) {
sum += data[i].first * data[i].second;
} else {
int amari = M - (count - data[i].second);
sum += data[i].first * amari;
break;
}
}
cout << sum << endl;
} | [] | 910,252 | 910,253 | u138273120 | cpp |
p03103 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, c))
#define pb push_back
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int inf = 1001001001;
int main() {
int n, m;
cin >> n >> m;
vector<P> dr(n);
rep(i, n) cin >> dr[i].first >> dr[i].second;
sort(all(dr));
ll ans = 0;
ll now = 0;
ll cnt = 0;
while (cnt < m) {
ll nf = dr[now].first;
ll ns = dr[now].second;
if (ns + cnt <= m) {
cnt += m;
ans += nf * ns;
} else {
ans += nf * (m - cnt);
cnt = m;
}
now++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep2(i, s, n) for (int i = s; i < n; ++i)
#define all(a) a.begin(), a.end()
#define tmax(a, b, c) max(a, max(b, c))
#define tmin(a, b, c) min(a, min(b, c))
#define pb push_back
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int inf = 1001001001;
int main() {
int n, m;
cin >> n >> m;
vector<P> dr(n);
rep(i, n) cin >> dr[i].first >> dr[i].second;
sort(all(dr));
ll ans = 0;
ll now = 0;
ll cnt = 0;
while (cnt < m) {
ll nf = dr[now].first;
ll ns = dr[now].second;
if (ns + cnt <= m) {
cnt += ns;
ans += nf * ns;
} else {
ans += nf * (m - cnt);
break;
}
now++;
}
cout << ans << endl;
} | [
"assignment.value.change",
"identifier.change",
"assignment.change"
] | 910,254 | 910,255 | u853721692 | cpp |
p03103 | #include <algorithm>
#include <iostream>
#include <math.h>
#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 result = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
result += (long long)buy * AB[i].first;
M -= buy;
}
cout << result << endl;
} | #include <algorithm>
#include <iostream>
#include <math.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 i = 0; i < N; i++) {
AB[i] = make_pair(A[i], B[i]);
}
sort(AB.begin(), AB.end());
long long result = 0;
for (int i = 0; i < N; i++) {
int buy = min(M, AB[i].second);
result += (long long)buy * AB[i].first;
M -= buy;
}
cout << result << endl;
} | [] | 910,262 | 910,263 | u274195948 | cpp |
p03103 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
// #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr long long int infll = 1001001001001001LL;
constexpr int INF = 1000000007;
constexpr int inf = 1000000007;
const int mod = 1000000007;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline double nCr(const int n, int r) {
if (n == 0) {
return 0;
}
if (r == 0) {
return 1;
}
if (r == 1) {
return n;
}
if (n == r) {
return 1;
}
if (r > n / 2) {
r = n / 2;
}
double result = 1;
for (double i = 1; i <= r; i++) {
result *= (n - i + 1) / i;
}
return (result);
}
template <typename T> T seinomi(T a) {
if (a > 0) {
return a;
} else {
return 0;
}
}
//----------------------------------------------------------------
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> rensou;
ll a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
rensou[a] = b;
}
ll cnt = 0;
ll sum = 0;
for (auto f : rensou) {
cnt += f.second;
sum += f.first * f.second;
if (cnt >= m) {
sum -= (cnt - m) * f.first;
break;
}
}
cout << sum << endl;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
// #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr long long int infll = 1001001001001001LL;
constexpr int INF = 1000000007;
constexpr int inf = 1000000007;
const int mod = 1000000007;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline double nCr(const int n, int r) {
if (n == 0) {
return 0;
}
if (r == 0) {
return 1;
}
if (r == 1) {
return n;
}
if (n == r) {
return 1;
}
if (r > n / 2) {
r = n / 2;
}
double result = 1;
for (double i = 1; i <= r; i++) {
result *= (n - i + 1) / i;
}
return (result);
}
template <typename T> T seinomi(T a) {
if (a > 0) {
return a;
} else {
return 0;
}
}
//----------------------------------------------------------------
int main() {
ll n, m;
cin >> n >> m;
map<ll, ll> rensou;
ll a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
rensou[a] += b;
}
ll cnt = 0;
ll sum = 0;
for (auto f : rensou) {
cnt += f.second;
sum += f.first * f.second;
if (cnt >= m) {
sum -= (cnt - m) * f.first;
break;
}
}
cout << sum << endl;
} | [
"assignment.value.change"
] | 910,264 | 910,265 | u863537799 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> pairs(n);
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
pairs.at(i) = make_pair(a, b);
}
sort(pairs.begin(), pairs.end());
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (m > pairs.at(i).second) {
m -= pairs.at(i).second;
ans += pairs.at(i).first * pairs.at(i).second;
} else {
ans += pairs.at(i).first * m;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long long int, long long int>> pairs(n);
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
pairs.at(i) = make_pair(a, b);
}
sort(pairs.begin(), pairs.end());
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (m > pairs.at(i).second) {
m -= pairs.at(i).second;
ans += pairs.at(i).first * pairs.at(i).second;
} else {
ans += pairs.at(i).first * m;
break;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.widen.change"
] | 910,266 | 910,267 | u459105164 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> vec(n, vector<int>(2));
for (int i = 0; i < n; i++) {
cin >> vec.at(i).at(0) >> vec.at(i).at(1);
}
sort(vec.begin(), vec.end());
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (m > vec.at(i).at(1)) {
m -= vec.at(i).at(1);
ans += vec.at(i).at(0) * vec.at(i).at(1);
} else {
ans += vec.at(i).at(0) * m;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long int>> vec(n, vector<long long int>(2));
for (int i = 0; i < n; i++) {
cin >> vec.at(i).at(0) >> vec.at(i).at(1);
}
sort(vec.begin(), vec.end());
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (m > vec.at(i).at(1)) {
m -= vec.at(i).at(1);
ans += vec.at(i).at(0) * vec.at(i).at(1);
} else {
ans += vec.at(i).at(0) * m;
break;
}
}
cout << ans << endl;
} | [
"variable_declaration.type.widen.change"
] | 910,268 | 910,269 | u459105164 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, S = 0, i;
cin >> N >> M;
vector<pair<int, int>> X(N);
for (i = 0; i < N; i++)
cin >> X.at(i).first >> X.at(i).second;
sort(X.begin(), X.end());
i = 0;
while (M > 0) {
S += X.at(i).first * min(M, X.at(i).second);
M -= X.at(i).second;
i++;
}
cout << S << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, M, S = 0, i;
cin >> N >> M;
vector<pair<long long int, long long int>> X(N);
for (i = 0; i < N; i++)
cin >> X.at(i).first >> X.at(i).second;
sort(X.begin(), X.end());
i = 0;
while (M > 0) {
S += X.at(i).first * min(M, X.at(i).second);
M -= X.at(i).second;
i++;
}
cout << S << endl;
} | [
"variable_declaration.type.widen.change"
] | 910,272 | 910,273 | u820224016 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N), B(N);
vector<pair<ll, ll>> p;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
p.push_back(make_pair(A[i], B[i]));
}
ll count = 0;
ll cost = 0;
sort(p.begin(), p.end());
for (int i = 0; i < N; i++) {
cost = p[i].first * p[i].second;
count = p[i].second;
if (count >= M) {
cost -= (count - M) * p[i].first;
break;
}
}
cout << cost << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N), B(N);
vector<pair<ll, ll>> p;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
p.push_back(make_pair(A[i], B[i]));
}
ll count = 0;
ll cost = 0;
sort(p.begin(), p.end());
for (int i = 0; i < N; i++) {
cost += p[i].first * p[i].second;
count += p[i].second;
if (count >= M) {
cost -= (count - M) * p[i].first;
break;
}
}
cout << cost << endl;
return 0;
} | [
"assignment.value.change"
] | 910,279 | 910,280 | u241312295 | cpp |
p03103 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
map<ll, ll> S;
REP(i, N) {
ll a, b;
cin >> a >> b;
S[a] = b;
}
ll ans = 0;
ll cnt = 0;
for (auto p : S) {
if (cnt + p.se < M) {
ans += p.fi * p.se;
cnt += p.se;
} else {
ll c = M - cnt;
ans += p.fi * c;
break;
}
}
cout << ans << endl;
} | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9 + 7;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
map<ll, ll> S;
REP(i, N) {
ll a, b;
cin >> a >> b;
S[a] += b;
}
ll ans = 0;
ll cnt = 0;
for (auto p : S) {
if (cnt + p.se < M) {
ans += p.fi * p.se;
cnt += p.se;
} else {
ll c = M - cnt;
ans += p.fi * c;
break;
}
}
cout << ans << endl;
} | [
"assignment.value.change"
] | 910,281 | 910,282 | u089177147 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
#define pb push_back
#define all(x) (x).begin(), (x).end()
typedef long long ll;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
const int inf = 1e9;
int n, m, a[N], k, q, u, v, x, y, tc, c, l, r, ans, cnt, root[N], sz[N];
char s[N];
pair<int, int> p[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
scanf("%d %d", &p[i].first, &p[i].second);
sort(p, p + n);
ll ans = 0;
for (int i = 0; i < n; i++) {
ll add = min(m, p[i].second);
ans += add * p[i].first;
m -= add;
}
printf("%d\n", ans);
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
#define pb push_back
#define all(x) (x).begin(), (x).end()
typedef long long ll;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
const int inf = 1e9;
int n, m, a[N], k, q, u, v, x, y, tc, c, l, r, ans, cnt, root[N], sz[N];
char s[N];
pair<int, int> p[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
scanf("%d %d", &p[i].first, &p[i].second);
sort(p, p + n);
ll ans = 0;
for (int i = 0; i < n; i++) {
ll add = min(m, p[i].second);
ans += add * p[i].first;
m -= add;
}
printf("%lld\n", ans);
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 910,283 | 910,284 | u318875010 | cpp |
p03103 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define lper(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9;
const ll INF = 4e18;
const ll dy[4] = {1, 0, -1, 0};
const ll dx[4] = {0, -1, 0, 1};
int main() {
ll N;
ll M;
cin >> N >> M;
vl A(N);
vl B(N);
rep(i, N) { cin >> A.at(i) >> B.at(i); }
vector<pair<ll, ll>> vec(N);
rep(i, N) {
vec.at(i).first = A.at(i);
vec.at(i).second = B.at(i);
}
sort(all(vec));
vl C(N);
rep(i, N) { C.at(i) = (vec.at(i).first) * (vec.at(i).second); }
ll ctot = 0;
ll tter = 0;
ll a = 0;
rep(i, N) {
if (ctot + vec.at(i).second <= M) {
ctot += vec.at(i).second;
// cout<<ctot<<vec.at(i).second<<endl;
tter += C.at(i);
a++;
}
if (ctot + vec.at(i).second > M) {
break;
}
}
// cout<<ctot<<endl;
if (ctot == M) {
cout << tter << endl;
}
else if (ctot < M) {
tter += (M - ctot) * (vec.at(a).first);
cout << tter << endl;
}
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define lper(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9;
const ll INF = 4e18;
const ll dy[4] = {1, 0, -1, 0};
const ll dx[4] = {0, -1, 0, 1};
int main() {
ll N;
ll M;
cin >> N >> M;
vl A(N);
vl B(N);
rep(i, N) { cin >> A.at(i) >> B.at(i); }
vector<pair<ll, ll>> vec(N);
rep(i, N) {
vec.at(i).first = A.at(i);
vec.at(i).second = B.at(i);
}
sort(all(vec));
vl C(N);
rep(i, N) { C.at(i) = (vec.at(i).first) * (vec.at(i).second); }
ll ctot = 0;
ll tter = 0;
ll a = 0;
rep(i, N) {
if (ctot + vec.at(i).second <= M) {
ctot += vec.at(i).second;
tter += C.at(i);
a++;
} else if (ctot + vec.at(i).second > M) {
break;
}
}
if (ctot == M) {
cout << tter << endl;
}
else if (ctot < M) {
tter += (M - ctot) * (vec.at(a).first);
cout << tter << endl;
}
}
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 910,287 | 910,288 | u978260507 | cpp |
p03103 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> a;
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
a.push_back(pair<int, int>(A, B));
}
sort(a.begin(), a.end());
long ans = 0;
for (int i = 0; i < N; i++) {
if (a.at(i).second <= M) {
long b = a.at(i).first;
ans += b * a.at(i).second;
M -= a.at(i).second;
} else {
ans += a.at(i).first * M;
break;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<long, long>> a;
for (int i = 0; i < N; i++) {
int A, B;
cin >> A >> B;
a.push_back(pair<int, int>(A, B));
}
sort(a.begin(), a.end());
long ans = 0;
for (int i = 0; i < N; i++) {
if (a.at(i).second <= M) {
long b = a.at(i).first;
ans += b * a.at(i).second;
M -= a.at(i).second;
} else {
ans += a.at(i).first * M;
break;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 910,291 | 910,292 | u387371565 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, M;
cin >> N >> M;
vector<pair<long long int, long long int>> X(N);
for (long long int i = 0; i < N; i++) {
long long int A, B;
cin >> A >> B;
X.at(i) = make_pair(A, B);
}
sort(X.begin(), X.end());
long long int ans = 0;
long long int i = 0;
while (M >= X.at(i).second) {
ans += X.at(i).first * X.at(i).second;
M -= X.at(i).second;
i++;
}
ans += X.at(i).first * M;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, M;
cin >> N >> M;
vector<pair<long long int, long long int>> X(N);
for (long long int i = 0; i < N; i++) {
long long int A, B;
cin >> A >> B;
X.at(i) = make_pair(A, B);
}
sort(X.begin(), X.end());
long long int ans = 0;
long long int i = 0;
while (M > X.at(i).second) {
ans += X.at(i).first * X.at(i).second;
M -= X.at(i).second;
i++;
}
ans += X.at(i).first * M;
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 910,293 | 910,294 | u817769480 | cpp |
p03103 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<long, int> ab[n];
for (int i = 0; i < n; i++)
cin >> ab[i].first >> ab[i].second;
sort(ab, ab + n);
int res = 0;
for (int i = 0; i < n; i++) {
if (m - ab[i].second <= 0) {
res += ab[i].first * m;
break;
} else {
res += ab[i].first * ab[i].second;
m -= ab[i].second;
}
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<long, int> ab[n];
for (int i = 0; i < n; i++)
cin >> ab[i].first >> ab[i].second;
sort(ab, ab + n);
long res = 0;
for (int i = 0; i < n; i++) {
if (m - ab[i].second <= 0) {
res += ab[i].first * m;
break;
} else {
res += ab[i].first * ab[i].second;
m -= ab[i].second;
}
}
cout << res << endl;
} | [
"variable_declaration.type.primitive.change"
] | 910,295 | 910,296 | u366398972 | cpp |
p03103 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<int, int> ab[n];
for (int i = 0; i < n; i++)
cin >> ab[i].first >> ab[i].second;
sort(ab, ab + n);
int res = 0;
for (int i = 0; i < n; i++) {
if (m - ab[i].second <= 0) {
res += ab[i].first * m;
break;
} else {
res += ab[i].first * ab[i].second;
m -= ab[i].second;
}
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <stack>
#include <string>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
pair<long, int> ab[n];
for (int i = 0; i < n; i++)
cin >> ab[i].first >> ab[i].second;
sort(ab, ab + n);
long res = 0;
for (int i = 0; i < n; i++) {
if (m - ab[i].second <= 0) {
res += ab[i].first * m;
break;
} else {
res += ab[i].first * ab[i].second;
m -= ab[i].second;
}
}
cout << res << endl;
} | [
"variable_declaration.type.primitive.change"
] | 910,297 | 910,296 | u366398972 | cpp |
p03103 | #include <bits/stdc++.h>
#include <string.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
typedef long long int ll;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> A(N);
rep(i, N) {
int a, b;
cin >> a >> b;
A.at(i) = make_pair(a, b);
}
sort(A.begin(), A.end());
int count = 0;
ll nedan = 0;
rep(i, N) {
if (count + A.at(i).second <= M) {
nedan += (ll)A.at(i).first * A.at(i).second;
count += A.at(i).second;
} else {
nedan += A.at(i).first * (M - count);
count += M - count;
}
if (count == M) {
break;
}
}
cout << nedan << endl;
return 0;
} | #include <bits/stdc++.h>
#include <string.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
typedef long long int ll;
int main() {
int N, M;
cin >> N >> M;
vector<pair<int, int>> A(N);
rep(i, N) {
int a, b;
cin >> a >> b;
A.at(i) = make_pair(a, b);
}
sort(A.begin(), A.end());
int count = 0;
ll nedan = 0;
rep(i, N) {
if (count + A.at(i).second <= M) {
nedan += (ll)A.at(i).first * A.at(i).second;
count += A.at(i).second;
} else {
nedan += (ll)A.at(i).first * (M - count);
count += M - count;
}
if (count == M) {
break;
}
}
cout << nedan << endl;
return 0;
} | [
"type_conversion.add"
] | 910,300 | 910,301 | u276980836 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(n);
rep(i, n) { cin >> p.at(i).first >> p.at(i).second; }
sort(p.begin(), p.end());
long long sum = 0;
rep(i, n) {
if (m >= p.at(i).second) {
m -= p.at(i).second;
sum += p.at(i).first * p.at(i).second;
} else {
sum += p.at(i).first * m;
break;
}
}
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> p(n);
rep(i, n) { cin >> p.at(i).first >> p.at(i).second; }
sort(p.begin(), p.end());
long long sum = 0;
rep(i, n) {
if (m >= p.at(i).second) {
m -= p.at(i).second;
sum += p.at(i).first * p.at(i).second;
} else {
sum += p.at(i).first * m;
break;
}
}
cout << sum << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 910,315 | 910,316 | u690475097 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, m;
cin >> n >> m;
int long long ans = 0;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
sort(all(v));
for (int i = 0; i < n; i++) {
int x, y;
tie(x, y) = v.at(i);
// cout << "x:" << x << " y:" << y << " m:" << m << endl;
if (0 < m && m <= y) {
ans += x * m;
m = 0;
}
if (0 < m && y <= m) {
m -= y;
ans += x * y;
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n, m;
cin >> n >> m;
int long long ans = 0;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int long long x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
sort(all(v));
for (int i = 0; i < n; i++) {
int long long x, y;
tie(x, y) = v.at(i);
// cout << "x:" << x << " y:" << y << " m:" << m << endl;
if (0 < m && m <= y) {
ans += x * m;
m = 0;
}
if (0 < m && y <= m) {
m -= y;
ans += x * y;
}
}
cout << ans;
}
| [
"variable_declaration.add"
] | 910,319 | 910,320 | u260907804 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, q;
cin >> n >> q;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++)
cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
ll ans = 0;
for (int i = 0; i < n; i++) {
int amount = min(q, v[i].second);
ans += v[i].first * amount;
q -= amount;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, q;
cin >> n >> q;
vector<pair<ll, ll>> v(n);
for (int i = 0; i < n; i++)
cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
ll ans = 0;
for (int i = 0; i < n; i++) {
int amount = min(q, v[i].second);
ans += v[i].first * amount;
q -= amount;
}
cout << ans << endl;
} | [] | 910,321 | 910,322 | u729337236 | cpp |
p03103 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
template <class Type> inline bool chmax(Type &a, Type b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class Type> inline bool chmin(Type &a, Type b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class Type> Type modpow(Type a, Type n, Type mod) {
Type res = 1;
while (0 < n) {
if (n & 1) {
res = res * a % mod;
}
a = a * a % mod;
n >>= 1;
}
return res;
}
template <class Type> Type gcd(Type x, Type y) {
Type r;
if (x < y) {
swap(x, y);
}
while (0 < y) {
r = x % y;
x = y;
y = r;
}
return x;
}
template <class Type> Type lcm(Type x, Type y) { return x * y / gcd(x, y); }
template <class Type> bool is_prime(Type x) {
if (x == 2)
return true;
if (x < 2 || x % 2 == 0)
return false;
for (Type i = 3; i <= sqrt(x); i += 2) {
if (x % i == 0)
return false;
}
return true;
}
template <class Type> vector<bool> eratos(Type n) {
vector<bool> isPrime(n + 1, true);
isPrime[0] = isPrime[1] = false;
for (Type i = 2; i <= n; i++) {
if (isPrime[i]) {
Type j = i + i;
while (j <= n) {
isPrime[j] = false;
j = j + i;
}
}
}
return isPrime;
}
bool binary_search_judge(vector<int> a, int index, int key) {
if (key <= a[index])
return true;
else
return false;
}
int binary_search(vector<int> a, int key) {
int ng = -1;
int ok = a.size();
while (1 < abs(ng - ok)) {
int mid = (ng + ok) / 2;
if (binary_search_judge(a, mid, key))
ok = mid;
else
ng = mid;
}
return a[ok] == key;
}
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> v;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v[i] = make_pair(a, b);
}
sort(v.begin(), v.end());
ll num = 0;
ll cost = 0;
for (auto p : v) {
if (num + p.second < m) {
num += p.second;
cost += p.first * p.second;
} else {
cost += p.first * (m - num);
cout << cost << endl;
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
template <class Type> inline bool chmax(Type &a, Type b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class Type> inline bool chmin(Type &a, Type b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class Type> Type modpow(Type a, Type n, Type mod) {
Type res = 1;
while (0 < n) {
if (n & 1) {
res = res * a % mod;
}
a = a * a % mod;
n >>= 1;
}
return res;
}
template <class Type> Type gcd(Type x, Type y) {
Type r;
if (x < y) {
swap(x, y);
}
while (0 < y) {
r = x % y;
x = y;
y = r;
}
return x;
}
template <class Type> Type lcm(Type x, Type y) { return x * y / gcd(x, y); }
template <class Type> bool is_prime(Type x) {
if (x == 2)
return true;
if (x < 2 || x % 2 == 0)
return false;
for (Type i = 3; i <= sqrt(x); i += 2) {
if (x % i == 0)
return false;
}
return true;
}
template <class Type> vector<bool> eratos(Type n) {
vector<bool> isPrime(n + 1, true);
isPrime[0] = isPrime[1] = false;
for (Type i = 2; i <= n; i++) {
if (isPrime[i]) {
Type j = i + i;
while (j <= n) {
isPrime[j] = false;
j = j + i;
}
}
}
return isPrime;
}
bool binary_search_judge(vector<int> a, int index, int key) {
if (key <= a[index])
return true;
else
return false;
}
int binary_search(vector<int> a, int key) {
int ng = -1;
int ok = a.size();
while (1 < abs(ng - ok)) {
int mid = (ng + ok) / 2;
if (binary_search_judge(a, mid, key))
ok = mid;
else
ng = mid;
}
return a[ok] == key;
}
int main() {
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> v(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v[i] = make_pair(a, b);
}
sort(v.begin(), v.end());
ll num = 0;
ll cost = 0;
for (auto p : v) {
if (num + p.second < m) {
num += p.second;
cost += p.first * p.second;
} else {
cost += p.first * (m - num);
cout << cost << endl;
return 0;
}
}
} | [] | 910,329 | 910,330 | u999989620 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.