problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD 1000000007
int main() {
ll n, m;
cin >> n >> m;
vector<ll> l(n + 1);
vector<ll> r(n + 1);
for (int i = 1; i <= m; i++) {
cin >> l[i] >> r[i];
}
ll lmax = 1;
ll rmin = 1e5;
for (ll i = 1; i <= m; i++) {
if (l[i] > lmax)
lmax = l[i];
if (r[i] < rmin)
rmin = r[i];
// cerr << lmax << " " << rmin << endl;
}
// cerr << lmax << " " << rmin << endl;
rmin = min(rmin, n);
ll ans = max((ll)0, rmin - lmax + 1);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD 1000000007
int main() {
ll n, m;
cin >> n >> m;
vector<ll> l(m + 1);
vector<ll> r(m + 1);
for (int i = 1; i <= m; i++) {
cin >> l[i] >> r[i];
}
ll lmax = 1;
ll rmin = 1e5;
for (ll i = 1; i <= m; i++) {
if (l[i] > lmax)
lmax = l[i];
if (r[i] < rmin)
rmin = r[i];
// cerr << lmax << " " << rmin << endl;
}
// cerr << lmax << " " << rmin << endl;
rmin = min(rmin, n);
ll ans = max((ll)0, rmin - lmax + 1);
cout << ans << endl;
} | replace | 8 | 10 | 8 | 10 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF INT_MAX
#define MOD 100000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
vector<int> sum(N + 1, 0);
for (int i = 0; i < M; i++)
sum[L[i]]++, sum[R[i] + 1]--;
for (int i = 1; i < N + 1; i++)
sum[i] += sum[i - 1];
int ans = 0;
for (auto it : sum)
if (it == M)
ans++;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
#define INF INT_MAX
#define MOD 100000007
#define rng(a) a.begin(), a.end()
#define rrng(a) a.end(), a.begin()
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
vector<int> sum(N + 2, 0);
for (int i = 0; i < M; i++)
sum[L[i]]++, sum[R[i] + 1]--;
for (int i = 1; i < N + 1; i++)
sum[i] += sum[i - 1];
int ans = 0;
for (auto it : sum)
if (it == M)
ans++;
cout << ans << endl;
return 0;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p03037 | C++ | Runtime Error | #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;
}
int main(void) {
// Your code here!
int n, m;
cin >> n >> m;
vector<int> l(n);
vector<int> r(n);
int left = 1;
int right = n;
bool res = true;
rep(i, m) {
cin >> l[i] >> r[i];
chmax(left, l[i]);
chmin(right, r[i]);
if (left > right) {
res = false;
break;
}
}
if (res)
cout << right - left + 1 << endl;
else
cout << 0 << 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;
}
int main(void) {
// Your code here!
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int left = 1;
int right = n;
bool res = true;
rep(i, m) {
cin >> l[i] >> r[i];
chmax(left, l[i]);
chmin(right, r[i]);
if (left > right) {
res = false;
break;
}
}
if (res)
cout << right - left + 1 << endl;
else
cout << 0 << endl;
}
| replace | 49 | 51 | 49 | 51 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> lr(n + 1, 0);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
lr[l]++, lr[r + 1]--;
}
for (int i = 0; i < n; i++) {
lr[i + 1] += lr[i];
}
cout << count(lr.begin(), lr.end(), m) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int64_t> lr(n + 1, 0);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
lr[l]++, lr[r + 1]--;
}
for (int i = 0; i < n; i++) {
lr[i + 1] += lr[i];
}
cout << count(lr.begin(), lr.end(), m) << endl;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> imo(n + 1, 0);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
++imo[l];
--imo[r + 1];
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
imo[i] += imo[i - 1];
if (imo[i] == m)
++ans;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> imo(n + 2, 0);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
++imo[l];
--imo[r + 1];
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
imo[i] += imo[i - 1];
if (imo[i] == m)
++ans;
}
cout << ans << endl;
return 0;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
rep(i, m) {
cin >> l[i];
cin >> r[i];
}
int ans = 0;
rep(i, n) {
bool ja = true;
rep(j, m) {
if (i + 1 < l[j] || r[j] < i + 1) {
ja = false;
}
}
if (ja) {
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
rep(i, m) {
cin >> l[i];
cin >> r[i];
}
sort(all(l));
reverse(all(l));
sort(all(r));
int ans = r[0] - l[0] + 1;
if (ans < 0) {
ans = 0;
}
cout << ans << endl;
} | replace | 15 | 26 | 15 | 21 | TLE | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define num 100000
int main() {
int n, m;
cin >> n >> m;
bitset<num> a;
REP(i, m) {
int L, R;
cin >> L >> R;
bitset<num> b;
for (int j = L - 1; j < R; j++)
b.set(j, 1);
if (i == 0)
a = b;
else
a = a & b;
}
cout << a.count() << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define num 100000
int main() {
int n, m;
cin >> n >> m;
bitset<num> a;
REP(i, m) {
int L, R;
cin >> L >> R;
bitset<num> b;
b.flip();
b = (b >> L - 1) ^ (b >> R);
if (i == 0)
a = b;
else
a = a & b;
}
cout << a.count() << endl;
}
| replace | 13 | 15 | 13 | 15 | TLE | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using llong = long long;
using ldbl = long double;
using P = pair<llong, llong>;
#define ALL(x) x.begin(), x.end()
const llong inf = 1100100100100100ll;
const llong mod = 1e9 + 7;
int main() {
llong N, M;
vector<llong> L, R, rui;
cin >> N >> M;
L.resize(N);
R.resize(N);
rui.resize(N + 2, 0);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
rui[L[i]]++;
rui[R[i] + 1]--;
}
llong ans = 0;
for (int i = 1; i <= N; i++) {
rui[i] += rui[i - 1];
if (rui[i] == M)
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using llong = long long;
using ldbl = long double;
using P = pair<llong, llong>;
#define ALL(x) x.begin(), x.end()
const llong inf = 1100100100100100ll;
const llong mod = 1e9 + 7;
int main() {
llong N, M;
vector<llong> L, R, rui;
cin >> N >> M;
L.resize(M);
R.resize(M);
rui.resize(N + 2, 0);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
rui[L[i]]++;
rui[R[i] + 1]--;
}
llong ans = 0;
for (int i = 1; i <= N; i++) {
rui[i] += rui[i - 1];
if (rui[i] == M)
ans++;
}
cout << ans << endl;
return 0;
}
| replace | 17 | 19 | 17 | 19 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef vector<int> vi;
typedef pair<int, int> pii;
const int mxsz = 1e5 + 3;
int n, m;
vector<pii> v;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> v[i].fi >> v[i].se;
}
sort(v.begin(), v.end());
int tot = 0;
int l = 0, r = 0x3f3f3f3f;
for (int i = 0; i < m; i++) {
l = max(l, v[i].fi);
r = min(r, v[i].se);
}
cout << max(0, r - l + 1) << '\n';
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef vector<int> vi;
typedef pair<int, int> pii;
const int mxsz = 1e5 + 3;
int n, m;
vector<pii> v;
int main() {
cin >> n >> m;
v.resize(m);
for (int i = 0; i < m; i++) {
cin >> v[i].fi >> v[i].se;
}
sort(v.begin(), v.end());
int tot = 0;
int l = 0, r = 0x3f3f3f3f;
for (int i = 0; i < m; i++) {
l = max(l, v[i].fi);
r = min(r, v[i].se);
}
cout << max(0, r - l + 1) << '\n';
return 0;
}
| replace | 14 | 15 | 14 | 16 | -11 | |
p03037 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <sstream>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
// #include "bits/stdc++.h"
using namespace std;
// using namespace std::vector;
#define rep(i, a, b) for (ll i = (a); i < (b); ++i)
// #define M_PI 3.1415926535
#define huge 1000000007
typedef long long int ll;
ll gcd(ll a, ll b);
ll lcm(ll x, ll y);
ll bur(ll N, ll X);
bool IsPrime(int num);
bool dp[110][10010];
class UnionFind;
// UF木
class UnionFind {
public:
// 親
vector<int> Parent;
// 初期状態
UnionFind(int N) { Parent = vector<int>(N, -1); }
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
// サイズ確認
int size(int A) { return -Parent[root(A)]; }
int connect(int A, int B) {
// root同氏をくっつける
A = root(A);
B = root(B);
// 結合済み
if (A == B) {
return false;
}
// 大きいほうに小さいほうをくっつける
if (size(A) < size(B))
swap(A, B);
// Aのサイズ更新
Parent[A] += Parent[B];
// Bの親をAに
Parent[B] = A;
return true;
}
};
int main(void) {
ll N = 0;
ll A = 0;
ll B = 0;
ll C = 0;
ll D = 0;
ll E = 0;
ll M = 0;
ll K = 0;
// ll T = 0;
// ll M = 0;
// ll h[400][400] = {};
ll b[9] = {1, 7, 4, 5, 3, 2, 9, 6, 8}; // 順番の配列
ll b2[9] = {2, 3, 4, 5, 5, 5, 6, 6, 7}; // 順番の配列
// ll aa[20][20] = {};//sortaf
ll c2[9] = {};
ll d[10] = {}; // 要素数
// ll v[3] = {};
// ll *c, *s, *n;
string S, T, U[52];
char fi[50], fv[50];
ll count = 0;
double count2 = 0;
ll min = 1000;
ll max = 1;
ll dist1 = 0;
ll dist2 = 0;
ll dist3 = 0;
ll now = 0;
int tmax = 10000;
int tmax2 = 0;
// int flag = 0;
char temp, head, state;
// int is = 0;
bool start = false;
// char p;
float all = 0;
ll amr = 0;
ll keep = 0;
ll lgh = 1000000007;
// ll state = 0;
char col = NULL;
// ll aa[3] = {10000,10000,10000}, bb[3] = { 10000,10000,10000 }, cc[3] = {
// 10000,10000,10000 }; ll an[3] = { 10000,10000,10000 }, bn[3] = {
// 10000,10000,10000 }, cn[3] = { 10000,10000,10000 };
cin >> N >> M;
vector<double> ti(N), xi(N), yi(N);
rep(i, 0, M) { cin >> xi[i] >> yi[i]; }
amr = xi[0];
keep = yi[0];
rep(i, 0, M) {
if (amr < xi[i])
amr = xi[i];
if (keep > yi[i])
keep = yi[i];
}
if (keep - amr >= 0)
cout << keep - amr + 1 << endl;
else
cout << 0 << endl;
return 0;
}
ll bur(ll N, ll X) {
ll pan = 1;
ll pat = 1;
ll burg = 0;
if (X > burg) {
if (N == 0)
return pat;
burg += pan;
burg += bur(N - 1, X);
burg += pat;
burg += bur(N - 1, X);
burg += pan;
}
return burg;
}
ll gcd(ll a, ll b) {
/* 自然数 a > b を確認・入替 */
if (a < b) {
ll tmp = a;
a = b;
b = tmp;
}
ll x = b;
ll y = a;
/* ユークリッドの互除法 */
ll r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return y / b * x;
}
bool IsPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
// 最大公約数を求める関数
ll lcm(ll x, ll y) {
if (x == 0 || y == 0) // 引数チェック
{
// fprintf(stderr, "引数エラーです。\n");
return 0;
}
return (x * y / gcd(x, y));
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <sstream>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
// #include "bits/stdc++.h"
using namespace std;
// using namespace std::vector;
#define rep(i, a, b) for (ll i = (a); i < (b); ++i)
// #define M_PI 3.1415926535
#define huge 1000000007
typedef long long int ll;
ll gcd(ll a, ll b);
ll lcm(ll x, ll y);
ll bur(ll N, ll X);
bool IsPrime(int num);
bool dp[110][10010];
class UnionFind;
// UF木
class UnionFind {
public:
// 親
vector<int> Parent;
// 初期状態
UnionFind(int N) { Parent = vector<int>(N, -1); }
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
// サイズ確認
int size(int A) { return -Parent[root(A)]; }
int connect(int A, int B) {
// root同氏をくっつける
A = root(A);
B = root(B);
// 結合済み
if (A == B) {
return false;
}
// 大きいほうに小さいほうをくっつける
if (size(A) < size(B))
swap(A, B);
// Aのサイズ更新
Parent[A] += Parent[B];
// Bの親をAに
Parent[B] = A;
return true;
}
};
int main(void) {
ll N = 0;
ll A = 0;
ll B = 0;
ll C = 0;
ll D = 0;
ll E = 0;
ll M = 0;
ll K = 0;
// ll T = 0;
// ll M = 0;
// ll h[400][400] = {};
ll b[9] = {1, 7, 4, 5, 3, 2, 9, 6, 8}; // 順番の配列
ll b2[9] = {2, 3, 4, 5, 5, 5, 6, 6, 7}; // 順番の配列
// ll aa[20][20] = {};//sortaf
ll c2[9] = {};
ll d[10] = {}; // 要素数
// ll v[3] = {};
// ll *c, *s, *n;
string S, T, U[52];
char fi[50], fv[50];
ll count = 0;
double count2 = 0;
ll min = 1000;
ll max = 1;
ll dist1 = 0;
ll dist2 = 0;
ll dist3 = 0;
ll now = 0;
int tmax = 10000;
int tmax2 = 0;
// int flag = 0;
char temp, head, state;
// int is = 0;
bool start = false;
// char p;
float all = 0;
ll amr = 0;
ll keep = 0;
ll lgh = 1000000007;
// ll state = 0;
char col = NULL;
// ll aa[3] = {10000,10000,10000}, bb[3] = { 10000,10000,10000 }, cc[3] = {
// 10000,10000,10000 }; ll an[3] = { 10000,10000,10000 }, bn[3] = {
// 10000,10000,10000 }, cn[3] = { 10000,10000,10000 };
cin >> N >> M;
vector<double> ti(M), xi(M), yi(M);
rep(i, 0, M) { cin >> xi[i] >> yi[i]; }
amr = xi[0];
keep = yi[0];
rep(i, 0, M) {
if (amr < xi[i])
amr = xi[i];
if (keep > yi[i])
keep = yi[i];
}
if (keep - amr >= 0)
cout << keep - amr + 1 << endl;
else
cout << 0 << endl;
return 0;
}
ll bur(ll N, ll X) {
ll pan = 1;
ll pat = 1;
ll burg = 0;
if (X > burg) {
if (N == 0)
return pat;
burg += pan;
burg += bur(N - 1, X);
burg += pat;
burg += bur(N - 1, X);
burg += pan;
}
return burg;
}
ll gcd(ll a, ll b) {
/* 自然数 a > b を確認・入替 */
if (a < b) {
ll tmp = a;
a = b;
b = tmp;
}
ll x = b;
ll y = a;
/* ユークリッドの互除法 */
ll r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return y / b * x;
}
bool IsPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
// 最大公約数を求める関数
ll lcm(ll x, ll y) {
if (x == 0 || y == 0) // 引数チェック
{
// fprintf(stderr, "引数エラーです。\n");
return 0;
}
return (x * y / gcd(x, y));
}
| replace | 126 | 127 | 126 | 127 | 0 | |
p03037 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, 0);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
a[l]++;
a[r + 1]--;
}
int x = 0;
int ans = 0;
for (int i = 1; i <= n; ++i) {
x += a[i];
if (x == m)
ans++;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long int;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 2, 0);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
a[l]++;
a[r + 1]--;
}
int x = 0;
int ans = 0;
for (int i = 1; i <= n; ++i) {
x += a[i];
if (x == m)
ans++;
}
cout << ans << endl;
return 0;
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
vector<int> L(N, 0), R(N, 0);
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++)
scanf("%d%d", &L[i], &R[i]);
int min = 1, max = N;
for (int i = 0; i < M; i++) {
if (L[i] > min)
min = L[i];
if (R[i] < max)
max = R[i];
}
if (min <= max)
printf("%d", max - min + 1);
else
printf("0");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
vector<int> L(N, 0), R(N, 0);
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
int l, r;
scanf("%d%d", &l, &r);
L[i] = l;
R[i] = r;
}
int min = 1, max = N;
for (int i = 0; i < M; i++) {
if (L[i] > min)
min = L[i];
if (R[i] < max)
max = R[i];
}
if (min <= max)
printf("%d", max - min + 1);
else
printf("0");
return 0;
} | replace | 7 | 9 | 7 | 13 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p03037 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define _GLIBCXX_DEBUG
using namespace std;
const long long INF = 1LL << 60;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(N);
int min_R;
int max_L;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
for (int i = 0; i < M; i++) {
if (i == 0) {
min_R = R[i];
max_L = L[i];
} else if (min_R > R[i]) {
min_R = R[i];
} else if (max_L < L[i]) {
max_L = L[i];
}
}
int ans;
ans = min_R - max_L + 1;
if (ans <= 0) {
ans = 0;
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define _GLIBCXX_DEBUG
using namespace std;
const long long INF = 1LL << 60;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M);
vector<int> R(M);
int min_R;
int max_L;
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
for (int i = 0; i < M; i++) {
if (i == 0) {
min_R = R[i];
max_L = L[i];
} else if (min_R > R[i]) {
min_R = R[i];
} else if (max_L < L[i]) {
max_L = L[i];
}
}
int ans;
ans = min_R - max_L + 1;
if (ans <= 0) {
ans = 0;
}
cout << ans << endl;
} | replace | 26 | 27 | 26 | 27 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(n);
vector<int> r(n);
int mal = 0;
int mar = 10000000;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
mal = max(mal, l[i]);
mar = min(mar, r[i]);
}
if (mal <= mar) {
cout << mar - mal + 1 << endl;
} else {
cout << 0 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int mal = 0;
int mar = 10000000;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
mal = max(mal, l[i]);
mar = min(mar, r[i]);
}
if (mal <= mar) {
cout << mar - mal + 1 << endl;
} else {
cout << 0 << endl;
}
}
| replace | 5 | 7 | 5 | 7 | 0 | |
p03037 | C++ | Runtime Error | // C - Prison
// https://atcoder.jp/contests/abc127/tasks/abc127_c
#include <bits/stdc++.h>
#define lli long long int
#define uli unsigned long long int
#define rep(i, m, n) for (lli i = m; i < (n); i++)
#define repe(i, m, n) for (lli i = m; i <= (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((lli)(x).size())
#define MAX(x) *max_element(ALL(x))
#define _GLIBCXX_DEBUG
const lli INF = 2147483647;
const lli MINF = -2147483648;
const lli LINF = 9223372036854775807;
const lli MOD = 1000000007; // 10^9+7
const long double PI = acos(-1);
#define SORT(n) sort(n.begin(), n.end())
#define SORTR(n) sort(n.begin(), n.end(), greater<int>())
#define REV(n) reverse(n.begin(), n.end())
#define Vec(K, L, N, S) vector<L> K(N, S)
#define rt sqrt
#define pb push_back
#define ppb pop_back
#define eb emplace_back
#pragma GCC optimize("Ofast")
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vlli = vector<lli>;
using P = pair<lli, lli>;
// vector<P> vp;
// vp.emplace_back(a[i], b[i]);
using vs = vector<string>;
using ll = long long;
// vector入力
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
// os << '{';
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : "");
}
// os << '}';
return os;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
lli a, b, c, h, k, n, m, w, ans = 0, count = 0;
string s, t;
cin >> n >> m;
vlli d, l(m), r(m);
rep(i, 0, m) {
cin >> l[i] >> r[i];
repe(j, l[i], r[i]) {
d.eb(j);
// cout << "j: " << j << endl;
}
}
// cout << "l: " << l << endl;
// cout << "r: " << r << endl;
lli num[100010] = {0};
rep(i, 0, d.size()) { ++num[d[i]]; }
repe(i, 0, d.size()) {
if (num[i] == m) {
count++;
}
}
cout << count << "\n";
// cout << d << "\n";
} | // C - Prison
// https://atcoder.jp/contests/abc127/tasks/abc127_c
#include <bits/stdc++.h>
#define lli long long int
#define uli unsigned long long int
#define rep(i, m, n) for (lli i = m; i < (n); i++)
#define repe(i, m, n) for (lli i = m; i <= (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((lli)(x).size())
#define MAX(x) *max_element(ALL(x))
#define _GLIBCXX_DEBUG
const lli INF = 2147483647;
const lli MINF = -2147483648;
const lli LINF = 9223372036854775807;
const lli MOD = 1000000007; // 10^9+7
const long double PI = acos(-1);
#define SORT(n) sort(n.begin(), n.end())
#define SORTR(n) sort(n.begin(), n.end(), greater<int>())
#define REV(n) reverse(n.begin(), n.end())
#define Vec(K, L, N, S) vector<L> K(N, S)
#define rt sqrt
#define pb push_back
#define ppb pop_back
#define eb emplace_back
#pragma GCC optimize("Ofast")
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vlli = vector<lli>;
using P = pair<lli, lli>;
// vector<P> vp;
// vp.emplace_back(a[i], b[i]);
using vs = vector<string>;
using ll = long long;
// vector入力
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
// os << '{';
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : "");
}
// os << '}';
return os;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
lli a, b, c, h, k, n, m, w, ans = 0, count = 0;
string s, t;
cin >> n >> m;
vlli l(m), r(m);
rep(i, 0, m) { cin >> l[i] >> r[i]; }
a = MAX(l);
SORT(r);
b = r[0];
cout << max(b - a + 1LL, 0LL) << endl;
} | replace | 57 | 76 | 57 | 63 | 0 | |
p03037 | C++ | Runtime Error | #ifndef LOCAL
#pragma GCC optimize("O3")
#endif
#include "bits/stdc++.h"
using namespace std;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge {
c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> sum(n + 1, 0);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
sum[l] += 1;
sum[r + 1] -= 1;
}
for (int i = 1; i < (int)sum.size(); i++) {
sum[i] += sum[i - 1];
}
int ans = 0;
for (int i = 0; i < (int)sum.size(); i++) {
if (sum[i] == m)
ans++;
}
// debug() << imie(sum) ;
cout << ans << endl;
return 0;
}
| #ifndef LOCAL
#pragma GCC optimize("O3")
#endif
#include "bits/stdc++.h"
using namespace std;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge {
c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> sum(n + 2, 0);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
sum[l] += 1;
sum[r + 1] -= 1;
}
for (int i = 1; i < (int)sum.size(); i++) {
sum[i] += sum[i - 1];
}
int ans = 0;
for (int i = 0; i < (int)sum.size(); i++) {
if (sum[i] == m)
ans++;
}
// debug() << imie(sum) ;
cout << ans << endl;
return 0;
}
| replace | 44 | 45 | 44 | 45 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++) {
cin >> l.at(i) >> r.at(i);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int count = 0;
for (int j = 0; j < m; j++) {
if (l.at(j) <= i && i <= r.at(j)) {
count++;
}
}
if (count == m) {
ans++;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
for (int i = 0; i < m; i++) {
cin >> l.at(i) >> r.at(i);
}
cout << max(0, *min_element(r.begin(), r.end()) -
*max_element(l.begin(), l.end()) + 1);
} | replace | 12 | 25 | 12 | 14 | TLE | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(N), R(N);
int maxl = 0, minr = 100010;
for (int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
maxl = max(maxl, L[i]);
minr = min(minr, R[i]);
}
cout << max(0, minr - maxl + 1) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
int maxl = 0, minr = 100010;
for (int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
maxl = max(maxl, L[i]);
minr = min(minr, R[i]);
}
cout << max(0, minr - maxl + 1) << endl;
}
| replace | 8 | 9 | 8 | 9 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<bool> can_use_card(n, true);
for (int i = 0; i < m; i++) {
int l, r;
std::cin >> l >> r;
l--;
r--;
for (int j = 0; j < l; j++) {
can_use_card[j] = false;
}
for (int j = r + 1; j < n; j++) {
can_use_card[j] = false;
}
}
std::cout << std::count(can_use_card.begin(), can_use_card.end(), true)
<< std::endl;
}
| #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<bool> can_use_card(n, true);
for (int i = 0; i < m; i++) {
int l, r;
std::cin >> l >> r;
l--;
r--;
std::fill(can_use_card.begin(), can_use_card.begin() + l, false);
std::fill(can_use_card.begin() + r + 1, can_use_card.end(), false);
}
std::cout << std::count(can_use_card.begin(), can_use_card.end(), true)
<< std::endl;
}
| replace | 16 | 23 | 16 | 18 | TLE | |
p03037 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(n);
vector<int> r(n);
int r_min = n;
int l_max = 1;
for (int i = 0; i < m; ++i) {
cin >> l[i] >> r[i];
if (r[i] < r_min) {
r_min = r[i];
}
if (l_max < l[i]) {
l_max = l[i];
}
}
// cerr << r_min << l_max << endl;
if (l_max <= r_min) {
cout << r_min - l_max + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
int r_min = n;
int l_max = 1;
for (int i = 0; i < m; ++i) {
cin >> l[i] >> r[i];
if (r[i] < r_min) {
r_min = r[i];
}
if (l_max < l[i]) {
l_max = l[i];
}
}
// cerr << r_min << l_max << endl;
if (l_max <= r_min) {
cout << r_min - l_max + 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| replace | 10 | 12 | 10 | 12 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
// 立ってるビットの数を数える (https://www.slideshare.net/KMC_JP/ss-45855264)
// 01111001 -> 5
inline std::uint64_t popcount(std::uint64_t x) {
x = ((x & 0xaaaaaaaaaaaaaaaa) >> 1) + (x & 0x5555555555555555);
x = ((x & 0xcccccccccccccccc) >> 2) + (x & 0x3333333333333333);
x = ((x & 0xf0f0f0f0f0f0f0f0) >> 4) + (x & 0x0f0f0f0f0f0f0f0f);
x = ((x & 0xff00ff00ff00ff00) >> 8) + (x & 0x00ff00ff00ff00ff);
x = ((x & 0xffff0000ffff0000) >> 16) + (x & 0x0000ffff0000ffff);
x = ((x & 0xffffffff00000000) >> 32) + (x & 0x00000000ffffffff);
return x;
}
// ビット列同士のハミング距離を計算
// (https://www.slideshare.net/KMC_JP/ss-45855264) 01101011, 10110000 -> 6
inline std::uint64_t hamming(std::uint64_t a, std::uint64_t b) {
return popcount(a ^ b);
}
// 立ってる一番下のビットのみを立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 0100110 -> 0000010
inline std::uint64_t bit_under(std::uint64_t x) { return x & -x; }
// 立ってる一番下のビットをクリア
// (https://www.slideshare.net/KMC_JP/ss-45855264) 0100110 -> 0100100
inline std::uint64_t bit_clear(std::uint64_t x) { return x & (x - 1); }
// 立ってる一番下のビットの位置を数える
// (https://siokoshou.hatenadiary.org/entry/20090704/p1) 0100100 -> 2
inline std::uint64_t ntz(std::uint64_t x) {
std::uint64_t hash = 0x03F566ED27179461;
unsigned int table[64];
for (char i = 0; i < 64; i++)
table[hash >> 58] = i, hash <<= 1;
return table[static_cast<std::uint64_t>((x & -x) * 0x03F566ED27179461) >> 58];
}
// 立ってる一番下のビットより上のビットをすべて立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 010110 -> 111100
inline std::uint64_t bit_toper(std::uint64_t x) { return x ^ -x; }
// 立ってる一番下のビット含む上のビットをすべて立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 010110 -> 111110
inline std::uint64_t bit_etoper(std::uint64_t x) { return x | -x; }
// 立ってる一番下のビット含む下のビットをすべて立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 00110100 -> 00000111
inline std::uint64_t bit_eunder(std::uint64_t x) { return x ^ (x - 1); }
// 立ってる一番上のビットを求める
// (https://www.slideshare.net/KMC_JP/ss-45855264) 0110110 -> 0100000
inline std::uint64_t bit_top(std::uint64_t x) {
x = (x & 0xffffffff00000000) ? (x & 0xffffffff00000000) : x;
x = (x & 0xffff0000ffff0000) ? (x & 0xffff0000ffff0000) : x;
x = (x & 0xff00ff00ff00ff00) ? (x & 0xff00ff00ff00ff00) : x;
x = (x & 0xf0f0f0f0f0f0f0f0) ? (x & 0xf0f0f0f0f0f0f0f0) : x;
x = (x & 0xcccccccccccccccc) ? (x & 0xcccccccccccccccc) : x;
x = (x & 0xaaaaaaaaaaaaaaaa) ? (x & 0xaaaaaaaaaaaaaaaa) : x;
return x;
}
// ビットの並びを反転 (https://www.slideshare.net/KMC_JP/ss-45855264)
inline std::uint64_t bit_inverce(std::uint64_t x) {
x = (x >> 32) | (x << 32);
x = ((x & 0xffff0000ffff0000) >> 16) | ((x & 0x0000ffff0000ffff) << 16);
x = ((x & 0xff00ff00ff00ff00) >> 8) | ((x & 0x00ff00ff00ff00ff) << 8);
x = ((x & 0xf0f0f0f0f0f0f0f0) >> 4) | ((x & 0x0f0f0f0f0f0f0f0f) << 4);
x = ((x & 0xcccccccccccccccc) >> 2) | ((x & 0x3333333333333333) << 2);
x = ((x & 0xaaaaaaaaaaaaaaaa) >> 1) | ((x & 0x5555555555555555) << 1);
return x;
}
// ビット列を一部だけ入れ替える (https://www.slideshare.net/KMC_JP/ss-45855264)
// ********************ABCDEFGH**************abcdefgh*******
// |---------delta-------|-size-|
// |
// start
// ||
// \ /
// \/
// ********************abcdefgh**************ABCDEFGH*******
inline std::uint64_t delta_swap(std::uint64_t x, char start, char size,
char delta) {
std::uint64_t mask = 1;
for (char i = 0; i < size; i++)
mask = (mask << 1) + 1;
mask <<= (start - delta);
std::uint64_t b = (x ^ (x >> delta)) & mask;
return x ^ (b ^ (b << delta));
}
std::uint64_t addMod(std::uint64_t a, std::uint64_t b, std::uint64_t m) {
std::uint64_t c = a + b;
return c >= m ? c - m : c;
}
std::uint64_t subMod(std::uint64_t a, std::uint64_t b, std::uint64_t m) {
std::uint64_t c = a - b;
return c >= m ? c - m : c;
}
using namespace std;
void bit_() {
std::uint64_t hash = 0x03F566ED27179461;
unsigned int table[64];
for (char i = 0; i < 64; i++)
table[hash >> 58] = i, hash <<= 1;
unsigned int n, x;
cin >> n >> x;
vector<unsigned int> a(n);
for (unsigned int i = 0; i < n; i++)
cin >> a[i];
unsigned int sum = 0;
for (x &= (1 << (n - 1)) ^ ((1 << (n - 1)) - 1); x != 0; x &= x - 1)
sum += a[table[static_cast<std::uint64_t>((x & -x) * 0x03F566ED27179461) >>
58]];
cout << sum << endl;
}
int main() {
long long N, M;
cin >> N >> M;
vector<long long> c(N);
long long l, r;
for (int i = 0; i < M; i++) {
cin >> l >> r;
c[l - 1] += 1;
c[r] += -1;
}
long long counter = (c[0] == M ? 1 : 0);
for (int i = 1; i < N; i++) {
c[i] += c[i - 1];
if (c[i] == M)
counter++;
}
cout << counter << endl;
return 0;
}
| #include <bits/stdc++.h>
// 立ってるビットの数を数える (https://www.slideshare.net/KMC_JP/ss-45855264)
// 01111001 -> 5
inline std::uint64_t popcount(std::uint64_t x) {
x = ((x & 0xaaaaaaaaaaaaaaaa) >> 1) + (x & 0x5555555555555555);
x = ((x & 0xcccccccccccccccc) >> 2) + (x & 0x3333333333333333);
x = ((x & 0xf0f0f0f0f0f0f0f0) >> 4) + (x & 0x0f0f0f0f0f0f0f0f);
x = ((x & 0xff00ff00ff00ff00) >> 8) + (x & 0x00ff00ff00ff00ff);
x = ((x & 0xffff0000ffff0000) >> 16) + (x & 0x0000ffff0000ffff);
x = ((x & 0xffffffff00000000) >> 32) + (x & 0x00000000ffffffff);
return x;
}
// ビット列同士のハミング距離を計算
// (https://www.slideshare.net/KMC_JP/ss-45855264) 01101011, 10110000 -> 6
inline std::uint64_t hamming(std::uint64_t a, std::uint64_t b) {
return popcount(a ^ b);
}
// 立ってる一番下のビットのみを立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 0100110 -> 0000010
inline std::uint64_t bit_under(std::uint64_t x) { return x & -x; }
// 立ってる一番下のビットをクリア
// (https://www.slideshare.net/KMC_JP/ss-45855264) 0100110 -> 0100100
inline std::uint64_t bit_clear(std::uint64_t x) { return x & (x - 1); }
// 立ってる一番下のビットの位置を数える
// (https://siokoshou.hatenadiary.org/entry/20090704/p1) 0100100 -> 2
inline std::uint64_t ntz(std::uint64_t x) {
std::uint64_t hash = 0x03F566ED27179461;
unsigned int table[64];
for (char i = 0; i < 64; i++)
table[hash >> 58] = i, hash <<= 1;
return table[static_cast<std::uint64_t>((x & -x) * 0x03F566ED27179461) >> 58];
}
// 立ってる一番下のビットより上のビットをすべて立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 010110 -> 111100
inline std::uint64_t bit_toper(std::uint64_t x) { return x ^ -x; }
// 立ってる一番下のビット含む上のビットをすべて立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 010110 -> 111110
inline std::uint64_t bit_etoper(std::uint64_t x) { return x | -x; }
// 立ってる一番下のビット含む下のビットをすべて立てる
// (https://www.slideshare.net/KMC_JP/ss-45855264) 00110100 -> 00000111
inline std::uint64_t bit_eunder(std::uint64_t x) { return x ^ (x - 1); }
// 立ってる一番上のビットを求める
// (https://www.slideshare.net/KMC_JP/ss-45855264) 0110110 -> 0100000
inline std::uint64_t bit_top(std::uint64_t x) {
x = (x & 0xffffffff00000000) ? (x & 0xffffffff00000000) : x;
x = (x & 0xffff0000ffff0000) ? (x & 0xffff0000ffff0000) : x;
x = (x & 0xff00ff00ff00ff00) ? (x & 0xff00ff00ff00ff00) : x;
x = (x & 0xf0f0f0f0f0f0f0f0) ? (x & 0xf0f0f0f0f0f0f0f0) : x;
x = (x & 0xcccccccccccccccc) ? (x & 0xcccccccccccccccc) : x;
x = (x & 0xaaaaaaaaaaaaaaaa) ? (x & 0xaaaaaaaaaaaaaaaa) : x;
return x;
}
// ビットの並びを反転 (https://www.slideshare.net/KMC_JP/ss-45855264)
inline std::uint64_t bit_inverce(std::uint64_t x) {
x = (x >> 32) | (x << 32);
x = ((x & 0xffff0000ffff0000) >> 16) | ((x & 0x0000ffff0000ffff) << 16);
x = ((x & 0xff00ff00ff00ff00) >> 8) | ((x & 0x00ff00ff00ff00ff) << 8);
x = ((x & 0xf0f0f0f0f0f0f0f0) >> 4) | ((x & 0x0f0f0f0f0f0f0f0f) << 4);
x = ((x & 0xcccccccccccccccc) >> 2) | ((x & 0x3333333333333333) << 2);
x = ((x & 0xaaaaaaaaaaaaaaaa) >> 1) | ((x & 0x5555555555555555) << 1);
return x;
}
// ビット列を一部だけ入れ替える (https://www.slideshare.net/KMC_JP/ss-45855264)
// ********************ABCDEFGH**************abcdefgh*******
// |---------delta-------|-size-|
// |
// start
// ||
// \ /
// \/
// ********************abcdefgh**************ABCDEFGH*******
inline std::uint64_t delta_swap(std::uint64_t x, char start, char size,
char delta) {
std::uint64_t mask = 1;
for (char i = 0; i < size; i++)
mask = (mask << 1) + 1;
mask <<= (start - delta);
std::uint64_t b = (x ^ (x >> delta)) & mask;
return x ^ (b ^ (b << delta));
}
std::uint64_t addMod(std::uint64_t a, std::uint64_t b, std::uint64_t m) {
std::uint64_t c = a + b;
return c >= m ? c - m : c;
}
std::uint64_t subMod(std::uint64_t a, std::uint64_t b, std::uint64_t m) {
std::uint64_t c = a - b;
return c >= m ? c - m : c;
}
using namespace std;
void bit_() {
std::uint64_t hash = 0x03F566ED27179461;
unsigned int table[64];
for (char i = 0; i < 64; i++)
table[hash >> 58] = i, hash <<= 1;
unsigned int n, x;
cin >> n >> x;
vector<unsigned int> a(n);
for (unsigned int i = 0; i < n; i++)
cin >> a[i];
unsigned int sum = 0;
for (x &= (1 << (n - 1)) ^ ((1 << (n - 1)) - 1); x != 0; x &= x - 1)
sum += a[table[static_cast<std::uint64_t>((x & -x) * 0x03F566ED27179461) >>
58]];
cout << sum << endl;
}
int main() {
long long N, M;
cin >> N >> M;
vector<long long> c(N + 1);
long long l, r;
for (int i = 0; i < M; i++) {
cin >> l >> r;
c[l - 1] += 1;
c[r] += -1;
}
long long counter = (c[0] == M ? 1 : 0);
for (int i = 1; i < N; i++) {
c[i] += c[i - 1];
if (c[i] == M)
counter++;
}
cout << counter << endl;
return 0;
}
| replace | 124 | 125 | 124 | 125 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
#define sp(x) cout << setprecision(x);
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define inf 10000000
#define linf INT64_MAX * 0.99
#define print(s) cout << (s) << endl
#define lint long long
#define yes "Yes"
#define no "No"
typedef pair<int, int> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
map<int, int> ma;
REP(i, m) {
int l, r;
cin >> l >> r;
while (l <= r) {
ma[l]++;
l++;
}
}
int ans = 0;
for (auto e : ma) {
if (e.second == m)
ans++;
}
print(ans);
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define sp(x) cout << setprecision(x);
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define inf 10000000
#define linf INT64_MAX * 0.99
#define print(s) cout << (s) << endl
#define lint long long
#define yes "Yes"
#define no "No"
typedef pair<int, int> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<lint> l(m), r(m);
REP(i, m) { cin >> l[i] >> r[i]; }
sort(all(l), greater<lint>());
sort(all(r));
if (r[0] - l[0] >= 0)
print(r[0] - l[0] + 1);
else
print(0);
return 0;
} | replace | 22 | 37 | 22 | 30 | TLE | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
vector<int> card_list(N + 1, 0);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
card_list[L[i]]++;
card_list[R[i] + 1]--;
}
for (int i = 0; i < N; i++) {
card_list[i + 1] += card_list[i];
}
int count = 0;
for (int i = 0; i < N + 1; i++) {
if (card_list[i] == M)
count++;
}
cout << count << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
vector<int> card_list(N + 1, 0);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
card_list[L[i] - 1]++;
card_list[R[i] + 1 - 1]--;
}
for (int i = 0; i < N; i++) {
card_list[i + 1] += card_list[i];
}
int count = 0;
for (int i = 0; i < N + 1; i++) {
if (card_list[i] == M)
count++;
}
cout << count << endl;
return 0;
} | replace | 10 | 12 | 10 | 12 | 0 | |
p03037 | C++ | Runtime Error |
// </> : towhid1zaman
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
#define fill(a, b) memset(a, b, sizeof(a))
#define all(v) (v).begin(), (v).end()
#define sp(k) cout << setprecision(k) << fixed;
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a, b) for (int i = (a); i <= (b); ++i)
#define irep(i, b, a) for (int i = (b); i >= (a); --i)
#define minv(v) *min_element(all(v))
#define maxv(v) *max_element(all(v))
#define unq(v) sort(all(v)), (v).erase(unique(all(v)), (v).end())
#define _ \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define sqr(a) ((a) * (a))
#define sz(a) int(a.size())
#define ff first
#define ss second
#define pb push_back
const double pi = acos(-1.0);
const int mod = 1000000007; // (int)1e9+7
const int inf = 0x3f3f3f3f; // (int)3e18;
const int maxn = 2000100;
int main() {
_ ll n, m;
cin >> n >> m;
ll L[n + 1], R[m + 1];
for (int i = 0; i < m; i++) {
cin >> L[i] >> R[i];
}
sort(L, L + m);
sort(R, R + m);
ll X = L[m - 1];
ll Y = R[0];
ll ans = Y - X + 1;
cout << (ans <= 0 ? 0 : ans) << endl;
return 0;
}
|
// </> : towhid1zaman
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
#define fill(a, b) memset(a, b, sizeof(a))
#define all(v) (v).begin(), (v).end()
#define sp(k) cout << setprecision(k) << fixed;
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a, b) for (int i = (a); i <= (b); ++i)
#define irep(i, b, a) for (int i = (b); i >= (a); --i)
#define minv(v) *min_element(all(v))
#define maxv(v) *max_element(all(v))
#define unq(v) sort(all(v)), (v).erase(unique(all(v)), (v).end())
#define _ \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define sqr(a) ((a) * (a))
#define sz(a) int(a.size())
#define ff first
#define ss second
#define pb push_back
const double pi = acos(-1.0);
const int mod = 1000000007; // (int)1e9+7
const int inf = 0x3f3f3f3f; // (int)3e18;
const int maxn = 2000100;
int main() {
_ ll n, m;
cin >> n >> m;
ll L[m + 1], R[m + 1];
for (int i = 0; i < m; i++) {
cin >> L[i] >> R[i];
}
sort(L, L + m);
sort(R, R + m);
ll X = L[m - 1];
ll Y = R[0];
ll ans = Y - X + 1;
cout << (ans <= 0 ? 0 : ans) << endl;
return 0;
}
| replace | 38 | 39 | 38 | 39 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> ok;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
for (int j = a; j <= b; j++) {
ok[j - 1]++;
}
}
int ans = 0;
for (int i = 0; i < n; i++)
if (ok[i] == m)
ans++;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(m);
vector<int> b(m);
for (int i = 0; i < m; i++)
cin >> a.at(i) >> b.at(i);
sort(a.begin(), a.end(), greater());
sort(b.begin(), b.end());
cout << max(0, b.at(0) - a.at(0) + 1) << endl;
return 0;
} | replace | 6 | 19 | 6 | 13 | TLE | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int max_l = INT_MIN;
int min_r = INT_MAX;
for (int i = 0; i < M; i++) {
int l, r;
cin >> l >> r;
max_l = max(max_l, l);
min_r = min(min_r, r);
}
if (min_r - max_l < 0)
return -1;
cout << min_r - max_l + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int max_l = INT_MIN;
int min_r = INT_MAX;
for (int i = 0; i < M; i++) {
int l, r;
cin >> l >> r;
max_l = max(max_l, l);
min_r = min(min_r, r);
}
if (min_r - max_l < 0)
cout << 0 << endl;
else
cout << min_r - max_l + 1 << endl;
}
| replace | 14 | 16 | 14 | 17 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> L(M);
vector<long long> R(M);
for (long long i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
long long check = 0;
for (long long i = 1; i < N + 1; i++) {
long long count = 0;
for (long long j = 0; j < M; j++) {
if (i >= L[j] && i <= R[j]) {
count++;
}
}
if (count == M) {
check++;
}
}
cout << check;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
vector<long long> L(M);
vector<long long> R(M);
for (long long i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
long long check = 0;
sort(L.begin(), L.end());
sort(R.begin(), R.end());
long long Lmax = L[M - 1];
long long Rmin = R[0];
for (int i = 1; i < N + 1; i++) {
if (i >= Lmax && i <= Rmin) {
check++;
}
}
cout << check;
} | replace | 11 | 19 | 11 | 17 | TLE | |
p03037 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
using ll = long long;
int main() {
ll N, M;
cin >> N >> M;
ll L[N + 10], R[N + 10], l, r;
for (int k = 1; k <= M; k++)
cin >> L[k] >> R[k];
l = L[1];
for (int i = 1; i <= M; i++) {
if (L[i] >= l)
l = L[i];
}
r = R[1];
for (int i = 1; i <= M; i++) {
if (R[i] <= r)
r = R[i];
}
if (0 <= r - l)
cout << r - l + 1 << endl;
else
cout << 0 << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
using ll = long long;
int main() {
ll N, M;
cin >> N >> M;
ll L[M + 10], R[M + 10], l, r;
for (int k = 1; k <= M; k++)
cin >> L[k] >> R[k];
l = L[1];
for (int i = 1; i <= M; i++) {
if (L[i] >= l)
l = L[i];
}
r = R[1];
for (int i = 1; i <= M; i++) {
if (R[i] <= r)
r = R[i];
}
if (0 <= r - l)
cout << r - l + 1 << endl;
else
cout << 0 << endl;
}
| replace | 8 | 9 | 8 | 9 | 0 | |
p03037 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const long long INF = 1e18, MOD = 1e9 + 7;
using namespace std;
int main() {
ll N, M, ans;
ll maxL = -1;
cin >> N >> M;
vector<ll> L(N), R(N);
rep(i, M) { cin >> L[i] >> R[i]; }
ll minR = INF;
rep(i, M) {
maxL = max(maxL, L[i]);
minR = min(minR, R[i]);
}
ans = minR - maxL + 1;
ans = max(ans, (ll)0);
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const long long INF = 1e18, MOD = 1e9 + 7;
using namespace std;
int main() {
ll N, M, ans;
ll maxL = -1;
cin >> N >> M;
vector<ll> L(M), R(M);
rep(i, M) { cin >> L[i] >> R[i]; }
ll minR = INF;
rep(i, M) {
maxL = max(maxL, L[i]);
minR = min(minR, R[i]);
}
ans = minR - maxL + 1;
ans = max(ans, (ll)0);
cout << ans << endl;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
vector<int> a(M);
vector<int> b(M);
for (int i = 0; i < M; i++) {
cin >> a.at(i) >> b.at(i);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (b[0] >= a[M - 1])
cout << b[0] - a[M - 1] + 1 << endl;
else
cout << 0 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> a(M);
vector<int> b(M);
for (int i = 0; i < M; i++) {
cin >> a.at(i) >> b.at(i);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (b[0] >= a[M - 1])
cout << b[0] - a[M - 1] + 1 << endl;
else
cout << 0 << endl;
}
| insert | 5 | 5 | 5 | 6 | 0 | |
p03037 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[N], R[N];
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
int l, r;
l = L[0];
r = R[0];
for (int i = 1; i < M; i++) {
l = max(l, L[i]);
r = min(r, R[i]);
}
cout << max(0, r - l + 1) << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int L[M], R[M];
for (int i = 0; i < M; i++)
cin >> L[i] >> R[i];
int l, r;
l = L[0];
r = R[0];
for (int i = 1; i < M; i++) {
l = max(l, L[i]);
r = min(r, R[i]);
}
cout << max(0, r - l + 1) << endl;
return 0;
}
| replace | 17 | 18 | 17 | 18 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
vector<int> xx, yy;
const int maxn = 1e5 + 7;
struct q {
int x, y;
} N[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
xx.push_back(x);
yy.push_back(y);
}
sort(xx.begin(), xx.end());
sort(yy.begin(), yy.end());
cout << xx[n - 1] - yy[0] << endl;
} | #include <bits/stdc++.h>
using namespace std;
vector<int> xx, yy;
const int maxn = 1e5 + 7;
struct q {
int x, y;
} N[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
xx.push_back(x);
yy.push_back(y);
}
sort(xx.begin(), xx.end());
sort(yy.begin(), yy.end());
cout << max(-xx[m - 1] + yy[0] + 1, 0) << endl;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p03037 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(0)
#define rep(i, x) for (int i = 0; i < (int)(x); ++i)
#define rep1(i, x) for (int i = 1; i <= (int)(x); ++i)
#define rrep(i, x) for (int i = (int)x - 1; i >= 0; --i)
#define rrep1(i, x) for (int i = (int)x; i >= 1; --i)
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using vpii = vector<pii>;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> p) {
os << "(" << p.fst << ", " << p.scd << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> v) {
rep(i, v.size()) {
if (i)
os << ", ";
os << v[i];
}
return os;
}
template <typename T> T &max(T &a, T &b) {
if (a >= b)
return a;
return b;
}
template <typename T> T &min(T &a, T &b) {
if (a < b)
return a;
return b;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
constexpr ll TEN(ll n) { return n == 0 ? 1 : 10ll * TEN(n - 1); }
constexpr ll inf = TEN(9) + 5;
constexpr ll linf = 3 * TEN(18);
signed main() {
int N, M;
cin >> N >> M;
vi imos(N + 1);
rep(i, M) {
int l, r;
cin >> l >> r;
imos[l]++;
imos[r + 1]--;
}
rep(i, N) imos[i + 1] += imos[i];
int ans = 0;
rep(i, N + 1) if (imos[i] == M) ans++;
printf("%d\n", ans);
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(0)
#define rep(i, x) for (int i = 0; i < (int)(x); ++i)
#define rep1(i, x) for (int i = 1; i <= (int)(x); ++i)
#define rrep(i, x) for (int i = (int)x - 1; i >= 0; --i)
#define rrep1(i, x) for (int i = (int)x; i >= 1; --i)
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using vpii = vector<pii>;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> p) {
os << "(" << p.fst << ", " << p.scd << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> v) {
rep(i, v.size()) {
if (i)
os << ", ";
os << v[i];
}
return os;
}
template <typename T> T &max(T &a, T &b) {
if (a >= b)
return a;
return b;
}
template <typename T> T &min(T &a, T &b) {
if (a < b)
return a;
return b;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
constexpr ll TEN(ll n) { return n == 0 ? 1 : 10ll * TEN(n - 1); }
constexpr ll inf = TEN(9) + 5;
constexpr ll linf = 3 * TEN(18);
signed main() {
int N, M;
cin >> N >> M;
vi imos(N + 1);
rep(i, M) {
int l, r;
cin >> l >> r;
--l, --r;
imos[l]++;
imos[r + 1]--;
}
rep(i, N) imos[i + 1] += imos[i];
int ans = 0;
rep(i, N + 1) if (imos[i] == M) ans++;
printf("%d\n", ans);
}
| insert | 90 | 90 | 90 | 91 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int r[N];
int l[N];
int left = 0;
int right = 100000;
for (int i = 0; i < M; i++) {
cin >> l[i] >> r[i];
if (left < l[i]) {
left = l[i];
}
if (right > r[i]) {
right = r[i];
}
}
if ((right - left) < 0) {
cout << 0 << endl;
return 0;
}
cout << right - left + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int r[M];
int l[M];
int left = 0;
int right = 100000;
for (int i = 0; i < M; i++) {
cin >> l[i] >> r[i];
if (left < l[i]) {
left = l[i];
}
if (right > r[i]) {
right = r[i];
}
}
if ((right - left) < 0) {
cout << 0 << endl;
return 0;
}
cout << right - left + 1 << endl;
return 0;
}
| replace | 6 | 8 | 6 | 8 | 0 | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 100000
#define md 1000000007ll
#define prMX 10000000
ll prime[prMX + 2];
bool vis[prMX + 2];
#define MX 10000000000000ll
int main() {
int n, m;
cin >> n >> m;
int ar[m + 2];
memset(ar, 0, sizeof ar);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
ar[x]++;
ar[y + 1]--;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ar[i] += ar[i - 1];
if (ar[i] == m)
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 100000
#define md 1000000007ll
#define prMX 10000000
ll prime[prMX + 2];
bool vis[prMX + 2];
#define MX 10000000000000ll
int main() {
int n, m;
cin >> n >> m;
int ar[n + 2];
memset(ar, 0, sizeof ar);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
ar[x]++;
ar[y + 1]--;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ar[i] += ar[i - 1];
if (ar[i] == m)
ans++;
}
cout << ans << endl;
return 0;
} | replace | 14 | 15 | 14 | 15 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = unsigned long long;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> card;
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
for (int j = l; j <= r; j++) {
card[j]++;
}
}
int ans = 0;
for (int i = 1; i < card.size() + 1; i++)
if (card[i] == m)
ans++;
cout << ans << "\n";
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = unsigned long long;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
rep(i, m) cin >> l[i] >> r[i];
sort(l.begin(), l.end(), greater<int>());
sort(r.begin(), r.end());
int ans = r[0] - l[0] + 1;
if (ans < 0)
ans = 0;
cout << ans << "\n";
return 0;
} | replace | 8 | 20 | 8 | 18 | TLE | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int min(vector<int> a, int m) {
sort(a.begin(), a.end());
return a.at(0);
}
int max(vector<int> a, int m) {
sort(a.begin(), a.end());
return a.at(m - 1);
}
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
int ans = 0;
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
int Lmax = max(L, m);
int Rmin = min(R, m);
for (int i = Lmax; i <= Rmin && i <= n; i++) {
int count = 0;
for (int j = 1; j < m / 2; j++) {
if (L.at(j) <= i && R.at(j) >= i)
count++;
else
break;
}
for (int j = m - 1; j > m / 2 - 1; j--) {
if (L.at(j) <= i && R.at(j) >= i)
count++;
else
break;
}
if (count >= m - 1)
ans++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int min(vector<int> a, int m) {
sort(a.begin(), a.end());
return a.at(0);
}
int max(vector<int> a, int m) {
sort(a.begin(), a.end());
return a.at(m - 1);
}
int main() {
int n, m;
cin >> n >> m;
vector<int> L(m);
vector<int> R(m);
int ans = 0;
for (int i = 0; i < m; i++) {
cin >> L.at(i) >> R.at(i);
}
int Lmax = max(L, m);
int Rmin = min(R, m);
if (Lmax > Rmin)
cout << 0;
else
cout << Rmin - Lmax + 1;
} | replace | 27 | 46 | 27 | 31 | TLE | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++)
cin >> L.at(i) >> R.at(i);
// vector<bool> A(N,true);
int ans = 0;
for (int i = 1; i <= N; i++) {
bool mighty = true;
for (int j = 0; j < M; j++) {
if (i < L.at(j) || R.at(j) < i) {
mighty = false;
break;
}
}
if (mighty)
ans++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++)
cin >> L.at(i) >> R.at(i);
// vector<bool> A(N,true);
sort(L.begin(), L.end());
sort(R.begin(), R.end());
reverse(L.begin(), L.end());
if (L.at(0) <= R.at(0))
cout << R.at(0) - L.at(0) + 1 << endl;
else
cout << 0 << endl;
}
| replace | 10 | 23 | 10 | 17 | TLE | |
p03037 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
for (int i = 0; i < m; ++i) {
cin >> l[i] >> r[i];
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
int num = l[n - 1] - r[0] + 1;
cout << num << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
for (int i = 0; i < m; ++i) {
cin >> l[i] >> r[i];
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
if (r[0] >= l[m - 1]) {
int num = r[0] - l[m - 1] + 1;
cout << num << endl;
} else {
cout << 0 << endl;
}
}
| replace | 13 | 15 | 13 | 19 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<int> a(n + 2, 0);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
for (int j = l; j <= r; j++) {
a[j]++;
}
}
long long kotae = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == m)
kotae++;
}
cout << kotae << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<int> a(n + 2, 0);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
a[l]++;
a[r + 1]--;
}
for (int i = 1; i < n + 2; i++) {
a[i] += a[i - 1];
}
long long kotae = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == m)
kotae++;
}
cout << kotae << endl;
return 0;
}
| replace | 10 | 13 | 10 | 15 | TLE | |
p03037 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define int long long
#ifndef FAST_IO
#define IOS ios_base::sync_with_stdio(false), cin.tie(nullptr);
#endif
#define ff first
#define ss second
#define all(c) c.begin(), c.end()
template <typename T> void print(T t) {
for (auto &it : t)
cout << it << " ";
cout << endl;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(n);
int max_l = INT_MIN, min_r = INT_MAX;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
max_l = max(max_l, l[i]);
min_r = min(min_r, r[i]);
}
int ans = min_r - max_l;
ans++;
cout << max(0ll, ans) << endl;
}
int32_t main() {
IOS;
solve();
// debug();
#ifdef LOCAL_DEFINE
cerr << "time elapsed " << (double)clock() / CLOCKS_PER_SEC << endl;
#endif
}
| #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define int long long
#ifndef FAST_IO
#define IOS ios_base::sync_with_stdio(false), cin.tie(nullptr);
#endif
#define ff first
#define ss second
#define all(c) c.begin(), c.end()
template <typename T> void print(T t) {
for (auto &it : t)
cout << it << " ";
cout << endl;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
int n, m;
cin >> n >> m;
vector<int> l(m), r(m);
int max_l = 1, min_r = 1000001;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
max_l = max(max_l, l[i]);
min_r = min(min_r, r[i]);
}
int ans = min_r - max_l;
ans++;
cout << max(0ll, ans) << endl;
}
int32_t main() {
IOS;
solve();
// debug();
#ifdef LOCAL_DEFINE
cerr << "time elapsed " << (double)clock() / CLOCKS_PER_SEC << endl;
#endif
}
| replace | 19 | 21 | 19 | 21 | 0 | |
p03037 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1e+9;
int main() {
int n, m = 0;
cin >> n >> m;
vector<int> l_list(m);
vector<int> r_list(m);
int r_min = INF;
int l_max = -99999;
int l = 0;
int r = 0;
for (int i = 0; i < m; i++) {
cin >> l;
l_max = max(l_max, l);
cin >> r;
r_min = min(r_min, r);
}
int ct = 0;
for (int i = 1; i < n + 1; i++) {
bool a = true;
for (int j = 0; j < m; j++) {
if (l_max <= i && i <= r_min) {
} else {
a = false;
}
}
if (a == true) {
ct++;
}
}
cout << ct << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1e+9;
int main() {
int n, m = 0;
cin >> n >> m;
vector<int> l_list(m);
vector<int> r_list(m);
int r_min = INF;
int l_max = -99999;
int l = 0;
int r = 0;
for (int i = 0; i < m; i++) {
cin >> l;
l_max = max(l_max, l);
cin >> r;
r_min = min(r_min, r);
}
int ct = 0;
for (int i = 1; i < n + 1; i++) {
if (l_max <= i && i <= r_min) {
ct++;
}
}
cout << ct << "\n";
return 0;
} | replace | 25 | 33 | 25 | 26 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
map<int, ll> mp;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
mp[c] += b;
}
ll ans = 0;
for (int i = 0; i < n; i++) {
auto it = mp.rbegin();
if (it->first > a[i]) {
a[i] = it->first;
it->second--;
if (it->second == 0)
mp.erase(it->first);
}
ans += a[i];
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
map<int, ll> mp;
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
mp[c] += b;
}
ll ans = 0;
for (int i = 0; i < n; i++) {
auto it = mp.rbegin();
if (mp.size() && it->first > a[i]) {
a[i] = it->first;
it->second--;
if (it->second == 0)
mp.erase(it->first);
}
ans += a[i];
}
cout << ans << endl;
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p03038 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define pb push_back
#define f first
#define s second
#define double long double
const int MAX = 2e5 + 5;
const int MAX2 = 2e5 + 4;
const int MAAX = 2e18;
const int MOD = 1e9 + 7;
int a[MAX];
pair<int, int> p[MAX];
in main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> p[i].s >> p[i].f;
p[i].f *= -1;
}
sort(a, a + n);
sort(p, p + m);
int idx = 0;
for (int i = 0; i < m; i++) {
p[i].f *= -1;
int cur = p[i].s;
while (p[i].f > a[idx] && cur--) {
a[idx++] = p[i].f;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define pb push_back
#define f first
#define s second
#define double long double
const int MAX = 2e5 + 5;
const int MAX2 = 2e5 + 4;
const int MAAX = 2e18;
const int MOD = 1e9 + 7;
int a[MAX];
pair<int, int> p[MAX];
in main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> p[i].s >> p[i].f;
p[i].f *= -1;
}
sort(a, a + n);
sort(p, p + m);
int idx = 0;
for (int i = 0; i < m; i++) {
p[i].f *= -1;
int cur = p[i].s;
while (idx < n && p[i].f > a[idx] && cur--) {
a[idx++] = p[i].f;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| replace | 34 | 35 | 34 | 35 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
int N, M;
long long int A[100005], C[100005];
int B[100005];
vector<long long int> V;
set<long long int> temp;
vector<long long int> W;
map<long long int, int> MAP;
int main(void) {
cin >> N >> M;
for (int i = 1; i <= N; i++) {
cin >> A[i];
V.push_back(A[i]);
}
for (int i = 1; i <= M; i++) {
cin >> B[i] >> C[i];
temp.insert(-C[i]);
MAP[C[i]] += B[i];
}
sort(V.begin(), V.end());
for (auto it = temp.begin(); it != temp.end(); it++) {
long long int val;
val = (*it);
val = -val;
for (int j = 1; j <= MAP[val]; j++) {
W.push_back(val);
}
if (W.size() > N) {
break;
}
}
W.push_back(-100004);
vector<long long int> ans;
int p = 0, q = 0;
for (int i = 1; i <= N; i++) {
// cout << "comp " << V[p] << " " << W[q] << endl;
if (V[p] > W[q]) {
ans.push_back(V[p]);
p++;
} else {
ans.push_back(W[q]);
q++;
p++;
}
}
long long int ANS = 0;
for (int i = 0; i < N; i++) {
ANS += ans[i];
}
cout << ANS << endl;
/*for (int i = 0; i < N; i++) {
cout << "V[" << i << "]= " << V[i] << endl;
}
for (int i = 0; i < N; i++) {
cout << "W[" << i << "]= " << W[i] << endl;
}
for (int i = 0; i < N; i++) {
cout << "ans[" << i << "]= " << ans[i] << endl;
}*/
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
int N, M;
long long int A[100005], C[100005];
int B[100005];
vector<long long int> V;
set<long long int> temp;
vector<long long int> W;
map<long long int, int> MAP;
int main(void) {
cin >> N >> M;
for (int i = 1; i <= N; i++) {
cin >> A[i];
V.push_back(A[i]);
}
for (int i = 1; i <= M; i++) {
cin >> B[i] >> C[i];
temp.insert(-C[i]);
MAP[C[i]] += B[i];
}
sort(V.begin(), V.end());
for (auto it = temp.begin(); it != temp.end(); it++) {
long long int val;
val = (*it);
val = -val;
for (int j = 1; j <= MAP[val]; j++) {
W.push_back(val);
if (W.size() > N) {
break;
}
}
if (W.size() > N) {
break;
}
}
W.push_back(-100004);
vector<long long int> ans;
int p = 0, q = 0;
for (int i = 1; i <= N; i++) {
// cout << "comp " << V[p] << " " << W[q] << endl;
if (V[p] > W[q]) {
ans.push_back(V[p]);
p++;
} else {
ans.push_back(W[q]);
q++;
p++;
}
}
long long int ANS = 0;
for (int i = 0; i < N; i++) {
ANS += ans[i];
}
cout << ANS << endl;
/*for (int i = 0; i < N; i++) {
cout << "V[" << i << "]= " << V[i] << endl;
}
for (int i = 0; i < N; i++) {
cout << "W[" << i << "]= " << W[i] << endl;
}
for (int i = 0; i < N; i++) {
cout << "ans[" << i << "]= " << ans[i] << endl;
}*/
return 0;
} | insert | 41 | 41 | 41 | 44 | TLE | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
// g++ -std=c++11
using namespace std;
typedef long long ll;
#define rep(i, n) for (long long i = 0; i < (n); ++i)
#define DIV 1000000007 // 10^9+7
int main() {
ll N, M;
cin >> N >> M;
priority_queue<ll, vector<ll>, greater<ll>> Q;
rep(i, N) {
ll a;
cin >> a;
Q.push(a);
}
vector<pair<ll, ll>> CB(M);
rep(i, M) { cin >> CB[i].second >> CB[i].first; }
sort(CB.rbegin(), CB.rend());
rep(i, M) {
rep(j, CB[i].second) {
if (Q.top() < CB[i].first) {
ll tmp = Q.top();
Q.pop();
Q.push(CB[i].first);
}
}
}
ll ans = 0;
while (!Q.empty()) {
ans += Q.top();
Q.pop();
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
// g++ -std=c++11
using namespace std;
typedef long long ll;
#define rep(i, n) for (long long i = 0; i < (n); ++i)
#define DIV 1000000007 // 10^9+7
int main() {
ll N, M;
cin >> N >> M;
priority_queue<ll, vector<ll>, greater<ll>> Q;
rep(i, N) {
ll a;
cin >> a;
Q.push(a);
}
vector<pair<ll, ll>> CB(M);
rep(i, M) { cin >> CB[i].second >> CB[i].first; }
sort(CB.rbegin(), CB.rend());
rep(i, M) {
rep(j, CB[i].second) {
if (Q.top() < CB[i].first) {
ll tmp = Q.top();
Q.pop();
Q.push(CB[i].first);
} else {
break;
}
}
}
ll ans = 0;
while (!Q.empty()) {
ans += Q.top();
Q.pop();
}
cout << ans << endl;
}
| insert | 31 | 31 | 31 | 33 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
vector<int> data;
vector<pair<int, int>> changes;
long long sum = 0;
cin >> n;
cin >> m;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
data.push_back(t);
}
sort(data.begin(), data.end());
for (int i = 0; i < m; i++) {
int k, t;
cin >> k;
cin >> t;
changes.push_back(make_pair(t, k));
}
sort(changes.rbegin(), changes.rend());
auto ptr = data.begin();
for (auto it = changes.begin(); it != changes.end();) {
if (*ptr < (*it).first) {
sum += (*it).first;
++ptr;
if ((*it).second == 1) {
++it;
} else {
(*it).second--;
}
} else {
break;
}
}
while (ptr != data.end()) {
sum += *ptr;
++ptr;
}
cout << sum << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
vector<int> data;
vector<pair<int, int>> changes;
long long sum = 0;
cin >> n;
cin >> m;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
data.push_back(t);
}
sort(data.begin(), data.end());
for (int i = 0; i < m; i++) {
int k, t;
cin >> k;
cin >> t;
changes.push_back(make_pair(t, k));
}
sort(changes.rbegin(), changes.rend());
auto ptr = data.begin();
for (auto it = changes.begin(); it != changes.end();) {
if (ptr == data.end()) {
break;
}
if (*ptr < (*it).first) {
sum += (*it).first;
++ptr;
if ((*it).second == 1) {
++it;
} else {
(*it).second--;
}
} else {
break;
}
}
while (ptr != data.end()) {
sum += *ptr;
++ptr;
}
cout << sum << endl;
return 0;
} | insert | 30 | 30 | 30 | 33 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ std::cout << #a << " = " << a << "\n"; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
template <class T, class V> istream &operator>>(istream &ist, pair<T, V> &p) {
return ist >> p.first >> p.second;
}
template <class T> ostream &operator<<(ostream &ost, pair<T, T> &p) {
return ost << p.first << ", " << p.second;
}
template <class T> istream &operator>>(istream &ist, vector<T> &vs) {
for (auto &e : vs)
ist >> e;
return ist;
}
typedef long long ll;
vector<int> A;
vector<pair<int, int>> BC;
int main() {
int N, M;
cin >> N >> M;
A.resize(N + 1);
rep(i, N) scanf("%d", &A[i]);
A[N] = INT_MAX;
BC.resize(M);
rep(i, M) scanf("%d %d", &BC[i].first, &BC[i].second);
sort(A.begin(), A.end());
sort(BC.begin(), BC.end(),
[](auto const &x, auto const &y) { return x.second >= y.second; });
int edited = 0;
ll ans = 0;
rep(i, M) {
int b = BC[i].first, c = BC[i].second;
int last =
std::lower_bound(A.begin() + edited, A.begin() + N, c) - A.begin();
int distance = min(b, last - edited);
if (!distance) {
break;
}
ans += (ll)distance * c;
edited += distance;
if (edited >= N) {
break;
}
}
REP(i, edited, N) ans += A[i];
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ std::cout << #a << " = " << a << "\n"; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
template <class T, class V> istream &operator>>(istream &ist, pair<T, V> &p) {
return ist >> p.first >> p.second;
}
template <class T> ostream &operator<<(ostream &ost, pair<T, T> &p) {
return ost << p.first << ", " << p.second;
}
template <class T> istream &operator>>(istream &ist, vector<T> &vs) {
for (auto &e : vs)
ist >> e;
return ist;
}
typedef long long ll;
vector<int> A;
vector<pair<int, int>> BC;
int main() {
int N, M;
cin >> N >> M;
A.resize(N + 1);
rep(i, N) scanf("%d", &A[i]);
A[N] = INT_MAX;
BC.resize(M);
rep(i, M) scanf("%d %d", &BC[i].first, &BC[i].second);
sort(A.begin(), A.end());
sort(BC.begin(), BC.end(), [](auto const &x, auto const &y) {
return x.second == y.second ? x.first > y.first : x.second > y.second;
});
int edited = 0;
ll ans = 0;
rep(i, M) {
int b = BC[i].first, c = BC[i].second;
int last =
std::lower_bound(A.begin() + edited, A.begin() + N, c) - A.begin();
int distance = min(b, last - edited);
if (!distance) {
break;
}
ans += (ll)distance * c;
edited += distance;
if (edited >= N) {
break;
}
}
REP(i, edited, N) ans += A[i];
cout << ans << endl;
}
| replace | 45 | 47 | 45 | 48 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
typedef long long ll;
bool debug = false;
string yes = "Yes";
string no = "No";
int main() {
ll n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> q;
rep(i, n) {
ll a;
cin >> a;
q.push(a);
}
vector<vector<ll>> v(m, vector<ll>(2, 0));
rep(j, m) {
ll b, c;
cin >> b >> c;
v[j][1] = b;
v[j][0] = c;
}
sort(v.begin(), v.end(), greater<vector<ll>>());
rep(k, m) {
rep(p, v[k][1]) {
ll t = q.top();
if (t > v[k][0])
break;
q.pop();
q.push(v[k][0]);
}
}
ll ans = 0;
while (!q.empty()) {
ans += q.top();
q.pop();
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
typedef long long ll;
bool debug = false;
string yes = "Yes";
string no = "No";
int main() {
ll n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> q;
rep(i, n) {
ll a;
cin >> a;
q.push(a);
}
vector<vector<ll>> v(m, vector<ll>(2, 0));
rep(j, m) {
ll b, c;
cin >> b >> c;
v[j][1] = b;
v[j][0] = c;
}
sort(v.begin(), v.end(), greater<vector<ll>>());
rep(k, m) {
rep(p, v[k][1]) {
ll t = q.top();
if (t >= v[k][0])
break;
q.pop();
q.push(v[k][0]);
}
}
ll ans = 0;
while (!q.empty()) {
ans += q.top();
q.pop();
}
cout << ans;
return 0;
}
| replace | 28 | 29 | 28 | 29 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define For(i, n) for (long i = 0; i < (n); i++)
int main() {
long n, m, k = 0;
cin >> n >> m;
vector<long> A(n);
vector<pair<long, long>> BC(m);
vector<long> change;
For(i, n) { cin >> A.at(i); }
For(i, m) {
long b, c;
cin >> b >> c;
BC[i] = make_pair(c, b);
k += b;
}
sort(A.begin(), A.end());
sort(BC.begin(), BC.end()); // firstが数字 secondが個数
long t = 0;
long num = m - 1;
long kosuu = 0;
while (A.at(t) < BC[num].first) {
A.at(t) = BC[num].first;
t++;
kosuu++;
if (kosuu >= BC[num].second) {
num--;
kosuu = 0;
}
if (t >= k) {
break;
}
}
long ans = 0;
For(i, n) {
// cout<<A.at(i)<<endl;
ans += A.at(i);
}
cout << ans << endl;
// For(i,m){
// cout<<BC[i].first<<BC[i].second<<endl;
//}
}
| #include <bits/stdc++.h>
using namespace std;
#define For(i, n) for (long i = 0; i < (n); i++)
int main() {
long n, m, k = 0;
cin >> n >> m;
vector<long> A(n);
vector<pair<long, long>> BC(m);
vector<long> change;
For(i, n) { cin >> A.at(i); }
For(i, m) {
long b, c;
cin >> b >> c;
BC[i] = make_pair(c, b);
k += b;
}
sort(A.begin(), A.end());
sort(BC.begin(), BC.end()); // firstが数字 secondが個数
long t = 0;
long num = m - 1;
long kosuu = 0;
while (A.at(t) < BC[num].first) {
A.at(t) = BC[num].first;
t++;
kosuu++;
if (kosuu >= BC[num].second) {
num--;
kosuu = 0;
}
if (t >= k || t >= n) {
break;
}
}
long ans = 0;
For(i, n) {
// cout<<A.at(i)<<endl;
ans += A.at(i);
}
cout << ans << endl;
// For(i,m){
// cout<<BC[i].first<<BC[i].second<<endl;
//}
}
| replace | 31 | 32 | 31 | 32 | 0 | |
p03038 | C++ | Time Limit Exceeded | // #include "bits/stdc++.h"
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, l, r) REPEAT(i, l, r, true) // [l, r)
#define rep(i, n) REP(i, 0, n) // [0, n)
#define REPEAT(i, l, r, condition) \
for (int i = (condition) ? l : r - 1; (condition) ? i < r : i >= l; \
(condition) ? ++i : --i) // false<-[l, r)->true
#define all(e) e.begin(), e.end()
#define rall(e) e.rbegin(), e.rend()
#define pb push_back
#define fs first
#define sc second
#ifdef LOCAL
#define show(...) \
cerr << #__VA_ARGS__ << " = "; \
_DEBUG(__VA_ARGS__)
#define showlr(n, l, r) \
cerr << #n << " = "; \
for (int i = l; i < r; i++) { \
cerr << n[i] << ", "; \
} \
cerr << endl // [l, r)
#else
#define show(...)
#define showlr(n, l, r)
#endif
#define YN(condition) puts((condition) ? "YES" : "NO")
#define Yn(condition) puts((condition) ? "Yes" : "No")
#define yn(condition) puts((condition) ? "yes" : "no")
#define YES puts("YES")
#define Yes puts("Yes")
#define yes puts("yes")
#define NO puts("NO")
#define No puts("No")
#define no puts("no")
#define case(i) printf("Case #%lld: ", i)
using namespace std;
using vi = vector<int>;
using pint = pair<int, int>;
struct io {
io() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.tie(0);
cout << fixed << setprecision(20);
}
} io;
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (T &e : v)
is >> e;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> v) {
os << "{";
for (T &e : v)
os << e << (v.size() - (int)(&e - &v[0]) > 1 ? ", " : "");
os << "}";
return os;
}
void _DEBUG() {}
template <typename H, typename... T> void _DEBUG(H a, T... b) {
cerr << a << (sizeof...(b) ? "," : "\n");
_DEBUG(b...);
}
inline void in() {}
template <typename H, typename... T> void in(H &a, T &...b) {
cin >> a;
in(b...);
}
inline void out() {}
template <typename H, typename... T> void out(H a, T... b) {
cout << a << (sizeof...(b) ? " " : "\n");
out(b...);
}
template <class T> void resz(int n, T &v) { v.resize(n); }
template <class H, class... T> void resz(int n, H &a, T &...b) {
a.resize(n);
resz(n, b...);
}
template <typename V, typename H> void resize(vector<V> &v, const H a) {
v.resize(a);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &v, const H &a, const T... b) {
v.resize(a);
for (auto &v : v)
resize(v, b...);
}
const int INF = 1LL << 55;
const int MOD = 1000000007;
const double EPS = 1e-8;
/*------------end of definitions------------*/
int N, M;
vi A;
vector<pint> BC;
int ans;
signed main() {
in(N, M);
A.resize(N);
BC.resize(M);
in(A);
rep(i, M) { in(BC[i].fs, BC[i].sc); }
sort(all(A));
sort(rall(BC), [](auto a, auto b) { return a.sc < b.sc; });
int index = 0;
rep(i, M) {
rep(j, BC[i].fs) {
if (index < A.size()) {
ans += max(A[index], BC[i].sc);
show(A[index], BC[i].sc);
index++;
}
}
}
while (index < A.size()) {
ans += A[index];
index++;
}
out(ans);
return 0;
}
| // #include "bits/stdc++.h"
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define int long long
#define REP(i, l, r) REPEAT(i, l, r, true) // [l, r)
#define rep(i, n) REP(i, 0, n) // [0, n)
#define REPEAT(i, l, r, condition) \
for (int i = (condition) ? l : r - 1; (condition) ? i < r : i >= l; \
(condition) ? ++i : --i) // false<-[l, r)->true
#define all(e) e.begin(), e.end()
#define rall(e) e.rbegin(), e.rend()
#define pb push_back
#define fs first
#define sc second
#ifdef LOCAL
#define show(...) \
cerr << #__VA_ARGS__ << " = "; \
_DEBUG(__VA_ARGS__)
#define showlr(n, l, r) \
cerr << #n << " = "; \
for (int i = l; i < r; i++) { \
cerr << n[i] << ", "; \
} \
cerr << endl // [l, r)
#else
#define show(...)
#define showlr(n, l, r)
#endif
#define YN(condition) puts((condition) ? "YES" : "NO")
#define Yn(condition) puts((condition) ? "Yes" : "No")
#define yn(condition) puts((condition) ? "yes" : "no")
#define YES puts("YES")
#define Yes puts("Yes")
#define yes puts("yes")
#define NO puts("NO")
#define No puts("No")
#define no puts("no")
#define case(i) printf("Case #%lld: ", i)
using namespace std;
using vi = vector<int>;
using pint = pair<int, int>;
struct io {
io() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.tie(0);
cout << fixed << setprecision(20);
}
} io;
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (T &e : v)
is >> e;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> v) {
os << "{";
for (T &e : v)
os << e << (v.size() - (int)(&e - &v[0]) > 1 ? ", " : "");
os << "}";
return os;
}
void _DEBUG() {}
template <typename H, typename... T> void _DEBUG(H a, T... b) {
cerr << a << (sizeof...(b) ? "," : "\n");
_DEBUG(b...);
}
inline void in() {}
template <typename H, typename... T> void in(H &a, T &...b) {
cin >> a;
in(b...);
}
inline void out() {}
template <typename H, typename... T> void out(H a, T... b) {
cout << a << (sizeof...(b) ? " " : "\n");
out(b...);
}
template <class T> void resz(int n, T &v) { v.resize(n); }
template <class H, class... T> void resz(int n, H &a, T &...b) {
a.resize(n);
resz(n, b...);
}
template <typename V, typename H> void resize(vector<V> &v, const H a) {
v.resize(a);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &v, const H &a, const T... b) {
v.resize(a);
for (auto &v : v)
resize(v, b...);
}
const int INF = 1LL << 55;
const int MOD = 1000000007;
const double EPS = 1e-8;
/*------------end of definitions------------*/
int N, M;
vi A;
vector<pint> BC;
int ans;
signed main() {
in(N, M);
A.resize(N);
BC.resize(M);
in(A);
rep(i, M) { in(BC[i].fs, BC[i].sc); }
sort(all(A));
sort(rall(BC), [](auto a, auto b) { return a.sc < b.sc; });
int index = 0;
rep(i, M) {
rep(j, BC[i].fs) {
if (index < A.size()) {
ans += max(A[index], BC[i].sc);
show(A[index], BC[i].sc);
index++;
} else
break;
}
}
while (index < A.size()) {
ans += A[index];
index++;
}
out(ans);
return 0;
}
| replace | 147 | 148 | 147 | 149 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb pushback
#define fr(i, n) for (int i = 0; i < n; i++)
#define ifr(i, n) for (int i = n - 1; i >= 0; i--)
int main() {
int n, m;
cin >> n >> m;
int a[n];
int b[m];
int c[m];
bool end = false;
vector<pair<long, long>> pairs(m);
fr(i, n) { cin >> a[i]; }
fr(i, m) {
cin >> b[i] >> c[i];
pairs[i] = make_pair(c[i], b[i]);
}
sort(pairs.begin(), pairs.end());
sort(a, a + n);
int k = 0;
ifr(i, m) {
fr(j, pairs[i].second) {
if (a[k] < pairs[i].first)
a[k] = pairs[i].first;
else {
end = true;
break;
}
k++;
}
if (end == true)
break;
}
ll ans = 0;
fr(i, n) { ans += a[i]; }
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb pushback
#define fr(i, n) for (int i = 0; i < n; i++)
#define ifr(i, n) for (int i = n - 1; i >= 0; i--)
int main() {
int n, m;
cin >> n >> m;
int a[n];
int b[m];
int c[m];
bool end = false;
vector<pair<long, long>> pairs(m);
fr(i, n) { cin >> a[i]; }
fr(i, m) {
cin >> b[i] >> c[i];
pairs[i] = make_pair(c[i], b[i]);
}
sort(pairs.begin(), pairs.end());
sort(a, a + n);
int k = 0;
ifr(i, m) {
fr(j, pairs[i].second) {
if (a[k] < pairs[i].first)
a[k] = pairs[i].first;
else {
end = true;
break;
}
k++;
if (k >= n) {
end = true;
break;
}
}
if (end == true)
break;
}
ll ans = 0;
fr(i, n) { ans += a[i]; }
cout << ans << endl;
}
| insert | 32 | 32 | 32 | 36 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100002];
int b, c;
priority_queue<pair<int, int>> pq;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
for (int i = 0; i < m; i++) {
cin >> b >> c;
pq.push(make_pair(c, b));
}
int cnt = 0;
while (!pq.empty()) {
pair<int, int> f = pq.top();
pq.pop();
int val = f.first, lim = f.second;
while (0 < lim && a[cnt] < val) {
a[cnt] = val;
cnt++;
lim--;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return (0);
} | #include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100002];
int b, c;
priority_queue<pair<int, int>> pq;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n);
for (int i = 0; i < m; i++) {
cin >> b >> c;
pq.push(make_pair(c, b));
}
int cnt = 0;
while (!pq.empty()) {
pair<int, int> f = pq.top();
pq.pop();
int val = f.first, lim = f.second;
while (0 < lim && a[cnt] < val && cnt < n) {
a[cnt] = val;
cnt++;
lim--;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
return (0);
} | replace | 23 | 24 | 23 | 24 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), B(M), C(M);
vector<P> Q(M);
for (int s = 0; s < N; s++) {
cin >> A.at(s);
}
for (int t = 0; t < M; t++) {
cin >> B.at(t) >> C.at(t);
Q.at(t) = P(C.at(t), B.at(t));
}
sort(Q.begin(), Q.end());
reverse(Q.begin(), Q.end());
sort(A.begin(), A.end());
ll sum = 0, S = 0, T = 0;
int j = 0;
for (int i = 0; i < M; i++) {
S = Q.at(i).second;
T = Q.at(i).first;
if (A.at(j) > T || j >= N)
break;
while (S > 0 && j < N) {
if (A.at(j) < T && j < N) {
A.at(j) = T;
S--;
} else
break;
j++;
}
}
for (int k = 0; k < N; k++) {
sum += A.at(k);
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), B(M), C(M);
vector<P> Q(M);
for (int s = 0; s < N; s++) {
cin >> A.at(s);
}
for (int t = 0; t < M; t++) {
cin >> B.at(t) >> C.at(t);
Q.at(t) = P(C.at(t), B.at(t));
}
sort(Q.begin(), Q.end());
reverse(Q.begin(), Q.end());
sort(A.begin(), A.end());
ll sum = 0, S = 0, T = 0;
int j = 0;
for (int i = 0; i < M; i++) {
S = Q.at(i).second;
T = Q.at(i).first;
if (j >= N)
break;
if (A.at(j) > T)
break;
while (S > 0 && j < N) {
if (A.at(j) < T && j < N) {
A.at(j) = T;
S--;
} else
break;
j++;
}
}
for (int k = 0; k < N; k++) {
sum += A.at(k);
}
cout << sum << endl;
return 0;
}
| replace | 39 | 40 | 39 | 42 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip>
#include <iostream> // cout, endl, cin
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define ll long long
using vt = ll; // ここで数値の型を変えられる
#define rep(i, n) for (vt i = 0; i < (vt)(n); i++)
#define reps(i, s, n) for (vt i = (vt)(s); i < (vt)(n); i++)
#define all(v) v.begin(), v.end()
#define P pair<ll, ll>
const ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> a;
rep(i, n) {
ll x;
cin >> x;
a.push(x);
}
vector<P> bc(n);
rep(i, m) {
ll x, y;
cin >> x >> y;
bc.at(i) = make_pair(y, x);
}
sort(all(bc));
reverse(all(bc));
rep(i, m) {
rep(j, bc.at(i).second) {
if (a.top() < bc.at(i).first) {
a.pop();
a.push(bc.at(i).first);
} else
break;
}
}
ll s = 0;
rep(i, n) {
s += a.top();
a.pop();
}
cout << s;
return 0;
} | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <functional>
#include <iomanip>
#include <iostream> // cout, endl, cin
#include <map> // map
#include <math.h>
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
#define ll long long
using vt = ll; // ここで数値の型を変えられる
#define rep(i, n) for (vt i = 0; i < (vt)(n); i++)
#define reps(i, s, n) for (vt i = (vt)(s); i < (vt)(n); i++)
#define all(v) v.begin(), v.end()
#define P pair<ll, ll>
const ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> a;
rep(i, n) {
ll x;
cin >> x;
a.push(x);
}
vector<P> bc(m);
rep(i, m) {
ll x, y;
cin >> x >> y;
bc.at(i) = make_pair(y, x);
}
sort(all(bc));
reverse(all(bc));
rep(i, m) {
rep(j, bc.at(i).second) {
if (a.top() < bc.at(i).first) {
a.pop();
a.push(bc.at(i).first);
} else
break;
}
}
ll s = 0;
rep(i, n) {
s += a.top();
a.pop();
}
cout << s;
return 0;
} | replace | 39 | 40 | 39 | 40 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) \
; \
for (int i = 0; i < (int)(n); i++)
int main() {
vector<pair<int, int>> so;
vector<int> a;
long long ans = 0;
int n, m, count = 0;
cin >> n >> m;
a.resize(n);
so.resize(m);
REP(i, n) { cin >> a[i]; }
REP(i, m) { cin >> so[i].second >> so[i].first; }
sort(a.begin(), a.end(), greater<int>());
sort(so.begin(), so.end(), greater<pair<int, int>>());
int j = 0;
int su = 0;
while (su < n) {
REP(i, so[j].second) { a.push_back(so[j].first); }
su += so[j].second;
j++;
}
sort(a.begin(), a.end(), greater<int>());
REP(i, n) { ans += a[i]; }
cout << ans;
return (0);
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) \
; \
for (int i = 0; i < (int)(n); i++)
int main() {
vector<pair<int, int>> so;
vector<int> a;
long long ans = 0;
int n, m, count = 0;
cin >> n >> m;
a.resize(n);
so.resize(m);
REP(i, n) { cin >> a[i]; }
REP(i, m) { cin >> so[i].second >> so[i].first; }
sort(a.begin(), a.end(), greater<int>());
sort(so.begin(), so.end(), greater<pair<int, int>>());
int j = 0;
int su = 0;
while (su < n) {
REP(i, so[j].second) { a.push_back(so[j].first); }
su += so[j].second;
j++;
if (j >= m)
break;
}
sort(a.begin(), a.end(), greater<int>());
REP(i, n) { ans += a[i]; }
cout << ans;
return (0);
} | insert | 32 | 32 | 32 | 34 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
int main() {
ll N, M;
cin >> N >> M;
vector<vector<ll>> vv(M, vector<ll>(2));
vector<ll> v(N);
for (ll i = 0LL; i < N; i++) {
cin >> v.at(i);
}
ll cnt = 0;
for (ll i = 0; i < M; i++) {
cin >> vv.at(i).at(1) >> vv.at(i).at(0);
}
vector<ll> va;
sort(vv.begin(), vv.end());
reverse(vv.begin(), vv.end());
sort(v.begin(), v.end());
for (ll i = 0; i < M; i++) {
for (ll j = 0; j < vv.at(i).at(1); j++) {
va.push_back(vv.at(i).at(0));
if (va.size() >= N)
break;
}
}
ll i = 0LL;
while (i < N && va.at(i) > v.at(i)) {
v.at(i) = va.at(i);
i++;
}
ll ans = 0LL;
for (ll j = 0; j < N; j++) {
ans += v.at(j);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
int main() {
ll N, M;
cin >> N >> M;
vector<vector<ll>> vv(M, vector<ll>(2));
vector<ll> v(N);
for (ll i = 0LL; i < N; i++) {
cin >> v.at(i);
}
ll cnt = 0;
for (ll i = 0; i < M; i++) {
cin >> vv.at(i).at(1) >> vv.at(i).at(0);
}
vector<ll> va;
sort(vv.begin(), vv.end());
reverse(vv.begin(), vv.end());
sort(v.begin(), v.end());
for (ll i = 0; i < M; i++) {
for (ll j = 0; j < vv.at(i).at(1); j++) {
va.push_back(vv.at(i).at(0));
if (va.size() >= N)
break;
}
}
ll i = 0LL;
while (i < N && i < va.size() && va.at(i) > v.at(i)) {
v.at(i) = va.at(i);
i++;
}
ll ans = 0LL;
for (ll j = 0; j < N; j++) {
ans += v.at(j);
}
cout << ans << endl;
}
| replace | 44 | 45 | 44 | 45 | 0 | |
p03038 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define int long long
#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 // ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 // ない環境用
#define MIN -(9223372036854775807 / 2)
#define INF 9223372036854775807 / 2
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
int imos[1000000];
int ans[1000000];
signed main() {
int N, M;
cin >> N >> M;
vector<int> A;
rep(i, N) {
int a;
cin >> a;
A.push_back(a);
}
sort(A.begin(), A.end());
vector<pair<int, int>> CB;
rep(i, M) {
int b, c;
cin >> b >> c;
CB.push_back(make_pair(c, b));
}
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
int now = 0;
for (auto cb : CB) {
// bだけ置き換える
rep(i, cb.second) {
if (A[now] < cb.first) {
A[now] = cb.first;
now++;
} else {
break;
}
}
}
int ans = 0;
rep(i, N) { ans += A[i]; }
cout << ans << "\n";
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define int long long
#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 // ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 // ない環境用
#define MIN -(9223372036854775807 / 2)
#define INF 9223372036854775807 / 2
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
int imos[1000000];
int ans[1000000];
signed main() {
int N, M;
cin >> N >> M;
vector<int> A;
rep(i, N) {
int a;
cin >> a;
A.push_back(a);
}
sort(A.begin(), A.end());
vector<pair<int, int>> CB;
rep(i, M) {
int b, c;
cin >> b >> c;
CB.push_back(make_pair(c, b));
}
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
int now = 0;
for (auto cb : CB) {
// bだけ置き換える
rep(i, cb.second) {
if (A[now] < cb.first) {
A[now] = cb.first;
now++;
} else {
break;
}
}
if (now >= N)
break;
}
int ans = 0;
rep(i, N) { ans += A[i]; }
cout << ans << "\n";
return 0;
} | insert | 122 | 122 | 122 | 124 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
rep(i, n) cin >> a[i];
vector<pair<int, int>> pairs(m);
int b, c;
rep(i, m) {
cin >> b >> c;
pairs[i] = make_pair(c, b);
}
sort(a, a + n);
sort(pairs.begin(), pairs.end(), greater<pair<int, int>>());
int work = 0;
rep(i, m) {
rep(j, pairs[i].second) {
if (j + work >= n)
break;
if (a[j + work] <= pairs[i].first)
a[j + work] = pairs[i].first;
}
work += pairs[i].second;
}
long long sum = 0;
rep(i, n) sum += a[i];
cout << sum;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
rep(i, n) cin >> a[i];
vector<pair<int, int>> pairs(m);
int b, c;
rep(i, m) {
cin >> b >> c;
pairs[i] = make_pair(c, b);
}
sort(a, a + n);
sort(pairs.begin(), pairs.end(), greater<pair<int, int>>());
int work = 0;
rep(i, m) {
rep(j, pairs[i].second) {
if (j + work >= n)
break;
if (a[j + work] <= pairs[i].first)
a[j + work] = pairs[i].first;
}
work += pairs[i].second;
if (work >= n)
break;
}
long long sum = 0;
rep(i, n) sum += a[i];
cout << sum;
} | insert | 34 | 34 | 34 | 36 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, M;
long A;
long B, C;
set<long> s;
vector<pair<long, long>> vec;
map<long, long> m;
long sum = 0;
cin >> N >> M;
for (long i = 0; i < N; i++) {
cin >> A;
m[A]++;
s.insert(A);
}
for (long i = 0; i < M; i++) {
cin >> B >> C;
vec.push_back(make_pair(C, B));
}
// cout << 1 << endl;
sort(vec.begin(), vec.end(), greater<pair<long, long>>());
// cout << 2 << endl;
// cout << vec[0].first;
for (long i = 0; i < M; i++) {
long count = 0;
for (auto itr = s.begin();
itr != s.end() && !s.empty() && count < vec[i].second; count++) {
auto tmp = vec[i].first;
// cout << *itr << endl;
if (tmp < *itr) {
if (itr == s.begin()) {
for (auto itr = m.begin(); itr != m.end(); ++itr) {
sum += itr->first * itr->second;
}
cout << sum << endl;
return 0;
}
break;
} else {
s.insert(tmp);
m[*itr]--;
if (m[*itr] == 0) {
itr = s.erase(itr);
}
m[tmp]++;
}
// cout << "count: " << count << endl;
}
}
// cout << 3 << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
sum += itr->first * itr->second;
}
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, M;
long A;
long B, C;
set<long> s;
vector<pair<long, long>> vec;
map<long, long> m;
long sum = 0;
cin >> N >> M;
for (long i = 0; i < N; i++) {
cin >> A;
m[A]++;
s.insert(A);
}
for (long i = 0; i < M; i++) {
cin >> B >> C;
vec.push_back(make_pair(C, B));
}
// cout << 1 << endl;
sort(vec.begin(), vec.end(), greater<pair<long, long>>());
// cout << 2 << endl;
// cout << vec[0].first;
for (long i = 0; i < M; i++) {
long count = 0;
for (auto itr = s.begin();
itr != s.end() && !s.empty() && count < vec[i].second; count++) {
auto tmp = vec[i].first;
// cout << *itr << endl;
if (tmp < *itr) {
if (itr == s.begin()) {
for (auto itr = m.begin(); itr != m.end(); ++itr) {
sum += itr->first * itr->second;
}
cout << sum << endl;
return 0;
}
break;
} else {
// s.insert(tmp);
m[*itr]--;
if (m[*itr] == 0) {
itr = s.erase(itr);
}
m[tmp]++;
}
// cout << "count: " << count << endl;
}
}
// cout << 3 << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
sum += itr->first * itr->second;
}
cout << sum << endl;
return 0;
} | replace | 44 | 45 | 44 | 45 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define p(s) cout << (s) << endl
#define p2(s, t) cout << (s) << " " << (t) << endl
#define ALL(v) (v).begin(), (v).end()
typedef long long ll;
using namespace std;
static const ll mod = 1e9 + 7;
static const ll inf = 1e18;
static const int White = 0;
static const int Gray = 1;
static const int Black = 2;
void pvector(vector<ll> A) {
cout << "[vector]";
for (int i = 0; i < A.size(); i++) {
cout << A[i] << " ";
}
cout << endl;
}
bool compare_by_b(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
int main() {
int n, m, t;
ll b, c;
ll ans = 0;
cin >> n >> m;
vector<ll> a;
vector<pair<ll, ll>> pairs;
REP(i, n) {
cin >> t;
a.push_back(t);
}
sort(ALL(a));
REP(i, m) {
cin >> b >> c;
pairs.push_back(make_pair(b, c));
}
/*cout << "[vector]";
for(int i = 0; i < pairs.size(); i++){
cout << pairs[i].first << " " << pairs[i].second << endl;
}*/
sort(ALL(pairs), compare_by_b);
int point = 0;
bool flag = 0;
int j = 0;
while (point < a.size()) {
int tmpp = point;
for (int i = point; i < tmpp + pairs[j].first; i++) {
if (pairs[j].second > a[i]) {
a[i] = pairs[j].second;
point++;
} else {
flag = 1;
break;
}
}
j++;
if (flag)
break;
}
/*cout << "[vector]";
for(int i = 0; i < pairs.size(); i++){
cout << pairs[i].first << " " << pairs[i].second << endl;
}
pvector(a);
*/
REP(i, n) { ans += a[i]; }
p(ans);
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define p(s) cout << (s) << endl
#define p2(s, t) cout << (s) << " " << (t) << endl
#define ALL(v) (v).begin(), (v).end()
typedef long long ll;
using namespace std;
static const ll mod = 1e9 + 7;
static const ll inf = 1e18;
static const int White = 0;
static const int Gray = 1;
static const int Black = 2;
void pvector(vector<ll> A) {
cout << "[vector]";
for (int i = 0; i < A.size(); i++) {
cout << A[i] << " ";
}
cout << endl;
}
bool compare_by_b(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
int main() {
int n, m, t;
ll b, c;
ll ans = 0;
cin >> n >> m;
vector<ll> a;
vector<pair<ll, ll>> pairs;
REP(i, n) {
cin >> t;
a.push_back(t);
}
sort(ALL(a));
REP(i, m) {
cin >> b >> c;
pairs.push_back(make_pair(b, c));
}
/*cout << "[vector]";
for(int i = 0; i < pairs.size(); i++){
cout << pairs[i].first << " " << pairs[i].second << endl;
}*/
sort(ALL(pairs), compare_by_b);
int point = 0;
bool flag = 0;
int j = 0;
while (point < a.size() && j < pairs.size()) {
int tmpp = point;
for (int i = point; i < tmpp + pairs[j].first; i++) {
if (pairs[j].second > a[i]) {
a[i] = pairs[j].second;
point++;
} else {
flag = 1;
break;
}
}
j++;
if (flag)
break;
}
/*cout << "[vector]";
for(int i = 0; i < pairs.size(); i++){
cout << pairs[i].first << " " << pairs[i].second << endl;
}
pvector(a);
*/
REP(i, n) { ans += a[i]; }
p(ans);
} | replace | 63 | 64 | 63 | 64 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define SE second
#define vi vector<int>
#define pb push_back
#define pi pair<int, int>
#define mp make_pair
#define ll long long
#define LLI long long int
#define REP(i, a, b) for (long long i = a; i < b; i++)
#define PER(i, a, b) for (int i = b - 1; i >= a; i--)
#define YES(i) cout << (i ? "YES" : "NO") << endl
#define Yes(i) cout << (i ? "Yes" : "No") << endl
#define Arrays(a, size) sort((a), (a) + (size))
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
using namespace std;
ll A[100001];
vector<pair<ll, ll>> pairs;
ll n, m;
int main() {
cin >> n >> m;
for (ll i = 0; i < n; i++)
cin >> A[i];
sort(A, A + n);
for (ll i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
pairs.pb(make_pair(c, b));
}
RSORT(pairs);
ll inserted = 0, move = 0;
for (ll i = 0; i < m; i++) {
ll c = pairs[i].first, b = pairs[i].second;
for (ll j = 0; j < b; j++) {
if (A[j + move] >= c)
break;
A[j + move] = c;
inserted++;
}
move = inserted;
}
ll sum = 0;
for (ll i = 0; i < n; i++)
sum += A[i];
cout << sum << endl;
}; | #include <bits/stdc++.h>
#define SE second
#define vi vector<int>
#define pb push_back
#define pi pair<int, int>
#define mp make_pair
#define ll long long
#define LLI long long int
#define REP(i, a, b) for (long long i = a; i < b; i++)
#define PER(i, a, b) for (int i = b - 1; i >= a; i--)
#define YES(i) cout << (i ? "YES" : "NO") << endl
#define Yes(i) cout << (i ? "Yes" : "No") << endl
#define Arrays(a, size) sort((a), (a) + (size))
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
using namespace std;
ll A[100001];
vector<pair<ll, ll>> pairs;
ll n, m;
int main() {
cin >> n >> m;
for (ll i = 0; i < n; i++)
cin >> A[i];
sort(A, A + n);
for (ll i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
pairs.pb(make_pair(c, b));
}
RSORT(pairs);
ll inserted = 0, move = 0;
for (ll i = 0; i < m; i++) {
ll c = pairs[i].first, b = pairs[i].second;
for (ll j = 0; j < b; j++) {
if (A[j + move] >= c || j + move > n)
break;
A[j + move] = c;
inserted++;
}
move = inserted;
}
ll sum = 0;
for (ll i = 0; i < n; i++)
sum += A[i];
cout << sum << endl;
}; | replace | 35 | 36 | 35 | 36 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define i64 int64_t
#define ff(ii, nn, mm) for (int ii = nn; ii < mm; ii++)
#define ffrvs(ii, nn, mm) for (int ii = nn; ii >= mm; ii--)
#define srt(vvv) sort(vvv.begin(), vvv.end())
#define srtrvs(vvv) reverse(vvv.begin(), vvv.end())
#define Graph vector<vector<int>>
i64 inf = 1000000007;
i64 giant = 4000000000000000037;
using namespace std;
// メモリ置き場
int n, m;
vector<i64> a;
deque<vector<i64>> c;
// inputします
void input() {
cin >> n >> m;
a.resize(n);
ff(i, 0, n) { cin >> a[i]; }
ff(i, 0, m) {
int b, d;
cin >> b >> d;
c.push_back({d, b});
}
srt(c);
srtrvs(c);
srt(a);
}
// ライブラリ置き場
// main
int main() {
input();
ff(i, 0, n) {
if (a[i] < c[0][0]) {
a[i] = c[0][0];
c[0][1]--;
if (c[0][1] == 0)
c.pop_front();
} else
break;
}
i64 ans = 0;
ff(i, 0, n) { ans += a[i]; }
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define i64 int64_t
#define ff(ii, nn, mm) for (int ii = nn; ii < mm; ii++)
#define ffrvs(ii, nn, mm) for (int ii = nn; ii >= mm; ii--)
#define srt(vvv) sort(vvv.begin(), vvv.end())
#define srtrvs(vvv) reverse(vvv.begin(), vvv.end())
#define Graph vector<vector<int>>
i64 inf = 1000000007;
i64 giant = 4000000000000000037;
using namespace std;
// メモリ置き場
int n, m;
vector<i64> a;
deque<vector<i64>> c;
// inputします
void input() {
cin >> n >> m;
a.resize(n);
ff(i, 0, n) { cin >> a[i]; }
ff(i, 0, m) {
int b, d;
cin >> b >> d;
c.push_back({d, b});
}
srt(c);
srtrvs(c);
srt(a);
}
// ライブラリ置き場
// main
int main() {
input();
ff(i, 0, n) {
if (c.empty())
break;
if (a[i] < c[0][0]) {
a[i] = c[0][0];
c[0][1]--;
if (c[0][1] == 0)
c.pop_front();
} else
break;
}
i64 ans = 0;
ff(i, 0, n) { ans += a[i]; }
cout << ans << endl;
return 0;
} | insert | 48 | 48 | 48 | 50 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
/**/
#include <random>
using namespace std;
int main() {
long long int N, M;
cin >> N >> M;
vector<long long int> A(N);
priority_queue<long long int, vector<long long int>, greater<long long int>>
que;
for (size_t i = 0; i < N; i++) {
cin >> A[i];
que.push(A[i]);
}
vector<pair<long long int, long long int>> BC(M);
for (size_t i = 0; i < M; i++) {
cin >> BC[i].second >> BC[i].first;
}
sort(BC.begin(), BC.end());
for (size_t i = 0; i < M; i++) {
long long int nowV = BC[i].first, nowCount = BC[i].second;
for (size_t j = 0; j < nowCount; j++) {
long long int now = que.top();
que.pop();
if (now < nowV) {
que.push(nowV);
} else {
que.push(now);
break;
}
}
}
long long int ans = 0;
while (que.size()) {
long long int now = que.top();
que.pop();
ans += now;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
/**/
#include <random>
using namespace std;
int main() {
long long int N, M;
cin >> N >> M;
vector<long long int> A(N);
priority_queue<long long int, vector<long long int>, greater<long long int>>
que;
for (size_t i = 0; i < N; i++) {
cin >> A[i];
que.push(A[i]);
}
vector<pair<long long int, long long int>> BC(M);
for (size_t i = 0; i < M; i++) {
cin >> BC[i].second >> BC[i].first;
}
sort(BC.begin(), BC.end());
long long int countSum = 0;
for (int i = M - 1; i >= 0; i--) {
BC[i].second = min(N - countSum, BC[i].second);
countSum += BC[i].second;
}
for (size_t i = 0; i < M; i++) {
long long int nowV = BC[i].first, nowCount = BC[i].second;
for (size_t j = 0; j < nowCount; j++) {
long long int now = que.top();
que.pop();
if (now < nowV) {
que.push(nowV);
} else {
que.push(now);
break;
}
}
}
long long int ans = 0;
while (que.size()) {
long long int now = que.top();
que.pop();
ans += now;
}
cout << ans << endl;
}
| insert | 22 | 22 | 22 | 28 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <cmath>
#include <math.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vs = vector<string>;
using vvs = vector<vs>;
using vc = vector<char>;
using vvc = vector<vc>;
using vb = vector<bool>;
using vvb = vector<vb>;
#define rep(i, n) \
; \
for (int i = 0; i < n; i++)
#define all(a) a.begin(), a.end()
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n", a)
#define mem(a) memset(a, 0, sizeof(a))
#define f(i, a, b) for (int i = a; i < b; i++)
#define pri(a) printf("%.14lf\n", a);
#define MOD 1000000007
bool is_int_lround(double x) { return std::lround(x) == x; }
ll keta(ll x) {
ll n = 0;
while (x > 0) {
x /= 10;
n++;
}
return n;
}
ll conbi(int n, int m) {
cin >> n >> m;
vector<ll> a(100);
a[0] = 1;
for (int i = 0; i < 14; i++) {
a[i + 1] = a[i] * (i + 1);
}
return a[n] / (a[m] * a[n - m]);
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1; // 繰り返し二乗法
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll kaijo(ll x) {
ll z = 1;
while (x > 0) {
z *= x;
z %= MOD;
x--;
}
return z;
}
ll yakusu_num(ll n) {
vl yakusu(n + 1, 1);
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
yakusu[i]++;
}
}
if (n != 1)
yakusu[n]++;
ll num = 1;
for (ll i = 0; i <= n; i++) {
num *= yakusu[i];
}
return num;
}
int main() {
ll N, M;
cin >> N >> M;
vl a(N);
vl b(N);
vl c(N);
vector<pair<ll, ll>> p(M);
rep(i, N) { cin >> a[i]; }
rep(i, M) {
cin >> b[i] >> c[i];
p[i] = make_pair(c[i], b[i]);
}
sort(all(a));
sort(all(p));
reverse(all(p));
int j = 0;
ll ans = 0;
rep(i, M) {
int k = 0;
while (p[i].second > k && j < N) {
a[j] = max(a[j], p[i].first);
j++;
k++;
}
}
rep(i, N) ans += a[i];
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <cmath>
#include <math.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vs = vector<string>;
using vvs = vector<vs>;
using vc = vector<char>;
using vvc = vector<vc>;
using vb = vector<bool>;
using vvb = vector<vb>;
#define rep(i, n) \
; \
for (int i = 0; i < n; i++)
#define all(a) a.begin(), a.end()
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n", a)
#define mem(a) memset(a, 0, sizeof(a))
#define f(i, a, b) for (int i = a; i < b; i++)
#define pri(a) printf("%.14lf\n", a);
#define MOD 1000000007
bool is_int_lround(double x) { return std::lround(x) == x; }
ll keta(ll x) {
ll n = 0;
while (x > 0) {
x /= 10;
n++;
}
return n;
}
ll conbi(int n, int m) {
cin >> n >> m;
vector<ll> a(100);
a[0] = 1;
for (int i = 0; i < 14; i++) {
a[i + 1] = a[i] * (i + 1);
}
return a[n] / (a[m] * a[n - m]);
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1; // 繰り返し二乗法
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll kaijo(ll x) {
ll z = 1;
while (x > 0) {
z *= x;
z %= MOD;
x--;
}
return z;
}
ll yakusu_num(ll n) {
vl yakusu(n + 1, 1);
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
yakusu[i]++;
}
}
if (n != 1)
yakusu[n]++;
ll num = 1;
for (ll i = 0; i <= n; i++) {
num *= yakusu[i];
}
return num;
}
int main() {
ll N, M;
cin >> N >> M;
vl a(N);
vl b(M);
vl c(M);
vector<pair<ll, ll>> p(M);
rep(i, N) { cin >> a[i]; }
rep(i, M) {
cin >> b[i] >> c[i];
p[i] = make_pair(c[i], b[i]);
}
sort(all(a));
sort(all(p));
reverse(all(p));
int j = 0;
ll ans = 0;
rep(i, M) {
int k = 0;
while (p[i].second > k && j < N) {
a[j] = max(a[j], p[i].first);
j++;
k++;
}
}
rep(i, N) ans += a[i];
cout << ans << endl;
} | replace | 88 | 90 | 88 | 90 | 0 | |
p03038 | C++ | Runtime Error | //==========================Head files==========================
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define LL long long
#define db double
#define mp make_pair
#define pr pair<int, int>
#define fir first
#define sec second
#define pb push_back
#define ms(i, j) memset(i, j, sizeof i)
using namespace std;
//==========================Templates==========================
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
inline LL readl() {
LL x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int power(int a, int b) {
int ans = 1;
while (b) {
if (b & 1)
ans = ans * a;
b >>= 1;
a = a * a;
}
return ans;
}
int power_mod(int a, int b, int mod) {
a %= mod;
int ans = 1;
while (b) {
if (b & 1)
ans = (ans * a) % mod;
b >>= 1, a = (a * a) % mod;
}
return ans;
}
LL powerl(LL a, LL b) {
LL ans = 1ll;
while (b) {
if (b & 1ll)
ans = ans * a;
b >>= 1ll;
a = a * a;
}
return ans;
}
LL power_modl(LL a, LL b, LL mod) {
a %= mod;
LL ans = 1ll;
while (b) {
if (b & 1ll)
ans = (ans * a) % mod;
b >>= 1ll, a = (a * a) % mod;
}
return ans;
}
LL gcdl(LL a, LL b) { return b == 0 ? a : gcdl(b, a % b); }
LL abssl(LL a) { return a > 0 ? a : -a; }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int abss(int a) { return a > 0 ? a : -a; }
//==========================Main body==========================
#define LD "%I64d"
#define D "%d"
#define pt printf
#define sn scanf
#define pty printf("YES\n")
#define ptn printf("NO\n")
//==========================Code here==========================
int n, m, a[100000 + 5];
pair<int, int> p[100000 + 5];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= m; ++i)
scanf("%d%d", &p[i].second, &p[i].first), p[i].second = -p[i].second,
p[i].first = -p[i].first;
sort(p + 1, p + 1 + m);
int now = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= -p[i].second; ++j) {
if (-p[i].first < a[now])
break;
a[now] = -p[i].first;
++now;
}
}
LL ans = 0;
for (int i = 1; i <= n; ++i)
ans += a[i];
cout << ans;
return 0;
} | //==========================Head files==========================
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define LL long long
#define db double
#define mp make_pair
#define pr pair<int, int>
#define fir first
#define sec second
#define pb push_back
#define ms(i, j) memset(i, j, sizeof i)
using namespace std;
//==========================Templates==========================
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
inline LL readl() {
LL x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int power(int a, int b) {
int ans = 1;
while (b) {
if (b & 1)
ans = ans * a;
b >>= 1;
a = a * a;
}
return ans;
}
int power_mod(int a, int b, int mod) {
a %= mod;
int ans = 1;
while (b) {
if (b & 1)
ans = (ans * a) % mod;
b >>= 1, a = (a * a) % mod;
}
return ans;
}
LL powerl(LL a, LL b) {
LL ans = 1ll;
while (b) {
if (b & 1ll)
ans = ans * a;
b >>= 1ll;
a = a * a;
}
return ans;
}
LL power_modl(LL a, LL b, LL mod) {
a %= mod;
LL ans = 1ll;
while (b) {
if (b & 1ll)
ans = (ans * a) % mod;
b >>= 1ll, a = (a * a) % mod;
}
return ans;
}
LL gcdl(LL a, LL b) { return b == 0 ? a : gcdl(b, a % b); }
LL abssl(LL a) { return a > 0 ? a : -a; }
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int abss(int a) { return a > 0 ? a : -a; }
//==========================Main body==========================
#define LD "%I64d"
#define D "%d"
#define pt printf
#define sn scanf
#define pty printf("YES\n")
#define ptn printf("NO\n")
//==========================Code here==========================
int n, m, a[100000 + 5];
pair<int, int> p[100000 + 5];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= m; ++i)
scanf("%d%d", &p[i].second, &p[i].first), p[i].second = -p[i].second,
p[i].first = -p[i].first;
sort(p + 1, p + 1 + m);
int now = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= -p[i].second; ++j) {
if (now > n)
break;
if (-p[i].first < a[now])
break;
a[now] = -p[i].first;
++now;
}
}
LL ans = 0;
for (int i = 1; i <= n; ++i)
ans += a[i];
cout << ans;
return 0;
} | insert | 114 | 114 | 114 | 116 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
#define mod 1000000007
#define ll long long int
#define pb(x) push_back(x)
#define MP(x, y) make_pair(x, y)
using namespace std;
ll power(ll a, ll b, ll m) {
if (b == 0)
return (1);
ll sol = power(a, b / 2, m);
sol = (sol * sol) % m;
if (b % 2 == 1)
sol = (sol * a) % m;
return (sol);
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else {
return gcd(b, a % b);
}
}
ll a[100001];
vector<pair<ll, ll>> v;
void solve() {
ll sol = 0;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
v.pb(MP(c, b));
}
sort(v.begin(), v.end());
int i = 0, j = m - 1;
;
while (1) {
ll co = v[j].second;
while (co > 0 && j >= 0) {
ll val = v[j].first;
if (a[i] < val) {
a[i] = val;
co--;
i++;
} else {
for (int i = 0; i < n; i++) {
sol = sol + a[i];
}
cout << sol;
return;
}
}
j--;
if (j < 0) {
for (int i = 0; i < n; i++) {
sol = sol + a[i];
}
cout << sol;
return;
}
}
}
int main() {
int t = 1;
// cin >> t;
while (t--)
solve();
return (0);
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <ctype.h>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
#define mod 1000000007
#define ll long long int
#define pb(x) push_back(x)
#define MP(x, y) make_pair(x, y)
using namespace std;
ll power(ll a, ll b, ll m) {
if (b == 0)
return (1);
ll sol = power(a, b / 2, m);
sol = (sol * sol) % m;
if (b % 2 == 1)
sol = (sol * a) % m;
return (sol);
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else {
return gcd(b, a % b);
}
}
ll a[100001];
vector<pair<ll, ll>> v;
void solve() {
ll sol = 0;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
v.pb(MP(c, b));
}
sort(v.begin(), v.end());
int i = 0, j = m - 1;
;
while (1) {
ll co = v[j].second;
while (co > 0 && j >= 0) {
ll val = v[j].first;
if (a[i] < val) {
a[i] = val;
co--;
i++;
if (i >= n) {
for (int i = 0; i < n; i++) {
sol = sol + a[i];
}
cout << sol;
return;
}
} else {
for (int i = 0; i < n; i++) {
sol = sol + a[i];
}
cout << sol;
return;
}
}
j--;
if (j < 0) {
for (int i = 0; i < n; i++) {
sol = sol + a[i];
}
cout << sol;
return;
}
}
}
int main() {
int t = 1;
// cin >> t;
while (t--)
solve();
return (0);
} | insert | 68 | 68 | 68 | 76 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 1; i <= (n); i++)
#define mod (ll)(1e9 + 7)
#define inf (ll)(3e18 + 7)
#define pi (double)acos(-1)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
using namespace std;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vector<pair<ll, ll>> b(n);
rep(i, m) cin >> b[i].second >> b[i].first;
sort(rall(b));
ll j = 0;
rep(i, n) {
if (a[i] < b[j].first) {
a[i] = b[j].first;
b[j].second--;
}
if (b[j].second <= 0)
j++;
if (j >= m)
break;
}
cout << accumulate(all(a), 0LL) << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 1; i <= (n); i++)
#define mod (ll)(1e9 + 7)
#define inf (ll)(3e18 + 7)
#define pi (double)acos(-1)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
using namespace std;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vector<pair<ll, ll>> b(m);
rep(i, m) cin >> b[i].second >> b[i].first;
sort(rall(b));
ll j = 0;
rep(i, n) {
if (a[i] < b[j].first) {
a[i] = b[j].first;
b[j].second--;
}
if (b[j].second <= 0)
j++;
if (j >= m)
break;
}
cout << accumulate(all(a), 0LL) << endl;
}
| replace | 20 | 21 | 20 | 21 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL MAX = 5e5 + 5;
bool a[MAX];
int main() {
LL n, m;
cin >> n >> m;
multiset<LL> s;
for (int i = 0; i < n; i++) {
LL x;
cin >> x;
s.insert(x);
}
while (m--) {
LL b, c;
cin >> b >> c;
while (b--) {
LL x = *(s.begin());
if (x >= c)
break;
// cout<<x<<" ";
s.erase(s.begin());
x = c;
s.insert(x);
}
}
LL sum = 0;
for (auto x : s) {
// cout<<x<<" ";
sum += x;
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL MAX = 5e5 + 5;
bool a[MAX];
int main() {
LL n, m;
cin >> n >> m;
multiset<LL> s;
for (int i = 0; i < n; i++) {
LL x;
cin >> x;
s.insert(x);
}
vector<pair<LL, LL>> v;
for (int i = 0; i < m; i++) {
LL x, y;
cin >> x >> y;
v.push_back(make_pair(y, x));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < m; i++) {
LL b = v[i].second;
LL c = v[i].first;
while (b--) {
LL x = *(s.begin());
if (x >= c)
break;
// cout<<x<<" ";
s.erase(s.begin());
x = c;
s.insert(x);
}
}
LL sum = 0;
for (auto x : s) {
// cout<<x<<" ";
sum += x;
}
cout << sum << endl;
} | replace | 15 | 18 | 15 | 26 | TLE | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (long long)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 500005
int32_t main() {
sp;
int n, m;
cin >> n >> m;
pq<int, vector<int>, greater<int>> q;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
q.push(x);
}
while (m--) {
int c, b;
cin >> b >> c;
while (b-- && q.empty() == 0 && q.top() < c) {
q.pop();
q.push(c);
}
}
int sum = 0;
while (!q.empty()) {
// cout<<q.top()<<" ";
sum += q.top();
q.pop();
}
cout << sum;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cps CLOCKS_PER_SEC
#define mod (long long)1000000007
#define f first
#define s second
#define debug1(x) cerr << x << "\n"
#define debug2(x, y) cerr << x << " " << y << "\n"
#define debug3(x, y, z) cerr << x << " " << y << " " << z << "\n"
#define nl cerr << "\n";
#define pq priority_queue
#define inf 0x3f3f3f3f
#define test cerr << "abcd\n";
#define pi pair<int, int>
#define pii pair<int, pi>
#define pb push_back
#define mxn 500005
int32_t main() {
sp;
int n, m;
cin >> n >> m;
pq<int, vector<int>, greater<int>> q;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
q.push(x);
}
vector<pi> v(m);
for (int i = 0; i < m; ++i)
cin >> v[i].s >> v[i].f;
sort(v.rbegin(), v.rend());
for (auto &it : v) {
int b = it.s;
int c = it.f;
while (b-- && q.empty() == 0 && q.top() < c) {
q.pop();
q.push(c);
}
}
int sum = 0;
while (!q.empty()) {
// cout<<q.top()<<" ";
sum += q.top();
q.pop();
}
cout << sum;
return 0;
}
| replace | 31 | 34 | 31 | 38 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
freopen("D.INP", "r", stdin);
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
priority_queue<int, vector<int>, greater<int>> q;
priority_queue<pair<int, int>> o;
cin >> n >> m;
while (n--) {
int t;
cin >> t;
q.push(t);
}
while (m--) {
int b, c;
cin >> b >> c;
o.push({c, b});
}
while (!o.empty() && q.top() < o.top().first) {
int b, c;
b = o.top().second;
c = o.top().first;
o.pop();
while (b-- && q.top() < c)
q.pop(), q.push(c);
}
long long ans = 0;
while (!q.empty())
ans += 1ll * q.top(), q.pop();
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
// freopen("D.INP","r",stdin);
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
priority_queue<int, vector<int>, greater<int>> q;
priority_queue<pair<int, int>> o;
cin >> n >> m;
while (n--) {
int t;
cin >> t;
q.push(t);
}
while (m--) {
int b, c;
cin >> b >> c;
o.push({c, b});
}
while (!o.empty() && q.top() < o.top().first) {
int b, c;
b = o.top().second;
c = o.top().first;
o.pop();
while (b-- && q.top() < c)
q.pop(), q.push(c);
}
long long ans = 0;
while (!q.empty())
ans += 1ll * q.top(), q.pop();
cout << ans << '\n';
return 0;
}
| replace | 5 | 6 | 5 | 6 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p03038 | C++ | Runtime Error | // D - Integer Cards
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<int, int>> t(n);
for (int i = 0; i < m; i++)
cin >> t[i].second >> t[i].first;
sort(a.begin(), a.end());
sort(t.begin(), t.end(), greater<pair<int, int>>());
long long sum = 0;
int k = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < t[i].second && k < n; j++)
if (t[i].first > a[k]) {
sum += t[i].first;
k++;
} else
break;
for (; k < n; k++)
sum += a[k];
cout << sum << endl;
return 0;
}
| // D - Integer Cards
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<int, int>> t(m);
for (int i = 0; i < m; i++)
cin >> t[i].second >> t[i].first;
sort(a.begin(), a.end());
sort(t.begin(), t.end(), greater<pair<int, int>>());
long long sum = 0;
int k = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < t[i].second && k < n; j++)
if (t[i].first > a[k]) {
sum += t[i].first;
k++;
} else
break;
for (; k < n; k++)
sum += a[k];
cout << sum << endl;
return 0;
}
| replace | 11 | 12 | 11 | 12 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define P pair<ll, ll>
typedef vector<int> vec;
typedef vector<vec> mat;
bool f(P x, P y) {
if (x.second != y.second)
return x.second > y.second;
else
return x.first <= y.first;
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
P b[m];
rep(i, m) cin >> b[i].first >> b[i].second;
sort(a, a + n);
sort(b, b + m, f);
ll ans = 0;
ll idx = 0;
rep(i, n) {
if (idx < m) {
if (a[i] < b[idx].second) {
ans += b[idx].second;
b[idx].first--;
} else {
ans += a[i];
idx = m;
}
} else {
ans += a[i];
}
if (b[idx].first == 0)
idx++;
}
// rep(i, m){
// cout << b[i].first << " " << b[i].second << endl;
// }
cout << ans << endl;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define P pair<ll, ll>
typedef vector<int> vec;
typedef vector<vec> mat;
bool f(P x, P y) {
if (x.second != y.second)
return x.second > y.second;
else
return x.first < y.first;
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
P b[m];
rep(i, m) cin >> b[i].first >> b[i].second;
sort(a, a + n);
sort(b, b + m, f);
ll ans = 0;
ll idx = 0;
rep(i, n) {
if (idx < m) {
if (a[i] < b[idx].second) {
ans += b[idx].second;
b[idx].first--;
} else {
ans += a[i];
idx = m;
}
} else {
ans += a[i];
}
if (b[idx].first == 0)
idx++;
}
// rep(i, m){
// cout << b[i].first << " " << b[i].second << endl;
// }
cout << ans << endl;
} | replace | 22 | 23 | 22 | 23 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
#define tl 1'000'000'007
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REREP(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, a, n) for (ll i = a; i < n; i++)
#define REFOR(i, n, a) for (ll i = n; i >= a; i--)
struct P {
ll b, c;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<ll> A(n);
vector<P> T(m);
REP(i, n) cin >> A[i];
REP(i, m) cin >> T[i].b >> T[i].c;
sort(A.begin(), A.end());
sort(T.begin(), T.end(), [](const P &x, const P &y) { return x.c > y.c; });
ll ii = 0;
REP(i, T.size()) {
REP(j, T[i].b) {
// cout << A[ii] << " ";
A[ii] = max(A[ii], T[i].c);
ii++;
if (ii >= n) {
break;
}
}
}
ll sum = 0;
REP(i, n) { sum += A[i]; }
cout << sum << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
#define tl 1'000'000'007
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REREP(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, a, n) for (ll i = a; i < n; i++)
#define REFOR(i, n, a) for (ll i = n; i >= a; i--)
struct P {
ll b, c;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<ll> A(n);
vector<P> T(m);
REP(i, n) cin >> A[i];
REP(i, m) cin >> T[i].b >> T[i].c;
sort(A.begin(), A.end());
sort(T.begin(), T.end(), [](const P &x, const P &y) { return x.c > y.c; });
ll ii = 0;
REP(i, T.size()) {
REP(j, T[i].b) {
// cout << A[ii] << " ";
A[ii] = max(A[ii], T[i].c);
ii++;
if (ii >= n) {
break;
}
}
if (ii >= n) {
break;
}
}
ll sum = 0;
REP(i, n) { sum += A[i]; }
cout << sum << endl;
}
| insert | 34 | 34 | 34 | 37 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <locale>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
const long long int INF = 1e9;
typedef long long int ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n) for (int i = 1; i <= (int)(n); i++)
#define llrep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define llRep(i, n) for (ll i = 1; i <= (ll)(n); i++)
using namespace std;
struct Point {
int x, y;
};
bool vector_finder(std::vector<ll> vec, ll number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance(vec.begin(), itr);
if (index != vec.size()) { // 発見できたとき
return true;
} else { // 発見できなかったとき
return false;
}
}
ll factorial(ll N) {
ll ans = 1;
llRep(i, N) { ans *= i; }
return ans;
}
ll extended_factorial(ll N) {
ll ans = 1;
llRep(i, N) {
ans *= i;
ans %= (ll)(1e9 + 7);
}
return ans;
}
vector<ll> Eratosthenes(ll N) {
bool arr[N + 1];
// initialization
arr[0] = false;
arr[1] = false;
for (ll i = 2; i < N + 1; i++) {
arr[i] = true;
}
// eratosthenes
for (ll i = 2; i <= sqrt(N); i++) {
if (arr[i]) {
for (ll j = 0; i * (j + 2) <= N; j++) {
arr[i * (j + 2)] = false; // not prime number
}
}
}
vector<ll> prime;
llRep(i, N) {
if (arr[i] == true) {
prime.push_back(i);
}
}
return prime;
}
char alphabet[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
// 二分探索
// llrep(i,N){
// b = B[i];
// auto cntA = lower_bound(A.begin(), A.end(),
// b);//イテレータなのでそのままllに変換とかはできない auto cntC =
// upper_bound(C.begin(), C.end(), b); ll cntA_ll = distance(A.begin(),
// cntA); ll cntC_ll = C.size() - distance(C.begin(), cntC); cnt += (cntA_ll
// * cntC_ll);
// }
vector<ll> A;
// priority_queue<ll, vector<ll>, greater<ll> > queueA;
vector<pair<ll, ll>> B_C;
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
int main() {
ll N, M, a, b, c;
cin >> N >> M;
ll sum = 0;
llrep(i, N) {
cin >> a;
// queueA.push(a);
A.push_back(a);
sum += a;
}
sort(A.begin(), A.end());
// llrep(i,A.size()){
// cout <<A[i] << endl;
// }
llrep(i, M) {
cin >> b >> c;
B_C.push_back(make_pair(b, c));
// llrep(j,b){
// if (c > queueA.top()){
// sum += (c - queueA.top());
// queueA.pop();
// queueA.push(c);
// }
// }
}
sort(B_C.begin(), B_C.end(), compare_by_second);
ll change = 0, cnt;
llrep(i, M) {
b = B_C[i].first;
c = B_C[i].second;
if (c <= A[change])
break;
cnt = 0;
llrep(j, b) {
if (change + j < N && c > A[change + j]) {
// cout << "erase " << A[change + j] << " & add "<< c << endl;
sum += (c - A[change + j]);
A[change + j] = c;
cnt++;
// queueA.pop();
// queueA.push(c);
}
}
change += cnt;
}
cout << sum << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <locale>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
const long long int INF = 1e9;
typedef long long int ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n) for (int i = 1; i <= (int)(n); i++)
#define llrep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define llRep(i, n) for (ll i = 1; i <= (ll)(n); i++)
using namespace std;
struct Point {
int x, y;
};
bool vector_finder(std::vector<ll> vec, ll number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance(vec.begin(), itr);
if (index != vec.size()) { // 発見できたとき
return true;
} else { // 発見できなかったとき
return false;
}
}
ll factorial(ll N) {
ll ans = 1;
llRep(i, N) { ans *= i; }
return ans;
}
ll extended_factorial(ll N) {
ll ans = 1;
llRep(i, N) {
ans *= i;
ans %= (ll)(1e9 + 7);
}
return ans;
}
vector<ll> Eratosthenes(ll N) {
bool arr[N + 1];
// initialization
arr[0] = false;
arr[1] = false;
for (ll i = 2; i < N + 1; i++) {
arr[i] = true;
}
// eratosthenes
for (ll i = 2; i <= sqrt(N); i++) {
if (arr[i]) {
for (ll j = 0; i * (j + 2) <= N; j++) {
arr[i * (j + 2)] = false; // not prime number
}
}
}
vector<ll> prime;
llRep(i, N) {
if (arr[i] == true) {
prime.push_back(i);
}
}
return prime;
}
char alphabet[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
// 二分探索
// llrep(i,N){
// b = B[i];
// auto cntA = lower_bound(A.begin(), A.end(),
// b);//イテレータなのでそのままllに変換とかはできない auto cntC =
// upper_bound(C.begin(), C.end(), b); ll cntA_ll = distance(A.begin(),
// cntA); ll cntC_ll = C.size() - distance(C.begin(), cntC); cnt += (cntA_ll
// * cntC_ll);
// }
vector<ll> A;
// priority_queue<ll, vector<ll>, greater<ll> > queueA;
vector<pair<ll, ll>> B_C;
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first > b.first;
}
}
int main() {
ll N, M, a, b, c;
cin >> N >> M;
ll sum = 0;
llrep(i, N) {
cin >> a;
// queueA.push(a);
A.push_back(a);
sum += a;
}
sort(A.begin(), A.end());
// llrep(i,A.size()){
// cout <<A[i] << endl;
// }
llrep(i, M) {
cin >> b >> c;
B_C.push_back(make_pair(b, c));
// llrep(j,b){
// if (c > queueA.top()){
// sum += (c - queueA.top());
// queueA.pop();
// queueA.push(c);
// }
// }
}
sort(B_C.begin(), B_C.end(), compare_by_second);
ll change = 0, cnt;
llrep(i, M) {
b = B_C[i].first;
c = B_C[i].second;
if (c <= A[change])
break;
if (change >= N)
break;
cnt = 0;
llrep(j, b) {
if (change + j < N && c > A[change + j]) {
// cout << "erase " << A[change + j] << " & add "<< c << endl;
sum += (c - A[change + j]);
A[change + j] = c;
cnt++;
// queueA.pop();
// queueA.push(c);
}
}
change += cnt;
}
cout << sum << endl;
return 0;
}
| insert | 138 | 138 | 138 | 140 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int arr[100001];
vector<pair<int, int>> v;
int n, m;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first)
return a.second > b.second;
return a.first > b.first;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> arr[i];
sort(arr, arr + n);
int num, val;
for (int i = 0; i < m; i++) {
cin >> num >> val;
v.push_back(make_pair(val, num));
}
sort(v.begin(), v.end(), cmp);
int j = 0; // v_ind
for (int i = 0; i < m; i++) {
if (v[i].first > arr[j] && v[i].second > 0) {
v[i].second -= 1;
arr[j] = v[i].first;
i--;
j++;
}
}
long long int result = 0;
for (int i = 0; i < n; i++)
result += arr[i];
cout << result;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int arr[100001];
vector<pair<int, int>> v;
int n, m;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first)
return a.second > b.second;
return a.first > b.first;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> arr[i];
sort(arr, arr + n);
int num, val;
for (int i = 0; i < m; i++) {
cin >> num >> val;
v.push_back(make_pair(val, num));
}
sort(v.begin(), v.end(), cmp);
int j = 0; // v_ind
for (int i = 0; i < m; i++) {
if (v[i].first > arr[j] && v[i].second > 0 && j < n) {
v[i].second -= 1;
arr[j] = v[i].first;
i--;
j++;
}
}
long long int result = 0;
for (int i = 0; i < n; i++)
result += arr[i];
cout << result;
}
| replace | 33 | 34 | 33 | 34 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define FORe(i, k, n) for (int i = (k); i <= (n); i++)
#define FORr(i, k, n) for (int i = (k)-1; i > (n); i--)
#define FORre(i, k, n) for (int i = (k)-1; i >= (n); i--)
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORre(i, n, 0)
#define ALL(x) (x).begin(), (x).end()
#define ALLr(x) (x).rbegin(), (x).rend()
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
int main(void) {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<P> v(n);
REP(i, n) cin >> a[i];
REP(i, m) {
int b, c;
cin >> b >> c;
v[i] = P(c, b);
}
sort(ALL(a));
sort(ALLr(v));
ll ans = 0;
int j = 0;
REP(i, m) {
int c = v[i].first;
int b = v[i].second;
if (a[j] >= c)
break;
while (j < n && a[j] < c && b > 0) {
ans += c;
j++;
b--;
}
if (j == n)
break;
}
while (j < n)
ans += a[j++];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define FORe(i, k, n) for (int i = (k); i <= (n); i++)
#define FORr(i, k, n) for (int i = (k)-1; i > (n); i--)
#define FORre(i, k, n) for (int i = (k)-1; i >= (n); i--)
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORre(i, n, 0)
#define ALL(x) (x).begin(), (x).end()
#define ALLr(x) (x).rbegin(), (x).rend()
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
int main(void) {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<P> v(m);
REP(i, n) cin >> a[i];
REP(i, m) {
int b, c;
cin >> b >> c;
v[i] = P(c, b);
}
sort(ALL(a));
sort(ALLr(v));
ll ans = 0;
int j = 0;
REP(i, m) {
int c = v[i].first;
int b = v[i].second;
if (a[j] >= c)
break;
while (j < n && a[j] < c && b > 0) {
ans += c;
j++;
b--;
}
if (j == n)
break;
}
while (j < n)
ans += a[j++];
cout << ans << endl;
return 0;
} | replace | 21 | 22 | 21 | 22 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<long long> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
vector<int> B(M);
vector<long long> C(N);
for (int i = 0; i < M; i++)
cin >> B[i] >> C[i];
sort(A.begin(), A.end());
vector<int> index(M);
iota(index.begin(), index.end(), 0);
sort(index.begin(), index.end(), [&](int i, int j) { return C[i] > C[j]; });
int cont = 0;
for (auto i : index) {
for (int j = 0; j < B[i]; j++) {
if (A[cont] > C[i])
break;
A[cont] = C[i];
cont++;
}
}
long long sum = 0;
for (int i = 0; i < N; i++)
sum += A[i];
cout << sum << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<long long> A(N);
for (int i = 0; i < N; i++)
cin >> A[i];
vector<int> B(M);
vector<long long> C(M);
for (int i = 0; i < M; i++)
cin >> B[i] >> C[i];
sort(A.begin(), A.end());
vector<int> index(M);
iota(index.begin(), index.end(), 0);
sort(index.begin(), index.end(), [&](int i, int j) { return C[i] > C[j]; });
int cont = 0;
for (auto i : index) {
for (int j = 0; j < B[i]; j++) {
if (A[cont] > C[i])
break;
A[cont] = C[i];
cont++;
}
}
long long sum = 0;
for (int i = 0; i < N; i++)
sum += A[i];
cout << sum << endl;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define MOD 1000000007
typedef long long int ll;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<ll> a(N), c(M), d(N);
vector<int> b(M);
vector<pair<int, int>> pairs(M);
ll sum = 0;
ll ans = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
}
ans = sum;
for (int i = 0; i < M; i++) {
cin >> b[i] >> c[i];
pairs[i] = make_pair(c[i], b[i]);
}
sort(a.begin(), a.end());
sort(pairs.begin(), pairs.end(), greater<pair<int, int>>());
int j = 0;
for (int i = 0; i < N; i++) {
if (pairs[j].second == 0)
j++;
d[i] = pairs[j].first;
pairs[j].second--;
}
for (int i = 0; i < N; i++) {
sum = sum + d[i] - a[i];
if (sum > ans)
ans = sum;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define MOD 1000000007
typedef long long int ll;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<ll> a(N), c(M), d(N);
vector<int> b(M);
vector<pair<ll, int>> pairs(M);
ll sum = 0;
ll ans = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
}
ans = sum;
for (int i = 0; i < M; i++) {
cin >> b[i] >> c[i];
pairs[i] = make_pair(c[i], b[i]);
}
sort(a.begin(), a.end());
sort(pairs.begin(), pairs.end(), greater<pair<int, int>>());
int j = 0;
for (int i = 0; i < N; i++) {
if (pairs[j].second == 0)
j++;
d[i] = pairs[j].first;
pairs[j].second--;
}
for (int i = 0; i < N; i++) {
sum = sum + d[i] - a[i];
if (sum > ans)
ans = sum;
}
cout << ans << endl;
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p03038 | C++ | Runtime Error | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
typedef int64_t ll;
typedef uint64_t ull;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
ll ans;
int n, m, a[100000];
priority_queue<pair<int, int>> pq;
int main(void) {
cin >> n >> m;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, m) {
int b, c;
cin >> b >> c;
pq.push(make_pair(c, b));
}
int i = 0;
while (pq.size() != 0) {
auto p = pq.top();
pq.pop();
int j = 0;
while (j < p.second) {
if (a[i] < p.first) {
a[i] = p.first;
i++;
j++;
continue;
}
goto end;
}
}
end:
rep(i, n) { ans += a[i]; }
cout << ans << endl;
return 0;
}
| #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
typedef int64_t ll;
typedef uint64_t ull;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
ll ans;
int n, m, a[100000];
priority_queue<pair<int, int>> pq;
int main(void) {
cin >> n >> m;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, m) {
int b, c;
cin >> b >> c;
pq.push(make_pair(c, b));
}
int i = 0;
while (pq.size() != 0) {
auto p = pq.top();
pq.pop();
int j = 0;
while (j < p.second) {
if (a[i] < p.first) {
a[i] = p.first;
i++;
j++;
if (i == n)
goto end;
continue;
}
goto end;
}
}
end:
rep(i, n) { ans += a[i]; }
cout << ans << endl;
return 0;
}
| insert | 35 | 35 | 35 | 37 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N, M;
cin >> N >> M;
vector<ll> vec(N);
for (ll i = 0; i < N; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
vector<pair<int, int>> card(M);
for (ll i = 0; i < M; i++) {
ll b, c;
cin >> b >> c;
card[i] = make_pair(c, b);
}
sort(card.begin(), card.end());
ll now = M - 1;
for (ll i = 0; i < N; i++) {
if (card[now].second <= 0) {
now--;
}
if (vec[i] < card[now].first) {
vec[i] = card[now].first;
card[now].second--;
}
}
ll ans = 0;
for (ll i = 0; i < N; i++) {
ans += vec[i];
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll N, M;
cin >> N >> M;
vector<ll> vec(N);
for (ll i = 0; i < N; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
vector<pair<ll, ll>> card(M);
for (ll i = 0; i < M; i++) {
ll b, c;
cin >> b >> c;
card[i] = make_pair(c, b);
}
sort(card.begin(), card.end());
ll now = M - 1;
for (ll i = 0; i < N; i++) {
if (card[now].second <= 0) {
now--;
}
if (vec[i] < card[now].first) {
vec[i] = card[now].first;
card[now].second--;
}
}
ll ans = 0;
for (ll i = 0; i < N; i++) {
ans += vec[i];
}
cout << ans << endl;
}
| replace | 13 | 14 | 13 | 14 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SORT(c) sort((c).begin(), (c).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define RREP(i, n) RFOR(i, n, 0)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INT_INF = 2147483647;
const long long LL_INF = 1LL << 60;
const long long MOD = 1000000007;
#define CLR(a) memset((a), 0, sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
bool comp(pair<ll, ll> a, pair<ll, ll> b) { return a.second > b.second; }
int main(void) {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
REP(i, N) cin >> A[i];
vector<pair<ll, ll>> v(M);
REP(i, M) {
ll b, c;
cin >> b >> c;
v[i].first = b;
v[i].second = c;
}
SORT(A);
sort(v.begin(), v.end(), comp);
ll t = 0;
vector<ll> newA(N);
REP(i, M) {
ll b = v[i].first, c = v[i].second;
FOR(j, t, min(t + b, N)) { newA[j] = c; }
t += b;
}
vector<ll> AA(N);
REP(i, N) AA[i] = max(A[i], newA[i]);
ll ans = 0;
REP(i, N) ans += AA[i];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SORT(c) sort((c).begin(), (c).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define RREP(i, n) RFOR(i, n, 0)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INT_INF = 2147483647;
const long long LL_INF = 1LL << 60;
const long long MOD = 1000000007;
#define CLR(a) memset((a), 0, sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
bool comp(pair<ll, ll> a, pair<ll, ll> b) { return a.second > b.second; }
int main(void) {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
REP(i, N) cin >> A[i];
vector<pair<ll, ll>> v(M);
REP(i, M) {
ll b, c;
cin >> b >> c;
v[i].first = b;
v[i].second = c;
}
SORT(A);
sort(v.begin(), v.end(), comp);
ll t = 0;
vector<ll> newA(N);
REP(i, M) {
ll b = v[i].first, c = v[i].second;
for (ll j = t; j < min(t + b, N); j++) {
newA[j] = c;
}
t += b;
}
vector<ll> AA(N);
REP(i, N) AA[i] = max(A[i], newA[i]);
ll ans = 0;
REP(i, N) ans += AA[i];
cout << ans << endl;
return 0;
} | replace | 80 | 81 | 80 | 83 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath> //sqrt pow
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cout, endl, cin
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define rep(i, n) for (int i = 0; i < n; i++)
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define mod 1000000007
using ll = long long;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vi a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
vector<pii> v(n);
rep(i, m) {
int b, c;
cin >> b >> c;
v[i] = make_pair(c, b);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int cnt = 0, last = n;
ll ans = 0;
rep(i, n) {
if (v[cnt].second <= 0)
cnt++;
if (cnt < m && v[cnt].first > a[i]) {
v[cnt].second--;
ans += v[cnt].first;
} else {
last = i;
break;
}
}
for (int i = last; i < n; i++)
ans += a[i];
cout << ans << endl;
} | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath> //sqrt pow
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iostream> // cout, endl, cin
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
#define rep(i, n) for (int i = 0; i < n; i++)
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define mod 1000000007
using ll = long long;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vi a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
vector<pii> v(m);
rep(i, m) {
int b, c;
cin >> b >> c;
v[i] = make_pair(c, b);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int cnt = 0, last = n;
ll ans = 0;
rep(i, n) {
if (v[cnt].second <= 0)
cnt++;
if (cnt < m && v[cnt].first > a[i]) {
v[cnt].second--;
ans += v[cnt].first;
} else {
last = i;
break;
}
}
for (int i = last; i < n; i++)
ans += a[i];
cout << ans << endl;
} | replace | 32 | 33 | 32 | 33 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first < b.first;
}
}
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll b;
ll c;
sort(a.begin(), a.end());
vector<pair<ll, ll>> pairs;
for (int i = 0; i < m; i++) {
pair<ll, ll> mypair;
cin >> b;
cin >> c;
mypair = make_pair(b, c);
pairs.push_back(mypair);
}
sort(pairs.begin(), pairs.end(), compare_by_second);
/*for (int i = 0; i < m; i++)
{
cout << pairs[i].first << " " << pairs[i].second << endl;
}*/
vector<ll> changer(n);
for (int i = 0; i < n; i++) {
changer[i] = 0;
}
int index = 0;
int pair_index = 0;
while (index < n && pair_index < m) {
while (pairs[pair_index].first > 0) {
changer[index] = pairs[pair_index].second;
pairs[pair_index].first--;
index++;
}
pair_index++;
}
index = 0;
int index_changer = 0;
while (index < n && index_changer < n) {
if (a[index] < changer[index_changer]) {
a[index] = changer[index_changer];
index++;
index_changer++;
} else {
index++;
}
}
ll sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
cout << sum << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second != b.second) {
return a.second > b.second;
} else {
return a.first < b.first;
}
}
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll b;
ll c;
sort(a.begin(), a.end());
vector<pair<ll, ll>> pairs;
for (int i = 0; i < m; i++) {
pair<ll, ll> mypair;
cin >> b;
cin >> c;
mypair = make_pair(b, c);
pairs.push_back(mypair);
}
sort(pairs.begin(), pairs.end(), compare_by_second);
/*for (int i = 0; i < m; i++)
{
cout << pairs[i].first << " " << pairs[i].second << endl;
}*/
vector<ll> changer(n);
for (int i = 0; i < n; i++) {
changer[i] = 0;
}
int index = 0;
int pair_index = 0;
while (index < n && pair_index < m) {
while (pairs[pair_index].first > 0 && index < n) {
changer[index] = pairs[pair_index].second;
pairs[pair_index].first--;
index++;
}
pair_index++;
}
index = 0;
int index_changer = 0;
while (index < n && index_changer < n) {
if (a[index] < changer[index_changer]) {
a[index] = changer[index_changer];
index++;
index_changer++;
} else {
index++;
}
}
ll sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
cout << sum << endl;
} | replace | 59 | 60 | 59 | 60 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const ll dx[4] = {0, -1, 1, 0};
const ll dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
///////////////////////////////////////
int main() {
int N, M;
vector<int> V;
cin >> N >> M;
ll A[100100];
ll B[100100], C[100100];
for (int i = 0; i < N; ++i) {
cin >> A[i];
V.push_back(A[i]);
}
vector<pii> key;
for (int i = 0; i < M; ++i) {
cin >> B[i] >> C[i];
key.push_back({C[i], B[i]});
}
sort(key.begin(), key.end(), greater<pii>());
sort(V.begin(), V.end());
int x = 0;
for (int i = 0; i < M; ++i) {
int count = 0;
while (V[x] < key[i].first && count < key[i].second) {
V[x] = key[i].first;
count++;
x++;
}
}
ll sum = 0;
for (int i = 0; i < N; ++i) {
sum += V[i];
}
cout << sum << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const ll dx[4] = {0, -1, 1, 0};
const ll dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
///////////////////////////////////////
int main() {
int N, M;
vector<int> V;
cin >> N >> M;
ll A[100100];
ll B[100100], C[100100];
for (int i = 0; i < N; ++i) {
cin >> A[i];
V.push_back(A[i]);
}
vector<pii> key;
for (int i = 0; i < M; ++i) {
cin >> B[i] >> C[i];
key.push_back({C[i], B[i]});
}
sort(key.begin(), key.end(), greater<pii>());
sort(V.begin(), V.end());
int x = 0;
for (int i = 0; i < M; ++i) {
int count = 0;
while (V[x] < key[i].first && count < key[i].second) {
V[x] = key[i].first;
count++;
x++;
}
if (x >= N) {
break;
}
}
ll sum = 0;
for (int i = 0; i < N; ++i) {
sum += V[i];
}
cout << sum << endl;
return 0;
}
| insert | 61 | 61 | 61 | 64 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll, ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i, m, n) for (ll(i) = (m), (i_len) = (n); (i) < (i_len); ++(i))
#define FORR(i, v) for (auto(i) : v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) \
ASC((x)); \
REV((x))
#define pb push_back
#define eb emplace_back
int main() {
ll N, M;
cin >> N >> M;
vec A(N);
vector<pll> P(N);
REP(i, 0, N) cin >> A[i];
REP(i, 0, M) cin >> P[i].second >> P[i].first;
ASC(A);
DESC(P);
ll k = 0, l = 0;
while (l < N && k < M) {
bool f = true;
REP(i, 0, P[k].second) {
if (l + i >= N)
break;
if (A[l + i] < P[k].first)
A[l + i] = P[k].first;
else {
f = false;
l += i;
}
}
if (f)
l += P[k].second;
else
++l;
++k;
}
ll sum = 0;
REP(i, 0, N) sum += A[i];
PR(sum);
return 0;
}
/*
*/ | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll, ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i, m, n) for (ll(i) = (m), (i_len) = (n); (i) < (i_len); ++(i))
#define FORR(i, v) for (auto(i) : v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) \
ASC((x)); \
REV((x))
#define pb push_back
#define eb emplace_back
int main() {
ll N, M;
cin >> N >> M;
vec A(N);
vector<pll> P(M);
REP(i, 0, N) cin >> A[i];
REP(i, 0, M) cin >> P[i].second >> P[i].first;
ASC(A);
DESC(P);
ll k = 0, l = 0;
while (l < N && k < M) {
bool f = true;
REP(i, 0, P[k].second) {
if (l + i >= N)
break;
if (A[l + i] < P[k].first)
A[l + i] = P[k].first;
else {
f = false;
l += i;
}
}
if (f)
l += P[k].second;
else
++l;
++k;
}
ll sum = 0;
REP(i, 0, N) sum += A[i];
PR(sum);
return 0;
}
/*
*/ | replace | 32 | 33 | 32 | 33 | 0 | |
p03038 | C++ | Time Limit Exceeded | //
// じょえチャンネル
// 高評価・チャンネル登録よろしくお願いします！
// https://www.youtube.com/watch?v=gPFr7q7eLL8
//
/*------------------------------------
∧＿∧
∧＿∧ （´<_｀ ）
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
-------------------------------------*/
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define ll long long
#define ld long double
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define Rep(i, n) for (ll i = 1; i <= n; ++i)
#define loop(i, m, n) for (ll i = m; i < n; ++i)
#define rev(i, n) for (ll i = n - 1; i >= 0; --i)
#define ggr \
getchar(); \
getchar(); \
return 0;
#define pie 3.141592653589793238462643383279
#define elif else if
#define P pair<ll, ll>
#define prique priority_queue<ll>
#define all(a) (a).begin(), (a).end()
const int mod = 1000000007;
const int mod2 = 998244353;
const int inf = 1 << 30;
const int MOD = 1e9 + 7;
long long fac[510000], finv[510000], inv[510000];
long long MAX = 510000;
bool COMinited = false;
long long COM(int n, int k) {
if (COMinited == false) {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
COMinited = true;
}
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<1000000007>;
int bin(int bina) {
int ans = 0;
for (int i = 0; bina > 0; i++) {
ans = ans + (bina % 2) * pow(10, i);
bina = bina / 2;
}
return ans;
}
bool prime(int n) {
for (ll i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int mod_pow(int x, int y, int m) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int jo(int x, int y) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x;
}
x = x * x;
y >>= 1;
}
return res;
}
int per(int n, int r) {
r = n - r;
int sum = 1;
int i;
for (i = n; i >= r + 1; i--)
sum *= i;
return sum;
}
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
vector<pair<long long, long long>> prime_factorize(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
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;
}
// cout << fixed << setprecision(10) << num << endl;
struct edge {
int to, cost;
};
#define F first
#define S second
int a[100010];
P p[100010];
signed main() {
int n, m;
cin >> n >> m;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, m) cin >> p[i].S >> p[i].F;
sort(p, p + m, greater<>());
int iwa = 0;
rep(i, m) {
rep(j, p[i].S) {
if (iwa >= n)
break;
if (a[iwa] < p[i].F) {
a[iwa] = p[i].F;
iwa++;
}
}
}
int ans = 0;
rep(i, n) ans += a[i];
cout << ans << endl;
} | //
// じょえチャンネル
// 高評価・チャンネル登録よろしくお願いします！
// https://www.youtube.com/watch?v=gPFr7q7eLL8
//
/*------------------------------------
∧＿∧
∧＿∧ （´<_｀ ）
（ ´_ゝ`） / ⌒i
／ ＼ | |
/ /￣￣￣￣/ |
＿_(__ﾆつ/ ＿/ .| .|＿＿＿＿
＼/＿＿＿＿/ （u ⊃
-------------------------------------*/
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define ll long long
#define ld long double
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define Rep(i, n) for (ll i = 1; i <= n; ++i)
#define loop(i, m, n) for (ll i = m; i < n; ++i)
#define rev(i, n) for (ll i = n - 1; i >= 0; --i)
#define ggr \
getchar(); \
getchar(); \
return 0;
#define pie 3.141592653589793238462643383279
#define elif else if
#define P pair<ll, ll>
#define prique priority_queue<ll>
#define all(a) (a).begin(), (a).end()
const int mod = 1000000007;
const int mod2 = 998244353;
const int inf = 1 << 30;
const int MOD = 1e9 + 7;
long long fac[510000], finv[510000], inv[510000];
long long MAX = 510000;
bool COMinited = false;
long long COM(int n, int k) {
if (COMinited == false) {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
COMinited = true;
}
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<1000000007>;
int bin(int bina) {
int ans = 0;
for (int i = 0; bina > 0; i++) {
ans = ans + (bina % 2) * pow(10, i);
bina = bina / 2;
}
return ans;
}
bool prime(int n) {
for (ll i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return n != 1;
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i;
res %= mod;
}
return res;
}
int mod_pow(int x, int y, int m) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int jo(int x, int y) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x;
}
x = x * x;
y >>= 1;
}
return res;
}
int per(int n, int r) {
r = n - r;
int sum = 1;
int i;
for (i = n; i >= r + 1; i--)
sum *= i;
return sum;
}
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
vector<pair<long long, long long>> prime_factorize(long long n) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0) {
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
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;
}
// cout << fixed << setprecision(10) << num << endl;
struct edge {
int to, cost;
};
#define F first
#define S second
int a[100010];
P p[100010];
signed main() {
int n, m;
cin >> n >> m;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, m) cin >> p[i].S >> p[i].F;
sort(p, p + m, greater<>());
int iwa = 0;
rep(i, m) {
rep(j, p[i].S) {
if (iwa >= n)
break;
if (a[iwa] < p[i].F) {
a[iwa] = p[i].F;
iwa++;
} else
break;
}
}
int ans = 0;
rep(i, n) ans += a[i];
cout << ans << endl;
} | replace | 286 | 287 | 286 | 288 | TLE | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
vector<pair<int, int>> cb(m);
vector<long long> d(n);
for (int i = 0; i < m; ++i) {
int b, c;
cin >> b >> c;
cb[i].first = c;
cb[i].second = b;
}
sort(cb.begin(), cb.end(), greater<pair<int, int>>());
sort(a.begin(), a.end());
int tmp = 0;
for (int i = 0; cb.size() > i; ++i) {
for (int j = 0; j < cb[i].second; ++j) {
if (tmp < n)
d[tmp++] = cb[i].first;
}
}
long long ans = 0;
tmp = 0;
for (int i = 0; i < n; ++i) {
if (i <= d.size() && a[i] < d[tmp])
ans += d[tmp++];
else
ans += a[i];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
vector<pair<int, int>> cb(m);
vector<long long> d(n);
for (int i = 0; i < m; ++i) {
int b, c;
cin >> b >> c;
cb[i].first = c;
cb[i].second = b;
}
sort(cb.begin(), cb.end(), greater<pair<int, int>>());
sort(a.begin(), a.end());
int tmp = 0;
for (int i = 0; tmp < n && cb.size() > i; ++i) {
for (int j = 0; j < cb[i].second; ++j) {
if (tmp < n)
d[tmp++] = cb[i].first;
}
}
long long ans = 0;
tmp = 0;
for (int i = 0; i < n; ++i) {
if (i <= d.size() && a[i] < d[tmp])
ans += d[tmp++];
else
ans += a[i];
}
cout << ans << endl;
return 0;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> A;
for (int i = 0; i < N; i++) {
int tmp;
cin >> tmp;
A.push(tmp);
}
map<int, int, greater<int>> C;
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
C[c] += b;
}
for (auto c : C) {
// cout << c.first << " " << c.second << endl;
for (int i = 0; i < c.second; i++) {
if (A.top() < c.first) {
A.pop();
A.push(c.first);
}
}
}
ll output = 0;
for (int i = 0; i < N; i++) {
output += (ll)A.top();
A.pop();
// cout << A[i] << endl;
}
cout << output << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> A;
for (int i = 0; i < N; i++) {
int tmp;
cin >> tmp;
A.push(tmp);
}
map<int, int, greater<int>> C;
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
C[c] += b;
}
for (auto c : C) {
// cout << c.first << " " << c.second << endl;
for (int i = 0; i < c.second; i++) {
if (A.top() < c.first) {
A.pop();
A.push(c.first);
} else {
break;
}
}
}
ll output = 0;
for (int i = 0; i < N; i++) {
output += (ll)A.top();
A.pop();
// cout << A[i] << endl;
}
cout << output << endl;
return 0;
}
| insert | 40 | 40 | 40 | 42 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long int> a(n);
vector<pair<long int, long int>> cb(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
for (int i = 0; i < m; i++) {
long int b_tmp, c_tmp;
cin >> b_tmp >> c_tmp;
cb.at(i) = make_pair(c_tmp, b_tmp);
}
sort(a.rbegin(), a.rend());
sort(cb.rbegin(), cb.rend());
int j = 0;
int count = 0;
long int out = 0;
for (int i = 0; i < n; i++) {
if (count == n)
break;
while (a.at(i) <= cb.at(j).first & j < m) {
if (n - count - cb.at(j).second >= 0) {
out += cb.at(j).first * cb.at(j).second;
count += cb.at(j).second;
j++;
} else {
out += cb.at(j).first * (n - count);
count += n - count;
break;
}
}
if (count == n)
break;
count++;
out += a.at(i);
}
cout << out;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long int> a(n);
vector<pair<long int, long int>> cb(m);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
for (int i = 0; i < m; i++) {
long int b_tmp, c_tmp;
cin >> b_tmp >> c_tmp;
cb.at(i) = make_pair(c_tmp, b_tmp);
}
sort(a.rbegin(), a.rend());
sort(cb.rbegin(), cb.rend());
int j = 0;
int count = 0;
long int out = 0;
for (int i = 0; i < n; i++) {
if (count == n)
break;
if (j < m) {
while (a.at(i) <= cb.at(j).first) {
if (n - count - cb.at(j).second >= 0) {
out += cb.at(j).first * cb.at(j).second;
count += cb.at(j).second;
j++;
if (j == m)
break;
} else {
out += cb.at(j).first * (n - count);
count += n - count;
break;
}
}
}
if (count == n)
break;
count++;
out += a.at(i);
}
cout << out;
} | replace | 24 | 33 | 24 | 37 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl;
#define mdebug(m) \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void Ans(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
const int mod = 1000000007;
// const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
signed main() {
int N, M;
cin >> N >> M;
vec A(N);
cin >> A;
Sort(A);
int B, C;
pairs p(N);
REP(i, M) {
cin >> B >> C;
p[i] = Pii(C, B);
}
Sort(p);
Reverse(p);
int i0 = 0;
REP(i, M) {
bool f = false;
REP(j, p[i].s) {
if (i0 == N || A[i0] >= p[i].f) {
f = true;
break;
} else
A[i0++] = p[i].f;
}
if (f)
break;
}
int ans = 0;
REP(i, N) ans += A[i];
Out(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
cout << #v << "=" << endl; \
REP(i_debug, v.size()) { cout << v[i_debug] << ","; } \
cout << endl;
#define mdebug(m) \
cout << #m << "=" << endl; \
REP(i_debug, m.size()) { \
REP(j_debug, m[i_debug].size()) { cout << m[i_debug][j_debug] << ","; } \
cout << endl; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v)
is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1)
cout << endl;
};
return os;
}
template <typename T> void Out(T x) { cout << x << endl; }
template <typename T1, typename T2> void Ans(bool f, T1 y, T2 n) {
if (f)
Out(y);
else
Out(n);
}
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
// char d[4] = {'D','R','U','L'};
const int mod = 1000000007;
// const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
signed main() {
int N, M;
cin >> N >> M;
vec A(N);
cin >> A;
Sort(A);
int B, C;
pairs p(M);
REP(i, M) {
cin >> B >> C;
p[i] = Pii(C, B);
}
Sort(p);
Reverse(p);
int i0 = 0;
REP(i, M) {
bool f = false;
REP(j, p[i].s) {
if (i0 == N || A[i0] >= p[i].f) {
f = true;
break;
} else
A[i0++] = p[i].f;
}
if (f)
break;
}
int ans = 0;
REP(i, N) ans += A[i];
Out(ans);
return 0;
}
| replace | 87 | 88 | 87 | 88 | 0 | |
p03038 | C++ | Runtime Error | #define _GLIBCXX_DEBUG
#include <algorithm> //next_permutation
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define dec(n) cout << fixed << setprecision(n);
#define large "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define small "abcdefghijklmnopqrstuvwxyz"
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll MOD = 1000000007;
const ll MAX = 2000001;
ll mod(ll a) { return a % MOD; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
int main() {
ll n, m;
cin >> n >> m;
vl cardnum(n);
ll sum = 0;
rep(i, n) {
cin >> cardnum[i];
sum += cardnum[i];
}
sort(all(cardnum));
vector<pair<ll, ll>> change(m);
rep(i, m) {
ll a, b;
cin >> a >> b;
change[i] = make_pair(b, a);
}
sort(all(change));
reverse(all(change));
/*for(auto p : change){
cout << p.first << p.second;
}
for(ll x : cardnum){
cout << x;
}*/
ll nowcard = 0;
for (auto p : change) {
for (ll i = 0; i < p.second; i++) {
if (cardnum[nowcard] < p.first and nowcard != n) {
sum += p.first - cardnum[nowcard];
nowcard++;
} else {
cout << sum << endl;
return 0;
}
}
}
cout << sum << endl;
} | #define _GLIBCXX_DEBUG
#include <algorithm> //next_permutation
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define dec(n) cout << fixed << setprecision(n);
#define large "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define small "abcdefghijklmnopqrstuvwxyz"
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll MOD = 1000000007;
const ll MAX = 2000001;
ll mod(ll a) { return a % MOD; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
int main() {
ll n, m;
cin >> n >> m;
vl cardnum(n);
ll sum = 0;
rep(i, n) {
cin >> cardnum[i];
sum += cardnum[i];
}
sort(all(cardnum));
vector<pair<ll, ll>> change(m);
rep(i, m) {
ll a, b;
cin >> a >> b;
change[i] = make_pair(b, a);
}
sort(all(change));
reverse(all(change));
/*for(auto p : change){
cout << p.first << p.second;
}
for(ll x : cardnum){
cout << x;
}*/
ll nowcard = 0;
for (auto p : change) {
for (ll i = 0; i < p.second; i++) {
if (nowcard != n and cardnum[nowcard] < p.first) {
sum += p.first - cardnum[nowcard];
nowcard++;
} else {
cout << sum << endl;
return 0;
}
}
}
cout << sum << endl;
} | replace | 62 | 63 | 62 | 63 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <functional>
#include <queue>
#include <stdio.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
int main(void) {
ll i, j, n, m, now, ans = 0, t, a;
scanf("%lld%lld", &n, &m);
priority_queue<ll, vector<ll>, greater<ll>> p;
for (i = 0; i < n; ++i)
scanf("%lld", &a), p.push(a);
pair<ll, ll> b[m];
for (i = 0; i < m; ++i)
scanf("%lld%lld", &b[i].second, &b[i].first);
sort(b, b + m, greater<pair<ll, ll>>());
for (i = 0; i < m; ++i) {
for (j = 0; j < b[i].second; ++j) {
if (p.top() > b[i].first)
break;
p.pop(), ans += b[i].first;
}
}
while (p.size())
ans += p.top(), p.pop();
printf("%lld", ans);
return 0;
} | #include <algorithm>
#include <functional>
#include <queue>
#include <stdio.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
int main(void) {
ll i, j, n, m, now, ans = 0, t, a;
scanf("%lld%lld", &n, &m);
priority_queue<ll, vector<ll>, greater<ll>> p;
for (i = 0; i < n; ++i)
scanf("%lld", &a), p.push(a);
pair<ll, ll> b[m];
for (i = 0; i < m; ++i)
scanf("%lld%lld", &b[i].second, &b[i].first);
sort(b, b + m, greater<pair<ll, ll>>());
for (i = 0; i < m; ++i) {
for (j = 0; j < b[i].second && p.size(); ++j) {
if (p.top() > b[i].first)
break;
p.pop(), ans += b[i].first;
}
}
while (p.size())
ans += p.top(), p.pop();
printf("%lld", ans);
return 0;
} | replace | 20 | 21 | 20 | 21 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll, ll>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vll a(n);
REP(i, n) cin >> a[i];
VSORT(a);
vector<P> p;
ll b, c;
REP(i, m) {
cin >> b >> c;
p.push_back(P{c, b});
}
sort(p.rbegin(), p.rend());
vll d(2 * n + 10);
ll id = 0;
REP(i, m) {
c = p[i].first, b = p[i].second;
REP(j, b) d[id + j] = c;
id += b;
}
ll res = 0;
REP(i, n) res += max(a[i], d[i]);
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll, ll>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vll a(n);
REP(i, n) cin >> a[i];
VSORT(a);
vector<P> p;
ll b, c;
REP(i, m) {
cin >> b >> c;
p.push_back(P{c, b});
}
sort(p.rbegin(), p.rend());
vll d(2 * n + 10);
ll id = 0;
REP(i, m) {
c = p[i].first, b = p[i].second;
REP(j, b) d[id + j] = c;
id += b;
if (id >= n)
break;
}
ll res = 0;
REP(i, n) res += max(a[i], d[i]);
cout << res << endl;
return 0;
} | insert | 36 | 36 | 36 | 38 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define FOR(NAME, START, NUM) for (ll NAME = START; NAME < (NUM); NAME++)
#define REP(NAME, NUM) for (ll NAME = 0; NAME < (NUM); NAME++)
#define BREP(NAME, NUM) for (ll NAME = (NUM)-1; NAME >= 0; NAME--)
#define ALL(NAME) (NAME).begin(), (NAME).end()
const ll INF = 1000000000000000;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
REP(i, n) cin >> a[i];
vector<pair<ll, ll>> cb(n);
REP(i, m) {
cin >> cb.at(i).second;
cin >> cb.at(i).first;
}
sort(ALL(a));
sort(ALL(cb));
reverse(ALL(cb));
ll bsum = 0, x = 0;
REP(i, n) {
if (a.at(i) < cb.at(x).first)
a.at(i) = cb.at(x).first;
else {
bsum = i + 1;
x++;
continue;
}
if (cb.at(x).second - 1 + bsum == i) {
bsum += cb.at(x).second;
x++;
}
}
ll sum = 0;
REP(i, n) { sum += a[i]; }
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define FOR(NAME, START, NUM) for (ll NAME = START; NAME < (NUM); NAME++)
#define REP(NAME, NUM) for (ll NAME = 0; NAME < (NUM); NAME++)
#define BREP(NAME, NUM) for (ll NAME = (NUM)-1; NAME >= 0; NAME--)
#define ALL(NAME) (NAME).begin(), (NAME).end()
const ll INF = 1000000000000000;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
REP(i, n) cin >> a[i];
vector<pair<ll, ll>> cb(max(m, n));
REP(i, m) {
cin >> cb.at(i).second;
cin >> cb.at(i).first;
}
sort(ALL(a));
sort(ALL(cb));
reverse(ALL(cb));
ll bsum = 0, x = 0;
REP(i, n) {
if (a.at(i) < cb.at(x).first)
a.at(i) = cb.at(x).first;
else {
bsum = i + 1;
x++;
continue;
}
if (cb.at(x).second - 1 + bsum == i) {
bsum += cb.at(x).second;
x++;
}
}
ll sum = 0;
REP(i, n) { sum += a[i]; }
cout << sum << endl;
} | replace | 17 | 18 | 17 | 18 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#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<int> a(n);
vector<pair<int, int>> p(n);
rep(i, n) cin >> a[i];
rep(i, m) {
int b, c;
cin >> b >> c;
p[i] = make_pair(c, b);
}
sort(a.begin(), a.end());
sort(p.begin(), p.end(), greater<pair<int, int>>());
int j = 0;
rep(i, n) {
if (a[i] < p[j].first) {
a[i] = p[j].first;
p[j].second--;
if (p[j].second == 0) {
if (j < m - 1)
j++;
else
break;
}
} else {
break;
}
}
ll ans = 0;
rep(i, n) { ans += a[i]; }
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<pair<int, int>> p(m);
rep(i, n) cin >> a[i];
rep(i, m) {
int b, c;
cin >> b >> c;
p[i] = make_pair(c, b);
}
sort(a.begin(), a.end());
sort(p.begin(), p.end(), greater<pair<int, int>>());
int j = 0;
rep(i, n) {
if (a[i] < p[j].first) {
a[i] = p[j].first;
p[j].second--;
if (p[j].second == 0) {
if (j < m - 1)
j++;
else
break;
}
} else {
break;
}
}
ll ans = 0;
rep(i, n) { ans += a[i]; }
cout << ans << endl;
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), B(M), C(M);
vector<P> Q;
for (int s = 0; s < N; s++) {
cin >> A.at(s);
}
for (int t = 0; t < M; t++) {
cin >> B.at(t) >> C.at(t);
Q.push_back(P(C.at(t), B.at(t)));
}
sort(Q.begin(), Q.end());
reverse(Q.begin(), Q.end());
sort(A.begin(), A.end());
ll sum = 0, S = 0, T = 0;
int j = 0;
for (int i = 0; i < M; i++) {
S = Q.at(i).second;
T = Q.at(i).first;
if (A.at(j) > T || j >= N)
break;
while (S > 0) {
if (j < N && A.at(j) < T) {
A.at(j) = T;
S--;
} else
break;
j++;
}
}
for (int k = 0; k < N; k++) {
sum += A.at(k);
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N), B(M), C(M);
vector<P> Q;
for (int s = 0; s < N; s++) {
cin >> A.at(s);
}
for (int t = 0; t < M; t++) {
cin >> B.at(t) >> C.at(t);
Q.push_back(P(C.at(t), B.at(t)));
}
sort(Q.begin(), Q.end());
reverse(Q.begin(), Q.end());
sort(A.begin(), A.end());
ll sum = 0, S = 0, T = 0;
int j = 0;
for (int i = 0; i < M; i++) {
S = Q.at(i).second;
T = Q.at(i).first;
if (j >= N || A.at(j) > T)
break;
while (S > 0) {
if (j < N && A.at(j) < T) {
A.at(j) = T;
S--;
} else
break;
j++;
}
}
for (int k = 0; k < N; k++) {
sum += A.at(k);
}
cout << sum << endl;
return 0;
}
| replace | 39 | 40 | 39 | 40 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
ll MOD = 1000000000 + 7;
bool debug = 0;
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<int, int>> bc(m);
for (int i = 0; i < m; i++)
cin >> bc[i].second >> bc[i].first;
sort(a.begin(), a.end());
sort(bc.begin(), bc.end(), greater<pair<int, int>>());
int idx = 0;
for (int i = 0; i < m; i++) {
for (int j = idx; j < idx + bc[i].second; j++) {
if (a[j] < bc[i].first)
a[j] = bc[i].first;
}
idx += bc[i].second;
if (idx >= n)
break;
}
ll sum = 0;
for (int i = 0; i < n; i++)
sum += a[i];
cout << sum << endl;
}
int main() {
if (debug) {
while (true) {
cout << "********" << endl;
solve();
}
} else {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
ll MOD = 1000000000 + 7;
bool debug = 0;
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<pair<int, int>> bc(m);
for (int i = 0; i < m; i++)
cin >> bc[i].second >> bc[i].first;
sort(a.begin(), a.end());
sort(bc.begin(), bc.end(), greater<pair<int, int>>());
int idx = 0;
for (int i = 0; i < m; i++) {
for (int j = idx; j < idx + bc[i].second; j++) {
if (j >= n)
break;
if (a[j] < bc[i].first)
a[j] = bc[i].first;
}
idx += bc[i].second;
if (idx >= n)
break;
}
ll sum = 0;
for (int i = 0; i < n; i++)
sum += a[i];
cout << sum << endl;
}
int main() {
if (debug) {
while (true) {
cout << "********" << endl;
solve();
}
} else {
solve();
}
return 0;
} | insert | 22 | 22 | 22 | 24 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll count = 0;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> vec(M, pair<ll, ll>());
for (ll i = 0; i < N; i++)
cin >> A.at(i);
for (ll i = 0; i < M; i++)
cin >> vec.at(i).second >> vec.at(i).first;
sort(A.begin(), A.end());
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
ll ite = 0;
for (ll i = 0; i < M; i++) {
for (ll j = ite; vec.at(i).second > 0; j++) {
if (A.at(j) < vec.at(i).first) {
A.at(j) = vec.at(i).first;
vec.at(i).second--;
ite++;
} else {
for (ll k = 0; k < N; k++)
count += A.at(k);
cout << count << endl;
return 0;
}
}
}
for (ll i = 0; i < N; i++)
count += A.at(i);
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll count = 0;
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> vec(M, pair<ll, ll>());
for (ll i = 0; i < N; i++)
cin >> A.at(i);
for (ll i = 0; i < M; i++)
cin >> vec.at(i).second >> vec.at(i).first;
sort(A.begin(), A.end());
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
ll ite = 0;
for (ll i = 0; i < M; i++) {
for (ll j = ite; vec.at(i).second > 0 && j < N; j++) {
if (A.at(j) < vec.at(i).first) {
A.at(j) = vec.at(i).first;
vec.at(i).second--;
ite++;
} else {
for (ll k = 0; k < N; k++)
count += A.at(k);
cout << count << endl;
return 0;
}
}
}
for (ll i = 0; i < N; i++)
count += A.at(i);
cout << count << endl;
}
| replace | 25 | 26 | 25 | 26 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm> // sort
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map> // pair
#include <queue>
#include <string>
#include <vector>
#define ABS(x) ((x) > 0 ? (x) : -(x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
using namespace std;
unsigned long long int newton(long long int a, long long int b) {
if (a == b)
return a;
while (a != 0 && b != 0) {
if (a > b) {
b += a;
a = b - a;
b -= a;
}
b %= a;
}
return a;
}
struct UnionFind {
vector<int> p;
UnionFind(int N) : p(N) {
for (int i = 0; i < N; i++) {
p[i] = i;
}
}
int root(int x) {
if (p[x] == x)
return x;
return p[x] = root(p[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
p[rx] = ry;
}
bool issame(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main() {
int N, M;
vector<int> A;
// 値 個数
priority_queue<pair<int, int>> q;
cin >> N >> M;
int i, j, k;
for (i = 0; i < N; ++i) {
cin >> j;
A.push_back(j);
}
for (i = 0; i < M; ++i) {
cin >> j >> k;
q.push(make_pair(k, j));
}
sort(A.begin(), A.end());
int cur = 0;
int end = 0;
while (!q.empty()) {
j = q.top().first;
k = q.top().second;
q.pop();
for (i = 0; i < k; ++i) {
if (A[cur] < j) {
A[cur] = j;
++cur;
} else {
end = 1;
break;
}
}
if (end)
break;
}
unsigned long long int ans = 0;
for (i = 0; i < N; ++i) {
ans += A[i];
}
cout << ans << endl;
return 0;
}
| #include <algorithm> // sort
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map> // pair
#include <queue>
#include <string>
#include <vector>
#define ABS(x) ((x) > 0 ? (x) : -(x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
using namespace std;
unsigned long long int newton(long long int a, long long int b) {
if (a == b)
return a;
while (a != 0 && b != 0) {
if (a > b) {
b += a;
a = b - a;
b -= a;
}
b %= a;
}
return a;
}
struct UnionFind {
vector<int> p;
UnionFind(int N) : p(N) {
for (int i = 0; i < N; i++) {
p[i] = i;
}
}
int root(int x) {
if (p[x] == x)
return x;
return p[x] = root(p[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
p[rx] = ry;
}
bool issame(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main() {
int N, M;
vector<int> A;
// 値 個数
priority_queue<pair<int, int>> q;
cin >> N >> M;
int i, j, k;
for (i = 0; i < N; ++i) {
cin >> j;
A.push_back(j);
}
for (i = 0; i < M; ++i) {
cin >> j >> k;
q.push(make_pair(k, j));
}
sort(A.begin(), A.end());
int cur = 0;
int end = 0;
while (!q.empty()) {
j = q.top().first;
k = q.top().second;
q.pop();
for (i = 0; i < k; ++i) {
if (A[cur] < j) {
A[cur] = j;
++cur;
} else {
end = 1;
break;
}
if (cur == N) {
end = 1;
break;
}
}
if (end)
break;
}
unsigned long long int ans = 0;
for (i = 0; i < N; ++i) {
ans += A[i];
}
cout << ans << endl;
return 0;
}
| insert | 83 | 83 | 83 | 87 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.