#pragma once
#include "../../../edh/discretization/lib.hpp"
#include "../data/lib.hpp"
namespace tifa_libs {
// clang-format off
// bianl: 89 waiting 7. bianr: 12 waiting 3. pair0: pair which cannot be improved
enum class MELDS_MJ: u8 { mian, bianl, bianr, kan, orphan, pair0, pair, bonus, chow, pung, kong };
// clang-format on
enum class RULE_MJ : u8 {
enable_kong = 1,
enable_13terminal = 2,
enable_7pairs = 4
};
struct mahjong_hand {
// clang-format off
enum class MODE_MH: u8 { normal_13, normal_14, pairs7_13, pairs7_14, terminal13_13, terminal13_14 };
// clang-format on
u32 max_card_per_kind;
MODE_MH mode;
// eye in {@code waiting} if mode == normal, otherwise in {@code prepared}
vecp<MELDS_MJ, u32> waiting, prepared;
CEXP auto operator<=>(mahjong_hand CR) CNE = default;
CEXP bool operator==(mahjong_hand CR) CNE = default;
ND CEXP arr<u32, 45> get_counter() CNE {
arr<u32, 45> counter{};
for (auto [melds, c] : waiting) switch (melds) {
case MELDS_MJ::mian:
case MELDS_MJ::bianl:
case MELDS_MJ::bianr: ++counter[c], ++counter[c + 1]; break;
case MELDS_MJ::kan: ++counter[c], ++counter[c + 2]; break;
case MELDS_MJ::orphan: ++counter[c]; break;
case MELDS_MJ::pair0:
case MELDS_MJ::pair: counter[c] += 2; break;
default: assert(false);
}
for (auto [melds, c] : prepared) switch (melds) {
case MELDS_MJ::bonus:
case MELDS_MJ::orphan: ++counter[c]; break;
case MELDS_MJ::pair: counter[c] += 2; break;
case MELDS_MJ::chow: ++counter[c], ++counter[c + 1], ++counter[c + 2]; break;
case MELDS_MJ::pung: counter[c] += 3; break;
case MELDS_MJ::kong: counter[c] += 4; break;
default: assert(false);
}
return counter;
}
ND CEXP bool win() CNE {
switch (mode) {
case MODE_MH::pairs7_14:
case MODE_MH::pairs7_13: return prepared.size() >= 6;
case MODE_MH::terminal13_14: return prepared.size() == 13;
case MODE_MH::terminal13_13: return prepared.size() == 13 || (prepared.size() == 12 && any_of(prepared, [](auto CR p) { return p.first == MELDS_MJ::pair; }));
case MODE_MH::normal_14: return prepared.size() == 4 && any_of(waiting, [](auto CR p) { return p.first == MELDS_MJ::pair || p.first == MELDS_MJ::pair0; });
case MODE_MH::normal_13: {
if (prepared.size() == 4) return true;
if (waiting.size() > 2 || prepared.size() < 3) return false;
u32 cnt_pair = 0, cnt_bmk = 0;
for (auto CR[meld, _] : waiting)
if (meld == MELDS_MJ::pair || meld == MELDS_MJ::pair0) ++cnt_pair;
else if (meld != MELDS_MJ::orphan) ++cnt_bmk;
return cnt_pair == 2 || (cnt_pair == 1 && cnt_bmk == 1);
}
}
assert(false);
}
ND CEXP vecu improve_cards() CNE {
if (mode == MODE_MH::terminal13_13 || mode == MODE_MH::terminal13_14) {
vecb vis(34);
u32 p = 34;
for (auto CR[meld, c] : prepared)
if (vis[c] = true; meld == MELDS_MJ::pair) {
p = c;
break;
}
if (p == 34) return {0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33};
vecu ans;
for (ans.reserve(13); auto c : vecu{0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33})
if (!vis[c]) ans.push_back(c);
return ans;
}
if (mode == MODE_MH::pairs7_13 || mode == MODE_MH::pairs7_14) {
vecu ans;
for (auto CR[_, c] : waiting) ans.push_back(c);
return ans;
}
auto cnt_pair = count_if(waiting, [](auto CR p) { return p.first == MELDS_MJ::pair || p.first == MELDS_MJ::pair0; });
vecb vis(34);
for (auto [melds, c] : waiting) switch (melds) {
case MELDS_MJ::mian: vis[c - 1] = vis[c + 2] = true; break;
case MELDS_MJ::bianl: vis[c - 1] = true; break;
case MELDS_MJ::bianr: vis[c + 2] = true; break;
case MELDS_MJ::kan: vis[c + 1] = true; break;
case MELDS_MJ::orphan: vis[c] = true; break;
case MELDS_MJ::pair0: break;
case MELDS_MJ::pair:
if (cnt_pair > 1) vis[c] = true;
break;
default: assert(false);
}
auto counter = get_counter();
flt_ (u32, i, 0, 34)
if (counter[i] >= max_card_per_kind) vis[i] = false;
vecu cards;
flt_ (u32, i, 0, 34)
if (vis[i]) cards.push_back(i);
return cards;
}
};
template <u32 cards = 14, u32 config = 0>
CEXP auto mahjong_parser(vec<mahjong_card> hand, u32 max_card_per_kind = 4) NE {
static_assert(cards == 13 || cards == 14);
CEXP bool enable_kong = config & (u32)RULE_MJ::enable_kong;
CEXP bool enable_13terminal = config & (u32)RULE_MJ::enable_13terminal;
CEXP bool enable_7pairs = config & (u32)RULE_MJ::enable_7pairs;
CEXP auto normal = cards == 13 ? mahjong_hand::MODE_MH::normal_13 : mahjong_hand::MODE_MH::normal_14;
CEXP auto pairs7 = cards == 13 ? mahjong_hand::MODE_MH::pairs7_13 : mahjong_hand::MODE_MH::pairs7_14;
CEXP auto terminal13 = cards == 13 ? mahjong_hand::MODE_MH::terminal13_13 : mahjong_hand::MODE_MH::terminal13_14;
using record_t = vecp<MELDS_MJ, u32>;
struct guard {
CEXP guard(record_t& target, arr<u8, 45>& counter, u32& sum_counter, u32 card, MELDS_MJ type) NE : target(target), counter(counter), sum_counter(sum_counter), card(card) {
switch (type) {
case MELDS_MJ::orphan: diff0 = 1; break;
case MELDS_MJ::mian:
case MELDS_MJ::bianl:
case MELDS_MJ::bianr: diff0 = diff1 = 1; break;
case MELDS_MJ::kan: diff0 = diff2 = 1; break;
case MELDS_MJ::pair0:
case MELDS_MJ::pair: diff0 = 2; break;
case MELDS_MJ::chow: diff0 = diff1 = diff2 = 1; break;
case MELDS_MJ::pung: diff0 = 3; break;
case MELDS_MJ::kong: diff0 = 4; break;
default: assert(false);
}
#pragma GCC diagnostic ignored "-Wconversion"
target.emplace_back(type, card), counter[card] -= diff0, counter[card + 1] -= diff1, counter[card + 2] -= diff2, sum_counter -= diff0 + diff1 + diff2;
}
CEXP ~guard() NE { target.pop_back(), counter[card] += diff0, counter[card + 1] += diff1, counter[card + 2] += diff2, sum_counter += diff0 + diff1 + diff2; }
#pragma GCC diagnostic warning "-Wconversion"
guard(guard CR) = delete;
guard& operator=(guard CR) = delete;
guard(guard&&) = delete;
guard& operator=(guard&&) = delete;
record_t& target;
arr<u8, 45>& counter;
u32& sum_counter;
u32 card, diff0 = 0, diff1 = 0, diff2 = 0;
};
if CEXP (enable_kong) assert(max_card_per_kind >= 4);
else assert(max_card_per_kind >= 3);
vec<mahjong_hand> ans;
record_t base;
sort(hand);
while (!hand.empty() && hand.back().is_bonus()) base.emplace_back(MELDS_MJ::bonus, hand.back().encode()), hand.pop_back();
if CEXP (enable_kong) assert(cards <= hand.size() && hand.size() <= cards + 4);
else assert(hand.size() == cards);
arr<u8, 45> counter{};
for (auto CR card : hand) ++counter[card.encode()];
u32 sum_counter = std::reduce(counter.begin(), counter.begin() + 34, 0_u32);
auto CR counter_bk = counter;
if CEXP (enable_13terminal)
if (hand.size() == cards) {
record_t waiting, prepared = base;
auto f = [&](u32 eye = -1_u32) {
std::list<guard> gs;
for (auto c : vecu{0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33})
if (auto cnt = counter[c]; c != eye && cnt) gs.emplace_back(prepared, counter, sum_counter, c, MELDS_MJ::orphan);
if (sum_counter)
flt_ (u32, c, 0, 34)
if (counter[c])
flt_ (u32, i, 0, counter[c]) gs.emplace_back(waiting, counter, sum_counter, c, MELDS_MJ::orphan);
ans.emplace_back(max_card_per_kind, terminal13, waiting, prepared);
};
bool _ = false;
for (auto c : vecu{0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33})
if (auto cnt = counter[c]; cnt > 1) {
guard g(prepared, counter, sum_counter, c, MELDS_MJ::pair);
_ = true, f(c);
}
if (!_) f();
}
if CEXP (enable_7pairs)
if (hand.size() == cards) {
record_t waiting, prepared = base;
flt_ (u32, i, 0, 34)
if (counter[i]) {
flt_ (u32, j, 0, counter[i] / 2) prepared.emplace_back(MELDS_MJ::pair, i);
if (counter[i] & 1) waiting.emplace_back(MELDS_MJ::orphan, i);
}
ans.emplace_back(max_card_per_kind, pairs7, waiting, prepared);
}
auto proceed_no_kong = [&]() NE {
record_t waiting, prepared = base;
auto f = [&](auto&& f) NE {
if (!sum_counter) {
ans.emplace_back(max_card_per_kind, normal, waiting, prepared);
return;
}
bool found = false;
flt_ (u32, c, 0, 34) {
cu32 cnt = counter[c];
if (!cnt) continue;
if (cnt >= 3) {
guard g_pung(prepared, counter, sum_counter, c, MELDS_MJ::pung);
found = true, f(f);
}
if (!mahjong_card::is_honor(c) && c % 9 < 7 && counter[c + 1] && counter[c + 2]) {
guard g_chow(prepared, counter, sum_counter, c, MELDS_MJ::chow);
found = true, f(f);
}
}
if (found) return;
found = false;
flt_ (u32, c, 0, 34) {
cu32 cnt = counter[c];
if (!cnt) continue;
if (cnt >= 2) {
guard g_pair(waiting, counter, sum_counter, c, counter_bk[c] < max_card_per_kind ? MELDS_MJ::pair : MELDS_MJ::pair0);
found = true, f(f);
}
if (!mahjong_card::is_honor(c)) {
if (c % 9 != 8 && counter[c + 1]) {
if (!(c % 9) && counter_bk[c + 2] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianr);
found = true, f(f);
} else if (c % 9 == 7 && counter_bk[c - 1] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianl);
found = true, f(f);
} else if (c % 9 && c % 9 < 7) {
if (counter_bk[c - 1] < max_card_per_kind && counter_bk[c + 2] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::mian);
found = true, f(f);
} else if (counter_bk[c - 1] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianl);
found = true, f(f);
} else if (counter_bk[c + 2] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianr);
found = true, f(f);
}
}
}
if (c % 9 < 7 && counter[c + 2] && counter_bk[c + 1] < max_card_per_kind) {
guard g_kan(waiting, counter, sum_counter, c, MELDS_MJ::kan);
found = true, f(f);
}
}
}
if (found) return;
std::list<guard> g_orphans;
flt_ (u32, c, 0, 34)
if (counter[c]) g_orphans.emplace_back(waiting, counter, sum_counter, c, MELDS_MJ::orphan);
f(f);
};
const bool _ = false;
flt_ (u32, c, 0, 34)
if (counter[c] >= 2) {
guard g_eye(waiting, counter, sum_counter, c, counter_bk[c] < max_card_per_kind ? MELDS_MJ::pair : MELDS_MJ::pair0);
f(f);
}
if (!_) f(f);
};
if CEXP (enable_kong) {
u32 kong_tot = (u32)hand.size() - cards;
vecu kongs;
flt_ (u32, i, 0, 34)
if (counter[i] >= 4)
flt_ (u32, j, 0, counter[i] / 4) kongs.push_back(i);
assert(kong_tot <= kongs.size() && kongs.size() <= 4);
sort(kongs);
do {
std::list<guard> guards;
flt_ (u32, i, 0, kong_tot) guards.emplace_back(base, counter, sum_counter, kongs[i], MELDS_MJ::kong);
proceed_no_kong();
} while (next_permutation(kongs).found);
} else proceed_no_kong();
for (auto& [_, __, waiting, prepared] : ans) sort(waiting), sort(prepared);
return uniq(ans);
}
} // namespace tifa_libs
#line 2 "src/game/mahjong/parser/lib.hpp"
#line 2 "src/edh/discretization/lib.hpp"
#line 2 "src/fast/rsort32/lib.hpp"
#line 2 "src/util/alias/others/lib.hpp"
#line 2 "src/util/consts/lib.hpp"
#line 2 "src/util/alias/num/lib.hpp"
#line 2 "src/util/util/lib.hpp"
// https://github.com/Tiphereth-A/CP-lib
#include <bits/extc++.h>
// clang-format off
namespace tifa_libs {
#define CEXP constexpr
#define CEXPE constexpr explicit
#define CR const&
#define CP const*
#define PC *const
#define CPC const*const
#define TPN typename
#define NE noexcept
#define CNE const noexcept
#define ND [[nodiscard]]
#define cT_(...) std::conditional_t<sizeof(__VA_ARGS__) <= sizeof(size_t) * 2, __VA_ARGS__, __VA_ARGS__ CR>
// NOLINTNEXTLINE(misc-const-correctness)
#define flt_(T, i, l, r, ...) for (T i = (l), i##e = (r)__VA_OPT__(, ) __VA_ARGS__; i < i##e; ++i)
#define retif_(cond, if_true, ...) if cond return if_true __VA_OPT__(; else return __VA_ARGS__)
#ifdef ONLINE_JUDGE
#undef assert
#define assert(x) 42
#endif
using namespace std::ranges;
using namespace std::literals;
template <class T>
CEXP T abs(T x) NE { retif_((x < 0), -x, x); }
} // namespace tifa_libs
// clang-format on
#line 4 "src/util/alias/num/lib.hpp"
// clang-format off
namespace tifa_libs {
#define mk0_(w, t) using w = t; using c##w = const t
#define mk_(w, t) mk0_(w, t); CEXP w operator""_##w(unsigned long long x) NE { return (w)x; }
mk_(i8, int8_t) mk_(u8, uint8_t) mk_(i16, int16_t) mk_(u16, uint16_t) mk_(i32, int32_t) mk_(u32, uint32_t) mk_(i64, int64_t) mk_(u64, uint64_t) mk_(isz, ssize_t) mk_(usz, size_t) mk_(chr, char) mk_(schr, signed char) mk_(uchr, unsigned char) mk_(sint, signed) mk_(uint, unsigned);
mk0_(i128, __int128_t); mk0_(u128, __uint128_t); mk0_(f32, float); mk0_(f64, double); mk0_(f128, long double);
#undef mk0_
#undef mk_
} // namespace tifa_libs
// clang-format on
#line 4 "src/util/consts/lib.hpp"
// clang-format off
namespace tifa_libs {
using std::numbers::pi_v;
template <std::floating_point FP>
inline FP eps_v = std::sqrt(std::numeric_limits<FP>::epsilon());
template <std::floating_point FP>
CEXP void set_eps(FP v) NE { eps_v<FP> = v; }
CEXP u32 TIME = ((__TIME__[0] & 15) << 20) | ((__TIME__[1] & 15) << 16) | ((__TIME__[3] & 15) << 12) | ((__TIME__[4] & 15) << 8) | ((__TIME__[6] & 15) << 4) | (__TIME__[7] & 15);
CEXP auto STR2U16 = [] { std::array<u32, 65536> table{}; table.fill(-1_u32); flt_ (u32, i, 48, 58) flt_ (u32, j, 48, 58) table[i << 8 | j] = (j & 15) * 10 + (i & 15); return table; }();
inline const auto fn_0 = [](auto&&...) NE {};
inline const auto fn_is0 = [](auto x) NE { return x == 0; };
} // namespace tifa_libs
// clang-format on
#line 4 "src/util/alias/others/lib.hpp"
namespace tifa_libs {
template <class T>
struct chash {
CEXP static u64 C = u64(pi_v<f128> * 2e18) | 71;
CEXP u64 operator()(T x) CNE { return __builtin_bswap64(((u64)x ^ TIME) * C); }
};
// clang-format off
#define mk_(w, t) using w = t; using c##w = const t;
mk_(strn, std::string) mk_(strnv, std::string_view)
#undef mk_
template <class T> struct edge_t { T w; u32 u, v; CEXP auto operator<=>(edge_t CR) const = default; }; template <class T> using cedge_t = const edge_t<T>;
template <class T> struct pt3 { T _0, _1, _2; CEXP auto operator<=>(pt3 CR) const = default; }; template <class T> using cpt3 = const pt3<T>;
template <class T> struct pt4 { T _0, _1, _2, _3; CEXP auto operator<=>(pt4 CR) const = default; }; template <class T> using cpt4 = const pt4<T>;
#define mkT_(w, t, ...) template <class T> using w = t __VA_OPT__(, ) __VA_ARGS__; template <class T> using c##w = const t __VA_OPT__(, ) __VA_ARGS__;
mkT_(ptt, std::pair<T, T>) mkT_(alc, std::pmr::polymorphic_allocator<T>) mkT_(vec, std::vector<T>) mkT_(vvec, vec<vec<T>>) mkT_(v3ec, vvec<vec<T>>) mkT_(vecpt, vec<ptt<T>>) mkT_(vvecpt, vvec<ptt<T>>) mkT_(ptvec, ptt<vec<T>>) mkT_(ptvvec, ptt<vvec<T>>)
#undef mkT_
template <class T> using itl = std ::initializer_list<T>;
template <class T, usz ext = std::dynamic_extent> using spn = std::span<T const, ext>;
template <class T, usz N> using arr = std::array<T, N>; template <class T, usz N> using carr = std::array<const T, N>;
template <class U, class T> using vecp = vec<std::pair<U, T>>; template <class U, class T> using vvecp = vvec<std::pair<U, T>>;
template <class U, class T> using vvecp = vvec<std::pair<U, T>>; template <class U, class T> using vvvecp = vvec<vvec<std::pair<U, T>>>;
#ifdef PB_DS_ASSOC_CNTNR_HPP
template <class T, class C = std::less<T>> using set = __gnu_pbds::tree<T, __gnu_pbds::null_type, C>;
template <class K, class V, class C = std::less<K>> using map = __gnu_pbds::tree<K, V, C>;
// hset<u64> s({}, {}, {}, {}, {1<<16});
template <class T, class HF = chash<T>> using hset = __gnu_pbds::gp_hash_table<T, __gnu_pbds::null_type, HF>;
// hmap<u64, int> s({}, {}, {}, {}, {1<<16});
template <class K, class V, class HF = chash<K>> using hmap = __gnu_pbds::gp_hash_table<K, V, HF>;
#else
using std::set, std::map;
template <class T, class HF = chash<T>> using hset = std::unordered_set<T, HF>;
template <class K, class V, class HF = chash<K>> using hmap = std::unordered_map<K, V, HF>;
#endif
#ifdef PB_DS_PRIORITY_QUEUE_HPP
template <class T, class C = std::less<T>> using pq = __gnu_pbds::priority_queue<T, C>;
#else
template <class T, class C = std::less<T>> using pq = std::priority_queue<T, vec<T>, C>;
#endif
template <class T> using pqg = pq<T, std::greater<T>>;
// clang-format on
#define mk1_(V, A, T) using V##A = V<T>;
#define mk_(V, A, T) mk1_(V, A, T) mk1_(c##V, A, T)
#define mk(A, T) mk_(edge_t, A, T) mk_(ptt, A, T) mk_(pt3, A, T) mk_(pt4, A, T) mk_(vec, A, T) mk_(vvec, A, T) mk_(v3ec, A, T) mk_(vecpt, A, T) mk_(vvecpt, A, T) mk_(ptvec, A, T) mk_(ptvvec, A, T) mk1_(spn, A, T) mk1_(itl, A, T)
mk(b, bool) mk(c, chr) mk(i, i32) mk(u, u32) mk(ii, i64) mk(uu, u64) mk(t, isz) mk(z, usz) mk(f, f32) mk(d, f64) mk(s, strn);
#undef mk
#undef mk_
#undef mk1_
} // namespace tifa_libs
#line 4 "src/fast/rsort32/lib.hpp"
namespace tifa_libs {
template <class C>
requires(std::is_array_v<C> && std::integral<decltype(std::declval<C>()[0])> && sizeof(std::declval<C>()[0]) == 4) || (std::contiguous_iterator<TPN C::iterator> && std::integral<TPN C::value_type> && sizeof(TPN C::value_type) == 4)
void rsort32(C& a) NE {
if (a.size() <= 1) return;
if (a.size() <= 200'000) {
std::ranges::sort(a);
return;
}
arr<u32, 256> _0{}, _1{}, _2{}, _3{};
cu32 n = (u32)a.size();
vecu b(n);
u32 *a_ = (u32*)a.data(), *b_ = (u32*)b.data();
for (cu32 *_ = a_ + n, *i = a_; i < _; ++i) ++_0[*i & 255], ++_1[*i >> 8 & 255], ++_2[*i >> 16 & 255], ++_3[*i >> 24 & 255];
flt_ (u32, i, 1, 256) _0[i] += _0[i - 1], _1[i] += _1[i - 1], _2[i] += _2[i - 1], _3[i] += _3[i - 1];
for (u32 CP i = a_ + n; --i >= a_;) b_[--_0[*i & 255]] = *i;
for (u32 CP i = b_ + n; --i >= b_;) a_[--_1[*i >> 8 & 255]] = *i;
for (u32 CP i = a_ + n; --i >= a_;) b_[--_2[*i >> 16 & 255]] = *i;
for (u32 CP i = b_ + n; --i >= b_;) a_[--_3[*i >> 24 & 255]] = *i;
if CEXP (std::is_signed_v<TPN C::value_type>) {
u32 i = n;
while (i && a[i - 1] < 0) --i;
rotate(a_, a_ + n, a_ + i);
}
}
template <class C>
requires(std::is_array_v<C> && std::integral<decltype(std::declval<C>()[0])> && sizeof(std::declval<C>()[0]) == 4) || range<C>
void sort(C& a) NE {
if CEXP (std::is_array_v<C> || (std::contiguous_iterator<TPN C::iterator> && std::integral<TPN C::value_type> && sizeof(TPN C::value_type) == 4)) rsort32(a);
else std::ranges::sort(a);
}
} // namespace tifa_libs
#line 4 "src/edh/discretization/lib.hpp"
namespace tifa_libs {
template <common_range T>
CEXP T uniq(T v) NE {
tifa_libs::sort(v);
auto r = unique(begin(v), end(v));
return {begin(v), begin(r)};
}
template <common_range T>
CEXP std::pair<T, vecu> gen_id(T CR v) NE {
const T _ = uniq(v);
vecu _1;
_1.reserve(v.size());
flt_ (u32, i, 0, (u32)v.size()) _1.push_back(u32(lower_bound(_, v[i]) - begin(_)));
return {_, _1};
}
} // namespace tifa_libs
#line 2 "src/game/mahjong/data/lib.hpp"
#line 2 "src/util/traits/others/lib.hpp"
// clang-format off
#line 4 "src/util/traits/others/lib.hpp"
namespace tifa_libs {
//! only for template without non-type argument
template <class, template <class...> class> CEXP bool specialized_from_v = false;
template <template <class...> class T, class... Args> CEXP bool specialized_from_v<T<Args...>, T> = true;
static_assert(specialized_from_v<vecu, std::vector>);
template <class T> concept container_c = common_range<T> && !std::is_array_v<std::remove_cvref_t<T>> && !std::same_as<std::remove_cvref_t<T>, strn> && !std::same_as<std::remove_cvref_t<T>, strnv>;
template <class T> concept istream_c = std::derived_from<T, std::istream> || std::derived_from<T, std::wistream> || requires(T is) { is.peek(); };
template <class T> concept ostream_c = std::derived_from<T, std::ostream> || std::derived_from<T, std::wostream> || requires(T os) { os.flush(); };
} // namespace tifa_libs
// clang-format on
#line 4 "src/game/mahjong/data/lib.hpp"
namespace tifa_libs {
struct mahjong_card {
static CEXP strn valid_rank = "123456789";
static CEXP strn valid_suit = "MPSZB";
static CEXP u32 rank_value(chr c) NE {
auto ret = valid_rank.find(c);
assert(ret != strn::npos);
return (u32)ret + 1;
}
static CEXP mahjong_card decode(u32 code) NE { return {code % 9 + 1, valid_suit[code / 9]}; }
ND CEXP u32 encode() CNE { return (u32)valid_suit.find(suit) * 9 + rank - 1; }
ND CEXP bool valid() CNE {
retif_((rank < 1 || rank > 9), false);
retif_((suit == 'Z' && rank > 7), false);
retif_((suit == 'B' && rank > 8), false);
return valid_suit.find(suit) != strn::npos;
}
static CEXP bool is_mixed_terminal(u32 code) NE { return code <= 33 && (27 <= code || code % 9 == 0 || code % 9 == 8); }
static CEXP bool is_terminal(u32 code) NE { return code <= 26 && (code % 9 == 0 || code % 9 == 8); }
static CEXP bool is_honor(u32 code) NE { return 27 <= code && code <= 33; }
static CEXP bool is_wind(u32 code) NE { return 27 <= code && code <= 30; }
static CEXP bool is_dragon(u32 code) NE { return 31 <= code && code <= 33; }
static CEXP bool is_bonus(u32 code) NE { return 36 <= code && code <= 43; }
static CEXP bool is_flower(u32 code) NE { return 36 <= code && code <= 39; }
static CEXP bool is_season(u32 code) NE { return 40 <= code && code <= 43; }
ND CEXP bool is_bonus() CNE { return suit == 'B'; }
ND CEXP bool is_mixed_terminal() CNE { return suit != 'B' && (suit == 'Z' || rank == 1 || rank == 9); }
ND CEXP bool is_terminal() CNE { return suit != 'Z' && is_mixed_terminal(); }
ND CEXP bool is_honor() CNE { return suit == 'Z'; }
ND CEXP bool is_wind() CNE { return suit == 'Z' && rank <= 4; }
ND CEXP bool is_dragon() CNE { return suit == 'Z' && rank > 4; }
ND CEXP bool is_flower() CNE { return suit == 'B' && rank <= 4; }
ND CEXP bool is_season() CNE { return suit == 'B' && rank > 4; }
friend CEXP auto operator<=>(mahjong_card l, mahjong_card r) NE {
if (l.suit == r.suit) return l.rank <=> r.rank;
return valid_suit.find(l.suit) <=> valid_rank.find(r.suit);
}
friend CEXP bool operator==(mahjong_card l, mahjong_card r) NE { return std::is_eq(l <=> r); }
friend auto& operator>>(tifa_libs::istream_c auto& is, mahjong_card& p) NE {
chr c;
(is >> c >> p.suit), p.rank = rank_value(c), p.suit = toupper(p.suit);
return is;
}
u32 rank;
chr suit;
};
namespace literals {
CEXP mahjong_card operator""_mjm(unsigned long long x) NE { return {(u32)x, 'M'}; }
CEXP mahjong_card operator""_mjp(unsigned long long x) NE { return {(u32)x, 'P'}; }
CEXP mahjong_card operator""_mjs(unsigned long long x) NE { return {(u32)x, 'S'}; }
CEXP mahjong_card operator""_mjz(unsigned long long x) NE { return {(u32)x, 'Z'}; }
CEXP mahjong_card operator""_mjb(unsigned long long x) NE { return {(u32)x, 'B'}; }
} // namespace literals
} // namespace tifa_libs
#line 5 "src/game/mahjong/parser/lib.hpp"
namespace tifa_libs {
// clang-format off
// bianl: 89 waiting 7. bianr: 12 waiting 3. pair0: pair which cannot be improved
enum class MELDS_MJ: u8 { mian, bianl, bianr, kan, orphan, pair0, pair, bonus, chow, pung, kong };
// clang-format on
enum class RULE_MJ : u8 {
enable_kong = 1,
enable_13terminal = 2,
enable_7pairs = 4
};
struct mahjong_hand {
// clang-format off
enum class MODE_MH: u8 { normal_13, normal_14, pairs7_13, pairs7_14, terminal13_13, terminal13_14 };
// clang-format on
u32 max_card_per_kind;
MODE_MH mode;
// eye in {@code waiting} if mode == normal, otherwise in {@code prepared}
vecp<MELDS_MJ, u32> waiting, prepared;
CEXP auto operator<=>(mahjong_hand CR) CNE = default;
CEXP bool operator==(mahjong_hand CR) CNE = default;
ND CEXP arr<u32, 45> get_counter() CNE {
arr<u32, 45> counter{};
for (auto [melds, c] : waiting) switch (melds) {
case MELDS_MJ::mian:
case MELDS_MJ::bianl:
case MELDS_MJ::bianr: ++counter[c], ++counter[c + 1]; break;
case MELDS_MJ::kan: ++counter[c], ++counter[c + 2]; break;
case MELDS_MJ::orphan: ++counter[c]; break;
case MELDS_MJ::pair0:
case MELDS_MJ::pair: counter[c] += 2; break;
default: assert(false);
}
for (auto [melds, c] : prepared) switch (melds) {
case MELDS_MJ::bonus:
case MELDS_MJ::orphan: ++counter[c]; break;
case MELDS_MJ::pair: counter[c] += 2; break;
case MELDS_MJ::chow: ++counter[c], ++counter[c + 1], ++counter[c + 2]; break;
case MELDS_MJ::pung: counter[c] += 3; break;
case MELDS_MJ::kong: counter[c] += 4; break;
default: assert(false);
}
return counter;
}
ND CEXP bool win() CNE {
switch (mode) {
case MODE_MH::pairs7_14:
case MODE_MH::pairs7_13: return prepared.size() >= 6;
case MODE_MH::terminal13_14: return prepared.size() == 13;
case MODE_MH::terminal13_13: return prepared.size() == 13 || (prepared.size() == 12 && any_of(prepared, [](auto CR p) { return p.first == MELDS_MJ::pair; }));
case MODE_MH::normal_14: return prepared.size() == 4 && any_of(waiting, [](auto CR p) { return p.first == MELDS_MJ::pair || p.first == MELDS_MJ::pair0; });
case MODE_MH::normal_13: {
if (prepared.size() == 4) return true;
if (waiting.size() > 2 || prepared.size() < 3) return false;
u32 cnt_pair = 0, cnt_bmk = 0;
for (auto CR[meld, _] : waiting)
if (meld == MELDS_MJ::pair || meld == MELDS_MJ::pair0) ++cnt_pair;
else if (meld != MELDS_MJ::orphan) ++cnt_bmk;
return cnt_pair == 2 || (cnt_pair == 1 && cnt_bmk == 1);
}
}
assert(false);
}
ND CEXP vecu improve_cards() CNE {
if (mode == MODE_MH::terminal13_13 || mode == MODE_MH::terminal13_14) {
vecb vis(34);
u32 p = 34;
for (auto CR[meld, c] : prepared)
if (vis[c] = true; meld == MELDS_MJ::pair) {
p = c;
break;
}
if (p == 34) return {0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33};
vecu ans;
for (ans.reserve(13); auto c : vecu{0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33})
if (!vis[c]) ans.push_back(c);
return ans;
}
if (mode == MODE_MH::pairs7_13 || mode == MODE_MH::pairs7_14) {
vecu ans;
for (auto CR[_, c] : waiting) ans.push_back(c);
return ans;
}
auto cnt_pair = count_if(waiting, [](auto CR p) { return p.first == MELDS_MJ::pair || p.first == MELDS_MJ::pair0; });
vecb vis(34);
for (auto [melds, c] : waiting) switch (melds) {
case MELDS_MJ::mian: vis[c - 1] = vis[c + 2] = true; break;
case MELDS_MJ::bianl: vis[c - 1] = true; break;
case MELDS_MJ::bianr: vis[c + 2] = true; break;
case MELDS_MJ::kan: vis[c + 1] = true; break;
case MELDS_MJ::orphan: vis[c] = true; break;
case MELDS_MJ::pair0: break;
case MELDS_MJ::pair:
if (cnt_pair > 1) vis[c] = true;
break;
default: assert(false);
}
auto counter = get_counter();
flt_ (u32, i, 0, 34)
if (counter[i] >= max_card_per_kind) vis[i] = false;
vecu cards;
flt_ (u32, i, 0, 34)
if (vis[i]) cards.push_back(i);
return cards;
}
};
template <u32 cards = 14, u32 config = 0>
CEXP auto mahjong_parser(vec<mahjong_card> hand, u32 max_card_per_kind = 4) NE {
static_assert(cards == 13 || cards == 14);
CEXP bool enable_kong = config & (u32)RULE_MJ::enable_kong;
CEXP bool enable_13terminal = config & (u32)RULE_MJ::enable_13terminal;
CEXP bool enable_7pairs = config & (u32)RULE_MJ::enable_7pairs;
CEXP auto normal = cards == 13 ? mahjong_hand::MODE_MH::normal_13 : mahjong_hand::MODE_MH::normal_14;
CEXP auto pairs7 = cards == 13 ? mahjong_hand::MODE_MH::pairs7_13 : mahjong_hand::MODE_MH::pairs7_14;
CEXP auto terminal13 = cards == 13 ? mahjong_hand::MODE_MH::terminal13_13 : mahjong_hand::MODE_MH::terminal13_14;
using record_t = vecp<MELDS_MJ, u32>;
struct guard {
CEXP guard(record_t& target, arr<u8, 45>& counter, u32& sum_counter, u32 card, MELDS_MJ type) NE : target(target), counter(counter), sum_counter(sum_counter), card(card) {
switch (type) {
case MELDS_MJ::orphan: diff0 = 1; break;
case MELDS_MJ::mian:
case MELDS_MJ::bianl:
case MELDS_MJ::bianr: diff0 = diff1 = 1; break;
case MELDS_MJ::kan: diff0 = diff2 = 1; break;
case MELDS_MJ::pair0:
case MELDS_MJ::pair: diff0 = 2; break;
case MELDS_MJ::chow: diff0 = diff1 = diff2 = 1; break;
case MELDS_MJ::pung: diff0 = 3; break;
case MELDS_MJ::kong: diff0 = 4; break;
default: assert(false);
}
#pragma GCC diagnostic ignored "-Wconversion"
target.emplace_back(type, card), counter[card] -= diff0, counter[card + 1] -= diff1, counter[card + 2] -= diff2, sum_counter -= diff0 + diff1 + diff2;
}
CEXP ~guard() NE { target.pop_back(), counter[card] += diff0, counter[card + 1] += diff1, counter[card + 2] += diff2, sum_counter += diff0 + diff1 + diff2; }
#pragma GCC diagnostic warning "-Wconversion"
guard(guard CR) = delete;
guard& operator=(guard CR) = delete;
guard(guard&&) = delete;
guard& operator=(guard&&) = delete;
record_t& target;
arr<u8, 45>& counter;
u32& sum_counter;
u32 card, diff0 = 0, diff1 = 0, diff2 = 0;
};
if CEXP (enable_kong) assert(max_card_per_kind >= 4);
else assert(max_card_per_kind >= 3);
vec<mahjong_hand> ans;
record_t base;
sort(hand);
while (!hand.empty() && hand.back().is_bonus()) base.emplace_back(MELDS_MJ::bonus, hand.back().encode()), hand.pop_back();
if CEXP (enable_kong) assert(cards <= hand.size() && hand.size() <= cards + 4);
else assert(hand.size() == cards);
arr<u8, 45> counter{};
for (auto CR card : hand) ++counter[card.encode()];
u32 sum_counter = std::reduce(counter.begin(), counter.begin() + 34, 0_u32);
auto CR counter_bk = counter;
if CEXP (enable_13terminal)
if (hand.size() == cards) {
record_t waiting, prepared = base;
auto f = [&](u32 eye = -1_u32) {
std::list<guard> gs;
for (auto c : vecu{0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33})
if (auto cnt = counter[c]; c != eye && cnt) gs.emplace_back(prepared, counter, sum_counter, c, MELDS_MJ::orphan);
if (sum_counter)
flt_ (u32, c, 0, 34)
if (counter[c])
flt_ (u32, i, 0, counter[c]) gs.emplace_back(waiting, counter, sum_counter, c, MELDS_MJ::orphan);
ans.emplace_back(max_card_per_kind, terminal13, waiting, prepared);
};
bool _ = false;
for (auto c : vecu{0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33})
if (auto cnt = counter[c]; cnt > 1) {
guard g(prepared, counter, sum_counter, c, MELDS_MJ::pair);
_ = true, f(c);
}
if (!_) f();
}
if CEXP (enable_7pairs)
if (hand.size() == cards) {
record_t waiting, prepared = base;
flt_ (u32, i, 0, 34)
if (counter[i]) {
flt_ (u32, j, 0, counter[i] / 2) prepared.emplace_back(MELDS_MJ::pair, i);
if (counter[i] & 1) waiting.emplace_back(MELDS_MJ::orphan, i);
}
ans.emplace_back(max_card_per_kind, pairs7, waiting, prepared);
}
auto proceed_no_kong = [&]() NE {
record_t waiting, prepared = base;
auto f = [&](auto&& f) NE {
if (!sum_counter) {
ans.emplace_back(max_card_per_kind, normal, waiting, prepared);
return;
}
bool found = false;
flt_ (u32, c, 0, 34) {
cu32 cnt = counter[c];
if (!cnt) continue;
if (cnt >= 3) {
guard g_pung(prepared, counter, sum_counter, c, MELDS_MJ::pung);
found = true, f(f);
}
if (!mahjong_card::is_honor(c) && c % 9 < 7 && counter[c + 1] && counter[c + 2]) {
guard g_chow(prepared, counter, sum_counter, c, MELDS_MJ::chow);
found = true, f(f);
}
}
if (found) return;
found = false;
flt_ (u32, c, 0, 34) {
cu32 cnt = counter[c];
if (!cnt) continue;
if (cnt >= 2) {
guard g_pair(waiting, counter, sum_counter, c, counter_bk[c] < max_card_per_kind ? MELDS_MJ::pair : MELDS_MJ::pair0);
found = true, f(f);
}
if (!mahjong_card::is_honor(c)) {
if (c % 9 != 8 && counter[c + 1]) {
if (!(c % 9) && counter_bk[c + 2] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianr);
found = true, f(f);
} else if (c % 9 == 7 && counter_bk[c - 1] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianl);
found = true, f(f);
} else if (c % 9 && c % 9 < 7) {
if (counter_bk[c - 1] < max_card_per_kind && counter_bk[c + 2] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::mian);
found = true, f(f);
} else if (counter_bk[c - 1] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianl);
found = true, f(f);
} else if (counter_bk[c + 2] < max_card_per_kind) {
guard g_mian(waiting, counter, sum_counter, c, MELDS_MJ::bianr);
found = true, f(f);
}
}
}
if (c % 9 < 7 && counter[c + 2] && counter_bk[c + 1] < max_card_per_kind) {
guard g_kan(waiting, counter, sum_counter, c, MELDS_MJ::kan);
found = true, f(f);
}
}
}
if (found) return;
std::list<guard> g_orphans;
flt_ (u32, c, 0, 34)
if (counter[c]) g_orphans.emplace_back(waiting, counter, sum_counter, c, MELDS_MJ::orphan);
f(f);
};
const bool _ = false;
flt_ (u32, c, 0, 34)
if (counter[c] >= 2) {
guard g_eye(waiting, counter, sum_counter, c, counter_bk[c] < max_card_per_kind ? MELDS_MJ::pair : MELDS_MJ::pair0);
f(f);
}
if (!_) f(f);
};
if CEXP (enable_kong) {
u32 kong_tot = (u32)hand.size() - cards;
vecu kongs;
flt_ (u32, i, 0, 34)
if (counter[i] >= 4)
flt_ (u32, j, 0, counter[i] / 4) kongs.push_back(i);
assert(kong_tot <= kongs.size() && kongs.size() <= 4);
sort(kongs);
do {
std::list<guard> guards;
flt_ (u32, i, 0, kong_tot) guards.emplace_back(base, counter, sum_counter, kongs[i], MELDS_MJ::kong);
proceed_no_kong();
} while (next_permutation(kongs).found);
} else proceed_no_kong();
for (auto& [_, __, waiting, prepared] : ans) sort(waiting), sort(prepared);
return uniq(ans);
}
} // namespace tifa_libs
src/game/mahjong/parser/lib.hpp