微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

hdu 1002 大数模板

分类：大数据作者：编程之家AI导航网

完整版 

#include <iostream>
#include <cstring>
#include <iomanip>
#include <algorithm>

using namespace std;

#define MAXN 9999
#define MAXSIZE 10
#define DLEN 4

class BigNum {
private:
    int a[500];//可以控制大数的位数
    int len;//大数长度
public:
    BigNum(){
        len = 1;
        memset(a,sizeof(a));
    }//构造函数
    BigNum(const int);//将一个int类型的变量转化为大数
    BigNum(const char*);//将一个字符串类型的变量转化为大数
    BigNum(const BigNum &);//拷贝构造函数
    BigNum &operator = (const BigNum &);//重载赋值运算符，大数之间进行赋值运算

    friend istream& operator >> (istream&,BigNum&);//重载输入运算符
    friend ostream& operator << (ostream&,BigNum&);//重载输出运算符

    BigNum operator + (const BigNum &) const;//重载加法运算符，两个大数之间的相加运算
    BigNum operator - (const BigNum &) const;//重载减法运算符，两个大数之间的相减运算
    BigNum operator * (const BigNum &) const;//重载乘法运算符，两个大数之间的相乘运算
    BigNum operator / (const int   &) const;//重载除法运算符，大数对一个整数进行相除运算

    BigNum operator ^ (const int  &) const;//大数的n次方运算
    int operator % (const int  &) const;//大数对一个int类型的变量进行取模运算
    bool operator > (const BigNum & T) const;//大数和另一个大数的大小比较
    bool operator > (const int & t) const;//大数和一个int类型的变量的大小比较

    void print();//输出大数
};
BigNum::BigNum(const int b){//将一个int类型的变量转化为大数
    int c,d = b;
    len = 0;
    memset(a,sizeof(a));
    while (d > MAXN){
        c = d - (d / (MAXN + 1)) * (MAXN + 1);
        d = d / (MAXN + 1);
        a[len++] = c;
    }
    a[len++] = d;
}
BigNum::BigNum(const char*s){//将一个字符串类型的变量转化为大数
    int t,k,index,l,i;
    memset(a,sizeof(a));
    l = strlen(s);
    len = l / DLEN;
    if (l % DLEN)
        len++;
    index = 0;
    for (i = l - 1; i >= 0; i -= DLEN){
        t = 0;
        k = i - DLEN + 1;
        if (k < 0)
            k = 0;
        for (int j = k; j <= i; j++)
            t = t * 10 + s[j] - '0';
        a[index++] = t;
    }
}
BigNum::BigNum(const BigNum & T) : len(T.len){//拷贝构造函数
    int i;
    memset(a,sizeof(a));
    for (i = 0; i < len; i++)
        a[i] = T.a[i];
}
BigNum & BigNum::operator = (const BigNum & n){//重载赋值运算符，大数之间进行赋值运算
    int i;
    len = n.len;
    memset(a,sizeof(a));
    for (i = 0; i < len; i++)
        a[i] = n.a[i];
    return *this;
}
istream& operator >> (istream & in,BigNum & b){//重载输入运算符
    char ch[MAXSIZE * 4];
    int i = -1;
    in >> ch;
    int l = strlen(ch);
    int count = 0,sum = 0;
    for (i = l - 1; i >= 0; ){
        sum = 0;
        int t = 1;
        for (int j = 0; j < 4 && i >= 0; j++,i--,t *= 10){
            sum += (ch[i] - '0') * t;
        }
        b.a[count] = sum;
        count++;
    }
    b.len = count++;
    return in;

}
ostream& operator << (ostream& out,BigNum& b){//重载输出运算符
    int i;
    cout << b.a[b.len - 1];
    for (i = b.len - 2; i >= 0; i--){
        cout.width(DLEN);
        cou
        t.fill('0');
        cout << b.a[i];
    }
    return out;
}

BigNum BigNum::operator + (const BigNum & T) const//两个大数之间的相加运算
{
    BigNum t(*this);
    int i,big;//位数
    big = T.len > len ? T.len : len;
    for (i = 0; i < big; i++){
        t.a[i] += T.a[i];
        if (t.a[i] > MAXN){
            t.a[i + 1]++;
            t.a[i] -= MAXN + 1;
        }
    }
    if (t.a[big] != 0)
        t.len = big + 1;
    else
        t.len = big;
    return t;
}
BigNum BigNum::operator - (const BigNum & T) const//两个大数之间的相减运算
{
    int i,j,big;
    bool flag;
    BigNum t1,t2;
    if (*this > T){
        t1 = *this;
        t2 = T;
        flag = 0;
    } else {
        t1 = T;
        t2 = *this;
        flag = 1;
    }
    big = t1.len;
    for (i = 0; i < big; i++){
        if (t1.a[i] < t2.a[i]){
            j = i + 1;
            while (t1.a[j] == 0)
                j++;
            t1.a[j--]--;
            while (j > i)
                t1.a[j--] += MAXN;
            t1.a[i] += MAXN + 1 - t2.a[i];
        } else
            t1.a[i] -= t2.a[i];
    }
    t1.len = big;
    while (t1.a[len - 1] == 0 && t1.len > 1){
        t1.len--;
        big--;
    }
    if (flag)
        t1.a[big - 1] = 0 - t1.a[big - 1];
    return t1;
}

BigNum BigNum::operator * (const BigNum & T) const//两个大数之间的相乘运算
{
    BigNum ret;
    int i,up;
    int temp,temp1;
    for (i = 0; i < len; i++){
        up = 0;
        for (j = 0; j < T.len; j++){
            temp = a[i] * T.a[j] + ret.a[i + j] + up;
            if (temp > MAXN){
                temp1 = temp - temp / (MAXN + 1) * (MAXN + 1);
                up = temp / (MAXN + 1);
                ret.a[i + j] = temp1;
            } else {
                up = 0;
                ret.a[i + j] = temp;
            }
        }
        if (up != 0)
            ret.a[i + j] = up;
    }
    ret.len = i + j;
    while (ret.a[ret.len - 1] == 0 && ret.len > 1)
        ret.len--;
    return ret;
}
BigNum BigNum::operator / (const int & b) const//大数对一个整数进行相除运算
{
    BigNum ret;
    int i,down = 0;
    for (i = len - 1; i >= 0; i--){
        ret.a[i] = (a[i] + down * (MAXN + 1)) / b;
        down = a[i] + down * (MAXN + 1) - ret.a[i] * b;
    }
    ret.len = len;
    while (ret.a[ret.len - 1] == 0 && ret.len > 1)
        ret.len--;
    return ret;
}
int BigNum::operator % (const int & b) const//大数对一个int类型的变量进行取模运算
{
    int i,d = 0;
    for (i = len - 1; i >= 0; i--){
        d = ((d * (MAXN + 1)) % b + a[i]) % b;
    }
    return d;
}
BigNum BigNum::operator ^ (const int & n) const//大数的n次方运算
{
    BigNum t,ret(1);
    int i;
    if (n < 0)
        exit(-1);
    if (n == 0)
        return 1;
    if (n == 1)
        return *this;
    int m = n;
    while (m > 1){
        t = *this;
        for (i = 1; i << 1 <= m; i <<= 1){
            t = t * t;
        }
        m -= i;
        ret = ret * t;
        if (m == 1)
            ret = ret * (*this);
    }
    return ret;
}
bool BigNum::operator > (const BigNum & T) const//大数和另一个大数的大小比较
{
    int ln;
    if (len > T.len)
        return true;
    else if (len == T.len){
        ln = len - 1;
        while (a[ln] == T.a[ln] && ln >= 0)
            ln--;
        if (ln >= 0 && a[ln] > T.a[ln])
            return true;
        else
            return false;
    } else
        return false;
}
bool BigNum::operator > (const int & t) const//大数和一个int类型的变量的大小比较
{
    BigNum b(t);
    return *this > b;
}

void BigNum::print(){//输出大数
    int i;
    cout << a[len - 1];
    for (i = len - 2; i >= 0; i--){
        cout.width(DLEN);
        cout.fill('0');
        cout << a[i];
    }
    cout << endl;
}
int main(void){
    int i,n;
    BigNum x[101];//定义大数的对象数组
    x[0] = 1;
    for (i = 1; i < 101; i++)
        x[i] = x[i - 1] * (4 * i - 2) / (i + 1);
    while (scanf("%d",&n) == 1 && n != -1){
        x[n].print();
    }
}

 

简单模板

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>

#define LL long long
int const MAX = 1e6 + 1;
int const INF = 1 << 30;
double const EPS = 0.00000001;
using namespace std;
int const MAXLEN = 10000;

struct BigNum {
    //保存各个位数的值,由低位到高位
    char a[MAXLEN];
    int len;
    BigNum(){
        memset(a,sizeof(a));
        len = 1;
    }
    //将一个int类型的变量转化为大数
    BigNum(int n){
        memset(a,sizeof(a));
        len = 0;
        do {
            a[len++] = n % 10;
            n /= 10;
        } while (n);
    }
    //将一个字符串类型的变量转化为大数
    BigNum(const char* s){
        memset(a,sizeof(a));
        //由低位到高位赋值
        len = strlen(s);
        for (int i = len - 1; i >= 0; i--)
            a[len - i - 1] = s[i] - '0';
    }
    //拷贝构造函数
    BigNum(const BigNum &bg){
        memset(a,sizeof(a));
        len = bg.len;
        for (int i = 0; i < len; i++)
            a[i] = bg.a[i];
    }
//重载赋值运算符，大数之间进行赋值运算
    BigNum &operator = (const BigNum & bg){
        memset(a,sizeof(a));
        len = bg.len;
        for (int i = 0; i < len; i++)
            a[i] = bg.a[i];
        return *this;
    }

    //重载加法运算符，两个大数之间的相加运算
    BigNum operator + (const BigNum &bg) const {
        BigNum nbg;
        int t = 0,maxlen = max(len,bg.len);//表示进位

        for (int i = 0; i < maxlen; i++){
            int sum = a[i] + bg.a[i] + t;
            nbg.a[i] = sum % 10;
            t = sum / 10;
        }

        if (t)
            nbg.a[maxlen++] = t;
        nbg.len = maxlen;
        return nbg;
    }
    //重载减法运算符，两个大数之间的相减运算
    BigNum operator - (const BigNum &) const;

    //重载乘法运算符，两个大数之间的相乘运算
    BigNum operator * (const BigNum &bg) const {
        BigNum nbg;
        int k = 0;//需要乘几次10
        for (int i = 0; i < len; i++){
            nbg.show();
            BigNum t = bg;
            for (int j = 0; j < k; j++)
                t = t * 10;
            nbg = nbg + t * a[i];
            k++;
        }
        nbg.show();
        return nbg;
    }

    //重载乘法运算符，大数 与int之间的相乘运算
    BigNum operator * (const int n) const {
        BigNum nbg;
        int nlen = len,t = 0;
        for (int i = 0; i < len; i++){
            t = a[i] * n + t;
            nbg.a[i] = t % 10;
            t /= 10;
        }
        while (t){
            nbg.a[nlen++] = t % 10;
            t /= 10;
        }
        nbg.len = nlen;
        return nbg;
    }
    //重载除法运算符，大数对一个整数进行相除运算
    BigNum operator / (const int   &) const {
        BigNum nbg;
        return nbg;
    }

    int operator % (const int& mod) const {
        int t = 0;
        for (int i = len - 1; i >= 0; i--){
            t = t * 10 + a[i];
            while (t < mod && i > 0)
                t = t * 10 + a[--i];

            if (t < mod) break;
            t = t % mod;
        }
        return t;
    }
    void show(){
        // printf("len=%d\n",len);
        for (int i = len - 1; i >= 0; i--)
            printf("%d",a[i]);
    }
};

char s1[MAXLEN],s2[MAXLEN];
int main(){
    int T;
    scanf("%d",&T);

    for (int c = 1; c <= T; c++){
        scanf("%s %s",s1,s2);
        BigNum n1(s1),n2(s2);
        BigNum n3 = n1 + n2;
        printf("Case %d:\n",c);
        n1.show();
        printf(" + ");
        n2.show();
        printf(" = ");
        n3.show();
        printf("\n");
        if (c != T)
            printf("\n");
    }

    return 0;
}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

大数据分析案例-基于随机森林模型对北京房价进行预测
自1998年我国取消了福利分房的政策后，房地产市场迅速开展蓬勃起来。同时，随着社会经济的快速开展，居民的经济条件越来越好，住房条件也在不断地提升。而住房是人民根本生活的保障，也是-一个家庭最重要的资产,从一定的层面.上反映了一个家庭整体的生活水王,多方面的因素使得房地产行业在短时间开展成为我国的支柱产业之一;成为了切实关乎人民生活和利益的重要产业。然而，随着房地产行业的开展，问题也慢慢突显出来，房价一直居高不下成为了一个大问题。作为国家的支柱产业,房地产的稳定发展关乎国计民生。近几年，房
机器学习实战——房价预测完整案例建议收藏慢慢品
文章目录获取数据查看数据结构获取数据下载数据可以直接通过浏览器下载压缩包，也可以通过函数来进行。import osimport tarfileimport urllib.requestDOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handson-ml2/master/"HOUSING_PATH = os.path.join("datasets", "housing") # datasetstestHOUSING_
网上商城系统MySql数据库设计项目实战
网上商城系统MySql数据库设计
常见气象数据获取方式及批量下载代码汇总
26个来源的气象数据获取代码
毕业设计 基于大数据的共享单车数据分析与可视化
大数据分析案例-对电信客户流失分析预警预测
在进入21世纪以来，中国电信业告别了20世纪最后阶段的高速发展状态，转而进入稳步发展阶段。近年来，随着通信的成本逐年下降，电信市场用户覆盖率近乎100%，几乎没有可开发的新市场，移动、联通、电信三大电信企业完全占据了电信服务市场，电信行业的不断进步，使得各大电信运营商自身服务体系不断完善，目前我国的三大运营商均实现了全业务经营 ，这意味着行业内存在产品、服务、模式等方面的高度同质化，企业间难以实现差异化竞争优势。现如今的竞争环境，迫使运营商的经营重点向有利于电信消费者的方向移动，为了维持客户的保有量，对
卡尔曼滤波
目录1.卡尔曼滤波入门2.学卡尔曼滤波的必备知识2.1.状态空间表达式2.2.高斯分布2.3.方差2.4.超参数2.5.卡尔曼直观图解3.卡尔曼滤波3.1.卡尔曼公式理解3.2.调节超参数3.2.1.Q和R的取值3.2.2.P0和X0的取值3.2.3.卡尔曼滤波的使用...
Python大数据-电商产品评论情感数据分析
一、项目背景网上购物已经成为大众生活的重要组成部分。人们在电商平台上浏览商品并购物，产生了海量的用户行为数据，用户对商品的评论数据对商家具有重要的意义。利用好这些碎片化、非结构化的数据，将有利于企业在电商平台上的持续发展，同时，对这部分数据进行分析，依据评论数据来优化现有产品也是大数据在企业经营中的实际应用。 分析产品：韶音 AfterShokz Aeropex AS800骨传导蓝牙耳机运动无线耳骨传导耳机跑步骑行 环法特别版（Aeropex AS800是AfterShokz韶音的网红新品，很多国内外
大数据项目之电商数仓、Maxwell使用、 Maxwell启停脚本、增量数据同步、历史数据全量同步、采集通道Maxwell配置、通道测试
但有时只有增量数据是不够的，我们可能需要使用到MySQL数据库中从历史至今的一个完整的数据集。这就需要我们在进行增量同步之前，先进行一次历史数据的全量同步。这样就能保证得到一个完整的数据集。1）第一条type为bootstrap-start和最后一条type为bootstrap-complete的数据，是bootstrap开始和结束的标志，不包含数据，中间的type为bootstrap-insert的数据才包含数据。2）一次bootstrap输出的所有记录的ts都相同，为bootstrap开始的时间。
[Hive]一篇带你读懂Hive是什么
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native