C++自动取模的模数类

最新推荐文章于 2024-05-16 14:27:53 发布
最新推荐文章于 2024-05-16 14:27:53 发布
阅读量1.1k 收藏 3
点赞数 4
分类专栏： # 组合数学 ---------- 杂项 ---------- 文章标签： 取模 自定义类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C20190102/article/details/102940879
版权

一直想写，今天终于写出来了。

使用方法：ModNumber<MOD> k，可以定义一个模MOD意义下的变量k，它接下来的所有运算都自动模MOD，不需要再手写。

具体操作方法请自行探索：

#define int long long

template<const int _MOD> struct ModNumber{
    int x;
    ModNumber(){x=0;}
    ModNumber(LL y){x=y%_MOD;}
    int Int(){return x;}
    int Pow(int y){
        int ret=1,tmp=x;
        while(y){
            if(y&1)
                ret=((LL)ret*tmp)%_MOD;
            y>>=1;
            tmp=((LL)tmp*tmp)%_MOD;
        }
        return ret;
    }
    void operator = (LL y){x=y%_MOD;}
    bool operator == (LL y) const{return x==y;}
    bool operator == (ModNumber y) const{return x==y.x;}
    bool operator != (LL y) const{return x!=y;}
    bool operator != (ModNumber y) const{return x!=y.x;}
    bool operator < (LL y) const{return x<y;}
    bool operator < (ModNumber y) const{return x<y.x;}
    bool operator > (LL y) const{return x>y;}
    bool operator > (ModNumber y) const{return x>y.x;}
    bool operator <= (LL y) const{return x<=y;}
    bool operator <= (ModNumber y) const{return x<=y.x;}
    bool operator >= (LL y) const{return x>=y;}
    bool operator >= (ModNumber y) const{return x>=y.x;}
    ModNumber operator + (ModNumber y) const{return ((LL)x+y.x)%_MOD;}
    ModNumber operator * (ModNumber y) const{
        return ((LL)x*y.x)%_MOD;
    }
    ModNumber operator - (ModNumber y) const{return ((x-y.x)%_MOD+_MOD)%_MOD;}
    ModNumber operator + (LL y) const{return ((LL)x+y)%_MOD;}
    ModNumber operator * (LL y) const{return ((LL)x*y)%_MOD;}
    ModNumber operator - (LL y) const{return ((x-y)%_MOD+_MOD)%_MOD;}
    void operator += (ModNumber y){*this=*this+y;}
    void operator *= (ModNumber y){*this=*this*y;}
    void operator -= (ModNumber y){*this=*this-y;}
    void operator += (LL y){x=((LL)x+y)%_MOD;}
    void operator *= (LL y){x=((LL)x*y)%_MOD;}
    void operator -= (LL y){x=((x-y)%_MOD+_MOD)%_MOD;}
    ModNumber operator ^ (int y){
        ModNumber ret=Pow(y);
        return ret;
    }
    ModNumber operator / (ModNumber y) const{
        return ((LL)x*(y.Pow(_MOD-2)))%_MOD;
    }
    void operator /= (ModNumber y){*this=*this/y;}
    template<class T> friend bool operator == (T y,ModNumber t){return y==t.x;}
    template<class T> friend ModNumber operator + (T t,ModNumber y){return ((LL)t+y.x)%_MOD;}
    template<class T> friend ModNumber operator * (T t,ModNumber y){return ((LL)t*y.x)%_MOD;}
    template<class T> friend ModNumber operator - (T t,ModNumber y){return ((t-y.x)%_MOD+_MOD)%_MOD;}
    template<class T> friend ModNumber operator / (T t,ModNumber y){return ModNumber((y/t).Pow(_MOD-2));}
    ModNumber operator / (int y) const{return ((LL)x*(ModNumber(y).Pow(_MOD-2)))%_MOD;}
    void operator /= (int y){*this=*this/y;}
    void operator ++ (){*this=*this+1;}
    void operator -- (){*this=*this-1;}
    void operator ++ (int k){*this=*this+1;}
    void operator -- (int k){*this=*this-1;}
};

例题：（树哈希）BZOJ4754 [Jsoi2016]独特的树叶

具体做法请等待后续博客，这里粘个用这个写的哈希代码（比自然溢出慢一点，但能过，模数用 1 0 9 + 7 10^9+7 109+7可以过， 998244353 998244353 998244353不行！）：

#include<set>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;

#define LL long long

template<const int _MOD> struct ModNumber{
    int x;
    ModNumber(){x=0;}
    ModNumber(LL y){x=y%_MOD;}
    int Int(){return x;}
    int Pow(int y){
        int ret=1,tmp=x;
        while(y){
            if(y&1)
                ret=((LL)ret*tmp)%_MOD;
            y>>=1;
            tmp=((LL)tmp*tmp)%_MOD;
        }
        return ret;
    }
    void operator = (LL y){x=y%_MOD;}
    bool operator == (LL y) const{return x==y;}
    bool operator == (ModNumber y) const{return x==y.x;}
    bool operator != (LL y) const{return x!=y;}
    bool operator != (ModNumber y) const{return x!=y.x;}
    bool operator < (LL y) const{return x<y;}
    bool operator < (ModNumber y) const{return x<y.x;}
    bool operator > (LL y) const{return x>y;}
    bool operator > (ModNumber y) const{return x>y.x;}
    bool operator <= (LL y) const{return x<=y;}
    bool operator <= (ModNumber y) const{return x<=y.x;}
    bool operator >= (LL y) const{return x>=y;}
    bool operator >= (ModNumber y) const{return x>=y.x;}
    ModNumber operator + (ModNumber y) const{return ((LL)x+y.x)%_MOD;}
    ModNumber operator * (ModNumber y) const{
        return ((LL)x*y.x)%_MOD;
    }
    ModNumber operator - (ModNumber y) const{return ((x-y.x)%_MOD+_MOD)%_MOD;}
    ModNumber operator + (LL y) const{return ((LL)x+y)%_MOD;}
    ModNumber operator * (LL y) const{return ((LL)x*y)%_MOD;}
    ModNumber operator - (LL y) const{return ((x-y)%_MOD+_MOD)%_MOD;}
    void operator += (ModNumber y){*this=*this+y;}
    void operator *= (ModNumber y){*this=*this*y;}
    void operator -= (ModNumber y){*this=*this-y;}
    void operator += (LL y){x=((LL)x+y)%_MOD;}
    void operator *= (LL y){x=((LL)x*y)%_MOD;}
    void operator -= (LL y){x=((x-y)%_MOD+_MOD)%_MOD;}
    ModNumber operator ^ (int y){
        ModNumber ret=Pow(y);
        return ret;
    }
    ModNumber operator / (ModNumber y) const{
        return ((LL)x*(y.Pow(_MOD-2)))%_MOD;
    }
    void operator /= (ModNumber y){*this=*this/y;}
    template<class T> friend bool operator == (T y,ModNumber t){return y==t.x;}
    template<class T> friend ModNumber operator + (T t,ModNumber y){return ((LL)t+y.x)%_MOD;}
    template<class T> friend ModNumber operator * (T t,ModNumber y){return ((LL)t*y.x)%_MOD;}
    template<class T> friend ModNumber operator - (T t,ModNumber y){return ((t-y.x)%_MOD+_MOD)%_MOD;}
    template<class T> friend ModNumber operator / (T t,ModNumber y){return ModNumber((y/t).Pow(_MOD-2));}
    ModNumber operator / (int y) const{return ((LL)x*(ModNumber(y).Pow(_MOD-2)))%_MOD;}
    void operator /= (int y){*this=*this/y;}
    void operator ++ (){*this=*this+1;}
    void operator -- (){*this=*this-1;}
    void operator ++ (int k){*this=*this+1;}
    void operator -- (int k){*this=*this-1;}
};

#define MAXN 100000
#define ULL ModNumber<1000000007>
//懒得改以前的代码所以直接把#define ULL long long改成了#define ULL ModNumber<1000000007>

ULL P[MAXN+5];
struct TreeHash{
    int N;
    int Size[MAXN+5];
    vector<int> G[MAXN+5];
    ULL Hash[MAXN+5],Up[MAXN+5],Down[MAXN+5];
    void Init(int n){
        N=n;
        for(int i=1;i<N;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
    }
    void Dfs1(int u,int fa){
        for(int i=0;i<int(G[u].size());i++){
            int v=G[u][i];
            if(v!=fa){
                Dfs1(v,u);
                Size[u]+=Size[v];
                Down[u]+=P[Size[v]]*Down[v];
            }
        }
        Size[u]++;
        Down[u]++;
    }
    void Dfs2(int u,int fa){
        Up[u]=P[N-Size[u]]*(Up[fa]+Down[fa]-Down[u]*P[Size[u]]);
        Hash[u]=Down[u]+Up[u];
        for(int i=0;i<int(G[u].size());i++){
            int v=G[u][i];
            if(v!=fa)
                Dfs2(v,u);
        }
    }
    void GetHash(){
        Dfs1(1,-1);
        Dfs2(1,-1);
    }
}A,B;

set<ULL> S;

int main(){
    int N;
    scanf("%d",&N);
    srand(998244353);
    for(int i=1;i<=N;i++)
        P[i]=rand();
    A.Init(N),A.GetHash();
    B.Init(N+1),B.GetHash();
    for(int i=1;i<=N;i++)
        S.insert(A.Hash[i]);
    for(int i=1;i<=N+1;i++)
        if(B.G[i].size()==1)
           if(S.count(B.Hash[B.G[i][0]]-P[1]))
                return printf("%d\n",i),0;
}

用模数类：
用模数类
自然溢出：
自然溢出

综上：有被卡常的风险！可能需要双哈希！作者不对此代码负责！！

ixRic
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++快速幂取模.cpp
04-13
C++快速幂取模代码，可根据需要自行调整优化，刷题的时候计算溢出可以用它解决，算法入门代码，可以直接复制使用
C++使用string的大数取模运算（5）
08-25
本文主要介绍了使用C++语言中string类来实现大数取模运算的方法。该方法主要用于解决大数的加减乘除和取模运算问题。 首先，需要注意的是大数指的是远超long long int的数据，而不是普通的整数类型。在这种情况下，...
关于c++ mod的性质的一些总结
weixin_61133168的博客
01-12 3201
所谓mod，也就是取余，在c++中用’%‘表示，是非常常见的一种对数据的处理方式，通俗的说，a mod b 等于a除以b的余数（当然了，b不能等于0）,a、b都得为整数。下面，介绍一些它的性质。所谓模同余，就是两个数对同一个数取模，如果结果相同，则称他们模同余。
【C++ 取模mod易错点】由于答案可能会很大，请你将结果对1e9+7取模后再返回
捡起一束光的博客
02-11 1万+
在做算法题时我们经常会遇到这样一句话： 由于答案可能会很大，请你将结果对10^9 + 7取模后再返回 这句话看上去只要对变量取模就可以了，但实际上取模的时机有一定的讲究，比如新手很容易犯一下两个错误 错误1：用max比较很大数据时，先取模 取mod的时候，如果题目要求你算最大值，并且说由于答案可能很大，输出结果请对1e9+7取，那你千万不能在max函数更新最大值时就取模，这样很可能会出错 比如：题.........
C++中%和MOD的区别
最新发布
qq_75225791的博客
05-16 303
例：a mod b=（a%b+b）%b；是取余的意思，但是在C++中。，符号取决于左操作数，而。余出来的数只能是正数。
(C++) 基于重载运算符的自动取模
cuber-lotus的博客
04-22 1501
文章目录直接上代码前言各部分介绍宏定义成员变量辅助函数构造和析构get/set仿函数标准输入输出重载`+= -= *= /=`重载`+ - * /`重载自增，自减运算符`++ --`重载比较、逻辑运算符一些使用注意点END 直接上代码 // #define int long long #ifndef MOD #define MOD 1e9+7 class Num { private: static const int mod = MOD; int val = 0; protected:
C++（C#）取余和取模运算
12-01
在编程语言中，运算符 `%` 通常被用于执行取余或取模操作，这个概念在C++和C#中同样适用。然而，虽然这两门语言都使用同一个符号，但理解其背后的运算行为是非常重要的，因为不同的上下文可能导致不同的结果。在这里...
用C++封装的CRandom类
08-02
本文将深入探讨一个名为`CRandom`的类，它被封装用来简化和增强C++中的随机数生成功能。这个类允许开发者轻松地生成指定范围内的随机整数、浮点数以及布尔值，提高了代码的可读性和复用性。 `CRandom`类的核心在于...
C++ 自动化 操作Word
05-02
结合自动化技术，我们可以利用C++实现对各种应用程序的控制，其中包括Microsoft Word这样的办公软件。本篇将深入探讨如何使用C++进行Word的自动化操作，如创建文档、插入段落以及保存文件。 首先，要实现C++对Word...
C++实现与matlab中的mod函数
qq_42102393的博客
09-07 1503
matlab中的mod函数的取值规律： res = mod(a, b) matlab文档帮助：mod(x,y) is x - n.*y where n = floor(x./y) if y ~= 0. 换句话说： 1、同号求模 res = a - int(a / b) * b 2、异号求模 能整除时，res = 0 不能整除时，res 的符号为 b 的符号，绝对值为 (abs(a)/abs(b) + 1) * abs(b) - abs(a) ...
模数求和 C++解法
菜鸡工坊
07-15 810
题目描述 现给定n个整数，并定义一个非负整数m，且令f(m) = (m%a1)+(m%a2)+…+(m%an)。 此处的X % Y的结果为X除以Y的余数。 现请你找出一个m，求出f(m)的最大值。 输入描述: 输入包含两行，第一行为一正整数n，(1<n<=3000) 第二行为n个整数a1,a2,…,an ，其中(2<=ai<=10^5) 输出描述: 输出仅包含一行，输出f(...
C++中取模运算mod和取余运算rem的区别
weixin_53475254的博客
09-06 7652
一般运算 数a，对数b进行取模或者取余运算 先求出a对b的除数 c = a / b 然后算出余数 d = a - b*c 区别 取模和取余运算的区别就在于a对b做除法的时候是怎样来取整的。 对于c++， %运算符是取余，采取了向零取整的方式。 5 ÷ 3 = 1.6666 向零取整为1 -5 ÷ 3 = - 1.6666向零取整为-1 对于(5) % (-3) 得到式子： 5 - (-3 * (-1)) = 2 对于(-5) % (3) 得到： -5 - (3 * (-1) ) = -2 取模采用了
C++使用string的大数运算（6）模加模减模乘模幂
我总是临时
04-30 815
本次项目目标：使用C++完成对于大数的相关运算项目要点1.大数指的是远超long long int的数据2.将大数用矩阵进行存储，并通过矩阵实现运算3.本人采用字符串进行存储，应注意char的特点比如：char a=161；     cout&lt;&lt;(int)a;此时会输出-95，而不是161，char类型首个比特位是作为正负号的这四个只要你完成了大数的加减乘法，以及取模运算之后就很简单了...
mod函数详解
飘的梦客厅
10-12 8127
 我们知道，mod函数是一个求余函数，其格式为： mod(nExp1,nExp2)，即是两个数值表达式作除法运算后的余数。那么：两个同号整数求余与你所知的两个正数求余完全一样(即两个负整数与两个正整数的算法一样)。 一、两个异号整数求余 1.函数值符号规律(余数的符号) mod(负,正)=正 mod(正,负)=负 结论：两个整数求余时，其值的符号为除数的符号。 2.取值规律 先将两个整数看作是正数
c++ 常用函数
jinchengzhou的专栏
06-24 1664
C/C++头文件一览 C #include <assert.h>　　　　//设定插入点 #include <ctype.h>　　　　 //字符处理 #include <errno.h>　　　　 //定义错误码 #include <float.h>　　　　 //浮点数处理 #include <iso646.h> //对应...
取余与取模的区别，以及在C++（C#）中的使用
热门推荐
Stones的博客
12-01 3万+
取余与取模的区别，以及在C++（C#）中的使用 c++和C#中，运算符‘%’为取余运算符，而并非取模预算符，在一些应用场景中，如果不加以区分，会产生严重的bug。 取余运算（Complementation）和取模运算（Modulo Operation）的区别： 对于整型数a，b来说，取模运算或取余运算的方法都是： 第一步：求 整数商： c = a/b; 第二步：计算模或者余数： r =
【C++心路历程8】mod mod哒
ctf109的博客
10-15 3893
(a+b) mod p = (a mod p + b mod p) mod p (a*b) mod p = ((a mod p) * (b mod p)) mod p (a-b) mod p = ((a mod p)-(b mod p) + p) mod p   三个重要公式   C++中有求余运算符号’%’，也是求余数功能，但和mod 有区别，mod 的结果一定是非负数， 而%
C++入门：类与对象详解
本资源是一份C++课件，主要聚焦于C++中的类和对象概念。C++是面向对象的编程语言，其基石就是类和对象。在课件的第一讲中，它涵盖了以下几个关键知识点： 1. 类的定义：类是一种用户自定义的数据类型，用于组织和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值