結果

問題 No.2857 Div Array
ユーザー dyktr_06
提出日時 2024-05-09 22:35:53
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 29 ms / 2,000 ms
コード長 10,934 bytes
コンパイル時間 2,680 ms
コンパイル使用メモリ 209,284 KB
最終ジャッジ日時 2025-02-21 12:05:22
ジャッジサーバーID
(参考情報)
judge1 / judge4
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 30
権限があれば一括ダウンロードができます

ソースコード

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

#include <bits/stdc++.h>
using namespace std;
template <long long Modulus>
struct ModInt{
long long val;
constexpr ModInt(const long long _val = 0) noexcept : val(_val) {
normalize();
}
void normalize(){
val = (val % Modulus + Modulus) % Modulus;
}
inline ModInt &operator+=(const ModInt &rhs) noexcept {
if(val += rhs.val, val >= Modulus) val -= Modulus;
return *this;
}
inline ModInt &operator-=(const ModInt &rhs) noexcept {
if(val -= rhs.val, val < 0) val += Modulus;
return *this;
}
inline ModInt &operator*=(const ModInt &rhs) noexcept {
val = val * rhs.val % Modulus;
return *this;
}
inline ModInt &operator/=(const ModInt &rhs) noexcept {
val = val * inv(rhs.val).val % Modulus;
return *this;
}
inline ModInt &operator++() noexcept {
if(++val >= Modulus) val -= Modulus;
return *this;
}
inline ModInt operator++(int) noexcept {
ModInt t = val;
if(++val >= Modulus) val -= Modulus;
return t;
}
inline ModInt &operator--() noexcept {
if(--val < 0) val += Modulus;
return *this;
}
inline ModInt operator--(int) noexcept {
ModInt t = val;
if(--val < 0) val += Modulus;
return t;
}
inline ModInt operator-() const noexcept { return (Modulus - val) % Modulus; }
inline ModInt inv(void) const { return inv(val); }
ModInt pow(long long n){
assert(0 <= n);
ModInt x = *this, r = 1;
while(n){
if(n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
ModInt inv(const long long n) const {
long long a = n, b = Modulus, u = 1, v = 0;
while(b){
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= Modulus;
if(u < 0) u += Modulus;
return u;
}
friend inline ModInt operator+(const ModInt &lhs, const ModInt &rhs) noexcept { return ModInt(lhs) += rhs; }
friend inline ModInt operator-(const ModInt &lhs, const ModInt &rhs) noexcept { return ModInt(lhs) -= rhs; }
friend inline ModInt operator*(const ModInt &lhs, const ModInt &rhs) noexcept { return ModInt(lhs) *= rhs; }
friend inline ModInt operator/(const ModInt &lhs, const ModInt &rhs) noexcept { return ModInt(lhs) /= rhs; }
friend inline bool operator==(const ModInt &lhs, const ModInt &rhs) noexcept { return lhs.val == rhs.val; }
friend inline bool operator!=(const ModInt &lhs, const ModInt &rhs) noexcept { return lhs.val != rhs.val; }
friend inline istream &operator>>(istream &is, ModInt &x) noexcept {
is >> x.val;
x.normalize();
return is;
}
friend inline ostream &operator<<(ostream &os, const ModInt &x) noexcept { return os << x.val; }
};
template <typename T>
struct Matrix{
int n, m;
vector<T> val;
Matrix(int _n, int _m) : n(_n), m(_m), val(_n *_m){}
Matrix(const vector<vector<T>> &mat){
n = mat.size();
m = mat[0].size();
val.resize(n * m);
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j){
val[i * m + j] = mat[i][j];
}
}
}
static Matrix e(int _n){
Matrix res(_n, _n);
for(int i = 0; i < _n; ++i){
res[i][i] = T{1};
}
return res;
}
auto operator[](int i){ return val.begin() + i * m; }
auto operator[](int i) const { return val.begin() + i * m; }
inline Matrix &operator+=(const Matrix &rhs){
for(int i = 0; i < n * m; ++i){
val[i] += rhs[i];
}
return *this;
}
inline Matrix &operator-=(const Matrix &rhs){
for(int i = 0; i < n * m; ++i){
val[i] -= rhs[i];
}
return *this;
}
inline Matrix operator*(const Matrix &rhs){
assert(m == rhs.n);
const int l = rhs.m;
Matrix res(n, l);
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j){
for(int k = 0; k < l; ++k){
res[i][k] += val[i * m + j] * rhs[j][k];
}
}
}
return res;
}
inline Matrix &operator*=(const Matrix &rhs){
return *this = *this * rhs;
}
friend inline Matrix operator+(const Matrix &lhs, const Matrix &rhs) noexcept { return Matrix(lhs) += rhs; }
friend inline Matrix operator-(const Matrix &lhs, const Matrix &rhs) noexcept { return Matrix(lhs) -= rhs; }
friend inline bool operator==(const Matrix &lhs, const Matrix &rhs) noexcept { return lhs.val == rhs.val; }
friend inline bool operator!=(const Matrix &lhs, const Matrix &rhs) noexcept { return lhs.val != rhs.val; }
friend inline ostream &operator<<(ostream &os, const Matrix &mat) noexcept {
const int _n = mat.n;
const int _m = mat.m;
for(int i = 0; i < _n; ++i){
for(int j = 0; j < _m; ++j){
os << mat[i][j] << " \n"[j == _m - 1];
}
}
return os;
}
Matrix inv() const {
Matrix a = *this, b = e(n);
for(int i = 0; i < n; ++i){
if(a[i][i] == 0){
for(int j = i + 1; j < n; ++j){
if(a[j][i] != 0){
for(int k = i; k < n; ++k) swap(a[i][k], a[j][k]);
for(int k = 0; k < n; ++k) swap(b[i][k], b[j][k]);
break;
}
}
}
if(a[i][i] == 0) throw "Inverse does not exist.";
const T x = T{1} / a[i][i];
for(int k = i; k < n; ++k) a[i][k] *= x;
for(int k = 0; k < n; ++k) b[i][k] *= x;
for(int j = 0; j < n; ++j){
if(i != j){
const T x = a[j][i];
for(int k = i; k < n; ++k) a[j][k] -= a[i][k] * x;
for(int k = 0; k < n; ++k) b[j][k] -= b[i][k] * x;
}
}
}
return b;
}
Matrix pow(long long r) const {
if(r == 0) return e(n);
if(r < 0) return inv().pow(-r);
Matrix res = e(n), a = *this;
while(r > 0){
if(r & 1) res *= a;
a *= a;
r >>= 1;
}
return res;
}
Matrix pow2(string &r) const {
if(r == "0") return e(n);
Matrix res = e(n), a = *this;
int siz = r.size();
for(int i = siz - 1; i >= 0; i--){
if(r[i] == '1') res *= a;
a *= a;
}
return res;
}
T det() const {
Matrix a = *this;
T res = 1;
for(int i = 0; i < n; ++i){
if(a[i][i] == 0){
for(int j = i + 1; j < n; ++j){
if(a[j][i] != 0){
for(int k = i; k < n; ++k){
swap(a[i][k], a[j][k]);
}
res = -res;
break;
}
}
}
if(a[i][i] == 0) return 0;
res *= a[i][i];
const T x = T{1} / a[i][i];
for(int k = i; k < n; ++k){
a[i][k] *= x;
}
for(int j = i + 1; j < n; ++j){
const T x = a[j][i];
for(int k = i; k < n; ++k){
a[j][k] -= a[i][k] * x;
}
}
}
return res;
}
Matrix transpose() const {
Matrix res(m, n), a = *this;
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j){
res[j][i] = a[i][j];
}
}
return res;
}
Matrix gauss() const {
Matrix a = *this;
int r = 0;
for(int i = 0; i < m; ++i){
int pivot = -1;
for(int j = r; j < n; ++j){
if(a[j][i] != 0){
pivot = j;
break;
}
}
if(pivot == -1) continue;
for(int j = 0; j < m; ++j){
swap(a[pivot][j], a[r][j]);
}
const T s = a[r][i];
for(int j = i; j < m; ++j){
a[r][j] /= s;
}
for(int j = 0; j < n; ++j){
if(j == r) continue;
const T s = a[j][i];
if(s == 0) continue;
for(int k = i; k < m; ++k){
a[j][k] -= a[r][k] * s;
}
}
++r;
}
return a;
}
int rank(bool is_gaussed = false) const {
Matrix a = *this;
if(!is_gaussed){
return (n >= m ? a : a.transpose()).gauss().rank(true);
}
int r = 0;
for(int i = 0; i < n; ++i){
while(r < m && a[i][r] == 0) ++r;
if(r == m){
return i;
}
++r;
}
return n;
}
// Rotate 90 degrees clockwise
Matrix rotate() const {
Matrix res(m, n), a = *this;
for(int i = 0; i < m; ++i){
for(int j = 0; j < n; ++j){
res[i][j] = a[n - j - 1][i];
}
}
return res;
}
};
template <typename T>
struct compress{
vector<T> sorted;
vector<int> compressed;
compress(const vector<T> &vec){
int n = vec.size();
compressed.resize(n);
for(T x : vec){
sorted.emplace_back(x);
}
sort(sorted.begin(), sorted.end());
sorted.erase(unique(sorted.begin(), sorted.end()), sorted.end());
for(int i = 0; i < n; ++i){
compressed[i] = lower_bound(sorted.begin(), sorted.end(), vec[i]) - sorted.begin();
}
}
int get(const T &x) const{
return lower_bound(sorted.begin(), sorted.end(), x) - sorted.begin();
}
T inv(const int x) const{
return sorted[x];
}
size_t size() const{
return sorted.size();
}
vector<T> getCompressed() const{
return compressed;
}
};
using mint = ModInt<998244353>;
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n;
int m, k;
cin >> n >> m >> k;
vector<int> q;
for(int i = 1; i <= m; i++){
q.push_back(m / i);
}
compress<int> comp(q);
int siz = comp.size();
Matrix<mint> dp(siz, siz), mat(1, siz);
for(int i = 0; i < siz; i++){
for(int j = 1; j <= m; j++){
if(abs(m / j - comp.inv(i)) <= k){
dp[i][comp.get(m / j)]++;
}
}
}
for(int i = 1; i <= m; i++){
mat[0][comp.get(m / i)] += 1;
}
dp = dp.pow(n - 1);
mat *= dp;
mint ans = 0;
for(int i = 0; i < siz; i++){
ans += mat[0][i];
}
cout << ans << "\n";
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0