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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
p03038 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define dump(x) cerr << #x << " = " << (x) << endl;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PLL;
const int INF =
1 << 29; // 十分大きい値にする, INT_MAX にしないのはオーバーフロー対策
void solve() {
const int MAX_N = 10000, MAX_M = 10000; // 最後に数字直す
int N, M;
priority_queue<LL, vector<LL>, greater<int>> A;
PLL BC[MAX_M + 1];
cin >> N >> M;
FOR(i, 0, N) {
LL tmp;
cin >> tmp;
A.push(tmp);
}
FOR(i, 0, M) { cin >> BC[i].first >> BC[i].second; }
sort(BC, BC + M, [](PLL &x, PLL &y) { return x.second > y.second; });
FOR(i, 0, M) {
int j = 0;
for (j = 0; j < BC[i].first; j++) {
if (A.top() < BC[i].second) {
A.pop();
A.push(BC[i].second);
} else {
break;
}
}
if (j == 0)
break;
}
LL ans = 0;
while (!A.empty()) {
ans += A.top();
A.pop();
}
cout << ans << endl;
}
int main(void) {
solve();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define dump(x) cerr << #x << " = " << (x) << endl;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PLL;
const int INF =
1 << 29; // 十分大きい値にする, INT_MAX にしないのはオーバーフロー対策
void solve() {
const int MAX_N = 100000, MAX_M = 100000; // 最後に数字直す
int N, M;
priority_queue<LL, vector<LL>, greater<int>> A;
PLL BC[MAX_M + 1];
cin >> N >> M;
FOR(i, 0, N) {
LL tmp;
cin >> tmp;
A.push(tmp);
}
FOR(i, 0, M) { cin >> BC[i].first >> BC[i].second; }
sort(BC, BC + M, [](PLL &x, PLL &y) { return x.second > y.second; });
FOR(i, 0, M) {
int j = 0;
for (j = 0; j < BC[i].first; j++) {
if (A.top() < BC[i].second) {
A.pop();
A.push(BC[i].second);
} else {
break;
}
}
if (j == 0)
break;
}
LL ans = 0;
while (!A.empty()) {
ans += A.top();
A.pop();
}
cout << ans << endl;
}
int main(void) {
solve();
return 0;
}
| replace | 22 | 23 | 22 | 23 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define eb emplace_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LLINF = 1e18;
const ll MOD = 1e9 + 7;
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 n, m;
ll a[100010];
vector<pli> v;
vector<ll> cand;
int main() {
cin >> n >> m;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, m) {
int b;
ll c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.begin(), v.end());
int cnt = 0;
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < v[i].second; j++) {
cand.push_back(v[i].first);
cnt++;
if (cnt >= n)
break;
}
}
ll ans = 0;
rep(i, n) { ans += max(a[i], cand[i]); }
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define eb emplace_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LLINF = 1e18;
const ll MOD = 1e9 + 7;
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 n, m;
ll a[100010];
vector<pli> v;
vector<ll> cand;
int main() {
cin >> n >> m;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, m) {
int b;
ll c;
cin >> b >> c;
v.push_back(make_pair(c, b));
}
sort(v.begin(), v.end());
int cnt = 0;
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < v[i].second; j++) {
cand.push_back(v[i].first);
cnt++;
if (cnt >= n)
break;
}
}
rep(i, n - cnt) cand.push_back(0);
ll ans = 0;
rep(i, n) { ans += max(a[i], cand[i]); }
cout << ans << endl;
}
| insert | 58 | 58 | 58 | 59 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
map<int, int> mp;
for (int i = 0; i < N; i++) {
mp[A[i]]++;
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
for (auto P : mp) {
pq.push(P);
}
for (int i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
int total = 0;
while (1) {
int num = pq.top().first;
int cnt = pq.top().second;
if (num >= C) {
break;
}
pq.pop();
if (total + cnt <= B) {
total += cnt;
} else {
pq.push(make_pair(num, cnt - (B - total)));
total = B;
break;
}
}
pq.push(make_pair(C, total));
}
long long ans = 0;
while (!pq.empty()) {
ans += (long long)pq.top().first * pq.top().second;
pq.pop();
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
map<int, int> mp;
for (int i = 0; i < N; i++) {
mp[A[i]]++;
}
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
for (auto P : mp) {
pq.push(P);
}
for (int i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
int total = 0;
while (1) {
if (pq.empty()) {
break;
}
int num = pq.top().first;
int cnt = pq.top().second;
if (num >= C) {
break;
}
pq.pop();
if (total + cnt <= B) {
total += cnt;
} else {
pq.push(make_pair(num, cnt - (B - total)));
total = B;
break;
}
}
pq.push(make_pair(C, total));
}
long long ans = 0;
while (!pq.empty()) {
ans += (long long)pq.top().first * pq.top().second;
pq.pop();
}
cout << ans << endl;
} | insert | 24 | 24 | 24 | 27 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repp(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define repm(i, n) for (int(i) = (n - 1); (i) >= 0; (i)--)
#define INF (1ll << 60)
typedef long long lint;
const lint MOD = 1000000007;
const lint MAX = 10000000;
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit() // 二項係数を求める時は前処理としてCOMinit()をする
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint 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;
}
}
// 二項係数計算
long long COM(lint n, lint k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num) {
if (num < 2)
return 0;
else if (num == 2)
return 1;
else if (num % 2 == 0)
return 0; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return 0;
}
}
// 素数である
return 1;
}
int main() {
lint N, M, ans = 0;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> A;
pair<lint, lint> x[M];
rep(i, N) {
int a;
cin >> a;
A.push(a);
}
rep(i, M) {
int a, b;
cin >> a >> b;
x[i] = make_pair(b, a);
}
sort(x, x + M);
rep(i, M) {
lint l, m;
tie(m, l) = x[i];
rep(j, l) {
if (A.top() < m) {
A.pop();
A.push(m);
} else
break;
}
}
rep(i, N) {
ans += A.top();
A.pop();
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repp(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define repm(i, n) for (int(i) = (n - 1); (i) >= 0; (i)--)
#define INF (1ll << 60)
typedef long long lint;
const lint MOD = 1000000007;
const lint MAX = 10000000;
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit() // 二項係数を求める時は前処理としてCOMinit()をする
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint 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;
}
}
// 二項係数計算
long long COM(lint n, lint k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num) {
if (num < 2)
return 0;
else if (num == 2)
return 1;
else if (num % 2 == 0)
return 0; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return 0;
}
}
// 素数である
return 1;
}
int main() {
lint N, M, ans = 0;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> A;
pair<lint, lint> x[M];
rep(i, N) {
int a;
cin >> a;
A.push(a);
}
rep(i, M) {
int a, b;
cin >> a >> b;
x[i] = make_pair(b, a);
}
sort(x, x + M, greater<pair<lint, lint>>());
rep(i, M) {
lint l, m;
tie(m, l) = x[i];
rep(j, l) {
if (A.top() < m) {
A.pop();
A.push(m);
} else
break;
}
}
rep(i, N) {
ans += A.top();
A.pop();
}
cout << ans;
} | replace | 68 | 69 | 68 | 69 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> que;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
que.push(a);
}
vector<pair<int, int>> v;
for (int i = 0; i < N; i++) {
int B, C;
cin >> B >> C;
v.push_back({C, B});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < M; i++) {
int B = v[i].second;
int C = v[i].first;
while (B--) {
if (C > que.top()) {
que.pop();
que.push(C);
} else {
break;
}
}
}
ll ans = 0;
while (!que.empty())
ans += que.top(), que.pop();
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
priority_queue<int, vector<int>, greater<int>> que;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
que.push(a);
}
vector<pair<int, int>> v;
for (int i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
v.push_back({C, B});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < M; i++) {
int B = v[i].second;
int C = v[i].first;
while (B--) {
if (C > que.top()) {
que.pop();
que.push(C);
} else {
break;
}
}
}
ll ans = 0;
while (!que.empty())
ans += que.top(), que.pop();
cout << ans << endl;
return 0;
} | replace | 16 | 17 | 16 | 17 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#include <cstdlib>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a.at(i);
vector<pair<ll, ll>> sousa;
rep(i, m) {
ll b, c;
cin >> b >> c;
sousa.push_back(make_pair(c, b));
}
sort(sousa.rbegin(), sousa.rend());
sort(a.begin(), a.end());
int count = 0;
int i = 0;
while (i < n) {
if (count >= m)
break;
ll b, c;
b = sousa.at(count).second;
c = sousa.at(count).first;
int change = 0;
while (a.at(i) < c && change < b) {
a.at(i) = c;
i++;
change++;
}
if (!change)
break;
count++;
}
ll ans = 0;
rep(i, n) ans += a.at(i);
cout << ans;
// rep(i,n) cout << a.at(i) << " ";
} | #include <bits/stdc++.h>
using namespace std;
#include <cstdlib>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a.at(i);
vector<pair<ll, ll>> sousa;
rep(i, m) {
ll b, c;
cin >> b >> c;
sousa.push_back(make_pair(c, b));
}
sort(sousa.rbegin(), sousa.rend());
sort(a.begin(), a.end());
int count = 0;
int i = 0;
while (i < n) {
if (count >= m)
break;
ll b, c;
b = sousa.at(count).second;
c = sousa.at(count).first;
int change = 0;
while (i < n && a.at(i) < c && change < b) {
a.at(i) = c;
i++;
change++;
}
if (!change)
break;
count++;
}
ll ans = 0;
rep(i, n) ans += a.at(i);
cout << ans;
// rep(i,n) cout << a.at(i) << " ";
} | replace | 35 | 36 | 35 | 36 | 0 | |
p03038 | C++ | Time Limit Exceeded | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// need
#include <algorithm>
#include <iostream>
// data structure
#include <bitset>
#include <complex>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// #include <deque>
#include <array>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
// stream
// #include <istream>
#include <sstream>
// #include <ostream>
#include <fstream>
// etc
#include <cassert>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <numeric>
#include <random>
// input
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T> void MACRO_VAR_Scan(T &t) { std::cin >> t; }
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &...rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
#define VEC_ROW(type, n, ...) \
std::vector<type> __VA_ARGS__; \
MACRO_VEC_ROW_Init(n, __VA_ARGS__); \
for (int w_ = 0; w_ < n; ++w_) { \
MACRO_VEC_ROW_Scan(w_, __VA_ARGS__); \
}
template <typename T> void MACRO_VEC_ROW_Init(int n, T &t) { t.resize(n); }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First &first, Rest &...rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T> void MACRO_VEC_ROW_Scan(int p, T &t) { std::cin >> t[p]; }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First &first, Rest &...rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(type, c, m, n) \
std::vector<std::vector<type>> c(m, std::vector<type>(n)); \
for (auto &R : c) \
for (auto &w : R) \
std::cin >> w;
// output
#define OUT(dist) std::cout << (dist);
#define FOUT(n, dist) std::cout << std::fixed << std::setprecision(n) << (dist);
#define SOUT(n, c, dist) std::cout << std::setw(n) << std::setfill(c) << (dist);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define ENDL std::cout << std::endl;
#define FLUSH std::cout << std::flush;
#define SHOW(dist) \
{ std::cerr << #dist << "\t:" << (dist) << "\n"; }
#define SHOWVECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOWVECTOR2(v) \
{ \
std::cerr << #v << "\t:\n"; \
for (const auto &xxx : v) { \
for (const auto &yyy : xxx) { \
std::cerr << yyy << " "; \
} \
std::cerr << "\n"; \
} \
}
#define SHOWQUEUE(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.front() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
// utility
#define ALL(a) (a).begin(), (a).end()
#define FOR(w, a, n) for (int w = (a); w < (n); ++w)
#define RFOR(w, a, n) for (int w = (n)-1; w >= (a); --w)
#define REP(w, n) for (int w = 0; w < int(n); ++w)
#define RREP(w, n) for (int w = int(n) - 1; w >= 0; --w)
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
#define EXCEPTION(msg) \
throw std::string("Exception : " msg " [ in ") + __func__ + " : " + \
std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) \
try { \
if (cond) \
EXCEPTION(msg); \
} catch (std::string s) { \
std::cerr << s << std::endl; \
}
// void CHECKTIME(std::function<void()> f) { auto start =
// std::chrono::system_clock::now(); f(); auto end =
// std::chrono::system_clock::now(); auto res =
// std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count();
// std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template <class T> using V = std::vector<T>;
template <class T> using VV = V<V<T>>;
template <typename S, typename T>
std::ostream &operator<<(std::ostream &os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
#define random_shuffle "USE std::shuffle!";
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = (1 << 30) - 1; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-10;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N> void FILL(T (&a)[N], const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T &val) {
for (auto &b : a)
FILL(b, val);
}
template <class T> void FILL(std::vector<T> &a, const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>> &a, const T &val) {
for (auto &b : a)
FILL(b, val);
}
// ------------>8------------------------------------->8------------
signed main() {
INIT;
VAR(int, n, m);
VEC(int, a, n);
VEC_ROW(int, m, b, c);
std::priority_queue<int> pq;
[&] {
V<PAIR> p(m);
REP(i, m) p[i] = PAIR(c[i], b[i]);
std::sort(ALL(p));
std::reverse(ALL(p));
int cnt = 0;
REP(i, m) {
REP(j, p[i].second) {
pq.push(p[i].first);
--cnt;
if (cnt == 0)
return;
}
}
}();
REP(i, n) pq.push(a[i]);
int ans = 0;
REP(i, n) {
ans += pq.top();
pq.pop();
}
OUT(ans) BR;
return 0;
} | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// need
#include <algorithm>
#include <iostream>
// data structure
#include <bitset>
#include <complex>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// #include <deque>
#include <array>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
// stream
// #include <istream>
#include <sstream>
// #include <ostream>
#include <fstream>
// etc
#include <cassert>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <numeric>
#include <random>
// input
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T> void MACRO_VAR_Scan(T &t) { std::cin >> t; }
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &...rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
#define VEC_ROW(type, n, ...) \
std::vector<type> __VA_ARGS__; \
MACRO_VEC_ROW_Init(n, __VA_ARGS__); \
for (int w_ = 0; w_ < n; ++w_) { \
MACRO_VEC_ROW_Scan(w_, __VA_ARGS__); \
}
template <typename T> void MACRO_VEC_ROW_Init(int n, T &t) { t.resize(n); }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First &first, Rest &...rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T> void MACRO_VEC_ROW_Scan(int p, T &t) { std::cin >> t[p]; }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First &first, Rest &...rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(type, c, m, n) \
std::vector<std::vector<type>> c(m, std::vector<type>(n)); \
for (auto &R : c) \
for (auto &w : R) \
std::cin >> w;
// output
#define OUT(dist) std::cout << (dist);
#define FOUT(n, dist) std::cout << std::fixed << std::setprecision(n) << (dist);
#define SOUT(n, c, dist) std::cout << std::setw(n) << std::setfill(c) << (dist);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define SPBR(w, n) std::cout << (w + 1 == n ? '\n' : ' ');
#define ENDL std::cout << std::endl;
#define FLUSH std::cout << std::flush;
#define SHOW(dist) \
{ std::cerr << #dist << "\t:" << (dist) << "\n"; }
#define SHOWVECTOR(v) \
{ \
std::cerr << #v << "\t:"; \
for (const auto &xxx : v) { \
std::cerr << xxx << " "; \
} \
std::cerr << "\n"; \
}
#define SHOWVECTOR2(v) \
{ \
std::cerr << #v << "\t:\n"; \
for (const auto &xxx : v) { \
for (const auto &yyy : xxx) { \
std::cerr << yyy << " "; \
} \
std::cerr << "\n"; \
} \
}
#define SHOWQUEUE(a) \
{ \
auto tmp(a); \
std::cerr << #a << "\t:"; \
while (!tmp.empty()) { \
std::cerr << tmp.front() << " "; \
tmp.pop(); \
} \
std::cerr << "\n"; \
}
// utility
#define ALL(a) (a).begin(), (a).end()
#define FOR(w, a, n) for (int w = (a); w < (n); ++w)
#define RFOR(w, a, n) for (int w = (n)-1; w >= (a); --w)
#define REP(w, n) for (int w = 0; w < int(n); ++w)
#define RREP(w, n) for (int w = int(n) - 1; w >= 0; --w)
#define IN(a, x, b) (a <= x && x < b)
template <class T> inline T CHMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class T> inline T CHMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
#define EXCEPTION(msg) \
throw std::string("Exception : " msg " [ in ") + __func__ + " : " + \
std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) \
try { \
if (cond) \
EXCEPTION(msg); \
} catch (std::string s) { \
std::cerr << s << std::endl; \
}
// void CHECKTIME(std::function<void()> f) { auto start =
// std::chrono::system_clock::now(); f(); auto end =
// std::chrono::system_clock::now(); auto res =
// std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count();
// std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
// test
template <class T> using V = std::vector<T>;
template <class T> using VV = V<V<T>>;
template <typename S, typename T>
std::ostream &operator<<(std::ostream &os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
#define random_shuffle "USE std::shuffle!";
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = (1 << 30) - 1; // 1.07x10^ 9
constexpr int INFINT_LIM = (1LL << 31) - 1; // 2.15x10^ 9
constexpr ll INFLL = 1LL << 60; // 1.15x10^18
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); // 9.22x10^18
constexpr double EPS = 1e-10;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N> void FILL(T (&a)[N], const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T &val) {
for (auto &b : a)
FILL(b, val);
}
template <class T> void FILL(std::vector<T> &a, const T &val) {
for (auto &x : a)
x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>> &a, const T &val) {
for (auto &b : a)
FILL(b, val);
}
// ------------>8------------------------------------->8------------
signed main() {
INIT;
VAR(int, n, m);
VEC(int, a, n);
VEC_ROW(int, m, b, c);
std::priority_queue<int> pq;
[&] {
V<PAIR> p(m);
REP(i, m) p[i] = PAIR(c[i], b[i]);
std::sort(ALL(p));
std::reverse(ALL(p));
int cnt = 0;
REP(i, m) {
REP(j, p[i].second) {
pq.push(p[i].first);
++cnt;
if (cnt >= n)
return;
}
}
}();
REP(i, n) pq.push(a[i]);
int ans = 0;
REP(i, n) {
ans += pq.top();
pq.pop();
}
OUT(ans) BR;
return 0;
} | replace | 207 | 209 | 207 | 209 | TLE | |
p03038 | C++ | Runtime Error |
/*****/
#include <algorithm>
#include <array>
#include <cmath>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
// #define int long long
using namespace std;
using ll = long long;
using ld = long double;
using vecll = vector<ll>;
template <class T> using pr = pair<T, T>;
template <class T> using vec = vector<T>;
#define nextline() (std::cerr << "\n")
#define debug(x) (#x " : " + (x))
#define debug_cout(x) (std::cerr << #x << " : " << (x) << "\n")
#define debug_tabcout(n, x) \
(std::cerr << strMulti("\t", n) << #x << " : " << (x) << "\n")
#define debug_headcout(h, x) (std::cerr << h << " : " << (x) << "\n")
#define debug_tabheadcout(n, h, x) \
(std::cerr << strMulti("\t", n) << h << " : " << (x) << "\n")
#define debugOut(a, b) \
(std::cerr << "(" << (a) << "," << (b) << ")" \
<< "\n")
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b)
constexpr int INF = 2000000100;
constexpr ll DIV = 1000000007; // 10e9+7
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T divup(T a, T b) {
if (a % b == 0) {
return a / b;
}
return a / b + 1;
}
std::string strMulti(std::string t, int n) {
std::string out = "";
for (int i = 0; i < n; i++) {
out += t;
}
return out;
}
template <class T> T math_P(T m, T n) {
T ret = 1;
for (T i = m; i > m - n; i--) {
ret *= i;
}
return ret;
}
template <class T> T math_C(T m, T n) {
T ret = mathP(m, n);
for (T i = 2; i <= n; i++) {
ret /= i;
}
return ret;
}
template <class T> bool compare_by_b(pair<T, T> a, pair<T, T> b) {
if (a.second != b.second) {
return a.second < b.second;
}
return a.first < b.first;
}
// template<class T> T math_gcd(T a, T b) { a = abs(a); b = abs(b); if (a < b) {
// std::swap(a, b); } T tmp; while (b != 0) { tmp = b; b = a % b; a = tmp; }
// return a; } template<class T> T math_lcm(T a, T b) { a = abs(a); b = abs(b);
// if (a > b) { std::swap(a, b); } if (a == 1) { return b; } T i = a; while (i %
// b != 0) { i += a; } return i; }
template <class T> T mod_pow(T x, T n, const T &p) {
T ret = 1;
while (n > 0) {
if (n & 1) {
(ret *= x) %= p;
}
(x *= x) %= p;
n >>= 1;
}
return ret;
}
/*****/
// ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
// ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
void Main() {
ll N, M;
cin >> N >> M;
vecll A(N);
rep(i, N) { cin >> A[i]; }
vec<pr<ll>> R(M);
rep(i, M) { cin >> R[i].second >> R[i].first; }
sort(all(A));
sort(all(R));
reverse(all(R));
ll update = 0;
for (int i = 0; i < M && update < N; i++) {
rep(_, R[i].second) {
if (R[i].first > A[update])
A[update] = R[i].first;
update++;
}
}
ll ret = 0;
rep(i, N) {
debug_cout(i);
debug_tabcout(1, A[i]);
ret += A[i];
}
cout << ret;
}
/*****/
int main() {
// std::ios::sync_with_stdio(false);
// std::cin.tie(0);
// std::cout << std::fixed << std::setprecision(10);
/*
while (true)
{
Main();
cout << endl;
}
//*/
Main();
return 0;
}
|
/*****/
#include <algorithm>
#include <array>
#include <cmath>
#include <iomanip> //cout << fixed << setprecision(桁数);
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
// #define int long long
using namespace std;
using ll = long long;
using ld = long double;
using vecll = vector<ll>;
template <class T> using pr = pair<T, T>;
template <class T> using vec = vector<T>;
#define nextline() (std::cerr << "\n")
#define debug(x) (#x " : " + (x))
#define debug_cout(x) (std::cerr << #x << " : " << (x) << "\n")
#define debug_tabcout(n, x) \
(std::cerr << strMulti("\t", n) << #x << " : " << (x) << "\n")
#define debug_headcout(h, x) (std::cerr << h << " : " << (x) << "\n")
#define debug_tabheadcout(n, h, x) \
(std::cerr << strMulti("\t", n) << h << " : " << (x) << "\n")
#define debugOut(a, b) \
(std::cerr << "(" << (a) << "," << (b) << ")" \
<< "\n")
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define all(x) (x).begin(), (x).end()
#define pair(a, b) make_pair(a, b)
constexpr int INF = 2000000100;
constexpr ll DIV = 1000000007; // 10e9+7
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T divup(T a, T b) {
if (a % b == 0) {
return a / b;
}
return a / b + 1;
}
std::string strMulti(std::string t, int n) {
std::string out = "";
for (int i = 0; i < n; i++) {
out += t;
}
return out;
}
template <class T> T math_P(T m, T n) {
T ret = 1;
for (T i = m; i > m - n; i--) {
ret *= i;
}
return ret;
}
template <class T> T math_C(T m, T n) {
T ret = mathP(m, n);
for (T i = 2; i <= n; i++) {
ret /= i;
}
return ret;
}
template <class T> bool compare_by_b(pair<T, T> a, pair<T, T> b) {
if (a.second != b.second) {
return a.second < b.second;
}
return a.first < b.first;
}
// template<class T> T math_gcd(T a, T b) { a = abs(a); b = abs(b); if (a < b) {
// std::swap(a, b); } T tmp; while (b != 0) { tmp = b; b = a % b; a = tmp; }
// return a; } template<class T> T math_lcm(T a, T b) { a = abs(a); b = abs(b);
// if (a > b) { std::swap(a, b); } if (a == 1) { return b; } T i = a; while (i %
// b != 0) { i += a; } return i; }
template <class T> T mod_pow(T x, T n, const T &p) {
T ret = 1;
while (n > 0) {
if (n & 1) {
(ret *= x) %= p;
}
(x *= x) %= p;
n >>= 1;
}
return ret;
}
/*****/
// ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
// ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
void Main() {
ll N, M;
cin >> N >> M;
vecll A(N);
rep(i, N) { cin >> A[i]; }
vec<pr<ll>> R(M);
rep(i, M) { cin >> R[i].second >> R[i].first; }
sort(all(A));
sort(all(R));
reverse(all(R));
ll update = 0;
for (int i = 0; i < M && update < N; i++) {
rep(_, R[i].second) {
if (R[i].first > A[update])
A[update] = R[i].first;
update++;
if (update >= N)
break;
}
}
ll ret = 0;
rep(i, N) {
debug_cout(i);
debug_tabcout(1, A[i]);
ret += A[i];
}
cout << ret;
}
/*****/
int main() {
// std::ios::sync_with_stdio(false);
// std::cin.tie(0);
// std::cout << std::fixed << std::setprecision(10);
/*
while (true)
{
Main();
cout << endl;
}
//*/
Main();
return 0;
}
| insert | 131 | 131 | 131 | 133 | 0 | i : 0
A[i] : 5
i : 1
A[i] : 4
i : 2
A[i] : 5
|
p03038 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <numeric>
#include <queue>
#include <regex>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool compare(const pair<long long, long long> &x,
const pair<long long, long long> &y) {
return x.second > y.second;
}
int main() {
int n, m;
vector<long long> a;
vector<pair<long long, long long>> bc;
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long a_;
cin >> a_;
a.push_back(a_);
}
sort(a.begin(), a.end());
for (int i = 0; i < m; i++) {
long long b_, c_;
cin >> b_ >> c_;
bc.push_back(make_pair(b_, c_));
}
sort(bc.begin(), bc.end(), compare);
int ai = 0;
int bci = 0;
long long ans = 0;
while (1) {
if (bci == m || a[ai] >= bc[bci].second)
break;
if (a[ai] < bc[bci].second && bc[bci].first > 0) {
ans += bc[bci].second;
ai++;
bc[bci].first--;
} else if (bc[bci].first == 0) {
bci++;
}
}
for (; ai < n; ai++) {
ans += a[ai];
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <numeric>
#include <queue>
#include <regex>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
bool compare(const pair<long long, long long> &x,
const pair<long long, long long> &y) {
return x.second > y.second;
}
int main() {
int n, m;
vector<long long> a;
vector<pair<long long, long long>> bc;
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long a_;
cin >> a_;
a.push_back(a_);
}
sort(a.begin(), a.end());
for (int i = 0; i < m; i++) {
long long b_, c_;
cin >> b_ >> c_;
bc.push_back(make_pair(b_, c_));
}
sort(bc.begin(), bc.end(), compare);
int ai = 0;
int bci = 0;
long long ans = 0;
while (1) {
if (bci == m || a[ai] >= bc[bci].second || ai == n)
break;
if (a[ai] < bc[bci].second && bc[bci].first > 0) {
ans += bc[bci].second;
ai++;
bc[bci].first--;
} else if (bc[bci].first == 0) {
bci++;
}
}
for (; ai < n; ai++) {
ans += a[ai];
}
cout << ans << endl;
return 0;
}
| replace | 44 | 45 | 44 | 45 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef long long int lli;
using namespace std;
typedef pair<int, int> ii;
#define int long long int
inline void swap(int &a, int &b) {
int tmp = a;
a = b;
b = tmp;
}
signed main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
int _a;
cin >> _a;
A[i] = _a;
}
sort(A.begin(), A.end());
vector<ii> BC;
for (int i = 0; i < M; i++) {
int _b, _c;
cin >> _b >> _c;
BC.push_back(ii(_b, _c));
}
sort(BC.begin(), BC.end(),
[](const ii &x, const ii &y) { return x.second > y.second; });
vector<int> C;
for (int i = 0; i < M; i++) {
for (int j = 0; j < BC[i].first && C.size() < N; j++) {
C.push_back(BC[i].second);
}
}
int total = 0;
for (int i = 0; i < N; i++) {
if (C.size() < N && A[i] < C[i])
total += C[i];
else
total += A[i];
}
cout << total << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef long long int lli;
using namespace std;
typedef pair<int, int> ii;
#define int long long int
inline void swap(int &a, int &b) {
int tmp = a;
a = b;
b = tmp;
}
signed main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
int _a;
cin >> _a;
A[i] = _a;
}
sort(A.begin(), A.end());
vector<ii> BC;
for (int i = 0; i < M; i++) {
int _b, _c;
cin >> _b >> _c;
BC.push_back(ii(_b, _c));
}
sort(BC.begin(), BC.end(),
[](const ii &x, const ii &y) { return x.second > y.second; });
vector<int> C;
for (int i = 0; i < M; i++) {
for (int j = 0; j < BC[i].first && C.size() < N; j++) {
C.push_back(BC[i].second);
}
}
int total = 0;
for (int i = 0; i < N; i++) {
if (i < C.size() && A[i] < C[i])
A[i] = C[i];
total += A[i];
}
cout << total << endl;
}
| replace | 51 | 55 | 51 | 54 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rp(i, k, n) for (int i = k; i < n; i++)
typedef long long ll;
typedef double ld;
ll mod = 1000000007ll;
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;
}
const ll inf = 1ll << 60;
int n, m;
vector<ll> A(101010);
vector<pair<ll, ll>> BC(101010);
int gcc(int n, int m) {
int a = max({n, m});
int b = min({n, m});
if (b == 0)
return a;
int c;
while (a % b != 0) {
c = a % b;
a = b;
b = c;
}
return b;
}
int main() {
scanf("%d%d", &n, &m);
rp(i, 0, n) { scanf("%lld", &A.at(i)); }
rp(i, 0, m) { scanf("%lld%lld", &BC.at(i).second, &BC.at(i).first); }
sort(A.begin(), A.begin() + n);
sort(BC.rbegin(), BC.rend());
int pointer = 0;
rp(i, 0, m) {
rp(j, 0, BC.at(i).second) {
if (A.at(pointer) < BC.at(i).first)
A.at(pointer) = BC.at(i).first;
pointer++;
}
if (pointer == n) {
ll ans = 0;
rp(i, 0, n) ans += A.at(i);
printf("%lld\n", ans);
return 0;
}
}
ll ans = 0;
rp(i, 0, n) ans += A.at(i);
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rp(i, k, n) for (int i = k; i < n; i++)
typedef long long ll;
typedef double ld;
ll mod = 1000000007ll;
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;
}
const ll inf = 1ll << 60;
int n, m;
vector<ll> A(101010);
vector<pair<ll, ll>> BC(101010);
int gcc(int n, int m) {
int a = max({n, m});
int b = min({n, m});
if (b == 0)
return a;
int c;
while (a % b != 0) {
c = a % b;
a = b;
b = c;
}
return b;
}
int main() {
scanf("%d%d", &n, &m);
rp(i, 0, n) { scanf("%lld", &A.at(i)); }
rp(i, 0, m) { scanf("%lld%lld", &BC.at(i).second, &BC.at(i).first); }
sort(A.begin(), A.begin() + n);
sort(BC.rbegin(), BC.rend());
int pointer = 0;
rp(i, 0, m) {
rp(j, 0, BC.at(i).second) {
if (A.at(pointer) < BC.at(i).first)
A.at(pointer) = BC.at(i).first;
pointer++;
if (pointer == n) {
ll ans = 0;
rp(i, 0, n) ans += A.at(i);
printf("%lld\n", ans);
return 0;
}
}
}
ll ans = 0;
rp(i, 0, n) ans += A.at(i);
printf("%lld\n", ans);
return 0;
} | replace | 55 | 61 | 55 | 61 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
const int maxn = 1e5 + 5;
int n, m, a[maxn];
struct Op {
int b, c;
bool operator<(Op b) const { return c > b.c; }
} p[maxn];
long long ans;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), ans += a[i];
for (int i = 1; i <= m; ++i)
scanf("%d %d", &p[i].b, &p[i].c);
std ::sort(a + 1, a + n + 1);
std ::sort(p + 1, p + m + 1);
for (int i = 1, j = 0; i <= m; ++i) {
while (p[i].b && a[j + 1] < p[i].c)
++j, --p[i].b, ans += p[i].c - a[j];
if (p[i].b)
break;
}
printf("%lld", ans);
return 0;
} | #include <algorithm>
#include <cstdio>
const int maxn = 1e5 + 5;
int n, m, a[maxn];
struct Op {
int b, c;
bool operator<(Op b) const { return c > b.c; }
} p[maxn];
long long ans;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), ans += a[i];
for (int i = 1; i <= m; ++i)
scanf("%d %d", &p[i].b, &p[i].c);
std ::sort(a + 1, a + n + 1);
std ::sort(p + 1, p + m + 1);
for (int i = 1, j = 0; i <= m; ++i) {
while (p[i].b && a[j + 1] < p[i].c && j < n)
++j, --p[i].b, ans += p[i].c - a[j];
if (p[i].b)
break;
}
printf("%lld", ans);
return 0;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p03038 | C++ | Runtime Error | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef map<int, int> mii;
typedef map<char, int> mci;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vii;
typedef vector<char> vc;
typedef vector<vc> vcc;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define in insert
#define sz(v) v.size()
#define mina(a, b) (a) = min((a), (b));
#define maxa(a, b) (a) = max((a), (b));
const int INF = 1e9 + 5;
void solve() {
int n, m;
cin >> n >> m;
vll v(n);
vii oper(m);
for (int i = 0; i < n; i++)
cin >> v[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
oper[i] = {(ll)b, a};
}
sort(all(v));
sort(rall(oper));
int cur = 0;
for (int i = 0; i < m; i++) {
// cout<<oper[i].S;
int curr = cur;
for (int j = curr; j < curr + oper[i].S; j++) {
// cout<<"/"<<j<<"/"<<endl;
if (v[j] < oper[i].F) {
// cout<<v[j]<<"->"<<oper[i].F<<endl;
v[j] = oper[i].F;
cur++;
} else
break;
}
}
ll sum = 0;
for (ll i : v)
sum += i;
cout << sum;
}
int main() {
int T = 1;
// cin>>T;
for (int i = 0; i < T; i++)
solve();
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef map<int, int> mii;
typedef map<char, int> mci;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vii;
typedef vector<char> vc;
typedef vector<vc> vcc;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define in insert
#define sz(v) v.size()
#define mina(a, b) (a) = min((a), (b));
#define maxa(a, b) (a) = max((a), (b));
const int INF = 1e9 + 5;
void solve() {
int n, m;
cin >> n >> m;
vll v(n);
vii oper(m);
for (int i = 0; i < n; i++)
cin >> v[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
oper[i] = {(ll)b, a};
}
sort(all(v));
sort(rall(oper));
int cur = 0;
for (int i = 0; i < m; i++) {
// cout<<oper[i].S;
int curr = cur;
for (int j = curr; j < min(curr + oper[i].S, n); j++) {
// cout<<"/"<<j<<"/"<<endl;
if (v[j] < oper[i].F) {
// cout<<v[j]<<"->"<<oper[i].F<<endl;
v[j] = oper[i].F;
cur++;
} else
break;
}
}
ll sum = 0;
for (ll i : v)
sum += i;
cout << sum;
}
int main() {
int T = 1;
// cin>>T;
for (int i = 0; i < T; i++)
solve();
} | replace | 43 | 44 | 43 | 44 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define boost \
ios::sync_with_stdio(0); \
cin.tie(0);
#define int long long
const int N = 2e5 + 10;
const int MOD = 1e9 + 7;
int32_t main() {
boost;
// code
int n, m, x, y;
cin >> n >> m;
int a[n];
vector<pair<int, int>> b;
multiset<int> st;
for (int i = 0; i < n; ++i) {
cin >> a[i];
st.insert(a[i]);
}
for (int i = 0; i < m; ++i) {
cin >> x >> y;
b.push_back({y, x});
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
int s = 0;
for (int i = 0; i < m; ++i) {
auto idx = st.lower_bound(b[i].first);
if (idx != st.begin()) {
while (*st.begin() < b[i].first and (b[i].second)--) {
st.erase(st.begin());
s += b[i].first;
}
} else {
break;
}
}
for (auto i : st) {
s += i;
}
cout << s;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define boost \
ios::sync_with_stdio(0); \
cin.tie(0);
#define int long long
const int N = 2e5 + 10;
const int MOD = 1e9 + 7;
int32_t main() {
boost;
// code
int n, m, x, y;
cin >> n >> m;
int a[n];
vector<pair<int, int>> b;
multiset<int> st;
for (int i = 0; i < n; ++i) {
cin >> a[i];
st.insert(a[i]);
}
for (int i = 0; i < m; ++i) {
cin >> x >> y;
b.push_back({y, x});
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
int s = 0;
for (int i = 0; i < m; ++i) {
auto idx = st.lower_bound(b[i].first);
if (idx != st.begin()) {
while (*st.begin() < b[i].first and (b[i].second)-- and !st.empty()) {
st.erase(st.begin());
s += b[i].first;
}
} else {
break;
}
}
for (auto i : st) {
s += i;
}
cout << s;
return 0;
}
| replace | 41 | 42 | 41 | 42 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, l, r, zero = 0, ans = 0, cur = 0;
cin >> n >> m;
vector<long long> a(n + 10);
vector<pair<long long, long long>> b(m + 10);
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (i = 0; i < n; i++) {
a[i] = a[i + 10];
}
for (i = 0; i < m; i++) {
cin >> b[i].second >> b[i].first;
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
i = 0;
while (cur < n && i < n) {
b[i].second = min(b[i].second, n - cur);
for (j = 0; j < b[i].second; j++) {
a[cur] = max(a[cur], b[i].first);
cur++;
}
i++;
}
for (i = 0; i < n; i++) {
ans += a[i];
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, l, r, zero = 0, ans = 0, cur = 0;
cin >> n >> m;
vector<long long> a(n + 10);
vector<pair<long long, long long>> b(m + 10);
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (i = 0; i < n; i++) {
a[i] = a[i + 10];
}
for (i = 0; i < m; i++) {
cin >> b[i].second >> b[i].first;
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
i = 0;
while (cur < n && i < m) {
b[i].second = min(b[i].second, n - cur);
for (j = 0; j < b[i].second; j++) {
a[cur] = max(a[cur], b[i].first);
cur++;
}
i++;
}
for (i = 0; i < n; i++) {
ans += a[i];
}
cout << ans;
return 0;
}
| replace | 22 | 23 | 22 | 23 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll) INF *INF
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (n); i++)
#define loop(i, a, n) for (int i = a; i < (n); i++)
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vp;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
signed main(void) {
int n, m;
cin >> n >> m;
vi a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vp v(m);
rep(i, m) cin >> v[i].second >> v[i].first;
sort(all(v));
reverse(all(v));
int ind = 0;
rep(i, m) {
// cout << v[i].first << " " << v[i].second << endl;
rep(j, v[i].second) {
if (ind < n)
a[ind] = max(a[ind], v[i].first), ind++;
}
}
int ans = 0;
rep(i, n) ans += a[i];
cout << ans << endl;
}
| #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define LINF (ll) INF *INF
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (n); i++)
#define loop(i, a, n) for (int i = a; i < (n); i++)
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
#define int ll //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vp;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
signed main(void) {
int n, m;
cin >> n >> m;
vi a(n);
rep(i, n) cin >> a[i];
sort(all(a));
vp v(m);
rep(i, m) cin >> v[i].second >> v[i].first;
sort(all(v));
reverse(all(v));
int ind = 0;
rep(i, m) {
// cout << v[i].first << " " << v[i].second << endl;
rep(j, v[i].second) {
if (ind < n)
a[ind] = max(a[ind], v[i].first), ind++;
else {
i = m;
break;
}
}
}
int ans = 0;
rep(i, n) ans += a[i];
cout << ans << endl;
}
| insert | 60 | 60 | 60 | 64 | TLE | |
p03038 | C++ | Runtime Error |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ll n, m;
cin >> n >> m;
ll arr[n + 1];
for (ll i = 0; i < n; i++)
cin >> arr[i];
map<ll, ll> mp;
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
mp[b] += a;
}
sort(arr, arr + n);
for (ll i = 0; i < n; i++) {
auto it = mp.end();
it--;
if (it->first > arr[i]) {
arr[i] = it->first;
it->second--;
if (it->second == 0) {
mp.erase(it->first);
}
}
// cout<<arr[i]<<" ";
} // cout<<endl;
ll ans = 0;
for (ll i = 0; i < n; i++)
ans += arr[i];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ll n, m;
cin >> n >> m;
ll arr[n + 1];
for (ll i = 0; i < n; i++)
cin >> arr[i];
map<ll, ll> mp;
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
mp[b] += a;
}
sort(arr, arr + n);
for (ll i = 0; i < n; i++) {
auto it = mp.end();
if (mp.size() == 0)
continue;
it--;
if (it->first > arr[i]) {
arr[i] = it->first;
it->second--;
if (it->second == 0) {
mp.erase(it->first);
}
}
// cout<<arr[i]<<" ";
} // cout<<endl;
ll ans = 0;
for (ll i = 0; i < n; i++)
ans += arr[i];
cout << ans << endl;
}
| insert | 29 | 29 | 29 | 31 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
template <class T> void vin(vector<T> &v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) cin >> A[i];
vector<pair<ll, ll>> cb(N);
rep(i, M) {
ll b, c;
cin >> b >> c;
cb[i] = {c, b};
}
sort(cb.rbegin(), cb.rend());
sort(A.begin(), A.end());
int cur = 0, used = 0;
rep(i, N) {
if (cb[cur].second == used) {
used = 0;
cur++;
}
if (cur < M and A[i] < cb[cur].first) {
used++;
A[i] = cb[cur].first;
} else {
break;
}
}
ll ans = 0;
rep(i, N) ans += A[i];
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
template <class T> void vin(vector<T> &v, int n) {
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
}
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) cin >> A[i];
vector<pair<ll, ll>> cb(M);
rep(i, M) {
ll b, c;
cin >> b >> c;
cb[i] = {c, b};
}
sort(cb.rbegin(), cb.rend());
sort(A.begin(), A.end());
int cur = 0, used = 0;
rep(i, N) {
if (cb[cur].second == used) {
used = 0;
cur++;
}
if (cur < M and A[i] < cb[cur].first) {
used++;
A[i] = cb[cur].first;
} else {
break;
}
}
ll ans = 0;
rep(i, N) ans += A[i];
cout << ans << endl;
return 0;
}
| replace | 19 | 20 | 19 | 20 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
/*
1, 2, 3
2, 5
5, 2, 3 = 10
2, 5, 3 = 10
*/
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
REP(i, 0, N) cin >> A[i];
vector<pair<int, int>> CB(M);
REP(i, 0, M) cin >> CB[i].second >> CB[i].first;
sort(ALL(A), greater<int>());
sort(ALL(CB), greater<pair<int, int>>());
ll ans = 0;
int ai = 0, cbi = 0;
REP(i, 0, N) {
if (A[ai] > CB[cbi].first) {
ans += A[ai++];
} else {
ans += CB[cbi].first;
CB[cbi].second--;
if (CB[cbi].second == 0)
cbi++;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
/*
1, 2, 3
2, 5
5, 2, 3 = 10
2, 5, 3 = 10
*/
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
REP(i, 0, N) cin >> A[i];
vector<pair<int, int>> CB(M);
REP(i, 0, M) cin >> CB[i].second >> CB[i].first;
sort(ALL(A), greater<int>());
sort(ALL(CB), greater<pair<int, int>>());
ll ans = 0;
int ai = 0, cbi = 0;
REP(i, 0, N) {
if (cbi == M || A[ai] > CB[cbi].first) {
ans += A[ai++];
} else {
ans += CB[cbi].first;
CB[cbi].second--;
if (CB[cbi].second == 0)
cbi++;
}
}
cout << ans << endl;
return 0;
} | replace | 29 | 30 | 29 | 30 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
priority_queue<ll> pq;
for (int i = 0; i < n; i++) {
ll a;
cin >> a;
pq.push(a);
}
vector<pair<ll, ll>> b(m);
for (int i = 0; i < m; i++) {
cin >> b[i].second >> b[i].first;
}
sort(b.rbegin(), b.rend());
ll now = 0;
for (ll i = 0; i < m; i++) {
for (ll j = 0; j < b[i].second; j++) {
pq.push(b[i].first);
if (++now == n)
break;
}
}
ll ret = 0;
for (int i = 0; i < n; i++) {
ret += pq.top();
pq.pop();
}
cout << ret << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
priority_queue<ll> pq;
for (int i = 0; i < n; i++) {
ll a;
cin >> a;
pq.push(a);
}
vector<pair<ll, ll>> b(m);
for (int i = 0; i < m; i++) {
cin >> b[i].second >> b[i].first;
}
sort(b.rbegin(), b.rend());
ll now = 0;
for (ll i = 0; i < m; i++) {
for (ll j = 0; j < b[i].second; j++) {
pq.push(b[i].first);
if (++now == n)
break;
}
if (now == n)
break;
}
ll ret = 0;
for (int i = 0; i < n; i++) {
ret += pq.top();
pq.pop();
}
cout << ret << endl;
}
| insert | 25 | 25 | 25 | 27 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define irep(i, a, b) for (ll i = ll(a); i >= ll(b); i--)
using ll = long long;
using namespace std;
ll n, m, sum = 0;
ll a[110000];
pair<ll, ll> x[110000];
int main() {
cin >> n >> m;
ll ps1 = 0, ps2 = m - 1; // 降順ソート出来ればps2=0
rep(i, 0, n) {
cin >> a[i];
sum += a[i];
}
rep(i, 0, m) cin >> x[i].second >> x[i].first;
sort(x, x + m);
// sort(x,x+m,greater<ll>());これでコンパイルエラー;;
// ８行目をvector<pair>>x;にして sort(x.rbegin(),x.rend());でセグフォ;;
sort(a, a + n);
bool p = true;
while (p) {
if (x[ps2].first > a[ps1] && x[ps2].second > 0) {
sum += x[ps2].first - a[ps1];
ps1++;
x[ps2].second--;
} else if (x[ps2].first <= a[ps1])
p = false;
else if (x[ps2].second == 0)
ps2--; // 降順ソート出来たらps2++;の予定だった..
}
cout << sum;
}
| #include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define irep(i, a, b) for (ll i = ll(a); i >= ll(b); i--)
using ll = long long;
using namespace std;
ll n, m, sum = 0;
ll a[110000];
pair<ll, ll> x[110000];
int main() {
cin >> n >> m;
ll ps1 = 0, ps2 = m - 1; // 降順ソート出来ればps2=0
rep(i, 0, n) {
cin >> a[i];
sum += a[i];
}
rep(i, 0, m) cin >> x[i].second >> x[i].first;
sort(x, x + m);
// sort(x,x+m,greater<ll>());これでコンパイルエラー;;
// ８行目をvector<pair>>x;にして sort(x.rbegin(),x.rend());でセグフォ;;
sort(a, a + n);
bool p = true;
while (p && ps2 >= 0 && ps1 < n) {
if (x[ps2].first > a[ps1] && x[ps2].second > 0) {
sum += x[ps2].first - a[ps1];
ps1++;
x[ps2].second--;
} else if (x[ps2].first <= a[ps1])
p = false;
else if (x[ps2].second == 0)
ps2--; // 降順ソート出来たらps2++;の予定だった..
}
cout << sum;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define swap(a, b) \
do { \
typeof(a) __tmp = (a); \
(a) = (b); \
(b) = __tmp; \
} while (0)
#define repd(i, a, b) for (typeof(b) i = a; i < (b); ++i)
#define rep(i, n) repd(i, 0, n)
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) cerr << "L" << __LINE__ << ": " << #x << " = " << (x) << endl
#define YesNo(x) cout << ((x) ? "Yes" : "No") << endl
#define YESNO(x) cout << ((x) ? "YES" : "NO") << endl
#define absi(x) (((x) >= 0) ? (x) : (-(x)))
#define pr(v) \
for (auto x : v) \
cerr << x << " "; \
cerr << endl;
bool f(pair<ll, ll> a, pair<ll, ll> b) {
return a.second == b.second ? a.first >= b.first : a.second > b.second;
}
int main(int argc, const char *argv[]) {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
vector<pair<ll, ll>> bc(m);
rep(i, n) { cin >> a.at(i); }
rep(i, m) { cin >> bc[i].first >> bc[i].second; }
sort(bc.begin(), bc.end(), f);
vector<ll> d;
rep(i, m) {
vector<ll> tmp(bc[i].first, bc[i].second);
d.insert(d.end(), tmp.begin(), tmp.end());
if (n <= d.size())
break;
}
d.insert(d.end(), a.begin(), a.end());
sort(d.begin(), d.end(), greater<ll>());
ll ret = 0;
rep(i, n) { ret += d[i]; }
cout << ret << endl;
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define swap(a, b) \
do { \
typeof(a) __tmp = (a); \
(a) = (b); \
(b) = __tmp; \
} while (0)
#define repd(i, a, b) for (typeof(b) i = a; i < (b); ++i)
#define rep(i, n) repd(i, 0, n)
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) cerr << "L" << __LINE__ << ": " << #x << " = " << (x) << endl
#define YesNo(x) cout << ((x) ? "Yes" : "No") << endl
#define YESNO(x) cout << ((x) ? "YES" : "NO") << endl
#define absi(x) (((x) >= 0) ? (x) : (-(x)))
#define pr(v) \
for (auto x : v) \
cerr << x << " "; \
cerr << endl;
bool f(pair<ll, ll> a, pair<ll, ll> b) { return (a.second > b.second); }
int main(int argc, const char *argv[]) {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
vector<pair<ll, ll>> bc(m);
rep(i, n) { cin >> a.at(i); }
rep(i, m) { cin >> bc[i].first >> bc[i].second; }
sort(bc.begin(), bc.end(), f);
vector<ll> d;
rep(i, m) {
vector<ll> tmp(bc[i].first, bc[i].second);
d.insert(d.end(), tmp.begin(), tmp.end());
if (n <= d.size())
break;
}
d.insert(d.end(), a.begin(), a.end());
sort(d.begin(), d.end(), greater<ll>());
ll ret = 0;
rep(i, n) { ret += d[i]; }
cout << ret << endl;
return 0;
}
| replace | 25 | 28 | 25 | 26 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct var {
int b, c;
var(int x, int y) { b = x, c = y; }
};
struct cmp {
bool operator()(var a, var b) { return a.c < b.c; }
};
priority_queue<var, vector<var>, cmp> q;
vector<int> v;
int main() {
freopen("inp", "r", stdin);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
// cout<<v[0]<<endl;
for (int i = 1; i <= m; ++i) {
int b, c;
cin >> b >> c;
q.push(var(b, c));
}
long long s = 0ll;
int b = q.top().b, c = q.top().c, i = 0;
q.pop();
for (; i < (int)v.size(); ++i) {
if ((q.empty() && b == 0) || v[i] > c)
break;
else if (b == 0)
b = q.top().b, c = q.top().c, q.pop();
s = s + max(v[i], c);
--b;
}
for (; i < (int)v.size(); ++i)
s += v[i];
cout << s << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct var {
int b, c;
var(int x, int y) { b = x, c = y; }
};
struct cmp {
bool operator()(var a, var b) { return a.c < b.c; }
};
priority_queue<var, vector<var>, cmp> q;
vector<int> v;
int main() {
// freopen("inp","r",stdin);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
// cout<<v[0]<<endl;
for (int i = 1; i <= m; ++i) {
int b, c;
cin >> b >> c;
q.push(var(b, c));
}
long long s = 0ll;
int b = q.top().b, c = q.top().c, i = 0;
q.pop();
for (; i < (int)v.size(); ++i) {
if ((q.empty() && b == 0) || v[i] > c)
break;
else if (b == 0)
b = q.top().b, c = q.top().c, q.pop();
s = s + max(v[i], c);
--b;
}
for (; i < (int)v.size(); ++i)
s += v[i];
cout << s << endl;
return 0;
}
| replace | 16 | 17 | 16 | 17 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
using vvvi = vector<vvi>;
using ll = long long; // long longをllだけにした
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using mii = map<int, int>;
long long divup(long long a, long long b);
long long kaijou(long long i);
long long P(long long n, long long k);
long long C(long long n, long long k);
long long GCD(long long a, long long b);
long long LCM(long long a, long long b);
bool prime(long long N);
double distance(vector<long long> p, vector<long long> q, long long n);
void press(vector<long long> &v);
void ranking(vector<long long> &v);
void erase(vector<long long> &v, long long i);
void unique(vector<long long> &v);
void printv(vector<long long> v);
vector<ll> keta(ll x);
long long modpow(long long a, long long n, long long mod);
long long modinv(long long a, long long mod);
// 20200416
vector<long long> inputv(long long n);
//////////////////////////////////////////////////////
// 端数繰りあがり割り算(検証済)
// a÷bの端数繰り上げ
// b!=0のデバグはしてないので分母に0を入れないように
// 負数対応
long long divup(long long a, long long b) {
long long x = abs(a);
long long y = abs(b);
long long z = (x + y - 1) / y;
if ((a < 0 && b > 0) || (a > 0 && b < 0))
return -z;
else if (a == 0)
return 0;
else
return z;
}
// 階乗
// 検証済み
long long kaijou(long long i) {
if (i == 0)
return 1;
long long j = 1;
for (long long k = 1; k <= i; k++) {
j *= k;
}
return j;
}
// 順列nPk(完成)
// n個の異なる要素から、取り出す順序を区別してk個取り出す場合の数
// n<kなら0を返す
// 敢えて負数時のデバグはしてない
long long P(long long n, long long k) {
if (n < k)
return 0;
long long y = 1;
for (long long i = 0; i < k; i++) {
y *= (n - i);
}
return y;
}
// 組み合わせnCk(検証済み)
// P,kaijouと併用
long long C(long long n, long long k) {
if (n < k)
return 0;
return P(n, k) / kaijou(k);
}
// nHk
// 区別しないn個の要素を、区別するk個のグループに分ける
// 0個のグループがあっ
// て良い
// C必須
// 最大公約数GCD,最小公倍数LCM
// LCMを使うときはGCDをセットで
// 検証済み
long long GCD(long long a, long long b) {
if (a < b)
swap(a, b);
long long d = a % b;
if (d == 0) {
return b;
}
return GCD(b, d);
}
long long LCM(long long a, long long b) { return (a / GCD(a, b)) * b; }
// 素数判定
// 素数ならばtrue、素数以外の整数にはfalse
// 負数は全てfalse
// 検証済み
bool prime(long long N) {
if (N == 1) {
return false;
}
if (N < 0)
return false;
long long p = sqrt(N);
for (long long i = 2; i <= p; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
// ユークリッド距離
// 検証済み
// 位置ベクトル1,位置ベクトル2,ベクトルの次元(2または3が一般的)
double distance(vector<long long> p, vector<long long> q, long long n) {
double x = 0;
for (long long i = 0; i < n; i++) {
x += pow((p.at(i) - q.at(i)), 2);
}
return sqrt(x);
}
// 配列圧縮(検証済)
//{1,36,1,3,8,-2,-92}を
//{2, 5,2,3,4, 1, 0}にする
void press(vector<long long> &v) {
long long n = v.size();
vector<long long> w(n);
map<long long, long long> m;
for (auto &p : v) {
m[p] = 0;
}
long long i = 0;
for (auto &p : m) {
p.second = i;
i++;
}
for (long long i = 0; i < n; i++) {
w.at(i) = m[v.at(i)];
}
v = w;
return;
}
// 配列のi番目の要素がj番目に小さいとき、j番目の数がiであるベクトルを返す関数
// 配列の要素が全て異なるときにしか正常に動作しない
// 配列の要素に同じものが含まれても見かけ上動作はするが意味のない値を戻し、
// エラーも起きないので注意
// 検証済
//{2,4,1,6,0,3,8,9,5}を
//{4,2,0,5,1,8,3,6,7}にして返す
//"rank"という名前にするとSTLの関数(配列の次元を返す関数)になるので注意
void ranking(vector<long long> &v) {
long long n = v.size();
map<long long, long long> m;
long long i;
for (i = 0; i < n; i++) {
m[v.at(i)] = i;
}
vector<long long> w(n);
i = 0;
for (auto &p : m) {
v.at(i) = p.second;
i++;
}
return;
}
// 部分削除(未検証)
// ベクトルのi番目(i=0,1,2,...,n-1)の要素を削除し、
// 以降の要素を全て前に1ずらして参照返し
// ベクトル長は1小さくなって返る
// i>n-1の時は変化しない
void erase(vector<long long> &v, long long i) {
long long n = v.size();
if (i > n - 1)
return;
for (long long j = i; j < n - 1; j++) {
v.at(j) = v.at(j + 1);
}
v.pop_back();
return;
}
// 重複削除(未完成)
// 引数ベクトルに同一要素が複数あるとき、先頭を残し他は削除
// 参照返し
// ベクトル長も変化する
// O(logn)くらい
void unique(vector<long long> &v) {
long long n = v.size();
set<long long> s;
long long i = 0;
while (i < n) {
if (s.count(v.at(i))) {
erase(v, i);
n--;
} else {
s.insert(v.at(i));
i++;
}
}
return;
}
// ベクトルの出力(検証済)
// debug用にvectorの中身を出力する
void printv(vector<long long> v) {
cout << "{ ";
for (auto &p : v) {
cout << p << ",";
}
cout << "}" << endl;
}
// 10進法でn桁の整数xに対して、大きい方の位から、その位の1桁の数字を
// 収納した長さnのベクトルを返す
// 0に対しては{0}を返す
// 検証済み
vector<ll> keta(ll x) {
if (x == 0)
return {0};
ll n = log10(x) + 1; // xの桁数
vll w(n, 0);
for (ll i = 0; i < n; i++) {
ll p;
p = x % 10;
x = x / 10;
w[n - 1 - i] = p;
}
return w;
}
// 20200415
// a^n mod を計算する
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;
}
// a^{-1} mod を計算する
// modとaが互いに素のときのみ有効(数学的に逆元が一意に定まるのがそのときのみ)
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
// 整数n個の入力を受け取ってベクトルに突っ込んで返す
// チェック済み
vector<long long> inputv(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
//////////////////////////////////////////////////
long long modC(long long n, long long k, long long MOD) {
long long p = 1, q = 1;
for (long long i = 0; i < k; i++) {
p = (n - i) * p % MOD;
q = (i + 1) * q % MOD;
}
return p * modinv(q, MOD) % MOD;
}
int main() {
ll n, m;
cin >> n >> m;
auto a = inputv(n);
vector<pair<ll, ll>> v(m);
rep(i, m) { cin >> v[i].second >> v[i].first; }
sort(all(a));
sort(all(v));
reverse(all(v));
vll c(n, 0);
ll i = 0;
ll k = 0;
while (i < n && k < m) {
rep(j, v[k].second) {
c[i] = v[k].first;
i++;
}
k++;
}
// printv(c);
ll cnt = 0;
rep(i, n) { cnt += max(c[i], a[i]); }
cout << cnt << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
using vvvi = vector<vvi>;
using ll = long long; // long longをllだけにした
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using mii = map<int, int>;
long long divup(long long a, long long b);
long long kaijou(long long i);
long long P(long long n, long long k);
long long C(long long n, long long k);
long long GCD(long long a, long long b);
long long LCM(long long a, long long b);
bool prime(long long N);
double distance(vector<long long> p, vector<long long> q, long long n);
void press(vector<long long> &v);
void ranking(vector<long long> &v);
void erase(vector<long long> &v, long long i);
void unique(vector<long long> &v);
void printv(vector<long long> v);
vector<ll> keta(ll x);
long long modpow(long long a, long long n, long long mod);
long long modinv(long long a, long long mod);
// 20200416
vector<long long> inputv(long long n);
//////////////////////////////////////////////////////
// 端数繰りあがり割り算(検証済)
// a÷bの端数繰り上げ
// b!=0のデバグはしてないので分母に0を入れないように
// 負数対応
long long divup(long long a, long long b) {
long long x = abs(a);
long long y = abs(b);
long long z = (x + y - 1) / y;
if ((a < 0 && b > 0) || (a > 0 && b < 0))
return -z;
else if (a == 0)
return 0;
else
return z;
}
// 階乗
// 検証済み
long long kaijou(long long i) {
if (i == 0)
return 1;
long long j = 1;
for (long long k = 1; k <= i; k++) {
j *= k;
}
return j;
}
// 順列nPk(完成)
// n個の異なる要素から、取り出す順序を区別してk個取り出す場合の数
// n<kなら0を返す
// 敢えて負数時のデバグはしてない
long long P(long long n, long long k) {
if (n < k)
return 0;
long long y = 1;
for (long long i = 0; i < k; i++) {
y *= (n - i);
}
return y;
}
// 組み合わせnCk(検証済み)
// P,kaijouと併用
long long C(long long n, long long k) {
if (n < k)
return 0;
return P(n, k) / kaijou(k);
}
// nHk
// 区別しないn個の要素を、区別するk個のグループに分ける
// 0個のグループがあっ
// て良い
// C必須
// 最大公約数GCD,最小公倍数LCM
// LCMを使うときはGCDをセットで
// 検証済み
long long GCD(long long a, long long b) {
if (a < b)
swap(a, b);
long long d = a % b;
if (d == 0) {
return b;
}
return GCD(b, d);
}
long long LCM(long long a, long long b) { return (a / GCD(a, b)) * b; }
// 素数判定
// 素数ならばtrue、素数以外の整数にはfalse
// 負数は全てfalse
// 検証済み
bool prime(long long N) {
if (N == 1) {
return false;
}
if (N < 0)
return false;
long long p = sqrt(N);
for (long long i = 2; i <= p; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
// ユークリッド距離
// 検証済み
// 位置ベクトル1,位置ベクトル2,ベクトルの次元(2または3が一般的)
double distance(vector<long long> p, vector<long long> q, long long n) {
double x = 0;
for (long long i = 0; i < n; i++) {
x += pow((p.at(i) - q.at(i)), 2);
}
return sqrt(x);
}
// 配列圧縮(検証済)
//{1,36,1,3,8,-2,-92}を
//{2, 5,2,3,4, 1, 0}にする
void press(vector<long long> &v) {
long long n = v.size();
vector<long long> w(n);
map<long long, long long> m;
for (auto &p : v) {
m[p] = 0;
}
long long i = 0;
for (auto &p : m) {
p.second = i;
i++;
}
for (long long i = 0; i < n; i++) {
w.at(i) = m[v.at(i)];
}
v = w;
return;
}
// 配列のi番目の要素がj番目に小さいとき、j番目の数がiであるベクトルを返す関数
// 配列の要素が全て異なるときにしか正常に動作しない
// 配列の要素に同じものが含まれても見かけ上動作はするが意味のない値を戻し、
// エラーも起きないので注意
// 検証済
//{2,4,1,6,0,3,8,9,5}を
//{4,2,0,5,1,8,3,6,7}にして返す
//"rank"という名前にするとSTLの関数(配列の次元を返す関数)になるので注意
void ranking(vector<long long> &v) {
long long n = v.size();
map<long long, long long> m;
long long i;
for (i = 0; i < n; i++) {
m[v.at(i)] = i;
}
vector<long long> w(n);
i = 0;
for (auto &p : m) {
v.at(i) = p.second;
i++;
}
return;
}
// 部分削除(未検証)
// ベクトルのi番目(i=0,1,2,...,n-1)の要素を削除し、
// 以降の要素を全て前に1ずらして参照返し
// ベクトル長は1小さくなって返る
// i>n-1の時は変化しない
void erase(vector<long long> &v, long long i) {
long long n = v.size();
if (i > n - 1)
return;
for (long long j = i; j < n - 1; j++) {
v.at(j) = v.at(j + 1);
}
v.pop_back();
return;
}
// 重複削除(未完成)
// 引数ベクトルに同一要素が複数あるとき、先頭を残し他は削除
// 参照返し
// ベクトル長も変化する
// O(logn)くらい
void unique(vector<long long> &v) {
long long n = v.size();
set<long long> s;
long long i = 0;
while (i < n) {
if (s.count(v.at(i))) {
erase(v, i);
n--;
} else {
s.insert(v.at(i));
i++;
}
}
return;
}
// ベクトルの出力(検証済)
// debug用にvectorの中身を出力する
void printv(vector<long long> v) {
cout << "{ ";
for (auto &p : v) {
cout << p << ",";
}
cout << "}" << endl;
}
// 10進法でn桁の整数xに対して、大きい方の位から、その位の1桁の数字を
// 収納した長さnのベクトルを返す
// 0に対しては{0}を返す
// 検証済み
vector<ll> keta(ll x) {
if (x == 0)
return {0};
ll n = log10(x) + 1; // xの桁数
vll w(n, 0);
for (ll i = 0; i < n; i++) {
ll p;
p = x % 10;
x = x / 10;
w[n - 1 - i] = p;
}
return w;
}
// 20200415
// a^n mod を計算する
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;
}
// a^{-1} mod を計算する
// modとaが互いに素のときのみ有効(数学的に逆元が一意に定まるのがそのときのみ)
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
// 整数n個の入力を受け取ってベクトルに突っ込んで返す
// チェック済み
vector<long long> inputv(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
//////////////////////////////////////////////////
long long modC(long long n, long long k, long long MOD) {
long long p = 1, q = 1;
for (long long i = 0; i < k; i++) {
p = (n - i) * p % MOD;
q = (i + 1) * q % MOD;
}
return p * modinv(q, MOD) % MOD;
}
int main() {
ll n, m;
cin >> n >> m;
auto a = inputv(n);
vector<pair<ll, ll>> v(m);
rep(i, m) { cin >> v[i].second >> v[i].first; }
sort(all(a));
sort(all(v));
reverse(all(v));
vll c(n, 0);
ll i = 0;
ll k = 0;
while (i < n && k < m) {
rep(j, v[k].second) {
if (i < n) {
c[i] = v[k].first;
i++;
}
}
k++;
}
// printv(c);
ll cnt = 0;
rep(i, n) { cnt += max(c[i], a[i]); }
cout << cnt << endl;
}
| replace | 304 | 306 | 304 | 308 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int inp[n];
for (int i = 0; i < n; i++)
scanf("%d", &inp[i]);
sort(inp, inp + n);
ii op[m];
for (int i = 0; i < m; i++)
scanf("%d %d", &op[i].second, &op[i].first);
sort(op, op + m,
[](const ii a, const ii b) -> bool { return a.first > b.first; });
int idx = 0;
for (int i = 0; idx < n && i < m; i++) {
int val = op[i].first;
for (int j = 0; j < op[i].second; j++) {
if (inp[idx] < val) {
inp[idx] = val;
idx++;
} else {
goto done;
}
}
}
done:
ll ans = 0;
for (int i = 0; i < n; i++)
ans += inp[i];
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int inp[n];
for (int i = 0; i < n; i++)
scanf("%d", &inp[i]);
sort(inp, inp + n);
ii op[m];
for (int i = 0; i < m; i++)
scanf("%d %d", &op[i].second, &op[i].first);
sort(op, op + m,
[](const ii a, const ii b) -> bool { return a.first > b.first; });
int idx = 0;
for (int i = 0; idx < n && i < m; i++) {
int val = op[i].first;
for (int j = 0; idx < n && j < op[i].second; j++) {
if (inp[idx] < val) {
inp[idx] = val;
idx++;
} else {
goto done;
}
}
}
done:
ll ans = 0;
for (int i = 0; i < n; i++)
ans += inp[i];
printf("%lld\n", ans);
return 0;
}
| replace | 25 | 26 | 25 | 26 | 0 | |
p03038 | C++ | Time Limit Exceeded | /*
* written by Yaqi Zhang (zhang623@wisc.edu)
* University of Wisconsin-Madison
* 2020
*/
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> A(n);
for (int i = 0; i < n; ++i)
cin >> A[i];
vector<pair<int, int>> cbs(m);
for (int i = 0; i < m; ++i) {
int b, c;
cin >> b >> c;
cbs[i] = {c, b};
}
sort(A.begin(), A.end());
sort(cbs.rbegin(), cbs.rend());
int idx = 0;
long long ans = accumulate(A.begin(), A.end(), 0LL);
bool done = false;
for (const auto &cb : cbs) {
int c = cb.first, b = cb.second;
// maximum is b
for (int i = 0; i < b; ++i) {
if (A[idx] < c)
ans += c - A[idx++];
if (idx == n) {
done = true;
break;
}
}
if (done)
break;
}
cout << ans << endl;
return 0;
}
| /*
* written by Yaqi Zhang (zhang623@wisc.edu)
* University of Wisconsin-Madison
* 2020
*/
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> A(n);
for (int i = 0; i < n; ++i)
cin >> A[i];
vector<pair<int, int>> cbs(m);
for (int i = 0; i < m; ++i) {
int b, c;
cin >> b >> c;
cbs[i] = {c, b};
}
sort(A.begin(), A.end());
sort(cbs.rbegin(), cbs.rend());
int idx = 0;
long long ans = accumulate(A.begin(), A.end(), 0LL);
bool done = false;
for (const auto &cb : cbs) {
int c = cb.first, b = cb.second;
// maximum is b
for (int i = 0; i < b; ++i) {
if (A[idx] < c)
ans += c - A[idx++];
else {
done = true;
break;
}
if (idx == n) {
done = true;
break;
}
}
if (done)
break;
}
cout << ans << endl;
return 0;
}
| insert | 36 | 36 | 36 | 40 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> TUP;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define mp(a, b) make_pair(a, b)
const ll MOD = 1000000007;
ll maxx(ll x, ll y, ll z) { return max(max(x, y), z); }
ll minn(ll x, ll y, ll z) { return min(min(x, y), z); }
ll gcd(ll x, ll y) {
if (x % y == 0)
return y;
else
return gcd(y, x % y);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
int main() {
ll N, M;
cin >> N >> M;
ll ans = 0;
vector<ll> A(N);
rep(i, N) cin >> A[i];
sort(A.begin(), A.end());
vector<P> p(N);
rep(i, M) {
ll B, C;
cin >> B >> C;
p[i] = mp(C, B);
}
sort(p.begin(), p.end(), greater<P>());
ll i = 0, n = 0;
while (i < M) {
for (int j = 1; j <= p[i].second; j++) {
if (p[i].first > A[n])
A[n++] = p[i].first;
else {
rep(k, N) { ans += A[k]; }
cout << ans << endl;
return 0;
}
}
i++;
}
rep(i, N) { ans += A[i]; }
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> TUP;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define mp(a, b) make_pair(a, b)
const ll MOD = 1000000007;
ll maxx(ll x, ll y, ll z) { return max(max(x, y), z); }
ll minn(ll x, ll y, ll z) { return min(min(x, y), z); }
ll gcd(ll x, ll y) {
if (x % y == 0)
return y;
else
return gcd(y, x % y);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
int main() {
ll N, M;
cin >> N >> M;
ll ans = 0;
vector<ll> A(N);
rep(i, N) cin >> A[i];
sort(A.begin(), A.end());
vector<P> p(M);
rep(i, M) {
ll B, C;
cin >> B >> C;
p[i] = mp(C, B);
}
sort(p.begin(), p.end(), greater<P>());
ll i = 0, n = 0;
while (i < M) {
for (int j = 1; j <= p[i].second; j++) {
if (p[i].first > A[n])
A[n++] = p[i].first;
else {
rep(k, N) { ans += A[k]; }
cout << ans << endl;
return 0;
}
}
i++;
}
rep(i, N) { ans += A[i]; }
cout << ans << endl;
}
| replace | 28 | 29 | 28 | 29 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cctype>
#include <deque>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<long, long>;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep_s(i, start, n) for (ll i = start; i < n; i++)
#define rep_down(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep_down_s(i, n, start) for (ll i = n - 1; i >= start; i--)
#define ALL(a) (a).begin(), (a).end()
#define ALL_str(a) (a).cbegin(), (a).cend()
#define print(ans) cout << ans << endl;
string alphabet_upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string alphabet_lower = "abcdefghijklmnopqrstuvwxyz";
string numbers = "0123456789";
/*
for (iterator = hash.begin(); iterator != hash.end(); iterator++)
{
// ここで、要素毎の操作を行います。
std::pair<std::string, CMyClass> element = *iterator;
}
*/
/*
using edge = struct {int to; ll cost;};
vector<edge> tree[limit];
ll depth[limit];
void dfs(int v, int p, ll d){
depth[v] = d;
//cout <<"v: " << v << endl;
for (auto &e: tree[v]){
//cout << "e.to: " << e.to << endl;
if (e.to == p) continue;
dfs(e.to, v, d+e.cost);
}
}
*/
int keta_sum(int num) {
int dig, sum = 0;
while (num) {
dig = num % 10;
sum = sum + dig;
num = num / 10;
}
return sum;
}
ll keta_num(ll num) {
ll total = 0;
while (num) {
num /= 10;
total++;
}
}
ll binary_search(ll left_key, ll border, ll low, ll high) {
// 配列 a の左端と右端
ll mid = (low + high) / 2;
while (high > low + 1) {
mid = (low + high) / 2;
if (left_key * mid > border)
high = mid;
else if (left_key * mid < border)
low = mid;
else {
mid = mid - 1;
break;
}
}
return mid;
}
bool IsPrime(ll a) {
ll b = sqrt(a);
b++;
while (b-- >= 2) {
if (a % b == 0)
return false;
}
return true;
}
ll gcd(ll a, ll b) {
ll tmp;
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
ll r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { // 最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(void) {
ll N, M, A, B, C, D, E, F, K, L, W, H, P, Q, R, X, Y;
ll ans;
string S, T;
cin >> N >> M;
vector<ll> a;
ans = 0;
rep(i, N) {
cin >> A;
a.push_back(A);
ans += A;
}
sort(ALL(a));
vector<pair<ll, ll>> bc;
rep(i, M) {
cin >> B >> C;
bc.push_back(make_pair(C, B));
}
sort(ALL(bc));
ll count = 0;
// cout << "ans: " << ans << endl;
for (ll i = bc.size() - 1; i >= 0; i--) {
// cout << "bc[i].first: " << bc[i].first << ", bc[i].second: " <<
// bc[i].second << endl;
rep(j, bc[i].second) {
if (bc[i].first > a[count]) {
// cout << "a[count]: " << a[count] << ", bc[i].first-a[count]: " <<
// bc[i].first-a[count] << endl; cout << ", bc[i].first: " <<
// bc[i].first << endl;
ans += bc[i].first - a[count];
// cout << ans << endl;
count++;
} else {
goto Idle;
}
}
}
Idle:
cout << ans << endl;
}
| #include <algorithm>
#include <cctype>
#include <deque>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<long, long>;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep_s(i, start, n) for (ll i = start; i < n; i++)
#define rep_down(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep_down_s(i, n, start) for (ll i = n - 1; i >= start; i--)
#define ALL(a) (a).begin(), (a).end()
#define ALL_str(a) (a).cbegin(), (a).cend()
#define print(ans) cout << ans << endl;
string alphabet_upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string alphabet_lower = "abcdefghijklmnopqrstuvwxyz";
string numbers = "0123456789";
/*
for (iterator = hash.begin(); iterator != hash.end(); iterator++)
{
// ここで、要素毎の操作を行います。
std::pair<std::string, CMyClass> element = *iterator;
}
*/
/*
using edge = struct {int to; ll cost;};
vector<edge> tree[limit];
ll depth[limit];
void dfs(int v, int p, ll d){
depth[v] = d;
//cout <<"v: " << v << endl;
for (auto &e: tree[v]){
//cout << "e.to: " << e.to << endl;
if (e.to == p) continue;
dfs(e.to, v, d+e.cost);
}
}
*/
int keta_sum(int num) {
int dig, sum = 0;
while (num) {
dig = num % 10;
sum = sum + dig;
num = num / 10;
}
return sum;
}
ll keta_num(ll num) {
ll total = 0;
while (num) {
num /= 10;
total++;
}
}
ll binary_search(ll left_key, ll border, ll low, ll high) {
// 配列 a の左端と右端
ll mid = (low + high) / 2;
while (high > low + 1) {
mid = (low + high) / 2;
if (left_key * mid > border)
high = mid;
else if (left_key * mid < border)
low = mid;
else {
mid = mid - 1;
break;
}
}
return mid;
}
bool IsPrime(ll a) {
ll b = sqrt(a);
b++;
while (b-- >= 2) {
if (a % b == 0)
return false;
}
return true;
}
ll gcd(ll a, ll b) {
ll tmp;
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
ll r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { // 最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(void) {
ll N, M, A, B, C, D, E, F, K, L, W, H, P, Q, R, X, Y;
ll ans;
string S, T;
cin >> N >> M;
vector<ll> a;
ans = 0;
rep(i, N) {
cin >> A;
a.push_back(A);
ans += A;
}
sort(ALL(a));
vector<pair<ll, ll>> bc;
rep(i, M) {
cin >> B >> C;
bc.push_back(make_pair(C, B));
}
sort(ALL(bc));
ll count = 0;
// cout << "ans: " << ans << endl;
for (ll i = bc.size() - 1; i >= 0; i--) {
// cout << "bc[i].first: " << bc[i].first << ", bc[i].second: " <<
// bc[i].second << endl;
rep(j, bc[i].second) {
if (bc[i].first > a[count]) {
// cout << "a[count]: " << a[count] << ", bc[i].first-a[count]: " <<
// bc[i].first-a[count] << endl; cout << ", bc[i].first: " <<
// bc[i].first << endl;
ans += bc[i].first - a[count];
// cout << ans << endl;
count++;
if (count == N)
goto Idle;
} else {
goto Idle;
}
}
}
Idle:
cout << ans << endl;
}
| insert | 178 | 178 | 178 | 180 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push(x);
}
vector<pair<ll, ll>> bc(m);
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
bc.at(i) = make_pair(c, b);
}
sort(bc.begin(), bc.end());
reverse(bc.begin(), bc.end());
for (int i = 0; i < m; i++) {
for (int j = 0; j < bc.at(i).second; j++) {
int mi = a.top();
if (mi > bc.at(i).first)
break;
a.pop();
a.push(bc.at(i).first);
}
}
ll ans = 0;
while (!a.empty()) {
ans += a.top();
a.pop();
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
priority_queue<ll, vector<ll>, greater<ll>> a;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push(x);
}
vector<pair<ll, ll>> bc(m);
for (int i = 0; i < m; i++) {
int b, c;
cin >> b >> c;
bc.at(i) = make_pair(c, b);
}
sort(bc.begin(), bc.end());
reverse(bc.begin(), bc.end());
for (int i = 0; i < m; i++) {
for (int j = 0; j < bc.at(i).second; j++) {
int mi = a.top();
if (mi >= bc.at(i).first)
break;
a.pop();
a.push(bc.at(i).first);
}
}
ll ans = 0;
while (!a.empty()) {
ans += a.top();
a.pop();
}
cout << ans << endl;
} | replace | 24 | 25 | 24 | 25 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
/* (๑╹◡╹) */
const ll MOD = 1000000007;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* (๑╹ここにすきなもじをいれてね！╹) */
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/* (๑╹最強╹) */
int main() {
ll N, M, c, b, m, ans;
m = 0;
cin >> N >> M;
ans = 0;
vector<ll> vec(N);
rep(i, N) { cin >> vec.at(i); }
vector<pair<ll, ll>> cb;
rep(i, M) {
cin >> b >> c;
cb.PB(MP(c, b));
}
sort(cb.rbegin(), cb.rend());
rep(i, M) {
rep(j, cb.at(i).second) { vec.push_back(cb.at(i).first); }
m += cb.at(i).second;
if (m < M)
break;
}
sort(vec.rbegin(), vec.rend());
rep(i, N) { ans += vec.at(i); }
cout << ans << endl;
} | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
/* (๑╹◡╹) */
const ll MOD = 1000000007;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* (๑╹ここにすきなもじをいれてね！╹) */
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/* (๑╹最強╹) */
int main() {
ll N, M, c, b, m, ans;
m = 0;
cin >> N >> M;
ans = 0;
vector<ll> vec(N);
rep(i, N) { cin >> vec.at(i); }
vector<pair<ll, ll>> cb;
rep(i, M) {
cin >> b >> c;
cb.PB(MP(c, b));
}
sort(cb.rbegin(), cb.rend());
rep(i, M) {
rep(j, cb.at(i).second) { vec.push_back(cb.at(i).first); }
m += cb.at(i).second;
if (m > N)
break;
}
sort(vec.rbegin(), vec.rend());
rep(i, N) { ans += vec.at(i); }
cout << ans << endl;
} | replace | 66 | 67 | 66 | 67 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int i, j;
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> P(M);
for (i = 0; i < N; i++)
cin >> A[i];
// 都合上，BとCを逆順に入力している
for (i = 0; i < M; i++)
cin >> P[i].second >> P[i].first;
// Aを降順にソート．Pをfirstでソート
sort(A.begin(), A.end());
sort(P.begin(), P.end(), greater<pair<int, int>>());
long long int sum = 0;
// Pを追っていく添字変数j
j = 0;
for (i = 0; i < N; i++) {
// 選んだカードの方が大きければそっちを足す
if (A[i] < P[j].first) {
sum += P[j].first;
// 選べる回数を一回減らす．B[j]--と同値
P[j].second--;
// 選べる上限に達したら次の操作に移る
if (P[j].second == 0)
j++;
}
// 選べるカードより元の数字の方が大きい
else
sum += A[i];
}
cout << sum << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int i, j;
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> P(M + 1);
for (i = 0; i < N; i++)
cin >> A[i];
// 都合上，BとCを逆順に入力している
for (i = 0; i < M; i++)
cin >> P[i].second >> P[i].first;
// Aを降順にソート．Pをfirstでソート
sort(A.begin(), A.end());
sort(P.begin(), P.end(), greater<pair<int, int>>());
long long int sum = 0;
// Pを追っていく添字変数j
j = 0;
for (i = 0; i < N; i++) {
// 選んだカードの方が大きければそっちを足す
if (A[i] < P[j].first) {
sum += P[j].first;
// 選べる回数を一回減らす．B[j]--と同値
P[j].second--;
// 選べる上限に達したら次の操作に移る
if (P[j].second == 0)
j++;
}
// 選べるカードより元の数字の方が大きい
else
sum += A[i];
}
cout << sum << endl;
return 0;
}
| replace | 11 | 12 | 11 | 12 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <queue>
#define ll long long
#define ri register int
using namespace std;
template <class T> inline void read(T &x) {
x = 0;
int ne = 0;
char c;
while (!isdigit(c = getchar()))
ne = c == '-';
x = c - 48;
while (isdigit(c = getchar()))
x = (x << 3) + (x << 1) + c - 48;
x = ne ? -x : x;
return;
}
const int maxn = 100005;
int N, m;
int a[maxn];
ll ans = 0;
struct Op {
int v, cnt;
bool operator<(const Op &x) const { return v < x.v; }
} opt[maxn];
struct Heap {
int n, heap[maxn];
inline void up(int fa) {
while (fa > 1) {
if (heap[fa] < heap[fa >> 1]) {
swap(heap[fa], heap[fa >> 1]);
fa = fa >> 1;
} else
break;
}
}
inline void push(int v) {
heap[++n] = v;
up(n);
}
inline void down(int fa) {
int s = fa << 1;
while (s <= n) {
if (s < n && heap[s] > heap[s + 1])
s++;
if (heap[s] < heap[fa]) {
swap(heap[s], heap[fa]);
fa = s;
s = fa << 1;
} else
break;
}
}
inline void pop() {
heap[1] = heap[n--];
down(1);
}
inline int top() { return heap[1]; }
} q;
int main() {
int b, c;
read(N), read(m);
for (ri i = 1; i <= N; i++) {
read(a[i]);
q.push(a[i]);
ans += a[i];
}
for (ri i = 1; i <= m; i++) {
read(opt[i].cnt), read(opt[i].v);
}
sort(opt + 1, opt + 1 + m);
// printf("%d\n",opt[1].v);
for (ri k = 1; k <= m; k++) {
b = opt[k].cnt, c = opt[k].v;
bool flag = 0;
for (ri i = 1; i <= b && !flag; i++) {
if (q.top() >= c) {
flag = 1;
} else {
ans -= q.top();
q.pop();
q.push(c);
ans += c;
}
}
}
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <queue>
#define ll long long
#define ri register int
using namespace std;
template <class T> inline void read(T &x) {
x = 0;
int ne = 0;
char c;
while (!isdigit(c = getchar()))
ne = c == '-';
x = c - 48;
while (isdigit(c = getchar()))
x = (x << 3) + (x << 1) + c - 48;
x = ne ? -x : x;
return;
}
const int maxn = 100005;
int N, m;
int a[maxn];
ll ans = 0;
struct Op {
int v, cnt;
bool operator<(const Op &x) const { return v > x.v; }
} opt[maxn];
struct Heap {
int n, heap[maxn];
inline void up(int fa) {
while (fa > 1) {
if (heap[fa] < heap[fa >> 1]) {
swap(heap[fa], heap[fa >> 1]);
fa = fa >> 1;
} else
break;
}
}
inline void push(int v) {
heap[++n] = v;
up(n);
}
inline void down(int fa) {
int s = fa << 1;
while (s <= n) {
if (s < n && heap[s] > heap[s + 1])
s++;
if (heap[s] < heap[fa]) {
swap(heap[s], heap[fa]);
fa = s;
s = fa << 1;
} else
break;
}
}
inline void pop() {
heap[1] = heap[n--];
down(1);
}
inline int top() { return heap[1]; }
} q;
int main() {
int b, c;
read(N), read(m);
for (ri i = 1; i <= N; i++) {
read(a[i]);
q.push(a[i]);
ans += a[i];
}
for (ri i = 1; i <= m; i++) {
read(opt[i].cnt), read(opt[i].v);
}
sort(opt + 1, opt + 1 + m);
// printf("%d\n",opt[1].v);
for (ri k = 1; k <= m; k++) {
b = opt[k].cnt, c = opt[k].v;
bool flag = 0;
for (ri i = 1; i <= b && !flag; i++) {
if (q.top() >= c) {
flag = 1;
} else {
ans -= q.top();
q.pop();
q.push(c);
ans += c;
}
}
}
printf("%lld\n", ans);
return 0;
} | replace | 28 | 29 | 28 | 29 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#ifdef HIRO
#define d(f_, ...) printf((f_), ##__VA_ARGS__)
#else
#define d(f_, ...)
#endif
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pllll;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pair<int, int>> vii;
typedef vector<pair<long long, long long>> vllll;
typedef map<int, int> mii;
typedef map<long long, long long> mllll;
typedef queue<int> qi;
typedef queue<pair<int, int>> qp;
#define mp make_pair
#define pi 3.14159265358979323846
#define MAX max_element
#define MIN min_element
#define all(v) v.begin(), v.end()
#define gt(T) greater<T>()
#define sum(v) accumulate(v.begin(), v.end(), 0ll)
#define uni(v) \
do { \
sort(v.begin(), v.end()); \
decltype(v)::iterator result = unique(v.begin(), v.end()); \
v.erase(result, v.end()); \
} while (0)
#define fi(init, n) for (int i = init; i < n; ++i)
#define fj(init, n) for (int j = init; j < n; ++j)
#define fk(init, n) for (int k = init; k < n; ++k)
#define zero(x) memset(x, 0, sizeof(x))
#define negative(x) memset(x, ~0, sizeof(x))
#define bitsum(x) __builtin_popcount(x)
const ll MOD = 1e9 + 7;
const int INF = 1e9;
const int di[] = {0, 1, 0, -1};
const int dj[] = {1, 0, -1, 0};
template <typename T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T> int finder(vector<T> vec, T number) {
auto itr = find(vec.begin(), vec.end(), number);
size_t index = distance(vec.begin(), itr);
if (index != vec.size())
return 1;
else
return 0;
}
ll frac(ll n) {
if (n == 0)
return 1;
return (n * frac(n - 1)) % MOD;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
bool cmp(pii &a, pii &b) { return a.second > b.second; }
int main(int argc, char **argv) {
#ifdef HIRO
string quiz(argv[1]);
string id(argv[2]);
string filename("input/" + quiz + "/" + id + ".txt");
ifstream fin(filename);
if (fin.peek() == ifstream::traits_type::eof()) {
cout << "No input.";
return 0;
}
ifstream cin(filename);
std::cin.rdbuf(cin.rdbuf());
#endif
ll ans = 0;
int n, m;
cin >> n >> m;
int arr[n], mask[n];
vii bc(n);
zero(mask);
fi(0, n) { cin >> arr[i]; }
sort(arr, arr + n);
fi(0, m) { cin >> bc[i].first >> bc[i].second; }
sort(all(bc), cmp);
int i = 0, end = 0;
for (pii p : bc) {
// cout << p.first << "," << p.second << endl;
fj(0, p.first) {
if (i >= n) {
end = 1;
break;
}
if (arr[i] < p.second)
arr[i++] = p.second;
else {
end = 1;
break;
}
}
if (end)
break;
}
// fi(0, n)
// cout << arr[i] << " ";
// cout << endl;
ans = accumulate(arr, arr + n, 0ll);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#ifdef HIRO
#define d(f_, ...) printf((f_), ##__VA_ARGS__)
#else
#define d(f_, ...)
#endif
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pllll;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pair<int, int>> vii;
typedef vector<pair<long long, long long>> vllll;
typedef map<int, int> mii;
typedef map<long long, long long> mllll;
typedef queue<int> qi;
typedef queue<pair<int, int>> qp;
#define mp make_pair
#define pi 3.14159265358979323846
#define MAX max_element
#define MIN min_element
#define all(v) v.begin(), v.end()
#define gt(T) greater<T>()
#define sum(v) accumulate(v.begin(), v.end(), 0ll)
#define uni(v) \
do { \
sort(v.begin(), v.end()); \
decltype(v)::iterator result = unique(v.begin(), v.end()); \
v.erase(result, v.end()); \
} while (0)
#define fi(init, n) for (int i = init; i < n; ++i)
#define fj(init, n) for (int j = init; j < n; ++j)
#define fk(init, n) for (int k = init; k < n; ++k)
#define zero(x) memset(x, 0, sizeof(x))
#define negative(x) memset(x, ~0, sizeof(x))
#define bitsum(x) __builtin_popcount(x)
const ll MOD = 1e9 + 7;
const int INF = 1e9;
const int di[] = {0, 1, 0, -1};
const int dj[] = {1, 0, -1, 0};
template <typename T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T> int finder(vector<T> vec, T number) {
auto itr = find(vec.begin(), vec.end(), number);
size_t index = distance(vec.begin(), itr);
if (index != vec.size())
return 1;
else
return 0;
}
ll frac(ll n) {
if (n == 0)
return 1;
return (n * frac(n - 1)) % MOD;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
bool cmp(pii &a, pii &b) { return a.second > b.second; }
int main(int argc, char **argv) {
#ifdef HIRO
string quiz(argv[1]);
string id(argv[2]);
string filename("input/" + quiz + "/" + id + ".txt");
ifstream fin(filename);
if (fin.peek() == ifstream::traits_type::eof()) {
cout << "No input.";
return 0;
}
ifstream cin(filename);
std::cin.rdbuf(cin.rdbuf());
#endif
ll ans = 0;
int n, m;
cin >> n >> m;
int arr[n];
vii bc(m);
fi(0, n) { cin >> arr[i]; }
sort(arr, arr + n);
fi(0, m) { cin >> bc[i].first >> bc[i].second; }
sort(all(bc), cmp);
int i = 0, end = 0;
for (pii p : bc) {
// cout << p.first << "," << p.second << endl;
fj(0, p.first) {
if (i >= n) {
end = 1;
break;
}
if (arr[i] < p.second)
arr[i++] = p.second;
else {
end = 1;
break;
}
}
if (end)
break;
}
// fi(0, n)
// cout << arr[i] << " ";
// cout << endl;
ans = accumulate(arr, arr + n, 0ll);
cout << ans << endl;
return 0;
}
| replace | 91 | 94 | 91 | 93 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
using namespace std;
using LL = long long;
using P = pair<int, int>;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
const int INF = (int)1e9;
const LL INFL = (LL)1e19;
const int MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> a(n), b(m), c(m);
REP(i, n) cin >> a[i];
REP(i, m) cin >> b[i] >> c[i];
vector<P> p;
REP(i, m) { p.pb(make_pair(c[i], b[i])); }
sort(all(a));
sort(all(p), greater<P>());
vector<int> d(n);
for (int i = 0, j = 0; i < m && j < n; i++) {
while (p[i].second > 0) {
d[j] = p[i].first;
j++;
p[i].second--;
}
}
priority_queue<LL> que;
REP(i, n) que.push(a[i]);
REP(i, n) que.push(d[i]);
LL ans = 0;
REP(i, n) {
ans += que.top();
que.pop();
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
using LL = long long;
using P = pair<int, int>;
#define FOR(i, a, n) for (int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define pb(a) push_back(a)
#define all(x) (x).begin(), (x).end()
const int INF = (int)1e9;
const LL INFL = (LL)1e19;
const int MOD = 1e9 + 7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> a(n), b(m), c(m);
REP(i, n) cin >> a[i];
REP(i, m) cin >> b[i] >> c[i];
vector<P> p;
REP(i, m) { p.pb(make_pair(c[i], b[i])); }
sort(all(a));
sort(all(p), greater<P>());
vector<int> d(n);
for (int i = 0, j = 0; i < m && j < n; i++) {
while (p[i].second > 0 && j < n) {
d[j] = p[i].first;
j++;
p[i].second--;
}
}
priority_queue<LL> que;
REP(i, n) que.push(a[i]);
REP(i, n) que.push(d[i]);
LL ans = 0;
REP(i, n) {
ans += que.top();
que.pop();
}
cout << ans << endl;
} | replace | 35 | 36 | 35 | 36 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct Bc {
int b, c;
Bc(int inputB, int inputC) {
b = inputB;
c = inputC;
}
bool operator<(const Bc &another) const { return c < another.c; }
};
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
vector<Bc> bc;
int tmp_b, tmp_c;
for (int i = 0; i < M; i++) {
cin >> tmp_b >> tmp_c;
bc.push_back(Bc(tmp_b, tmp_c));
}
sort(A.begin(), A.end());
sort(bc.begin(), bc.end());
reverse(bc.begin(), bc.end());
int point = 0;
bool brk = false;
for (auto itr : bc) {
for (int i = 0; i < itr.b; i++) {
if (A.at(point) < itr.c) {
A.at(point) = itr.c;
point++;
} else {
brk = true;
break;
}
}
if (brk) {
break;
}
}
int64_t sum = 0;
for (int i = 0; i < A.size(); i++) {
sum += A.at(i);
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
struct Bc {
int b, c;
Bc(int inputB, int inputC) {
b = inputB;
c = inputC;
}
bool operator<(const Bc &another) const { return c < another.c; }
};
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
vector<Bc> bc;
int tmp_b, tmp_c;
for (int i = 0; i < M; i++) {
cin >> tmp_b >> tmp_c;
bc.push_back(Bc(tmp_b, tmp_c));
}
sort(A.begin(), A.end());
sort(bc.begin(), bc.end());
reverse(bc.begin(), bc.end());
int point = 0;
bool brk = false;
for (auto itr : bc) {
for (int i = 0; i < itr.b; i++) {
if (A.at(point) < itr.c) {
A.at(point) = itr.c;
point++;
if (point >= A.size()) {
brk = true;
break;
}
} else {
brk = true;
break;
}
}
if (brk) {
break;
}
}
int64_t sum = 0;
for (int i = 0; i < A.size(); i++) {
sum += A.at(i);
}
cout << sum << endl;
} | insert | 38 | 38 | 38 | 42 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define sz size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(c) (c).begin(), (c).end()
#define rep(i, a, b) for (ll i = (a); i < (b); ++i)
#define per(i, a, b) for (ll i = b - 1LL; i >= (a); --i)
#define clr(a, b) memset((a), (b), sizeof(a))
#define ctos(c) string(1, c)
#define print(x) cout << #x << " = " << x << endl;
#define MOD 1000000007
int main() {
ll n, m;
cin >> n >> m;
vector<ll> v1;
rep(i, 0, n) {
ll a;
cin >> a;
v1.pb(a);
}
sort(all(v1));
vector<pair<ll, ll>> vp;
vector<ll> v2;
rep(i, 0, m) {
ll b, c;
cin >> b >> c;
vp.pb(mp(c, b));
}
sort(all(vp));
reverse(all(vp));
rep(i, 0, vp.sz) {
ll b = vp[i].se;
ll c = vp[i].fi;
rep(j, 0, b) {
if (v2.sz > 100100)
break;
v2.pb(c);
}
}
sort(all(v2));
reverse(all(v2));
ll ans = 0;
rep(i, 0, n) { ans += max(v1[i], v2[i]); }
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define sz size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(c) (c).begin(), (c).end()
#define rep(i, a, b) for (ll i = (a); i < (b); ++i)
#define per(i, a, b) for (ll i = b - 1LL; i >= (a); --i)
#define clr(a, b) memset((a), (b), sizeof(a))
#define ctos(c) string(1, c)
#define print(x) cout << #x << " = " << x << endl;
#define MOD 1000000007
int main() {
ll n, m;
cin >> n >> m;
vector<ll> v1;
rep(i, 0, n) {
ll a;
cin >> a;
v1.pb(a);
}
sort(all(v1));
vector<pair<ll, ll>> vp;
vector<ll> v2;
rep(i, 0, m) {
ll b, c;
cin >> b >> c;
vp.pb(mp(c, b));
}
sort(all(vp));
reverse(all(vp));
rep(i, 0, vp.sz) {
ll b = vp[i].se;
ll c = vp[i].fi;
rep(j, 0, b) {
if (v2.sz > 100100)
break;
v2.pb(c);
}
}
sort(all(v2));
reverse(all(v2));
rep(i, 0, 100100) { v2.pb(0); }
ll ans = 0;
rep(i, 0, n) { ans += max(v1[i], v2[i]); }
cout << ans << endl;
return 0;
} | insert | 68 | 68 | 68 | 69 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
vector<pair<ll, int>> bc(m);
rep(i, m) {
int b;
ll c;
cin >> b >> c;
bc[i] = {c, b};
}
sort(bc.begin(), bc.end());
reverse(bc.begin(), bc.end());
int l = 0;
int i = 0;
ll ans = 0;
while (1) {
if (l == n || i == n)
break;
int idx =
lower_bound(a.begin() + l, a.end(), bc[i].first) - (a.begin() + l);
idx = min(bc[i].second, idx);
ans += bc[i].first * (ll)idx;
l += idx;
++i;
}
for (int i = l; i < n; ++i) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
vector<pair<ll, int>> bc(m);
rep(i, m) {
int b;
ll c;
cin >> b >> c;
bc[i] = {c, b};
}
sort(bc.begin(), bc.end());
reverse(bc.begin(), bc.end());
int l = 0;
int i = 0;
ll ans = 0;
while (1) {
if (l == n || i == m)
break;
int idx =
lower_bound(a.begin() + l, a.end(), bc[i].first) - (a.begin() + l);
idx = min(bc[i].second, idx);
ans += bc[i].first * (ll)idx;
l += idx;
++i;
}
for (int i = l; i < n; ++i) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| replace | 34 | 35 | 34 | 35 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
/* function */
/* main */
int main() {
int N, M, b, c;
cin >> N >> M;
vector<int> a(N);
vector<pii> v(M);
for (int i = 0; i < N; i++)
cin >> a[i];
for (int i = 0; i < M; i++) {
cin >> b >> c;
v[i] = pii(c, b);
}
sort(a.begin(), a.end());
sort(v.begin(), v.end(), greater<pii>());
int j = 0;
for (int i = 0; i < N; i++) {
int c = v[j].first;
if (a[i] < c) {
a[i] = c;
v[j].second--;
}
if (v[j].second == 0)
j++;
}
cout << accumulate(a.begin(), a.end(), 0LL) << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
/* function */
/* main */
int main() {
int N, M, b, c;
cin >> N >> M;
vector<int> a(N);
vector<pii> v(M);
for (int i = 0; i < N; i++)
cin >> a[i];
for (int i = 0; i < M; i++) {
cin >> b >> c;
v[i] = pii(c, b);
}
sort(a.begin(), a.end());
sort(v.begin(), v.end(), greater<pii>());
int j = 0;
for (int i = 0; i < N && j < M; i++) {
int c = v[j].first;
if (a[i] < c) {
a[i] = c;
v[j].second--;
}
if (v[j].second == 0)
j++;
}
cout << accumulate(a.begin(), a.end(), 0LL) << '\n';
}
| replace | 30 | 31 | 30 | 31 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, q, A[N];
pair<int, int> B[N];
multiset<int> S;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++)
scanf("%d", &A[i]);
for (int i = 1; i <= q; i++)
scanf("%d%d", &B[i].second, &B[i].first);
sort(B + 1, B + q + 1);
sort(A + 1, A + n + 1);
vector<int> vec;
for (int i = q; i; i--)
while ((int)vec.size() < n && B[i].second)
vec.push_back(B[i].first), B[i].second--;
long long Mx = 0, sum = 0;
for (int i = 0; i < n; i++)
sum += vec[i] - A[i + 1], Mx = max(Mx, sum);
for (int i = 1; i <= n; i++)
Mx += A[i];
printf("%lld\n", Mx);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, q, A[N];
pair<int, int> B[N];
multiset<int> S;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++)
scanf("%d", &A[i]);
for (int i = 1; i <= q; i++)
scanf("%d%d", &B[i].second, &B[i].first);
sort(B + 1, B + q + 1);
sort(A + 1, A + n + 1);
vector<int> vec;
for (int i = q; i; i--)
while ((int)vec.size() < n && B[i].second)
vec.push_back(B[i].first), B[i].second--;
long long Mx = 0, sum = 0;
for (int i = 0; i < min(n, (int)vec.size()); i++)
sum += vec[i] - A[i + 1], Mx = max(Mx, sum);
for (int i = 1; i <= n; i++)
Mx += A[i];
printf("%lld\n", Mx);
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
using ll = long long;
static const ll mod = 1e9 + 7;
static const ll INF = 1LL << 50;
using namespace std;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n), b(m), c(m);
vector<pair<ll, ll>> cmp;
ll sum = 0;
rep(i, n) {
cin >> a[i];
sum += a[i];
}
rep(i, m) {
cin >> b[i] >> c[i];
cmp.eb(c[i], b[i]);
}
sort(cmp.begin(), cmp.end(), greater<pair<ll, ll>>());
sort(a.begin(), a.end());
int k = 0;
rep(i, m) {
rep(j, cmp[i].se) {
if (a[k] <= cmp[i].fi)
sum += cmp[i].fi - a[k];
k++;
}
}
cout << sum << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
using ll = long long;
static const ll mod = 1e9 + 7;
static const ll INF = 1LL << 50;
using namespace std;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n), b(m), c(m);
vector<pair<ll, ll>> cmp;
ll sum = 0;
rep(i, n) {
cin >> a[i];
sum += a[i];
}
rep(i, m) {
cin >> b[i] >> c[i];
cmp.eb(c[i], b[i]);
}
sort(cmp.begin(), cmp.end(), greater<pair<ll, ll>>());
sort(a.begin(), a.end());
int k = 0;
rep(i, m) {
rep(j, cmp[i].se) {
if (k == n)
break;
if (a[k] <= cmp[i].fi)
sum += cmp[i].fi - a[k];
k++;
}
}
cout << sum << endl;
} | insert | 43 | 43 | 43 | 45 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long long ll;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<ll> VLL;
typedef vector<PLL> VP;
const static int INF = 1000000000;
const static int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
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;
}
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, n) for (ll i = n - 1; i >= 0; i--)
#define rept(i, m, n) for (ll i = m; i < n; i++)
#define stl_rep(itr, x) for (auto itr = x.begin(); itr != x.end(); ++itr)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define PF push_front
#define PB push_back
#define SORT(V) sort((V).begin(), (V).end())
#define RVERSE(V) reverse((V).begin(), (V).end())
#define paired make_pair
#define PRINT(V) \
for (auto v : (V)) \
cout << v << " "
// charを整数に
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
// 累積和 for (int i = 0; i < N; ++i) s[i+1] = s[i] + a[i];
void cum_sum(int N, vector<double> a, vector<double> &s) {
for (int i = 0; i < N; i++) {
s[i + 1] = s[i] + a[i];
}
}
// ユークリッドの控除法
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; // Be careful not to overflow
}
// 素数判定
bool is_prime(long long n) {
if (n <= 1)
return false;
for (long long p = 2; p * p <= n; ++p) {
if (n % p == 0)
return false;
}
return true;
}
int getdigit(ll num) {
unsigned digit = 0;
while (num != 0) {
num /= 10;
digit++;
}
return digit;
}
// 空白文字も入力 getline(cin, S);
// 桁数指定 setprecision
int main() {
ll N, M;
cin >> N >> M;
VLL A(N);
rep(i, N) { cin >> A[i]; }
vector<pair<ll, ll>> F;
ll res = 0;
rep(i, M) {
ll b, c;
cin >> b >> c;
res += b;
F.PB(make_pair(c, b));
}
sort(all(F));
reverse(all(F));
VLL S;
bool judge = false;
while (1) {
for (int i = 0; i < M; i++) {
for (int j = 0; j < F[i].S; j++) {
S.PB(F[i].F);
if (S.size() == res) {
judge = true;
break;
}
}
if (judge)
break;
}
if (judge)
break;
}
// cout << S.size() << endl;
sort(all(A));
reverse(all(A));
ll counter_a = 0;
ll counter_s = 0;
ll sum = 0;
rep(i, N) {
if (A[counter_a] >= S[counter_s]) {
sum += A[counter_a];
counter_a++;
continue;
}
if (A[counter_a] <= S[counter_s] && counter_s < S.size()) {
sum += S[counter_s];
counter_s++;
continue;
}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long long ll;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<ll> VLL;
typedef vector<PLL> VP;
const static int INF = 1000000000;
const static int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
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;
}
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, n) for (ll i = n - 1; i >= 0; i--)
#define rept(i, m, n) for (ll i = m; i < n; i++)
#define stl_rep(itr, x) for (auto itr = x.begin(); itr != x.end(); ++itr)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define PF push_front
#define PB push_back
#define SORT(V) sort((V).begin(), (V).end())
#define RVERSE(V) reverse((V).begin(), (V).end())
#define paired make_pair
#define PRINT(V) \
for (auto v : (V)) \
cout << v << " "
// charを整数に
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
// 累積和 for (int i = 0; i < N; ++i) s[i+1] = s[i] + a[i];
void cum_sum(int N, vector<double> a, vector<double> &s) {
for (int i = 0; i < N; i++) {
s[i + 1] = s[i] + a[i];
}
}
// ユークリッドの控除法
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; // Be careful not to overflow
}
// 素数判定
bool is_prime(long long n) {
if (n <= 1)
return false;
for (long long p = 2; p * p <= n; ++p) {
if (n % p == 0)
return false;
}
return true;
}
int getdigit(ll num) {
unsigned digit = 0;
while (num != 0) {
num /= 10;
digit++;
}
return digit;
}
// 空白文字も入力 getline(cin, S);
// 桁数指定 setprecision
int main() {
ll N, M;
cin >> N >> M;
VLL A(N);
rep(i, N) { cin >> A[i]; }
vector<pair<ll, ll>> F;
ll res = 0;
rep(i, M) {
ll b, c;
cin >> b >> c;
res += b;
F.PB(make_pair(c, b));
}
if (res <= N) {
res = res;
} else {
res = N;
}
sort(all(F));
reverse(all(F));
VLL S;
bool judge = false;
while (1) {
for (int i = 0; i < M; i++) {
for (int j = 0; j < F[i].S; j++) {
S.PB(F[i].F);
if (S.size() == res) {
judge = true;
break;
}
}
if (judge)
break;
}
if (judge)
break;
}
// cout << S.size() << endl;
sort(all(A));
reverse(all(A));
ll counter_a = 0;
ll counter_s = 0;
ll sum = 0;
rep(i, N) {
if (A[counter_a] >= S[counter_s]) {
sum += A[counter_a];
counter_a++;
continue;
}
if (A[counter_a] <= S[counter_s] && counter_s < S.size()) {
sum += S[counter_s];
counter_s++;
continue;
}
}
cout << sum << endl;
} | insert | 102 | 102 | 102 | 107 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef long long ll;
ll inf = -1;
ll mod = pow(10, 9) + 7;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<P> cb(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> cb[i].second >> cb[i].first;
}
sort(a.begin(), a.end());
sort(cb.begin(), cb.end(), greater<P>());
vector<int> c;
int cnt = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < cb[i].second; j++) {
if (cnt >= n) {
break;
}
c.push_back(cb[i].first);
cnt++;
}
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += max(a[i], c[i]);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
typedef long long ll;
ll inf = -1;
ll mod = pow(10, 9) + 7;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<P> cb(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> cb[i].second >> cb[i].first;
}
sort(a.begin(), a.end());
sort(cb.begin(), cb.end(), greater<P>());
vector<int> c;
int cnt = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < cb[i].second; j++) {
if (cnt >= n) {
break;
}
c.push_back(cb[i].first);
cnt++;
}
}
ll ans = 0;
if (c.size() < n) {
for (int i = 0; i < n - c.size(); i++) {
c.push_back(0);
}
}
for (int i = 0; i < n; i++) {
ans += max(a[i], c[i]);
}
cout << ans << endl;
return 0;
} | insert | 40 | 40 | 40 | 45 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007LL;
bool cmp(const pair<int, ll> &a, const pair<int, ll> &b) {
if (a.second > b.second)
return true;
else if (a.second == b.second && a.first > b.first)
return true;
else
return false;
}
int main(void) {
int N, M;
cin >> N >> M;
vector<ll> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
#ifdef DEBUG
for (int i = 0; i < N; i++) {
cout << A[i] << " ";
}
cout << endl;
#endif
vector<pair<int, ll>> Q(M);
for (int j = 0; j < M; j++) {
int b;
ll c;
cin >> b >> c;
Q.push_back(make_pair(b, c));
}
sort(Q.begin(), Q.end(), cmp);
#ifdef DEBUG
for (int j = 0; j < M; j++) {
cout << Q[j].first << " " << Q[j].second << endl;
}
#endif
auto itr = A.begin();
for (int j = 0; j < M && itr != A.end(); j++) {
if (*itr >= Q[j].second)
break;
for (int i = 0; i < Q[j].first; itr++, i++)
if (itr != A.end())
if (*itr < Q[j].second)
*itr = Q[j].second;
}
ll Y = accumulate(A.begin(), A.end(), 0LL);
cout << Y << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007LL;
bool cmp(const pair<int, ll> &a, const pair<int, ll> &b) {
if (a.second > b.second)
return true;
else if (a.second == b.second && a.first > b.first)
return true;
else
return false;
}
int main(void) {
int N, M;
cin >> N >> M;
vector<ll> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
#ifdef DEBUG
for (int i = 0; i < N; i++) {
cout << A[i] << " ";
}
cout << endl;
#endif
vector<pair<int, ll>> Q(M);
for (int j = 0; j < M; j++) {
int b;
ll c;
cin >> b >> c;
Q.push_back(make_pair(b, c));
}
sort(Q.begin(), Q.end(), cmp);
#ifdef DEBUG
for (int j = 0; j < M; j++) {
cout << Q[j].first << " " << Q[j].second << endl;
}
#endif
auto itr = A.begin();
for (int j = 0; j < M && itr != A.end(); j++) {
if (*itr >= Q[j].second)
break;
for (int i = 0; i < Q[j].first && itr != A.end(); itr++, i++)
if (*itr < Q[j].second)
*itr = Q[j].second;
}
ll Y = accumulate(A.begin(), A.end(), 0LL);
cout << Y << endl;
return 0;
}
| replace | 54 | 58 | 54 | 57 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
ll n, m, l, ans;
ll a[100005];
priority_queue<pll> pq;
int main() {
cin >> n >> m;
for (ll i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (ll b, c, i = 0; i < m; ++i) {
cin >> b >> c;
pq.emplace(c, b);
}
while (!pq.empty()) {
pll top = pq.top();
pq.pop();
while (top.second-- && a[l] < top.first) {
a[l++] = top.first;
}
}
for (ll x : a)
ans += x;
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
ll n, m, l, ans;
ll a[100005];
priority_queue<pll> pq;
int main() {
cin >> n >> m;
for (ll i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (ll b, c, i = 0; i < m; ++i) {
cin >> b >> c;
pq.emplace(c, b);
}
while (!pq.empty()) {
pll top = pq.top();
pq.pop();
while (l < n && top.second-- && a[l] < top.first) {
a[l++] = top.first;
}
}
for (ll x : a)
ans += x;
cout << ans;
return 0;
}
| replace | 22 | 23 | 22 | 23 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
priority_queue<ll, vector<ll>, greater<ll>> q;
ll n, m, x, ans = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
q.push(x);
}
vector<pair<ll, ll>> v(m);
for (int i = 0; i < m; i++)
cin >> v[i].second >> v[i].first;
sort(v.begin(), v.end(), greater<>());
for (int i = 0; i < m; i++) {
for (int j = 0; j < v[i].second; j++) {
if (q.top() >= v[i].first)
break;
ans += v[i].first;
q.pop();
}
}
while (!q.empty()) {
ans += q.top();
q.pop();
}
cout << ans;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
priority_queue<ll, vector<ll>, greater<ll>> q;
ll n, m, x, ans = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
q.push(x);
}
vector<pair<ll, ll>> v(m);
for (int i = 0; i < m; i++)
cin >> v[i].second >> v[i].first;
sort(v.begin(), v.end(), greater<>());
for (int i = 0; i < m; i++) {
for (int j = 0; j < v[i].second; j++) {
if (q.empty() || q.top() >= v[i].first)
break;
ans += v[i].first;
q.pop();
}
}
while (!q.empty()) {
ans += q.top();
q.pop();
}
cout << ans;
} | replace | 22 | 23 | 22 | 23 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
#define revrep(i, N) for (int i = N - 1; i >= 0; i--)
#define coutline cout << "------------ (" << __LINE__ << ")" << endl;
typedef long long ll;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> CB(N);
rep(i, N) { cin >> A.at(i); }
rep(i, M) {
int b, c;
cin >> b >> c;
CB.at(i) = make_pair(c, b);
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end(), std::greater<pair<int, int>>());
ll ret = 0;
auto itrA = A.begin();
auto itrC = CB.begin();
while (itrA != A.end()) {
if (itrC != CB.end() && *itrA < itrC->first) {
ret += itrC->first;
itrC->second--;
if (itrC->second <= 0)
itrC++;
} else {
ret += *itrA;
}
itrA++;
}
cout << ret << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
#define revrep(i, N) for (int i = N - 1; i >= 0; i--)
#define coutline cout << "------------ (" << __LINE__ << ")" << endl;
typedef long long ll;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> CB(M);
rep(i, N) { cin >> A.at(i); }
rep(i, M) {
int b, c;
cin >> b >> c;
CB.at(i) = make_pair(c, b);
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end(), std::greater<pair<int, int>>());
ll ret = 0;
auto itrA = A.begin();
auto itrC = CB.begin();
while (itrA != A.end()) {
if (itrC != CB.end() && *itrA < itrC->first) {
ret += itrC->first;
itrC->second--;
if (itrC->second <= 0)
itrC++;
} else {
ret += *itrA;
}
itrA++;
}
cout << ret << endl;
return 0;
}
| replace | 24 | 25 | 24 | 25 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <string>
using namespace std;
using ulli = long long int;
int main() {
int n, m;
cin >> n >> m;
deque<ulli> cards;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
cards.push_back(temp);
}
sort(cards.begin(), cards.end());
deque<pair<int, ulli>> bc;
for (int i = 0; i < m; i++) {
int b;
ulli c;
cin >> b >> c;
bc.emplace_back(make_pair(b, c));
}
sort(bc.begin(), bc.end(), [](auto const &lhs, auto const &rhs) {
return lhs.second > rhs.second;
});
ulli res = 0;
deque<ulli>::iterator p = cards.begin();
while (!bc.empty() && bc.front().second > *p) {
*p = bc.front().second;
bc.front().first--;
p++;
if (bc.front().first == 0) {
bc.pop_front();
}
}
while (!cards.empty()) {
res += cards.front();
cards.pop_front();
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <string>
using namespace std;
using ulli = long long int;
int main() {
int n, m;
cin >> n >> m;
deque<ulli> cards;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
cards.push_back(temp);
}
sort(cards.begin(), cards.end());
deque<pair<int, ulli>> bc;
for (int i = 0; i < m; i++) {
int b;
ulli c;
cin >> b >> c;
bc.emplace_back(make_pair(b, c));
}
sort(bc.begin(), bc.end(), [](auto const &lhs, auto const &rhs) {
return lhs.second > rhs.second;
});
ulli res = 0;
deque<ulli>::iterator p = cards.begin();
while (!bc.empty() && bc.front().second > *p && p != cards.end()) {
*p = bc.front().second;
bc.front().first--;
p++;
if (bc.front().first == 0) {
bc.pop_front();
}
}
while (!cards.empty()) {
res += cards.front();
cards.pop_front();
}
cout << res << endl;
return 0;
} | replace | 31 | 32 | 31 | 32 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cstdint>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
struct BC {
uint32_t B;
uint32_t C;
};
int main() {
uint32_t N, M;
cin >> N >> M;
vector<uint32_t> A;
uint64_t sum = 0;
for (uint32_t i = 0; i < N; ++i) {
uint32_t t;
cin >> t;
A.push_back(t);
sum += t;
}
sort(A.begin(), A.end());
vector<BC> bc;
for (uint32_t i = 0; i < M; i++) {
uint32_t B, C;
cin >> B >> C;
bc.push_back(BC{B, C});
}
sort(bc.begin(), bc.end(), [](const BC &x, const BC y) { return x.C > y.C; });
int k = 0;
for (int i = 0; i < M; i++) {
for (int j = 0; j < bc[i].B; j++) {
if (A[k] >= bc[i].C) {
cout << sum << endl;
return 0;
}
sum += bc[i].C - A[k];
k++;
}
}
cout << sum << endl;
}
| #include <algorithm>
#include <cstdint>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
struct BC {
uint32_t B;
uint32_t C;
};
int main() {
uint32_t N, M;
cin >> N >> M;
vector<uint32_t> A;
uint64_t sum = 0;
for (uint32_t i = 0; i < N; ++i) {
uint32_t t;
cin >> t;
A.push_back(t);
sum += t;
}
sort(A.begin(), A.end());
vector<BC> bc;
for (uint32_t i = 0; i < M; i++) {
uint32_t B, C;
cin >> B >> C;
bc.push_back(BC{B, C});
}
sort(bc.begin(), bc.end(), [](const BC &x, const BC y) { return x.C > y.C; });
int k = 0;
for (int i = 0; i < M; i++) {
for (int j = 0; j < bc[i].B; j++) {
if (k >= N || A[k] >= bc[i].C) {
cout << sum << endl;
return 0;
}
sum += bc[i].C - A[k];
k++;
}
}
cout << sum << endl;
}
| replace | 38 | 39 | 38 | 39 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, b, c;
cin >> n >> m;
vector<int> a(n);
vector<vector<int>> op(m);
for (int i = 0; i < n; i++)
cin >> a.at(i);
for (int i = 0; i < m; i++) {
cin >> b >> c;
op.at(i) = {c, b};
}
sort(a.begin(), a.end());
sort(op.begin(), op.end());
reverse(op.begin(), op.end());
int p = 0;
for (int i = 0; i < m; i++) {
b = op.at(i).at(1);
c = op.at(i).at(0);
while (a.at(p) < c && b > 0 && p < n) {
a.at(p) = c;
b--;
p++;
}
if (b > 0)
break;
}
int64_t ans = 0;
for (int i = 0; i < n; i++)
ans += a.at(i);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, b, c;
cin >> n >> m;
vector<int> a(n);
vector<vector<int>> op(m);
for (int i = 0; i < n; i++)
cin >> a.at(i);
for (int i = 0; i < m; i++) {
cin >> b >> c;
op.at(i) = {c, b};
}
sort(a.begin(), a.end());
sort(op.begin(), op.end());
reverse(op.begin(), op.end());
int p = 0;
for (int i = 0; i < m; i++) {
b = op.at(i).at(1);
c = op.at(i).at(0);
while (b > 0 && p < n &&
a.at(p) < c) { // 判定の順序のせいでa[n]out_of_rangeになった
a.at(p) = c;
b--;
p++;
}
if (b > 0)
break;
}
int64_t ans = 0;
for (int i = 0; i < n; i++)
ans += a.at(i);
cout << ans << endl;
} | replace | 22 | 23 | 22 | 24 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long ll;
using namespace std;
int main() {
// input
int n, m, a, b, c;
cin >> n >> m;
vector<pair<ll, int>> cb;
rep(i, n) {
cin >> a;
cb.push_back(make_pair(a, 1));
}
rep(i, m) {
cin >> b >> c;
cb[i] = make_pair(c, b);
}
sort(cb.begin(), cb.end(), greater<pair<ll, int>>());
// solve
ll ans = 0;
rep(i, cb.size()) {
if (n > cb[i].second) {
ans += cb[i].first * cb[i].second;
n -= cb[i].second;
if (n == 0)
break;
} else {
ans += cb[i].first * n;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long ll;
using namespace std;
int main() {
// input
int n, m, a, b, c;
cin >> n >> m;
vector<pair<ll, int>> cb;
rep(i, n) {
cin >> a;
cb.push_back(make_pair(a, 1));
}
rep(i, m) {
cin >> b >> c;
cb.push_back(make_pair(c, b));
}
sort(cb.begin(), cb.end(), greater<pair<ll, int>>());
// solve
ll ans = 0;
rep(i, cb.size()) {
if (n > cb[i].second) {
ans += cb[i].first * cb[i].second;
n -= cb[i].second;
if (n == 0)
break;
} else {
ans += cb[i].first * n;
break;
}
}
cout << ans << endl;
} | replace | 16 | 17 | 16 | 17 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define all \
int i = 0; \
i < n; \
i++
#define pb push_back
typedef long long int ll;
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define endl '\n'
#define mod 1000000007
bool sortinrev(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.first > b.first);
}
vector<pair<ll, ll>> v;
int main() {
FAST_IO;
ll n, m, x, ans = 0;
cin >> n >> m;
ll arr[n];
for (all)
cin >> arr[i];
sort(arr, arr + n);
v.resize(n);
for (int i = 0; i < m; i++)
cin >> v[i].second >> v[i].first;
sort(v.begin(), v.end(), sortinrev);
int j = 0, flag = 0;
for (int i = 0; i < m; i++) {
if (flag == 1)
break;
while (true) {
if (j >= n || v[i].second <= 0)
break;
if (arr[j] < v[i].first) {
arr[j] = v[i].first;
v[i].second--;
j++;
} else {
flag = 1;
break;
}
}
}
for (int i = 0; i < n; i++)
ans += arr[i];
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define all \
int i = 0; \
i < n; \
i++
#define pb push_back
typedef long long int ll;
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define endl '\n'
#define mod 1000000007
bool sortinrev(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.first > b.first);
}
vector<pair<ll, ll>> v;
int main() {
FAST_IO;
ll n, m, x, ans = 0;
cin >> n >> m;
ll arr[n];
for (all)
cin >> arr[i];
sort(arr, arr + n);
v.resize(m);
for (int i = 0; i < m; i++)
cin >> v[i].second >> v[i].first;
sort(v.begin(), v.end(), sortinrev);
int j = 0, flag = 0;
for (int i = 0; i < m; i++) {
if (flag == 1)
break;
while (true) {
if (j >= n || v[i].second <= 0)
break;
if (arr[j] < v[i].first) {
arr[j] = v[i].first;
v[i].second--;
j++;
} else {
flag = 1;
break;
}
}
}
for (int i = 0; i < n; i++)
ans += arr[i];
cout << ans << endl;
}
| replace | 28 | 29 | 28 | 29 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long mo = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
int main() {
ll N, M;
cin >> N >> M;
deque<ll> A;
priority_queue<Pll> B;
ll a, b, c;
rep(i, N) {
cin >> a;
A.push_back(a);
}
sort(A.begin(), A.end());
rep(i, M) {
cin >> b >> c;
B.push(Pll(c, b));
}
ll cnt = 0;
rep(i, M) {
if (cnt > N)
break;
c = B.top().first;
b = B.top().second;
cnt += b;
B.pop();
rep(j, b) {
auto itr = lower_bound(A.begin(), A.end(), c);
if (itr == A.begin()) {
break;
} else {
A.erase(A.begin());
A.insert(itr, c);
}
}
}
ll sum = 0;
rep(i, N) {
// cout << A[i] << " ";
sum += A[i];
}
// cout << endl;
cout << sum << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
long long mo = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
int main() {
ll N, M;
cin >> N >> M;
deque<ll> A;
priority_queue<Pll> B;
ll a, b, c;
rep(i, N) {
cin >> a;
A.push_back(a);
}
sort(A.begin(), A.end());
rep(i, M) {
cin >> b >> c;
B.push(Pll(c, b));
}
ll cnt = 0;
rep(i, M) {
if (cnt > N)
break;
c = B.top().first;
b = B.top().second;
cnt += b;
B.pop();
rep(j, b) {
auto itr = lower_bound(A.begin(), A.end(), c);
if (itr == A.begin()) {
break;
} else if (itr == A.end()) {
A.erase(A.begin());
A.insert(A.end(), c);
} else {
A.erase(A.begin());
A.insert(itr, c);
}
}
}
ll sum = 0;
rep(i, N) {
// cout << A[i] << " ";
sum += A[i];
}
// cout << endl;
cout << sum << endl;
}
| insert | 44 | 44 | 44 | 47 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long long ll;
const int INT_INF = 1e9;
const ll INF = 1LL << 30;
const ll MOD = 1e9 + 7;
int main() {
ll n, m;
cin >> n >> m;
V<ll> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
V<P<ll, ll>> pa(m);
for (int i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
pa[i] = make_pair(c, b);
}
sort(ALL(a));
sort(ALL(pa), greater<P<ll, ll>>());
int p = 0;
for (int i = 0; i < m; i++) {
if (n < p)
break;
ll b = pa[i].second;
ll c = pa[i].first;
if (a[p] <= c) {
for (int j = p; j < p + b; j++) {
if (a[j] <= c)
a[j] = c;
}
p += b;
}
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long long ll;
const int INT_INF = 1e9;
const ll INF = 1LL << 30;
const ll MOD = 1e9 + 7;
int main() {
ll n, m;
cin >> n >> m;
V<ll> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
V<P<ll, ll>> pa(m);
for (int i = 0; i < m; i++) {
ll b, c;
cin >> b >> c;
pa[i] = make_pair(c, b);
}
sort(ALL(a));
sort(ALL(pa), greater<P<ll, ll>>());
int p = 0;
for (int i = 0; i < m; i++) {
if (n < p)
break;
ll b = pa[i].second;
ll c = pa[i].first;
if (a[p] <= c) {
for (int j = p; j < min(p + b, n); j++) {
if (a[j] <= c)
a[j] = c;
}
p += b;
}
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << endl;
}
| replace | 35 | 36 | 35 | 36 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long int64;
int main(void) {
int64 N, M;
cin >> N >> M;
vector<int64> A(N);
vector<pair<int64, int64>> CB(M);
int64 ans = 0;
for (int64 i = 0; i < N; i++) {
cin >> A[i];
}
int64 b, c;
for (int64 i = 0; i < M; i++) {
cin >> b >> c;
CB[i] = make_pair(c, b);
}
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
int64 j = 0;
int64 tmp = 0;
while (tmp <= N) {
for (int64 i = 0; i < CB[j].second; i++) {
A.push_back(CB[j].first);
tmp++;
// cout<<CB[j].first<<endl;
if (tmp > N)
break;
}
j++;
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
for (int64 i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long int64;
int main(void) {
int64 N, M;
cin >> N >> M;
vector<int64> A(N);
vector<pair<int64, int64>> CB(M);
int64 ans = 0;
for (int64 i = 0; i < N; i++) {
cin >> A[i];
}
int64 b, c;
for (int64 i = 0; i < M; i++) {
cin >> b >> c;
CB[i] = make_pair(c, b);
}
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
int64 j = 0;
int64 tmp = 0;
while (tmp <= N) {
for (int64 i = 0; i < CB[j].second; i++) {
A.push_back(CB[j].first);
tmp++;
// cout<<CB[j].first<<endl;
if (tmp > N)
break;
}
j++;
if (j >= M)
break;
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
for (int64 i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | insert | 42 | 42 | 42 | 44 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], n, m;
vector<pair<int, int>> v;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v.push_back(make_pair(y, x));
}
int pos = 0;
sort(a, a + n);
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
int x = v[i].first, y = v[i].second;
int sum = y + pos;
for (int i = pos; i < sum; i++) {
if (a[i] > x)
break;
else
a[i] = x;
pos++;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
// cout<<a[i]<<endl;
ans += a[i];
}
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], n, m;
vector<pair<int, int>> v;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v.push_back(make_pair(y, x));
}
int pos = 0;
sort(a, a + n);
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int now = -1, has = 0, x;
for (int i = 0; i < n; i++) {
if (has == 0) {
now++;
x = v[now].first;
has = v[now].second;
}
if (a[i] > x)
break;
else {
a[i] = x;
has--;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
// cout<<a[i]<<endl;
ans += a[i];
}
printf("%lld", ans);
return 0;
} | replace | 21 | 30 | 21 | 33 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using st = string;
using db = double;
using vll = vector<long long>;
using vdb = vector<db>;
using vvll = vector<vll>;
using vst = vector<st>;
using vchar = vector<char>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
#define rep(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define vrep(i, vec) for (auto &i : vec)
#define vin(vec) \
for (auto &i : vec) \
cin >> i
#define all(v) v.begin(), v.end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const ll mod = 1000000007;
const ll inf = 1LL << 60;
int main() {
ll n, m;
cin >> n >> m;
vll a(n);
vin(a);
vpll chn(m);
rep(i, 0, m) {
ll b, c;
cin >> c >> b;
chn.at(i) = make_pair(b, c);
}
sort(all(a));
sort(all(chn), greater<pll>());
ll now = 0;
vrep(i, chn) {
ll value = i.first, j = i.second;
while (j > 0) {
if (a.at(now) < value && now < n) {
a.at(now) = value;
j--;
now++;
} else
goto out;
}
}
out:
cout << accumulate(all(a), 0ll) << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using st = string;
using db = double;
using vll = vector<long long>;
using vdb = vector<db>;
using vvll = vector<vll>;
using vst = vector<st>;
using vchar = vector<char>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
#define rep(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define vrep(i, vec) for (auto &i : vec)
#define vin(vec) \
for (auto &i : vec) \
cin >> i
#define all(v) v.begin(), v.end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const ll mod = 1000000007;
const ll inf = 1LL << 60;
int main() {
ll n, m;
cin >> n >> m;
vll a(n);
vin(a);
vpll chn(m);
rep(i, 0, m) {
ll b, c;
cin >> c >> b;
chn.at(i) = make_pair(b, c);
}
sort(all(a));
sort(all(chn), greater<pll>());
ll now = 0;
vrep(i, chn) {
ll value = i.first, j = i.second;
while (j > 0) {
if (now < n && a.at(now) < value) {
a.at(now) = value;
j--;
now++;
} else
goto out;
}
}
out:
cout << accumulate(all(a), 0ll) << endl;
} | replace | 56 | 57 | 56 | 57 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define MaxSize 100005
ll n, m, sum = 0;
ll a[MaxSize];
P res[MaxSize];
void Solve() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++)
cin >> res[i].second >> res[i].first;
sort(res, res + m, greater<P>());
sort(a, a + n);
int tmp = 0;
for (int i = 0; i < m; i++) {
int tmp1 = tmp;
for (int j = tmp1; j < tmp1 + res[i].second; j++) {
if (a[j] < res[i].first) {
a[j] = res[i].first;
tmp++;
} else
break;
}
}
for (int i = 0; i < n; i++)
sum += a[i];
cout << sum << endl;
}
int main() {
Solve();
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define MaxSize 100005
ll n, m, sum = 0;
ll a[MaxSize];
P res[MaxSize];
void Solve() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++)
cin >> res[i].second >> res[i].first;
sort(res, res + m, greater<P>());
sort(a, a + n);
int tmp = 0;
for (int i = 0; i < m; i++) {
int tmp1 = tmp;
for (int j = tmp1; j < tmp1 + res[i].second; j++) {
if (tmp >= n)
break;
else if (a[j] < res[i].first) {
a[j] = res[i].first;
tmp++;
} else
break;
}
}
for (int i = 0; i < n; i++)
sum += a[i];
cout << sum << endl;
}
int main() {
Solve();
return 0;
} | replace | 21 | 22 | 21 | 24 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using lli = long long int;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const pair<T, T> &p) {
o << "(" << p.first << ", " << p.second << ")";
return o;
}
#define rep(i, n) for (lli i = 0; i < (lli)(n); i++)
const lli MOD = 1000000007LL;
lli modpow(lli a, lli n) {
lli res = 1;
for (lli ai = a; n; n >>= 1) {
if (1 & n)
res = (res * ai) % MOD;
ai = (ai * ai) % MOD;
}
return res;
}
lli inv(lli n) { return modpow(n, MOD - 2); }
lli modperm(lli n, lli k) {
lli res = 1;
rep(i, k) { res = (res * (n - i)) % MOD; }
return res;
}
lli modcomb(lli n, lli k) { return (modperm(n, k) * inv(modperm(k, k))) % MOD; }
lli posmod(lli n) {
lli res = n;
res %= MOD;
if (res < 0)
res += MOD;
return res;
}
lli n, m;
vector<lli> A, D;
vector<pair<lli, lli>> cb;
lli res = 0;
int main(void) {
cin >> n >> m;
rep(i, n) {
lli a;
cin >> a;
A.push_back(a);
}
rep(j, m) {
lli b, c;
cin >> b >> c;
cb.push_back(make_pair(c, b));
}
sort(cb.begin(), cb.end(), greater<pair<lli, lli>>());
for (auto i : cb) {
while (i.second-- && D.size() < n) {
D.push_back(i.first);
}
}
rep(i, n) { A.push_back(D[i]); }
sort(A.begin(), A.end(), greater<lli>());
rep(i, n) { res += A[i]; }
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using lli = long long int;
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "{";
for (int i = 0; i < (int)v.size(); i++)
o << (i > 0 ? ", " : "") << v[i];
o << "}";
return o;
}
template <class T> ostream &operator<<(ostream &o, const pair<T, T> &p) {
o << "(" << p.first << ", " << p.second << ")";
return o;
}
#define rep(i, n) for (lli i = 0; i < (lli)(n); i++)
const lli MOD = 1000000007LL;
lli modpow(lli a, lli n) {
lli res = 1;
for (lli ai = a; n; n >>= 1) {
if (1 & n)
res = (res * ai) % MOD;
ai = (ai * ai) % MOD;
}
return res;
}
lli inv(lli n) { return modpow(n, MOD - 2); }
lli modperm(lli n, lli k) {
lli res = 1;
rep(i, k) { res = (res * (n - i)) % MOD; }
return res;
}
lli modcomb(lli n, lli k) { return (modperm(n, k) * inv(modperm(k, k))) % MOD; }
lli posmod(lli n) {
lli res = n;
res %= MOD;
if (res < 0)
res += MOD;
return res;
}
lli n, m;
vector<lli> A, D;
vector<pair<lli, lli>> cb;
lli res = 0;
int main(void) {
cin >> n >> m;
rep(i, n) {
lli a;
cin >> a;
A.push_back(a);
}
rep(j, m) {
lli b, c;
cin >> b >> c;
cb.push_back(make_pair(c, b));
}
sort(cb.begin(), cb.end(), greater<pair<lli, lli>>());
for (auto i : cb) {
while (i.second-- && D.size() < n) {
D.push_back(i.first);
}
}
while (D.size() != n)
D.push_back(-LLONG_MAX);
rep(i, n) { A.push_back(D[i]); }
sort(A.begin(), A.end(), greater<lli>());
rep(i, n) { res += A[i]; }
cout << res << endl;
return 0;
}
| insert | 73 | 73 | 73 | 75 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using ll = long long;
using P = pair<ll, ll>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) { cin >> A[i]; }
vector<P> D;
rep(i, M) {
ll B, C;
cin >> B >> C;
D.push_back(make_pair(C, B));
}
sort(A.begin(), A.end());
sort(D.rbegin(), D.rend());
vector<ll> E;
rep(i, M) {
rep(j, D[i].second) {
E.push_back(D[i].first);
if (E.size() == N)
break;
}
}
ll ans = 0;
rep(i, N) {
if (i < E.size())
ans += max(A[i], E[i]);
else
ans += A[i];
}
cout << ans << endl;
return 0;
}
// Ctrl+Shift+Bでコンパイルと実行を行ってデバッグすること | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using ll = long long;
using P = pair<ll, ll>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) { cin >> A[i]; }
vector<P> D;
rep(i, M) {
ll B, C;
cin >> B >> C;
D.push_back(make_pair(C, B));
}
sort(A.begin(), A.end());
sort(D.rbegin(), D.rend());
vector<ll> E;
rep(i, M) {
rep(j, D[i].second) {
E.push_back(D[i].first);
if (E.size() == N)
break;
}
if (E.size() == N)
break;
}
ll ans = 0;
rep(i, N) {
if (i < E.size())
ans += max(A[i], E[i]);
else
ans += A[i];
}
cout << ans << endl;
return 0;
}
// Ctrl+Shift+Bでコンパイルと実行を行ってデバッグすること | insert | 32 | 32 | 32 | 34 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> v;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
int b, c;
vector<vector<int>> sousa;
for (int i = 0; i < m; i++) {
cin >> b >> c;
vector<int> temp = {b, c};
sousa.push_back(temp);
}
sort(sousa.begin(), sousa.end(),
[](auto &x, auto &y) { return x[1] > y[1]; });
vector<int>::iterator it = v.end();
vector<int>::iterator be = v.begin();
for (int i = 0; i < m; i++) {
it = lower_bound(be, it, sousa[i][1]);
if (it != be) {
int count = 0;
for (auto t = be; t != it; t++) {
if (count < sousa[i][0]) {
*t = sousa[i][1];
count++;
be++;
} else {
break;
}
}
} else {
break;
}
sort(be, it);
}
ll res = 0;
for (int i = 0; i < n; i++) {
res += v[i];
}
cout << res << endl;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> v;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
int b, c;
vector<vector<int>> sousa;
for (int i = 0; i < m; i++) {
cin >> b >> c;
vector<int> temp = {b, c};
sousa.push_back(temp);
}
sort(sousa.begin(), sousa.end(),
[](auto &x, auto &y) { return x[1] > y[1]; });
vector<int>::iterator it = v.end();
vector<int>::iterator be = v.begin();
for (int i = 0; i < m; i++) {
it = lower_bound(be, it, sousa[i][1]);
if (it != be) {
int count = 0;
for (auto t = be; t != it; t++) {
if (count < sousa[i][0]) {
*t = sousa[i][1];
count++;
be++;
} else {
break;
}
}
} else {
break;
}
}
ll res = 0;
for (int i = 0; i < n; i++) {
res += v[i];
}
cout << res << endl;
} | delete | 44 | 45 | 44 | 44 | TLE | |
p03038 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
struct Card {
ll b;
ll c;
Card(ll b = 0, ll c = 0) {
this->b = b;
this->c = c;
}
bool operator<(const Card &a) const { return this->c < a.c; }
void print() { printf("b:%2ld c:%2ld\n", this->b, this->c); }
};
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
vector<Card> dic(m);
rep(i, m) {
ll b, c;
cin >> b >> c;
dic[i].b = b;
dic[i].c = c;
}
sort(a.begin(), a.end());
sort(dic.rbegin(), dic.rend());
vector<ll> d;
rep(i, m) rep(j, dic[i].b) d.push_back(dic[i].c);
int ptr = 0;
for (; ptr < d.size(); ptr++) {
if (ptr >= n)
break;
if (a[ptr] > d[ptr])
break;
}
ll ans = 0;
if (ptr >= n) {
rep(i, ptr) ans += d[i];
} else {
rep(i, ptr) ans += d[i];
for (int i = ptr; i < n; i++)
ans += a[i];
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
struct Card {
ll b;
ll c;
Card(ll b = 0, ll c = 0) {
this->b = b;
this->c = c;
}
bool operator<(const Card &a) const { return this->c < a.c; }
void print() { printf("b:%2ld c:%2ld\n", this->b, this->c); }
};
int main() {
int n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
vector<Card> dic(m);
rep(i, m) {
ll b, c;
cin >> b >> c;
dic[i].b = b;
dic[i].c = c;
}
sort(a.begin(), a.end());
sort(dic.rbegin(), dic.rend());
vector<ll> d;
int count = 0;
rep(i, m) {
rep(j, dic[i].b) {
count++;
d.push_back(dic[i].c);
if (count > n)
break;
}
if (count > n)
break;
}
int ptr = 0;
for (; ptr < d.size(); ptr++) {
if (ptr >= n)
break;
if (a[ptr] > d[ptr])
break;
}
ll ans = 0;
if (ptr >= n) {
rep(i, ptr) ans += d[i];
} else {
rep(i, ptr) ans += d[i];
for (int i = ptr; i < n; i++)
ans += a[i];
}
cout << ans << endl;
}
| replace | 37 | 38 | 37 | 48 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
// 条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
// 最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
// 組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; 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;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
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;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
// 素数は1より大きい
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) { cin >> a[i]; }
sort(a.begin(), a.end());
vector<pair<ll, ll>> p(m);
rep(i, m) { cin >> p[i].second >> p[i].first; }
sort(p.rbegin(), p.rend());
vector<ll> change;
rep(i, m) {
rep(j, p[i].second) {
change.push_back(p[i].first);
if (change.size() == n)
break;
}
}
ll k = change.size();
if (k < n) {
rep(i, n - k) { change.push_back(-1); }
}
ll ans = 0;
rep(i, n) { ans += max(a[i], change[i]); }
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
// 条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
// 最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
// 組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; 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;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
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;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
// 素数は1より大きい
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) { cin >> a[i]; }
sort(a.begin(), a.end());
vector<pair<ll, ll>> p(m);
rep(i, m) { cin >> p[i].second >> p[i].first; }
sort(p.rbegin(), p.rend());
vector<ll> change;
rep(i, m) {
rep(j, p[i].second) {
change.push_back(p[i].first);
if (change.size() == n)
break;
}
if (change.size() == n)
break;
}
ll k = change.size();
if (k < n) {
rep(i, n - k) { change.push_back(-1); }
}
ll ans = 0;
rep(i, n) { ans += max(a[i], change[i]); }
cout << ans << endl;
} | insert | 133 | 133 | 133 | 135 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MAX 5000
#define MOD 1000000007
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> CB(M);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
for (int i = 0; i < M; i++) {
cin >> CB.at(i).second >> CB.at(i).first;
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
int k = 0;
for (int i = 0; i < M; i++) {
bool flag = false;
for (int j = 0; j < CB.at(i).second; j++) {
if (A.at(k) < CB.at(i).first) {
A.at(k) = CB.at(i).first;
k++;
} else {
flag = true;
break;
}
}
if (flag) {
break;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += A.at(i);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MAX 5000
#define MOD 1000000007
int main() {
int N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> CB(M);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
for (int i = 0; i < M; i++) {
cin >> CB.at(i).second >> CB.at(i).first;
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
int k = 0;
for (int i = 0; i < M; i++) {
bool flag = false;
for (int j = 0; j < CB.at(i).second; j++) {
if (A.at(k) < CB.at(i).first) {
A.at(k) = CB.at(i).first;
k++;
if (k == N) {
flag = true;
break;
}
} else {
flag = true;
break;
}
}
if (flag) {
break;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += A.at(i);
}
cout << ans << endl;
}
| insert | 28 | 28 | 28 | 32 | 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;
const int INF = 1e9;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<pair<int, int>> p(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
// rep(i, m) cin >> p[i].second >> p[i].first;
rep(i, m) {
int b, c;
cin >> b >> c;
p[i] = {c, b};
}
sort(p.rbegin(), p.rend());
ll i = 0;
ll j = 0;
while (a[i] < p[j].first && i < n && j < m) {
a[i] = p[j].first;
i++;
if (p[j].second > 1)
p[j].second--;
else
j++;
}
// int l = 0;
// for (auto pp : p) {
// int cnt = pp.second;
// while (cnt-- && a[l] < pp.first && l < n) {
// a[l++] = pp.first;
// }
// }
ll ans = 0;
rep(i, n) ans += 1LL * 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;
const int INF = 1e9;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<pair<int, int>> p(m);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
// rep(i, m) cin >> p[i].second >> p[i].first;
rep(i, m) {
int b, c;
cin >> b >> c;
p[i] = {c, b};
}
sort(p.rbegin(), p.rend());
ll i = 0;
ll j = 0;
while (a[i] < p[j].first && i < n && j < m) {
a[i] = p[j].first;
i++;
if (p[j].second > 1)
p[j].second--;
else
j++;
}
// int l = 0;
// for (auto pp : p) {
// int cnt = pp.second;
// while (cnt-- && a[l] < pp.first && l < n) {
// a[l++] = pp.first;
// }
// }
ll ans = 0;
rep(i, n) ans += 1LL * a[i];
cout << ans << endl;
return 0;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define INF 100000000000
#define MOD 1000000007
#define ll long long int
using namespace std;
/*
int main(){
int a,b;cin>>a>>b;
if(a>=13) cout<<b<<endl;
else if(a>=6 and a<=12) cout<<b/2<<endl;
else cout<<0<<endl;
// //return 0;
return 0;
}*/
vector<int> box1(1000000000, 0);
vector<int> box2(1000000000, 0);
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N, 0);
ll amax = -1;
ll ans = 0;
set<int> zaatu;
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < N; i++) {
box1[A[i]]++;
// amax = max(amax,A[i]);
ans += A[i];
zaatu.insert(A[i]);
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
box2[c] += b;
zaatu.insert(c);
}
auto itr1 = zaatu.begin(); // int now1 = *itr1;
auto itr2 = zaatu.end();
itr2--; // int now2 = *itr2;
while (itr1 != itr2) {
if (box1[*itr1] == 0) {
itr1++;
continue;
}
if (box2[*itr2] == 0) {
itr2--;
continue;
}
box1[*itr1]--;
box2[*itr2]--;
ans = ans + *itr2 - *itr1;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define INF 100000000000
#define MOD 1000000007
#define ll long long int
using namespace std;
/*
int main(){
int a,b;cin>>a>>b;
if(a>=13) cout<<b<<endl;
else if(a>=6 and a<=12) cout<<b/2<<endl;
else cout<<0<<endl;
// //return 0;
return 0;
}*/
map<int, int> box1; //(1000000000,0);
map<int, int> box2; //(1000000000,0);
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N, 0);
ll amax = -1;
ll ans = 0;
set<int> zaatu;
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < N; i++) {
box1[A[i]]++;
// amax = max(amax,A[i]);
ans += A[i];
zaatu.insert(A[i]);
}
for (int i = 0; i < M; i++) {
int b, c;
cin >> b >> c;
box2[c] += b;
zaatu.insert(c);
}
auto itr1 = zaatu.begin(); // int now1 = *itr1;
auto itr2 = zaatu.end();
itr2--; // int now2 = *itr2;
while (itr1 != itr2) {
if (box1[*itr1] == 0) {
itr1++;
continue;
}
if (box2[*itr2] == 0) {
itr2--;
continue;
}
box1[*itr1]--;
box2[*itr2]--;
ans = ans + *itr2 - *itr1;
}
cout << ans << endl;
return 0;
} | replace | 25 | 27 | 25 | 27 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = ((n)-1); (i) >= 0; (i)--)
#define itn int
#define miele(v) min_element(v.begin(), v.end())
#define maele(v) max_element(v.begin(), v.end())
#define SUM(v) accumulate(v.begin(), v.end(), 0LL)
#define lb(a, key) lower_bound(a.begin(), a.end(), key)
#define ub(a, key) upper_bound(a.begin(), a.end(), key)
#define COUNT(a, key) count(a.begin(), a.end(), key)
#define BITCOUNT(x) __builtin_popcount(x)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
using P = pair<int, int>;
using WeightedGraph = vector<vector<P>>;
using UnWeightedGraph = vector<vector<int>>;
using Real = long double;
using Point = complex<Real>; // Point and Vector2d is the same!
using Vector2d = complex<Real>;
const long long INF = 1LL << 60;
const int MOD = 1000000007;
const double EPS = 1e-15;
const double PI = 3.14159265358979323846;
template <typename T> int getIndexOfLowerBound(vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
template <typename T> int getIndexOfUpperBound(vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define DUMPOUT cerr
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
istream &operator>>(istream &is, Point &p) {
Real a, b;
is >> a >> b;
p = Point(a, b);
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p_var) {
is >> p_var.first >> p_var.second;
return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> istream &operator>>(istream &is, vector<vector<T>> &df) {
for (int i = 0; i < df.size(); i++)
for (int j = 0; j < df[i].size(); j++)
is >> df[i][j];
return is;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
DUMPOUT << '{';
os << pair_var.first;
DUMPOUT << ',';
os << " " << pair_var.second;
DUMPOUT << '}';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
DUMPOUT << '[';
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
DUMPOUT << ']';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &df) {
for (auto &vec : df)
os << vec;
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
DUMPOUT << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
DUMPOUT << ", ";
itr--;
}
DUMPOUT << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
DUMPOUT << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
DUMPOUT << ", ";
itr--;
}
DUMPOUT << "}";
return os;
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head;
if (sizeof...(tail) != 0)
cout << " ";
print(forward<Tail>(tail)...);
}
void dump_func() { DUMPOUT << '#' << endl; }
template <typename Head, typename... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0)
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> a(n);
cin >> a;
priority_queue<int, vector<int>, greater<int>> pq;
rep(i, n) { pq.push(a[i]); }
vector<pair<int, int>> p(n);
rep(i, m) {
int b, c;
cin >> b >> c;
p[i] = {c, b};
}
sort(p.begin(), p.end(), greater<P>());
int ans = 0;
rep(i, m) {
rep(j, p[i].S) {
if (pq.empty())
break;
int tmp = pq.top();
pq.pop();
if (tmp < p[i].F) {
ans += p[i].F;
} else {
pq.push(tmp);
break;
}
}
}
while (!pq.empty()) {
ans += pq.top();
pq.pop();
}
print(ans);
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = ((n)-1); (i) >= 0; (i)--)
#define itn int
#define miele(v) min_element(v.begin(), v.end())
#define maele(v) max_element(v.begin(), v.end())
#define SUM(v) accumulate(v.begin(), v.end(), 0LL)
#define lb(a, key) lower_bound(a.begin(), a.end(), key)
#define ub(a, key) upper_bound(a.begin(), a.end(), key)
#define COUNT(a, key) count(a.begin(), a.end(), key)
#define BITCOUNT(x) __builtin_popcount(x)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
using P = pair<int, int>;
using WeightedGraph = vector<vector<P>>;
using UnWeightedGraph = vector<vector<int>>;
using Real = long double;
using Point = complex<Real>; // Point and Vector2d is the same!
using Vector2d = complex<Real>;
const long long INF = 1LL << 60;
const int MOD = 1000000007;
const double EPS = 1e-15;
const double PI = 3.14159265358979323846;
template <typename T> int getIndexOfLowerBound(vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
template <typename T> int getIndexOfUpperBound(vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define DUMPOUT cerr
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
istream &operator>>(istream &is, Point &p) {
Real a, b;
is >> a >> b;
p = Point(a, b);
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p_var) {
is >> p_var.first >> p_var.second;
return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
template <typename T> istream &operator>>(istream &is, vector<vector<T>> &df) {
for (int i = 0; i < df.size(); i++)
for (int j = 0; j < df[i].size(); j++)
is >> df[i][j];
return is;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
DUMPOUT << '{';
os << pair_var.first;
DUMPOUT << ',';
os << " " << pair_var.second;
DUMPOUT << '}';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
DUMPOUT << '[';
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
DUMPOUT << ']';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &df) {
for (auto &vec : df)
os << vec;
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
DUMPOUT << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
DUMPOUT << ", ";
itr--;
}
DUMPOUT << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
DUMPOUT << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
DUMPOUT << ", ";
itr--;
}
DUMPOUT << "}";
return os;
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head;
if (sizeof...(tail) != 0)
cout << " ";
print(forward<Tail>(tail)...);
}
void dump_func() { DUMPOUT << '#' << endl; }
template <typename Head, typename... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0)
DUMPOUT << ", ";
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> a(n);
cin >> a;
priority_queue<int, vector<int>, greater<int>> pq;
rep(i, n) { pq.push(a[i]); }
vector<pair<int, int>> p(m);
rep(i, m) {
int b, c;
cin >> b >> c;
p[i] = {c, b};
}
sort(p.begin(), p.end(), greater<P>());
int ans = 0;
rep(i, m) {
rep(j, p[i].S) {
if (pq.empty())
break;
int tmp = pq.top();
pq.pop();
if (tmp < p[i].F) {
ans += p[i].F;
} else {
pq.push(tmp);
break;
}
}
}
while (!pq.empty()) {
ans += pq.top();
pq.pop();
}
print(ans);
}
| replace | 153 | 154 | 153 | 154 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> CB(M);
for (int i = 0; i < N; i++)
cin >> A.at(i);
for (int i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
CB.at(i) = make_pair(C, B);
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
vector<int> vec;
for (int i = 0; i < M; i++) {
for (int j = 0; j < CB.at(i).second; j++) {
vec.push_back(CB.at(i).first);
}
}
int i = 0;
int j = 0;
while (i < N && j < vec.size()) {
if (A.at(i) < vec.at(j)) {
A.at(i) = vec.at(j);
i++;
}
j++;
}
long long ans = 0;
for (int i = 0; i < N; i++)
ans += A.at(i);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
vector<pair<int, int>> CB(M);
for (int i = 0; i < N; i++)
cin >> A.at(i);
for (int i = 0; i < M; i++) {
int B, C;
cin >> B >> C;
CB.at(i) = make_pair(C, B);
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end());
reverse(CB.begin(), CB.end());
vector<int> vec;
for (int i = 0; i < M; i++) {
for (int j = 0; j < CB.at(i).second; j++) {
if (vec.size() > N)
break;
vec.push_back(CB.at(i).first);
}
}
int i = 0;
int j = 0;
while (i < N && j < vec.size()) {
if (A.at(i) < vec.at(j)) {
A.at(i) = vec.at(j);
i++;
}
j++;
}
long long ans = 0;
for (int i = 0; i < N; i++)
ans += A.at(i);
cout << ans << endl;
}
| insert | 21 | 21 | 21 | 23 | TLE | |
p03038 | C++ | Time Limit Exceeded | // todo 文字数を少なくする
// mintより高速に計算したい時用に modmul() modadd (正の値限定) を作る
// #pragma GCC optimize ("-O3")
#include <bits/stdc++.h>
using namespace std;
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} __initon;
// 衝突対策
#define ws ___ws
//@必須構造
struct T {
int f, s, t;
T() { f = -1, s = -1, t = -1; }
T(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const T &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const T &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
bool operator==(const T &r) const { return f == r.f && s == r.s && t == r.t; }
bool operator!=(const T &r) const { return f != r.f || s != r.s || t != r.t; }
int operator[](int i) {
assert(i < 3);
return i == 0 ? f : i == 1 ? s : t;
}
};
struct F {
int a, b, c, d;
F() { a = -1, b = -1, c = -1, d = -1; }
F(int a, int b, int c, int d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d;
// return a != r.a ? a > r.a : b != r.b ? b > r.b : c != r.c ? c >
// r.c : d > r.d;
}
bool operator>(const F &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d;
// return a != r.a ? a < r.a : b != r.b ? b < r.b : c != r.c ? c <
// r.c : d < r.d;
}
bool operator==(const F &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
int operator[](int i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
T mt(int a, int b, int c) { return T(a, b, c); }
//@マクロ省略系 型,構造
#define int long long
#define ll long long
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using pd = pair<dou, dou>;
#define fi first
#define se second
#define vec vector
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
// マクロ省略系 コンテナ
using vi = vector<int>;
#define _overloadvvi(_1, _2, _3, _4, name, ...) name
#define vvi0() vec<vi>
#define vvi1(a) vec<vi> a
#define vvi2(a, b) vec<vi> a(b)
#define vvi3(a, b, c) vec<vi> a(b, vi(c))
#define vvi4(a, b, c, d) vec<vi> a(b, vi(c, d))
#define vvi(...) \
_overloadvvi(__VA_ARGS__, vvi4, vvi3, vvi2, vvi1, vvi0)(__VA_ARGS__)
using vl = vector<ll>;
#define _overloadvvl(_1, _2, _3, _4, name, ...) name
#define vvl1(a) vec<vl> a
#define vvl2(a, b) vec<vl> a(b)
#define vvl3(a, b, c) vec<vl> a(b, vl(c))
#define vvl4(a, b, c, d) vec<vl> a(b, vl(c, d))
#define vvl(...) _overloadvvl(__VA_ARGS__, vvl4, vvl3, vvl2, vvl1)(__VA_ARGS__)
using vb = vector<bool>;
#define _overloadvvb(_1, _2, _3, _4, name, ...) name
#define vvb1(a) vec<vb> a
#define vvb2(a, b) vec<vb> a(b)
#define vvb3(a, b, c) vec<vb> a(b, vb(c))
#define vvb4(a, b, c, d) vec<vb> a(b, vb(c, d))
#define vvb(...) _overloadvvb(__VA_ARGS__, vvb4, vvb3, vvb2, vvb1)(__VA_ARGS__)
using vs = vector<string>;
#define _overloadvvs(_1, _2, _3, _4, name, ...) name
#define vvs1(a) vec<vs> a
#define vvs2(a, b) vec<vs> a(b)
#define vvs3(a, b, c) vec<vs> a(b, vs(c))
#define vvs4(a, b, c, d) vec<vs> a(b, vs(c, d))
#define vvs(...) _overloadvvs(__VA_ARGS__, vvs4, vvs3, vvs2, vvs1)(__VA_ARGS__)
using vd = vector<double>;
#define _overloadvvd(_1, _2, _3, _4, name, ...) name
#define vvd1(a) vec<vd> a
#define vvd2(a, b) vec<vd> a(b)
#define vvd3(a, b, c) vec<vd> a(b, vd(c))
#define vvd4(a, b, c, d) vec<vd> a(b, vd(c, d))
#define vvd(...) _overloadvvd(__VA_ARGS__, vvd4, vvd3, vvd2, vvd1)(__VA_ARGS__)
using vc = vector<char>;
#define _overloadvvc(_1, _2, _3, _4, name, ...) name
#define vvc1(a) vec<vc> a
#define vvc2(a, b) vec<vc> a(b)
#define vvc3(a, b, c) vec<vc> a(b, vc(c))
#define vvc4(a, b, c, d) vec<vc> a(b, vc(c, d))
#define vvc(...) _overloadvvc(__VA_ARGS__, vvc4, vvc3, vvc2, vvc1)(__VA_ARGS__)
using vp = vector<P>;
#define _overloadvvp(_1, _2, _3, _4, name, ...) name
#define vvp1(a) vec<vp> a
#define vvp2(a, b) vec<vp> a(b)
#define vvp3(a, b, c) vec<vp> a(b, vp(c))
#define vvp4(a, b, c, d) vec<vp> a(b, vp(c, d))
#define vvp(...) _overloadvvp(__VA_ARGS__, vvp4, vvp3, vvp2, vvp1)(__VA_ARGS__)
using vt = vector<T>;
#define _overloadvvt(_1, _2, _3, _4, name, ...) name
#define vvt1(a) vec<vt> a
#define vvt2(a, b) vec<vt> a(b)
#define vvt3(a, b, c) vec<vt> a(b, vt(c))
#define vvt4(a, b, c, d) vec<vt> a(b, vt(c, d))
#define vvt(...) _overloadvvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1)(__VA_ARGS__)
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
#define _vvi vector<vi>
#define _vvl vector<vl>
#define _vvb vector<vb>
#define _vvs vector<vs>
#define _vvd vector<vd>
#define _vvc vector<vc>
#define _vvp vector<vp>
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<int>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<int, int>;
using mapp = map<P, int>;
using mapd = map<dou, int>;
using mapc = map<char, int>;
using maps = map<str, int>;
using seti = set<int>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<int>;
#define bset bitset
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define umapi unordered_map<int, int>
#define umapp unordered_map<P, int>
#define mmap multimap
// マクロ 繰り返し
#define _overloadrep(_1, _2, _3, _4, name, ...) name
#define _rep(i, n) for (int i = 0, _lim = n; i < _lim; i++)
#define repi(i, m, n) for (int i = m, _lim = n; i < _lim; i++)
#define repadd(i, m, n, ad) for (int i = m, _lim = n; i < _lim; i += ad)
#define rep(...) _overloadrep(__VA_ARGS__, repadd, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m, _lim = n; i >= _lim; i--)
#define rerdec(i, m, n, dec) for (int i = m, _lim = n; i >= _lim; i -= dec)
#define rer(...) _overloadrep(__VA_ARGS__, rerdec, reri, _rer, )(__VA_ARGS__)
#define reps2(i, j, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++)
#define reps3(i, j, k, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++)
#define reps4(i, j, k, l, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++) \
for (int l = 0; l < _lim; l++)
#define _overloadreps(_1, _2, _3, _4, _5, name, ...) name
#define reps(...) \
_overloadreps(__VA_ARGS__, reps4, reps3, reps2, _rep, )(__VA_ARGS__)
#define repss(i, j, k, a, b, c) \
for (int i = 0; i < a; i++) \
for (int j = 0; j < b; j++) \
for (int k = 0; k < c; k++)
#define fora(a, b) for (auto &&a : b)
#define forg(gi, ve) \
for (int gi = 0, _lim = ve.size(), f, t, c; \
gi < _lim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); gi++)
#define fort(gi, ve) \
for (int gi = 0, f, t, c; \
gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); \
gi++) \
if (t != p)
// #define fort(gi, ve) for (int gi = 0, f, t, c;gi<ve.size()&& (gi+=
// (ve[gi].t==p))< ve.size() && (f = ve[gi].f,t=ve[gi].t, c = ve[gi].c,true);
// gi++)
#define form(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; it++)
#define forit(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r; it++)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int inf = (int)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((int)(a).size())
// #define rs resize
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
constexpr bool ev(int a) { return !(a & 1); }
constexpr bool od(int a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
// 大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
for (T &x : vec)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se << endl;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < vec[0].size(); j++) {
os << vec[i][j];
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
for (auto &&v : m)
os << v;
return os;
}
template <typename V, typename H> void resize(vector<V> &vec, const H head) {
vec.resize(head);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &vec, const H &head, const T... tail) {
vec.resize(head);
for (auto &v : vec)
resize(v, tail...);
}
template <typename T, typename _Pr>
bool all_of(const vector<T> &vec, _Pr pred) {
return std::all_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool any_of(const vector<T> &vec, _Pr pred) {
return std::any_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool none_of(const vector<T> &vec, _Pr pred) {
return std::none_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
const typename vector<T>::const_iterator find_if(const vector<T> &vec,
_Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred);
}
template <class T> bool contains(const std::string &s, const T &v) {
return s.find(v) != std::string::npos;
}
template <typename T> bool contains(const vector<T> &vec, const T &val) {
return std::find(vec.begin(), vec.end(), val) != vec.end();
}
template <typename T, typename _Pr>
bool contains_if(const vector<T> &vec, _Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred) != vec.end();
}
template <class T, class U> void replace(vector<T> &a, T key, U v) {
replace(a.begin(), a.end(), key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(all(a), key), a.end());
}
void replace(str &a, str key, str v) {
if (v == "")
a.erase(remove(all(a), key[0]), a.end());
else
replace(all(a), key[0], v[0]);
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(all(c));
sort(all(d));
return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(all(a));
}
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
inline void sort(string &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
}
template <class T, class F> inline void sort(vector<T> &a, F f) {
sort(a.begin(), a.end(), [&](T a, T b) { return f(a) < f(b); });
}
enum ___pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
inline void sort(vector<P> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
break;
case fisd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
break;
case fdsi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
break;
case fdsd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
break;
case sifi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
break;
case sifd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
break;
case sdfi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
break;
case sdfd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
break;
}
};
inline void sort(vector<T> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
break;
case fisd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
break;
case fdsi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
break;
case fdsd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
break;
case sifi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
break;
case sifd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
break;
case sdfi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
break;
case sdfd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
break;
}
};
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
template <class U, class F> inline void rsort(vector<U> &a, F f) {
sort(a.begin(), a.end(), [&](U l, U r) { return f(l) > f(r); });
};
template <class U> inline void sortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
;
}
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class U, class F> inline void sortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void sortp(vector<U> &a, vector<U> &b, char type) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, type);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void rsortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void rsortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
// indexをつけてsortする (second)
template <class T> auto sorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
sort(ret);
return ret;
};
template <class T> auto rsorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
rsort(ret);
return ret;
};
template <class T> inline void sort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
sort(a[i]);
}
template <class T> inline void rsort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
rsort(a[i]);
}
template <typename A, size_t N, typename T>
inline void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
inline void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
inline void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
inline void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
inline void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
inline void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
template <typename V, typename T> void fill(V &xx, const T vall) { xx = vall; }
template <typename V, typename T> void fill(vector<V> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
//@汎用便利関数 入力
inline int in() {
int ret;
// scanf("%lld", &ret);
cin >> ret;
return ret;
}
inline string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> inline void in(T &head) { cin >> head; }
template <class T, class... U> inline void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
#define _overloaddin(_1, _2, _3, _4, name, ...) name
#define din1(a) \
int a; \
cin >> a
#define din2(a, b) \
int a, b; \
cin >> a >> b
#define din3(a, b, c) \
int a, b, c; \
cin >> a >> b >> c
#define din4(a, b, c, d) \
int a, b, c, d; \
cin >> a >> b >> c >> d
#define din(...) _overloaddin(__VA_ARGS__, din4, din3, din2, din1)(__VA_ARGS__)
#define _overloaddind(_1, _2, _3, _4, name, ...) name
#define din1d(a) \
din1(a); \
a--
#define din2d(a, b) \
din2(a, b); \
a--, b--
#define din3d(a, b, c) \
din3(a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din4(a, b, c, d); \
a--, b--, c--, d--
#define dind(...) \
_overloaddind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
#define _overloadout(_1, _2, _3, _4, name, ...) name
#define out1(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define out3(a, b, c) cout << a << " " << b << " " << c << endl
#define out4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl
#define out(...) \
_overloadout((__VA_ARGS__), out4, out3, out2, out1)((__VA_ARGS__))
template <class T> void outl(vector<T> &a) { fora(v, a) cout << v << endl; }
#define na(a, n) \
a.resize(n); \
rep(_i, n) cin >> a[_i];
#define dna(a, n) \
vi a(n); \
rep(_i, n) cin >> a[_i];
#define nao(a, n) \
a.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1];
#define nad(a, n) \
a.resize(n); \
rep(_i, n) { \
cin >> a[_i]; \
a[_i]--; \
}
#define na2(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define dna2(a, b, n) \
vi a(n), b(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define nao2(a, b, n) \
a.resize(n + 1), b.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1] >> b[_i + 1];
#define na2d(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i]; \
a[_i]--, b[_i]--; \
}
#define na3(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define dna3(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define na3d(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define dna3d(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define nt(a, h, w) \
resize(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi];
#define ntd(a, h, w) \
rs(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi], a[_hi][_wi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(_hi, 1, h + 1) rep(_wi, 1, w + 1) cin >> a[_hi][_wi];
// デバッグ
#define sp << " " <<
#define debugName(VariableName) #VariableName
#define _deb1(x) debugName(x) << " = " << x
#define _deb2(x, ...) _deb1(x) << ", " << _deb1(__VA_ARGS__)
#define _deb3(x, ...) _deb1(x) << ", " << _deb2(__VA_ARGS__)
#define _deb4(x, ...) _deb1(x) << ", " << _deb3(__VA_ARGS__)
#define _deb5(x, ...) _deb1(x) << ", " << _deb4(__VA_ARGS__)
#define _deb6(x, ...) _deb1(x) << ", " << _deb5(__VA_ARGS__)
#define _deb7(x, ...) _deb1(x) << ", " << _deb6(__VA_ARGS__)
#define _deb8(x, ...) _deb1(x) << ", " << _deb7(__VA_ARGS__)
#define _deb9(x, ...) _deb1(x) << ", " << _deb8(__VA_ARGS__)
#define _deb10(x, ...) _deb1(x) << ", " << _deb9(__VA_ARGS__)
#define _overloadebug(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, name, ...) name
#ifdef _DEBUG
#define deb(...) \
cerr << _overloadebug(__VA_ARGS__, _deb10, _deb9, _deb8, _deb7, _deb6, \
_deb5, _deb4, _deb3, _deb2, _deb1)(__VA_ARGS__) \
<< endl
#else
#define deb(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
// よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
int find(int x) { return root(x); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
// 順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.fi;
res[i].push_back(r);
for (auto &&v : p.se) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
using bint = __int128;
using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 toi128(string &s) {
__int128 ret = 0;
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
template <typename T> T minv(T a, T m);
template <typename T> T minv(T a);
template <typename T> class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U> Modular(const U &x) { value = normalize(x); }
template <typename U> static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0)
v += mod();
return v;
}
const Type &operator()() const { return value; }
template <typename U> explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
if ((value += other.value) >= mod())
value -= mod();
return *this;
}
Modular &operator-=(const Modular &other) {
if ((value -= other.value) < 0)
value += mod();
return *this;
}
template <typename U> Modular &operator+=(const U &other) {
return *this += Modular(other);
}
template <typename U> Modular &operator-=(const U &other) {
return *this -= Modular(other);
}
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(signed) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(signed) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, signed>::value,
Modular>::type &
operator*=(const Modular &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type &
operator*=(const Modular &rhs) {
int64_t q =
static_cast<int64_t>(static_cast<double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) {
return *this *= Modular(minv(other.value));
}
template <typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
operator int() { return normalize(value); }
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
constexpr signed MOD = 1e9 + 7; // MOD
using mint = Modular<std::integral_constant<decay<decltype(MOD)>::type, MOD>>;
constexpr int mint_len = 1400001;
vi fac, finv, inv;
vi p2;
void setmod() {
// p2.resize(mint_len);p[0] = 1; for (int i = 1; i < mint_len; ++i) p2[i] =
// p2[i - 1] * 2 % MOD;
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
#define smod setmod
inline mint com(int n, int r) {
if (r < 0 || r > n)
return 0;
return mint(finv[r] * fac[n] % MOD * finv[n - r]);
}
inline mint pom(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - 1]);
}
inline mint npr(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
inline int nprin(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return fac[n] * finv[n - r] % MOD;
}
inline int icom(int n, int r) {
const int NUM_ = 1400001;
static ll fac[NUM_ + 1], finv[NUM_ + 1], inv[NUM_ + 1];
if (fac[0] == 0) {
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
if (r < 0 || r > n)
return 0;
return ((finv[r] * fac[n] % MOD) * finv[n - r]) % MOD;
}
#define ncr com
#define ncri icom
inline mint nhr(int n, int r) { return com(n + r - 1, r); }
inline mint hom(int n, int r) { return com(n + r - 1, r); }
inline int nhri(int n, int r) { return icom(n + r - 1, r); }
template <typename T> inline T minv(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T> inline T minv(T a) {
if (a < mint_len)
return inv[a];
T u = 0, v = 1;
T m = MOD;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T, typename U>
inline Modular<T> mpow(const Modular<T> &a, const U &b) {
assert(b >= 0);
int x = a(), res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline mint mpow(const T a, const U b, const V m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T, typename U> inline mint mpow(const T a, const U b) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline int mpowi(const T &a, const U &b, const V &m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T> inline string to_string(const Modular<T> &number) {
return to_string(number());
}
template <typename T>
std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
return stream << number();
}
template <typename T>
std::istream &operator>>(std::istream &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
using PM = pair<mint, mint>;
using vm = vector<mint>;
using mapm = map<int, mint>;
using umapm = umap<int, mint>;
#define _overloadvvm(_1, _2, _3, _4, name, ...) name
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
#define vvm1(a) vec<vm> a
#define vvm2(a, b) vec<vm> a(b)
#define vvm3(a, b, c) vec<vm> a(b, vm(c))
#define vvm4(a, b, c, d) vec<vm> a(b, vm(c, d))
#define vvm(...) _overloadvvm(__VA_ARGS__, vvm4, vvm3, vvm2, vvm1)(__VA_ARGS__)
// エラー
void ole() {
#ifdef _DEBUG
debugline("ole");
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re() { assert(0 == 1); }
void tle() {
while (inf)
cout << inf << endl;
}
// 便利関数
// テスト用
char ranc() { return (char)('a' + rand() % 26); }
int rand(int min, int max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
//+
if (rand() % 2) {
return rand(0, max);
//-
} else {
return -rand(0, -min);
}
}
}
vi ranv(int n, int min, int max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
// 単調増加
vi ranvi(int n, int min, int max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
void ranvlr(int n, int min, int max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
// 便利 汎用
vp run_length(vi &a) {
vp ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
vector<pair<char, int>> run_length(string &a) {
vector<pair<char, int>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
template <class F> inline int mgr(int ok, int ng, F f) {
#define _mgrbody \
int mid = (ok + ng) / 2; \
if (f(mid)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody
}
else
while (ok - ng > 1) {
_mgrbody
}
return ok;
}
template <class F> inline int mgr(int ok, int ng, int second, F f) {
#define _mgrbody2 \
int mid = (ok + ng) / 2; \
if (f(mid, second)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody2
}
else
while (ok - ng > 1) {
_mgrbody2
}
return ok;
}
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return b;
} else if (a[i] > b[i])
return a;
}
}
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) < sz(b)) {
return a;
} else if (sz(a) > sz(b)) {
return b;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i])
return b;
}
}
return a;
}
template <typename V, typename T> int find(vector<V> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename V, typename T> P find(vector<vector<V>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
template <typename V, typename U>
T find(vector<vector<vector<V>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
return mt(-1, -1, -1);
}
template <typename V, typename T> int count2(V &a, const T k) { return a == k; }
template <typename V, typename T> int count2(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count(v, k);
return ret;
}
template <typename V, typename T> int count(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
int count(str a, str k) {
int ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ret++;
return ret;
}
template <typename V> int count_odd(V &a) { return a % 2; }
template <typename V> int count_odd(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_odd(v);
return ret;
}
template <typename V> int count_even(V &a) { return a % 2 == 0; }
template <typename V> int count_even(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_even(v);
return ret;
}
// algorythm
void iota(vector<int> &ve, int s, int n) {
ve.resize(n);
iota(all(ve), s);
}
vi iota(int s, int len) {
vi ve(len);
iota(all(ve), s);
return ve;
}
inline ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class T> vector<T> revv(vector<T> &a) {
vector<T> b = a;
reverse(all(b));
return b;
}
void inline rev(string &a) { reverse(all(a)); }
constexpr int p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
int get(int a, int keta) { return (a / (int)pow(10, keta)) % 10; }
int keta(ll v) {
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1])
return 1;
else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else if (v < p10[15])
return 15;
else
return 16;
} else {
if (v < p10[17])
return 17;
else
return 18;
}
}
}
}
int dsum(int v) {
int ret = 0;
for (; v; v /= 10)
ret += v % 10;
return ret;
}
inline int sumd(int v) { return dsum(v); }
struct sint {
int v;
sint(int v) : v(v) {}
operator int() { return v; }
int operator[](int i) { return (v / p10[i]) % 10; }
int top(int i) {
int len = keta(v);
return operator[](len - 1 - i);
}
// 先頭からi番目にセット
int top(int i, int k) {
int len = keta(v);
return set(len - 1 - i, k);
}
int set(int i, int k) {
if (i < 0)
return top(abs(i) - 1, k);
return v += p10[i] * (k - (v / p10[i]) % 10);
}
int inc(int i, int k = 1) { return v += p10[i] * k; }
int inct(int i, int k = 1) { return v += p10[keta(v) - i - 1] * k; }
int dec(int i, int k = 1) { return v -= p10[i] * k; }
int dect(int i, int k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o) \
template <class T> inline t operator o(T r) { return v o r; }
op(int, +=);
op(int, -=);
op(int, *=);
op(int, /=);
op(int, %=);
op(int, +);
op(int, -);
op(int, *);
op(int, /);
op(int, %);
op(bool, ==);
op(bool, !=);
op(bool, <);
op(bool, <=);
op(bool, >);
op(bool, >=);
#undef op
template <class T> inline int operator<<=(T r) { return v *= p10[r]; }
template <class T> inline int operator<<(T r) { return v * p10[r]; }
template <class T> inline int operator>>=(T r) { return v /= p10[r]; }
template <class T> inline int operator>>(T r) { return v / p10[r]; }
};
int mask10(int v) { return p10[v] - 1; }
// 変換系
template <class T, class U> inline vector<T> keys(vector<pair<T, U>> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> vector<U> inline values(vector<pair<T, U>> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chma(const U &b) { return chma(ma, b); }
template <class T, class U> inline bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chmi(const U &b) { return chmi(mi, b); }
template <class T> inline T min(T a, signed b) { return a < b ? a : b; }
template <class T> inline T max(T a, signed b) { return a < b ? b : a; }
template <class T> inline T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> inline T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> inline T min(vector<T> a) { return *min_element(all(a)); }
template <class T> inline T mini(vector<T> a) {
return min_element(all(a)) - a.begin();
}
template <class T> inline T min(vector<T> a, int n) {
return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T min(vector<T> a, int s, int n) {
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a) { return *max_element(all(a)); }
template <class T> inline T maxi(vector<T> a) {
return max_element(all(a)) - a.begin();
}
template <class T> inline T max(vector<T> a, int n) {
return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a, int s, int n) {
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> inline A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> inline A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <class T> inline T sum(T &v) { return v; }
template <class T> inline auto sum(vector<T> &v) {
auto ret = sum(v[0]);
rep(i, 1, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T, class U, class... V>
inline auto sum(vector<T> &v, U head, V... tail) {
auto ret = sum(v[0], tail...);
rep(i, 1, min(sz(v), head)) ret += sum(v[i], tail...);
return ret;
}
inline P sump(vp &v, int len = -1) {
if (len == -1)
len = v.size();
P res = {0, 0};
chmi(len, v.size());
rep(i, len) {
res.fi += v[i].fi;
res.se += v[i].se;
}
return res;
}
/// 要素が0の時、返り値は0か1か
template <class T> inline T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
chmi(len, v.size());
rep(i, len) res *= v[i];
return res;
}
inline void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> inline void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> inline T *negarr(int size) {
T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
return body + size;
}
template <class T> inline T *negarr2(int h, int w) {
double **dummy1 = new double *[2 * h + 1];
double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
dummy1[0] = dummy2 + w;
for (int i = 1; i <= 2 * h + 1; i++) {
dummy1[i] = dummy1[i - 1] + 2 * w + 1;
}
double **a = dummy1 + h;
return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> inline vector<T> imo(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// kと同じものの数
template <class T, class U> inline vi imo(vector<T> &a, U k) {
vector<T> ret = a;
rep(i, sz(ret) - 1) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T> inline vector<T> imox(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> inline vector<T> imi(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> struct ruiC {
const vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
inline T operator()(int l, int r) {
assert(l <= r);
return rui[r] - rui[l];
}
inline T operator[](int i) { return rui[i]; }
};
template <class T> struct rruic {
const T *rrui;
rruic(T *ru) : rrui(ru) {}
// n-1から-1へ
inline T operator()(int l, int r) {
assert(l >= r);
return rrui[r] - rrui[l];
}
inline T operator[](int i) { return rrui[i]; }
};
template <class T> inline vector<T> ruiv(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> inline ruiC<T> ruic(vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
// kと同じものの数
template <class T, class U> inline vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> inline ruiC<int> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<int>(ret);
}
// xor
template <class T> inline vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> inline vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> inline vector<T> ruimi(vector<T> &a) {
int n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> rruic<T> rrui(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
rer(i, len - 1) res[i - 1] = res[i] + a[i];
return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void inc(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void plus(T &a, U v = 1) { a += v; }
template <class T, class U> void plus(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void plus(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void dec(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class T, class U> void minu(T &a, U v = 1) { a -= v; }
template <class T, class U> void minu(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void minu(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class U> void minu(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
void minu(string &a) {
for (auto &u : a)
dec(u, 1);
}
inline bool inside(int h, int w, int H, int W) {
return h >= 0 && w >= 0 && h < H && w < W;
}
inline bool inside(int l, int v, int r) { return l <= v && v < r; }
#define ins inside
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
vector<T> ret = a;
fora(v, ret) v = u(v);
return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
ll goldd(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return resIndex;
}
ll goldt(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return resIndex;
}
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmi(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chma(res, *max_element(all(a[i])));
return res;
}
constexpr bool bget(ll m, int keta) {
assert(keta < 64);
return (m >> keta) & 1;
}
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
ll bit(int n) { return (1LL << (n)); }
ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int mask(int n) { return (1ll << n) - 1; }
// int bcou(ll m) { return __builtin_popcount(m & 0xFFFFFFFF) +
// __builtin_popcount(m >> 32); }
#define bcou __builtin_popcountll
// 最下位ビット
int lbit(int n) { return n & -n; }
// 最上位ビット
int hbit(int n) {
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
int hbitk(int n) {
int k = 0;
rer(i, 5) {
int a = k + (1ll << i);
int b = 1ll << a;
if (b <= n)
k += 1ll << i;
}
return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; // 最下位の1
ll y = mask + x; // 連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
// 大文字小文字を区別する
int altoiaZ(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoalaZ(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
// aもAも0を返す 基本小文字
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
char itoal(int i) { return 'a' + i; }
int ctoi(char c) { return c - '0'; }
char itoc(int i) { return i + '0'; }
int vtoi(vi &v) {
int res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(int i) {
vi res;
while (i) {
res.pb(i % 10);
i /= 10;
}
rev(res);
return res;
}
vi stov(string &a) {
int n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
vector<vector<int>> ctoi(vector<vector<char>> s, char c) {
int n = sz(s), m = sz(s[0]);
vector<vector<int>> res(n, vector<int>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
// 便利 数学 math
int mod(int a, int m) { return (a % m + m) % m; }
int pow(int a) { return a * a; };
ll fact(int v) { return v <= 1 ? 1 : v * fact(v - 1); }
ll comi(int n, int r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
double comd(int n, int r) {
assert(n < 2020);
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
int gcd(int a, int b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
int gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
int res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
namespace pnumber_tools {
#define Eratosthenes30_2 \
class Eratosthenes { \
public: \
virtual void initialize() {} \
virtual void generate(const int64_t x) = 0; \
virtual void generate(const int64_t from, const int64_t to) = 0; \
virtual int64_t count() = 0; \
virtual bool prime(int x) = 0; \
virtual int32_t version() = 0; \
inline uint64_t PopCnt(uint64_t); \
inline int BitToIndex(uint8_t); \
}; \
uint64_t Eratosthenes::PopCnt(uint64_t bits) { \
bits = (bits & 0x5555555555555555ULL) + \
((bits >> 1) & 0x5555555555555555ULL); \
bits = (bits & 0x3333333333333333ULL) + \
((bits >> 2) & 0x3333333333333333ULL); \
bits = (bits & 0x0f0f0f0f0f0f0f0fULL) + \
((bits >> 4) & 0x0f0f0f0f0f0f0f0fULL); \
return (bits * 0x0101010101010101ULL) >> (64 - 8); \
} \
int Eratosthenes::BitToIndex(uint8_t b) { \
switch (b) { \
case 1 << 0: \
return 0; \
case 1 << 1: \
return 1; \
case 1 << 2: \
return 2; \
case 1 << 3: \
return 3; \
case 1 << 4: \
return 4; \
case 1 << 5: \
return 5; \
case 1 << 6: \
return 6; \
case 1 << 7: \
return 7; \
} \
return -1; \
} \
namespace { \
const uint64_t kSegmentSize = 1000000; \
const int32_t kMod30[] = {1, 7, 11, 13, 17, 19, 23, 29}; \
const int C1[] = {6, 4, 2, 4, 2, 4, 6, 2}; \
const int C0[][8] = { \
{0, 0, 0, 0, 0, 0, 0, 1}, {1, 1, 1, 0, 1, 1, 1, 1}, \
{2, 2, 0, 2, 0, 2, 2, 1}, {3, 1, 1, 2, 1, 1, 3, 1}, \
{3, 3, 1, 2, 1, 3, 3, 1}, {4, 2, 2, 2, 2, 2, 4, 1}, \
{5, 3, 1, 4, 1, 3, 5, 1}, {6, 4, 2, 4, 2, 4, 6, 1}, \
}; \
const uint8_t kMask[][8] = { \
{0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f}, \
{0xfd, 0xdf, 0xef, 0xfe, 0x7f, 0xf7, 0xfb, 0xbf}, \
{0xfb, 0xef, 0xfe, 0xbf, 0xfd, 0x7f, 0xf7, 0xdf}, \
{0xf7, 0xfe, 0xbf, 0xdf, 0xfb, 0xfd, 0x7f, 0xef}, \
{0xef, 0x7f, 0xfd, 0xfb, 0xdf, 0xbf, 0xfe, 0xf7}, \
{0xdf, 0xf7, 0x7f, 0xfd, 0xbf, 0xfe, 0xef, 0xfb}, \
{0xbf, 0xfb, 0xf7, 0x7f, 0xfe, 0xef, 0xdf, 0xfd}, \
{0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe}, \
}; \
const int64_t kSievedPrimes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23}; \
const int64_t kInitialSize = 7 * 11 * 13 * 17 * 19 * 23; \
class Eratosthenes2 final : public Eratosthenes { \
public: \
void generate(const int64_t x) override; \
void generate(const int64_t, const int64_t) override { assert(false); } \
bool prime(int x) override; \
int64_t count() override; \
int32_t version() override { return 2; } \
std::vector<uint8_t> flags_; \
}; \
void Eratosthenes2::generate(const int64_t x) { \
flags_.clear(); \
if (x > 10000000000) \
return; \
int64_t size = x / 30 + (x % 30 != 0); \
flags_.resize(size, 0xff); \
if (int r = x % 30) { \
if (r <= 1) \
flags_[size - 1] = 0x0; \
else if (r <= 7) \
flags_[size - 1] = 0x1; \
else if (r <= 11) \
flags_[size - 1] = 0x3; \
else if (r <= 13) \
flags_[size - 1] = 0x7; \
else if (r <= 17) \
flags_[size - 1] = 0xf; \
else if (r <= 19) \
flags_[size - 1] = 0x1f; \
else if (r <= 23) \
flags_[size - 1] = 0x3f; \
else if (r <= 29) \
flags_[size - 1] = 0x7f; \
} \
flags_[0] = 0xfe; \
const uint64_t sqrt_x = std::ceil(std::sqrt(x) + 0.1); \
const uint64_t sqrt_xi = sqrt_x / 30 + 1; \
for (uint64_t i = 0; i < sqrt_xi; ++i) { \
for (uint8_t flags = flags_[i]; flags; flags &= flags - 1) { \
uint8_t lsb = flags & (-flags); \
int ibit = BitToIndex(lsb); \
const int32_t m = kMod30[ibit]; \
int32_t pm = 30 * i + 2 * m; \
for (uint64_t j = i * pm + (m * m) / 30, k = ibit; j < flags_.size(); \
j += i * C1[k] + C0[ibit][k], k = (k + 1) & 7) { \
flags_[j] &= kMask[ibit][k]; \
} \
} \
} \
} \
int64_t Eratosthenes2::count() { \
if (flags_.empty()) \
return -1; \
int64_t ret = 3; \
for (uint8_t f : flags_) { \
ret += PopCnt(f); \
} \
return ret; \
} \
inline bool Eratosthenes2::prime(int x) { \
static unordered_map<int, int> imap = { \
{1, 0}, {7, 1}, {11, 2}, {13, 3}, {17, 4}, {19, 5}, {23, 6}, {29, 7}}; \
if (x == 2 || x == 3 || x == 5) \
return true; \
else if (!(x & 1) || x % 3 == 0 || x % 5 == 0) \
return false; \
return (flags_[x / 30] >> imap[x % 30]) & 1; \
} \
}
Eratosthenes30_2 Eratosthenes2 era;
int prime_len = 3e6;
vector<int> primes;
void setprime(int size = 3e6) {
prime_len = size;
era.generate(size);
primes = {2, 3, 5};
int nums[129] = {};
nums[1] = 1;
nums[2] = 7;
nums[4] = 11;
nums[8] = 13;
nums[16] = 17;
nums[32] = 19;
nums[64] = 23;
nums[128] = 29;
// p = 30i + j
int j = 0;
int sflim = era.flags_.size();
int i30 = 0;
for (int i = 0; i < sflim; i++, i30 += 30) {
uint8_t m = era.flags_[i];
while (m) {
j = m & -m;
primes.push_back(i30 + nums[j]);
m ^= j;
}
}
}
using u32 = unsigned int; // longlongになっていると思うが放置していいと思う
using u64 = unsigned long long;
using u128 = __uint128_t;
// O(k log(n)^3)
// 32bit -> 270回程度
// 64bit -> 1260回程度
// 64bit以下で精度100%
template <class BinOp>
bool miller_rabin(const uint64_t &n, const uint64_t *witness, BinOp modmul) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
const int64_t m = n - 1, d = m / (m & -m);
auto modpow = [&](int64_t a, int64_t b) {
int64_t res = 1;
for (; b; b /= 2) {
if (b & 1)
res = modmul(res, a);
a = modmul(a, a);
}
return res;
};
auto suspect = [&](uint64_t a, uint64_t t) {
a = modpow(a, t);
while (t != n - 1 && a != 1 && a != n - 1) {
a = modmul(a, a);
t = modmul(t, 2);
}
return a == n - 1 || t % 2 == 1;
};
for (const uint64_t *w = witness; *w; w++) {
if (*w % n != 0 && !suspect(*w, d))
return false;
}
return true;
}
// miller_rabin & エラトステネス
bool prime(const int &n) {
assert(n < 9223372036854775808ULL);
if (!sz(primes))
setprime();
// エラトステネスの篩 偶数省略ver
//[i] = i*2+1
if (n < prime_len)
return era.prime(n);
if (n < 4294967296) {
rep(i, 30) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 7, 61, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t { return a * b % n; };
return miller_rabin(n, witness, modmul);
} else {
rep(i, 50) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 325, 9375, 28178,
450775, 9780504, 1795265022, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t {
return (uint64_t)((__uint128_t)a * b % n);
};
return miller_rabin(n, witness, modmul);
}
}
vi divisors(int v) {
vi res;
double lim = std::sqrt(v);
for (int i = 1; i <= lim; ++i) {
if (v % i == 0) {
res.pb(i);
// if (i != v / i)res.pb(v / i);
}
}
rer(i, sz(res) - 1) {
if (res[i] != v / res[i])
res.pb(v / res[i]);
}
return res;
}
vp factorization(int v) {
assert(v);
int tv = v;
vp res;
if (!sz(primes))
setprime();
for (auto &&p : primes) {
if (v % p == 0)
res.eb(p, 0);
while (v % p == 0) {
v /= p;
res.back().second++;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.eb(v, 1);
return res;
}
// 注意 gcdを取る間隔 i%10 が場合によってはtleを引き起こす
// うまくいかなかったら%1で動かすように変更した
vp rho(int v) {
assert(v);
if (v == 1)
return vp();
vi ret;
if (!sz(primes))
setprime();
int lim = 300; // 64bit
if (v < 4294967296)
lim = 80; // 32bit
else if (v < 281474976710656LL)
lim = 120; // 48bit
for (int i = 0; i < lim; i += 5) {
// v<=1の判定回数を減らせる分高速化できる事を期待している
while (v % primes[i] == 0)
ret.pb(primes[i]), v /= primes[i];
while (v % primes[i + 1] == 0)
ret.pb(primes[i + 1]), v /= primes[i + 1];
while (v % primes[i + 2] == 0)
ret.pb(primes[i + 2]), v /= primes[i + 2];
while (v % primes[i + 3] == 0)
ret.pb(primes[i + 3]), v /= primes[i + 3];
while (v % primes[i + 4] == 0)
ret.pb(primes[i + 4]), v /= primes[i + 4];
if (v <= 1) {
sort(ret); // 試し割りだけで終わった時
return run_length(ret);
}
}
int lower_prime_bound = primes[lim - 1] * primes[lim - 1];
// 試し割りするか
mt19937 mr;
mr.seed(clock());
int c;
auto fac = [&](int v, const int loop = 10) {
// if (v == 4)return 2ll; //試し割りで消えた
c = mr() % v;
int x = mr() % v;
int y = x;
int d = 1;
int lim = std::sqrt(v) + 2;
// brentによる改良 差分を一操作で求められる
for (int i = 1, mul = 1, next_2pow = 2; d == 1 && i <= lim; i++) {
if (i == next_2pow) {
y = x;
next_2pow <<= 1;
}
x = ((u128)x * x + c) % v;
mul = ((u128)mul * abs(x - y)) %
v; // ユークリッドの互除法と同じ原理で因数は保たれる
if (i % loop == 0) { // 10とかなんとか iによっては死ぬ
d = gcd(mul, v);
mul = 1;
}
}
if (d == v)
return -1ll;
return d;
};
queue<int> q;
q.push(v);
while (!q.empty()) {
int v = q.front();
q.pop();
if (prime(v)) {
ret.pb(v);
continue;
}
int d = -1;
// 基本loop回数10でやり、駄目なら1で
for (int i = 0; d == -1 && i < 5; i++)
d = fac(v, 10);
if (d == -1)
while (d == -1)
d = fac(v, 1);
int d2 = v / d;
rep(_, 2) {
if (d <= lower_prime_bound)
ret.pb(d);
else
q.push(d);
d = d2;
}
}
sort(ret);
return run_length(ret);
}
} // namespace pnumber_tools
using namespace pnumber_tools;
// 幾何 Pをcomplexとして扱う
template <class T, class U> bool eq(T a, U b) { return fabs(a - b) < eps; }
dou atan2(pd a) { return atan2(a.se, a.fi); }
dou angle(pd f, pd t) { return atan2(t.se - f.se, t.fi - f.fi); }
dou distance(pd a, pd b) { return hypot(a.fi - b.fi, a.se - b.se); }
// bを中心とするabcのtheta aからcにかけて時計回り
dou angle(pd a, pd b, pd c) {
dou ax = a.fi - b.fi;
dou ay = a.se - b.se;
dou cx = c.fi - b.fi;
dou cy = c.se - b.se;
double ret = atan2(cy, cx) - atan2(ay, ax);
if (ret < 0)
ret += 2 * PI;
return ret;
}
dou dot(pd a, pd b) { return a.fi * b.fi + a.se + b.se; }
dou cro(pd a, pd b) { return a.fi * b.se - a.se + b.fi; }
template <class T> struct edge {
int f, t;
T c;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: f(f), t(t), c(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return c < b.c; }
bool operator>(const edge &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge<T> &e) {
os << e.f << " " << e.t << " " << e.c;
return os;
}
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) { g.resize(n), _used.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
vector<edge<T>> &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int id, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, id, ty);
edges.emplace_back(f, t, c, id, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("undigraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid, eid += 2;
g[f].emplace_back(f, t, c, id, ty);
g[t].emplace_back(t, f, c, id + 1, ty);
edges.emplace_back(f, t, c, id, ty);
edges.emplace_back(t, f, c, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.f, t = e.t, ty = e.type;
T c = e.c;
add(f, t, c, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <typename T> struct radixheap {
vector<pair<u64, T>> v[65];
u64 size, last;
radixheap() : size(0), last(0) {}
bool empty() const { return size == 0; }
inline int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
void push(u64 key, const T &value) {
++size;
v[getbit(key ^ last)].emplace_back(key, value);
}
pair<u64, T> pop() {
if (v[0].empty()) {
int idx = 1;
while (v[idx].empty())
++idx;
last = min_element(begin(v[idx]), end(v[idx]))->first;
for (auto &p : v[idx])
v[getbit(p.first ^ last)].emplace_back(p);
v[idx].clear();
}
--size;
auto ret = v[0].back();
v[0].pop_back();
return ret;
}
};
vi dijkstra2(const graph<int> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
int initValue = MAX(int);
vi dis(g.n, initValue);
radixheap<int> q;
dis[s] = 0;
q.push(0, s);
while (!q.empty()) {
int nowc, i;
tie(nowc, i) = q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
int c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.push(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<T> dijkstra(const graph<T> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.emplace(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<vector<T>> warshall(const graph<T> &g, int cant_arrive = -1) {
int n = g.n;
vector<vector<T>> dis(n, vector<T>(n, linf));
rep(i, n) fora(e, g.g[i]) chmi(dis[e.f][e.t], e.c);
rep(i, n) dis[i][i] = 0;
rep(k, n) rep(i, n) rep(j, n) chmi(dis[i][j], dis[i][k] + dis[k][j]);
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = -1;
return dis;
}
template <class T = int> class tree : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
vi disv;
private:
bool never = 1;
int root = -1;
vi dep; // 到着した順の深さ
vi vis; // 到着した順
vi first; // 初めてiに到着した時
vector<int> bestt; // タイミングを持つ
int sn = 0; // seg木の底辺の長さ euler tourの長さ
void built() {
never = 0;
n = g.size();
// euler tour
disv.resize(n);
first.resize(n);
dep.resize(n * 2);
vis.resize(n * 2);
function<void(int, int, int, int &)> dfs = [&](int i, int p, int d,
int &k) {
first[i] = k;
vis[k] = i;
dep[k++] = d;
forg(gi, g[i]) {
if (t == p)
continue;
disv[t] = disv[i] + c;
dfs(t, i, d + 1, k);
vis[k] = i;
dep[k++] = d;
}
};
int k = 0;
dfs(root, -1, 0, k);
// rmq
sn = 1;
while (sn < n * 2)
sn <<= 1;
bestt.resize((sn << 1) - 1);
rep(i, k) bestt[i + sn - 1] = i; // 時間を持つ
rer(i, sn - 2) {
int lt = (i << 1) + 1, rt = (i << 1) + 2;
if (dep[bestt[lt]] < dep[bestt[rt]]) {
bestt[i] = bestt[lt];
} else {
bestt[i] = bestt[rt];
}
}
}
// 最小の深さを持つタイミングが知りたい
inline int lca_rmq(int l, int r) {
int midv = inf;
int midi = -1;
l += sn - 1;
r += sn - 1;
while (l < r) {
// 右なら、次に右上へ移動してしまうので
if (!(l & 1)) {
if (chmi(midv, dep[bestt[l]])) {
midi = bestt[l];
}
}
// 右なら、左を取らないと機会を逃す
if (!(r & 1)) {
if (chmi(midv, dep[bestt[r - 1]])) {
midi = bestt[r - 1];
}
}
l >>= 1;
r = (r - 1) >> 1;
}
return vis[midi];
}
public:
tree(int n, int root = 0) : undigraph<T>(n), root(root) {}
bool leaf(int v) { return sz(g[v]) == 1 && v != root; }
int lca(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
return lca_rmq(first[u], first[v] + 1);
}
int dis(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
int p = lca_rmq(first[u], first[v] + 1);
return disv[u] + disv[v] - disv[p] * 2;
}
};
// 辺によりメモリを大量消費
// よってedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
// 軽量化のため、辺を持たないbig gridクラスがあってもいいかもしれない
//
template <class T = int> class grid_k6 : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("grid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
g[t].emplace_back(t, f, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
grid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
using digraph<T>::g;
using digraph<T>::n;
using digraph<T>::edges;
using digraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digrid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
digrid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
template <class T> bool nibu(const graph<T> &g) {
int size = 0;
rep(i, g.n) size += sz(g.g[i]);
if (size == 0)
return true;
UnionFind uf(g.n * 2);
rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
uf.unite(e.f + g.n, e.t);
rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
return 1;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
vp cg;
if (!nibu(g)) {
debugline("nibu");
ole();
}
int _n = g.size();
vb _was(_n);
queue<P> q;
rep(i, _n) {
if (_was[i])
continue;
q.push(mp(i, 1));
_was[i] = 1;
int red = 0;
int coun = 0;
while (q.size()) {
int now = q.front().fi;
int col = q.front().se;
red += col;
coun++;
q.pop();
forg(gi, g[now]) {
if (_was[t])
continue;
q.push(mp(t, col ^ 1));
_was[t] = 1;
}
}
cg.push_back(mp(red, coun - red));
}
return cg;
}
template <class T> ostream &operator<<(ostream &os, graph<T> &g) {
rep(i, sz(g)) {
forg(gi, g[i]) { os << f << " " << t << " " << c << endl; }
}
return os;
}
// 機能拡張
vp vtop(vi &a, vi &b) {
vp res(sz(a));
rep(i, sz(a)) res[i] = mp(a[i], b[i]);
return res;
}
void ptov(vp &p, vi &a, vi &b) {
a.resize(sz(p));
b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
__lhs += to_string(__rv);
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
__lhs += to_string(__rv);
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T, class U> set<T> &operator+=(set<T> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.pb(v);
return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
vector<T> ret;
ret = a;
fora(v, b) ret += v;
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
fora(v, b) a += v;
return a;
}
template <class T, class U>
vector<T> &operator+=(vector<T> &a, initializer_list<U> v) {
for (auto &&va : v)
a.pb(va);
return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
ole();
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T, typename U>
void insert(vector<T> &v, initializer_list<U> list) {
for (auto &&va : list)
v.pb(va);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, initializer_list<U> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
template <typename T> void insert(set<T> &v, initializer_list<T> list) {
for (auto &&va : list)
v.insert(va);
}
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
}
return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
// 小さい順
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) if (nyu[i] == 0) q.push(i);
while (q.size()) {
int i = q.top();
q.pop();
res.pb(i);
fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
void yn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Yn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fyn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
exit(0);
}
void fYn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
exit(0);
}
void fYN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
void Possible(bool a) {
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
int n, m, k, d, H, W, x, y, z, q;
int cou;
vi t, a, b, c;
// vvi (s, 0, 0);
vvc(ba, 0, 0);
vp p;
str s;
void solve() {
cin >> n >> m;
na(a, n);
na2(b, c, m);
rsortp(c, b);
priority_queue<int, vector<int>, greater<int>> q; // 小さい順
rep(i, n) q += a[i];
rep(i, m) {
rep(j, b[i]) {
int v = q.top();
if (v < c[i]) {
q.pop();
q += c[i];
}
}
}
while (sz(q)) {
cou += q.top();
q.pop();
}
cout << cou << endl;
}
int my(int n, vi &a) { return 0; }
int sister(int n, vi &a) {
int ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (int i = 0, ok = 1; i < k5 && ok; i++) {
int n = rand(1, 8);
vi a = ranv(n, 1, 10);
int myres = my(arg);
int res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "正解 : " << res << endl;
cerr << "自分 : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// cout << "完璧 : solveを書き直そう" << endl;
// cout << " : そして、solve()を呼び出すのだ" << endl;
// cout << " : cin>>n; na(a,n);も忘れるな" << endl;
}
#endif
return 0;
};
| // todo 文字数を少なくする
// mintより高速に計算したい時用に modmul() modadd (正の値限定) を作る
// #pragma GCC optimize ("-O3")
#include <bits/stdc++.h>
using namespace std;
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} __initon;
// 衝突対策
#define ws ___ws
//@必須構造
struct T {
int f, s, t;
T() { f = -1, s = -1, t = -1; }
T(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const T &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const T &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
bool operator==(const T &r) const { return f == r.f && s == r.s && t == r.t; }
bool operator!=(const T &r) const { return f != r.f || s != r.s || t != r.t; }
int operator[](int i) {
assert(i < 3);
return i == 0 ? f : i == 1 ? s : t;
}
};
struct F {
int a, b, c, d;
F() { a = -1, b = -1, c = -1, d = -1; }
F(int a, int b, int c, int d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d;
// return a != r.a ? a > r.a : b != r.b ? b > r.b : c != r.c ? c >
// r.c : d > r.d;
}
bool operator>(const F &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d;
// return a != r.a ? a < r.a : b != r.b ? b < r.b : c != r.c ? c <
// r.c : d < r.d;
}
bool operator==(const F &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
int operator[](int i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
T mt(int a, int b, int c) { return T(a, b, c); }
//@マクロ省略系 型,構造
#define int long long
#define ll long long
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using pd = pair<dou, dou>;
#define fi first
#define se second
#define vec vector
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
// マクロ省略系 コンテナ
using vi = vector<int>;
#define _overloadvvi(_1, _2, _3, _4, name, ...) name
#define vvi0() vec<vi>
#define vvi1(a) vec<vi> a
#define vvi2(a, b) vec<vi> a(b)
#define vvi3(a, b, c) vec<vi> a(b, vi(c))
#define vvi4(a, b, c, d) vec<vi> a(b, vi(c, d))
#define vvi(...) \
_overloadvvi(__VA_ARGS__, vvi4, vvi3, vvi2, vvi1, vvi0)(__VA_ARGS__)
using vl = vector<ll>;
#define _overloadvvl(_1, _2, _3, _4, name, ...) name
#define vvl1(a) vec<vl> a
#define vvl2(a, b) vec<vl> a(b)
#define vvl3(a, b, c) vec<vl> a(b, vl(c))
#define vvl4(a, b, c, d) vec<vl> a(b, vl(c, d))
#define vvl(...) _overloadvvl(__VA_ARGS__, vvl4, vvl3, vvl2, vvl1)(__VA_ARGS__)
using vb = vector<bool>;
#define _overloadvvb(_1, _2, _3, _4, name, ...) name
#define vvb1(a) vec<vb> a
#define vvb2(a, b) vec<vb> a(b)
#define vvb3(a, b, c) vec<vb> a(b, vb(c))
#define vvb4(a, b, c, d) vec<vb> a(b, vb(c, d))
#define vvb(...) _overloadvvb(__VA_ARGS__, vvb4, vvb3, vvb2, vvb1)(__VA_ARGS__)
using vs = vector<string>;
#define _overloadvvs(_1, _2, _3, _4, name, ...) name
#define vvs1(a) vec<vs> a
#define vvs2(a, b) vec<vs> a(b)
#define vvs3(a, b, c) vec<vs> a(b, vs(c))
#define vvs4(a, b, c, d) vec<vs> a(b, vs(c, d))
#define vvs(...) _overloadvvs(__VA_ARGS__, vvs4, vvs3, vvs2, vvs1)(__VA_ARGS__)
using vd = vector<double>;
#define _overloadvvd(_1, _2, _3, _4, name, ...) name
#define vvd1(a) vec<vd> a
#define vvd2(a, b) vec<vd> a(b)
#define vvd3(a, b, c) vec<vd> a(b, vd(c))
#define vvd4(a, b, c, d) vec<vd> a(b, vd(c, d))
#define vvd(...) _overloadvvd(__VA_ARGS__, vvd4, vvd3, vvd2, vvd1)(__VA_ARGS__)
using vc = vector<char>;
#define _overloadvvc(_1, _2, _3, _4, name, ...) name
#define vvc1(a) vec<vc> a
#define vvc2(a, b) vec<vc> a(b)
#define vvc3(a, b, c) vec<vc> a(b, vc(c))
#define vvc4(a, b, c, d) vec<vc> a(b, vc(c, d))
#define vvc(...) _overloadvvc(__VA_ARGS__, vvc4, vvc3, vvc2, vvc1)(__VA_ARGS__)
using vp = vector<P>;
#define _overloadvvp(_1, _2, _3, _4, name, ...) name
#define vvp1(a) vec<vp> a
#define vvp2(a, b) vec<vp> a(b)
#define vvp3(a, b, c) vec<vp> a(b, vp(c))
#define vvp4(a, b, c, d) vec<vp> a(b, vp(c, d))
#define vvp(...) _overloadvvp(__VA_ARGS__, vvp4, vvp3, vvp2, vvp1)(__VA_ARGS__)
using vt = vector<T>;
#define _overloadvvt(_1, _2, _3, _4, name, ...) name
#define vvt1(a) vec<vt> a
#define vvt2(a, b) vec<vt> a(b)
#define vvt3(a, b, c) vec<vt> a(b, vt(c))
#define vvt4(a, b, c, d) vec<vt> a(b, vt(c, d))
#define vvt(...) _overloadvvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1)(__VA_ARGS__)
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
#define _vvi vector<vi>
#define _vvl vector<vl>
#define _vvb vector<vb>
#define _vvs vector<vs>
#define _vvd vector<vd>
#define _vvc vector<vc>
#define _vvp vector<vp>
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<int>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<int, int>;
using mapp = map<P, int>;
using mapd = map<dou, int>;
using mapc = map<char, int>;
using maps = map<str, int>;
using seti = set<int>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<int>;
#define bset bitset
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define umapi unordered_map<int, int>
#define umapp unordered_map<P, int>
#define mmap multimap
// マクロ 繰り返し
#define _overloadrep(_1, _2, _3, _4, name, ...) name
#define _rep(i, n) for (int i = 0, _lim = n; i < _lim; i++)
#define repi(i, m, n) for (int i = m, _lim = n; i < _lim; i++)
#define repadd(i, m, n, ad) for (int i = m, _lim = n; i < _lim; i += ad)
#define rep(...) _overloadrep(__VA_ARGS__, repadd, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m, _lim = n; i >= _lim; i--)
#define rerdec(i, m, n, dec) for (int i = m, _lim = n; i >= _lim; i -= dec)
#define rer(...) _overloadrep(__VA_ARGS__, rerdec, reri, _rer, )(__VA_ARGS__)
#define reps2(i, j, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++)
#define reps3(i, j, k, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++)
#define reps4(i, j, k, l, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++) \
for (int l = 0; l < _lim; l++)
#define _overloadreps(_1, _2, _3, _4, _5, name, ...) name
#define reps(...) \
_overloadreps(__VA_ARGS__, reps4, reps3, reps2, _rep, )(__VA_ARGS__)
#define repss(i, j, k, a, b, c) \
for (int i = 0; i < a; i++) \
for (int j = 0; j < b; j++) \
for (int k = 0; k < c; k++)
#define fora(a, b) for (auto &&a : b)
#define forg(gi, ve) \
for (int gi = 0, _lim = ve.size(), f, t, c; \
gi < _lim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); gi++)
#define fort(gi, ve) \
for (int gi = 0, f, t, c; \
gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); \
gi++) \
if (t != p)
// #define fort(gi, ve) for (int gi = 0, f, t, c;gi<ve.size()&& (gi+=
// (ve[gi].t==p))< ve.size() && (f = ve[gi].f,t=ve[gi].t, c = ve[gi].c,true);
// gi++)
#define form(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; it++)
#define forit(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r; it++)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int inf = (int)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((int)(a).size())
// #define rs resize
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
constexpr bool ev(int a) { return !(a & 1); }
constexpr bool od(int a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
// 大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
for (T &x : vec)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se << endl;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < vec[0].size(); j++) {
os << vec[i][j];
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
for (auto &&v : m)
os << v;
return os;
}
template <typename V, typename H> void resize(vector<V> &vec, const H head) {
vec.resize(head);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &vec, const H &head, const T... tail) {
vec.resize(head);
for (auto &v : vec)
resize(v, tail...);
}
template <typename T, typename _Pr>
bool all_of(const vector<T> &vec, _Pr pred) {
return std::all_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool any_of(const vector<T> &vec, _Pr pred) {
return std::any_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool none_of(const vector<T> &vec, _Pr pred) {
return std::none_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
const typename vector<T>::const_iterator find_if(const vector<T> &vec,
_Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred);
}
template <class T> bool contains(const std::string &s, const T &v) {
return s.find(v) != std::string::npos;
}
template <typename T> bool contains(const vector<T> &vec, const T &val) {
return std::find(vec.begin(), vec.end(), val) != vec.end();
}
template <typename T, typename _Pr>
bool contains_if(const vector<T> &vec, _Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred) != vec.end();
}
template <class T, class U> void replace(vector<T> &a, T key, U v) {
replace(a.begin(), a.end(), key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(all(a), key), a.end());
}
void replace(str &a, str key, str v) {
if (v == "")
a.erase(remove(all(a), key[0]), a.end());
else
replace(all(a), key[0], v[0]);
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(all(c));
sort(all(d));
return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(all(a));
}
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
inline void sort(string &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
}
template <class T, class F> inline void sort(vector<T> &a, F f) {
sort(a.begin(), a.end(), [&](T a, T b) { return f(a) < f(b); });
}
enum ___pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
inline void sort(vector<P> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
break;
case fisd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
break;
case fdsi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
break;
case fdsd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
break;
case sifi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
break;
case sifd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
break;
case sdfi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
break;
case sdfd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
break;
}
};
inline void sort(vector<T> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
break;
case fisd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
break;
case fdsi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
break;
case fdsd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
break;
case sifi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
break;
case sifd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
break;
case sdfi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
break;
case sdfd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
break;
}
};
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
template <class U, class F> inline void rsort(vector<U> &a, F f) {
sort(a.begin(), a.end(), [&](U l, U r) { return f(l) > f(r); });
};
template <class U> inline void sortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
;
}
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class U, class F> inline void sortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void sortp(vector<U> &a, vector<U> &b, char type) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, type);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void rsortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void rsortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
// indexをつけてsortする (second)
template <class T> auto sorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
sort(ret);
return ret;
};
template <class T> auto rsorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
rsort(ret);
return ret;
};
template <class T> inline void sort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
sort(a[i]);
}
template <class T> inline void rsort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
rsort(a[i]);
}
template <typename A, size_t N, typename T>
inline void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
inline void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
inline void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
inline void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
inline void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
inline void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
template <typename V, typename T> void fill(V &xx, const T vall) { xx = vall; }
template <typename V, typename T> void fill(vector<V> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
//@汎用便利関数 入力
inline int in() {
int ret;
// scanf("%lld", &ret);
cin >> ret;
return ret;
}
inline string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> inline void in(T &head) { cin >> head; }
template <class T, class... U> inline void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
#define _overloaddin(_1, _2, _3, _4, name, ...) name
#define din1(a) \
int a; \
cin >> a
#define din2(a, b) \
int a, b; \
cin >> a >> b
#define din3(a, b, c) \
int a, b, c; \
cin >> a >> b >> c
#define din4(a, b, c, d) \
int a, b, c, d; \
cin >> a >> b >> c >> d
#define din(...) _overloaddin(__VA_ARGS__, din4, din3, din2, din1)(__VA_ARGS__)
#define _overloaddind(_1, _2, _3, _4, name, ...) name
#define din1d(a) \
din1(a); \
a--
#define din2d(a, b) \
din2(a, b); \
a--, b--
#define din3d(a, b, c) \
din3(a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din4(a, b, c, d); \
a--, b--, c--, d--
#define dind(...) \
_overloaddind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
#define _overloadout(_1, _2, _3, _4, name, ...) name
#define out1(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define out3(a, b, c) cout << a << " " << b << " " << c << endl
#define out4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl
#define out(...) \
_overloadout((__VA_ARGS__), out4, out3, out2, out1)((__VA_ARGS__))
template <class T> void outl(vector<T> &a) { fora(v, a) cout << v << endl; }
#define na(a, n) \
a.resize(n); \
rep(_i, n) cin >> a[_i];
#define dna(a, n) \
vi a(n); \
rep(_i, n) cin >> a[_i];
#define nao(a, n) \
a.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1];
#define nad(a, n) \
a.resize(n); \
rep(_i, n) { \
cin >> a[_i]; \
a[_i]--; \
}
#define na2(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define dna2(a, b, n) \
vi a(n), b(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define nao2(a, b, n) \
a.resize(n + 1), b.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1] >> b[_i + 1];
#define na2d(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i]; \
a[_i]--, b[_i]--; \
}
#define na3(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define dna3(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define na3d(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define dna3d(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define nt(a, h, w) \
resize(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi];
#define ntd(a, h, w) \
rs(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi], a[_hi][_wi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(_hi, 1, h + 1) rep(_wi, 1, w + 1) cin >> a[_hi][_wi];
// デバッグ
#define sp << " " <<
#define debugName(VariableName) #VariableName
#define _deb1(x) debugName(x) << " = " << x
#define _deb2(x, ...) _deb1(x) << ", " << _deb1(__VA_ARGS__)
#define _deb3(x, ...) _deb1(x) << ", " << _deb2(__VA_ARGS__)
#define _deb4(x, ...) _deb1(x) << ", " << _deb3(__VA_ARGS__)
#define _deb5(x, ...) _deb1(x) << ", " << _deb4(__VA_ARGS__)
#define _deb6(x, ...) _deb1(x) << ", " << _deb5(__VA_ARGS__)
#define _deb7(x, ...) _deb1(x) << ", " << _deb6(__VA_ARGS__)
#define _deb8(x, ...) _deb1(x) << ", " << _deb7(__VA_ARGS__)
#define _deb9(x, ...) _deb1(x) << ", " << _deb8(__VA_ARGS__)
#define _deb10(x, ...) _deb1(x) << ", " << _deb9(__VA_ARGS__)
#define _overloadebug(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, name, ...) name
#ifdef _DEBUG
#define deb(...) \
cerr << _overloadebug(__VA_ARGS__, _deb10, _deb9, _deb8, _deb7, _deb6, \
_deb5, _deb4, _deb3, _deb2, _deb1)(__VA_ARGS__) \
<< endl
#else
#define deb(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
// よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
int find(int x) { return root(x); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
// 順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.fi;
res[i].push_back(r);
for (auto &&v : p.se) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
using bint = __int128;
using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 toi128(string &s) {
__int128 ret = 0;
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
template <typename T> T minv(T a, T m);
template <typename T> T minv(T a);
template <typename T> class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U> Modular(const U &x) { value = normalize(x); }
template <typename U> static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0)
v += mod();
return v;
}
const Type &operator()() const { return value; }
template <typename U> explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
if ((value += other.value) >= mod())
value -= mod();
return *this;
}
Modular &operator-=(const Modular &other) {
if ((value -= other.value) < 0)
value += mod();
return *this;
}
template <typename U> Modular &operator+=(const U &other) {
return *this += Modular(other);
}
template <typename U> Modular &operator-=(const U &other) {
return *this -= Modular(other);
}
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(signed) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(signed) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, signed>::value,
Modular>::type &
operator*=(const Modular &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type &
operator*=(const Modular &rhs) {
int64_t q =
static_cast<int64_t>(static_cast<double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) {
return *this *= Modular(minv(other.value));
}
template <typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
operator int() { return normalize(value); }
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
constexpr signed MOD = 1e9 + 7; // MOD
using mint = Modular<std::integral_constant<decay<decltype(MOD)>::type, MOD>>;
constexpr int mint_len = 1400001;
vi fac, finv, inv;
vi p2;
void setmod() {
// p2.resize(mint_len);p[0] = 1; for (int i = 1; i < mint_len; ++i) p2[i] =
// p2[i - 1] * 2 % MOD;
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
#define smod setmod
inline mint com(int n, int r) {
if (r < 0 || r > n)
return 0;
return mint(finv[r] * fac[n] % MOD * finv[n - r]);
}
inline mint pom(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - 1]);
}
inline mint npr(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
inline int nprin(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return fac[n] * finv[n - r] % MOD;
}
inline int icom(int n, int r) {
const int NUM_ = 1400001;
static ll fac[NUM_ + 1], finv[NUM_ + 1], inv[NUM_ + 1];
if (fac[0] == 0) {
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
if (r < 0 || r > n)
return 0;
return ((finv[r] * fac[n] % MOD) * finv[n - r]) % MOD;
}
#define ncr com
#define ncri icom
inline mint nhr(int n, int r) { return com(n + r - 1, r); }
inline mint hom(int n, int r) { return com(n + r - 1, r); }
inline int nhri(int n, int r) { return icom(n + r - 1, r); }
template <typename T> inline T minv(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T> inline T minv(T a) {
if (a < mint_len)
return inv[a];
T u = 0, v = 1;
T m = MOD;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T, typename U>
inline Modular<T> mpow(const Modular<T> &a, const U &b) {
assert(b >= 0);
int x = a(), res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline mint mpow(const T a, const U b, const V m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T, typename U> inline mint mpow(const T a, const U b) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline int mpowi(const T &a, const U &b, const V &m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T> inline string to_string(const Modular<T> &number) {
return to_string(number());
}
template <typename T>
std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
return stream << number();
}
template <typename T>
std::istream &operator>>(std::istream &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
using PM = pair<mint, mint>;
using vm = vector<mint>;
using mapm = map<int, mint>;
using umapm = umap<int, mint>;
#define _overloadvvm(_1, _2, _3, _4, name, ...) name
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
#define vvm1(a) vec<vm> a
#define vvm2(a, b) vec<vm> a(b)
#define vvm3(a, b, c) vec<vm> a(b, vm(c))
#define vvm4(a, b, c, d) vec<vm> a(b, vm(c, d))
#define vvm(...) _overloadvvm(__VA_ARGS__, vvm4, vvm3, vvm2, vvm1)(__VA_ARGS__)
// エラー
void ole() {
#ifdef _DEBUG
debugline("ole");
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re() { assert(0 == 1); }
void tle() {
while (inf)
cout << inf << endl;
}
// 便利関数
// テスト用
char ranc() { return (char)('a' + rand() % 26); }
int rand(int min, int max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
//+
if (rand() % 2) {
return rand(0, max);
//-
} else {
return -rand(0, -min);
}
}
}
vi ranv(int n, int min, int max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
// 単調増加
vi ranvi(int n, int min, int max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
void ranvlr(int n, int min, int max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
// 便利 汎用
vp run_length(vi &a) {
vp ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
vector<pair<char, int>> run_length(string &a) {
vector<pair<char, int>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
template <class F> inline int mgr(int ok, int ng, F f) {
#define _mgrbody \
int mid = (ok + ng) / 2; \
if (f(mid)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody
}
else
while (ok - ng > 1) {
_mgrbody
}
return ok;
}
template <class F> inline int mgr(int ok, int ng, int second, F f) {
#define _mgrbody2 \
int mid = (ok + ng) / 2; \
if (f(mid, second)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody2
}
else
while (ok - ng > 1) {
_mgrbody2
}
return ok;
}
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return b;
} else if (a[i] > b[i])
return a;
}
}
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) < sz(b)) {
return a;
} else if (sz(a) > sz(b)) {
return b;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i])
return b;
}
}
return a;
}
template <typename V, typename T> int find(vector<V> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename V, typename T> P find(vector<vector<V>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
template <typename V, typename U>
T find(vector<vector<vector<V>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
return mt(-1, -1, -1);
}
template <typename V, typename T> int count2(V &a, const T k) { return a == k; }
template <typename V, typename T> int count2(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count(v, k);
return ret;
}
template <typename V, typename T> int count(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
int count(str a, str k) {
int ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ret++;
return ret;
}
template <typename V> int count_odd(V &a) { return a % 2; }
template <typename V> int count_odd(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_odd(v);
return ret;
}
template <typename V> int count_even(V &a) { return a % 2 == 0; }
template <typename V> int count_even(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_even(v);
return ret;
}
// algorythm
void iota(vector<int> &ve, int s, int n) {
ve.resize(n);
iota(all(ve), s);
}
vi iota(int s, int len) {
vi ve(len);
iota(all(ve), s);
return ve;
}
inline ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class T> vector<T> revv(vector<T> &a) {
vector<T> b = a;
reverse(all(b));
return b;
}
void inline rev(string &a) { reverse(all(a)); }
constexpr int p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
int get(int a, int keta) { return (a / (int)pow(10, keta)) % 10; }
int keta(ll v) {
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1])
return 1;
else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else if (v < p10[15])
return 15;
else
return 16;
} else {
if (v < p10[17])
return 17;
else
return 18;
}
}
}
}
int dsum(int v) {
int ret = 0;
for (; v; v /= 10)
ret += v % 10;
return ret;
}
inline int sumd(int v) { return dsum(v); }
struct sint {
int v;
sint(int v) : v(v) {}
operator int() { return v; }
int operator[](int i) { return (v / p10[i]) % 10; }
int top(int i) {
int len = keta(v);
return operator[](len - 1 - i);
}
// 先頭からi番目にセット
int top(int i, int k) {
int len = keta(v);
return set(len - 1 - i, k);
}
int set(int i, int k) {
if (i < 0)
return top(abs(i) - 1, k);
return v += p10[i] * (k - (v / p10[i]) % 10);
}
int inc(int i, int k = 1) { return v += p10[i] * k; }
int inct(int i, int k = 1) { return v += p10[keta(v) - i - 1] * k; }
int dec(int i, int k = 1) { return v -= p10[i] * k; }
int dect(int i, int k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o) \
template <class T> inline t operator o(T r) { return v o r; }
op(int, +=);
op(int, -=);
op(int, *=);
op(int, /=);
op(int, %=);
op(int, +);
op(int, -);
op(int, *);
op(int, /);
op(int, %);
op(bool, ==);
op(bool, !=);
op(bool, <);
op(bool, <=);
op(bool, >);
op(bool, >=);
#undef op
template <class T> inline int operator<<=(T r) { return v *= p10[r]; }
template <class T> inline int operator<<(T r) { return v * p10[r]; }
template <class T> inline int operator>>=(T r) { return v /= p10[r]; }
template <class T> inline int operator>>(T r) { return v / p10[r]; }
};
int mask10(int v) { return p10[v] - 1; }
// 変換系
template <class T, class U> inline vector<T> keys(vector<pair<T, U>> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> vector<U> inline values(vector<pair<T, U>> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chma(const U &b) { return chma(ma, b); }
template <class T, class U> inline bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chmi(const U &b) { return chmi(mi, b); }
template <class T> inline T min(T a, signed b) { return a < b ? a : b; }
template <class T> inline T max(T a, signed b) { return a < b ? b : a; }
template <class T> inline T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> inline T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> inline T min(vector<T> a) { return *min_element(all(a)); }
template <class T> inline T mini(vector<T> a) {
return min_element(all(a)) - a.begin();
}
template <class T> inline T min(vector<T> a, int n) {
return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T min(vector<T> a, int s, int n) {
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a) { return *max_element(all(a)); }
template <class T> inline T maxi(vector<T> a) {
return max_element(all(a)) - a.begin();
}
template <class T> inline T max(vector<T> a, int n) {
return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a, int s, int n) {
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> inline A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> inline A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <class T> inline T sum(T &v) { return v; }
template <class T> inline auto sum(vector<T> &v) {
auto ret = sum(v[0]);
rep(i, 1, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T, class U, class... V>
inline auto sum(vector<T> &v, U head, V... tail) {
auto ret = sum(v[0], tail...);
rep(i, 1, min(sz(v), head)) ret += sum(v[i], tail...);
return ret;
}
inline P sump(vp &v, int len = -1) {
if (len == -1)
len = v.size();
P res = {0, 0};
chmi(len, v.size());
rep(i, len) {
res.fi += v[i].fi;
res.se += v[i].se;
}
return res;
}
/// 要素が0の時、返り値は0か1か
template <class T> inline T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
chmi(len, v.size());
rep(i, len) res *= v[i];
return res;
}
inline void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> inline void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> inline T *negarr(int size) {
T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
return body + size;
}
template <class T> inline T *negarr2(int h, int w) {
double **dummy1 = new double *[2 * h + 1];
double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
dummy1[0] = dummy2 + w;
for (int i = 1; i <= 2 * h + 1; i++) {
dummy1[i] = dummy1[i - 1] + 2 * w + 1;
}
double **a = dummy1 + h;
return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> inline vector<T> imo(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// kと同じものの数
template <class T, class U> inline vi imo(vector<T> &a, U k) {
vector<T> ret = a;
rep(i, sz(ret) - 1) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T> inline vector<T> imox(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> inline vector<T> imi(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> struct ruiC {
const vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
inline T operator()(int l, int r) {
assert(l <= r);
return rui[r] - rui[l];
}
inline T operator[](int i) { return rui[i]; }
};
template <class T> struct rruic {
const T *rrui;
rruic(T *ru) : rrui(ru) {}
// n-1から-1へ
inline T operator()(int l, int r) {
assert(l >= r);
return rrui[r] - rrui[l];
}
inline T operator[](int i) { return rrui[i]; }
};
template <class T> inline vector<T> ruiv(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> inline ruiC<T> ruic(vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
// kと同じものの数
template <class T, class U> inline vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> inline ruiC<int> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<int>(ret);
}
// xor
template <class T> inline vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> inline vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> inline vector<T> ruimi(vector<T> &a) {
int n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> rruic<T> rrui(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
rer(i, len - 1) res[i - 1] = res[i] + a[i];
return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void inc(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void plus(T &a, U v = 1) { a += v; }
template <class T, class U> void plus(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void plus(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void dec(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class T, class U> void minu(T &a, U v = 1) { a -= v; }
template <class T, class U> void minu(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void minu(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class U> void minu(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
void minu(string &a) {
for (auto &u : a)
dec(u, 1);
}
inline bool inside(int h, int w, int H, int W) {
return h >= 0 && w >= 0 && h < H && w < W;
}
inline bool inside(int l, int v, int r) { return l <= v && v < r; }
#define ins inside
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
vector<T> ret = a;
fora(v, ret) v = u(v);
return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
ll goldd(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return resIndex;
}
ll goldt(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return resIndex;
}
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmi(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chma(res, *max_element(all(a[i])));
return res;
}
constexpr bool bget(ll m, int keta) {
assert(keta < 64);
return (m >> keta) & 1;
}
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
ll bit(int n) { return (1LL << (n)); }
ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int mask(int n) { return (1ll << n) - 1; }
// int bcou(ll m) { return __builtin_popcount(m & 0xFFFFFFFF) +
// __builtin_popcount(m >> 32); }
#define bcou __builtin_popcountll
// 最下位ビット
int lbit(int n) { return n & -n; }
// 最上位ビット
int hbit(int n) {
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
int hbitk(int n) {
int k = 0;
rer(i, 5) {
int a = k + (1ll << i);
int b = 1ll << a;
if (b <= n)
k += 1ll << i;
}
return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; // 最下位の1
ll y = mask + x; // 連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
// 大文字小文字を区別する
int altoiaZ(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoalaZ(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
// aもAも0を返す 基本小文字
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
char itoal(int i) { return 'a' + i; }
int ctoi(char c) { return c - '0'; }
char itoc(int i) { return i + '0'; }
int vtoi(vi &v) {
int res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(int i) {
vi res;
while (i) {
res.pb(i % 10);
i /= 10;
}
rev(res);
return res;
}
vi stov(string &a) {
int n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
vector<vector<int>> ctoi(vector<vector<char>> s, char c) {
int n = sz(s), m = sz(s[0]);
vector<vector<int>> res(n, vector<int>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
void compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
// 便利 数学 math
int mod(int a, int m) { return (a % m + m) % m; }
int pow(int a) { return a * a; };
ll fact(int v) { return v <= 1 ? 1 : v * fact(v - 1); }
ll comi(int n, int r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
double comd(int n, int r) {
assert(n < 2020);
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
int gcd(int a, int b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
int gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
int res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
namespace pnumber_tools {
#define Eratosthenes30_2 \
class Eratosthenes { \
public: \
virtual void initialize() {} \
virtual void generate(const int64_t x) = 0; \
virtual void generate(const int64_t from, const int64_t to) = 0; \
virtual int64_t count() = 0; \
virtual bool prime(int x) = 0; \
virtual int32_t version() = 0; \
inline uint64_t PopCnt(uint64_t); \
inline int BitToIndex(uint8_t); \
}; \
uint64_t Eratosthenes::PopCnt(uint64_t bits) { \
bits = (bits & 0x5555555555555555ULL) + \
((bits >> 1) & 0x5555555555555555ULL); \
bits = (bits & 0x3333333333333333ULL) + \
((bits >> 2) & 0x3333333333333333ULL); \
bits = (bits & 0x0f0f0f0f0f0f0f0fULL) + \
((bits >> 4) & 0x0f0f0f0f0f0f0f0fULL); \
return (bits * 0x0101010101010101ULL) >> (64 - 8); \
} \
int Eratosthenes::BitToIndex(uint8_t b) { \
switch (b) { \
case 1 << 0: \
return 0; \
case 1 << 1: \
return 1; \
case 1 << 2: \
return 2; \
case 1 << 3: \
return 3; \
case 1 << 4: \
return 4; \
case 1 << 5: \
return 5; \
case 1 << 6: \
return 6; \
case 1 << 7: \
return 7; \
} \
return -1; \
} \
namespace { \
const uint64_t kSegmentSize = 1000000; \
const int32_t kMod30[] = {1, 7, 11, 13, 17, 19, 23, 29}; \
const int C1[] = {6, 4, 2, 4, 2, 4, 6, 2}; \
const int C0[][8] = { \
{0, 0, 0, 0, 0, 0, 0, 1}, {1, 1, 1, 0, 1, 1, 1, 1}, \
{2, 2, 0, 2, 0, 2, 2, 1}, {3, 1, 1, 2, 1, 1, 3, 1}, \
{3, 3, 1, 2, 1, 3, 3, 1}, {4, 2, 2, 2, 2, 2, 4, 1}, \
{5, 3, 1, 4, 1, 3, 5, 1}, {6, 4, 2, 4, 2, 4, 6, 1}, \
}; \
const uint8_t kMask[][8] = { \
{0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f}, \
{0xfd, 0xdf, 0xef, 0xfe, 0x7f, 0xf7, 0xfb, 0xbf}, \
{0xfb, 0xef, 0xfe, 0xbf, 0xfd, 0x7f, 0xf7, 0xdf}, \
{0xf7, 0xfe, 0xbf, 0xdf, 0xfb, 0xfd, 0x7f, 0xef}, \
{0xef, 0x7f, 0xfd, 0xfb, 0xdf, 0xbf, 0xfe, 0xf7}, \
{0xdf, 0xf7, 0x7f, 0xfd, 0xbf, 0xfe, 0xef, 0xfb}, \
{0xbf, 0xfb, 0xf7, 0x7f, 0xfe, 0xef, 0xdf, 0xfd}, \
{0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe}, \
}; \
const int64_t kSievedPrimes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23}; \
const int64_t kInitialSize = 7 * 11 * 13 * 17 * 19 * 23; \
class Eratosthenes2 final : public Eratosthenes { \
public: \
void generate(const int64_t x) override; \
void generate(const int64_t, const int64_t) override { assert(false); } \
bool prime(int x) override; \
int64_t count() override; \
int32_t version() override { return 2; } \
std::vector<uint8_t> flags_; \
}; \
void Eratosthenes2::generate(const int64_t x) { \
flags_.clear(); \
if (x > 10000000000) \
return; \
int64_t size = x / 30 + (x % 30 != 0); \
flags_.resize(size, 0xff); \
if (int r = x % 30) { \
if (r <= 1) \
flags_[size - 1] = 0x0; \
else if (r <= 7) \
flags_[size - 1] = 0x1; \
else if (r <= 11) \
flags_[size - 1] = 0x3; \
else if (r <= 13) \
flags_[size - 1] = 0x7; \
else if (r <= 17) \
flags_[size - 1] = 0xf; \
else if (r <= 19) \
flags_[size - 1] = 0x1f; \
else if (r <= 23) \
flags_[size - 1] = 0x3f; \
else if (r <= 29) \
flags_[size - 1] = 0x7f; \
} \
flags_[0] = 0xfe; \
const uint64_t sqrt_x = std::ceil(std::sqrt(x) + 0.1); \
const uint64_t sqrt_xi = sqrt_x / 30 + 1; \
for (uint64_t i = 0; i < sqrt_xi; ++i) { \
for (uint8_t flags = flags_[i]; flags; flags &= flags - 1) { \
uint8_t lsb = flags & (-flags); \
int ibit = BitToIndex(lsb); \
const int32_t m = kMod30[ibit]; \
int32_t pm = 30 * i + 2 * m; \
for (uint64_t j = i * pm + (m * m) / 30, k = ibit; j < flags_.size(); \
j += i * C1[k] + C0[ibit][k], k = (k + 1) & 7) { \
flags_[j] &= kMask[ibit][k]; \
} \
} \
} \
} \
int64_t Eratosthenes2::count() { \
if (flags_.empty()) \
return -1; \
int64_t ret = 3; \
for (uint8_t f : flags_) { \
ret += PopCnt(f); \
} \
return ret; \
} \
inline bool Eratosthenes2::prime(int x) { \
static unordered_map<int, int> imap = { \
{1, 0}, {7, 1}, {11, 2}, {13, 3}, {17, 4}, {19, 5}, {23, 6}, {29, 7}}; \
if (x == 2 || x == 3 || x == 5) \
return true; \
else if (!(x & 1) || x % 3 == 0 || x % 5 == 0) \
return false; \
return (flags_[x / 30] >> imap[x % 30]) & 1; \
} \
}
Eratosthenes30_2 Eratosthenes2 era;
int prime_len = 3e6;
vector<int> primes;
void setprime(int size = 3e6) {
prime_len = size;
era.generate(size);
primes = {2, 3, 5};
int nums[129] = {};
nums[1] = 1;
nums[2] = 7;
nums[4] = 11;
nums[8] = 13;
nums[16] = 17;
nums[32] = 19;
nums[64] = 23;
nums[128] = 29;
// p = 30i + j
int j = 0;
int sflim = era.flags_.size();
int i30 = 0;
for (int i = 0; i < sflim; i++, i30 += 30) {
uint8_t m = era.flags_[i];
while (m) {
j = m & -m;
primes.push_back(i30 + nums[j]);
m ^= j;
}
}
}
using u32 = unsigned int; // longlongになっていると思うが放置していいと思う
using u64 = unsigned long long;
using u128 = __uint128_t;
// O(k log(n)^3)
// 32bit -> 270回程度
// 64bit -> 1260回程度
// 64bit以下で精度100%
template <class BinOp>
bool miller_rabin(const uint64_t &n, const uint64_t *witness, BinOp modmul) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
const int64_t m = n - 1, d = m / (m & -m);
auto modpow = [&](int64_t a, int64_t b) {
int64_t res = 1;
for (; b; b /= 2) {
if (b & 1)
res = modmul(res, a);
a = modmul(a, a);
}
return res;
};
auto suspect = [&](uint64_t a, uint64_t t) {
a = modpow(a, t);
while (t != n - 1 && a != 1 && a != n - 1) {
a = modmul(a, a);
t = modmul(t, 2);
}
return a == n - 1 || t % 2 == 1;
};
for (const uint64_t *w = witness; *w; w++) {
if (*w % n != 0 && !suspect(*w, d))
return false;
}
return true;
}
// miller_rabin & エラトステネス
bool prime(const int &n) {
assert(n < 9223372036854775808ULL);
if (!sz(primes))
setprime();
// エラトステネスの篩 偶数省略ver
//[i] = i*2+1
if (n < prime_len)
return era.prime(n);
if (n < 4294967296) {
rep(i, 30) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 7, 61, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t { return a * b % n; };
return miller_rabin(n, witness, modmul);
} else {
rep(i, 50) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 325, 9375, 28178,
450775, 9780504, 1795265022, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t {
return (uint64_t)((__uint128_t)a * b % n);
};
return miller_rabin(n, witness, modmul);
}
}
vi divisors(int v) {
vi res;
double lim = std::sqrt(v);
for (int i = 1; i <= lim; ++i) {
if (v % i == 0) {
res.pb(i);
// if (i != v / i)res.pb(v / i);
}
}
rer(i, sz(res) - 1) {
if (res[i] != v / res[i])
res.pb(v / res[i]);
}
return res;
}
vp factorization(int v) {
assert(v);
int tv = v;
vp res;
if (!sz(primes))
setprime();
for (auto &&p : primes) {
if (v % p == 0)
res.eb(p, 0);
while (v % p == 0) {
v /= p;
res.back().second++;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.eb(v, 1);
return res;
}
// 注意 gcdを取る間隔 i%10 が場合によってはtleを引き起こす
// うまくいかなかったら%1で動かすように変更した
vp rho(int v) {
assert(v);
if (v == 1)
return vp();
vi ret;
if (!sz(primes))
setprime();
int lim = 300; // 64bit
if (v < 4294967296)
lim = 80; // 32bit
else if (v < 281474976710656LL)
lim = 120; // 48bit
for (int i = 0; i < lim; i += 5) {
// v<=1の判定回数を減らせる分高速化できる事を期待している
while (v % primes[i] == 0)
ret.pb(primes[i]), v /= primes[i];
while (v % primes[i + 1] == 0)
ret.pb(primes[i + 1]), v /= primes[i + 1];
while (v % primes[i + 2] == 0)
ret.pb(primes[i + 2]), v /= primes[i + 2];
while (v % primes[i + 3] == 0)
ret.pb(primes[i + 3]), v /= primes[i + 3];
while (v % primes[i + 4] == 0)
ret.pb(primes[i + 4]), v /= primes[i + 4];
if (v <= 1) {
sort(ret); // 試し割りだけで終わった時
return run_length(ret);
}
}
int lower_prime_bound = primes[lim - 1] * primes[lim - 1];
// 試し割りするか
mt19937 mr;
mr.seed(clock());
int c;
auto fac = [&](int v, const int loop = 10) {
// if (v == 4)return 2ll; //試し割りで消えた
c = mr() % v;
int x = mr() % v;
int y = x;
int d = 1;
int lim = std::sqrt(v) + 2;
// brentによる改良 差分を一操作で求められる
for (int i = 1, mul = 1, next_2pow = 2; d == 1 && i <= lim; i++) {
if (i == next_2pow) {
y = x;
next_2pow <<= 1;
}
x = ((u128)x * x + c) % v;
mul = ((u128)mul * abs(x - y)) %
v; // ユークリッドの互除法と同じ原理で因数は保たれる
if (i % loop == 0) { // 10とかなんとか iによっては死ぬ
d = gcd(mul, v);
mul = 1;
}
}
if (d == v)
return -1ll;
return d;
};
queue<int> q;
q.push(v);
while (!q.empty()) {
int v = q.front();
q.pop();
if (prime(v)) {
ret.pb(v);
continue;
}
int d = -1;
// 基本loop回数10でやり、駄目なら1で
for (int i = 0; d == -1 && i < 5; i++)
d = fac(v, 10);
if (d == -1)
while (d == -1)
d = fac(v, 1);
int d2 = v / d;
rep(_, 2) {
if (d <= lower_prime_bound)
ret.pb(d);
else
q.push(d);
d = d2;
}
}
sort(ret);
return run_length(ret);
}
} // namespace pnumber_tools
using namespace pnumber_tools;
// 幾何 Pをcomplexとして扱う
template <class T, class U> bool eq(T a, U b) { return fabs(a - b) < eps; }
dou atan2(pd a) { return atan2(a.se, a.fi); }
dou angle(pd f, pd t) { return atan2(t.se - f.se, t.fi - f.fi); }
dou distance(pd a, pd b) { return hypot(a.fi - b.fi, a.se - b.se); }
// bを中心とするabcのtheta aからcにかけて時計回り
dou angle(pd a, pd b, pd c) {
dou ax = a.fi - b.fi;
dou ay = a.se - b.se;
dou cx = c.fi - b.fi;
dou cy = c.se - b.se;
double ret = atan2(cy, cx) - atan2(ay, ax);
if (ret < 0)
ret += 2 * PI;
return ret;
}
dou dot(pd a, pd b) { return a.fi * b.fi + a.se + b.se; }
dou cro(pd a, pd b) { return a.fi * b.se - a.se + b.fi; }
template <class T> struct edge {
int f, t;
T c;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: f(f), t(t), c(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return c < b.c; }
bool operator>(const edge &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge<T> &e) {
os << e.f << " " << e.t << " " << e.c;
return os;
}
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) { g.resize(n), _used.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
vector<edge<T>> &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int id, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, id, ty);
edges.emplace_back(f, t, c, id, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("undigraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid, eid += 2;
g[f].emplace_back(f, t, c, id, ty);
g[t].emplace_back(t, f, c, id + 1, ty);
edges.emplace_back(f, t, c, id, ty);
edges.emplace_back(t, f, c, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.f, t = e.t, ty = e.type;
T c = e.c;
add(f, t, c, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <typename T> struct radixheap {
vector<pair<u64, T>> v[65];
u64 size, last;
radixheap() : size(0), last(0) {}
bool empty() const { return size == 0; }
inline int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
void push(u64 key, const T &value) {
++size;
v[getbit(key ^ last)].emplace_back(key, value);
}
pair<u64, T> pop() {
if (v[0].empty()) {
int idx = 1;
while (v[idx].empty())
++idx;
last = min_element(begin(v[idx]), end(v[idx]))->first;
for (auto &p : v[idx])
v[getbit(p.first ^ last)].emplace_back(p);
v[idx].clear();
}
--size;
auto ret = v[0].back();
v[0].pop_back();
return ret;
}
};
vi dijkstra2(const graph<int> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
int initValue = MAX(int);
vi dis(g.n, initValue);
radixheap<int> q;
dis[s] = 0;
q.push(0, s);
while (!q.empty()) {
int nowc, i;
tie(nowc, i) = q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
int c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.push(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<T> dijkstra(const graph<T> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.emplace(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<vector<T>> warshall(const graph<T> &g, int cant_arrive = -1) {
int n = g.n;
vector<vector<T>> dis(n, vector<T>(n, linf));
rep(i, n) fora(e, g.g[i]) chmi(dis[e.f][e.t], e.c);
rep(i, n) dis[i][i] = 0;
rep(k, n) rep(i, n) rep(j, n) chmi(dis[i][j], dis[i][k] + dis[k][j]);
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = -1;
return dis;
}
template <class T = int> class tree : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
vi disv;
private:
bool never = 1;
int root = -1;
vi dep; // 到着した順の深さ
vi vis; // 到着した順
vi first; // 初めてiに到着した時
vector<int> bestt; // タイミングを持つ
int sn = 0; // seg木の底辺の長さ euler tourの長さ
void built() {
never = 0;
n = g.size();
// euler tour
disv.resize(n);
first.resize(n);
dep.resize(n * 2);
vis.resize(n * 2);
function<void(int, int, int, int &)> dfs = [&](int i, int p, int d,
int &k) {
first[i] = k;
vis[k] = i;
dep[k++] = d;
forg(gi, g[i]) {
if (t == p)
continue;
disv[t] = disv[i] + c;
dfs(t, i, d + 1, k);
vis[k] = i;
dep[k++] = d;
}
};
int k = 0;
dfs(root, -1, 0, k);
// rmq
sn = 1;
while (sn < n * 2)
sn <<= 1;
bestt.resize((sn << 1) - 1);
rep(i, k) bestt[i + sn - 1] = i; // 時間を持つ
rer(i, sn - 2) {
int lt = (i << 1) + 1, rt = (i << 1) + 2;
if (dep[bestt[lt]] < dep[bestt[rt]]) {
bestt[i] = bestt[lt];
} else {
bestt[i] = bestt[rt];
}
}
}
// 最小の深さを持つタイミングが知りたい
inline int lca_rmq(int l, int r) {
int midv = inf;
int midi = -1;
l += sn - 1;
r += sn - 1;
while (l < r) {
// 右なら、次に右上へ移動してしまうので
if (!(l & 1)) {
if (chmi(midv, dep[bestt[l]])) {
midi = bestt[l];
}
}
// 右なら、左を取らないと機会を逃す
if (!(r & 1)) {
if (chmi(midv, dep[bestt[r - 1]])) {
midi = bestt[r - 1];
}
}
l >>= 1;
r = (r - 1) >> 1;
}
return vis[midi];
}
public:
tree(int n, int root = 0) : undigraph<T>(n), root(root) {}
bool leaf(int v) { return sz(g[v]) == 1 && v != root; }
int lca(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
return lca_rmq(first[u], first[v] + 1);
}
int dis(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
int p = lca_rmq(first[u], first[v] + 1);
return disv[u] + disv[v] - disv[p] * 2;
}
};
// 辺によりメモリを大量消費
// よってedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
// 軽量化のため、辺を持たないbig gridクラスがあってもいいかもしれない
//
template <class T = int> class grid_k6 : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("grid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
g[t].emplace_back(t, f, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
grid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
using digraph<T>::g;
using digraph<T>::n;
using digraph<T>::edges;
using digraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digrid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
digrid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
template <class T> bool nibu(const graph<T> &g) {
int size = 0;
rep(i, g.n) size += sz(g.g[i]);
if (size == 0)
return true;
UnionFind uf(g.n * 2);
rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
uf.unite(e.f + g.n, e.t);
rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
return 1;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
vp cg;
if (!nibu(g)) {
debugline("nibu");
ole();
}
int _n = g.size();
vb _was(_n);
queue<P> q;
rep(i, _n) {
if (_was[i])
continue;
q.push(mp(i, 1));
_was[i] = 1;
int red = 0;
int coun = 0;
while (q.size()) {
int now = q.front().fi;
int col = q.front().se;
red += col;
coun++;
q.pop();
forg(gi, g[now]) {
if (_was[t])
continue;
q.push(mp(t, col ^ 1));
_was[t] = 1;
}
}
cg.push_back(mp(red, coun - red));
}
return cg;
}
template <class T> ostream &operator<<(ostream &os, graph<T> &g) {
rep(i, sz(g)) {
forg(gi, g[i]) { os << f << " " << t << " " << c << endl; }
}
return os;
}
// 機能拡張
vp vtop(vi &a, vi &b) {
vp res(sz(a));
rep(i, sz(a)) res[i] = mp(a[i], b[i]);
return res;
}
void ptov(vp &p, vi &a, vi &b) {
a.resize(sz(p));
b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
__lhs += to_string(__rv);
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
__lhs += to_string(__rv);
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T, class U> set<T> &operator+=(set<T> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.pb(v);
return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
vector<T> ret;
ret = a;
fora(v, b) ret += v;
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
fora(v, b) a += v;
return a;
}
template <class T, class U>
vector<T> &operator+=(vector<T> &a, initializer_list<U> v) {
for (auto &&va : v)
a.pb(va);
return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
ole();
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T, typename U>
void insert(vector<T> &v, initializer_list<U> list) {
for (auto &&va : list)
v.pb(va);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, initializer_list<U> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
template <typename T> void insert(set<T> &v, initializer_list<T> list) {
for (auto &&va : list)
v.insert(va);
}
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
}
return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
// 小さい順
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) if (nyu[i] == 0) q.push(i);
while (q.size()) {
int i = q.top();
q.pop();
res.pb(i);
fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
void yn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Yn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fyn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
exit(0);
}
void fYn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
exit(0);
}
void fYN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
void Possible(bool a) {
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
int n, m, k, d, H, W, x, y, z, q;
int cou;
vi t, a, b, c;
// vvi (s, 0, 0);
vvc(ba, 0, 0);
vp p;
str s;
void solve() {
cin >> n >> m;
na(a, n);
na2(b, c, m);
rsortp(c, b);
priority_queue<int, vector<int>, greater<int>> q; // 小さい順
rep(i, n) q += a[i];
rep(i, m) {
rep(j, b[i]) {
int v = q.top();
if (v < c[i]) {
q.pop();
q += c[i];
} else {
break;
}
}
}
while (sz(q)) {
cou += q.top();
q.pop();
}
cout << cou << endl;
}
int my(int n, vi &a) { return 0; }
int sister(int n, vi &a) {
int ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (int i = 0, ok = 1; i < k5 && ok; i++) {
int n = rand(1, 8);
vi a = ranv(n, 1, 10);
int myres = my(arg);
int res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "正解 : " << res << endl;
cerr << "自分 : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// cout << "完璧 : solveを書き直そう" << endl;
// cout << " : そして、solve()を呼び出すのだ" << endl;
// cout << " : cin>>n; na(a,n);も忘れるな" << endl;
}
#endif
return 0;
};
| insert | 3,552 | 3,552 | 3,552 | 3,554 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
ll i, j, k, n, m;
cin >> n >> m;
vector<ll> a(n);
vector<pair<ll, ll>> q(n + 1);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> q[i].second >> q[i].first;
}
// sort(a.begin(),a.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
vector<ll> change(n);
ll now = 0; // 置き換えたところ
priority_queue<ll> que;
ll qs = q.size();
for (i = 0; i < qs; i++) {
for (j = 0; j < q[i].second; j++) {
// change[now++]=q[i].first;
que.push(q[i].first);
now++;
if (now == n)
break;
}
if (now == n)
break;
}
// sort(change.begin(),change.end());
// reverse(change.begin(),change.end());
// ll s = change.size();
for (i = 0; i < n; i++) {
que.push(a[i]);
}
ll ret = 0;
// for(i=0;i<s;i++)que.push(change[i]);
for (i = 0; i < n; i++) {
ret += que.top();
que.pop();
}
cout << ret << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
using namespace std;
int main() {
ll i, j, k, n, m;
cin >> n >> m;
vector<ll> a(n);
vector<pair<ll, ll>> q(m);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> q[i].second >> q[i].first;
}
// sort(a.begin(),a.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
vector<ll> change(n);
ll now = 0; // 置き換えたところ
priority_queue<ll> que;
ll qs = q.size();
for (i = 0; i < qs; i++) {
for (j = 0; j < q[i].second; j++) {
// change[now++]=q[i].first;
que.push(q[i].first);
now++;
if (now == n)
break;
}
if (now == n)
break;
}
// sort(change.begin(),change.end());
// reverse(change.begin(),change.end());
// ll s = change.size();
for (i = 0; i < n; i++) {
que.push(a[i]);
}
ll ret = 0;
// for(i=0;i<s;i++)que.push(change[i]);
for (i = 0; i < n; i++) {
ret += que.top();
que.pop();
}
cout << ret << endl;
return 0;
}
| replace | 14 | 15 | 14 | 15 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
#define int long long
#define mod (int)(1000000007)
using namespace std;
int test[213456];
signed main() {
int n, k, b = 0, ans = 0;
cin >> n >> k;
int a = k - 1;
for (int h = 0; h < n; h++) {
cin >> test[h];
}
sort(test, test + n);
vector<vector<long long>> aa(k, vector<long long>(2));
for (int h = 0; h < k; h++) {
cin >> aa[h][1] >> aa[h][0];
}
sort(aa.begin(), aa.end());
for (int h = 0; h < n; h++) {
if (b != 0 && test[h] < aa[a][0]) {
test[h] = aa[a][0];
b--;
if (a == 0 && b == 0) {
break;
}
if (b == 0) {
a--;
}
}
if (b == 0 && test[h] < aa[a][0]) {
test[h] = aa[a][0];
b = aa[a][1] - 1;
if (b == 0) {
a--;
}
}
}
for (int h = 0; h < n; h++) {
ans += test[h];
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
#define int long long
#define mod (int)(1000000007)
using namespace std;
int test[213456];
signed main() {
int n, k, b = 0, ans = 0;
cin >> n >> k;
int a = k - 1;
for (int h = 0; h < n; h++) {
cin >> test[h];
}
sort(test, test + n);
vector<vector<long long>> aa(k, vector<long long>(2));
for (int h = 0; h < k; h++) {
cin >> aa[h][1] >> aa[h][0];
}
sort(aa.begin(), aa.end());
for (int h = 0; h < n; h++) {
if (b != 0 && test[h] < aa[a][0]) {
test[h] = aa[a][0];
b--;
if (a == 0 && b == 0) {
break;
}
if (b == 0) {
a--;
}
}
if (b == 0 && test[h] < aa[a][0]) {
test[h] = aa[a][0];
b = aa[a][1] - 1;
if (a == 0 && b == 0) {
break;
}
if (b == 0) {
a--;
}
}
}
for (int h = 0; h < n; h++) {
ans += test[h];
}
cout << ans << endl;
} | insert | 41 | 41 | 41 | 44 | 0 | |
p03038 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
typedef long long int64;
typedef pair<int, int> ii;
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a.begin(), a.end());
vector<ii> b(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &b[i].second, &b[i].first);
}
sort(b.begin(), b.end(), greater<ii>());
vector<int> c(n);
for (int i = 0, k = 0; i < m && k < n; ++i) {
int len = min(n - i, b[i].second);
while (len--)
c[k++] = b[i].first;
}
int64 ret = 0;
for (int i = 0; i < n; ++i) {
ret += max(a[i], c[i]);
}
printf("%lld\n", ret);
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
typedef long long int64;
typedef pair<int, int> ii;
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a.begin(), a.end());
vector<ii> b(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &b[i].second, &b[i].first);
}
sort(b.begin(), b.end(), greater<ii>());
vector<int> c(n);
for (int i = 0, k = 0; i < m && k < n; ++i) {
int len = min(n - k, b[i].second);
while (len--)
c[k++] = b[i].first;
}
int64 ret = 0;
for (int i = 0; i < n; ++i) {
ret += max(a[i], c[i]);
}
printf("%lld\n", ret);
return 0;
}
| replace | 57 | 58 | 57 | 58 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 999999999
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll modpow(ll n, ll k) {
if (k == 1) {
return n;
} else if (k == 0) {
return 1;
} else if (k % 2 == 0) {
ll memo = modpow(n, k / 2) % MOD;
return memo * memo % MOD;
} else {
return n * modpow(n, k - 1) % MOD;
}
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> v;
REP(i, n) {
ll t;
cin >> t;
v.pb(t);
}
VSORT(v);
vector<LP> vlp;
REP(i, m) {
ll b, c;
cin >> b >> c;
LP lp;
lp.first = c;
lp.second = b;
vlp.pb(lp);
}
sort(vlp.begin(), vlp.end());
ll vlpCounter = m - 1;
ll vCounter = 0;
bool bo = false;
while (vlpCounter >= 0) {
ll c = vlp[vlpCounter].first;
ll b = vlp[vlpCounter].second;
for (int i = vCounter; i < vCounter + b; i++) {
if (v[i] <= c) {
v[i] = c;
} else {
bo = true;
break;
}
}
if (bo)
break;
vCounter += b;
vlpCounter--;
/*vector<ll>::iterator it = lower_bound(v.begin(),v.end(),c);
if(it==v.begin())break;
ll num = it - v.begin();
if(num<=b){
REP(i,num){
v[i] = c;
}
break;
}else{
for(int i = num-1;i>=num - b;i--){
v[i] = c;
}
}
vlpCounter--;
REP(i,n){
cout<<v[i]<<" ";
}
cout<<endl;*/
}
ll ans = 0;
REP(i, n) { ans += v[i]; }
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define INF 999999999
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll modpow(ll n, ll k) {
if (k == 1) {
return n;
} else if (k == 0) {
return 1;
} else if (k % 2 == 0) {
ll memo = modpow(n, k / 2) % MOD;
return memo * memo % MOD;
} else {
return n * modpow(n, k - 1) % MOD;
}
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> v;
REP(i, n) {
ll t;
cin >> t;
v.pb(t);
}
VSORT(v);
vector<LP> vlp;
REP(i, m) {
ll b, c;
cin >> b >> c;
LP lp;
lp.first = c;
lp.second = b;
vlp.pb(lp);
}
sort(vlp.begin(), vlp.end());
ll vlpCounter = m - 1;
ll vCounter = 0;
bool bo = false;
while (vlpCounter >= 0) {
ll c = vlp[vlpCounter].first;
ll b = vlp[vlpCounter].second;
for (int i = vCounter; i < vCounter + b; i++) {
if (i == n) {
bo = true;
break;
}
if (v[i] <= c) {
v[i] = c;
} else {
bo = true;
break;
}
}
if (bo)
break;
vCounter += b;
vlpCounter--;
/*vector<ll>::iterator it = lower_bound(v.begin(),v.end(),c);
if(it==v.begin())break;
ll num = it - v.begin();
if(num<=b){
REP(i,num){
v[i] = c;
}
break;
}else{
for(int i = num-1;i>=num - b;i--){
v[i] = c;
}
}
vlpCounter--;
REP(i,n){
cout<<v[i]<<" ";
}
cout<<endl;*/
}
ll ans = 0;
REP(i, n) { ans += v[i]; }
cout << ans << endl;
return 0;
} | insert | 68 | 68 | 68 | 72 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M, ans = 0;
cin >> N >> M;
vector<long long> A(N);
vector<long long> B(N);
map<long long, long long> mp;
long long visit = -1;
for (int i = 0; i < N; i++) {
long long a;
cin >> a;
A.at(i) = a;
}
sort(A.begin(), A.end());
for (int i = 0; i < M; i++) {
long long B, C;
cin >> B >> C;
mp[C] += B;
}
int check = 0, rock = 0;
for (auto i = mp.end(); i != mp.begin(); --i) {
if (check == 0) {
check++;
continue;
}
long long x = i->first;
long long y = i->second;
for (int j = visit + 1; j < visit + 1 + y; j++) {
B.at(j) = x;
if (j == N - 1) {
rock = 54;
break;
}
}
if (rock == 54) {
for (int i = 0; i < N; i++) {
ans += max(B.at(i), A.at(i));
}
cout << ans << endl;
return 0;
}
visit = max(visit, visit + y);
}
long long X = mp.begin()->first;
long long Y = mp.begin()->second;
for (int i = visit + 1; i < visit + 1 + Y; i++) {
B.at(i) = X;
}
for (int i = 0; i < N; i++) {
ans += max(B.at(i), A.at(i));
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M, ans = 0;
cin >> N >> M;
vector<long long> A(N);
vector<long long> B(N);
map<long long, long long> mp;
long long visit = -1;
for (int i = 0; i < N; i++) {
long long a;
cin >> a;
A.at(i) = a;
}
sort(A.begin(), A.end());
for (int i = 0; i < M; i++) {
long long B, C;
cin >> B >> C;
mp[C] += B;
}
int check = 0, rock = 0;
for (auto i = mp.end(); i != mp.begin(); --i) {
if (check == 0) {
check++;
continue;
}
long long x = i->first;
long long y = i->second;
for (int j = visit + 1; j < visit + 1 + y; j++) {
B.at(j) = x;
if (j == N - 1) {
rock = 54;
break;
}
}
if (rock == 54) {
for (int i = 0; i < N; i++) {
ans += max(B.at(i), A.at(i));
}
cout << ans << endl;
return 0;
}
visit = max(visit, visit + y);
}
long long X = mp.begin()->first;
long long Y = mp.begin()->second;
for (int i = visit + 1; i < visit + 1 + Y; i++) {
B.at(i) = X;
if (i == N - 1) {
rock = 54;
break;
}
}
for (int i = 0; i < N; i++) {
ans += max(B.at(i), A.at(i));
}
cout << ans << endl;
return 0;
} | insert | 48 | 48 | 48 | 52 | 0 | |
p03038 | C++ | Time Limit Exceeded | // todo 文字数を少なくする
// mintより高速に計算したい時用に modmul() modadd (正の値限定) を作る
// #pragma GCC optimize ("-O3")
#include <bits/stdc++.h>
using namespace std;
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} __initon;
// 衝突対策
#define ws ___ws
//@必須構造
struct T {
int f, s, t;
T() { f = -1, s = -1, t = -1; }
T(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const T &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const T &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
bool operator==(const T &r) const { return f == r.f && s == r.s && t == r.t; }
bool operator!=(const T &r) const { return f != r.f || s != r.s || t != r.t; }
int operator[](int i) {
assert(i < 3);
return i == 0 ? f : i == 1 ? s : t;
}
};
struct F {
int a, b, c, d;
F() { a = -1, b = -1, c = -1, d = -1; }
F(int a, int b, int c, int d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d;
// return a != r.a ? a > r.a : b != r.b ? b > r.b : c != r.c ? c >
// r.c : d > r.d;
}
bool operator>(const F &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d;
// return a != r.a ? a < r.a : b != r.b ? b < r.b : c != r.c ? c <
// r.c : d < r.d;
}
bool operator==(const F &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
int operator[](int i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
T mt(int a, int b, int c) { return T(a, b, c); }
//@マクロ省略系 型,構造
#define int long long
#define ll long long
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using pd = pair<dou, dou>;
#define fi first
#define se second
#define vec vector
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
// マクロ省略系 コンテナ
using vi = vector<int>;
#define _overloadvvi(_1, _2, _3, _4, name, ...) name
#define vvi0() vec<vi>
#define vvi1(a) vec<vi> a
#define vvi2(a, b) vec<vi> a(b)
#define vvi3(a, b, c) vec<vi> a(b, vi(c))
#define vvi4(a, b, c, d) vec<vi> a(b, vi(c, d))
#define vvi(...) \
_overloadvvi(__VA_ARGS__, vvi4, vvi3, vvi2, vvi1, vvi0)(__VA_ARGS__)
using vl = vector<ll>;
#define _overloadvvl(_1, _2, _3, _4, name, ...) name
#define vvl1(a) vec<vl> a
#define vvl2(a, b) vec<vl> a(b)
#define vvl3(a, b, c) vec<vl> a(b, vl(c))
#define vvl4(a, b, c, d) vec<vl> a(b, vl(c, d))
#define vvl(...) _overloadvvl(__VA_ARGS__, vvl4, vvl3, vvl2, vvl1)(__VA_ARGS__)
using vb = vector<bool>;
#define _overloadvvb(_1, _2, _3, _4, name, ...) name
#define vvb1(a) vec<vb> a
#define vvb2(a, b) vec<vb> a(b)
#define vvb3(a, b, c) vec<vb> a(b, vb(c))
#define vvb4(a, b, c, d) vec<vb> a(b, vb(c, d))
#define vvb(...) _overloadvvb(__VA_ARGS__, vvb4, vvb3, vvb2, vvb1)(__VA_ARGS__)
using vs = vector<string>;
#define _overloadvvs(_1, _2, _3, _4, name, ...) name
#define vvs1(a) vec<vs> a
#define vvs2(a, b) vec<vs> a(b)
#define vvs3(a, b, c) vec<vs> a(b, vs(c))
#define vvs4(a, b, c, d) vec<vs> a(b, vs(c, d))
#define vvs(...) _overloadvvs(__VA_ARGS__, vvs4, vvs3, vvs2, vvs1)(__VA_ARGS__)
using vd = vector<double>;
#define _overloadvvd(_1, _2, _3, _4, name, ...) name
#define vvd1(a) vec<vd> a
#define vvd2(a, b) vec<vd> a(b)
#define vvd3(a, b, c) vec<vd> a(b, vd(c))
#define vvd4(a, b, c, d) vec<vd> a(b, vd(c, d))
#define vvd(...) _overloadvvd(__VA_ARGS__, vvd4, vvd3, vvd2, vvd1)(__VA_ARGS__)
using vc = vector<char>;
#define _overloadvvc(_1, _2, _3, _4, name, ...) name
#define vvc1(a) vec<vc> a
#define vvc2(a, b) vec<vc> a(b)
#define vvc3(a, b, c) vec<vc> a(b, vc(c))
#define vvc4(a, b, c, d) vec<vc> a(b, vc(c, d))
#define vvc(...) _overloadvvc(__VA_ARGS__, vvc4, vvc3, vvc2, vvc1)(__VA_ARGS__)
using vp = vector<P>;
#define _overloadvvp(_1, _2, _3, _4, name, ...) name
#define vvp1(a) vec<vp> a
#define vvp2(a, b) vec<vp> a(b)
#define vvp3(a, b, c) vec<vp> a(b, vp(c))
#define vvp4(a, b, c, d) vec<vp> a(b, vp(c, d))
#define vvp(...) _overloadvvp(__VA_ARGS__, vvp4, vvp3, vvp2, vvp1)(__VA_ARGS__)
using vt = vector<T>;
#define _overloadvvt(_1, _2, _3, _4, name, ...) name
#define vvt1(a) vec<vt> a
#define vvt2(a, b) vec<vt> a(b)
#define vvt3(a, b, c) vec<vt> a(b, vt(c))
#define vvt4(a, b, c, d) vec<vt> a(b, vt(c, d))
#define vvt(...) _overloadvvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1)(__VA_ARGS__)
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
#define _vvi vector<vi>
#define _vvl vector<vl>
#define _vvb vector<vb>
#define _vvs vector<vs>
#define _vvd vector<vd>
#define _vvc vector<vc>
#define _vvp vector<vp>
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<int>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<int, int>;
using mapp = map<P, int>;
using mapd = map<dou, int>;
using mapc = map<char, int>;
using maps = map<str, int>;
using seti = set<int>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<int>;
#define bset bitset
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define umapi unordered_map<int, int>
#define umapp unordered_map<P, int>
#define mmap multimap
// マクロ 繰り返し
#define _overloadrep(_1, _2, _3, _4, name, ...) name
#define _rep(i, n) for (int i = 0, _lim = n; i < _lim; i++)
#define repi(i, m, n) for (int i = m, _lim = n; i < _lim; i++)
#define repadd(i, m, n, ad) for (int i = m, _lim = n; i < _lim; i += ad)
#define rep(...) _overloadrep(__VA_ARGS__, repadd, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m, _lim = n; i >= _lim; i--)
#define rerdec(i, m, n, dec) for (int i = m, _lim = n; i >= _lim; i -= dec)
#define rer(...) _overloadrep(__VA_ARGS__, rerdec, reri, _rer, )(__VA_ARGS__)
#define reps2(i, j, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++)
#define reps3(i, j, k, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++)
#define reps4(i, j, k, l, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++) \
for (int l = 0; l < _lim; l++)
#define _overloadreps(_1, _2, _3, _4, _5, name, ...) name
#define reps(...) \
_overloadreps(__VA_ARGS__, reps4, reps3, reps2, _rep, )(__VA_ARGS__)
#define repss(i, j, k, a, b, c) \
for (int i = 0; i < a; i++) \
for (int j = 0; j < b; j++) \
for (int k = 0; k < c; k++)
#define fora(a, b) for (auto &&a : b)
#define forg(gi, ve) \
for (int gi = 0, _lim = ve.size(), f, t, c; \
gi < _lim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); gi++)
#define fort(gi, ve) \
for (int gi = 0, f, t, c; \
gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); \
gi++) \
if (t != p)
// #define fort(gi, ve) for (int gi = 0, f, t, c;gi<ve.size()&& (gi+=
// (ve[gi].t==p))< ve.size() && (f = ve[gi].f,t=ve[gi].t, c = ve[gi].c,true);
// gi++)
#define form(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; it++)
#define forit(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r; it++)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int inf = (int)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((int)(a).size())
// #define rs resize
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
constexpr bool ev(int a) { return !(a & 1); }
constexpr bool od(int a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
// 大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
for (T &x : vec)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se << endl;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < vec[0].size(); j++) {
os << vec[i][j];
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
for (auto &&v : m)
os << v;
return os;
}
template <typename V, typename H> void resize(vector<V> &vec, const H head) {
vec.resize(head);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &vec, const H &head, const T... tail) {
vec.resize(head);
for (auto &v : vec)
resize(v, tail...);
}
template <typename T, typename _Pr>
bool all_of(const vector<T> &vec, _Pr pred) {
return std::all_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool any_of(const vector<T> &vec, _Pr pred) {
return std::any_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool none_of(const vector<T> &vec, _Pr pred) {
return std::none_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
const typename vector<T>::const_iterator find_if(const vector<T> &vec,
_Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred);
}
template <class T> bool contains(const std::string &s, const T &v) {
return s.find(v) != std::string::npos;
}
template <typename T> bool contains(const vector<T> &vec, const T &val) {
return std::find(vec.begin(), vec.end(), val) != vec.end();
}
template <typename T, typename _Pr>
bool contains_if(const vector<T> &vec, _Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred) != vec.end();
}
template <class T, class U> void replace(vector<T> &a, T key, U v) {
replace(a.begin(), a.end(), key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(all(a), key), a.end());
}
void replace(str &a, str key, str v) {
if (v == "")
a.erase(remove(all(a), key[0]), a.end());
else
replace(all(a), key[0], v[0]);
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(all(c));
sort(all(d));
return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(all(a));
}
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
inline void sort(string &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
}
template <class T, class F> inline void sort(vector<T> &a, F f) {
sort(a.begin(), a.end(), [&](T a, T b) { return f(a) < f(b); });
}
enum ___pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
inline void sort(vector<P> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
break;
case fisd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
break;
case fdsi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
break;
case fdsd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
break;
case sifi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
break;
case sifd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
break;
case sdfi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
break;
case sdfd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
break;
}
};
inline void sort(vector<T> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
break;
case fisd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
break;
case fdsi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
break;
case fdsd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
break;
case sifi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
break;
case sifd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
break;
case sdfi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
break;
case sdfd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
break;
}
};
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
template <class U, class F> inline void rsort(vector<U> &a, F f) {
sort(a.begin(), a.end(), [&](U l, U r) { return f(l) > f(r); });
};
template <class U> inline void sortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
;
}
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class U, class F> inline void sortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void sortp(vector<U> &a, vector<U> &b, char type) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, type);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void rsortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void rsortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
// indexをつけてsortする (second)
template <class T> auto sorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
sort(ret);
return ret;
};
template <class T> auto rsorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
rsort(ret);
return ret;
};
template <class T> inline void sort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
sort(a[i]);
}
template <class T> inline void rsort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
rsort(a[i]);
}
template <typename A, size_t N, typename T>
inline void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
inline void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
inline void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
inline void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
inline void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
inline void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
template <typename V, typename T> void fill(V &xx, const T vall) { xx = vall; }
template <typename V, typename T> void fill(vector<V> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
//@汎用便利関数 入力
inline int in() {
int ret;
// scanf("%lld", &ret);
cin >> ret;
return ret;
}
inline string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> inline void in(T &head) { cin >> head; }
template <class T, class... U> inline void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
#define _overloaddin(_1, _2, _3, _4, name, ...) name
#define din1(a) \
int a; \
cin >> a
#define din2(a, b) \
int a, b; \
cin >> a >> b
#define din3(a, b, c) \
int a, b, c; \
cin >> a >> b >> c
#define din4(a, b, c, d) \
int a, b, c, d; \
cin >> a >> b >> c >> d
#define din(...) _overloaddin(__VA_ARGS__, din4, din3, din2, din1)(__VA_ARGS__)
#define _overloaddind(_1, _2, _3, _4, name, ...) name
#define din1d(a) \
din1(a); \
a--
#define din2d(a, b) \
din2(a, b); \
a--, b--
#define din3d(a, b, c) \
din3(a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din4(a, b, c, d); \
a--, b--, c--, d--
#define dind(...) \
_overloaddind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
#define _overloadout(_1, _2, _3, _4, name, ...) name
#define out1(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define out3(a, b, c) cout << a << " " << b << " " << c << endl
#define out4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl
#define out(...) \
_overloadout((__VA_ARGS__), out4, out3, out2, out1)((__VA_ARGS__))
template <class T> void outl(vector<T> &a) { fora(v, a) cout << v << endl; }
#define na(a, n) \
a.resize(n); \
rep(_i, n) cin >> a[_i];
#define dna(a, n) \
vi a(n); \
rep(_i, n) cin >> a[_i];
#define nao(a, n) \
a.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1];
#define nad(a, n) \
a.resize(n); \
rep(_i, n) { \
cin >> a[_i]; \
a[_i]--; \
}
#define na2(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define dna2(a, b, n) \
vi a(n), b(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define nao2(a, b, n) \
a.resize(n + 1), b.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1] >> b[_i + 1];
#define na2d(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i]; \
a[_i]--, b[_i]--; \
}
#define na3(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define dna3(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define na3d(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define dna3d(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define nt(a, h, w) \
resize(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi];
#define ntd(a, h, w) \
rs(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi], a[_hi][_wi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(_hi, 1, h + 1) rep(_wi, 1, w + 1) cin >> a[_hi][_wi];
// デバッグ
#define sp << " " <<
#define debugName(VariableName) #VariableName
#define _deb1(x) debugName(x) << " = " << x
#define _deb2(x, ...) _deb1(x) << ", " << _deb1(__VA_ARGS__)
#define _deb3(x, ...) _deb1(x) << ", " << _deb2(__VA_ARGS__)
#define _deb4(x, ...) _deb1(x) << ", " << _deb3(__VA_ARGS__)
#define _deb5(x, ...) _deb1(x) << ", " << _deb4(__VA_ARGS__)
#define _deb6(x, ...) _deb1(x) << ", " << _deb5(__VA_ARGS__)
#define _deb7(x, ...) _deb1(x) << ", " << _deb6(__VA_ARGS__)
#define _deb8(x, ...) _deb1(x) << ", " << _deb7(__VA_ARGS__)
#define _deb9(x, ...) _deb1(x) << ", " << _deb8(__VA_ARGS__)
#define _deb10(x, ...) _deb1(x) << ", " << _deb9(__VA_ARGS__)
#define _overloadebug(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, name, ...) name
#ifdef _DEBUG
#define deb(...) \
cerr << _overloadebug(__VA_ARGS__, _deb10, _deb9, _deb8, _deb7, _deb6, \
_deb5, _deb4, _deb3, _deb2, _deb1)(__VA_ARGS__) \
<< endl
#else
#define deb(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
// よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
int find(int x) { return root(x); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
// 順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.fi;
res[i].push_back(r);
for (auto &&v : p.se) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
using bint = __int128;
using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 toi128(string &s) {
__int128 ret = 0;
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
template <typename T> T minv(T a, T m);
template <typename T> T minv(T a);
template <typename T> class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U> Modular(const U &x) { value = normalize(x); }
template <typename U> static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0)
v += mod();
return v;
}
const Type &operator()() const { return value; }
template <typename U> explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
if ((value += other.value) >= mod())
value -= mod();
return *this;
}
Modular &operator-=(const Modular &other) {
if ((value -= other.value) < 0)
value += mod();
return *this;
}
template <typename U> Modular &operator+=(const U &other) {
return *this += Modular(other);
}
template <typename U> Modular &operator-=(const U &other) {
return *this -= Modular(other);
}
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(signed) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(signed) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, signed>::value,
Modular>::type &
operator*=(const Modular &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type &
operator*=(const Modular &rhs) {
int64_t q =
static_cast<int64_t>(static_cast<double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) {
return *this *= Modular(minv(other.value));
}
template <typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
operator int() { return normalize(value); }
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
constexpr signed MOD = 1e9 + 7; // MOD
using mint = Modular<std::integral_constant<decay<decltype(MOD)>::type, MOD>>;
constexpr int mint_len = 1400001;
vi fac, finv, inv;
vi p2;
void setmod() {
// p2.resize(mint_len);p[0] = 1; for (int i = 1; i < mint_len; ++i) p2[i] =
// p2[i - 1] * 2 % MOD;
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
#define smod setmod
inline mint com(int n, int r) {
if (r < 0 || r > n)
return 0;
return mint(finv[r] * fac[n] % MOD * finv[n - r]);
}
inline mint pom(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - 1]);
}
inline mint npr(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
inline int nprin(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return fac[n] * finv[n - r] % MOD;
}
inline int icom(int n, int r) {
const int NUM_ = 1400001;
static ll fac[NUM_ + 1], finv[NUM_ + 1], inv[NUM_ + 1];
if (fac[0] == 0) {
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
if (r < 0 || r > n)
return 0;
return ((finv[r] * fac[n] % MOD) * finv[n - r]) % MOD;
}
#define ncr com
#define ncri icom
inline mint nhr(int n, int r) { return com(n + r - 1, r); }
inline mint hom(int n, int r) { return com(n + r - 1, r); }
inline int nhri(int n, int r) { return icom(n + r - 1, r); }
template <typename T> inline T minv(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T> inline T minv(T a) {
if (a < mint_len)
return inv[a];
T u = 0, v = 1;
T m = MOD;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T, typename U>
inline Modular<T> mpow(const Modular<T> &a, const U &b) {
assert(b >= 0);
int x = a(), res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline mint mpow(const T a, const U b, const V m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T, typename U> inline mint mpow(const T a, const U b) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline int mpowi(const T &a, const U &b, const V &m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T> inline string to_string(const Modular<T> &number) {
return to_string(number());
}
template <typename T>
std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
return stream << number();
}
template <typename T>
std::istream &operator>>(std::istream &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
using PM = pair<mint, mint>;
using vm = vector<mint>;
using mapm = map<int, mint>;
using umapm = umap<int, mint>;
#define _overloadvvm(_1, _2, _3, _4, name, ...) name
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
#define vvm1(a) vec<vm> a
#define vvm2(a, b) vec<vm> a(b)
#define vvm3(a, b, c) vec<vm> a(b, vm(c))
#define vvm4(a, b, c, d) vec<vm> a(b, vm(c, d))
#define vvm(...) _overloadvvm(__VA_ARGS__, vvm4, vvm3, vvm2, vvm1)(__VA_ARGS__)
// エラー
void ole() {
#ifdef _DEBUG
debugline("ole");
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re() { assert(0 == 1); }
void tle() {
while (inf)
cout << inf << endl;
}
// 便利関数
// テスト用
char ranc() { return (char)('a' + rand() % 26); }
int rand(int min, int max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
//+
if (rand() % 2) {
return rand(0, max);
//-
} else {
return -rand(0, -min);
}
}
}
vi ranv(int n, int min, int max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
// 単調増加
vi ranvi(int n, int min, int max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
void ranvlr(int n, int min, int max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
// 便利 汎用
vp run_length(vi &a) {
vp ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
vector<pair<char, int>> run_length(string &a) {
vector<pair<char, int>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
template <class F> inline int mgr(int ok, int ng, F f) {
#define _mgrbody \
int mid = (ok + ng) / 2; \
if (f(mid)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody
}
else
while (ok - ng > 1) {
_mgrbody
}
return ok;
}
template <class F> inline int mgr(int ok, int ng, int second, F f) {
#define _mgrbody2 \
int mid = (ok + ng) / 2; \
if (f(mid, second)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody2
}
else
while (ok - ng > 1) {
_mgrbody2
}
return ok;
}
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return b;
} else if (a[i] > b[i])
return a;
}
}
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) < sz(b)) {
return a;
} else if (sz(a) > sz(b)) {
return b;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i])
return b;
}
}
return a;
}
template <typename V, typename T> int find(vector<V> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename V, typename T> P find(vector<vector<V>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
template <typename V, typename U>
T find(vector<vector<vector<V>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
return mt(-1, -1, -1);
}
template <typename V, typename T> int count2(V &a, const T k) { return a == k; }
template <typename V, typename T> int count2(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count(v, k);
return ret;
}
template <typename V, typename T> int count(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
int count(str a, str k) {
int ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ret++;
return ret;
}
template <typename V> int count_odd(V &a) { return a % 2; }
template <typename V> int count_odd(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_odd(v);
return ret;
}
template <typename V> int count_even(V &a) { return a % 2 == 0; }
template <typename V> int count_even(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_even(v);
return ret;
}
// algorythm
void iota(vector<int> &ve, int s, int n) {
ve.resize(n);
iota(all(ve), s);
}
vi iota(int s, int len) {
vi ve(len);
iota(all(ve), s);
return ve;
}
inline ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class T> vector<T> revv(vector<T> &a) {
vector<T> b = a;
reverse(all(b));
return b;
}
void inline rev(string &a) { reverse(all(a)); }
constexpr int p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
int get(int a, int keta) { return (a / (int)pow(10, keta)) % 10; }
int keta(ll v) {
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1])
return 1;
else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else if (v < p10[15])
return 15;
else
return 16;
} else {
if (v < p10[17])
return 17;
else
return 18;
}
}
}
}
int dsum(int v) {
int ret = 0;
for (; v; v /= 10)
ret += v % 10;
return ret;
}
inline int sumd(int v) { return dsum(v); }
struct sint {
int v;
sint(int v) : v(v) {}
operator int() { return v; }
int operator[](int i) { return (v / p10[i]) % 10; }
int top(int i) {
int len = keta(v);
return operator[](len - 1 - i);
}
// 先頭からi番目にセット
int top(int i, int k) {
int len = keta(v);
return set(len - 1 - i, k);
}
int set(int i, int k) {
if (i < 0)
return top(abs(i) - 1, k);
return v += p10[i] * (k - (v / p10[i]) % 10);
}
int inc(int i, int k = 1) { return v += p10[i] * k; }
int inct(int i, int k = 1) { return v += p10[keta(v) - i - 1] * k; }
int dec(int i, int k = 1) { return v -= p10[i] * k; }
int dect(int i, int k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o) \
template <class T> inline t operator o(T r) { return v o r; }
op(int, +=);
op(int, -=);
op(int, *=);
op(int, /=);
op(int, %=);
op(int, +);
op(int, -);
op(int, *);
op(int, /);
op(int, %);
op(bool, ==);
op(bool, !=);
op(bool, <);
op(bool, <=);
op(bool, >);
op(bool, >=);
#undef op
template <class T> inline int operator<<=(T r) { return v *= p10[r]; }
template <class T> inline int operator<<(T r) { return v * p10[r]; }
template <class T> inline int operator>>=(T r) { return v /= p10[r]; }
template <class T> inline int operator>>(T r) { return v / p10[r]; }
};
int mask10(int v) { return p10[v] - 1; }
// 変換系
template <class T, class U> inline vector<T> keys(vector<pair<T, U>> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> vector<U> inline values(vector<pair<T, U>> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chma(const U &b) { return chma(ma, b); }
template <class T, class U> inline bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chmi(const U &b) { return chmi(mi, b); }
template <class T> inline T min(T a, signed b) { return a < b ? a : b; }
template <class T> inline T max(T a, signed b) { return a < b ? b : a; }
template <class T> inline T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> inline T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> inline T min(vector<T> a) { return *min_element(all(a)); }
template <class T> inline T mini(vector<T> a) {
return min_element(all(a)) - a.begin();
}
template <class T> inline T min(vector<T> a, int n) {
return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T min(vector<T> a, int s, int n) {
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a) { return *max_element(all(a)); }
template <class T> inline T maxi(vector<T> a) {
return max_element(all(a)) - a.begin();
}
template <class T> inline T max(vector<T> a, int n) {
return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a, int s, int n) {
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> inline A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> inline A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <class T> inline T sum(T &v) { return v; }
template <class T> inline auto sum(vector<T> &v) {
auto ret = sum(v[0]);
rep(i, 1, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T>
inline auto sum(priority_queue<T, vector<T>, greater<T>> &r) {
auto q = r;
T ret = 0;
while (sz(q)) {
ret += q.top();
q.pop();
}
return ret;
}
template <class T, class U, class... V>
inline auto sum(vector<T> &v, U head, V... tail) {
auto ret = sum(v[0], tail...);
rep(i, 1, min(sz(v), head)) ret += sum(v[i], tail...);
return ret;
}
inline P sump(vp &v, int len = -1) {
if (len == -1)
len = v.size();
P res = {0, 0};
chmi(len, v.size());
rep(i, len) {
res.fi += v[i].fi;
res.se += v[i].se;
}
return res;
}
/// 要素が0の時、返り値は0か1か
template <class T> inline T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
chmi(len, v.size());
rep(i, len) res *= v[i];
return res;
}
inline void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> inline void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> inline T *negarr(int size) {
T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
return body + size;
}
template <class T> inline T *negarr2(int h, int w) {
double **dummy1 = new double *[2 * h + 1];
double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
dummy1[0] = dummy2 + w;
for (int i = 1; i <= 2 * h + 1; i++) {
dummy1[i] = dummy1[i - 1] + 2 * w + 1;
}
double **a = dummy1 + h;
return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> inline vector<T> imo(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// kと同じものの数
template <class T, class U> inline vi imo(vector<T> &a, U k) {
vector<T> ret = a;
rep(i, sz(ret) - 1) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T> inline vector<T> imox(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> inline vector<T> imi(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> struct ruiC {
const vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
inline T operator()(int l, int r) {
assert(l <= r);
return rui[r] - rui[l];
}
inline T operator[](int i) { return rui[i]; }
};
template <class T> struct rruic {
const T *rrui;
rruic(T *ru) : rrui(ru) {}
// n-1から-1へ
inline T operator()(int l, int r) {
assert(l >= r);
return rrui[r] - rrui[l];
}
inline T operator[](int i) { return rrui[i]; }
};
template <class T> inline vector<T> ruiv(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> inline ruiC<T> ruic(vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
// kと同じものの数
template <class T, class U> inline vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> inline ruiC<int> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<int>(ret);
}
// xor
template <class T> inline vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> inline vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> inline vector<T> ruimi(vector<T> &a) {
int n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> rruic<T> rrui(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
rer(i, len - 1) res[i - 1] = res[i] + a[i];
return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void inc(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void plus(T &a, U v = 1) { a += v; }
template <class T, class U> void plus(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void plus(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void dec(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class T, class U> void minu(T &a, U v = 1) { a -= v; }
template <class T, class U> void minu(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void minu(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class U> void minu(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
void minu(string &a) {
for (auto &u : a)
dec(u, 1);
}
inline bool inside(int h, int w, int H, int W) {
return h >= 0 && w >= 0 && h < H && w < W;
}
inline bool inside(int l, int v, int r) { return l <= v && v < r; }
#define ins inside
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
vector<T> ret = a;
fora(v, ret) v = u(v);
return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
ll goldd(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return resIndex;
}
ll goldt(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return resIndex;
}
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmi(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chma(res, *max_element(all(a[i])));
return res;
}
constexpr bool bget(ll m, int keta) {
assert(keta < 64);
return (m >> keta) & 1;
}
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
ll bit(int n) { return (1LL << (n)); }
ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int mask(int n) { return (1ll << n) - 1; }
// int bcou(ll m) { return __builtin_popcount(m & 0xFFFFFFFF) +
// __builtin_popcount(m >> 32); }
#define bcou __builtin_popcountll
// 最下位ビット
int lbit(int n) { return n & -n; }
// 最上位ビット
int hbit(int n) {
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
int hbitk(int n) {
int k = 0;
rer(i, 5) {
int a = k + (1ll << i);
int b = 1ll << a;
if (b <= n)
k += 1ll << i;
}
return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; // 最下位の1
ll y = mask + x; // 連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
// 大文字小文字を区別する
int altoiaZ(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoalaZ(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
// aもAも0を返す 基本小文字
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
char itoal(int i) { return 'a' + i; }
int ctoi(char c) { return c - '0'; }
char itoc(int i) { return i + '0'; }
int vtoi(vi &v) {
int res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(int i) {
vi res;
while (i) {
res.pb(i % 10);
i /= 10;
}
rev(res);
return res;
}
vi stov(string &a) {
int n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
vector<vector<int>> ctoi(vector<vector<char>> s, char c) {
int n = sz(s), m = sz(s[0]);
vector<vector<int>> res(n, vector<int>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
//[i] := i番として圧縮されたものを返す
vi compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r) {
vi b;
int len = a.size();
fora(v, a) b.pb(v);
fora(v, r) b.pb(v);
sort(b);
unique(b);
for (int i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (int i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r, vi &s) {
vi b;
int len = a.size();
fora(v, a) b.pb(v);
fora(v, r) b.pb(v);
fora(v, s) b.pb(v);
sort(b);
unique(b);
for (int i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (int i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
for (int i = 0; i < sz(s); ++i)
r[i] = lower_bound(all(b), s[i]) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(_vvi &a) {
vi b;
fora(vv, a) fora(v, vv) b.pb(v);
sort(b);
unique(b);
fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vector<vi>> &a) {
vi b;
fora(vvv, a) fora(vv, vvv) fora(v, vv) b.pb(v);
sort(b);
unique(b);
fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
// 便利 数学 math
int mod(int a, int m) { return (a % m + m) % m; }
int pow(int a) { return a * a; };
ll fact(int v) { return v <= 1 ? 1 : v * fact(v - 1); }
ll comi(int n, int r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
double comd(int n, int r) {
assert(n < 2020);
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
int gcd(int a, int b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
int gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
int res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
namespace pnumber_tools {
#define Eratosthenes30_2 \
class Eratosthenes { \
public: \
virtual void initialize() {} \
virtual void generate(const int64_t x) = 0; \
virtual void generate(const int64_t from, const int64_t to) = 0; \
virtual int64_t count() = 0; \
virtual bool prime(int x) = 0; \
virtual int32_t version() = 0; \
inline uint64_t PopCnt(uint64_t); \
inline int BitToIndex(uint8_t); \
}; \
uint64_t Eratosthenes::PopCnt(uint64_t bits) { \
bits = (bits & 0x5555555555555555ULL) + \
((bits >> 1) & 0x5555555555555555ULL); \
bits = (bits & 0x3333333333333333ULL) + \
((bits >> 2) & 0x3333333333333333ULL); \
bits = (bits & 0x0f0f0f0f0f0f0f0fULL) + \
((bits >> 4) & 0x0f0f0f0f0f0f0f0fULL); \
return (bits * 0x0101010101010101ULL) >> (64 - 8); \
} \
int Eratosthenes::BitToIndex(uint8_t b) { \
switch (b) { \
case 1 << 0: \
return 0; \
case 1 << 1: \
return 1; \
case 1 << 2: \
return 2; \
case 1 << 3: \
return 3; \
case 1 << 4: \
return 4; \
case 1 << 5: \
return 5; \
case 1 << 6: \
return 6; \
case 1 << 7: \
return 7; \
} \
return -1; \
} \
namespace { \
const uint64_t kSegmentSize = 1000000; \
const int32_t kMod30[] = {1, 7, 11, 13, 17, 19, 23, 29}; \
const int C1[] = {6, 4, 2, 4, 2, 4, 6, 2}; \
const int C0[][8] = { \
{0, 0, 0, 0, 0, 0, 0, 1}, {1, 1, 1, 0, 1, 1, 1, 1}, \
{2, 2, 0, 2, 0, 2, 2, 1}, {3, 1, 1, 2, 1, 1, 3, 1}, \
{3, 3, 1, 2, 1, 3, 3, 1}, {4, 2, 2, 2, 2, 2, 4, 1}, \
{5, 3, 1, 4, 1, 3, 5, 1}, {6, 4, 2, 4, 2, 4, 6, 1}, \
}; \
const uint8_t kMask[][8] = { \
{0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f}, \
{0xfd, 0xdf, 0xef, 0xfe, 0x7f, 0xf7, 0xfb, 0xbf}, \
{0xfb, 0xef, 0xfe, 0xbf, 0xfd, 0x7f, 0xf7, 0xdf}, \
{0xf7, 0xfe, 0xbf, 0xdf, 0xfb, 0xfd, 0x7f, 0xef}, \
{0xef, 0x7f, 0xfd, 0xfb, 0xdf, 0xbf, 0xfe, 0xf7}, \
{0xdf, 0xf7, 0x7f, 0xfd, 0xbf, 0xfe, 0xef, 0xfb}, \
{0xbf, 0xfb, 0xf7, 0x7f, 0xfe, 0xef, 0xdf, 0xfd}, \
{0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe}, \
}; \
const int64_t kSievedPrimes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23}; \
const int64_t kInitialSize = 7 * 11 * 13 * 17 * 19 * 23; \
class Eratosthenes2 final : public Eratosthenes { \
public: \
void generate(const int64_t x) override; \
void generate(const int64_t, const int64_t) override { assert(false); } \
bool prime(int x) override; \
int64_t count() override; \
int32_t version() override { return 2; } \
std::vector<uint8_t> flags_; \
}; \
void Eratosthenes2::generate(const int64_t x) { \
flags_.clear(); \
if (x > 10000000000) \
return; \
int64_t size = x / 30 + (x % 30 != 0); \
flags_.resize(size, 0xff); \
if (int r = x % 30) { \
if (r <= 1) \
flags_[size - 1] = 0x0; \
else if (r <= 7) \
flags_[size - 1] = 0x1; \
else if (r <= 11) \
flags_[size - 1] = 0x3; \
else if (r <= 13) \
flags_[size - 1] = 0x7; \
else if (r <= 17) \
flags_[size - 1] = 0xf; \
else if (r <= 19) \
flags_[size - 1] = 0x1f; \
else if (r <= 23) \
flags_[size - 1] = 0x3f; \
else if (r <= 29) \
flags_[size - 1] = 0x7f; \
} \
flags_[0] = 0xfe; \
const uint64_t sqrt_x = std::ceil(std::sqrt(x) + 0.1); \
const uint64_t sqrt_xi = sqrt_x / 30 + 1; \
for (uint64_t i = 0; i < sqrt_xi; ++i) { \
for (uint8_t flags = flags_[i]; flags; flags &= flags - 1) { \
uint8_t lsb = flags & (-flags); \
int ibit = BitToIndex(lsb); \
const int32_t m = kMod30[ibit]; \
int32_t pm = 30 * i + 2 * m; \
for (uint64_t j = i * pm + (m * m) / 30, k = ibit; j < flags_.size(); \
j += i * C1[k] + C0[ibit][k], k = (k + 1) & 7) { \
flags_[j] &= kMask[ibit][k]; \
} \
} \
} \
} \
int64_t Eratosthenes2::count() { \
if (flags_.empty()) \
return -1; \
int64_t ret = 3; \
for (uint8_t f : flags_) { \
ret += PopCnt(f); \
} \
return ret; \
} \
inline bool Eratosthenes2::prime(int x) { \
static unordered_map<int, int> imap = { \
{1, 0}, {7, 1}, {11, 2}, {13, 3}, {17, 4}, {19, 5}, {23, 6}, {29, 7}}; \
if (x == 2 || x == 3 || x == 5) \
return true; \
else if (!(x & 1) || x % 3 == 0 || x % 5 == 0) \
return false; \
return (flags_[x / 30] >> imap[x % 30]) & 1; \
} \
}
Eratosthenes30_2 Eratosthenes2 era;
int prime_len = 3e6;
vector<int> primes;
void setprime(int size = 3e6) {
prime_len = size;
era.generate(size);
primes = {2, 3, 5};
int nums[129] = {};
nums[1] = 1;
nums[2] = 7;
nums[4] = 11;
nums[8] = 13;
nums[16] = 17;
nums[32] = 19;
nums[64] = 23;
nums[128] = 29;
// p = 30i + j
int j = 0;
int sflim = era.flags_.size();
int i30 = 0;
for (int i = 0; i < sflim; i++, i30 += 30) {
uint8_t m = era.flags_[i];
while (m) {
j = m & -m;
primes.push_back(i30 + nums[j]);
m ^= j;
}
}
}
using u32 = unsigned int; // longlongになっていると思うが放置していいと思う
using u64 = unsigned long long;
using u128 = __uint128_t;
// O(k log(n)^3)
// 32bit -> 270回程度
// 64bit -> 1260回程度
// 64bit以下で精度100%
template <class BinOp>
bool miller_rabin(const uint64_t &n, const uint64_t *witness, BinOp modmul) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
const int64_t m = n - 1, d = m / (m & -m);
auto modpow = [&](int64_t a, int64_t b) {
int64_t res = 1;
for (; b; b /= 2) {
if (b & 1)
res = modmul(res, a);
a = modmul(a, a);
}
return res;
};
auto suspect = [&](uint64_t a, uint64_t t) {
a = modpow(a, t);
while (t != n - 1 && a != 1 && a != n - 1) {
a = modmul(a, a);
t = modmul(t, 2);
}
return a == n - 1 || t % 2 == 1;
};
for (const uint64_t *w = witness; *w; w++) {
if (*w % n != 0 && !suspect(*w, d))
return false;
}
return true;
}
// miller_rabin & エラトステネス
bool prime(const int &n) {
assert(n < 9223372036854775808ULL);
if (!sz(primes))
setprime();
// エラトステネスの篩 偶数省略ver
//[i] = i*2+1
if (n < prime_len)
return era.prime(n);
if (n < 4294967296) {
rep(i, 30) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 7, 61, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t { return a * b % n; };
return miller_rabin(n, witness, modmul);
} else {
rep(i, 50) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 325, 9375, 28178,
450775, 9780504, 1795265022, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t {
return (uint64_t)((__uint128_t)a * b % n);
};
return miller_rabin(n, witness, modmul);
}
}
vi divisors(int v) {
vi res;
double lim = std::sqrt(v);
for (int i = 1; i <= lim; ++i) {
if (v % i == 0) {
res.pb(i);
// if (i != v / i)res.pb(v / i);
}
}
rer(i, sz(res) - 1) {
if (res[i] != v / res[i])
res.pb(v / res[i]);
}
return res;
}
vp factorization(int v) {
assert(v);
int tv = v;
vp res;
if (!sz(primes))
setprime();
for (auto &&p : primes) {
if (v % p == 0)
res.eb(p, 0);
while (v % p == 0) {
v /= p;
res.back().second++;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.eb(v, 1);
return res;
}
// 注意 gcdを取る間隔 i%10 が場合によってはtleを引き起こす
// うまくいかなかったら%1で動かすように変更した
vp rho(int v) {
assert(v);
if (v == 1)
return vp();
vi ret;
if (!sz(primes))
setprime();
int lim = 300; // 64bit
if (v < 4294967296)
lim = 80; // 32bit
else if (v < 281474976710656LL)
lim = 120; // 48bit
for (int i = 0; i < lim; i += 5) {
// v<=1の判定回数を減らせる分高速化できる事を期待している
while (v % primes[i] == 0)
ret.pb(primes[i]), v /= primes[i];
while (v % primes[i + 1] == 0)
ret.pb(primes[i + 1]), v /= primes[i + 1];
while (v % primes[i + 2] == 0)
ret.pb(primes[i + 2]), v /= primes[i + 2];
while (v % primes[i + 3] == 0)
ret.pb(primes[i + 3]), v /= primes[i + 3];
while (v % primes[i + 4] == 0)
ret.pb(primes[i + 4]), v /= primes[i + 4];
if (v <= 1) {
sort(ret); // 試し割りだけで終わった時
return run_length(ret);
}
}
int lower_prime_bound = primes[lim - 1] * primes[lim - 1];
// 試し割りするか
mt19937 mr;
mr.seed(clock());
int c;
auto fac = [&](int v, const int loop = 10) {
// if (v == 4)return 2ll; //試し割りで消えた
c = mr() % v;
int x = mr() % v;
int y = x;
int d = 1;
int lim = std::sqrt(v) + 2;
// brentによる改良 差分を一操作で求められる
for (int i = 1, mul = 1, next_2pow = 2; d == 1 && i <= lim; i++) {
if (i == next_2pow) {
y = x;
next_2pow <<= 1;
}
x = ((u128)x * x + c) % v;
mul = ((u128)mul * abs(x - y)) %
v; // ユークリッドの互除法と同じ原理で因数は保たれる
if (i % loop == 0) { // 10とかなんとか iによっては死ぬ
d = gcd(mul, v);
mul = 1;
}
}
if (d == v)
return -1ll;
return d;
};
queue<int> q;
q.push(v);
while (!q.empty()) {
int v = q.front();
q.pop();
if (prime(v)) {
ret.pb(v);
continue;
}
int d = -1;
// 基本loop回数10でやり、駄目なら1で
for (int i = 0; d == -1 && i < 5; i++)
d = fac(v, 10);
if (d == -1)
while (d == -1)
d = fac(v, 1);
int d2 = v / d;
rep(_, 2) {
if (d <= lower_prime_bound)
ret.pb(d);
else
q.push(d);
d = d2;
}
}
sort(ret);
return run_length(ret);
}
} // namespace pnumber_tools
using namespace pnumber_tools;
// 幾何 Pをcomplexとして扱う
template <class T, class U> bool eq(T a, U b) { return fabs(a - b) < eps; }
dou atan2(pd a) { return atan2(a.se, a.fi); }
dou angle(pd f, pd t) { return atan2(t.se - f.se, t.fi - f.fi); }
dou distance(pd a, pd b) { return hypot(a.fi - b.fi, a.se - b.se); }
// bを中心とするabcのtheta aからcにかけて時計回り
dou angle(pd a, pd b, pd c) {
dou ax = a.fi - b.fi;
dou ay = a.se - b.se;
dou cx = c.fi - b.fi;
dou cy = c.se - b.se;
double ret = atan2(cy, cx) - atan2(ay, ax);
if (ret < 0)
ret += 2 * PI;
return ret;
}
dou dot(pd a, pd b) { return a.fi * b.fi + a.se + b.se; }
dou cro(pd a, pd b) { return a.fi * b.se - a.se + b.fi; }
template <class T> struct edge {
int f, t;
T c;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: f(f), t(t), c(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return c < b.c; }
bool operator>(const edge &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge<T> &e) {
os << e.f << " " << e.t << " " << e.c;
return os;
}
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) { g.resize(n), _used.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
vector<edge<T>> &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int id, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, id, ty);
edges.emplace_back(f, t, c, id, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("undigraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid, eid += 2;
g[f].emplace_back(f, t, c, id, ty);
g[t].emplace_back(t, f, c, id + 1, ty);
edges.emplace_back(f, t, c, id, ty);
edges.emplace_back(t, f, c, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.f, t = e.t, ty = e.type;
T c = e.c;
add(f, t, c, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <typename T> struct radixheap {
vector<pair<u64, T>> v[65];
u64 size, last;
radixheap() : size(0), last(0) {}
bool empty() const { return size == 0; }
inline int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
void push(u64 key, const T &value) {
++size;
v[getbit(key ^ last)].emplace_back(key, value);
}
pair<u64, T> pop() {
if (v[0].empty()) {
int idx = 1;
while (v[idx].empty())
++idx;
last = min_element(begin(v[idx]), end(v[idx]))->first;
for (auto &p : v[idx])
v[getbit(p.first ^ last)].emplace_back(p);
v[idx].clear();
}
--size;
auto ret = v[0].back();
v[0].pop_back();
return ret;
}
};
vi dijkstra2(const graph<int> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
int initValue = MAX(int);
vi dis(g.n, initValue);
radixheap<int> q;
dis[s] = 0;
q.push(0, s);
while (!q.empty()) {
int nowc, i;
tie(nowc, i) = q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
int c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.push(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<T> dijkstra(const graph<T> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.emplace(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<vector<T>> warshall(const graph<T> &g, int cant_arrive = -1) {
int n = g.n;
vector<vector<T>> dis(n, vector<T>(n, linf));
rep(i, n) fora(e, g.g[i]) chmi(dis[e.f][e.t], e.c);
rep(i, n) dis[i][i] = 0;
rep(k, n) rep(i, n) rep(j, n) chmi(dis[i][j], dis[i][k] + dis[k][j]);
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = -1;
return dis;
}
template <class T = int> class tree : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
vi disv;
private:
bool never = 1;
int root = -1;
vi dep; // 到着した順の深さ
vi vis; // 到着した順
vi first; // 初めてiに到着した時
vector<int> bestt; // タイミングを持つ
int sn = 0; // seg木の底辺の長さ euler tourの長さ
void built() {
never = 0;
n = g.size();
// euler tour
disv.resize(n);
first.resize(n);
dep.resize(n * 2);
vis.resize(n * 2);
function<void(int, int, int, int &)> dfs = [&](int i, int p, int d,
int &k) {
first[i] = k;
vis[k] = i;
dep[k++] = d;
forg(gi, g[i]) {
if (t == p)
continue;
disv[t] = disv[i] + c;
dfs(t, i, d + 1, k);
vis[k] = i;
dep[k++] = d;
}
};
int k = 0;
dfs(root, -1, 0, k);
// rmq
sn = 1;
while (sn < n * 2)
sn <<= 1;
bestt.resize((sn << 1) - 1);
rep(i, k) bestt[i + sn - 1] = i; // 時間を持つ
rer(i, sn - 2) {
int lt = (i << 1) + 1, rt = (i << 1) + 2;
if (dep[bestt[lt]] < dep[bestt[rt]]) {
bestt[i] = bestt[lt];
} else {
bestt[i] = bestt[rt];
}
}
}
// 最小の深さを持つタイミングが知りたい
inline int lca_rmq(int l, int r) {
int midv = inf;
int midi = -1;
l += sn - 1;
r += sn - 1;
while (l < r) {
// 右なら、次に右上へ移動してしまうので
if (!(l & 1)) {
if (chmi(midv, dep[bestt[l]])) {
midi = bestt[l];
}
}
// 右なら、左を取らないと機会を逃す
if (!(r & 1)) {
if (chmi(midv, dep[bestt[r - 1]])) {
midi = bestt[r - 1];
}
}
l >>= 1;
r = (r - 1) >> 1;
}
return vis[midi];
}
public:
tree(int n, int root = 0) : undigraph<T>(n), root(root) {}
bool leaf(int v) { return sz(g[v]) == 1 && v != root; }
int lca(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
return lca_rmq(first[u], first[v] + 1);
}
int dis(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
int p = lca_rmq(first[u], first[v] + 1);
return disv[u] + disv[v] - disv[p] * 2;
}
};
// 辺によりメモリを大量消費
// よってedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
// 軽量化のため、辺を持たないbig gridクラスがあってもいいかもしれない
//
template <class T = int> class grid_k6 : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("grid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
g[t].emplace_back(t, f, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
grid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
using digraph<T>::g;
using digraph<T>::n;
using digraph<T>::edges;
using digraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digrid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
digrid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
template <class T> bool nibu(const graph<T> &g) {
int size = 0;
rep(i, g.n) size += sz(g.g[i]);
if (size == 0)
return true;
UnionFind uf(g.n * 2);
rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
uf.unite(e.f + g.n, e.t);
rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
return 1;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
vp cg;
if (!nibu(g)) {
debugline("nibu");
ole();
}
int _n = g.size();
vb _was(_n);
queue<P> q;
rep(i, _n) {
if (_was[i])
continue;
q.push(mp(i, 1));
_was[i] = 1;
int red = 0;
int coun = 0;
while (q.size()) {
int now = q.front().fi;
int col = q.front().se;
red += col;
coun++;
q.pop();
forg(gi, g[now]) {
if (_was[t])
continue;
q.push(mp(t, col ^ 1));
_was[t] = 1;
}
}
cg.push_back(mp(red, coun - red));
}
return cg;
}
template <class T> ostream &operator<<(ostream &os, graph<T> &g) {
rep(i, sz(g)) {
forg(gi, g[i]) { os << f << " " << t << " " << c << endl; }
}
return os;
}
// 機能拡張
vp vtop(vi &a, vi &b) {
vp res(sz(a));
rep(i, sz(a)) res[i] = mp(a[i], b[i]);
return res;
}
void ptov(vp &p, vi &a, vi &b) {
a.resize(sz(p));
b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
__lhs += to_string(__rv);
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
__lhs += to_string(__rv);
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<U> &v) {
fora(d, v) a.push(d);
return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T, class U> set<T> &operator+=(set<T> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.pb(v);
return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
vector<T> ret;
ret = a;
fora(v, b) ret += v;
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
fora(v, b) a += v;
return a;
}
template <class T, class U>
vector<T> &operator+=(vector<T> &a, initializer_list<U> v) {
for (auto &&va : v)
a.pb(va);
return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
ole();
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T, typename U>
void insert(vector<T> &v, initializer_list<U> list) {
for (auto &&va : list)
v.pb(va);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, initializer_list<U> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
template <typename T> void insert(set<T> &v, initializer_list<T> list) {
for (auto &&va : list)
v.insert(va);
}
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
}
return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
// 小さい順
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) if (nyu[i] == 0) q.push(i);
while (q.size()) {
int i = q.top();
q.pop();
res.pb(i);
fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
void yn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Yn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fyn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
exit(0);
}
void fYn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
exit(0);
}
void fYN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
void Possible(bool a) {
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
int n, m, k, d, H, W, x, y, z, q;
int cou;
vi t, a, b, c;
// vvi (s, 0, 0);
vvc(ba, 0, 0);
vp p;
str s;
void solve() {
cin >> n >> m;
na(a, n);
na2(b, c, m);
sortp(c, b);
priority_queue<int, vector<int>, greater<int>> q; // 小さい順
q += a;
rep(i, m) {
rep(j, b[i]) {
if (q.top() < c[i]) {
q.pop();
q += c[i];
} else {
break;
}
}
}
cout << sum(q) << endl;
}
int my(int n, vi &a) { return 0; }
int sister(int n, vi &a) {
int ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (int i = 0, ok = 1; i < k5 && ok; i++) {
int n = rand(1, 8);
vi a = ranv(n, 1, 10);
int myres = my(arg);
int res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "正解 : " << res << endl;
cerr << "自分 : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// cout << "完璧 : solveを書き直そう" << endl;
// cout << " : そして、solve()を呼び出すのだ" << endl;
// cout << " : cin>>n; na(a,n);も忘れるな" << endl;
}
#endif
return 0;
};
| // todo 文字数を少なくする
// mintより高速に計算したい時用に modmul() modadd (正の値限定) を作る
// #pragma GCC optimize ("-O3")
#include <bits/stdc++.h>
using namespace std;
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} __initon;
// 衝突対策
#define ws ___ws
//@必須構造
struct T {
int f, s, t;
T() { f = -1, s = -1, t = -1; }
T(int f, int s, int t) : f(f), s(s), t(t) {}
bool operator<(const T &r) const {
return f != r.f ? f < r.f : s != r.s ? s < r.s : t < r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 大きい順
}
bool operator>(const T &r) const {
return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t;
// return f != r.f ? f > r.f : s != r.s ? s > r.s : t > r.t; 小さい順
}
bool operator==(const T &r) const { return f == r.f && s == r.s && t == r.t; }
bool operator!=(const T &r) const { return f != r.f || s != r.s || t != r.t; }
int operator[](int i) {
assert(i < 3);
return i == 0 ? f : i == 1 ? s : t;
}
};
struct F {
int a, b, c, d;
F() { a = -1, b = -1, c = -1, d = -1; }
F(int a, int b, int c, int d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d;
// return a != r.a ? a > r.a : b != r.b ? b > r.b : c != r.c ? c >
// r.c : d > r.d;
}
bool operator>(const F &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d;
// return a != r.a ? a < r.a : b != r.b ? b < r.b : c != r.c ? c <
// r.c : d < r.d;
}
bool operator==(const F &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
int operator[](int i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
T mt(int a, int b, int c) { return T(a, b, c); }
//@マクロ省略系 型,構造
#define int long long
#define ll long long
#define double long double
#define ull unsigned long long
using dou = double;
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
using pd = pair<dou, dou>;
#define fi first
#define se second
#define vec vector
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
// マクロ省略系 コンテナ
using vi = vector<int>;
#define _overloadvvi(_1, _2, _3, _4, name, ...) name
#define vvi0() vec<vi>
#define vvi1(a) vec<vi> a
#define vvi2(a, b) vec<vi> a(b)
#define vvi3(a, b, c) vec<vi> a(b, vi(c))
#define vvi4(a, b, c, d) vec<vi> a(b, vi(c, d))
#define vvi(...) \
_overloadvvi(__VA_ARGS__, vvi4, vvi3, vvi2, vvi1, vvi0)(__VA_ARGS__)
using vl = vector<ll>;
#define _overloadvvl(_1, _2, _3, _4, name, ...) name
#define vvl1(a) vec<vl> a
#define vvl2(a, b) vec<vl> a(b)
#define vvl3(a, b, c) vec<vl> a(b, vl(c))
#define vvl4(a, b, c, d) vec<vl> a(b, vl(c, d))
#define vvl(...) _overloadvvl(__VA_ARGS__, vvl4, vvl3, vvl2, vvl1)(__VA_ARGS__)
using vb = vector<bool>;
#define _overloadvvb(_1, _2, _3, _4, name, ...) name
#define vvb1(a) vec<vb> a
#define vvb2(a, b) vec<vb> a(b)
#define vvb3(a, b, c) vec<vb> a(b, vb(c))
#define vvb4(a, b, c, d) vec<vb> a(b, vb(c, d))
#define vvb(...) _overloadvvb(__VA_ARGS__, vvb4, vvb3, vvb2, vvb1)(__VA_ARGS__)
using vs = vector<string>;
#define _overloadvvs(_1, _2, _3, _4, name, ...) name
#define vvs1(a) vec<vs> a
#define vvs2(a, b) vec<vs> a(b)
#define vvs3(a, b, c) vec<vs> a(b, vs(c))
#define vvs4(a, b, c, d) vec<vs> a(b, vs(c, d))
#define vvs(...) _overloadvvs(__VA_ARGS__, vvs4, vvs3, vvs2, vvs1)(__VA_ARGS__)
using vd = vector<double>;
#define _overloadvvd(_1, _2, _3, _4, name, ...) name
#define vvd1(a) vec<vd> a
#define vvd2(a, b) vec<vd> a(b)
#define vvd3(a, b, c) vec<vd> a(b, vd(c))
#define vvd4(a, b, c, d) vec<vd> a(b, vd(c, d))
#define vvd(...) _overloadvvd(__VA_ARGS__, vvd4, vvd3, vvd2, vvd1)(__VA_ARGS__)
using vc = vector<char>;
#define _overloadvvc(_1, _2, _3, _4, name, ...) name
#define vvc1(a) vec<vc> a
#define vvc2(a, b) vec<vc> a(b)
#define vvc3(a, b, c) vec<vc> a(b, vc(c))
#define vvc4(a, b, c, d) vec<vc> a(b, vc(c, d))
#define vvc(...) _overloadvvc(__VA_ARGS__, vvc4, vvc3, vvc2, vvc1)(__VA_ARGS__)
using vp = vector<P>;
#define _overloadvvp(_1, _2, _3, _4, name, ...) name
#define vvp1(a) vec<vp> a
#define vvp2(a, b) vec<vp> a(b)
#define vvp3(a, b, c) vec<vp> a(b, vp(c))
#define vvp4(a, b, c, d) vec<vp> a(b, vp(c, d))
#define vvp(...) _overloadvvp(__VA_ARGS__, vvp4, vvp3, vvp2, vvp1)(__VA_ARGS__)
using vt = vector<T>;
#define _overloadvvt(_1, _2, _3, _4, name, ...) name
#define vvt1(a) vec<vt> a
#define vvt2(a, b) vec<vt> a(b)
#define vvt3(a, b, c) vec<vt> a(b, vt(c))
#define vvt4(a, b, c, d) vec<vt> a(b, vt(c, d))
#define vvt(...) _overloadvvt(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1)(__VA_ARGS__)
#define v3i(a, b, c, d) vector<vector<vi>> a(b, vector<vi>(c, vi(d)))
#define v3d(a, b, c, d) vector<vector<vd>> a(b, vector<vd>(c, vd(d)))
#define v3m(a, b, c, d) vector<vector<vm>> a(b, vector<vm>(c, vm(d)))
#define _vvi vector<vi>
#define _vvl vector<vl>
#define _vvb vector<vb>
#define _vvs vector<vs>
#define _vvd vector<vd>
#define _vvc vector<vc>
#define _vvp vector<vp>
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<int>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<int, int>;
using mapp = map<P, int>;
using mapd = map<dou, int>;
using mapc = map<char, int>;
using maps = map<str, int>;
using seti = set<int>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<int>;
#define bset bitset
#define uset unordered_set
#define mset multiset
#define umap unordered_map
#define umapi unordered_map<int, int>
#define umapp unordered_map<P, int>
#define mmap multimap
// マクロ 繰り返し
#define _overloadrep(_1, _2, _3, _4, name, ...) name
#define _rep(i, n) for (int i = 0, _lim = n; i < _lim; i++)
#define repi(i, m, n) for (int i = m, _lim = n; i < _lim; i++)
#define repadd(i, m, n, ad) for (int i = m, _lim = n; i < _lim; i += ad)
#define rep(...) _overloadrep(__VA_ARGS__, repadd, repi, _rep, )(__VA_ARGS__)
#define _rer(i, n) for (int i = n; i >= 0; i--)
#define reri(i, m, n) for (int i = m, _lim = n; i >= _lim; i--)
#define rerdec(i, m, n, dec) for (int i = m, _lim = n; i >= _lim; i -= dec)
#define rer(...) _overloadrep(__VA_ARGS__, rerdec, reri, _rer, )(__VA_ARGS__)
#define reps2(i, j, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++)
#define reps3(i, j, k, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++)
#define reps4(i, j, k, l, n) \
for (int i = 0, _lim = n; i < _lim; i++) \
for (int j = 0; j < _lim; j++) \
for (int k = 0; k < _lim; k++) \
for (int l = 0; l < _lim; l++)
#define _overloadreps(_1, _2, _3, _4, _5, name, ...) name
#define reps(...) \
_overloadreps(__VA_ARGS__, reps4, reps3, reps2, _rep, )(__VA_ARGS__)
#define repss(i, j, k, a, b, c) \
for (int i = 0; i < a; i++) \
for (int j = 0; j < b; j++) \
for (int k = 0; k < c; k++)
#define fora(a, b) for (auto &&a : b)
#define forg(gi, ve) \
for (int gi = 0, _lim = ve.size(), f, t, c; \
gi < _lim && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); gi++)
#define fort(gi, ve) \
for (int gi = 0, f, t, c; \
gi < ve.size() && (f = ve[gi].f, t = ve[gi].t, c = ve[gi].c, true); \
gi++) \
if (t != p)
// #define fort(gi, ve) for (int gi = 0, f, t, c;gi<ve.size()&& (gi+=
// (ve[gi].t==p))< ve.size() && (f = ve[gi].f,t=ve[gi].t, c = ve[gi].c,true);
// gi++)
#define form(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it).fi < r; it++)
#define forit(st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r; it++)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const int inf = (int)1e9 + 100;
const ll linf = (ll)1e18 + 100;
const char infc = '{';
const string infs = "{";
const double eps = 1e-9;
const double PI = 3.1415926535897932384626433832795029L;
ll ma = numeric_limits<ll>::min();
ll mi = numeric_limits<ll>::max();
const int y4[] = {-1, 1, 0, 0};
const int x4[] = {0, 0, -1, 1};
const int y8[] = {0, 1, 0, -1, -1, 1, 1, -1};
const int x8[] = {1, 0, -1, 0, 1, -1, 1, -1};
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((int)(a).size())
// #define rs resize
#define mp make_pair
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
constexpr bool ev(int a) { return !(a & 1); }
constexpr bool od(int a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public:
// 大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) + x.second);
}
};
} // namespace std
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec) {
for (T &x : vec)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se << endl;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &vec) {
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < vec[0].size(); j++) {
os << vec[i][j];
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
for (auto &&v : m)
os << v;
return os;
}
template <typename V, typename H> void resize(vector<V> &vec, const H head) {
vec.resize(head);
}
template <typename V, typename H, typename... T>
void resize(vector<V> &vec, const H &head, const T... tail) {
vec.resize(head);
for (auto &v : vec)
resize(v, tail...);
}
template <typename T, typename _Pr>
bool all_of(const vector<T> &vec, _Pr pred) {
return std::all_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool any_of(const vector<T> &vec, _Pr pred) {
return std::any_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
bool none_of(const vector<T> &vec, _Pr pred) {
return std::none_of(vec.begin(), vec.end(), pred);
}
template <typename T, typename _Pr>
const typename vector<T>::const_iterator find_if(const vector<T> &vec,
_Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred);
}
template <class T> bool contains(const std::string &s, const T &v) {
return s.find(v) != std::string::npos;
}
template <typename T> bool contains(const vector<T> &vec, const T &val) {
return std::find(vec.begin(), vec.end(), val) != vec.end();
}
template <typename T, typename _Pr>
bool contains_if(const vector<T> &vec, _Pr pred) {
return std::find_if(vec.begin(), vec.end(), pred) != vec.end();
}
template <class T, class U> void replace(vector<T> &a, T key, U v) {
replace(a.begin(), a.end(), key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(all(a), key), a.end());
}
void replace(str &a, str key, str v) {
if (v == "")
a.erase(remove(all(a), key[0]), a.end());
else
replace(all(a), key[0], v[0]);
}
void replace(str &a, char key, char v) { replace(all(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
template <class T> void replace(T &a) { replace(a, '#'); }
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(all(c));
sort(all(d));
return includes(all(c), all(d));
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(all(a), all(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(all(a));
}
template <class T> T pop(set<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T pop(mset<T> &set) {
T res = *set.begin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(set<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
template <class T> T popBack(mset<T> &set) {
T res = *set.rbegin();
set.erase(set.find(res));
return res;
}
inline void sort(string &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a) { sort(a.begin(), a.end()); }
template <class T> inline void sort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len);
}
template <class T, class F> inline void sort(vector<T> &a, F f) {
sort(a.begin(), a.end(), [&](T a, T b) { return f(a) < f(b); });
}
enum ___pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
inline void sort(vector<P> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
break;
case fisd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
break;
case fdsi:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
break;
case fdsd:
sort(all(a),
[&](P l, P r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
break;
case sifi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
break;
case sifd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
break;
case sdfi:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
break;
case sdfd:
sort(all(a),
[&](P l, P r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
break;
}
};
inline void sort(vector<T> &a, ___pcomparator type) {
switch (type) {
case fisi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
break;
case fisd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
break;
case fdsi:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
break;
case fdsd:
sort(all(a), [&](T l, T r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
break;
case sifi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
break;
case sifd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
break;
case sdfi:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
break;
case sdfd:
sort(all(a), [&](T l, T r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
break;
}
};
template <class T> inline void rsort(vector<T> &a) {
sort(a.begin(), a.end(), greater<T>());
};
template <class T> inline void rsort(vector<T> &a, int len) {
sort(a.begin(), a.begin() + len, greater<T>());
};
template <class U, class F> inline void rsort(vector<U> &a, F f) {
sort(a.begin(), a.end(), [&](U l, U r) { return f(l) > f(r); });
};
template <class U> inline void sortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
;
}
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class U, class F> inline void sortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void sortp(vector<U> &a, vector<U> &b, char type) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
sort(c, type);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void rsortp(vector<U> &a, vector<U> &b) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U, class F>
inline void rsortp(vector<U> &a, vector<U> &b, F f) {
vp c;
int n = sz(a);
assert(n == sz(b));
rep(i, n) c.eb(a[i], b[i]);
rsort(c, f);
rep(i, n) {
a[i] = c[i].first;
b[i] = c[i].second;
}
};
template <class U> inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void sortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
sort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U, class F>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c, F f) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r, f);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
template <class U>
inline void rsortt(vector<U> &a, vector<U> &b, vector<U> &c) {
vt r;
int n = sz(a);
assert(n == sz(b));
assert(n == sz(c));
rep(i, n) r.eb(a[i], b[i], c[i]);
rsort(r);
rep(i, n) {
a[i] = r[i].f;
b[i] = r[i].s;
c[i] = r[i].t;
}
};
// indexをつけてsortする (second)
template <class T> auto sorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
sort(ret);
return ret;
};
template <class T> auto rsorti(vector<T> &a) {
int n = sz(a);
vp ret(n);
rep(i, n) ret[i] = P(a[i], i);
rsort(ret);
return ret;
};
template <class T> inline void sort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
sort(a[i]);
}
template <class T> inline void rsort2(vector<vector<T>> &a) {
for (int i = 0, n = a.size(); i < n; i++)
rsort(a[i]);
}
template <typename A, size_t N, typename T>
inline void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
inline void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
inline void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
inline void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
inline void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
inline void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
template <typename V, typename T> void fill(V &xx, const T vall) { xx = vall; }
template <typename V, typename T> void fill(vector<V> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
//@汎用便利関数 入力
inline int in() {
int ret;
// scanf("%lld", &ret);
cin >> ret;
return ret;
}
inline string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> inline void in(T &head) { cin >> head; }
template <class T, class... U> inline void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
#define _overloaddin(_1, _2, _3, _4, name, ...) name
#define din1(a) \
int a; \
cin >> a
#define din2(a, b) \
int a, b; \
cin >> a >> b
#define din3(a, b, c) \
int a, b, c; \
cin >> a >> b >> c
#define din4(a, b, c, d) \
int a, b, c, d; \
cin >> a >> b >> c >> d
#define din(...) _overloaddin(__VA_ARGS__, din4, din3, din2, din1)(__VA_ARGS__)
#define _overloaddind(_1, _2, _3, _4, name, ...) name
#define din1d(a) \
din1(a); \
a--
#define din2d(a, b) \
din2(a, b); \
a--, b--
#define din3d(a, b, c) \
din3(a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din4(a, b, c, d); \
a--, b--, c--, d--
#define dind(...) \
_overloaddind(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
#define _overloadout(_1, _2, _3, _4, name, ...) name
#define out1(a) cout << a << endl
#define out2(a, b) cout << a << " " << b << endl
#define out3(a, b, c) cout << a << " " << b << " " << c << endl
#define out4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl
#define out(...) \
_overloadout((__VA_ARGS__), out4, out3, out2, out1)((__VA_ARGS__))
template <class T> void outl(vector<T> &a) { fora(v, a) cout << v << endl; }
#define na(a, n) \
a.resize(n); \
rep(_i, n) cin >> a[_i];
#define dna(a, n) \
vi a(n); \
rep(_i, n) cin >> a[_i];
#define nao(a, n) \
a.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1];
#define nad(a, n) \
a.resize(n); \
rep(_i, n) { \
cin >> a[_i]; \
a[_i]--; \
}
#define na2(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define dna2(a, b, n) \
vi a(n), b(n); \
rep(_i, n) cin >> a[_i] >> b[_i];
#define nao2(a, b, n) \
a.resize(n + 1), b.resize(n + 1); \
rep(_i, n) cin >> a[_i + 1] >> b[_i + 1];
#define na2d(a, b, n) \
a.resize(n), b.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i]; \
a[_i]--, b[_i]--; \
}
#define na3(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define dna3(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) cin >> a[_i] >> b[_i] >> c[_i];
#define na3d(a, b, c, n) \
a.resize(n), b.resize(n), c.resize(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define dna3d(a, b, c, n) \
vi a(n), b(n), c(n); \
rep(_i, n) { \
cin >> a[_i] >> b[_i] >> c[_i]; \
a[_i]--, b[_i]--, c[_i]--; \
}
#define nt(a, h, w) \
resize(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi];
#define ntd(a, h, w) \
rs(a, h, w); \
rep(_hi, h) rep(_wi, w) cin >> a[_hi][_wi], a[_hi][_wi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(_hi, 1, h + 1) rep(_wi, 1, w + 1) cin >> a[_hi][_wi];
// デバッグ
#define sp << " " <<
#define debugName(VariableName) #VariableName
#define _deb1(x) debugName(x) << " = " << x
#define _deb2(x, ...) _deb1(x) << ", " << _deb1(__VA_ARGS__)
#define _deb3(x, ...) _deb1(x) << ", " << _deb2(__VA_ARGS__)
#define _deb4(x, ...) _deb1(x) << ", " << _deb3(__VA_ARGS__)
#define _deb5(x, ...) _deb1(x) << ", " << _deb4(__VA_ARGS__)
#define _deb6(x, ...) _deb1(x) << ", " << _deb5(__VA_ARGS__)
#define _deb7(x, ...) _deb1(x) << ", " << _deb6(__VA_ARGS__)
#define _deb8(x, ...) _deb1(x) << ", " << _deb7(__VA_ARGS__)
#define _deb9(x, ...) _deb1(x) << ", " << _deb8(__VA_ARGS__)
#define _deb10(x, ...) _deb1(x) << ", " << _deb9(__VA_ARGS__)
#define _overloadebug(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, name, ...) name
#ifdef _DEBUG
#define deb(...) \
cerr << _overloadebug(__VA_ARGS__, _deb10, _deb9, _deb8, _deb7, _deb6, \
_deb5, _deb4, _deb3, _deb2, _deb1)(__VA_ARGS__) \
<< endl
#else
#define deb(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
// よく使うクラス、構造体
class UnionFind {
public:
vi par, rank, sizes;
int n, trees;
UnionFind(int n) : n(n), trees(n) {
par.resize(n), rank.resize(n), sizes.resize(n);
rep(i, n) par[i] = i, sizes[i] = 1;
}
int root(int x) {
if (par[x] == x)
return x;
else
return par[x] = root(par[x]);
}
int find(int x) { return root(x); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
trees--;
par[y] = x;
sizes[x] += sizes[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return root(x) == root(y); }
int size(int x) { return sizes[root(x)]; }
// 順不同 umapなので
vec<vi> sets() {
vec<vi> res(trees);
umap<int, vi> map;
rep(i, n) map[root(i)].push_back(i);
int i = 0;
for (auto &&p : map) {
int r = p.fi;
res[i].push_back(r);
for (auto &&v : p.se) {
if (r == v)
continue;
res[i].push_back(v);
}
i++;
}
return res;
}
};
using bint = __int128;
using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 toi128(string &s) {
__int128 ret = 0;
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
template <typename T> T minv(T a, T m);
template <typename T> T minv(T a);
template <typename T> class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U> Modular(const U &x) { value = normalize(x); }
template <typename U> static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0)
v += mod();
return v;
}
const Type &operator()() const { return value; }
template <typename U> explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
if ((value += other.value) >= mod())
value -= mod();
return *this;
}
Modular &operator-=(const Modular &other) {
if ((value -= other.value) < 0)
value += mod();
return *this;
}
template <typename U> Modular &operator+=(const U &other) {
return *this += Modular(other);
}
template <typename U> Modular &operator-=(const U &other) {
return *this -= Modular(other);
}
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(signed) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(signed) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, signed>::value,
Modular>::type &
operator*=(const Modular &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type &
operator*=(const Modular &rhs) {
int64_t q =
static_cast<int64_t>(static_cast<double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) {
return *this *= Modular(minv(other.value));
}
template <typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
operator int() { return normalize(value); }
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
constexpr signed MOD = 1e9 + 7; // MOD
using mint = Modular<std::integral_constant<decay<decltype(MOD)>::type, MOD>>;
constexpr int mint_len = 1400001;
vi fac, finv, inv;
vi p2;
void setmod() {
// p2.resize(mint_len);p[0] = 1; for (int i = 1; i < mint_len; ++i) p2[i] =
// p2[i - 1] * 2 % MOD;
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
#define smod setmod
inline mint com(int n, int r) {
if (r < 0 || r > n)
return 0;
return mint(finv[r] * fac[n] % MOD * finv[n - r]);
}
inline mint pom(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - 1]);
}
inline mint npr(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
inline int nprin(int n, int r) {
// if (!sz(fac)) com(0, -1);
if (r < 0 || r > n)
return 0;
return fac[n] * finv[n - r] % MOD;
}
inline int icom(int n, int r) {
const int NUM_ = 1400001;
static ll fac[NUM_ + 1], finv[NUM_ + 1], inv[NUM_ + 1];
if (fac[0] == 0) {
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
if (r < 0 || r > n)
return 0;
return ((finv[r] * fac[n] % MOD) * finv[n - r]) % MOD;
}
#define ncr com
#define ncri icom
inline mint nhr(int n, int r) { return com(n + r - 1, r); }
inline mint hom(int n, int r) { return com(n + r - 1, r); }
inline int nhri(int n, int r) { return icom(n + r - 1, r); }
template <typename T> inline T minv(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T> inline T minv(T a) {
if (a < mint_len)
return inv[a];
T u = 0, v = 1;
T m = MOD;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T, typename U>
inline Modular<T> mpow(const Modular<T> &a, const U &b) {
assert(b >= 0);
int x = a(), res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline mint mpow(const T a, const U b, const V m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T, typename U> inline mint mpow(const T a, const U b) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
template <typename T, typename U, typename V>
inline int mpowi(const T &a, const U &b, const V &m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T> inline string to_string(const Modular<T> &number) {
return to_string(number());
}
template <typename T>
std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
return stream << number();
}
template <typename T>
std::istream &operator>>(std::istream &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
using PM = pair<mint, mint>;
using vm = vector<mint>;
using mapm = map<int, mint>;
using umapm = umap<int, mint>;
#define _overloadvvm(_1, _2, _3, _4, name, ...) name
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
#define vvm1(a) vec<vm> a
#define vvm2(a, b) vec<vm> a(b)
#define vvm3(a, b, c) vec<vm> a(b, vm(c))
#define vvm4(a, b, c, d) vec<vm> a(b, vm(c, d))
#define vvm(...) _overloadvvm(__VA_ARGS__, vvm4, vvm3, vvm2, vvm1)(__VA_ARGS__)
// エラー
void ole() {
#ifdef _DEBUG
debugline("ole");
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re() { assert(0 == 1); }
void tle() {
while (inf)
cout << inf << endl;
}
// 便利関数
// テスト用
char ranc() { return (char)('a' + rand() % 26); }
int rand(int min, int max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
//+
if (rand() % 2) {
return rand(0, max);
//-
} else {
return -rand(0, -min);
}
}
}
vi ranv(int n, int min, int max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
// 単調増加
vi ranvi(int n, int min, int max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
void ranvlr(int n, int min, int max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
// 便利 汎用
vp run_length(vi &a) {
vp ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
vector<pair<char, int>> run_length(string &a) {
vector<pair<char, int>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
template <class F> inline int mgr(int ok, int ng, F f) {
#define _mgrbody \
int mid = (ok + ng) / 2; \
if (f(mid)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody
}
else
while (ok - ng > 1) {
_mgrbody
}
return ok;
}
template <class F> inline int mgr(int ok, int ng, int second, F f) {
#define _mgrbody2 \
int mid = (ok + ng) / 2; \
if (f(mid, second)) \
ok = mid; \
else \
ng = mid;
if (ok < ng)
while (ng - ok > 1) {
_mgrbody2
}
else
while (ok - ng > 1) {
_mgrbody2
}
return ok;
}
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return b;
} else if (a[i] > b[i])
return a;
}
}
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) < sz(b)) {
return a;
} else if (sz(a) > sz(b)) {
return b;
} else {
rep(i, sz(a)) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i])
return b;
}
}
return a;
}
template <typename V, typename T> int find(vector<V> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename V, typename T> P find(vector<vector<V>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
template <typename V, typename U>
T find(vector<vector<vector<V>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] == key) return mt(i, j, k);
return mt(-1, -1, -1);
}
template <typename V, typename T> int count2(V &a, const T k) { return a == k; }
template <typename V, typename T> int count2(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count(v, k);
return ret;
}
template <typename V, typename T> int count(vector<V> &a, const T k) {
int ret = 0;
fora(v, a) ret += count2(v, k);
return ret;
}
int count(str a, str k) {
int ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ret++;
return ret;
}
template <typename V> int count_odd(V &a) { return a % 2; }
template <typename V> int count_odd(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_odd(v);
return ret;
}
template <typename V> int count_even(V &a) { return a % 2 == 0; }
template <typename V> int count_even(vector<V> &a) {
int ret = 0;
fora(v, a) ret += count_even(v);
return ret;
}
// algorythm
void iota(vector<int> &ve, int s, int n) {
ve.resize(n);
iota(all(ve), s);
}
vi iota(int s, int len) {
vi ve(len);
iota(all(ve), s);
return ve;
}
inline ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> void rev(vector<T> &a) { reverse(all(a)); }
template <class T> vector<T> revv(vector<T> &a) {
vector<T> b = a;
reverse(all(b));
return b;
}
void inline rev(string &a) { reverse(all(a)); }
constexpr int p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
int get(int a, int keta) { return (a / (int)pow(10, keta)) % 10; }
int keta(ll v) {
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1])
return 1;
else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else if (v < p10[15])
return 15;
else
return 16;
} else {
if (v < p10[17])
return 17;
else
return 18;
}
}
}
}
int dsum(int v) {
int ret = 0;
for (; v; v /= 10)
ret += v % 10;
return ret;
}
inline int sumd(int v) { return dsum(v); }
struct sint {
int v;
sint(int v) : v(v) {}
operator int() { return v; }
int operator[](int i) { return (v / p10[i]) % 10; }
int top(int i) {
int len = keta(v);
return operator[](len - 1 - i);
}
// 先頭からi番目にセット
int top(int i, int k) {
int len = keta(v);
return set(len - 1 - i, k);
}
int set(int i, int k) {
if (i < 0)
return top(abs(i) - 1, k);
return v += p10[i] * (k - (v / p10[i]) % 10);
}
int inc(int i, int k = 1) { return v += p10[i] * k; }
int inct(int i, int k = 1) { return v += p10[keta(v) - i - 1] * k; }
int dec(int i, int k = 1) { return v -= p10[i] * k; }
int dect(int i, int k = 1) { return v -= p10[keta(v) - i - 1] * k; }
#define op(t, o) \
template <class T> inline t operator o(T r) { return v o r; }
op(int, +=);
op(int, -=);
op(int, *=);
op(int, /=);
op(int, %=);
op(int, +);
op(int, -);
op(int, *);
op(int, /);
op(int, %);
op(bool, ==);
op(bool, !=);
op(bool, <);
op(bool, <=);
op(bool, >);
op(bool, >=);
#undef op
template <class T> inline int operator<<=(T r) { return v *= p10[r]; }
template <class T> inline int operator<<(T r) { return v * p10[r]; }
template <class T> inline int operator>>=(T r) { return v /= p10[r]; }
template <class T> inline int operator>>(T r) { return v / p10[r]; }
};
int mask10(int v) { return p10[v] - 1; }
// 変換系
template <class T, class U> inline vector<T> keys(vector<pair<T, U>> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(map<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> inline vector<U> keys(umap<T, U> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.fi);
return res;
}
template <class T, class U> vector<U> inline values(vector<pair<T, U>> a) {
vector<U> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(map<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline vector<T> values(umap<T, U> a) {
vector<T> res;
for (auto &&k : a)
res.pb(k.se);
return res;
}
template <class T, class U> inline bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chma(const U &b) { return chma(ma, b); }
template <class T, class U> inline bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class U> inline bool chmi(const U &b) { return chmi(mi, b); }
template <class T> inline T min(T a, signed b) { return a < b ? a : b; }
template <class T> inline T max(T a, signed b) { return a < b ? b : a; }
template <class T> inline T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> inline T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class T> inline T min(vector<T> a) { return *min_element(all(a)); }
template <class T> inline T mini(vector<T> a) {
return min_element(all(a)) - a.begin();
}
template <class T> inline T min(vector<T> a, int n) {
return *min_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T min(vector<T> a, int s, int n) {
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a) { return *max_element(all(a)); }
template <class T> inline T maxi(vector<T> a) {
return max_element(all(a)) - a.begin();
}
template <class T> inline T max(vector<T> a, int n) {
return *max_element(a.begin(), a.begin() + min(n, sz(a)));
}
template <class T> inline T max(vector<T> a, int s, int n) {
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <typename A, size_t N> inline A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> inline A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> inline A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P>
inline A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
inline A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
inline A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
inline A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <class T> inline T sum(T &v) { return v; }
template <class T> inline auto sum(vector<T> &v) {
auto ret = sum(v[0]);
rep(i, 1, sz(v)) ret += sum(v[i]);
return ret;
}
template <class T>
inline auto sum(priority_queue<T, vector<T>, greater<T>> &r) {
auto q = r;
T ret = 0;
while (sz(q)) {
ret += q.top();
q.pop();
}
return ret;
}
template <class T, class U, class... V>
inline auto sum(vector<T> &v, U head, V... tail) {
auto ret = sum(v[0], tail...);
rep(i, 1, min(sz(v), head)) ret += sum(v[i], tail...);
return ret;
}
inline P sump(vp &v, int len = -1) {
if (len == -1)
len = v.size();
P res = {0, 0};
chmi(len, v.size());
rep(i, len) {
res.fi += v[i].fi;
res.se += v[i].se;
}
return res;
}
/// 要素が0の時、返り値は0か1か
template <class T> inline T mul(vector<T> &v, int len = -1) {
if (len == -1)
len = v.size();
T res = 1;
chmi(len, v.size());
rep(i, len) res *= v[i];
return res;
}
inline void clear(PQ &q) {
while (q.size())
q.pop();
}
template <class T> inline void clear(queue<T> &q) {
while (q.size())
q.pop();
}
template <class T> inline T *negarr(int size) {
T *body = (T *)malloc((size * 2 + 1) * sizeof(T));
return body + size;
}
template <class T> inline T *negarr2(int h, int w) {
double **dummy1 = new double *[2 * h + 1];
double *dummy2 = new double[(2 * h + 1) * (2 * w + 1)];
dummy1[0] = dummy2 + w;
for (int i = 1; i <= 2 * h + 1; i++) {
dummy1[i] = dummy1[i - 1] + 2 * w + 1;
}
double **a = dummy1 + h;
return a;
}
// imoは0-indexed
// ruiは1-indexed
template <class T> inline vector<T> imo(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// kと同じものの数
template <class T, class U> inline vi imo(vector<T> &a, U k) {
vector<T> ret = a;
rep(i, sz(ret) - 1) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T> inline vector<T> imox(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> inline vector<T> imi(vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> struct ruiC {
const vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
inline T operator()(int l, int r) {
assert(l <= r);
return rui[r] - rui[l];
}
inline T operator[](int i) { return rui[i]; }
};
template <class T> struct rruic {
const T *rrui;
rruic(T *ru) : rrui(ru) {}
// n-1から-1へ
inline T operator()(int l, int r) {
assert(l >= r);
return rrui[r] - rrui[l];
}
inline T operator[](int i) { return rrui[i]; }
};
template <class T> inline vector<T> ruiv(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> inline ruiC<T> ruic(vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
// kと同じものの数
template <class T, class U> inline vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> inline ruiC<int> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<int>(ret);
}
// xor
template <class T> inline vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> inline vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> inline vector<T> ruimi(vector<T> &a) {
int n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> rruic<T> rrui(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
rer(i, len - 1) res[i - 1] = res[i] + a[i];
return rruic<T>(res);
}
// 掛け算
template <class T> T *rruim(vector<T> &a) {
int len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void inc(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void plus(T &a, U v = 1) { a += v; }
template <class T, class U> void plus(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T> void plus(vector<T> &a) {
for (auto &u : a)
inc(u, 1);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void dec(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class T, class U> void minu(T &a, U v = 1) { a -= v; }
template <class T, class U> void minu(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T> void minu(vector<T> &a) {
for (auto &u : a)
dec(u, 1);
}
template <class U> void minu(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
void minu(string &a) {
for (auto &u : a)
dec(u, 1);
}
inline bool inside(int h, int w, int H, int W) {
return h >= 0 && w >= 0 && h < H && w < W;
}
inline bool inside(int l, int v, int r) { return l <= v && v < r; }
#define ins inside
ll u(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u(const vector<T> &a) {
vector<T> ret = a;
fora(v, ret) v = u(v);
return ret;
}
#define MIN(a) numeric_limits<a>::min()
#define MAX(a) numeric_limits<a>::max()
ll goldd(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return resIndex;
}
ll goldt(ll left, ll right, function<ll(ll)> calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN(ll);
ll resIndex = left;
for (ll i = left; i < right + 1; i++) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return resIndex;
}
template <class T> T min(vector<vector<T>> &a) {
T res = MAX(T);
rep(i, a.size()) chmi(res, *min_element(all(a[i])));
return res;
}
template <class T> T max(vector<vector<T>> &a) {
T res = MIN(T);
rep(i, a.size()) chma(res, *max_element(all(a[i])));
return res;
}
constexpr bool bget(ll m, int keta) {
assert(keta < 64);
return (m >> keta) & 1;
}
int bget(ll m, int keta, int sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
ll bit(int n) { return (1LL << (n)); }
ll bit(int n, int sinsuu) { return (ll)pow(sinsuu, n); }
int mask(int n) { return (1ll << n) - 1; }
// int bcou(ll m) { return __builtin_popcount(m & 0xFFFFFFFF) +
// __builtin_popcount(m >> 32); }
#define bcou __builtin_popcountll
// 最下位ビット
int lbit(int n) { return n & -n; }
// 最上位ビット
int hbit(int n) {
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
int hbitk(int n) {
int k = 0;
rer(i, 5) {
int a = k + (1ll << i);
int b = 1ll << a;
if (b <= n)
k += 1ll << i;
}
return k;
}
// 初期化は0を渡す
ll nextComb(ll &mask, int n, int r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; // 最下位の1
ll y = mask + x; // 連続した下の1を繰り上がらせる
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vl bitCombList(int n, int r) {
vl res;
int m = 0;
while (nextComb(m, n, r)) {
res.pb(m);
}
return res;
}
// 大文字小文字を区別する
int altoiaZ(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a' + 26;
}
char itoalaZ(int i) {
if (i < 26)
return 'A' + i;
return 'a' + i - 26;
}
// aもAも0を返す 基本小文字
int altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
char itoal(int i) { return 'a' + i; }
int ctoi(char c) { return c - '0'; }
char itoc(int i) { return i + '0'; }
int vtoi(vi &v) {
int res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(int i) {
vi res;
while (i) {
res.pb(i % 10);
i /= 10;
}
rev(res);
return res;
}
vi stov(string &a) {
int n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
vector<vector<int>> ctoi(vector<vector<char>> s, char c) {
int n = sz(s), m = sz(s[0]);
vector<vector<int>> res(n, vector<int>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
//[i] := i番として圧縮されたものを返す
vi compress(vi &a) {
vi b;
int len = a.size();
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r) {
vi b;
int len = a.size();
fora(v, a) b.pb(v);
fora(v, r) b.pb(v);
sort(b);
unique(b);
for (int i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (int i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r, vi &s) {
vi b;
int len = a.size();
fora(v, a) b.pb(v);
fora(v, r) b.pb(v);
fora(v, s) b.pb(v);
sort(b);
unique(b);
for (int i = 0; i < len; ++i)
a[i] = lower_bound(all(b), a[i]) - b.begin();
for (int i = 0; i < sz(r); ++i)
r[i] = lower_bound(all(b), r[i]) - b.begin();
for (int i = 0; i < sz(s); ++i)
r[i] = lower_bound(all(b), s[i]) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(_vvi &a) {
vi b;
fora(vv, a) fora(v, vv) b.pb(v);
sort(b);
unique(b);
fora(vv, a) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vector<vi>> &a) {
vi b;
fora(vvv, a) fora(vv, vvv) fora(v, vv) b.pb(v);
sort(b);
unique(b);
fora(vvv, a) fora(vv, vvv) fora(v, vv) v = lower_bound(all(b), v) - b.begin();
int blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
void compress(int a[], int len) {
vi b;
for (int i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (int i = 0; i < len; ++i) {
a[i] = lower_bound(all(b), a[i]) - b.begin();
}
}
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(all(a), v))
#define lowerIndex(a, v) (lower_bound(all(a), v) - a.begin())
#define lowerBound(a, v) (*lower_bound(all(a), v))
#define upperIndex(a, v) (upper_bound(all(a), v) - a.begin())
#define upperBound(a, v) (*upper_bound(all(a), v))
#define ans(a) \
cout << a << endl; \
continue;
#define poll(a) \
q.front(); \
q.pop()
#define dpoll(a) \
q.front(); \
q.pop_front()
#define pollLast(a) \
q.back(); \
q.pop_back()
#define pollBack(a) \
q.back(); \
q.pop_back()
template <class T> inline void fin(T s) { cout << s << endl, exit(0); }
// 便利 数学 math
int mod(int a, int m) { return (a % m + m) % m; }
int pow(int a) { return a * a; };
ll fact(int v) { return v <= 1 ? 1 : v * fact(v - 1); }
ll comi(int n, int r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
double comd(int n, int r) {
assert(n < 2020);
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
int gcd(int a, int b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
int gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
int res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
res++;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
ll sig(ll t) { return (1 + t) * t / 2; }
ll sig(ll s, ll t) { return (s + t) * (t - s + 1) / 2; }
namespace pnumber_tools {
#define Eratosthenes30_2 \
class Eratosthenes { \
public: \
virtual void initialize() {} \
virtual void generate(const int64_t x) = 0; \
virtual void generate(const int64_t from, const int64_t to) = 0; \
virtual int64_t count() = 0; \
virtual bool prime(int x) = 0; \
virtual int32_t version() = 0; \
inline uint64_t PopCnt(uint64_t); \
inline int BitToIndex(uint8_t); \
}; \
uint64_t Eratosthenes::PopCnt(uint64_t bits) { \
bits = (bits & 0x5555555555555555ULL) + \
((bits >> 1) & 0x5555555555555555ULL); \
bits = (bits & 0x3333333333333333ULL) + \
((bits >> 2) & 0x3333333333333333ULL); \
bits = (bits & 0x0f0f0f0f0f0f0f0fULL) + \
((bits >> 4) & 0x0f0f0f0f0f0f0f0fULL); \
return (bits * 0x0101010101010101ULL) >> (64 - 8); \
} \
int Eratosthenes::BitToIndex(uint8_t b) { \
switch (b) { \
case 1 << 0: \
return 0; \
case 1 << 1: \
return 1; \
case 1 << 2: \
return 2; \
case 1 << 3: \
return 3; \
case 1 << 4: \
return 4; \
case 1 << 5: \
return 5; \
case 1 << 6: \
return 6; \
case 1 << 7: \
return 7; \
} \
return -1; \
} \
namespace { \
const uint64_t kSegmentSize = 1000000; \
const int32_t kMod30[] = {1, 7, 11, 13, 17, 19, 23, 29}; \
const int C1[] = {6, 4, 2, 4, 2, 4, 6, 2}; \
const int C0[][8] = { \
{0, 0, 0, 0, 0, 0, 0, 1}, {1, 1, 1, 0, 1, 1, 1, 1}, \
{2, 2, 0, 2, 0, 2, 2, 1}, {3, 1, 1, 2, 1, 1, 3, 1}, \
{3, 3, 1, 2, 1, 3, 3, 1}, {4, 2, 2, 2, 2, 2, 4, 1}, \
{5, 3, 1, 4, 1, 3, 5, 1}, {6, 4, 2, 4, 2, 4, 6, 1}, \
}; \
const uint8_t kMask[][8] = { \
{0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f}, \
{0xfd, 0xdf, 0xef, 0xfe, 0x7f, 0xf7, 0xfb, 0xbf}, \
{0xfb, 0xef, 0xfe, 0xbf, 0xfd, 0x7f, 0xf7, 0xdf}, \
{0xf7, 0xfe, 0xbf, 0xdf, 0xfb, 0xfd, 0x7f, 0xef}, \
{0xef, 0x7f, 0xfd, 0xfb, 0xdf, 0xbf, 0xfe, 0xf7}, \
{0xdf, 0xf7, 0x7f, 0xfd, 0xbf, 0xfe, 0xef, 0xfb}, \
{0xbf, 0xfb, 0xf7, 0x7f, 0xfe, 0xef, 0xdf, 0xfd}, \
{0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe}, \
}; \
const int64_t kSievedPrimes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23}; \
const int64_t kInitialSize = 7 * 11 * 13 * 17 * 19 * 23; \
class Eratosthenes2 final : public Eratosthenes { \
public: \
void generate(const int64_t x) override; \
void generate(const int64_t, const int64_t) override { assert(false); } \
bool prime(int x) override; \
int64_t count() override; \
int32_t version() override { return 2; } \
std::vector<uint8_t> flags_; \
}; \
void Eratosthenes2::generate(const int64_t x) { \
flags_.clear(); \
if (x > 10000000000) \
return; \
int64_t size = x / 30 + (x % 30 != 0); \
flags_.resize(size, 0xff); \
if (int r = x % 30) { \
if (r <= 1) \
flags_[size - 1] = 0x0; \
else if (r <= 7) \
flags_[size - 1] = 0x1; \
else if (r <= 11) \
flags_[size - 1] = 0x3; \
else if (r <= 13) \
flags_[size - 1] = 0x7; \
else if (r <= 17) \
flags_[size - 1] = 0xf; \
else if (r <= 19) \
flags_[size - 1] = 0x1f; \
else if (r <= 23) \
flags_[size - 1] = 0x3f; \
else if (r <= 29) \
flags_[size - 1] = 0x7f; \
} \
flags_[0] = 0xfe; \
const uint64_t sqrt_x = std::ceil(std::sqrt(x) + 0.1); \
const uint64_t sqrt_xi = sqrt_x / 30 + 1; \
for (uint64_t i = 0; i < sqrt_xi; ++i) { \
for (uint8_t flags = flags_[i]; flags; flags &= flags - 1) { \
uint8_t lsb = flags & (-flags); \
int ibit = BitToIndex(lsb); \
const int32_t m = kMod30[ibit]; \
int32_t pm = 30 * i + 2 * m; \
for (uint64_t j = i * pm + (m * m) / 30, k = ibit; j < flags_.size(); \
j += i * C1[k] + C0[ibit][k], k = (k + 1) & 7) { \
flags_[j] &= kMask[ibit][k]; \
} \
} \
} \
} \
int64_t Eratosthenes2::count() { \
if (flags_.empty()) \
return -1; \
int64_t ret = 3; \
for (uint8_t f : flags_) { \
ret += PopCnt(f); \
} \
return ret; \
} \
inline bool Eratosthenes2::prime(int x) { \
static unordered_map<int, int> imap = { \
{1, 0}, {7, 1}, {11, 2}, {13, 3}, {17, 4}, {19, 5}, {23, 6}, {29, 7}}; \
if (x == 2 || x == 3 || x == 5) \
return true; \
else if (!(x & 1) || x % 3 == 0 || x % 5 == 0) \
return false; \
return (flags_[x / 30] >> imap[x % 30]) & 1; \
} \
}
Eratosthenes30_2 Eratosthenes2 era;
int prime_len = 3e6;
vector<int> primes;
void setprime(int size = 3e6) {
prime_len = size;
era.generate(size);
primes = {2, 3, 5};
int nums[129] = {};
nums[1] = 1;
nums[2] = 7;
nums[4] = 11;
nums[8] = 13;
nums[16] = 17;
nums[32] = 19;
nums[64] = 23;
nums[128] = 29;
// p = 30i + j
int j = 0;
int sflim = era.flags_.size();
int i30 = 0;
for (int i = 0; i < sflim; i++, i30 += 30) {
uint8_t m = era.flags_[i];
while (m) {
j = m & -m;
primes.push_back(i30 + nums[j]);
m ^= j;
}
}
}
using u32 = unsigned int; // longlongになっていると思うが放置していいと思う
using u64 = unsigned long long;
using u128 = __uint128_t;
// O(k log(n)^3)
// 32bit -> 270回程度
// 64bit -> 1260回程度
// 64bit以下で精度100%
template <class BinOp>
bool miller_rabin(const uint64_t &n, const uint64_t *witness, BinOp modmul) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
const int64_t m = n - 1, d = m / (m & -m);
auto modpow = [&](int64_t a, int64_t b) {
int64_t res = 1;
for (; b; b /= 2) {
if (b & 1)
res = modmul(res, a);
a = modmul(a, a);
}
return res;
};
auto suspect = [&](uint64_t a, uint64_t t) {
a = modpow(a, t);
while (t != n - 1 && a != 1 && a != n - 1) {
a = modmul(a, a);
t = modmul(t, 2);
}
return a == n - 1 || t % 2 == 1;
};
for (const uint64_t *w = witness; *w; w++) {
if (*w % n != 0 && !suspect(*w, d))
return false;
}
return true;
}
// miller_rabin & エラトステネス
bool prime(const int &n) {
assert(n < 9223372036854775808ULL);
if (!sz(primes))
setprime();
// エラトステネスの篩 偶数省略ver
//[i] = i*2+1
if (n < prime_len)
return era.prime(n);
if (n < 4294967296) {
rep(i, 30) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 7, 61, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t { return a * b % n; };
return miller_rabin(n, witness, modmul);
} else {
rep(i, 50) if (!(n % primes[i])) return false;
constexpr uint64_t witness[] = {2, 325, 9375, 28178,
450775, 9780504, 1795265022, 0};
auto modmul = [&](uint64_t a, uint64_t b) -> uint64_t {
return (uint64_t)((__uint128_t)a * b % n);
};
return miller_rabin(n, witness, modmul);
}
}
vi divisors(int v) {
vi res;
double lim = std::sqrt(v);
for (int i = 1; i <= lim; ++i) {
if (v % i == 0) {
res.pb(i);
// if (i != v / i)res.pb(v / i);
}
}
rer(i, sz(res) - 1) {
if (res[i] != v / res[i])
res.pb(v / res[i]);
}
return res;
}
vp factorization(int v) {
assert(v);
int tv = v;
vp res;
if (!sz(primes))
setprime();
for (auto &&p : primes) {
if (v % p == 0)
res.eb(p, 0);
while (v % p == 0) {
v /= p;
res.back().second++;
}
if (v == 1 || p * p > tv)
break;
}
if (v > 1)
res.eb(v, 1);
return res;
}
// 注意 gcdを取る間隔 i%10 が場合によってはtleを引き起こす
// うまくいかなかったら%1で動かすように変更した
vp rho(int v) {
assert(v);
if (v == 1)
return vp();
vi ret;
if (!sz(primes))
setprime();
int lim = 300; // 64bit
if (v < 4294967296)
lim = 80; // 32bit
else if (v < 281474976710656LL)
lim = 120; // 48bit
for (int i = 0; i < lim; i += 5) {
// v<=1の判定回数を減らせる分高速化できる事を期待している
while (v % primes[i] == 0)
ret.pb(primes[i]), v /= primes[i];
while (v % primes[i + 1] == 0)
ret.pb(primes[i + 1]), v /= primes[i + 1];
while (v % primes[i + 2] == 0)
ret.pb(primes[i + 2]), v /= primes[i + 2];
while (v % primes[i + 3] == 0)
ret.pb(primes[i + 3]), v /= primes[i + 3];
while (v % primes[i + 4] == 0)
ret.pb(primes[i + 4]), v /= primes[i + 4];
if (v <= 1) {
sort(ret); // 試し割りだけで終わった時
return run_length(ret);
}
}
int lower_prime_bound = primes[lim - 1] * primes[lim - 1];
// 試し割りするか
mt19937 mr;
mr.seed(clock());
int c;
auto fac = [&](int v, const int loop = 10) {
// if (v == 4)return 2ll; //試し割りで消えた
c = mr() % v;
int x = mr() % v;
int y = x;
int d = 1;
int lim = std::sqrt(v) + 2;
// brentによる改良 差分を一操作で求められる
for (int i = 1, mul = 1, next_2pow = 2; d == 1 && i <= lim; i++) {
if (i == next_2pow) {
y = x;
next_2pow <<= 1;
}
x = ((u128)x * x + c) % v;
mul = ((u128)mul * abs(x - y)) %
v; // ユークリッドの互除法と同じ原理で因数は保たれる
if (i % loop == 0) { // 10とかなんとか iによっては死ぬ
d = gcd(mul, v);
mul = 1;
}
}
if (d == v)
return -1ll;
return d;
};
queue<int> q;
q.push(v);
while (!q.empty()) {
int v = q.front();
q.pop();
if (prime(v)) {
ret.pb(v);
continue;
}
int d = -1;
// 基本loop回数10でやり、駄目なら1で
for (int i = 0; d == -1 && i < 5; i++)
d = fac(v, 10);
if (d == -1)
while (d == -1)
d = fac(v, 1);
int d2 = v / d;
rep(_, 2) {
if (d <= lower_prime_bound)
ret.pb(d);
else
q.push(d);
d = d2;
}
}
sort(ret);
return run_length(ret);
}
} // namespace pnumber_tools
using namespace pnumber_tools;
// 幾何 Pをcomplexとして扱う
template <class T, class U> bool eq(T a, U b) { return fabs(a - b) < eps; }
dou atan2(pd a) { return atan2(a.se, a.fi); }
dou angle(pd f, pd t) { return atan2(t.se - f.se, t.fi - f.fi); }
dou distance(pd a, pd b) { return hypot(a.fi - b.fi, a.se - b.se); }
// bを中心とするabcのtheta aからcにかけて時計回り
dou angle(pd a, pd b, pd c) {
dou ax = a.fi - b.fi;
dou ay = a.se - b.se;
dou cx = c.fi - b.fi;
dou cy = c.se - b.se;
double ret = atan2(cy, cx) - atan2(ay, ax);
if (ret < 0)
ret += 2 * PI;
return ret;
}
dou dot(pd a, pd b) { return a.fi * b.fi + a.se + b.se; }
dou cro(pd a, pd b) { return a.fi * b.se - a.se + b.fi; }
template <class T> struct edge {
int f, t;
T c;
int id;
int type;
edge(int f, int t, T c = 1, int id = -1, int ty = -1)
: f(f), t(t), c(c), id(id), type(ty) {}
bool operator<(const edge &b) const { return c < b.c; }
bool operator>(const edge &b) const { return c > b.c; }
};
template <class T> ostream &operator<<(ostream &os, edge<T> &e) {
os << e.f << " " << e.t << " " << e.c;
return os;
}
template <typename T> class graph {
protected:
vector<bool> _used;
public:
vector<vector<edge<T>>> g;
vector<edge<T>> edges;
int n;
graph(int n) : n(n) { g.resize(n), _used.resize(n); }
void clear() { g.clear(), edges.clear(); }
void resize(int n) {
this->n = n;
g.resize(n);
_used.resize(n);
}
int size() { return g.size(); }
vector<edge<T>> &operator[](int i) { return g[i]; }
virtual void add(int f, int t, T c, int id, int ty) = 0;
virtual bool used(edge<T> &e) = 0;
virtual bool used(int id) = 0;
virtual void del(edge<T> &e) = 0;
virtual void del(int id) = 0;
virtual void set_edges() = 0;
};
template <typename T = ll> class digraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
digraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid++;
g[f].emplace_back(f, t, c, id, ty);
edges.emplace_back(f, t, c, id, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <class T = int> class undigraph : public graph<T> {
public:
using graph<T>::g;
using graph<T>::n;
using graph<T>::edges;
using graph<T>::_used;
int eid = 0;
undigraph(int n) : graph<T>(n) {}
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("undigraph add");
deb(f, t, c, id, ty);
ole();
}
if (id == -1)
id = eid, eid += 2;
g[f].emplace_back(f, t, c, id, ty);
g[t].emplace_back(t, f, c, id + 1, ty);
edges.emplace_back(f, t, c, id, ty);
edges.emplace_back(t, f, c, id + 1, ty);
}
void add(edge<T> &e) {
int f = e.f, t = e.t, ty = e.type;
T c = e.c;
add(f, t, c, ty);
}
bool used(edge<T> &e) { return _used[e.id]; }
bool used(int id) { return _used[id]; }
void del(edge<T> &e) { _used[e.id] = _used[e.id ^ 1] = 1; }
void del(int id) { _used[id] = _used[id ^ 1] = 1; }
void set_edges() {
if (sz(edges))
return;
rep(i, n) fora(e, g[i]) edges.pb(e);
}
};
template <typename T> struct radixheap {
vector<pair<u64, T>> v[65];
u64 size, last;
radixheap() : size(0), last(0) {}
bool empty() const { return size == 0; }
inline int getbit(int a) { return a ? 64 - __builtin_clzll(a) : 0; }
void push(u64 key, const T &value) {
++size;
v[getbit(key ^ last)].emplace_back(key, value);
}
pair<u64, T> pop() {
if (v[0].empty()) {
int idx = 1;
while (v[idx].empty())
++idx;
last = min_element(begin(v[idx]), end(v[idx]))->first;
for (auto &p : v[idx])
v[getbit(p.first ^ last)].emplace_back(p);
v[idx].clear();
}
--size;
auto ret = v[0].back();
v[0].pop_back();
return ret;
}
};
vi dijkstra2(const graph<int> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
int initValue = MAX(int);
vi dis(g.n, initValue);
radixheap<int> q;
dis[s] = 0;
q.push(0, s);
while (!q.empty()) {
int nowc, i;
tie(nowc, i) = q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
int c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.push(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<T> dijkstra(const graph<T> &g, int s, int cant_arrive = -1) {
if (!(0 <= s && s < g.n)) {
debugline("dijkstra");
deb(s, g.n);
ole();
}
T initValue = MAX(T);
vector<T> dis(g.n, initValue);
priority_queue<pair<T, int>, vector<pair<T, int>>, greater<pair<T, int>>> q;
dis[s] = 0;
q.emplace(0, s);
while (q.size()) {
T nowc = q.top().fi;
int i = q.top().se;
q.pop();
if (dis[i] != nowc)
continue;
for (auto &&e : g.g[i]) {
int to = e.t;
T c = nowc + e.c;
if (dis[to] > c) {
dis[to] = c;
q.emplace(dis[to], to);
}
}
}
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
for (auto &&d : dis)
if (d == initValue)
d = -1;
return dis;
}
template <class T>
vector<vector<T>> warshall(const graph<T> &g, int cant_arrive = -1) {
int n = g.n;
vector<vector<T>> dis(n, vector<T>(n, linf));
rep(i, n) fora(e, g.g[i]) chmi(dis[e.f][e.t], e.c);
rep(i, n) dis[i][i] = 0;
rep(k, n) rep(i, n) rep(j, n) chmi(dis[i][j], dis[i][k] + dis[k][j]);
// 基本、たどり着かないなら-1
if (cant_arrive == -1)
rep(i, n) rep(j, n) if (dis[i][j] == linf) dis[i][j] = -1;
return dis;
}
template <class T = int> class tree : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
vi disv;
private:
bool never = 1;
int root = -1;
vi dep; // 到着した順の深さ
vi vis; // 到着した順
vi first; // 初めてiに到着した時
vector<int> bestt; // タイミングを持つ
int sn = 0; // seg木の底辺の長さ euler tourの長さ
void built() {
never = 0;
n = g.size();
// euler tour
disv.resize(n);
first.resize(n);
dep.resize(n * 2);
vis.resize(n * 2);
function<void(int, int, int, int &)> dfs = [&](int i, int p, int d,
int &k) {
first[i] = k;
vis[k] = i;
dep[k++] = d;
forg(gi, g[i]) {
if (t == p)
continue;
disv[t] = disv[i] + c;
dfs(t, i, d + 1, k);
vis[k] = i;
dep[k++] = d;
}
};
int k = 0;
dfs(root, -1, 0, k);
// rmq
sn = 1;
while (sn < n * 2)
sn <<= 1;
bestt.resize((sn << 1) - 1);
rep(i, k) bestt[i + sn - 1] = i; // 時間を持つ
rer(i, sn - 2) {
int lt = (i << 1) + 1, rt = (i << 1) + 2;
if (dep[bestt[lt]] < dep[bestt[rt]]) {
bestt[i] = bestt[lt];
} else {
bestt[i] = bestt[rt];
}
}
}
// 最小の深さを持つタイミングが知りたい
inline int lca_rmq(int l, int r) {
int midv = inf;
int midi = -1;
l += sn - 1;
r += sn - 1;
while (l < r) {
// 右なら、次に右上へ移動してしまうので
if (!(l & 1)) {
if (chmi(midv, dep[bestt[l]])) {
midi = bestt[l];
}
}
// 右なら、左を取らないと機会を逃す
if (!(r & 1)) {
if (chmi(midv, dep[bestt[r - 1]])) {
midi = bestt[r - 1];
}
}
l >>= 1;
r = (r - 1) >> 1;
}
return vis[midi];
}
public:
tree(int n, int root = 0) : undigraph<T>(n), root(root) {}
bool leaf(int v) { return sz(g[v]) == 1 && v != root; }
int lca(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
return lca_rmq(first[u], first[v] + 1);
}
int dis(int u, int v) {
if (never)
built();
if (first[u] > first[v])
swap(u, v);
int p = lca_rmq(first[u], first[v] + 1);
return disv[u] + disv[v] - disv[p] * 2;
}
};
// 辺によりメモリを大量消費
// よってedgesを消している
// 頂点10^6でメモリを190MB(制限の8割)使う
// 軽量化のため、辺を持たないbig gridクラスがあってもいいかもしれない
//
template <class T = int> class grid_k6 : public undigraph<T> {
public:
using undigraph<T>::g;
using undigraph<T>::n;
using undigraph<T>::edges;
using undigraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("grid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
g[t].emplace_back(t, f, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
grid_k6(int H, int W) : H(H), W(W), undigraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
grid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), undigraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
// 左上から右下に移動できる
template <class T = int> class digrid_k6 : public digraph<T> {
public:
using digraph<T>::g;
using digraph<T>::n;
using digraph<T>::edges;
using digraph<T>::_used;
int H, W;
int eid = 0;
void add(int f, int t, T c = 1, int id = -1, int ty = -1) {
if (!(0 <= f && f < n && 0 <= t && t < n)) {
debugline("digrid_k6 add");
deb(f, t, c, id, ty);
ole();
}
g[f].emplace_back(f, t, c, eid++, ty);
}
int getid(int h, int w) {
if (!inside(h, w, H, W))
return -1;
return W * h + w;
}
P get2(int id) { return mp(id / W, id % W); }
P operator()(int id) { return get2(id); }
int operator()(int h, int w) { return getid(h, w); }
digrid_k6(int H, int W) : H(H), W(W), digraph<T>(H * W) {
rep(h, H) {
rep(w, W) {
int f = getid(h, w);
if (w + 1 < W)
add(f, getid(h, w + 1));
if (h + 1 < H)
add(f, getid(h + 1, w));
}
}
}
digrid_k6(_vvc ba, char wall = '#')
: H(sz(ba)), W(sz(ba[0])), digraph<T>(sz(ba) * sz(ba[0])) {
rep(h, H) {
rep(w, W) {
if (ba[h][w] == wall)
con;
int f = getid(h, w);
if (w + 1 < W && ba[h][w + 1] != wall) {
add(f, getid(h, w + 1));
}
if (h + 1 < H && ba[h + 1][w] != wall) {
add(f, getid(h + 1, w));
}
}
}
}
void add(int fh, int fw, int th, int tw) {
add(getid(fh, fw), getid(th, tw));
}
void set_edges() { rep(i, n) fora(e, g[i]) edges.pb(e); }
};
template <class T> bool nibu(const graph<T> &g) {
int size = 0;
rep(i, g.n) size += sz(g.g[i]);
if (size == 0)
return true;
UnionFind uf(g.n * 2);
rep(i, g.n) fora(e, g.g[i]) uf.unite(e.f, e.t + g.n),
uf.unite(e.f + g.n, e.t);
rep(i, g.n) if (uf.same(i, i + g.n)) return 0;
return 1;
}
// 二部グラフを色分けした際の頂点数を返す
template <class T> vp nibug(graph<T> &g) {
vp cg;
if (!nibu(g)) {
debugline("nibu");
ole();
}
int _n = g.size();
vb _was(_n);
queue<P> q;
rep(i, _n) {
if (_was[i])
continue;
q.push(mp(i, 1));
_was[i] = 1;
int red = 0;
int coun = 0;
while (q.size()) {
int now = q.front().fi;
int col = q.front().se;
red += col;
coun++;
q.pop();
forg(gi, g[now]) {
if (_was[t])
continue;
q.push(mp(t, col ^ 1));
_was[t] = 1;
}
}
cg.push_back(mp(red, coun - red));
}
return cg;
}
template <class T> ostream &operator<<(ostream &os, graph<T> &g) {
rep(i, sz(g)) {
forg(gi, g[i]) { os << f << " " << t << " " << c << endl; }
}
return os;
}
// 機能拡張
vp vtop(vi &a, vi &b) {
vp res(sz(a));
rep(i, sz(a)) res[i] = mp(a[i], b[i]);
return res;
}
void ptov(vp &p, vi &a, vi &b) {
a.resize(sz(p));
b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs, const int __rv) {
__lhs += to_string(__rv);
}
template <typename _CharT, typename _Traits, typename _Alloc>
basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
__str.append(to_string(__rv));
return __str;
}
template <typename _CharT, typename _Traits, typename _Alloc>
void operator+=(basic_string<_CharT, _Traits, _Alloc> &__lhs,
const signed __rv) {
__lhs += to_string(__rv);
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<U> &v) {
fora(d, v) a.push(d);
return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T, class U> set<T> &operator+=(set<T> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.pb(v);
return a;
}
template <class T, class U> vector<T> operator+(const vector<T> &a, U v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(vector<T> a, vector<T> b) {
vector<T> ret;
ret = a;
fora(v, b) ret += v;
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, vector<T> &b) {
fora(v, b) a += v;
return a;
}
template <class T, class U>
vector<T> &operator+=(vector<T> &a, initializer_list<U> v) {
for (auto &&va : v)
a.pb(va);
return a;
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
ole();
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
template <typename T> void remove(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T>
void remove(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T>
void removen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T> void erase(vector<T> &v, unsigned int i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned int s, unsigned int e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <class T, class U> void erase(map<T, U> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, int okl, int ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T>
void erasen(vector<T> &v, unsigned int s, unsigned int n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T, typename U>
void insert(vector<T> &v, initializer_list<U> list) {
for (auto &&va : list)
v.pb(va);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned int i, initializer_list<U> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
template <typename T> void insert(set<T> &v, vector<T> list) {
for (auto &&va : list)
v.insert(va);
}
template <typename T> void insert(set<T> &v, initializer_list<T> list) {
for (auto &&va : list)
v.insert(va);
}
// 閉路がなければtrue
bool topo(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
queue<int> st;
rep(i, n) if (nyu[i] == 0) st.push(i);
while (st.size()) {
int v = st.front();
st.pop();
res.pb(v);
fora(e, g[v]) if (--nyu[e.t] == 0) st.push(e.t);
}
return res.size() == n;
}
// 辞書順最小トポロジカルソート
bool topos(vi &res, digraph<int> &g) {
int n = g.g.size();
vi nyu(n);
rep(i, n) for (auto &&e : g[i]) nyu[e.t]++;
// 小さい順
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) if (nyu[i] == 0) q.push(i);
while (q.size()) {
int i = q.top();
q.pop();
res.pb(i);
fora(e, g[i]) if (--nyu[e.t] == 0) q.push(e.t);
}
return res.size() == n;
}
vector<string> split(const string a, const char deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string a, const string deli) {
string b = a + deli;
int l = 0, r = 0, n = b.size(), dn = deli.size();
vector<string> res;
rep(i, n) {
if (i + dn <= n && b.substr(i, i + dn) == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
i += dn - 1;
l = i + 1;
}
}
return res;
}
void yn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void Yn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void YN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fyn(bool a) {
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
exit(0);
}
void fYn(bool a) {
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
exit(0);
}
void fYN(bool a) {
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
void Possible(bool a) {
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
int n, m, k, d, H, W, x, y, z, q;
int cou;
vi t, a, b, c;
// vvi (s, 0, 0);
vvc(ba, 0, 0);
vp p;
str s;
void solve() {
cin >> n >> m;
na(a, n);
na2(b, c, m);
rsortp(c, b);
priority_queue<int, vector<int>, greater<int>> q; // 小さい順
q += a;
rep(i, m) {
rep(j, b[i]) {
if (q.top() < c[i]) {
q.pop();
q += c[i];
} else {
break;
}
}
}
cout << sum(q) << endl;
}
int my(int n, vi &a) { return 0; }
int sister(int n, vi &a) {
int ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (int i = 0, ok = 1; i < k5 && ok; i++) {
int n = rand(1, 8);
vi a = ranv(n, 1, 10);
int myres = my(arg);
int res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "正解 : " << res << endl;
cerr << "自分 : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// cout << "完璧 : solveを書き直そう" << endl;
// cout << " : そして、solve()を呼び出すのだ" << endl;
// cout << " : cin>>n; na(a,n);も忘れるな" << endl;
}
#endif
return 0;
};
| replace | 3,621 | 3,622 | 3,621 | 3,622 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iterator>
#include <map>
#include <queue>
#include <vector>
using namespace std;
// 定义比较结构
struct cmp1 {
bool operator()(int &a, int &b) {
return a > b; // 最小值优先
}
};
std::priority_queue<int, vector<int>, cmp1> q; // 最小值优先
int n, m;
int a[100010];
struct Card {
int value;
int count;
};
Card cards[100010];
int r[100010];
bool compareCard(const Card &a, const Card &b) { return a.value > b.value; }
bool compare(const int &a, const int &b) { return a < b; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
scanf("%d", &(a[i]));
for (int i = 0; i < m; i++)
scanf("%d%d", &(cards[i].count), &(cards[i].value));
sort(cards, cards + m, compareCard);
int szR = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < cards[i].count; j++) {
r[szR] = cards[i].value;
szR++;
if (szR > n)
break;
// q.push(cards[i].value);
//
// if (q.size() >= n)
// break;
}
}
// int limit = q.size();
//
// for (int i = limit - 1 ; i >= 0 ; i--)
// {
// r[i] = q.top();
// q.pop();
// }
sort(a, a + n, compare);
// for (int i = 0 ; i < limit ; i++)
for (int i = 0; i < szR; i++) {
if (r[i] > a[i])
a[i] = r[i];
}
long long sum = 0;
for (int i = 0; i < n; i++)
sum = sum + a[i];
printf("%lld\n", sum);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iterator>
#include <map>
#include <queue>
#include <vector>
using namespace std;
// 定义比较结构
struct cmp1 {
bool operator()(int &a, int &b) {
return a > b; // 最小值优先
}
};
std::priority_queue<int, vector<int>, cmp1> q; // 最小值优先
int n, m;
int a[100010];
struct Card {
int value;
int count;
};
Card cards[100010];
int r[100010];
bool compareCard(const Card &a, const Card &b) { return a.value > b.value; }
bool compare(const int &a, const int &b) { return a < b; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
scanf("%d", &(a[i]));
for (int i = 0; i < m; i++)
scanf("%d%d", &(cards[i].count), &(cards[i].value));
sort(cards, cards + m, compareCard);
int szR = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < cards[i].count; j++) {
if (szR > n)
break;
r[szR] = cards[i].value;
szR++;
if (szR > n)
break;
// q.push(cards[i].value);
//
// if (q.size() >= n)
// break;
}
}
// int limit = q.size();
//
// for (int i = limit - 1 ; i >= 0 ; i--)
// {
// r[i] = q.top();
// q.pop();
// }
sort(a, a + n, compare);
// for (int i = 0 ; i < limit ; i++)
for (int i = 0; i < szR; i++) {
if (r[i] > a[i])
a[i] = r[i];
}
long long sum = 0;
for (int i = 0; i < n; i++)
sum = sum + a[i];
printf("%lld\n", sum);
return 0;
}
| insert | 49 | 49 | 49 | 52 | 0 | |
p03038 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
using namespace std;
const int mod = 1e9 + 7;
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
void run() {
int n, m;
cin >> n >> m;
vi a(n);
rep(i, n) cin >> a[i];
vp v;
rep(i, m) {
int b, c;
cin >> b >> c;
v.pb({c, b});
}
sort(all(a));
sort(all(v));
reverse(all(v));
int j = 0;
rep(i, n) {
if (a[i] < v[j].fi) {
a[i] = v[j].fi;
v[j].se--;
}
if (v[j].se == 0)
j++;
}
int ans = 0;
rep(i, n) ans += a[i];
cout << ans << endl;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, a, b) for (int i = a; i < b; i++)
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define rev(i, n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define pi pair<int, int>
#define vp vector<pair<int, int>>
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a, 0, sizeof(a))
#define inf (1ll << 60)
#define Yes(f) cout << (f ? "Yes" : "No") << endl
#define yes(f) cout << (f ? "yes" : "no") << endl
#define YES(f) cout << (f ? "YES" : "NO") << endl
using namespace std;
const int mod = 1e9 + 7;
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
}
signed main() {
init();
run();
return 0;
}
void run() {
int n, m;
cin >> n >> m;
vi a(n);
rep(i, n) cin >> a[i];
vp v;
rep(i, m) {
int b, c;
cin >> b >> c;
v.pb({c, b});
}
sort(all(a));
sort(all(v));
reverse(all(v));
int j = 0;
rep(i, n) {
if (j == v.size())
break;
if (a[i] < v[j].fi) {
a[i] = v[j].fi;
v[j].se--;
}
if (v[j].se == 0)
j++;
}
int ans = 0;
rep(i, n) ans += a[i];
cout << ans << endl;
}
| insert | 66 | 66 | 66 | 68 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (long long)(x).size()
#define sqr(x) (x) * (x)
#define sof sizeof
#define ins insert
#define lowerB lower_bound
#define upperB upper_bound
#define mkp make_pair
#define mod 1000000007
#define mod1 998244353
#define N (long long)sqrt(2e5 + 1)
#define inf 1e18
#define minf -1e18
#define min3(a, b, c) min(a, min(b, c));
#define max3(a, b, c) max(a, max(b, c));
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define FastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define PRECISION \
std::cout.unsetf(std::ios::floatfield); \
std::cout.precision(15)
#define PI M_PI
#define fi first
#define se second
#define here cout << "RSSB" << endl
#define showzero cout << std::showpoint
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a * b) / gcd(a, b)
#define br "\n"
using namespace std;
typedef double db;
typedef long long ll;
typedef vector<int> vi;
// typedef vector<l>vl ;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vstr;
typedef vector<bool> vbool;
/*vbool isprime(N,true);
vll spf(N,0);
vll prime;
void sieve()
{
isprime[0] = isprime[1] = false;
for(ll i = 2 ; i<N ; i++)
{
if(isprime[i])
{
for(ll j=2*i ; j<N ; j+=i)
{
isprime[j] = false;
if(spf[j]==0)
{
spf[j] = i;
}
}
prime.pb(i);
}
}
}*/
ll nck(ll n, ll k, ll m = 1e18 + 7) {
ll i, j, b = 1, c = 1;
if (n - k < k) {
k = n - k;
}
while (k) {
b *= n;
c *= k;
ll g = __gcd(b, c);
b /= g;
c /= g;
n--;
k--;
}
return (b);
}
long long power(long long k, long long n, long long m = mod) {
long long res = 1;
while (n) {
if (n % 2 != 0) {
res = (res * k) % m;
}
k = (k * k) % m;
n = n / 2;
}
return (res);
}
void READ(vll &v, ll n) {
ll a;
for (ll i = 0; i < n; i = i + 1) {
cin >> a;
v.pb(a);
}
}
void PRINT(vll &v, ll a = 0) {
// ll a ;
for (ll i = a; i < v.size(); i = i + 1) {
v[i] = max((ll)0, v[i]);
cout << v[i] << " ";
}
cout << "\n";
}
ll n, m, k;
int main() {
FastIO;
PRECISION;
ll a, b, c, d, e, i, j, t, x, y, z, x1, y1, z1, f;
// double p,q,r,u,w ;
char ch, chr;
string str, st, str2, str3;
// ll a1=0,a2=0,b1=0,b2=0,c1=0 ;
// cin>>str>>str1;
cin >> n >> m;
vll v;
READ(v, n);
sort(all(v));
set<ll> s;
map<ll, ll> mp;
for (i = 0; i < m; i++) {
cin >> a >> b;
s.ins(b);
mp[b] += a;
}
for (i = 0; i < n; i++) {
a = *s.rbegin();
b = v[i];
if (a > b) {
v[i] = a;
mp[a]--;
if (mp[a] == 0) {
s.erase(a);
}
}
}
cout << accumulate(all(v), (ll)0);
} | #include <bits/stdc++.h>
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (long long)(x).size()
#define sqr(x) (x) * (x)
#define sof sizeof
#define ins insert
#define lowerB lower_bound
#define upperB upper_bound
#define mkp make_pair
#define mod 1000000007
#define mod1 998244353
#define N (long long)sqrt(2e5 + 1)
#define inf 1e18
#define minf -1e18
#define min3(a, b, c) min(a, min(b, c));
#define max3(a, b, c) max(a, max(b, c));
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define FastIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define PRECISION \
std::cout.unsetf(std::ios::floatfield); \
std::cout.precision(15)
#define PI M_PI
#define fi first
#define se second
#define here cout << "RSSB" << endl
#define showzero cout << std::showpoint
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a * b) / gcd(a, b)
#define br "\n"
using namespace std;
typedef double db;
typedef long long ll;
typedef vector<int> vi;
// typedef vector<l>vl ;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vstr;
typedef vector<bool> vbool;
/*vbool isprime(N,true);
vll spf(N,0);
vll prime;
void sieve()
{
isprime[0] = isprime[1] = false;
for(ll i = 2 ; i<N ; i++)
{
if(isprime[i])
{
for(ll j=2*i ; j<N ; j+=i)
{
isprime[j] = false;
if(spf[j]==0)
{
spf[j] = i;
}
}
prime.pb(i);
}
}
}*/
ll nck(ll n, ll k, ll m = 1e18 + 7) {
ll i, j, b = 1, c = 1;
if (n - k < k) {
k = n - k;
}
while (k) {
b *= n;
c *= k;
ll g = __gcd(b, c);
b /= g;
c /= g;
n--;
k--;
}
return (b);
}
long long power(long long k, long long n, long long m = mod) {
long long res = 1;
while (n) {
if (n % 2 != 0) {
res = (res * k) % m;
}
k = (k * k) % m;
n = n / 2;
}
return (res);
}
void READ(vll &v, ll n) {
ll a;
for (ll i = 0; i < n; i = i + 1) {
cin >> a;
v.pb(a);
}
}
void PRINT(vll &v, ll a = 0) {
// ll a ;
for (ll i = a; i < v.size(); i = i + 1) {
v[i] = max((ll)0, v[i]);
cout << v[i] << " ";
}
cout << "\n";
}
ll n, m, k;
int main() {
FastIO;
PRECISION;
ll a, b, c, d, e, i, j, t, x, y, z, x1, y1, z1, f;
// double p,q,r,u,w ;
char ch, chr;
string str, st, str2, str3;
// ll a1=0,a2=0,b1=0,b2=0,c1=0 ;
// cin>>str>>str1;
cin >> n >> m;
vll v;
READ(v, n);
sort(all(v));
set<ll> s;
map<ll, ll> mp;
for (i = 0; i < m; i++) {
cin >> a >> b;
s.ins(b);
mp[b] += a;
}
for (i = 0; i < n; i++) {
if (sz(s) == 0) {
break;
}
a = *s.rbegin();
b = v[i];
if (a > b) {
v[i] = a;
mp[a]--;
if (mp[a] == 0) {
s.erase(a);
}
}
}
cout << accumulate(all(v), (ll)0);
} | insert | 133 | 133 | 133 | 136 | 0 | |
p03038 | Python | Time Limit Exceeded | import heapq
N, M = map(int, input().split())
A = list(map(int, input().split()))
change = []
for m in range(M):
B, C = map(int, input().split())
change.append((B, C))
change.sort(key=lambda x: -x[1])
change2 = []
for c in change:
change2.extend([c[1]] * c[0])
change2 = change2[:N]
heapq.heapify(A)
for c in change2:
x = heapq.heappop(A)
if x >= c:
# 先頭すでに十分大きい場合は抜ける
heapq.heappush(A, x)
break
else:
x = max(x, c)
heapq.heappush(A, x)
print(sum(A))
| import heapq
N, M = map(int, input().split())
A = list(map(int, input().split()))
change = []
for m in range(M):
B, C = map(int, input().split())
change.append((B, C))
change.sort(key=lambda x: -x[1])
change2 = []
for c in change:
change2.extend([c[1]] * c[0])
if len(change2) >= N:
change2 = change2[:N]
break
heapq.heapify(A)
for c in change2:
x = heapq.heappop(A)
if x >= c:
# 先頭すでに十分大きい場合は抜ける
heapq.heappush(A, x)
break
else:
x = max(x, c)
heapq.heappush(A, x)
print(sum(A))
| replace | 14 | 15 | 14 | 17 | TLE | |
p03038 | C++ | Time Limit Exceeded | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
map<int, int> mp;
priority_queue<l_l> q;
rep(i, n) {
cin >> a[i];
q.push(l_l(a[i], 1));
}
vector<int> b(m);
vector<int> c(m);
rep(i, m) cin >> b[i] >> c[i];
rep(i, m) { q.push(l_l(c[i], b[i])); }
ll ans = 0;
int cnt = 0;
while (cnt + q.top().second <= n) {
ans += q.top().first * q.top().second;
cnt += q.top().second;
q.pop();
}
ans += q.top().first * (n - cnt);
cout << ans << endl;
} | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
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;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
map<int, int> mp;
priority_queue<l_l> q;
rep(i, n) {
cin >> a[i];
q.push(l_l(a[i], 1));
}
vector<int> b(m);
vector<int> c(m);
rep(i, m) cin >> b[i] >> c[i];
rep(i, m) { q.push(l_l(c[i], b[i])); }
ll ans = 0;
int cnt = 0;
while (cnt + q.top().second <= n) {
ans += q.top().first * q.top().second;
cnt += q.top().second;
q.pop();
}
ans += q.top().first * (n - cnt);
cout << ans << endl;
} | replace | 0 | 1 | 0 | 1 | TLE | |
p03038 | C++ | Time Limit Exceeded | // #define _GLIBCXX_DEBUG
#include <algorithm>
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
using namespace std;
using Graph = vector<vector<int>>;
typedef long long ll;
const int mod = 1e+9 + 7;
int main() {
ll n, m;
cin >> n >> m;
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) {
ll a;
cin >> a;
q.push(a);
}
vector<vector<ll>> cng(m, vector<ll>(2));
rep(i, m) {
ll b, c;
cin >> b >> c;
cng[i][0] = c;
cng[i][1] = b;
}
sort(cng.begin(), cng.end());
rep(i, m) {
ll cnt = 0;
while (q.top() < cng[i][0]) {
q.pop();
q.push(cng[i][0]);
cnt++;
if (cnt == cng[i][1])
break;
}
}
ll ans = 0;
rep(i, n) {
ans += q.top();
q.pop();
}
cout << ans << endl;
}
| // #define _GLIBCXX_DEBUG
#include <algorithm>
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
using namespace std;
using Graph = vector<vector<int>>;
typedef long long ll;
const int mod = 1e+9 + 7;
int main() {
ll n, m;
cin >> n >> m;
priority_queue<int, vector<int>, greater<int>> q;
rep(i, n) {
ll a;
cin >> a;
q.push(a);
}
vector<vector<ll>> cng(m, vector<ll>(2));
rep(i, m) {
ll b, c;
cin >> b >> c;
cng[i][0] = c;
cng[i][1] = b;
}
sort(cng.begin(), cng.end());
reverse(cng.begin(), cng.end());
rep(i, m) {
ll cnt = 0;
while (q.top() < cng[i][0]) {
q.pop();
q.push(cng[i][0]);
cnt++;
if (cnt == cng[i][1])
break;
}
}
ll ans = 0;
rep(i, n) {
ans += q.top();
q.pop();
}
cout << ans << endl;
}
| insert | 27 | 27 | 27 | 28 | TLE | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MINF(a) memset(a, 0x3f, sizeof(a))
#define POW(n) (1LL << (n))
#define IN(i, a, b) (a <= i && i <= b)
using namespace std;
template <typename T> inline bool CHMIN(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool CHMAX(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline void SORT(T &a) { sort(ALL(a)); }
template <typename T> inline void REV(T &a) { reverse(ALL(a)); }
template <typename T> inline void UNI(T &a) {
sort(ALL(a));
a.erase(unique(ALL(a)), a.end());
}
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-10;
/* ----------------------------------------------------------------------------------------------------
*/
int N, M;
int A[100010];
pii p[100010];
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin >> N >> M;
REP(i, N) cin >> A[i];
sort(A, A + N);
REP(i, M) cin >> p[i].second >> p[i].first;
sort(p, p + M);
reverse(p, p + M);
vector<int> v;
REP(i, M) {
REP(j, p[i].second) {
v.push_back(p[i].first);
if (v.size() == N)
break;
}
if (v.size() == N)
break;
}
int ans = 0;
REP(i, N) ans += max(v[i], A[i]);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MINF(a) memset(a, 0x3f, sizeof(a))
#define POW(n) (1LL << (n))
#define IN(i, a, b) (a <= i && i <= b)
using namespace std;
template <typename T> inline bool CHMIN(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline bool CHMAX(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> inline void SORT(T &a) { sort(ALL(a)); }
template <typename T> inline void REV(T &a) { reverse(ALL(a)); }
template <typename T> inline void UNI(T &a) {
sort(ALL(a));
a.erase(unique(ALL(a)), a.end());
}
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-10;
/* ----------------------------------------------------------------------------------------------------
*/
int N, M;
int A[100010];
pii p[100010];
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin >> N >> M;
REP(i, N) cin >> A[i];
sort(A, A + N);
REP(i, M) cin >> p[i].second >> p[i].first;
sort(p, p + M);
reverse(p, p + M);
vector<int> v;
REP(i, M) {
REP(j, p[i].second) {
v.push_back(p[i].first);
if (v.size() == N)
break;
}
if (v.size() == N)
break;
}
int ans = 0;
REP(i, N) {
if (i < v.size())
ans += max(v[i], A[i]);
else
ans += A[i];
}
cout << ans << endl;
return 0;
} | replace | 64 | 65 | 64 | 70 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
vector<int> b(m), c(m);
for (int j = 0; j < m; j++) {
cin >> b.at(j) >> c.at(j);
}
int l = accumulate(b.begin(), b.end(), 0);
vector<pair<int, int>> pairs(m);
for (int j = 0; j < m; j++) {
pairs[j] = make_pair(c.at(j), b.at(j));
}
// firstが小さい順、secondが小さい順にソート
sort(pairs.begin(), pairs.end());
reverse(pairs.begin(), pairs.end());
// for(int j = 0; j < m; j++) {
// cout << pairs[j].first << endl;
// }
int i = 0;
int flag = 0;
for (int j = 0; j < m; j++) {
for (int k = 0; k < pairs[j].second; k++) {
if (a.at(i) > pairs[j].first) {
flag = 1;
++i;
break;
} else {
a.at(i) = pairs[j].first;
++i;
}
}
if (flag == 1) {
break;
}
}
long long s = accumulate(a.begin(), a.end(), 0LL);
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
vector<int> b(m), c(m);
for (int j = 0; j < m; j++) {
cin >> b.at(j) >> c.at(j);
}
int l = accumulate(b.begin(), b.end(), 0);
vector<pair<int, int>> pairs(m);
for (int j = 0; j < m; j++) {
pairs[j] = make_pair(c.at(j), b.at(j));
}
// firstが小さい順、secondが小さい順にソート
sort(pairs.begin(), pairs.end());
reverse(pairs.begin(), pairs.end());
// for(int j = 0; j < m; j++) {
// cout << pairs[j].first << endl;
// }
int i = 0;
int flag = 0;
for (int j = 0; j < m; j++) {
for (int k = 0; k < pairs[j].second; k++) {
if (i == n) {
flag = 1;
break;
}
if (a.at(i) > pairs[j].first) {
flag = 1;
++i;
break;
} else {
a.at(i) = pairs[j].first;
++i;
}
}
if (flag == 1) {
break;
}
}
long long s = accumulate(a.begin(), a.end(), 0LL);
cout << s << endl;
} | insert | 30 | 30 | 30 | 34 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, sum;
cin >> n >> m;
priority_queue<long long, vector<long long>, greater<long long>> a;
vector<long long> b(m), c(m);
vector<pair<long long, long long>> bc(m);
for (i = 0; i < n; ++i) {
long long z;
cin >> z;
a.push(z);
}
for (i = 0; i < m; ++i) {
cin >> b[i] >> c[i];
bc[i] = make_pair(c[i], b[i]);
}
sort(bc.begin(), bc.end());
for (i = 0; i < m; ++i) {
j = 0;
long long hi;
hi = a.top();
while (j < bc[i].second && hi < bc[i].first) {
a.pop();
a.push(bc[i].first);
hi = a.top();
++j;
}
}
sum = 0;
while (!a.empty()) {
sum += a.top();
a.pop();
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, sum;
cin >> n >> m;
priority_queue<long long, vector<long long>, greater<long long>> a;
vector<long long> b(m), c(m);
vector<pair<long long, long long>> bc(m);
for (i = 0; i < n; ++i) {
long long z;
cin >> z;
a.push(z);
}
for (i = 0; i < m; ++i) {
cin >> b[i] >> c[i];
bc[i] = make_pair(c[i], b[i]);
}
sort(bc.begin(), bc.end(), greater<>());
for (i = 0; i < m; ++i) {
j = 0;
long long hi;
hi = a.top();
while (j < bc[i].second && hi < bc[i].first) {
a.pop();
a.push(bc[i].first);
hi = a.top();
++j;
}
}
sum = 0;
while (!a.empty()) {
sum += a.top();
a.pop();
}
cout << sum << endl;
return 0;
}
| replace | 18 | 19 | 18 | 19 | TLE | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = (1 << 28);
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
int n, m;
ll a[100000];
vector<pair<ll, int>> b;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++) {
int t;
ll t1;
cin >> t >> t1;
b.push_back(make_pair(t1, t));
}
sort(a, a + n);
sort(b.begin(), b.end());
int ch = 0;
for (int i = m - 1; i >= 0; i--) {
if (a[n - 1] < b[i].first && b[i].second + ch - 1 > n - 1) {
for (int j = ch; j < n; j++) {
a[j] = b[i].first;
}
break;
}
if (a[b[i].second + ch - 1] < b[i].first) {
for (int j = ch; j < b[i].second + ch; j++) {
a[j] = b[i].first;
}
ch = b[i].second + ch;
} else {
bool c = true;
int k = ch;
while (c && k < n) {
if (a[k] < b[i].first) {
a[k] = b[i].first;
k++;
} else {
c = false;
}
}
break;
}
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << "\n";
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = (1 << 28);
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
int n, m;
ll a[100000];
vector<pair<ll, int>> b;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < m; i++) {
int t;
ll t1;
cin >> t >> t1;
b.push_back(make_pair(t1, t));
}
sort(a, a + n);
sort(b.begin(), b.end());
int ch = 0;
for (int i = m - 1; i >= 0; i--) {
if (a[n - 1] < b[i].first && b[i].second + ch - 1 > n - 1) {
for (int j = ch; j < n; j++) {
a[j] = b[i].first;
}
break;
}
if (a[min(n - 1, b[i].second + ch - 1)] < b[i].first) {
for (int j = ch; j < min(n, b[i].second + ch); j++) {
a[j] = b[i].first;
}
ch = b[i].second + ch;
} else {
bool c = true;
int k = ch;
while (c && k < n) {
if (a[k] < b[i].first) {
a[k] = b[i].first;
k++;
} else {
c = false;
}
}
break;
}
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans << "\n";
} | replace | 59 | 61 | 59 | 61 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define sz(a) int(a.size())
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int &t : a)
cin >> t;
vector<pair<int, int>> cb(m);
for (auto &t : cb) {
int &c = t.first, &b = t.second;
cin >> b >> c;
}
sort(rbegin(cb), rend(cb));
vector<int> cur;
for (auto t : cb) {
int c = t.first, b = t.second;
while (sz(cur) < n && b--)
cur.push_back(c);
}
sort(begin(a), end(a));
long long ans = 0;
for (int i = 0; i < n; i++)
ans += max(cur[i], a[i]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define sz(a) int(a.size())
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int &t : a)
cin >> t;
vector<pair<int, int>> cb(m);
for (auto &t : cb) {
int &c = t.first, &b = t.second;
cin >> b >> c;
}
sort(rbegin(cb), rend(cb));
vector<int> cur;
for (auto t : cb) {
int c = t.first, b = t.second;
while (sz(cur) < n && b--)
cur.push_back(c);
}
while (sz(cur) < n)
cur.push_back(0);
sort(begin(a), end(a));
long long ans = 0;
for (int i = 0; i < n; i++)
ans += max(cur[i], a[i]);
cout << ans << endl;
}
| insert | 26 | 26 | 26 | 28 | 0 | |
p03038 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
const ll infll = 9223372036854775806;
const int inf = 2147483646;
int main() {
// freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
ll i, j, k, n, m, a[100000], t, ans = 0, b1, c1;
cin >> n >> m;
vector<pair<int, int>> b;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> b1 >> c1;
b.push_back(make_pair(c1, b1));
}
sort(a, a + n);
sort(b.begin(), b.end());
t = m - 1;
for (i = 0; i < n; i++) {
if (b[t].second == 0) {
t--;
}
if (t >= 0 && b[t].first > a[i]) {
ans += b[t].first;
b[t].second--;
} else {
ans += a[i];
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
const ll infll = 9223372036854775806;
const int inf = 2147483646;
int main() {
// freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
ll i, j, k, n, m, a[100000], t, ans = 0, b1, c1;
cin >> n >> m;
vector<pair<int, int>> b;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> b1 >> c1;
b.push_back(make_pair(c1, b1));
}
sort(a, a + n);
sort(b.begin(), b.end());
t = m - 1;
for (i = 0; i < n; i++) {
if (t >= 0 && b[t].second == 0) {
t--;
}
if (t >= 0 && b[t].first > a[i]) {
ans += b[t].first;
b[t].second--;
} else {
ans += a[i];
}
}
cout << ans;
return 0;
} | replace | 27 | 28 | 27 | 28 | 0 | |
p03038 | C++ | Runtime Error | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
bool my_compare(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first) {
return a.first > b.first;
}
if (a.second != b.second) {
return a.second > b.second;
} else {
return true;
}
}
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> CB(M);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++) {
cin >> CB[i].second >> CB[i].first;
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end(), my_compare);
ll cur_min = A[0], cur_min_idx = 0, replace_size, replace_num;
for (int i = 0; i < M; i++) {
replace_size = CB[i].second;
replace_num = CB[i].first;
if (cur_min < replace_num) {
ll upper =
(cur_min_idx + replace_size < N) ? cur_min_idx + replace_size : N;
for (int j = cur_min_idx; j < upper && A[j] < replace_num; j++) {
A[j] = replace_num;
}
if (upper == N)
break;
cur_min_idx = upper;
cur_min = A[cur_min_idx];
} else {
break;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
bool my_compare(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first != b.first) {
return a.first > b.first;
}
if (a.second != b.second) {
return a.second > b.second;
} else {
return false;
}
}
int main() {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
vector<pair<ll, ll>> CB(M);
for (int i = 0; i < N; i++)
cin >> A[i];
for (int i = 0; i < M; i++) {
cin >> CB[i].second >> CB[i].first;
}
sort(A.begin(), A.end());
sort(CB.begin(), CB.end(), my_compare);
ll cur_min = A[0], cur_min_idx = 0, replace_size, replace_num;
for (int i = 0; i < M; i++) {
replace_size = CB[i].second;
replace_num = CB[i].first;
if (cur_min < replace_num) {
ll upper =
(cur_min_idx + replace_size < N) ? cur_min_idx + replace_size : N;
for (int j = cur_min_idx; j < upper && A[j] < replace_num; j++) {
A[j] = replace_num;
}
if (upper == N)
break;
cur_min_idx = upper;
cur_min = A[cur_min_idx];
} else {
break;
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p03038 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve(long long N, long long M, std::vector<long long> A,
std::vector<long long> B, std::vector<long long> C) {
vector<pair<ll, ll>> BC;
for (ll i = 0; i < M; ++i) {
BC.emplace_back(B[i], C[i]);
}
sort(begin(BC), end(BC),
[](auto &&a, auto &&b) { return a.second > b.second; });
sort(begin(A), end(A));
ll w_idx = 0;
for (auto &&bc : BC) {
for (ll i = 0; i < bc.first && w_idx < (ll)A.size(); ++i) {
if (A[w_idx] < bc.second) {
A[w_idx] = bc.second;
w_idx++;
}
}
}
ll ans = accumulate(begin(A), end(A), 0LL);
cout << ans << "\n";
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
// clang-format off
int main(){
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(false);
long long N;
scanf("%lld",&N);
long long M;
scanf("%lld",&M);
std::vector<long long> A(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&A[i]);
}
std::vector<long long> B(M);
std::vector<long long> C(M);
for(int i = 0 ; i < M ; i++){
scanf("%lld",&B[i]);
scanf("%lld",&C[i]);
}
solve(N, M, std::move(A), std::move(B), std::move(C));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve(long long N, long long M, std::vector<long long> A,
std::vector<long long> B, std::vector<long long> C) {
vector<pair<ll, ll>> BC;
for (ll i = 0; i < M; ++i) {
BC.emplace_back(B[i], C[i]);
}
sort(begin(BC), end(BC),
[](auto &&a, auto &&b) { return a.second > b.second; });
sort(begin(A), end(A));
ll w_idx = 0;
for (auto &&bc : BC) {
for (ll i = 0; i < bc.first && w_idx < (ll)A.size() && A[w_idx] < bc.second;
++i) {
A[w_idx] = bc.second;
w_idx++;
}
}
ll ans = accumulate(begin(A), end(A), 0LL);
cout << ans << "\n";
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
// clang-format off
int main(){
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(false);
long long N;
scanf("%lld",&N);
long long M;
scanf("%lld",&M);
std::vector<long long> A(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&A[i]);
}
std::vector<long long> B(M);
std::vector<long long> C(M);
for(int i = 0 ; i < M ; i++){
scanf("%lld",&B[i]);
scanf("%lld",&C[i]);
}
solve(N, M, std::move(A), std::move(B), std::move(C));
return 0;
}
| replace | 16 | 21 | 16 | 20 | TLE | |
p03038 | Python | Runtime Error | """
解説を参考に作成 その3
"""
def solve():
N, M = map(int, input().split())
A = [int(i) for i in input().split()]
A.sort()
CB = [list(reversed([int(i) for i in input().split()])) for _ in range(M)]
CB = list(sorted(CB, reverse=True))
count = 0
flag = False
for cb in CB:
for b in range(cb[1]):
if A[count] < cb[0]:
A[count] = cb[0]
else:
flag = True
break
count += 1
if flag:
break
print(sum(A))
if __name__ == "__main__":
solve()
| """
解説を参考に作成 その3
"""
def solve():
N, M = map(int, input().split())
A = [int(i) for i in input().split()]
A.sort()
CB = [list(reversed([int(i) for i in input().split()])) for _ in range(M)]
CB = list(sorted(CB, reverse=True))
count = 0
flag = False
for cb in CB:
for b in range(cb[1]):
if A[count] < cb[0]:
A[count] = cb[0]
else:
flag = True
break
count += 1
if count >= N:
flag = True
break
if flag:
break
print(sum(A))
if __name__ == "__main__":
solve()
| insert | 22 | 22 | 22 | 26 | 0 | |
p03038 | Python | Runtime Error | n, m = map(int, input().split())
a_list = list(map(int, input().split()))
bc_list = [list(map(int, input().split())) for _ in range(m)]
a_list.sort()
bc_list.sort(key=lambda i: -i[1])
a_idx = 0
bc_idx = 0
while bc_idx < len(bc_list):
b, c = bc_list[bc_idx]
finish = False
for _ in range(b):
if c > a_list[a_idx]:
a_list[a_idx] = c
a_idx += 1
else:
finish = True
break
if finish:
break
bc_idx += 1
print(sum(a_list))
| n, m = map(int, input().split())
a_list = list(map(int, input().split()))
bc_list = [list(map(int, input().split())) for _ in range(m)]
a_list.sort()
bc_list.sort(key=lambda i: -i[1])
a_idx = 0
bc_idx = 0
while bc_idx < len(bc_list):
b, c = bc_list[bc_idx]
finish = False
for _ in range(b):
if a_idx >= len(a_list):
finish = True
break
if c > a_list[a_idx]:
a_list[a_idx] = c
a_idx += 1
else:
finish = True
break
if finish:
break
bc_idx += 1
print(sum(a_list))
| insert | 12 | 12 | 12 | 15 | 0 | |
p03038 | Python | Time Limit Exceeded | N, M = [int(i) for i in input().strip().split()]
A = [int(i) for i in input().strip().split()]
A.sort()
for i in range(M):
B, C = [int(i) for i in input().strip().split()]
is_changed = False
for j in range(0, B):
if A[j] < C:
A[j] = C
is_changed = True
else:
break
if is_changed:
A.sort()
print(sum(A))
| N, M = [int(i) for i in input().strip().split()]
A = [int(i) for i in input().strip().split()]
A.sort()
BC = [[0, 0] for _ in range(M)]
for j in range(M):
BC[j][0], BC[j][1] = [int(i) for i in input().strip().split()]
BC.sort(key=lambda x: x[1])
res = 0
cnt = 0
i = N - 1
j = M - 1
while True:
if cnt == N:
break
if j == -1:
res += A[i]
i -= 1
elif A[i] > BC[j][1]:
res += A[i]
i -= 1
elif A[i] <= BC[j][1]:
res += BC[j][1]
BC[j][0] -= 1
if BC[j][0] == 0:
j -= 1
else:
raise ValueError
cnt += 1
print(res)
| replace | 3 | 15 | 3 | 32 | TLE | |
p03038 | Python | Runtime Error | #!/usr/bin/env python3
N, M = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))
B = []
C = []
for _ in range(M):
b, c = map(int, input().rstrip().split())
B.append(b)
C.append(c)
Index = sorted(range(M), key=lambda i: C[i], reverse=True)
sum = 0
A.sort()
for index in Index:
if A[0] >= C[index]:
break
count = 0
i = 0
while True:
if i >= len(A):
break
if A[i] < C[index] and count < B[index]:
sum += C[index]
A.pop(i)
# print(A)
count += 1
continue
if A[i] >= C[index] or count >= B[index]:
break
i += 1
if A:
for a in A:
sum += a
print(sum)
| #!/usr/bin/env python3
N, M = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))
B = []
C = []
for _ in range(M):
b, c = map(int, input().rstrip().split())
B.append(b)
C.append(c)
Index = sorted(range(M), key=lambda i: C[i], reverse=True)
sum = 0
A.sort()
for index in Index:
if A and A[0] >= C[index]:
break
count = 0
i = 0
while True:
if i >= len(A):
break
if A[i] < C[index] and count < B[index]:
sum += C[index]
A.pop(i)
# print(A)
count += 1
continue
if A[i] >= C[index] or count >= B[index]:
break
i += 1
if A:
for a in A:
sum += a
print(sum)
| replace | 16 | 17 | 16 | 17 | 0 | |
p03038 | Python | Time Limit Exceeded | import heapq
N, M = map(int, input().split())
A_LIST = list(map(int, input().split()))
BC_LIST = []
heapq.heapify(A_LIST)
for i in range(M):
b, c = map(int, input().split())
BC_LIST.append([b, c])
BC_LIST.sort(reverse=True, key=lambda x: x[1]) # C降順にソート
for b, c in BC_LIST:
for _ in range(b):
tmp = heapq.heappop(A_LIST)
heapq.heappush(A_LIST, max(tmp, c))
print(sum(A_LIST))
| import heapq
N, M = map(int, input().split())
A_LIST = list(map(int, input().split()))
BC_LIST = []
heapq.heapify(A_LIST)
for i in range(M):
b, c = map(int, input().split())
BC_LIST.append([b, c])
BC_LIST.sort(reverse=True, key=lambda x: x[1]) # C降順にソート
for b, c in BC_LIST:
for _ in range(b):
tmp = heapq.heappop(A_LIST)
if tmp < c:
heapq.heappush(A_LIST, c)
else:
heapq.heappush(A_LIST, tmp)
break
print(sum(A_LIST))
| replace | 13 | 14 | 13 | 18 | TLE | |
p03038 | Python | Runtime Error | n, m = map(int, input().split())
a = list(map(int, input().split()))
bc = [0] * m
ans = []
a.sort()
for i in range(m):
bc[i] = list(map(int, input().split()))
bc.sort(key=lambda x: x[1], reverse=True)
j = 0
for i in range(n):
if bc[j][0] == 0:
j += 1
if j >= m:
ans.append(a[i])
elif a[i] >= bc[j][1]:
ans.append(a[i])
else:
ans.append(bc[j][1])
bc[j][0] -= 1
print(sum(ans))
| n, m = map(int, input().split())
a = list(map(int, input().split()))
bc = [0] * m
ans = []
a.sort()
for i in range(m):
bc[i] = list(map(int, input().split()))
bc.sort(key=lambda x: x[1], reverse=True)
j = 0
for i in range(n):
if j < m:
if bc[j][0] == 0:
j += 1
if j >= m:
ans.append(a[i])
elif a[i] >= bc[j][1]:
ans.append(a[i])
else:
ans.append(bc[j][1])
bc[j][0] -= 1
print(sum(ans))
| replace | 12 | 14 | 12 | 15 | 0 | |
p03038 | Python | Time Limit Exceeded | import sys
input = sys.stdin.readline
N, M = map(int, input().split())
A = list(map(int, input().split()))
op = [list(map(int, input().split())) for _ in range(M)]
cards = sorted(A)
op.sort(key=lambda x: -x[1])
i = 0
for m in range(M):
b, c = op[m]
for _ in range(b):
if cards[i] < c:
cards[i] = c
i += 1
if i >= N:
break
else:
continue
break
print(sum(cards))
| import sys
input = sys.stdin.readline
N, M = map(int, input().split())
A = list(map(int, input().split()))
op = [list(map(int, input().split())) for _ in range(M)]
cards = sorted(A)
op.sort(key=lambda x: -x[1])
i = 0
for m in range(M):
b, c = op[m]
for _ in range(b):
if cards[i] < c:
cards[i] = c
i += 1
if i >= N:
break
else:
break
else:
continue
break
print(sum(cards))
| replace | 19 | 20 | 19 | 22 | TLE | |
p03038 | Python | Runtime Error | import sys
import operator
n, m = map(int, input().split())
a = [int(x) for x in sys.stdin.readline().rstrip().split()]
a.sort()
cards = [[int(x) for x in sys.stdin.readline().rstrip().split()] for _ in range(m)]
cards.sort(key=operator.itemgetter(1), reverse=True)
a_idx = 0
a_len = len(a)
for b, c in cards:
if c <= a[a_idx] or a_idx == a_len:
break
for b_idx in range(b):
if a_idx == a_len or c <= a[a_idx]:
break
else:
a[a_idx] = c
a_idx += 1
print(sum(a))
| import sys
import operator
n, m = map(int, input().split())
a = [int(x) for x in sys.stdin.readline().rstrip().split()]
a.sort()
cards = [[int(x) for x in sys.stdin.readline().rstrip().split()] for _ in range(m)]
cards.sort(key=operator.itemgetter(1), reverse=True)
a_idx = 0
a_len = len(a)
for b, c in cards:
if a_idx == a_len:
break
for b_idx in range(b):
if a_idx == a_len or c <= a[a_idx]:
break
else:
a[a_idx] = c
a_idx += 1
print(sum(a))
| replace | 15 | 16 | 15 | 16 | 0 | |
p03038 | Python | Time Limit Exceeded | import heapq
N, M = map(int, input().split())
A = list(map(int, input().split()))
heapq.heapify(A)
B = []
C = []
CB = []
for _ in range(M):
b, c = map(int, input().split())
B.append(b)
C.append(c)
CB.append((c, b))
CB.sort()
for c, b in CB:
for j in range(b):
tmp = heapq.heappop(A)
if tmp >= c:
heapq.heappush(A, tmp)
break
else:
heapq.heappush(A, c)
print(sum(A))
| import heapq
N, M = map(int, input().split())
A = list(map(int, input().split()))
heapq.heapify(A)
B = []
C = []
CB = []
for _ in range(M):
b, c = map(int, input().split())
B.append(b)
C.append(c)
CB.append((c, b))
CB.sort(reverse=True)
for c, b in CB:
for j in range(b):
tmp = heapq.heappop(A)
if tmp >= c:
heapq.heappush(A, tmp)
break
else:
heapq.heappush(A, c)
print(sum(A))
| replace | 13 | 14 | 13 | 14 | TLE | |
p03038 | Python | Time Limit Exceeded | N, M = map(int, input().split())
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
A.sort()
BC.sort(key=lambda bc: bc[1], reverse=True)
update_bc = [0 for _ in range(N)]
cnt = 0
for b, c in BC:
for i in range(b):
if cnt < N:
update_bc[cnt] = c
cnt += 1
for i in range(N):
if A[i] < update_bc[i]:
A[i] = update_bc[i]
else:
break
print(sum(A))
| N, M = map(int, input().split())
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(M)]
A.sort()
BC.sort(key=lambda bc: bc[1], reverse=True)
update_bc = [0 for _ in range(N)]
cnt = 0
for b, c in BC:
for i in range(b):
if cnt < N:
update_bc[cnt] = c
cnt += 1
else:
break
if cnt >= N:
break
for i in range(N):
if A[i] < update_bc[i]:
A[i] = update_bc[i]
else:
break
print(sum(A))
| insert | 14 | 14 | 14 | 18 | TLE | |
p03038 | Python | Runtime Error | n, m = map(int, input().split())
a = list(map(int, input().split()))
bc = []
for _ in range(m):
b, c = map(int, input().split())
bc.append([b, c])
a.sort()
bc.sort(reverse=True, key=lambda x: x[1])
cnt = 0
for i in range(m):
for j in range(bc[i][0]):
if bc[i][1] > a[cnt]:
a[cnt] = bc[i][1]
if cnt == n:
break
cnt += 1
else:
break
print(sum(a))
| n, m = map(int, input().split())
a = list(map(int, input().split()))
bc = []
for _ in range(m):
b, c = map(int, input().split())
bc.append([b, c])
a.sort()
bc.sort(reverse=True, key=lambda x: x[1])
cnt = 0
for i in range(m):
for j in range(bc[i][0]):
if bc[i][1] > a[cnt]:
a[cnt] = bc[i][1]
if cnt == n - 1:
break
cnt += 1
else:
break
print(sum(a))
| replace | 13 | 14 | 13 | 14 | 0 | |
p03038 | Python | Time Limit Exceeded | from sys import stdin
N, M = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) for x in stdin.readline().rstrip().split()]
BC = [[int(x) for x in stdin.readline().rstrip().split()] for _ in range(M)]
BC.sort(key=lambda x: x[1], reverse=True)
for i in range(M):
A = A + [BC[i][1]] * BC[i][0]
if len(A) >= 2 * N:
break
A.sort(reverse=True)
print(sum(A[:N]))
| from sys import stdin
N, M = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) for x in stdin.readline().rstrip().split()]
BC = [[int(x) for x in stdin.readline().rstrip().split()] for _ in range(M)]
BC.sort(key=lambda x: x[1], reverse=True)
for i in range(M):
A.extend([BC[i][1]] * BC[i][0])
if len(A) >= 2 * N:
break
A.sort(reverse=True)
print(sum(A[:N]))
| replace | 7 | 8 | 7 | 8 | TLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.