记一个 modint 类的实现

upd 22/8/27

避免构造函数多次取模的加速优化__construct()，更新了构造函数。

比 1.0 快一点点。

实际运行的时候建议删去一些不用的函数，保证效率

namespace simpler{
    template<const unsigned _Mod=INT32_MAX>
    class modint{
    protected:
        int64_t _val;
        typedef modint<_Mod> _mint;
        friend inline _mint 
        __construct(_mint&& _res,int64_t _x){
            _res._val=_x;
            return _res;
        }
        template<class _Tp>friend _mint
        __quickly_power(_mint _a,_Tp _b){
            if(_b<=0)return 1;
            _mint _res=1;
            for(;(bool)_b;_b>>=1,_a*=_a)if(_b&1)_res*=_a;
            return _res;
        }
    public:
        modint():_val(0){}
        template<class _Tp>modint(_Tp _x){
            _val=((int64_t)_x%_Mod+_Mod)%_Mod;
        }
        template<class _Tp>explicit inline operator _Tp(){return (_Tp)_val;}

        friend _mint operator+(const _mint& _a,const _mint& _b){
            if(_a._val+_b._val>=_Mod)return __construct(_mint(),_a._val+_b._val-_Mod);
            return __construct(_mint(),_a._val+_b._val);
        }
        inline _mint& operator+=(const _mint& _b){return *this=*this+_b;}
        inline _mint& operator++(){return *this=*this+__construct(_mint(),1);}
        inline _mint& operator++(int){
            _mint _res=*this;*this=*this+__construct(_mint(),1);
            return _res;
        }//plus
        friend _mint operator-(const _mint& _a,const _mint& _b){
            if(_a._val-_b._val<0)return __construct(_mint(),_a._val-_b._val+_Mod);
            return __construct(_mint(),_a._val-_b._val);
        }
        inline _mint& operator-=(const _mint& _b){return *this=*this-_b;}
        inline _mint& operator--(){return *this=*this-__construct(_mint(),1);}
        inline _mint& operator--(int){
            _mint _res=*this;*this=*this-__construct(_mint(),1);
            return _res;
        }//minus
        friend inline _mint 
        operator*(const _mint& _a,const _mint& _b){
            return __construct(_mint(),_a._val*_b._val%_Mod);
        }
        inline _mint& operator*=(const _mint& _b){return *this=*this*_b;}//multiplies
        _mint operator-(){return __construct(_mint(),_val?_Mod-_val:_val);}//negative
        friend inline _mint
        operator%(const _mint& _a,const _mint& _b){
            return __construct(_mint(),_a._val%_b._val);
        }
        inline _mint& operator%=(const _mint& _b){return *this=*this%_b;}//modulus

        friend inline bool
        operator==(const _mint& _a,const _mint& _b){
            return _a._val==_b._val;
        }
        friend inline bool
        operator!=(const _mint& _a,const _mint& _b){
            return _a._val!=_b._val;
        }
        friend inline bool
        operator<(const _mint& _a,const _mint& _b){
            return _a._val<_b._val;
        }
        friend inline bool
        operator>(const _mint& _a,const _mint& _b){
            return _a._val>_b._val;
        }
        friend inline bool
        operator<=(const _mint& _a,const _mint& _b){
            return _a._val<=_b._val; 
        }
        friend inline bool
        operator>=(const _mint& _a,const _mint& _b){
            return _a._val>=_b._val;
        }

        friend inline _mint
        operator&(const _mint& _a,const _mint& _b){
            return _a._val&_b._val;
        }
        inline _mint& operator&=(const _mint& _b){return *this=*this&_b;}
        friend inline _mint
        operator|(const _mint& _a,const _mint& _b){
            return _a._val|_b._val;
        }
        inline _mint& operator|=(const _mint& _b){return *this=*this|_b;}
        friend inline _mint
        operator^(const _mint& _a,const _mint& _b){
            return _a._val^_b._val;
        }
        inline _mint& operator^=(const _mint& _b){return *this=*this^_b;}
        friend inline _mint
        operator<<(const _mint& _a,const _mint& _b){
            return _a._val<<_b._val;
        }
        inline _mint& operator<<=(const _mint& _b){return *this=*this<<_b;}
        friend inline _mint
        operator>>(const _mint& _a,const _mint& _b){
            return _a._val>>_b._val;
        }
        inline _mint& operator>>=(const _mint& _b){return *this=*this>>_b;}
        inline _mint operator~()const{return __construct(_mint(),~_val);}
        inline bool  operator!()const{return !_val;}

        friend inline std::istream&
        operator>>(std::istream& _is,_mint& _b){
            return _is>>_b._val;
        }
        friend inline std::ostream&
        operator<<(std::ostream& _os,const _mint& _b){
            return _os<<_b._val;
        }

        template<class _Tp>_mint
        power(_Tp _n)const{
            return __quickly_power(*this,_n);
        }
        inline _mint inv()const{return __quickly_power(*this,_Mod-2);}

        friend inline _mint 
        operator/(const _mint& _a,const _mint& _b){
            return __construct(_mint(),_a._val*_b.inv()._val%_Mod);
        }
        inline _mint& operator/=(const _mint& _b){return *this=*this/_b;}
    };//modint 2.0
}

示例（[CF1603C Extreme Extension](Problem - 1603C - Codeforces)）

#include<cstdio>
#include<cstring>
#include<iostream>
namespace simpler{...//此处粘贴上述代码
using namespace std;
using mint=simpler::modint<998244353>;
const int Maxn=1e5+5;
mint a[Maxn];
mint f[2][Maxn];
void solve(){
    int n;cin>>n;
    for(int i=1;i<=n;++i)cin>>a[i];
    mint res=0;
    int cur=0;
    memset(f,0,sizeof f);
    for(int i=n;i>1;--i,cur^=1){
        f[cur^1][(int)a[i]]+=1;
        int l=1;
        while(l<=a[i]){
            int c=(int)a[i]/l;
            int r=(int)a[i]/c;
            if(f[cur^1][c]){
                int k=(int)(a[i-1]+c-1)/c;
                f[cur][(int)a[i-1]/k]+=f[cur^1][c];
                res+=f[cur^1][c]*(i-1)*(k-1);
                f[cur^1][c]=0;
            }
            l=r+1;
        }
    }
    cout<<res<<'\n';
}
int main(){
    int T;cin>>T;
    while(T--)solve();
    return 0;
}