数运算的一些模板

最新推荐文章于 2024-02-24 23:32:17 发布
最新推荐文章于 2024-02-24 23:32:17 发布
阅读量333 收藏
点赞数
分类专栏： ACM知识点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xtulollipop/article/details/52611251
版权

用过的一些模板
1.分数类的运算

#include <utility>
#include <algorithm>
using namespace std;
using namespace rel_ops;

template <class VAL = long long> class Frac {
public:
    VAL num,den;
    Frac(){}
    Frac(const VAL& x, const VAL& y = 1){
        den=__gcd(x,y);
        num=x/den,den=y/den;
        if(den<0) num=-num,den=-den;
    }
    bool operator <(const Frac& rhs) const {
        return num*rhs.den<rhs.num*den;
    }
    bool operator==(const Frac& rhs) const {
        return num==rhs.num && den==rhs.den;
    }
    Frac operator +(const Frac& rhs) const {
        return Frac(num*rhs.den+den*rhs.num,den*rhs.den);
    }
    Frac operator -(const Frac& rhs) const {
        return Frac(num*rhs.den-den*rhs.num,den*rhs.den);
    }
    Frac operator *(const Frac& rhs) const {
        return Frac(num*rhs.num,den*rhs.den);
    }
    Frac operator /(const Frac& rhs) const {
        return Frac(num*rhs.den,den*rhs.num);
    }
    Frac operator -() const {return Frac(-num,den);}
    Frac& operator +=(const Frac& rhs){return *this=*this+rhs;}
    Frac& operator -=(const Frac& rhs){return *this=*this-rhs;}
    Frac& operator *=(const Frac& rhs){return *this=*this*rhs;}
    Frac& operator /=(const Frac& rhs){return *this=*this/rhs;}
};

2.取膜运算

class Imp {
public:
    static const int MOD = 1000000007;
    typedef long long LL;
    int u;
    Imp(){};    // 以下所有函数的传入参数都必须在[0,MOD)之间
    Imp(int v):u(v){}   // 且运算符左侧类型必须是Imp
    operator int&(){return u;}
    operator const int&() const {return u;}
    Imp operator +(int v) const {return u+v<MOD?u+v:u+v-MOD;}
    Imp operator -(int v) const {return u<v?u-v+MOD:u-v;}
    Imp operator *(int v) const {return u*LL(v)%MOD;}
    Imp operator /(int v) const {return u*RR(v)%MOD;}
    Imp operator -() const {return u?MOD-u:0;}
    Imp& operator +=(int v){u+=u+v<MOD?v:v-MOD; return *this;}
    Imp& operator -=(int v){u-=u<v?v-MOD:v; return *this;}
    Imp& operator *=(int v){u=u*LL(v)%MOD; return *this;}
    Imp& operator /=(int v){u=u*RR(v)%MOD; return *this;}
    static LL RR(int x){
        return x>1?RR(MOD%x)*(MOD-MOD/x)%MOD:x;
    }
};

3.大数运算

#include <cstdio>
#include <string>
#include <cstring>
using namespace std;

class BigNum {
public:
    static const int MOD = 100000000;
    static const int BIT = 8, SIZE = 105;
    mutable int n,o;
    long long u[SIZE];
    BigNum(){}
    BigNum(const string& s){
        memset(this,0,sizeof(BigNum));
        int num=0,cnt=1;
        for(int i=s.size()-1;~i;i--){
            if(s[i]=='-') o^=1;
            if(s[i]>='0' && s[i]<='9'){
                num+=(s[i]-'0')*cnt;
                cnt*=10;
                if(cnt==MOD) u[n++]=num,num=0,cnt=1;
            }
        }
        if(!n || cnt>=10) u[n++]=num;
        if(!u[0] && n==1) o=0;
    }
    BigNum(long long x){
        memset(this,0,sizeof(BigNum));
        if(x<0) o=1,x=-x;
        do u[n++]=x%MOD; while(x/=MOD);
    }
    operator string() const {
        static char s[SIZE*BIT+10];
        char* c=s+sprintf(s,"%s%d",o?"-":"",int(u[n-1]));
        for(int i=n-2;~i;i--) c+=sprintf(c,"%0*d",BIT,int(u[i]));
        return s;
    }
    int operator [](int pos) const {
        static int e[BIT]={1};
        for(static int i=1;i<BIT;i++) e[i]=e[i-1]*10;
        return u[pos/BIT]/e[pos%BIT]%10;
    }
    int length() const {
        int ret=(n-1)*BIT+1;
        for(int x=u[n-1]/10;x;x/=10) ret++;
        return ret;
    }
    friend int cmp(const BigNum& l, const BigNum& r){
        if(l.o!=r.o) return (l.o?-1:1);
        if(l.n!=r.n) return (l.o?-1:1)*(l.n-r.n);
        for(int i=l.n-1;~i;i--) if(l.u[i]-r.u[i])
                return (l.o?-1:1)*(l.u[i]-r.u[i]);
        return 0;
    }
    // 运算符
    bool operator < (const BigNum& r) const {return cmp(*this,r)<0;}
    bool operator > (const BigNum& r) const {return cmp(*this,r)>0;}
    bool operator <=(const BigNum& r) const {return cmp(*this,r)<=0;}
    bool operator >=(const BigNum& r) const {return cmp(*this,r)>=0;}
    bool operator ==(const BigNum& r) const {return cmp(*this,r)==0;}
    bool operator !=(const BigNum& r) const {return cmp(*this,r)!=0;}
    BigNum operator +(const BigNum& r) const {return BigNum(*this)+=r;}
    BigNum operator -(const BigNum& r) const {return BigNum(*this)-=r;}
    BigNum operator *(int x) const {return BigNum(*this)*=x;}
    BigNum operator /(int x) const {return BigNum(*this)/=x;}
    BigNum& operator *=(const BigNum& r){return *this=*this*r;}
    BigNum& operator /=(const BigNum& r){return *this=*this/r;}
    BigNum& operator %=(const BigNum& r){return *this=*this%r;}
    BigNum& operator %=(int x){return *this=*this%x;}
    BigNum operator -() const {
        BigNum s=*this;
        if(s.u[0] || s.n>=2) s.o^=1;
        return s;
    }
    BigNum& operator +=(const BigNum& r){
        if(r.n==1 && !r.u[0]) return *this;
        if(r.o^o) return r.o^=1,*this-=r,r.o^=1,*this;
        if(r.n>n) n=r.n;
        for(int i=0;i<r.n;i++) u[i]+=r.u[i];
        for(int i=0;i<n;i++) if(u[i]>=MOD) u[i+1]++,u[i]-=MOD;
        if(u[n]) n++;
        return *this;
    }
    BigNum& operator -=(const BigNum& r){
        if(r.n==1 && !r.u[0]) return *this;
        if(r.o^o) return r.o^=1,*this+=r,r.o^=1,*this;
        if(cmp(*this,r)*(r.o?-1:1)<0){
            o^=1,n=r.n;
            for(int i=0;i<r.n;i++) u[i]=r.u[i]-u[i];
        }else{
            for(int i=0;i<r.n;i++) u[i]=u[i]-r.u[i];
        }
        for(int i=0;i<n;i++) if(u[i]<0) u[i+1]--,u[i]+=MOD;
        while(!u[n-1] && n>=2) --n;
        if(!u[0] && n==1) o=0;
        return *this;
    }
    BigNum operator *(const BigNum& r) const {
        BigNum s=0;
        if(!u[n-1] || !r.u[r.n-1]) return s;
        s.n=r.n+n-1;
        s.o=r.o^o;
        for(int i=0;i<n;i++) for(int j=0;j<r.n;j++)
            s.u[i+j]+=u[i]*r.u[j];
        for(int i=0;i<s.n;i++) if(s.u[i]>=MOD){
            s.u[i+1]+=s.u[i]/MOD;
            s.u[i]%=MOD;
            if(i==s.n-1) s.n++;
        }
        return s;
    }
    BigNum operator /(const BigNum& r) const {
        BigNum e[35],s=0,c=0;
        int m=0,ro=r.o,lo=o;
        r.o^=ro,o^=lo;
        for(e[m]=r;MOD>>++m;e[m]=e[m-1]+e[m-1]);
        for(int i=n-1;~i;i--){
            int tag=0;
            (s*=MOD)+=u[i];
            for(int x=m-1;~x;x--) if(s>=e[x]) s-=e[x],tag|=1<<x;
            (c*=MOD)+=tag;
        }
        r.o^=ro,o^=lo;
        if(c.u[0] || c.n>=2) c.o=r.o^o;
        return c;
    }
    BigNum operator %(const BigNum& r) const {
        BigNum e[35],s=0;
        int m=0,ro=r.o,lo=o;
        r.o^=ro,o^=lo;
        for(e[m]=r;MOD>>++m;e[m]=e[m-1]+e[m-1]);
        for(int i=n-1;~i;i--){
            (s*=MOD)+=u[i];
            for(int x=m-1;~x;x--) if(s>=e[x]) s-=e[x];
        }
        r.o^=ro,o^=lo;
        if(s.u[0] || s.n>=2) s.o=o;
        return s;
    }
    BigNum& operator *=(int x){
        if(!x) return *this=0;
        if(x<0) o^=1,x=-x;
        for(int i=0;i<n;i++) u[i]*=x;
        for(int i=0;i<n;i++) if(u[i]>=MOD){
            u[i+1]+=u[i]/MOD;
            u[i]%=MOD;
            if(i==n-1) n++;
        }
        if(!u[0] && n==1) o=0;
        return *this;
    }
    BigNum& operator /=(int x){
        if(x<0) o^=1,x=-x;
        for(int i=n-1;i;u[i--]/=x) u[i-1]+=u[i]%x*MOD;
        for(u[0]/=x;n>=2;n--) if(u[n-1]) break;
        if(!u[0] && n==1) o=0;
        return *this;
    }
    int operator %(int x) const {
        long long c=0;
        for(int i=n-1;~i;i--) c=(c*MOD+u[i])%x;
        return (1-o-o)*int(c);
    }
};
xtulollipop
关注
专栏目录
算法优化-模板运算
wuyou_365的专栏
12-17 1008
模板运算在图像处理中非常普遍，模板运算普遍运算量大，但可以通过避免其中许多重复的运算达到优化的效果，以下以krisch算子为例来说明如何避免重复运算，krisch算子包含8个3x3模板： 具体运算过程是对于源图像的每一个像素和它的8邻域与以上8个模板进行运算，共得出8个值，取其中最大的值作为该像素的最终值。 int cvKirsch(unsigned char* srcarr, unsig
定义类模板实现2个数的算术运算
06-14
本题目要求定义类模板实现2个数的最大值、最小值、加、减、乘、除等算术运算，在main（）函数中使用该类模板分别实例化为int型和double型的类，定义相关的对象，读入2个整数和2个浮点数，然后分别输出它们的最大值、...
分数模板（C++模板）
a83229442的博客
09-13 431
貌似没什么用。。。没有多少毒瘤题要输出分数吧。。。 update:真的有，而且在NOIP模拟赛里出现了！写double的卡精度到怀疑人生！ 可以套个兼容性比较好的高精度模板进来。 #include<bits/stdc++.h> using namespace std; namespace FlashHu{ #define RG register #define I inlin...
图像处理之基础---卷积模板运算
weixin_34186128的博客
08-10 847
1.使用模板处理图像相关概念：            模板：矩阵方块，其数学含义是一种卷积运算。      卷积运算：可看作是加权求和的过程，使用到的图像区域中的每个像素分别于卷积核(权矩阵)的每个元素对应相                乘，所有乘积之和作为区域中心像素的新值。      卷积核：卷积时使用到的权用一个矩阵表示，该矩阵与使用的图像区域大小相同，其行、列都是奇数，      ...
【模板】表达式运算
Loi_Chairmanの博客
10-24 429
这些都是emmmm http://www.tyvj.cn/p/1041 http://www.tyvj.cn/p/1042 http://codevs.cn/problem/2178/描述给出一个表达式,其中运算符仅包含+,-,*,/,^要求求出表达式的最终值数据可能会出现括号情况 还有可能出现多余括号情况数据保证不会出现>maxlongint的数据。数据可能回出现负数情况样例输入 Sampl
使用c++实现带分数的运算
weixin_52934900的博客
04-15 4101
带分数的运算一、前言二、带分数的运算1.头文件（Rational.h）2.源文件(实现函数）3.源文件（测试函数）4.运行截图三、总结 一、前言 为了更深入的学习c++，小编将带领大家一起使用c++实现带分数的运算，本文就介绍了一些相关的代码。 二、带分数的运算 Rational（有理数类），执行带分数的运算，编写测试代码。用整数表示类的private数据（分子，分母），结果以最简分数形式保存。 1.头文件（Rational.h） #include<math.h> using namespace
tuxiangchulishiyan.rar_图像处理 实验_数字 图象处理 MATLAB_模板运算
07-15
在本压缩包“tuxiangchulishiyan.rar”中，包含的是一个关于数字图像处理的实验教程，主要涉及了图像处理的一些核心概念和技术，如直方图、图像处理变换、小波变换以及模板运算，并且特别强调了MATLAB在这些操作中的...
smarty模板数学运算示例
10-20
在Smarty模板中进行运算时，变量和表达式可以直接在模板文件中设置，如文档内容所示，可以通过模板变量赋值，例如$x=$height和$y=$width。 此外，模板中的数学运算支持使用括号进行运算优先级的控制，如“((x+y)/z)...
ThinkPHP自定义函数解决模板标签加减运算的方法
12-18
本文实例讲述了ThinkPHP自定义函数解决模板标签加减运算的方法。分享给大家供大家参考。具体如下： 实际项目中，我们经常需要标签变量加减运算的操作。但是，在ThinkPHP中，并不支持模板变量直接运算的操作。 幸运的...
模运算 详解
weixin_43888067的博客
10-28 7014
模运算 模运算是大数运算中的常用操作。如果一个数太大，无法直接输出，或者不需要直接输出，可以把它取模后缩小数值在输出。 定义模运算为 a 除以 m 的余数，记为： a mod m = a % m 取模的结果满足 0 <= a mod m <= m-1,题目用给定的 m 限制计算结果的范围。例如 m = 10，就是取计算结果的个位数，参考 HUD 1061 题 ，求 nn ,n &lt...
模板数组类（支持分数和浮点数的求和计算） .cpp
06-30
【问题描述】 封装一个模板数组类Array，支持以下操作： 1. 构造函数Array(int n)，将数组初始化为n个存储空间，建议使用vector； 2. 函数input(int n)，使用插入运算符<<读取数据，最多读取n个元素，但不能超过数组存储空间的上限； 3. 重载下标运算符，返回数组的元素。 封装一个分数类Fract，用来处理分数功能和运算，能支持你的Array类使用。 1. 构造：传入两个参数n和m，表示n/m；分数在构造时立即转化成最简分数。 提示：分数化简有专门的算法，可自行调研 2. show()函数：分数输出为“a/b”或“-a/b”的形式，a、b都是无符号整数。若a为0或b为1，只输出符号和分子，不输出“/”和分母。 3. 在分数类上重载+=运算符，进行分数的加法运算。 【输入形式】 输入为两部分，分别是一组实数测试样例和一组分数测试样例。 这两组测试样例都以正整数n，且n小于1000，n表示需要输入n个实数（或分数）。 测试样例的第二行开始为n个实数（或分数）。其中每个分数输入为两个整数n、m，表示分数n/m。 【输出形式】 第一部分输出一个实数，是第一组测试样例之和；第二部分输出一个分数，是第二组测试样例之和。 分数输出时为最简形式，负号只会出现在最前面，若分母为1或分子为0，则只输出一个整数，即分子部分，而没有“/”和分母部分。 【样例输入】 4 6 8 7 5 9 1 3 20 -15 80 150 -9 1 6 6 12 16 -33 -48 6 11 0 -10 【样例输出】 26 -17117/2640 25.00 下载源文件 得分25.00 最后一次提交时间:2021-06-08 21:49:12 共有测试数据:5 平均占用内存:1.415K 平均运行时间:0.00648S 测试数据 评判结果 测试数据1 完全正确 测试数据2 完全正确 测试数据3 完全正确 测试数据4 完全正确 测试数据5 完全正确 详细 
C++（C#）取余和取模运算
12-01
c++和C#中，运算符‘%’为取余运算符，而并非取模预算符，在一些应用场景中，如果不加以区分，会产生严重的bug。
C++实现大数模拟/高精度计算（包含加减乘除）详细版
city_cheng的博客
03-23 540
详细介绍了大数（高精度）的加减乘除操作，以及c++代码实现
2.3 模运算
tang7mj的博客
11-04 5814
模的概念模运算是一种算术运算，常写作a mod n，表示整数a除以正整数n后的余数。模数是模运算中的除数n，它决定了结果的范围。公式表达a = qn + r，其中0 ≤ r < n，q是整数商，即q = ⌊a/n⌋。a除以n的余数是a mod n。示例（11除以7的余数是4）（-11除以7的余数是3）剩余类集合（模n的剩余类）每个整数表示一个剩余类: [0],[1],…,[�−1][0],[1],…,[n−1]
分数取模
05-08 1473
下面是“分数”模运算的定义： b, m互质 k = a/b (mod m) <=> kb = a (mod m) 这里求 x = 1/17 (mod 2668) <=> 17x = 1 (mod 2668) <=> 17x = 2668k + 1 （k∈整数） 取合适的k使得17|(2668k+1) 这里刚好17 | (2...
敲代码的第二十三天:模板分数上篇（c++）
qq_58131187的博客
11-17 535
#include<iostream> #include<string.h> using namespace std; class denominator_zero {}; template<class T> class score { private: T molecular; T denominator; public: score() {} score(T x, T y); score add(score x); sco...
（三）空域图像增强：像素联系和模板运算
cuttleKK的博客
11-15 1593
空域指像素位置所在的空间，一般看作图像的原始空间。空域图像增强指直接作用于像素，在图像空间的增强。在空域增强中分为点操作和模板操作。
C++实现：分数类
https://github.com/JelinYao
03-05 7824
花了几个小时敲代码——测试——修改…… 总算搞定了 好累，睡觉去的 有问题欢迎提出，继续修改 首先是头文件CFraction.h:   #ifndef CFRACTION_H_ #define CFRACTION_H_ #include using namespace std; class CFraction { public: CFraction(int a=1,
C++分数取模【固定模板+讲解】
最新发布
weixin_73074505的博客
02-24 1286
对于算法题目中要求对分数取模的题目，往往不能直接求解，这里是一套标准实用的C++模板和讲解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值