結果

問題 No.2921 Seated in Classroom
ユーザー 👑 bo9chanbo9chan
提出日時 2024-10-30 21:42:49
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 151 ms / 2,000 ms
コード長 45,743 bytes
コンパイル時間 2,387 ms
コンパイル使用メモリ 176,888 KB
実行使用メモリ 6,820 KB
最終ジャッジ日時 2024-10-30 21:42:53
合計ジャッジ時間 4,195 ms
ジャッジサーバーID
(参考情報)
judge2 / judge3
このコードへのチャレンジ
(要ログイン)

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 134 ms
6,820 KB
testcase_01 AC 80 ms
6,816 KB
testcase_02 AC 60 ms
6,820 KB
testcase_03 AC 151 ms
6,816 KB
testcase_04 AC 86 ms
6,816 KB
testcase_05 AC 2 ms
6,816 KB
testcase_06 AC 2 ms
6,816 KB
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#ifdef __LOCAL
#include <mytemplate.hpp> // ~/local/include/mytemplate.hpp.gch
#else
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#endif
using namespace std;
// #pragma GCC target "no-avx" // gcc12.2boost使
// #include <boost/multiprecision/cpp_int.hpp>
// using bint = boost::multiprecision::cpp_int;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
using vc = vector<char>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
template <class T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
#define REP1(i, n) REP3(i, 0, n, 1)
#define REP2(i, s, n) REP3(i, s, n, 1)
#define REP3(i, s, n, d) for (ll i = (ll)(s); i < (ll)(n); i += (d))
#define REP_OVERLOAD(e1, e2, e3, e4, NAME, ...) NAME
#define rep(...) REP_OVERLOAD(__VA_ARGS__, REP3, REP2, REP1)(__VA_ARGS__)
#define DEP1(i, n) DEP3(i, n, -1, 1)
#define DEP2(i, n, s) DEP3(i, n, s, 1)
#define DEP3(i, n, s, d) for (ll i = (ll)(n); (ll)(s) < i; i -= (d))
#define DEP_OVERLOAD(e1, e2, e3, e4, NAME, ...) NAME
#define dep(...) DEP_OVERLOAD(__VA_ARGS__, DEP3, DEP2, DEP1)(__VA_ARGS__)
#define fore(e, a) for (auto&& e : (a))
#define len(a) (ll)(a).size()
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define th third
#define fo fourth
/********* C O N S T A N T **********/
constexpr ll INF = LONG_LONG_MAX / 2 - 10000LL; // 4,611,686,018,427,377,903 ~= 4.6e+18, 19
const double PI = acos(-1);
/********* 1 2 8 b i t **********/
using int128 = __int128_t;
istream& operator>>(istream& stream, int128& val);
ostream& operator<<(ostream& stream, const int128& val_);
/********* P A I R **********/
// + -
template <class T, class U> pair<T, U> operator+(pair<T, U> a);
template <class T, class U> pair<T, U> operator-(pair<T, U> a);
//
template <class T, class U> pair<T, U>& operator+=(pair<T, U>& a, const pair<T, U> b);
template <class T, class U> pair<T, U>& operator-=(pair<T, U>& a, const pair<T, U> b);
template <class T, class U> pair<T, U>& operator*=(pair<T, U>& a, const pair<T, U> b);
template <class T, class U> pair<T, U>& operator/=(pair<T, U>& a, const pair<T, U> b);
template <class T, class U> pair<T, U>& operator%=(pair<T, U>& a, const pair<T, U> b);
template <class T, class U, class V> pair<T, U>& operator+=(pair<T, U>& a, const V b);
template <class T, class U, class V> pair<T, U>& operator-=(pair<T, U>& a, const V b);
template <class T, class U, class V> pair<T, U>& operator*=(pair<T, U>& a, const V b);
template <class T, class U, class V> pair<T, U>& operator/=(pair<T, U>& a, const V b);
template <class T, class U, class V> pair<T, U>& operator%=(pair<T, U>& a, const V b);
//
template <class T, class U, class V> pair<T, U> operator+(pair<T, U> a, const V& b);
template <class T, class U, class V> pair<T, U> operator-(pair<T, U> a, const V& b);
template <class T, class U, class V> pair<T, U> operator*(pair<T, U> a, const V& b);
template <class T, class U, class V> pair<T, U> operator/(pair<T, U> a, const V& b);
template <class T, class U, class V> pair<T, U> operator%(pair<T, U> a, const V& b);
//
template <class T, class U> istream& operator>>(istream& stream, pair<T, U>& a);
template <class T, class U> ostream& operator<<(ostream& stream, const pair<T, U>& a);
/********* V E C T O R **********/
// + -
template <class T> vector<T> operator+(vector<T> a);
template <class T> vector<T> operator-(vector<T> a);
//
template <class T> vector<T>& operator+=(vector<T>& a, const vector<T> b);
template <class T> vector<T>& operator-=(vector<T>& a, const vector<T> b);
template <class T> vector<T>& operator*=(vector<T>& a, const vector<T> b);
template <class T> vector<T>& operator/=(vector<T>& a, const vector<T> b);
template <class T> vector<T>& operator%=(vector<T>& a, const vector<T> b);
template <class T, class U> vector<T>& operator+=(vector<T>& a, const U b);
template <class T, class U> vector<T>& operator-=(vector<T>& a, const U b);
template <class T, class U> vector<T>& operator*=(vector<T>& a, const U b);
template <class T, class U> vector<T>& operator/=(vector<T>& a, const U b);
template <class T, class U> vector<T>& operator%=(vector<T>& a, const U b);
//
template <class T, class U> vector<T> operator+(vector<T> a, const U& b);
template <class T, class U> vector<T> operator-(vector<T> a, const U& b);
template <class T, class U> vector<T> operator*(vector<T> a, const U& b);
template <class T, class U> vector<T> operator/(vector<T> a, const U& b);
template <class T, class U> vector<T> operator%(vector<T> a, const U& b);
//
template <class T> istream& operator>>(istream& stream, vector<T>& a);
template <class T> ostream& operator<<(ostream& stream, const vector<T>& v);
template <class T> ostream& operator<<(ostream& stream, const vector<vector<T>>& vv);
//
template <class T> T Sum(const vector<T>& v);
template <class T> T Max(const vector<T>& v);
template <class T> T Min(const vector<T>& v);
template <class T> ll Argmax(const vector<T>& v);
template <class T> ll Argmin(const vector<T>& v);
template <class T, class U> bool Contains(const vector<T>& v, const U& a);
template <class T> void Unique(vector<T>& v);
//
template <class T, class U> vector<T> make_vector(int n, U v);
template <class T, class... Args> auto make_vector(int n, Args... args) {
auto val = make_vector<T>(args...);
return make_vector<decltype(val)>(n, move(val));
}
/********* S E T **********/
template <class T> istream& operator>>(istream& stream, set<T>& st);
template <class T> ostream& operator<<(ostream& stream, const set<T>& st);
template <class T> T Max(const set<T>& st);
template <class T> T Min(const set<T>& st);
/********* M U L T I S E T **********/
template <class T> istream& operator>>(istream& stream, multiset<T>& st);
template <class T> ostream& operator<<(ostream& stream, const multiset<T>& st);
template <class T> T Max(const multiset<T>& st);
template <class T> T Min(const multiset<T>& st);
template <class T> bool EraseOne(multiset<T>& st, const T& x);
/********* C H A R **********/
bool IsUpper(const char& c);
bool IsLower(const char& c);
char ToUpper(const char& c);
char ToLower(const char& c);
/********* S T R I N G **********/
string ToUpper(const string& s);
string ToLower(const string& s);
bool IsPalindrome(const string& S);
/********* T R I O **********/
template <class T1, class T2, class T3> struct trio {
T1 first;
T2 second;
T3 third;
//
trio();
trio(const T1& x);
trio(const T1& x, const T2& y, const T3& z);
trio(const trio& t);
trio& operator=(const trio& t);
//
bool operator<(const trio& t) const;
bool operator==(const trio& t) const;
bool operator!=(const trio& t) const;
bool operator>(const trio& t) const;
bool operator<=(const trio& t) const;
bool operator>=(const trio& t) const;
// + -
trio operator+() const;
trio operator-() const;
//
template <class U1, class U2, class U3> friend istream& operator>>(istream&, trio<U1, U2, U3>&);
template <class U1, class U2, class U3> friend ostream& operator<<(ostream&, const trio<U1, U2, U3>&);
// `tie(a, b, c) = tll{3, 5, 7}`
operator tuple<T1&, T2&, T3&>() {
return tie(first, second, third);
}
};
//
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b);
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b);
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b);
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b);
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const U b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const U b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const U b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const U b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const U b);
//
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator+(trio<T1, T2, T3> a, const U& b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator-(trio<T1, T2, T3> a, const U& b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator*(trio<T1, T2, T3> a, const U& b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator/(trio<T1, T2, T3> a, const U& b);
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator%(trio<T1, T2, T3> a, const U& b);
using tll = trio<ll, ll, ll>;
/********* Q U A R T E T **********/
template <class T1, class T2, class T3, class T4> struct quartet {
T1 first;
T2 second;
T3 third;
T4 fourth;
//
quartet();
quartet(const T1& x);
quartet(const T1& x, const T2& y, const T3& z, const T4& w);
quartet(const quartet& t);
quartet& operator=(const quartet& t);
//
bool operator<(const quartet& t) const;
bool operator==(const quartet& t) const;
bool operator!=(const quartet& other) const;
bool operator>(const quartet& other) const;
bool operator<=(const quartet& other) const;
bool operator>=(const quartet& other) const;
// + -
quartet operator+() const;
quartet operator-() const;
//
template <class U1, class U2, class U3, class U4>
friend istream& operator>>(istream&, quartet<U1, U2, U3, U4>&);
template <class U1, class U2, class U3, class U4>
friend ostream& operator<<(ostream&, const quartet<U1, U2, U3, U4>&);
// `tie(a, b, c, d) = qll{3, 5, 7, 9}`
operator tuple<T1&, T2&, T3&, T4&>() {
return tie(first, second, third, fourth);
}
};
//
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b);
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b);
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b);
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b);
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const U b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const U b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const U b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const U b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const U b);
//
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator+(quartet<T1, T2, T3, T4> a, const U& b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator-(quartet<T1, T2, T3, T4> a, const U& b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator*(quartet<T1, T2, T3, T4> a, const U& b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator/(quartet<T1, T2, T3, T4> a, const U& b);
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator%(quartet<T1, T2, T3, T4> a, const U& b);
using qll = quartet<ll, ll, ll, ll>;
/********* R A N D O M **********/
struct Random {
mt19937_64 rnd;
Random();
Random(ll seed);
ll randint(ll a, ll b);
double randreal(double a, double b);
char randchar(char a, char b);
template <class T> void shuffle(vector<T>& vec);
};
/********* T I M E R **********/
struct Timer {
int time_limit;
int start_time;
Timer(double time_limit_sec);
bool is_time_up() const;
double get_elapsed_ratio() const;
};
/********* P R I N T **********/
template <class T> void print(const T& e);
template <class H, class... T> void print(const H& h, const T&... t);
template <class... T> void End(const T&... t);
/********* D E B U G **********/
#ifdef __LOCAL
#define debug(...) \
if (DEBUG) do { \
cout << '[' << #__VA_ARGS__ << "] "; \
debug_(__VA_ARGS__); \
} while (0)
#else
#define debug(...)
#endif
void dbg_(const long long& e);
template <class T> void dbg_(const T& e);
template <class T, class U> void dbg_(const pair<T, U>& p);
template <class T1, class T2, class T3> void dbg_(const trio<T1, T2, T3>& t);
template <class T1, class T2, class T3, class T4> void dbg_(const quartet<T1, T2, T3, T4>& t);
template <class T> void debug_(const T& e);
template <class T> void debug_(const vector<T>& v);
template <class T> void debug_(const vector<vector<T>>& vv);
template <class T, class U> void debug_(const map<T, U>& mp);
template <class T, class U> void debug_(const vector<map<T, U>>& vm);
template <class T> void debug_(const set<T>& st);
template <class T> void debug_(const multiset<T>& st);
template <class T> void debug_(const vector<set<T>>& vs);
template <class T> void debug_(const vector<multiset<T>>& vs);
template <class H, class... T> void debug_(const H& h, const T&... t);
/********* O T H E R S **********/
template <class T, class U> bool chmin(T& a, U b);
template <class T, class U> bool chmax(T& a, U b);
template <class T, class U> T Mod(const T& a, const U& m);
template <class T, class U> T Ceil(const T& x, const U& y);
template <class T, class U> T Floor(const T& x, const U& y);
template <class T> ll Sign(const T& x);
ll Isqrt(ll n);
ll Comb(ll n, ll r);
template <class T> T Pow(T x, ll n);
template <class T> T Pow(T x, ll n, T mod);
template <class T> T Aseries(T a, T d, ll n);
template <class T> T Gseries(T a, T r, ll n);
bool Bit(ll b, int i);
ll Popcount(ll b);
ll Mask(ll n);
ll Mask(ll n, ll m);
pll GetOverlap(ll l1, ll r1, ll l2, ll r2);
bool IsOverlap(ll l1, ll r1, ll l2, ll r2);
void PrintYesNo(bool b);
/********* M O D **********/
// #include <atcoder/modint> // https://atcoder.github.io/ac-library/production/document_ja/
// using namespace atcoder;
// using mint = modint998244353; // modint1000000007;
// istream& operator >>(istream& stream, mint& e) {ll n; stream >> n; e = n; return stream; }
// ostream& operator <<(ostream& stream, const mint& e) { stream << e.val(); return stream; }
// using vm = vector<mint>;
// using vvm = vector<vm>;
/***************************************/
constexpr bool DEBUG = true;
int main() {
cin.tie(nullptr);
cout << fixed << setprecision(10);
ll T;
cin >> T;
rep(t, T) {
ll N, M;
cin >> N >> M;
ll ans = Ceil(N, 4);
M -= 4 * ans + (4 - N % 4) % 4;
if (M > 0) ans += Ceil(M, 8);
print(ans);
}
}
/********* 1 2 8 b i t *********/
// 128bit. LONG_LONG_MAX/LONG_LONG_MINOK.
istream& operator>>(istream& stream, int128& val) {
string s;
stream >> s;
assert(s.size() > 0);
val = 0;
bool is_minus = false;
for (int i = 0; i < (int)s.size(); i++) {
if (i == 0 && s[i] == '-') {
assert(s.size() > 1);
is_minus = true;
} else {
assert('0' <= s[i] && s[i] <= '9');
val *= 10;
val += s[i] - '0';
}
}
if (is_minus) val *= -1;
return stream;
}
// 128bit.
ostream& operator<<(ostream& stream, const int128& val_) {
auto val(val_);
if (val == 0) return stream << 0;
if (val < 0) {
stream << '-';
val *= -1;
}
string s;
while (val > 0) {
s += (val % 10) + '0';
val /= 10;
}
reverse(all(s));
return stream << s;
}
/********* P A I R **********/
/* + - */
template <class T, class U> pair<T, U> operator+(pair<T, U> a) {
return a;
}
template <class T, class U> pair<T, U> operator-(pair<T, U> a) {
return a * (-1);
}
/* (pair) */
template <class T, class U> pair<T, U>& operator+=(pair<T, U>& a, const pair<T, U> b) {
a.fi += b.fi;
a.se += b.se;
return a;
}
template <class T, class U> pair<T, U>& operator-=(pair<T, U>& a, const pair<T, U> b) {
a.fi -= b.fi;
a.se -= b.se;
return a;
}
template <class T, class U> pair<T, U>& operator*=(pair<T, U>& a, const pair<T, U> b) {
a.fi *= b.fi;
a.se *= b.se;
return a;
}
template <class T, class U> pair<T, U>& operator/=(pair<T, U>& a, const pair<T, U> b) {
a.fi /= b.fi;
a.se /= b.se;
return a;
}
template <class T, class U> pair<T, U>& operator%=(pair<T, U>& a, const pair<T, U> b) {
a.fi %= b.fi;
a.se %= b.se;
return a;
}
template <class T, class U, class V> pair<T, U>& operator+=(pair<T, U>& a, const V b) {
a.fi += b;
a.se += b;
return a;
}
template <class T, class U, class V> pair<T, U>& operator-=(pair<T, U>& a, const V b) {
a.fi -= b;
a.se -= b;
return a;
}
template <class T, class U, class V> pair<T, U>& operator*=(pair<T, U>& a, const V b) {
a.fi *= b;
a.se *= b;
return a;
}
template <class T, class U, class V> pair<T, U>& operator/=(pair<T, U>& a, const V b) {
a.fi /= b;
a.se /= b;
return a;
}
template <class T, class U, class V> pair<T, U>& operator%=(pair<T, U>& a, const V b) {
a.fi %= b;
a.se %= b;
return a;
}
/* (pair) */
template <class T, class U, class V> pair<T, U> operator+(pair<T, U> a, const V& b) {
return a += b;
}
template <class T, class U, class V> pair<T, U> operator-(pair<T, U> a, const V& b) {
return a -= b;
}
template <class T, class U, class V> pair<T, U> operator*(pair<T, U> a, const V& b) {
return a *= b;
}
template <class T, class U, class V> pair<T, U> operator/(pair<T, U> a, const V& b) {
return a /= b;
}
template <class T, class U, class V> pair<T, U> operator%(pair<T, U> a, const V& b) {
return a %= b;
}
//
template <class T, class U> istream& operator>>(istream& stream, pair<T, U>& a) {
stream >> a.fi >> a.se;
return stream;
}
template <class T, class U> ostream& operator<<(ostream& stream, const pair<T, U>& a) {
stream << a.fi << " " << a.se;
return stream;
}
/********* V E C T O R **********/
/* + - */
template <class T> vector<T> operator+(vector<T> a) {
return a;
}
template <class T> vector<T> operator-(vector<T> a) {
return a * (-1);
}
/* (vector) */
template <class T> vector<T>& operator+=(vector<T>& a, const vector<T> b) {
assert(a.size() == b.size());
rep(i, 0, a.size()) a[i] += b[i];
return a;
}
template <class T> vector<T>& operator-=(vector<T>& a, const vector<T> b) {
assert(a.size() == b.size());
rep(i, 0, a.size()) a[i] -= b[i];
return a;
}
template <class T> vector<T>& operator*=(vector<T>& a, const vector<T> b) {
assert(a.size() == b.size());
rep(i, 0, a.size()) a[i] *= b[i];
return a;
}
template <class T> vector<T>& operator/=(vector<T>& a, const vector<T> b) {
assert(a.size() == b.size());
rep(i, 0, a.size()) a[i] /= b[i];
return a;
}
template <class T> vector<T>& operator%=(vector<T>& a, const vector<T> b) {
assert(a.size() == b.size());
rep(i, 0, a.size()) a[i] %= b[i];
return a;
}
template <class T, class U> vector<T>& operator+=(vector<T>& a, const U b) {
fore(e, a) e += b;
return a;
}
template <class T, class U> vector<T>& operator-=(vector<T>& a, const U b) {
fore(e, a) e -= b;
return a;
}
template <class T, class U> vector<T>& operator*=(vector<T>& a, const U b) {
fore(e, a) e *= b;
return a;
}
template <class T, class U> vector<T>& operator/=(vector<T>& a, const U b) {
fore(e, a) e /= b;
return a;
}
template <class T, class U> vector<T>& operator%=(vector<T>& a, const U b) {
fore(e, a) e %= b;
return a;
}
/* (vector) */
template <class T, class U> vector<T> operator+(vector<T> a, const U& b) {
return a += b;
}
template <class T, class U> vector<T> operator-(vector<T> a, const U& b) {
return a -= b;
}
template <class T, class U> vector<T> operator*(vector<T> a, const U& b) {
return a *= b;
}
template <class T, class U> vector<T> operator/(vector<T> a, const U& b) {
return a /= b;
}
template <class T, class U> vector<T> operator%(vector<T> a, const U& b) {
return a %= b;
}
/* (vector) */
//
template <class T> istream& operator>>(istream& stream, vector<T>& a) {
fore(e, a) stream >> e;
return stream;
}
//
template <class T> ostream& operator<<(ostream& stream, const vector<T>& v) {
if (v.size()) {
stream << v[0];
rep(i, 1, v.size()) cout << " " << v[i];
}
return stream;
}
// 2/
template <class T> ostream& operator<<(ostream& stream, const vector<vector<T>>& vv) {
if (vv.size()) {
stream << vv[0];
rep(i, 1, vv.size()) cout << '\n' << vv[i];
}
return stream;
}
/* (vector) */
// v.size() == 0 T()
template <class T> T Sum(const vector<T>& v) {
return reduce(all(v));
}
template <class T> T Max(const vector<T>& v) {
assert(v.size());
return *max_element(all(v));
}
template <class T> T Min(const vector<T>& v) {
assert(v.size());
return *min_element(all(v));
}
// 0-origin, O(N).
template <class T> ll Argmax(const vector<T>& v) {
assert(v.size());
return max_element(all(v)) - v.begin();
}
// 0-origin, O(N).
template <class T> ll Argmin(const vector<T>& v) {
assert(v.size());
return min_element(all(v)) - v.begin();
}
// `a``v`1
template <class T, class U> bool Contains(const vector<T>& v, const U& a) {
return find(all(v), a) != v.end();
}
// inplace, O(NlogN).
template <class T> void Unique(vector<T>& v) {
sort(all(v));
v.erase(unique(all(v)), v.end());
}
/* (vector) */
template <class T, class U> vector<T> make_vector(int n, U v) {
return vector<T>(n, v);
}
/********* S E T **********/
//
template <class T> istream& operator>>(istream& stream, set<T>& st) {
T e;
stream >> e;
st.insert(e);
return stream;
}
//
template <class T> ostream& operator<<(ostream& stream, const set<T>& st) {
if (st.size()) {
auto it = st.begin();
stream << *it++;
for (; it != st.end(); it++)
cout << " " << *it;
}
return stream;
}
template <class T> T Max(const set<T>& st) {
assert(st.size());
return *prev(st.end());
}
template <class T> T Min(const set<T>& st) {
assert(st.size());
return *st.begin();
}
/********* M U L T I S E T **********/
//
template <class T> istream& operator>>(istream& stream, multiset<T>& st) {
T e;
stream >> e;
st.insert(e);
return stream;
}
//
template <class T> ostream& operator<<(ostream& stream, const multiset<T>& st) {
if (st.size()) {
auto it = st.begin();
stream << *it++;
for (; it != st.end(); it++)
cout << " " << *it;
}
return stream;
}
template <class T> T Max(const multiset<T>& st) {
assert(st.size());
return *prev(st.end());
}
template <class T> T Min(const multiset<T>& st) {
assert(st.size());
return *st.begin();
}
// x1. true.
template <class T> bool EraseOne(multiset<T>& st, const T& x) {
auto it = st.find(x);
if (it != st.end()) {
st.erase(it);
return true;
} else return false;
}
/********* C H A R **********/
//
bool IsUpper(const char& c) {
return isupper(c) > 0;
}
//
bool IsLower(const char& c) {
return islower(c) > 0;
}
//
char ToUpper(const char& c) {
string s{c}, t;
t.resize(s.size());
std::transform(all(s), t.begin(), ::toupper);
return t[0];
}
//
char ToLower(const char& c) {
string s{c}, t;
t.resize(s.size());
std::transform(all(s), t.begin(), ::tolower);
return t[0];
}
/********* S T R I N G **********/
//
string ToUpper(const string& s) {
string t;
t.resize(s.size());
std::transform(all(s), t.begin(), ::toupper);
return t;
}
//
string ToLower(const string& s) {
string t;
t.resize(s.size());
std::transform(all(s), t.begin(), ::tolower);
return t;
}
// , O(N). True.
bool IsPalindrome(const string& S) {
ll N = len(S);
for (ll i = 0; 2 * i < N; i++)
if (S[i] != S[N - i - 1]) return false;
return true;
}
/********* T R I O **********/
//
template <class T1, class T2, class T3> trio<T1, T2, T3>::trio() {
first = T1();
second = T2();
third = T3();
}
template <class T1, class T2, class T3> trio<T1, T2, T3>::trio(const T1& x) : first(x), second(x), third(x) {}
template <class T1, class T2, class T3>
trio<T1, T2, T3>::trio(const T1& x, const T2& y, const T3& z) : first(x), second(y), third(z) {}
template <class T1, class T2, class T3> trio<T1, T2, T3>::trio(const trio& t) {
first = t.first;
second = t.second;
third = t.third;
}
template <class T1, class T2, class T3> trio<T1, T2, T3>& trio<T1, T2, T3>::operator=(const trio& t) {
first = t.first;
second = t.second;
third = t.third;
return *this;
}
// (trio)
template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator<(const trio& t) const {
return tie(first, second, third) < tie(t.first, t.second, t.third);
}
template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator==(const trio& t) const {
return tie(first, second, third) == tie(t.first, t.second, t.third);
}
template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator!=(const trio& t) const {
return !(*this == t);
}
template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator>(const trio& t) const {
return t < *this;
}
template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator<=(const trio& t) const {
return !(*this > t);
}
template <class T1, class T2, class T3> bool trio<T1, T2, T3>::operator>=(const trio& t) const {
return !(*this < t);
}
// + - (trio)
template <class T1, class T2, class T3> trio<T1, T2, T3> trio<T1, T2, T3>::operator+() const {
return *this;
}
template <class T1, class T2, class T3> trio<T1, T2, T3> trio<T1, T2, T3>::operator-() const {
return (*this) * (-1);
}
// (trio)
template <class T1, class T2, class T3> istream& operator>>(istream& stream, trio<T1, T2, T3>& t) {
return stream >> t.first >> t.second >> t.third;
}
template <class T1, class T2, class T3> ostream& operator<<(ostream& stream, const trio<T1, T2, T3>& t) {
return stream << t.first << " " << t.second << " " << t.third;
}
/* (trio) */
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) {
a.fi += b.fi;
a.se += b.se;
a.th += b.th;
return a;
}
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) {
a.fi -= b.fi;
a.se -= b.se;
a.th -= b.th;
return a;
}
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) {
a.fi *= b.fi;
a.se *= b.se;
a.th *= b.th;
return a;
}
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) {
a.fi /= b.fi;
a.se /= b.se;
a.th /= b.th;
return a;
}
template <class T1, class T2, class T3>
trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const trio<T1, T2, T3> b) {
a.fi %= b.fi;
a.se %= b.se;
a.th %= b.th;
return a;
}
template <class T1, class T2, class T3, class U>
trio<T1, T2, T3>& operator+=(trio<T1, T2, T3>& a, const U b) {
a.fi += b;
a.se += b;
a.th += b;
return a;
}
template <class T1, class T2, class T3, class U>
trio<T1, T2, T3>& operator-=(trio<T1, T2, T3>& a, const U b) {
a.fi -= b;
a.se -= b;
a.th -= b;
return a;
}
template <class T1, class T2, class T3, class U>
trio<T1, T2, T3>& operator*=(trio<T1, T2, T3>& a, const U b) {
a.fi *= b;
a.se *= b;
a.th *= b;
return a;
}
template <class T1, class T2, class T3, class U>
trio<T1, T2, T3>& operator/=(trio<T1, T2, T3>& a, const U b) {
a.fi /= b;
a.se /= b;
a.th /= b;
return a;
}
template <class T1, class T2, class T3, class U>
trio<T1, T2, T3>& operator%=(trio<T1, T2, T3>& a, const U b) {
a.fi %= b;
a.se %= b;
a.th %= b;
return a;
}
/* (trio) */
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator+(trio<T1, T2, T3> a, const U& b) {
return a += b;
}
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator-(trio<T1, T2, T3> a, const U& b) {
return a -= b;
}
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator*(trio<T1, T2, T3> a, const U& b) {
return a *= b;
}
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator/(trio<T1, T2, T3> a, const U& b) {
return a /= b;
}
template <class T1, class T2, class T3, class U> trio<T1, T2, T3> operator%(trio<T1, T2, T3> a, const U& b) {
return a %= b;
}
/********* Q U A R T E T **********/
//
template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>::quartet() {
first = T1();
second = T2();
third = T3();
fourth = T4();
}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>::quartet(const T1& x) : first(x), second(x), third(x), fourth(x) {}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>::quartet(const T1& x, const T2& y, const T3& z, const T4& w)
: first(x), second(y), third(z), fourth(w) {}
template <class T1, class T2, class T3, class T4> quartet<T1, T2, T3, T4>::quartet(const quartet& t) {
first = t.first;
second = t.second;
third = t.third;
fourth = t.fourth;
}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& quartet<T1, T2, T3, T4>::operator=(const quartet& t) {
first = t.first;
second = t.second;
third = t.third;
fourth = t.fourth;
return *this;
}
// (quartet)
template <class T1, class T2, class T3, class T4>
bool quartet<T1, T2, T3, T4>::operator<(const quartet& t) const {
return tie(first, second, third, fourth) < tie(t.first, t.second, t.third, t.fourth);
}
template <class T1, class T2, class T3, class T4>
bool quartet<T1, T2, T3, T4>::operator==(const quartet& t) const {
return tie(first, second, third, fourth) == tie(t.first, t.second, t.third, t.fourth);
}
template <class T1, class T2, class T3, class T4>
bool quartet<T1, T2, T3, T4>::operator!=(const quartet& t) const {
return !(*this == t);
}
template <class T1, class T2, class T3, class T4>
bool quartet<T1, T2, T3, T4>::operator>(const quartet& t) const {
return t < *this;
}
template <class T1, class T2, class T3, class T4>
bool quartet<T1, T2, T3, T4>::operator<=(const quartet& t) const {
return !(*this > t);
}
template <class T1, class T2, class T3, class T4>
bool quartet<T1, T2, T3, T4>::operator>=(const quartet& t) const {
return !(*this < t);
}
// + - (quartet)
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4> quartet<T1, T2, T3, T4>::operator+() const {
return *this;
}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4> quartet<T1, T2, T3, T4>::operator-() const {
return (*this) * (-1);
}
// (quartet)
template <class T1, class T2, class T3, class T4>
istream& operator>>(istream& stream, quartet<T1, T2, T3, T4>& t) {
return stream >> t.first >> t.second >> t.third >> t.fourth;
}
template <class T1, class T2, class T3, class T4>
ostream& operator<<(ostream& stream, const quartet<T1, T2, T3, T4>& t) {
return stream << t.first << " " << t.second << " " << t.third << " " << t.fourth;
}
/* (quartet) */
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) {
a.fi += b.fi;
a.se += b.se;
a.th += b.th;
a.fo += b.fo;
return a;
}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) {
a.fi -= b.fi;
a.se -= b.se;
a.th -= b.th;
a.fo -= b.fo;
return a;
}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) {
a.fi *= b.fi;
a.se *= b.se;
a.th *= b.th;
a.fo *= b.fo;
return a;
}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) {
a.fi /= b.fi;
a.se /= b.se;
a.th /= b.th;
a.fo /= b.fo;
return a;
}
template <class T1, class T2, class T3, class T4>
quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const quartet<T1, T2, T3, T4> b) {
a.fi %= b.fi;
a.se %= b.se;
a.th %= b.th;
a.fo %= b.fo;
return a;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator+=(quartet<T1, T2, T3, T4>& a, const U b) {
a.fi += b;
a.se += b;
a.th += b;
a.fo += b;
return a;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator-=(quartet<T1, T2, T3, T4>& a, const U b) {
a.fi -= b;
a.se -= b;
a.th -= b;
a.fo -= b;
return a;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator*=(quartet<T1, T2, T3, T4>& a, const U b) {
a.fi *= b;
a.se *= b;
a.th *= b;
a.fo *= b;
return a;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator/=(quartet<T1, T2, T3, T4>& a, const U b) {
a.fi /= b;
a.se /= b;
a.th /= b;
a.fo /= b;
return a;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4>& operator%=(quartet<T1, T2, T3, T4>& a, const U b) {
a.fi %= b;
a.se %= b;
a.th %= b;
a.fo %= b;
return a;
}
/* (quartet) */
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator+(quartet<T1, T2, T3, T4> a, const U& b) {
return a += b;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator-(quartet<T1, T2, T3, T4> a, const U& b) {
return a -= b;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator*(quartet<T1, T2, T3, T4> a, const U& b) {
return a *= b;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator/(quartet<T1, T2, T3, T4> a, const U& b) {
return a /= b;
}
template <class T1, class T2, class T3, class T4, class U>
quartet<T1, T2, T3, T4> operator%(quartet<T1, T2, T3, T4> a, const U& b) {
return a %= b;
}
/********* R A N D O M **********/
// : seed
Random::Random() {
random_device seed_gen;
rnd.seed(seed_gen());
}
// : seed
Random::Random(ll seed) {
rnd.seed(seed);
}
// [a, b]
ll Random::randint(ll a, ll b) {
uniform_int_distribution<ll> dist(a, b);
return dist(rnd);
}
// [a, b]
double Random::randreal(double a, double b) {
uniform_real_distribution<double> dist(a, b);
return dist(rnd);
}
// [a, b]
char Random::randchar(char a, char b) {
uniform_int_distribution<ll> dist(a, b);
return dist(rnd);
}
// `vec`inplace
template <class T> void Random::shuffle(vector<T>& vec) {
std::shuffle(all(vec), rnd);
}
/********* T I M E R **********/
// :
Timer::Timer(double time_limit_sec) {
assert(time_limit_sec > 0);
this->time_limit = time_limit_sec * CLOCKS_PER_SEC;
this->start_time = clock();
}
//
bool Timer::is_time_up() const {
return clock() - this->start_time >= this->time_limit;
}
// [0.0, 1.0]
double Timer::get_elapsed_ratio() const {
double ratio = 1.0 * (clock() - this->start_time) / (this->time_limit - this->start_time);
return min(1.0, ratio);
}
/********* P R I N T **********/
template <class T> void print(const T& e) {
cout << e << '\n';
}
template <class H, class... T> void print(const H& h, const T&... t) {
cout << h << ' ';
print(t...);
}
template <class... T> void End(const T&... t) {
print(t...);
exit(0);
}
/********* D E B U G *********/
void dbg_(const long long& e) {
if (e == INF) cout << "INF";
else if (e == -INF) cout << "-INF";
else cout << e;
}
template <class T> void dbg_(const T& e) {
cout << e;
}
template <class T, class U> void dbg_(const pair<T, U>& p) {
cout << '(';
dbg_(p.first);
cout << ' ';
dbg_(p.second);
cout << ')';
}
template <class T1, class T2, class T3> void dbg_(const trio<T1, T2, T3>& t) {
cout << '(';
dbg_(t.first);
cout << ' ';
dbg_(t.second);
cout << ' ';
dbg_(t.third);
cout << ')';
}
template <class T1, class T2, class T3, class T4> void dbg_(const quartet<T1, T2, T3, T4>& t) {
cout << '(';
dbg_(t.first);
cout << ' ';
dbg_(t.second);
cout << ' ';
dbg_(t.third);
cout << ' ';
dbg_(t.fourth);
cout << ')';
}
template <class T> void debug_(const T& e) {
dbg_(e);
cout << '\n';
}
template <class T> void debug_(const vector<T>& v) {
if (v.size()) {
auto it = v.begin();
dbg_(*it++);
for (; it != v.end(); ++it) {
cout << ' ';
dbg_(*it);
}
}
cout << '\n';
}
template <class T> void debug_(const vector<vector<T>>& vv) {
cout << '\n';
ll cnt = 0;
for (auto&& v : vv) {
cout << cnt++ << ": ";
debug_(v);
}
}
template <class T, class U> void debug_(const map<T, U>& mp) {
if (mp.size()) {
auto it = mp.begin();
dbg_(*it++);
for (; it != mp.end(); ++it) {
cout << ' ';
dbg_(*it);
}
}
cout << '\n';
}
template <class T, class U> void debug_(const vector<map<T, U>>& vm) {
cout << '\n';
ll cnt = 0;
for (auto&& mp : vm) {
cout << cnt++ << ": ";
debug_(mp);
}
}
template <class T> void debug_(const set<T>& st) {
if (st.size()) {
auto it = st.begin();
dbg_(*it++);
for (; it != st.end(); ++it) {
cout << ' ';
dbg_(*it);
}
}
cout << '\n';
}
template <class T> void debug_(const multiset<T>& st) {
if (st.size()) {
auto it = st.begin();
dbg_(*it++);
for (; it != st.end(); ++it) {
cout << ' ';
dbg_(*it);
}
}
cout << '\n';
}
template <class T> void debug_(const vector<set<T>>& vs) {
cout << '\n';
ll cnt = 0;
for (auto&& st : vs) {
cout << cnt++ << ": ";
debug_(st);
}
}
template <class T> void debug_(const vector<multiset<T>>& vs) {
cout << '\n';
ll cnt = 0;
for (auto&& st : vs) {
cout << cnt++ << ": ";
debug_(st);
}
}
template <class H, class... T> void debug_(const H& h, const T&... t) {
dbg_(h);
cout << ", ";
debug_(t...);
}
/********* O T H E R S **********/
// a > b a b .
template <class T, class U> bool chmin(T& a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// a < b a b .
template <class T, class U> bool chmax(T& a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// a % m. aOK.
template <class T, class U> T Mod(const T& a, const U& m) {
assert(m > 0);
return (a % m + m) % m;
}
// . xOK
template <class T, class U> T Ceil(const T& x, const U& y) {
assert(y > 0);
return x < 0 ? x / y : (x + y - 1) / y;
}
// . xOK
template <class T, class U> T Floor(const T& x, const U& y) {
assert(y > 0);
return -(Ceil(-x, y));
}
// . : -1, 0, +1
template <class T> ll Sign(const T& x) {
return (x > T(0)) - (x < T(0));
}
// x * x <= n`x`
ll Isqrt(ll n) {
assert(n >= 0);
ll x = round(sqrt(n));
while (x * x > n)
--x;
return x;
}
// nCr. n=60, r=30OK.
ll Comb(ll n, ll r) {
if (r < 0 || n < r) return 0;
r = min(r, n - r);
ll ret = 1;
rep(i, r) {
ret *= n - i;
ret /= i + 1;
}
return ret;
}
// x^n. mintOK.
template <class T> T Pow(T x, ll n) {
assert(n >= 0);
T ret = 1;
while (1) {
if (n % 2) ret *= x;
n /= 2;
if (!n) return ret;
x = x * x;
}
}
// (x^n) % mod.
template <class T> T Pow(T x, ll n, T mod) {
assert(n >= 0 && mod > 0);
T ret = 1;
while (1) {
if (n % 2) ret = (ret * x) % mod;
n /= 2;
if (!n) return ret;
x = (x * x) % mod;
}
}
// . mintOK.
template <class T> T Aseries(T a, T d, ll n) {
assert(n >= 0);
return a * n + n * (n - 1) / 2 * d;
}
// . mintOK.
template <class T> T Gseries(T a, T r, ll n) {
assert(n >= 0);
if (r == 1) return a * n;
else return a * (1 - Pow(r, n)) / (1 - r);
}
// `b``i`0 origin1
bool Bit(ll b, int i) {
assert(0 <= i && i < 64);
return (b >> i) & 1;
}
// `b`
ll Popcount(ll b) {
return __builtin_popcountll(b);
}
// [0, n)64bit.
ll Mask(ll n) {
assert(0 <= n && n < 63);
return (1LL << n) - 1LL;
}
// [m, n)64bit.
ll Mask(ll n, ll m) {
assert(n >= m);
return Mask(n) ^ Mask(m);
}
// [l1, r1)[l2, r2). : [3, 6) x [5, 7) = [5, 6)
pll GetOverlap(ll l1, ll r1, ll l2, ll r2) {
return {max(l1, l2), min(r1, r2)};
}
// [l1, r1)[l2, r2). false;
bool IsOverlap(ll l1, ll r1, ll l2, ll r2) {
return max(l1, l2) < min(r1, r2);
}
// b=true"Yes\n", false"No\n"
void PrintYesNo(bool b) {
b ? print("Yes") : print("No");
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0