結果
| 問題 | No.2266 Fractions (hard) |
| ユーザー |
 NyaanNyaan
|
| 提出日時 | 2023-04-10 19:31:31 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 3,786 ms / 6,000 ms |
| コード長 | 33,730 bytes |
| コンパイル時間 | 3,625 ms |
| コンパイル使用メモリ | 289,536 KB |
| 実行使用メモリ | 5,376 KB |
| 最終ジャッジ日時 | 2024-04-15 23:05:12 |
| 合計ジャッジ時間 | 35,131 ms |
|
ジャッジサーバーID （参考情報） |
judge5 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 16 ms
5,248 KB |
| testcase_01 | AC | 1,784 ms
5,376 KB |
| testcase_02 | AC | 881 ms
5,376 KB |
| testcase_03 | AC | 2 ms
5,376 KB |
| testcase_04 | AC | 4 ms
5,376 KB |
| testcase_05 | AC | 9 ms
5,376 KB |
| testcase_06 | AC | 79 ms
5,376 KB |
| testcase_07 | AC | 31 ms
5,376 KB |
| testcase_08 | AC | 9 ms
5,376 KB |
| testcase_09 | AC | 4 ms
5,376 KB |
| testcase_10 | AC | 5 ms
5,376 KB |
| testcase_11 | AC | 2 ms
5,376 KB |
| testcase_12 | AC | 13 ms
5,376 KB |
| testcase_13 | AC | 1,268 ms
5,376 KB |
| testcase_14 | AC | 120 ms
5,376 KB |
| testcase_15 | AC | 148 ms
5,376 KB |
| testcase_16 | AC | 1,328 ms
5,376 KB |
| testcase_17 | AC | 1,054 ms
5,376 KB |
| testcase_18 | AC | 1,419 ms
5,376 KB |
| testcase_19 | AC | 2,140 ms
5,376 KB |
| testcase_20 | AC | 106 ms
5,376 KB |
| testcase_21 | AC | 1,674 ms
5,376 KB |
| testcase_22 | AC | 667 ms
5,376 KB |
| testcase_23 | AC | 185 ms
5,376 KB |
| testcase_24 | AC | 185 ms
5,376 KB |
| testcase_25 | AC | 1,885 ms
5,376 KB |
| testcase_26 | AC | 184 ms
5,376 KB |
| testcase_27 | AC | 1,566 ms
5,376 KB |
| testcase_28 | AC | 186 ms
5,376 KB |
| testcase_29 | AC | 184 ms
5,376 KB |
| testcase_30 | AC | 185 ms
5,376 KB |
| testcase_31 | AC | 185 ms
5,376 KB |
| testcase_32 | AC | 1,284 ms
5,376 KB |
| testcase_33 | AC | 2 ms
5,376 KB |
| testcase_34 | AC | 2,684 ms
5,376 KB |
| testcase_35 | AC | 2,558 ms
5,376 KB |
| testcase_36 | AC | 3,786 ms
5,376 KB |
| testcase_37 | AC | 2,075 ms
5,376 KB |
コンパイルメッセージ
main.cpp:870:7: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
870 | : iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&> {
| ^~~~~~~~
In file included from /home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/bits/stl_algobase.h:65,
from /home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/algorithm:60,
from main.cpp:11:
/home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
main.cpp:872:7: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
872 | iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&>;
| ^~~~~~~~
/home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
In file included from /home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/functional:59,
from main.cpp:31:
In copy constructor 'std::function<_Res(_ArgTypes ...)>::function(const std::function<_Res(_ArgTypes ...)>&) [with _Res = int; _ArgTypes = {long long int}]',
inlined from 'enumerate_mf_prefix_sum<T>::enumerate_mf_prefix_sum(const std::function<T(long long int)>&, const std::function<T(long long int)>&) [with T = int]' at main.cpp:1241:9,
inlined from 'Nyaan::pl calc(Nyaan::ll, Nyaan::ll)' at main.cpp:1259:42:
/home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/bits/std_function.h:391:17: warning: '<anonymous>' may be used uninitialized [-Wmaybe-uninitialized]
391 | __x._M_manager(_M_func
ソースコード
/**
* date : 2023-04-10 19:31:23
*/
#define NDEBUG
using namespace std;
// intrinstic
#include <immintrin.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// utility
namespace Nyaan {
using ll = long long;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<vector<T>>;
using vi = vector<int>;
using vl = vector<long long>;
using vd = V<double>;
using vs = V<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
template <typename T, typename U>
struct P : pair<T, U> {
template <typename... Args>
P(Args... args) : pair<T, U>(args...) {}
using pair<T, U>::first;
using pair<T, U>::second;
P &operator+=(const P &r) {
first += r.first;
second += r.second;
return *this;
}
P &operator-=(const P &r) {
first -= r.first;
second -= r.second;
return *this;
}
P &operator*=(const P &r) {
first *= r.first;
second *= r.second;
return *this;
}
template <typename S>
P &operator*=(const S &r) {
first *= r, second *= r;
return *this;
}
P operator+(const P &r) const { return P(*this) += r; }
P operator-(const P &r) const { return P(*this) -= r; }
P operator*(const P &r) const { return P(*this) *= r; }
template <typename S>
P operator*(const S &r) const {
return P(*this) *= r;
}
P operator-() const { return P{-first, -second}; }
};
using pl = P<ll, ll>;
using pi = P<int, int>;
using vp = V<pl>;
constexpr int inf = 1001001001;
constexpr long long infLL = 4004004004004004004LL;
template <typename T>
int sz(const T &t) {
return t.size();
}
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T>
inline T Max(const vector<T> &v) {
return *max_element(begin(v), end(v));
}
template <typename T>
inline T Min(const vector<T> &v) {
return *min_element(begin(v), end(v));
}
template <typename T>
inline long long Sum(const vector<T> &v) {
return accumulate(begin(v), end(v), 0LL);
}
template <typename T>
int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T>
int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
for (; n; x *= x, n >>= 1) ret *= (n & 1 ? x : 1);
return ret;
}
template <typename T, typename U>
pair<T, U> mkp(const T &t, const U &u) {
return make_pair(t, u);
}
template <typename T>
vector<T> mkrui(const vector<T> &v, bool rev = false) {
vector<T> ret(v.size() + 1);
if (rev) {
for (int i = int(v.size()) - 1; i >= 0; i--) ret[i] = v[i] + ret[i + 1];
} else {
for (int i = 0; i < int(v.size()); i++) ret[i + 1] = ret[i] + v[i];
}
return ret;
};
template <typename T>
vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F>
vector<int> mkord(int N,F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T>
vector<int> mkinv(vector<T> &v) {
int max_val = *max_element(begin(v), end(v));
vector<int> inv(max_val + 1, -1);
for (int i = 0; i < (int)v.size(); i++) inv[v[i]] = i;
return inv;
}
vector<int> mkiota(int n) {
vector<int> ret(n);
iota(begin(ret), end(ret), 0);
return ret;
}
template <typename T>
T mkrev(const T &v) {
T w{v};
reverse(begin(w), end(w));
return w;
}
template <typename T>
bool nxp(vector<T> &v) {
return next_permutation(begin(v), end(v));
}
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
} // namespace Nyaan
// bit operation
namespace Nyaan {
__attribute__((target("popcnt"))) inline int popcnt(const u64 &a) {
return _mm_popcnt_u64(a);
}
inline int lsb(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int ctz(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int msb(const u64 &a) { return a ? 63 - __builtin_clzll(a) : -1; }
template <typename T>
inline int gbit(const T &a, int i) {
return (a >> i) & 1;
}
template <typename T>
inline void sbit(T &a, int i, bool b) {
if (gbit(a, i) != b) a ^= T(1) << i;
}
constexpr long long PW(int n) { return 1LL << n; }
constexpr long long MSK(int n) { return (1LL << n) - 1; }
} // namespace Nyaan
// inout
namespace Nyaan {
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
istream &operator>>(istream &is, __int128_t &x) {
string S;
is >> S;
x = 0;
int flag = 0;
for (auto &c : S) {
if (c == '-') {
flag = true;
continue;
}
x *= 10;
x += c - '0';
}
if (flag) x = -x;
return is;
}
istream &operator>>(istream &is, __uint128_t &x) {
string S;
is >> S;
x = 0;
for (auto &c : S) {
x *= 10;
x += c - '0';
}
return is;
}
ostream &operator<<(ostream &os, __int128_t x) {
if (x == 0) return os << 0;
if (x < 0) os << '-', x = -x;
string S;
while (x) S.push_back('0' + x % 10), x /= 10;
reverse(begin(S), end(S));
return os << S;
}
ostream &operator<<(ostream &os, __uint128_t x) {
if (x == 0) return os << 0;
string S;
while (x) S.push_back('0' + x % 10), x /= 10;
reverse(begin(S), end(S));
return os << S;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &...u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U, char sep = ' '>
void out(const T &t, const U &...u) {
cout << t;
if (sizeof...(u)) cout << sep;
out(u...);
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
} // namespace Nyaan
// debug
#ifdef NyaanDebug
#define trc(...) (void(0))
#else
#define trc(...) (void(0))
#endif
#ifdef NyaanLocal
#define trc2(...) (void(0))
#else
#define trc2(...) (void(0))
#endif
// macro
#define each(x, v) for (auto&& x : v)
#define each2(x, y, v) for (auto&& [x, y] : v)
#define all(v) (v).begin(), (v).end()
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define regr(i, a, b) for (long long i = (b)-1; i >= (a); i--)
#define fi first
#define se second
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define die(...) \
do { \
Nyaan::out(__VA_ARGS__); \
return; \
} while (0)
namespace Nyaan {
void solve();
}
int main() { Nyaan::solve(); }
//
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0) x += m;
return x;
}
// Fast modular multiplication by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m < 2^31`
barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) < 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v) v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1) return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1) r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1) return false;
if (n == 2 || n == 7 || n == 61) return true;
if (n % 2 == 0) return false;
long long d = n - 1;
while (d % 2 == 0) d /= 2;
constexpr long long bases[3] = {2, 7, 61};
for (long long a : bases) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0) return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0) m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2) return 1;
if (m == 167772161) return 3;
if (m == 469762049) return 3;
if (m == 754974721) return 11;
if (m == 998244353) return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0) x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok) return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
} // namespace internal
} // namespace atcoder
namespace atcoder {
long long pow_mod(long long x, long long n, int m) {
assert(0 <= n && 1 <= m);
if (m == 1) return 0;
internal::barrett bt((unsigned int)(m));
unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
while (n) {
if (n & 1) r = bt.mul(r, y);
y = bt.mul(y, y);
n >>= 1;
}
return r;
}
long long inv_mod(long long x, long long m) {
assert(1 <= m);
auto z = internal::inv_gcd(x, m);
assert(z.first == 1);
return z.second;
}
// (rem, mod)
std::pair<long long, long long> crt(const std::vector<long long>& r,
const std::vector<long long>& m) {
assert(r.size() == m.size());
int n = int(r.size());
// Contracts: 0 <= r0 < m0
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert(1 <= m[i]);
long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
std::swap(r0, r1);
std::swap(m0, m1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1) return {0, 0};
continue;
}
// assume: m0 > m1, lcm(m0, m1) >= 2 * max(m0, m1)
// (r0, m0), (r1, m1) -> (r2, m2 = lcm(m0, m1));
// r2 % m0 = r0
// r2 % m1 = r1
// -> (r0 + x*m0) % m1 = r1
// -> x*u0*g % (u1*g) = (r1 - r0) (u0*g = m0, u1*g = m1)
// -> x = (r1 - r0) / g * inv(u0) (mod u1)
// im = inv(u0) (mod u1) (0 <= im < u1)
long long g, im;
std::tie(g, im) = internal::inv_gcd(m0, m1);
long long u1 = (m1 / g);
// |r1 - r0| < (m0 + m1) <= lcm(m0, m1)
if ((r1 - r0) % g) return {0, 0};
// u1 * u1 <= m1 * m1 / g / g <= m0 * m1 / g = lcm(m0, m1)
long long x = (r1 - r0) / g % u1 * im % u1;
// |r0| + |m0 * x|
// < m0 + m0 * (u1 - 1)
// = m0 + m0 * m1 / g - m0
// = lcm(m0, m1)
r0 += x * m0;
m0 *= u1; // -> lcm(m0, m1)
if (r0 < 0) r0 += m0;
}
return {r0, m0};
}
long long floor_sum(long long n, long long m, long long a, long long b) {
long long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long long y_max = (a * n + b) / m, x_max = (y_max * m - b);
if (y_max == 0) return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
} // namespace atcoder
//
using namespace std;
using namespace std;
namespace BinaryGCDImpl {
using u64 = unsigned long long;
using i8 = char;
inline u64 binary_gcd(u64 a, u64 b) {
if (a == 0 || b == 0) return a + b;
i8 n = __builtin_ctzll(a);
i8 m = __builtin_ctzll(b);
a >>= n;
b >>= m;
n = min(n, m);
while (a != b) {
u64 d = a - b;
i8 s = __builtin_ctzll(d);
bool f = a > b;
b = f ? b : a;
a = (f ? d : -d) >> s;
}
return a << n;
}
} // namespace BinaryGCDImpl
long long fgcd(long long a, long long b) {
return BinaryGCDImpl::binary_gcd(abs(a), abs(b));
}
/**
* @brief binary GCD
*/
// T : 値, U : 比較用
template <typename T, typename U>
struct RationalBase {
using R = RationalBase;
using Key = T;
T x, y;
RationalBase() : x(0), y(1) {}
RationalBase(T _x, T _y = 1) : x(_x), y(_y) {
assert(y != 0);
if (y == -1) x = -x, y = -y;
if (y != 1) {
T g;
if constexpr (is_same_v<T, int> || is_same_v<T, long long>) {
g = fgcd(abs(x), abs(y));
} else {
assert(false);
}
if (g != 0) x /= g, y /= g;
if (y < 0) x = -x, y = -y;
}
}
// y = 0 の代入も認める
static R raw(T _x, T _y) {
R r;
r.x = _x, r.y = _y;
return r;
}
friend R operator+(const R& l, const R& r) {
if (l.y == r.y) return R{l.x + r.x, l.y};
return R{l.x * r.y + l.y * r.x, l.y * r.y};
}
friend R operator-(const R& l, const R& r) {
if (l.y == r.y) return R{l.x - r.x, l.y};
return R{l.x * r.y - l.y * r.x, l.y * r.y};
}
friend R operator*(const R& l, const R& r) { return R{l.x * r.x, l.y * r.y}; }
friend R operator/(const R& l, const R& r) { return R{l.x * r.y, l.y * r.x}; }
R& operator+=(const R& r) { return (*this) = (*this) + r; }
R& operator-=(const R& r) { return (*this) = (*this) - r; }
R& operator*=(const R& r) { return (*this) = (*this) * r; }
R& operator/=(const R& r) { return (*this) = (*this) / r; }
R operator-() const { return raw(-x, y); }
R inverse() const {
assert(x != 0);
R r = raw(y, x);
if (r.y < 0) r.x = -r.x, r.y = -r.y;
return r;
}
R pow(long long p) const {
R res{1}, base{*this};
while (p) {
if (p & 1) res *= base;
base *= base;
p >>= 1;
}
return res;
}
friend bool operator==(const R& l, const R& r) {
return l.x == r.x && l.y == r.y;
};
friend bool operator!=(const R& l, const R& r) {
return l.x != r.x || l.y != r.y;
};
friend bool operator<(const R& l, const R& r) {
return U{l.x} * r.y < U{l.y} * r.x;
};
friend bool operator<=(const R& l, const R& r) { return l < r || l == r; }
friend bool operator>(const R& l, const R& r) {
return U{l.x} * r.y > U{l.y} * r.x;
};
friend bool operator>=(const R& l, const R& r) { return l > r || l == r; }
friend ostream& operator<<(ostream& os, const R& r) {
os << r.x;
if (r.x != 0 && r.y != 1) os << "/" << r.y;
return os;
}
T toMint(T mod) {
assert(mod != 0);
T a = y, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return U((u % mod + mod) % mod) * x % mod;
}
};
using Rational = RationalBase<long long, __int128_t>;
template <typename R = Rational>
struct Binomial {
vector<R> fc;
Binomial(int = 0) { fc.emplace_back(1); }
void extend() {
int n = fc.size();
R nxt = fc.back() * n;
fc.push_back(nxt);
}
R fac(int n) {
if (n < 0) return 0;
while ((int)fc.size() <= n) extend();
return fc[n];
}
R finv(int n) {
if (n < 0) return 0;
return fac(n).inverse();
}
R inv(int n) {
if (n < 0) return -inv(-n);
return R{1, max(n, 1)};
}
R C(int n, int r) {
if (n < 0 or r < 0 or n < r) return R{0};
return fac(n) * finv(n - r) * finv(r);
}
R operator()(int n, int r) { return C(n, r); }
template <typename I>
R multinomial(const vector<I>& r) {
static_assert(is_integral<I>::value == true);
int n = 0;
for (auto& x : r) {
if (x < 0) return R{0};
n += x;
}
R res = fac(n);
for (auto& x : r) res *= finv(x);
return res;
}
template <typename I>
R operator()(const vector<I>& r) {
return multinomial(r);
}
};
//
using namespace std;
using namespace std;
namespace HashMapImpl {
using u32 = uint32_t;
using u64 = uint64_t;
template <typename Key, typename Data>
struct HashMapBase;
template <typename Key, typename Data>
struct itrB
: iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&> {
using base =
iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&>;
using ptr = typename base::pointer;
using ref = typename base::reference;
u32 i;
HashMapBase<Key, Data>* p;
explicit constexpr itrB() : i(0), p(nullptr) {}
explicit constexpr itrB(u32 _i, HashMapBase<Key, Data>* _p) : i(_i), p(_p) {}
explicit constexpr itrB(u32 _i, const HashMapBase<Key, Data>* _p)
: i(_i), p(const_cast<HashMapBase<Key, Data>*>(_p)) {}
friend void swap(itrB& l, itrB& r) { swap(l.i, r.i), swap(l.p, r.p); }
friend bool operator==(const itrB& l, const itrB& r) { return l.i == r.i; }
friend bool operator!=(const itrB& l, const itrB& r) { return l.i != r.i; }
const ref operator*() const {
return const_cast<const HashMapBase<Key, Data>*>(p)->data[i];
}
ref operator*() { return p->data[i]; }
ptr operator->() const { return &(p->data[i]); }
itrB& operator++() {
assert(i != p->cap && "itr::operator++()");
do {
i++;
if (i == p->cap) break;
if (p->occupied_flag[i] && !p->deleted_flag[i]) break;
} while (true);
return (*this);
}
itrB operator++(int) {
itrB it(*this);
++(*this);
return it;
}
itrB& operator--() {
do {
i--;
if (p->occupied_flag[i] && !p->deleted_flag[i]) break;
assert(i != 0 && "itr::operator--()");
} while (true);
return (*this);
}
itrB operator--(int) {
itrB it(*this);
--(*this);
return it;
}
};
template <typename Key, typename Data>
struct HashMapBase {
using u32 = uint32_t;
using u64 = uint64_t;
using iterator = itrB<Key, Data>;
using itr = iterator;
protected:
template <typename K>
inline u64 randomized(const K& key) const {
return u64(key) ^ r;
}
template <typename K,
enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<K>::value, nullptr_t> = nullptr>
inline u32 inner_hash(const K& key) const {
return (randomized(key) * 11995408973635179863ULL) >> shift;
}
template <
typename K, enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<decltype(K::first)>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<decltype(K::second)>::value, nullptr_t> = nullptr>
inline u32 inner_hash(const K& key) const {
u64 a = randomized(key.first), b = randomized(key.second);
a *= 11995408973635179863ULL;
b *= 10150724397891781847ULL;
return (a + b) >> shift;
}
template <typename K,
enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<typename K::value_type>::value, nullptr_t> =
nullptr>
inline u32 inner_hash(const K& key) const {
static constexpr u64 mod = (1LL << 61) - 1;
static constexpr u64 base = 950699498548472943ULL;
u64 res = 0;
for (auto& elem : key) {
__uint128_t x = __uint128_t(res) * base + (randomized(elem) & mod);
res = (x & mod) + (x >> 61);
}
__uint128_t x = __uint128_t(res) * base;
res = (x & mod) + (x >> 61);
if (res >= mod) res -= mod;
return res >> (shift - 3);
}
template <typename D = Data,
enable_if_t<is_same<D, Key>::value, nullptr_t> = nullptr>
inline u32 hash(const D& dat) const {
return inner_hash(dat);
}
template <
typename D = Data,
enable_if_t<is_same<decltype(D::first), Key>::value, nullptr_t> = nullptr>
inline u32 hash(const D& dat) const {
return inner_hash(dat.first);
}
template <typename D = Data,
enable_if_t<is_same<D, Key>::value, nullptr_t> = nullptr>
inline Key data_to_key(const D& dat) const {
return dat;
}
template <
typename D = Data,
enable_if_t<is_same<decltype(D::first), Key>::value, nullptr_t> = nullptr>
inline Key data_to_key(const D& dat) const {
return dat.first;
}
void reallocate(u32 ncap) {
vector<Data> ndata(ncap);
vector<bool> nf(ncap);
shift = 64 - __lg(ncap);
for (u32 i = 0; i < cap; i++) {
if (occupied_flag[i] && !deleted_flag[i]) {
u32 h = hash(data[i]);
while (nf[h]) h = (h + 1) & (ncap - 1);
ndata[h] = move(data[i]);
nf[h] = true;
}
}
data.swap(ndata);
occupied_flag.swap(nf);
cap = ncap;
occupied = s;
deleted_flag.resize(cap);
fill(std::begin(deleted_flag), std::end(deleted_flag), false);
}
inline bool extend_rate(u32 x) const { return x * 2 >= cap; }
inline bool shrink_rate(u32 x) const {
return HASHMAP_DEFAULT_SIZE < cap && x * 10 <= cap;
}
inline void extend() { reallocate(cap << 1); }
inline void shrink() { reallocate(cap >> 1); }
public:
u32 cap, s, occupied;
vector<Data> data;
vector<bool> occupied_flag, deleted_flag;
u32 shift;
static u64 r;
static constexpr uint32_t HASHMAP_DEFAULT_SIZE = 4;
explicit HashMapBase()
: cap(HASHMAP_DEFAULT_SIZE),
s(0),
occupied(0),
data(cap),
occupied_flag(cap),
deleted_flag(cap),
shift(64 - __lg(cap)) {}
itr begin() const {
u32 h = 0;
while (h != cap) {
if (occupied_flag[h] && !deleted_flag[h]) break;
h++;
}
return itr(h, this);
}
itr end() const { return itr(this->cap, this); }
friend itr begin(const HashMapBase& h) { return h.begin(); }
friend itr end(const HashMapBase& h) { return h.end(); }
itr find(const Key& key) const {
u32 h = inner_hash(key);
while (true) {
if (occupied_flag[h] == false) return this->end();
if (data_to_key(data[h]) == key) {
if (deleted_flag[h] == true) return this->end();
return itr(h, this);
}
h = (h + 1) & (cap - 1);
}
}
bool contain(const Key& key) const { return find(key) != this->end(); }
itr insert(const Data& d) {
u32 h = hash(d);
while (true) {
if (occupied_flag[h] == false) {
if (extend_rate(occupied + 1)) {
extend();
h = hash(d);
continue;
}
data[h] = d;
occupied_flag[h] = true;
++occupied, ++s;
return itr(h, this);
}
if (data_to_key(data[h]) == data_to_key(d)) {
if (deleted_flag[h] == true) {
data[h] = d;
deleted_flag[h] = false;
++s;
}
return itr(h, this);
}
h = (h + 1) & (cap - 1);
}
}
// tips for speed up :
// if return value is unnecessary, make argument_2 false.
itr erase(itr it, bool get_next = true) {
if (it == this->end()) return this->end();
s--;
if (!get_next) {
this->deleted_flag[it.i] = true;
if (shrink_rate(s)) shrink();
return this->end();
}
itr nxt = it;
nxt++;
this->deleted_flag[it.i] = true;
if (shrink_rate(s)) {
Data d = data[nxt.i];
shrink();
it = find(data_to_key(d));
}
return nxt;
}
itr erase(const Key& key) { return erase(find(key)); }
int count(const Key& key) { return find(key) == end() ? 0 : 1; }
bool empty() const { return s == 0; }
int size() const { return s; }
void clear() {
fill(std::begin(occupied_flag), std::end(occupied_flag), false);
fill(std::begin(deleted_flag), std::end(deleted_flag), false);
s = occupied = 0;
}
void reserve(int n) {
if (n <= 0) return;
n = 1 << min(23, __lg(n) + 2);
if (cap < u32(n)) reallocate(n);
}
};
template <typename Key, typename Data>
uint64_t HashMapBase<Key, Data>::r =
chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count();
} // namespace HashMapImpl
/**
* @brief Hash Map(base) (ハッシュマップ・基底クラス)
*/
template <typename Key, typename Val>
struct HashMap : HashMapImpl::HashMapBase<Key, pair<Key, Val>> {
using base = typename HashMapImpl::HashMapBase<Key, pair<Key, Val>>;
using HashMapImpl::HashMapBase<Key, pair<Key, Val>>::HashMapBase;
using Data = pair<Key, Val>;
Val& operator[](const Key& k) {
typename base::u32 h = base::inner_hash(k);
while (true) {
if (base::occupied_flag[h] == false) {
if (base::extend_rate(base::occupied + 1)) {
base::extend();
h = base::hash(k);
continue;
}
base::data[h].first = k;
base::data[h].second = Val();
base::occupied_flag[h] = true;
++base::occupied, ++base::s;
return base::data[h].second;
}
if (base::data[h].first == k) {
if (base::deleted_flag[h] == true) {
base::data[h].second = Val();
base::deleted_flag[h] = false;
++base::s;
}
return base::data[h].second;
}
h = (h + 1) & (base::cap - 1);
}
}
typename base::itr emplace(const Key& key, const Val& val) {
return base::insert(Data(key, val));
}
};
/*
* @brief ハッシュマップ(連想配列)
* @docs docs/hashmap/hashmap.md
**/
namespace EnumerateQuotientImpl {
long long fast_div(long long a, long long b) { return 1.0 * a / b; };
long long slow_div(long long a, long long b) { return a / b; };
} // namespace EnumerateQuotientImpl
// { (q, l, r) : forall x in (l,r], floor(N/x) = q }
// を引数に取る関数f(q, l, r)を渡す。範囲が左に半開なのに注意
template <typename T, typename F>
void enumerate_quotient(T N, const F& f) {
T sq = sqrt(N);
while ((sq + 1) * (sq + 1) <= N) sq++;
while (sq * sq > N) sq--;
#define FUNC(d) \
T upper = N, quo = 0; \
while (upper > sq) { \
T thres = d(N, (++quo + 1)); \
f(quo, thres, upper); \
upper = thres; \
} \
while (upper > 0) { \
f(d(N, upper), upper - 1, upper); \
upper--; \
}
if (N <= 1e12) {
FUNC(EnumerateQuotientImpl::fast_div);
} else {
FUNC(EnumerateQuotientImpl::slow_div);
}
#undef FUNC
}
/**
* @brief 商の列挙
*/
/**
* S(f, n) = f(1) + f(2) + ... + f(n) とする
* f と g のディリクレ積を h とする
* S(h, n) と S(g, n) が高速に計算できる, かつ g(1) = 1 のとき
* S(f, N/i) を O(N^{3/4}) で列挙できる
*
* うまくやると O~(N^{2/3}) に落ちたり g(1) != 1 に対応できる
* https://codeforces.com/blog/entry/54150
*/
template <typename T>
struct enumerate_mf_prefix_sum {
unordered_map<long long, T> dp;
function<T(long long)> sg;
function<T(long long)> sh;
enumerate_mf_prefix_sum(const function<T(long long)>& _sg,
const function<T(long long)>& _sh)
: sg(_sg), sh(_sh) {}
T get(long long n) {
if (dp.count(n)) return dp[n];
T res = sh(n);
enumerate_quotient(n, [&](long long q, long long l, long long r) {
if (q != n) res -= get(q) * (sg(r) - sg(l));
});
return dp[n] = res;
}
T operator()(long long n) { return get(n); }
};
using namespace Nyaan;
// k 番目に小さい
pl calc(ll N, ll K) {
auto sg = [](int n) -> int { return n; };
auto sh = [](int) -> int { return 1; };
enumerate_mf_prefix_sum<int> moe(sg, sh);
auto cnt = [&](Rational f) -> ll {
// trc2(f);
ll s = 0;
enumerate_quotient(N, [&](ll q, ll l, ll r) {
ll x = 0;
x += atcoder::floor_sum(r + 1, f.y, f.x, 0);
x -= atcoder::floor_sum(l + 1, f.y, f.x, 0);
s += x * moe(q);
});
/*
each(i, mop) {
if (i > N) break;
s += i * ll(f.x) / int(f.y);
}
*/
// trc2(f, s);
return s;
};
Rational L{0, 1};
Rational M{1, 2};
Rational R{1, 1};
while (true) {
// trc2(L.x, L.y, M.x, M.y, R.x, R.y);
ll c = cnt(M);
if (c == K) {
break;
}
if (c < K) {
L = M;
for (ll i = 2;; i *= 2) {
Rational f{L.x + R.x * i, L.y + R.y * i};
if (max(f.x, f.y) > N) break;
if (cnt(f) == K) return {f.x, f.y};
if (cnt(f) < K) {
L = f;
} else {
break;
}
}
} else {
R = M;
for (ll i = 2;; i *= 2) {
Rational f{L.x * i + R.x, L.y * i + R.y};
if (max(f.x, f.y) > N) break;
if (cnt(f) == K) return {f.x, f.y};
if (cnt(f) >= K) {
R = f;
} else {
break;
}
}
}
M = Rational{L.x + R.x, L.y + R.y};
}
return {M.x, M.y};
}
void q() {
inl(N, K);
auto g = [](ll n) -> ll { return n; };
auto h = [](ll n) -> ll { return n * (n + 1) / 2; };
enumerate_mf_prefix_sum<ll> tot(g, h);
ll s = tot(N) - 1;
trc(s);
ll p = -1, q = -1;
if (K <= s) {
tie(p, q) = calc(N, K);
} else if (K == s + 1) {
p = q = 1;
} else if (K <= s * 2 + 1) {
tie(q, p) = calc(N, 2 * s + 1 - (K - 1));
} else {
// do nothing
}
if (p == -1) {
out(-1);
} else {
cout << p << "/" << q << "\n";
}
}
void Nyaan::solve() {
int t = 1;
// in(t);
while (t--) q();
}