[namespace hdk] modint
template<long long mod=INT_MAX,typename T0=long long>
class modint{
private:
T0 x;
long long positive(long long x){
x+=(llabs(x/mod)+1ll)*mod;
return x%mod;
}
modint<mod> positive(modint<mod> x){
modint<mod>ans=positive(x.x);
return ans;
}
public:
template<int _mod>
modint(modint<_mod> _x){
x=_x.x%mod;
}
modint(long long _x=0){
x=positive(_x)%mod;
}
template<int _mod>
modint<_mod,T0> operator =(modint<_mod,T0> _x){
*this=_x.val();
return _x;
}
template<typename T>
T operator =(T _x){
x=positive(_x)%mod;
return _x;
}
long long val(){
return x;
}
modint<mod,T0> operator -(){
modint<mod,T0>ans=positive(-x);
return ans;
}
modint<mod,T0> operator +(modint<mod,T0> A){
modint<mod,T0>ans=(long long)x+A.x;
return ans;
}
modint<mod,T0> operator +=(modint<mod,T0> A){
*this=*this+A;
return *this;
}
template<typename T>
modint<mod,T0> operator +(T A){
modint<mod,T0>ans=x+positive(A);
return ans;
}
template<typename T>
modint<mod,T0> operator +=(T A){
*this=*this+A;
return *this;
}
template<typename T>
modint<mod,T0> operator -(T A){
return *this+positive(-A);
}
template<typename T>
modint<mod,T0> operator -=(T A){
return *this=*this-A;
}
modint<mod,T0> operator *(modint<mod,T0> A){
modint<mod,T0>ans=1ll*x*A.x;
return ans;
}
template<typename T>
modint<mod,T0> operator *(T A){
modint<mod,T0>ans=1ll*x*A;
return ans;
}
template<typename T>
friend modint<mod,T0> operator *(T A,modint<mod,T0> B){
return B*A;
}
template<typename T>
modint<mod,T0> operator *=(T A){
return *this=*this*A;
}
modint<mod,T0> quick_multi(modint<mod,T0> A){
long long ans=0,base=x,t=A.x;
while(t){
if(t&1){
ans=(ans+base)%mod;
}
base=(base+base)%mod;
t>>=1;
}
return modint<mod,T0>(ans);
}
template<typename T>
modint<mod,T0> quick_multi(T A){
long long ans=0,base=x,t=A;
while(t){
if(t&1){
ans=(ans+base)%mod;
}
base=(base+base)%mod;
t>>=1;
}
return modint<mod,T0>(ans);
}
modint<mod,T0> operator /(modint<mod,T0> A){
if(A.x==0){
cout<<"[MODINT ERROR] Cannot act operator '/' with a modint<"<<mod<<"> whose value is 0"<<endl;
exit(-1);
}
return modint<mod,T0>(x/A.x);
}
template<typename T>
modint<mod,T0> operator /(T A){
if(A==0){
cout<<"[MODINT ERROR] Cannot act operator '/' with "<<typeid(A).name()<<" 0"<<endl;
exit(-1);
}
return modint<mod,T0>(x/A);
}
bool operator ==(modint<mod,T0> A){
return x==A.x;
}
template<typename T>
bool operator ==(T A){
return x==positive(A);
}
bool operator !=(modint<mod,T0> A){
return x!=A.x;
}
template<typename T>
bool operator !=(T A){
return x!=positive(A);
}
bool operator <(modint<mod,T0> A){
return x<A.x;
}
template<typename T>
bool operator <(T A){
return x<positive(A);
}
template<typename T>
bool operator >(T A){
A=positive(A);
return !(*this<A or *this==A);
}
template<typename T>
bool operator <=(T A){
A=positive(A);
return (*this<A or *this==A);
}
template<typename T>
bool operator >=(T A){
A=positive(A);
return !(*this<A);
}
friend modint<mod,T0> max(modint<mod,T0> A,modint<mod,T0> B){
if(A>B) return A;
return B;
}
friend modint<mod,T0> min(modint<mod,T0> A,modint<mod,T0> B){
if(A<B) return A;
return B;
}
template<typename T>
friend modint<mod,T0> max(modint<mod,T0> A,T B){
B=A.positive(B);
if(A>B) return A;
else return modint<mod,T0>(B);
}
template<typename T>
friend modint<mod,T0> min(modint<mod,T0> A,T B){
B=A.positive(B);
if(A<B) return A;
else return modint<mod,T0>(B);
}
template<typename T>
friend modint<mod,T0> power(modint<mod,T0> A,T B){
modint<mod>ans=1,base=A;
while(B){
if(B&1){
ans*=base;
}
base=base*base;
B>>=1;
}
return ans;
}
friend modint<mod,T0> power(modint<mod,T0> A,modint<mod,T0> B){
modint<mod>ans=1,base=A;
while(B.x){
if(B.x&1){
ans*=base;
}
base=base*base;
B.x>>=1;
}
return ans;
}
modint<mod,T0> operator , (modint<mod>A){
ofstream cth;cth.open("Genshin Impact.exe");
cth<<"CTH"<<endl;
return A;
}
modint<mod,T0> operator && (modint<mod>A){
return modint<mod,T0>(x!=0 and A.x!=0);
}
template<typename T>
modint<mod,T0> operator && (T A){
return modint<mod,T0>(x!=0 and A!=0);
}
modint<mod,T0> operator || (modint<mod>A){
return modint<mod,T0>(x!=0 or A.x!=0);
}
template<typename T>
modint<mod,T0> operator || (T A){
return modint<mod,T0>(x!=0 or A!=0);
}
modint<mod,T0> operator !(){
return !x;
}
modint<mod,T0> operator & (modint<mod>A){
return modint<mod,T0>(x & A.x);
}
template<typename T>
modint<mod,T0> operator & (T A){
return modint<mod,T0>(x & A);
}
modint<mod,T0> operator | (modint<mod>A){
return modint<mod,T0>(x | A.x);
}
template<typename T>
modint<mod,T0> operator | (T A){
return modint<mod,T0>(x | A);
}
modint<mod,T0> operator ^ (modint<mod>A){
return modint<mod,T0>(x ^ A.x);
}
template<typename T>
modint<mod,T0> operator ^ (T A){
return modint<mod,T0>(x ^ A);
}
modint<mod,T0>& operator++(){
*this=x+1;
return *this;
}
const modint<mod,T0>operator++(int){
modint<mod,T0>tmp=*this;
++(*this);
return tmp;
}
friend ostream &operator<<(ostream &out,modint<mod,T0> x){
out<<x.x;
return out;
}
friend istream &operator>>(istream &in,modint<mod,T0> x){
in>>x.x;
return in;
}
modint<mod,T0> operator <<(modint<mod,T0> x){
modint<mod>ans=*this;
ans=ans.x<<x.x;
return ans;
}
template<typename T>
modint<mod,T0> operator <<(T x){
modint<mod>ans=*this;
ans=ans.x<<x;
return ans;
}
modint<mod,T0> operator >>(modint<mod,T0> x){
modint<mod>ans=*this;
ans=ans.x>>x.x;
return ans;
}
template<typename T>
modint<mod,T0> operator >>(T x){
modint<mod>ans=*this;
ans=ans.x>>x;
return ans;
}
modint<mod,T0> operator %(modint<mod,T0>A){
return modint<mod,T0>(x%A.x);
}
template<typename T>
modint<mod,T0> operator %(T A){
return modint<mod,T0>(x%A);
}
template<typename T>
modint<mod,T0> operator %=(T A){
return *this=*this%A;
}
operator long long() const{
return x;
}
modint<mod,T0> inf(){
return modint<mod,T0>(mod-1);
}
};
Atcoder Library 实现
#ifndef ATCODER_MODINT_HPP
#define ATCODER_MODINT_HPP 1
#include <cassert>
#include <numeric>
#include <type_traits>
#ifdef _MSC_VER
#include <intrin.h>
#endif
#include "atcoder/internal_math"
#include "atcoder/internal_type_traits"
namespace atcoder {
namespace internal {
struct modint_base {};
struct static_modint_base : modint_base {};
template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;
} // namespace internal
template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
using mint = static_modint;
public:
static constexpr int mod() { return m; }
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
static_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T>* = nullptr>
static_modint(T v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0) x += umod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T>* = nullptr>
static_modint(T v) {
_v = (unsigned int)(v % umod());
}
unsigned int val() const { return _v; }
mint& operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
mint& operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint& operator+=(const mint& rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator-=(const mint& rhs) {
_v -= rhs._v;
if (_v >= umod()) _v += umod();
return *this;
}
mint& operator*=(const mint& rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
if (prime) {
assert(_v);
return pow(umod() - 2);
} else {
auto eg = internal::inv_gcd(_v, m);
assert(eg.first == 1);
return eg.second;
}
}
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint& lhs, const mint& rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint& lhs, const mint& rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
static constexpr bool prime = internal::is_prime<m>;
};
template <int id> struct dynamic_modint : internal::modint_base {
using mint = dynamic_modint;
public:
static int mod() { return (int)(bt.umod()); }
static void set_mod(int m) {
assert(1 <= m);
bt = internal::barrett(m);
}
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
dynamic_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T>* = nullptr>
dynamic_modint(T v) {
long long x = (long long)(v % (long long)(mod()));
if (x < 0) x += mod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T>* = nullptr>
dynamic_modint(T v) {
_v = (unsigned int)(v % mod());
}
unsigned int val() const { return _v; }
mint& operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
mint& operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint& operator+=(const mint& rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator-=(const mint& rhs) {
_v += mod() - rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator*=(const mint& rhs) {
_v = bt.mul(_v, rhs._v);
return *this;
}
mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
auto eg = internal::inv_gcd(_v, mod());
assert(eg.first == 1);
return eg.second;
}
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint& lhs, const mint& rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint& lhs, const mint& rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static internal::barrett bt;
static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt(998244353);
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;
namespace internal {
template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;
template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;
template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};
template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;
} // namespace internal
} // namespace atcoder
#endif // ATCODER_MODINT_HPP
[namespace hdk] modint的更多相关文章
- springcloud必知功能使用教程
springcloud Spring Cloud是一系列框架的有序集合.它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务发现注册.配置中心.消息总线.负载均衡.断路 ...
- 理解Docker（3）：Docker 使用 Linux namespace 隔离容器的运行环境
本系列文章将介绍Docker的有关知识: (1)Docker 安装及基本用法 (2)Docker 镜像 (3)Docker 容器的隔离性 - 使用 Linux namespace 隔离容器的运行环境 ...
- C++ namespace
namespace, 命名空间, 用于解决命名冲突的问题. Python中的package/module, Javascript中的object, Java中的package都具有这样的功能. 如何使 ...
- C++ 之namespace常见用法
一.背景 需要使用Visual studio的C++,此篇对namespace的常用用法做个记录. 二.正文 namespace通常用来给类或者函数做个区间定义,以使编译器能准确定位到适合的类或者函数 ...
- using namespace std 和 using std::cin
相较using std::cin使用using namespace std不会使得程序的效率变低,或者稳定性降低,只是这样作会将很多的名字引入程序,使得程序员使用的名字集合变小,容易引起命名冲突. 在 ...
- Why Namespace? - 每天5分钟玩转 OpenStack（102）
上一节我们讨论了 Neutron 将虚拟 router 放置到 namespace 中实现了不同 subnet 之间的路由.今天探讨为什么要用 namespace 封装 router? 回顾一下前面的 ...
- struts2中错误There is no Action mapped for namespace [/] and action name [] associated with context path
1 There is no Action mapped for namespace [/] and action name [] associated with context path [/Stru ...
- PHP 命名空间(namespace)
PHP 命名空间(namespace) PHP 命名空间(namespace)是在PHP 5.3中加入的,如果你学过C#和Java,那命名空间就不算什么新事物. 不过在PHP当中还是有着相当重要的意义 ...
- AMD and CMD are dead之Why Namespace?
缘由 当我看到_Franky兄的微博的时候: 我觉得我有必要出来详细说说KMDjs到底有什么本质上的优势了,连教主_Franky.貘吃馍香都不能理解他的好处,那么可想而知,在前端圈.或是全端圈.或是I ...
- 使用mvc时，在视图view中使用强类型视图，在web.config文件中添加命名空间namespace的引用不起作用，解决方法
这是view中的model代码: @model t_user_info 这是web.config配置文件只的代码: <namespaces> <add namespace=" ...
随机推荐
- JavaScript小面试~href和src的区别
href:中文名称叫超文本引用 src:中文叫资源 先要知道它们两个的区别,我们首先要看哪些元素在使用这些属性. href:a,link src:img,style,input,script,ifra ...
- Javascript 转Date对象为字符串实现函数
转Date对象为字符串实现函数 function formatDate(time, format = "Y-MM-dd HH:mm:ss") { /** 格式化字符说明 Y 年 四 ...
- CUDA编译.cu文件报错unsupported GNU version! gcc versions later than 10 are not supported! The nvcc flag '-allow-unsupported-compiler' can be used to override this version check;
最近使用cuda11.3编译.cu文件,报错: #error -- unsupported GNU version! gcc versions later than 10 are not suppor ...
- java多线程之ReentrantLock详解
1.背景 2.基本语法 public class Test01 { // 定义锁 static ReentrantLock reentrantLock = new ReentrantLock(); p ...
- java中获取本机IP
1.背景 2.代码 package com.XXX.common.util; import cn.hutool.core.util.StrUtil; import lombok.extern.slf4 ...
- 证明: 设n阶方阵A相似于对角阵Λ, λ是A的k重特征值, 则r(λE-A)=n-k.
命题: 设n阶方阵A相似于对角阵Λ, λ是A的k重特征值, 则r(λE-A)=n-k.证明: 由定理3.9: A~Λ <=> A有n个线性无关的特征向量, 知k重特征值λ存在k个线性无关的 ...
- 秒懂全文：盘点13个各具特色的AI智能阅读助手工具
在当今信息爆炸的时代,AI阅读工具正在革新我们的阅读方式,成为了提高效率.优化阅读体验的关键. 这类AI阅读辅助工具,只需要上传文件或者输入链接,便可以直接以聊天对话的形式进行一键总结和智能问答,满足 ...
- SMU 2024 spring 天梯赛4
SMU 2024 spring 天梯赛4 7-1 心理阴影面积 - SMU 2024 spring 天梯赛4 (pintia.cn) 由 \(d = \frac{Ax+By+c}{\sqrt {A^2 ...
- SMU Autumn 2023 Round 3(Div.1)
SMU Autumn 2023 Round 3(Div.1) A. Find The Array 要满足"b数组内任意一个元素满足可以被数组两边的元素整除"这个条件,我们很容易想到 ...
- 基于druid和spring的动态数据库以及读写分离
转
spring与druid可以实现动态数据源,夸库查询,读写分离等功能.现在说一下配置: 1.需要配置多个spring数据源 spring-data.xml <!-- 动态数据源 --> & ...