Всем от новичка до профессионала приходится иметь дело с модульной арифметикой в очень широком спектре задач, от хеширования строк, до подсчета дп на деревьях (да-да, сейчас кто-то скажет, что все сводится к хэшам и комбе, но тема от этого не менее часто встречается).

Мне же еще с самых первых дней в олимпиадном программировании не нравились задачи с модульной арифметикой, забудешь один раз ans %= MOD; И сиди с WA, и, либо минусом по задаче, либо просто трать время на дебаг, поэтому всегда приходилось внимательно расписывать формулы. Однажды меня познакомили с хэшами и удобным способом их написания: функциями необходимыми, чтобы не забыть о модулях по типу add(x, y), sub(x, y) и mul(x, y). Код, хоть и стал выглядеть гораздо лучше, но все еще оставался нечитаемым, да и задумываться о прикладных мелочах, пока считаешь математику, не хочется, поэтому логическим продолжением данной темы с функциями (имхо) будет класс модульных интов. Я предлагаю следующую реализацию: ~~~~~

include "iostream"

template<class T, T MOD> class ModInt{ public: ModInt(const T &x = T(0)) : x_(x % MOD) {} friend ModInt& operator+=(ModInt &a, const ModInt &b){ a.x_ += b.x_; if (a.x_ >= MOD) a.x_ -= MOD; return a; } friend ModInt operator+(ModInt a, const ModInt &b){ return a += b; } friend ModInt& operator-=(ModInt &a, const ModInt &b){ a.x_ -= b.x_; if (a.x_ < 0) a.x_ += MOD; return a; } friend ModInt operator-(ModInt a, const ModInt &b){ return a -= b; } friend ModInt& operator*=(ModInt &a, const ModInt &b){ a.x_ = a.x_ * b.x_ % MOD; return a; } friend ModInt& operator*(ModInt a, const ModInt &b){ return a *= b; } ModInt& operator=(const ModInt &b){ x_ = b.x_; return *this; } friend std::istream &operator>>(std::istream &in, ModInt &a){ in >> a.x_; a.x_ %= MOD; return in; } friend std::ostream &operator<<(std::ostream &out, const ModInt &a){ out << a.x_; return out; } ModInt& operator++(){ ++x_; if (x_ == MOD) x_ = 0; return *this; } ModInt& operator--(){ --x_; if (x_ == -1) x_ = MOD — 1; return *this; } ModInt operator++(int ){ ModInt old = *this; ++x_; if (x_ == MOD) x_ = 0; return old; } ModInt operator--(int ){ ModInt old = *this; --x_; if (x_ == -1) x_ = MOD — 1; return old; } private: T x_; }; ~~~~~

Теперь все, что вам нужно сделать в задаче, чтобы ваш ответ считался по модулю — это написать: ~~~~~

define int ModInt<int64_t, 998244353>

~~~~~

WARNING: Константы по типу INF или подобные могут испортиться, думайте, когда используете этот define

Да, такой #define использовать плохо, но кто мне запретит. Конечно, теперь решение работает незначительно медленнее, например, потому что счетчики в циклах for теперь тоже работают по модулю (а вы их 100% часто используете), но, если вам не нужно пихать задачу, то жизнь вам это хуже не сделает.

Плюсы: 1) Хэши теперь можно писать почти как в 2009, когда еще не был известен anti-hash test против модулей 2^k 2) Любую комбинаторику из тетрадки можно просто перенести в код без лишней мороки

Минусы: 1) Незначительно ухудшает скорость программы

Лично для меня + сильно перевешивают -. Если придется загонять задачу, то, скорее всего, так и так придется хардкодить. Здесь же сильно упрощена работа с любой арифметикой и код становится гораздо более читаемым.

Далее можно развить класс, добавив модульное деление, т.е. умножение на обратное по модулю, но это я уже оставлю в качестве тривиального упражнения читателю)

В заключение: Конечно, на туре такое писать вряд ли быстрее, чем написать пару функций или, вообще, все считать в одной строке, но не всегда цель — решить задачу как можно быстрее, иногда этим процессом хочется насладиться, или для поиска бага повысить читаемость кода, да и не всегда пишешь задачи в какой-то ограниченный по времени тур, иногда закинуть готовый шаблон гораздо приятнее, чем переписывать все формулы по модулю на фул)