上次BC遇到一个大数题目，没有大数模板和不会使用JAVA的同学们GG了，赛后从队友哪里骗出大数模板。2333333，真的炒鸡nice（就是有点长），贴出来分享一下好辣。

  1.  //可以处理字符串前导零
  2.  #include <iostream>
  3.  #include <queue>
  4.  #include <cstdio>
  5.  #include <cstring>
  6.  #include <cstdlib>
  7.  #include <stack>
  8.  using namespace std;
  9.  #define maxn 120//大数的个数
  10.  class DividedByZeroException {};
  11.  
  12.  class BigInteger
  13.  {
  14.  private:
  15.      vector<char> digits;
  16.      bool sign;          //  true for positive, false for negitive
  17.      void trim();        //  remove zeros in tail, but if the value is 0, keep only one:)
  18.  public:
  19.      BigInteger(int);    // construct with a int integer
  20.      BigInteger(string&) ;
  21.      BigInteger();
  22.      BigInteger (const BigInteger&);
  23.      BigInteger operator=(const BigInteger& op2);
  24.  
  25.      BigInteger      abs() const;
  26.      BigInteger    pow(int a);
  27.  
  28.      //binary operators
  29.  
  30.      friend BigInteger operator+=(BigInteger&,const BigInteger&);
  31.      friend BigInteger operator-=(BigInteger&,const BigInteger&);
  32.      friend BigInteger operator*=(BigInteger&,const BigInteger&);
  33.      friend BigInteger operator/=(BigInteger&,const BigInteger&) throw(DividedByZeroException);
  34.      friend BigInteger operator%=(BigInteger&,const BigInteger&) throw(DividedByZeroException);
  35.  
  36.      friend BigInteger operator+(const BigInteger&,const BigInteger&);
  37.      friend BigInteger operator-(const BigInteger&,const BigInteger&);
  38.      friend BigInteger operator*(const BigInteger&,const BigInteger&);
  39.      friend BigInteger operator/(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
  40.      friend BigInteger operator%(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
  41.  
  42.      //uniary operators
  43.      friend BigInteger operator-(const BigInteger&);   //negative
  44.  
  45.      friend BigInteger operator++(BigInteger&);        //++v
  46.      friend BigInteger operator++(BigInteger&,int);    //v++
  47.      friend BigInteger operator--(BigInteger&);        //--v
  48.      friend BigInteger operator--(BigInteger&,int);    //v--
  49.  
  50.      friend bool operator>(const BigInteger&,const BigInteger&);
  51.      friend bool operator<(const BigInteger&,const BigInteger&);
  52.      friend bool operator==(const BigInteger&,const BigInteger&);
  53.      friend bool operator!=(const BigInteger&,const BigInteger&);
  54.      friend bool operator>=(const BigInteger&,const BigInteger&);
  55.      friend bool operator<=(const BigInteger&,const BigInteger&);
  56.  
  57.      friend ostream& operator<<(ostream&,const BigInteger&);    //print the BigInteger
  58.      friend istream& operator>>(istream&, BigInteger&);         // input the BigInteger
  59.  
  60.  public:
  61.      static const BigInteger ZERO;
  62.      static const BigInteger ONE;
  63.      static const BigInteger TEN;
  64.  };
  65.  // BigInteger.cpp
  66.  
  67.  const BigInteger BigInteger::ZERO=BigInteger();
  68.  const BigInteger BigInteger::ONE =BigInteger();
  69.  const BigInteger BigInteger::TEN =BigInteger();
  70.  
  71.  BigInteger::BigInteger()
  72.  {
  73.      sign=true;
  74.  }
  75.  
  76.  BigInteger::BigInteger(int val) // construct with a int integer
  77.  {
  78.      if (val >= )
  79.          sign = true;
  80.      else
  81.      {
  82.          sign = false;
  83.          val *= (-);
  84.      }
  85.      do
  86.      {
  87.          digits.push_back( (char)(val%) );
  88.          val /= ;
  89.      }
  90.      while ( val !=  );
  91.  }
  92.  
  93.  BigInteger::BigInteger(string& def)
  94.  {
  95.      sign=true;
  96.      for ( string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++)
  97.      {
  98.          char ch = (*iter);
  99.          if (iter == def.rend()-)
  100.          {
  101.              if ( ch == '+' )
  102.                  break;
  103.              if(ch == '-' )
  104.              {
  105.                  sign = false;
  106.                  break;
  107.              }
  108.          }
  109.          digits.push_back( (char)((*iter) - '' ) );
  110.      }
  111.      trim();
  112.  }
  113.  
  114.  void BigInteger::trim()
  115.  {
  116.      vector<char>::reverse_iterator iter = digits.rbegin();
  117.      while(!digits.empty() && (*iter) == )
  118.      {
  119.          digits.pop_back();
  120.          iter=digits.rbegin();
  121.      }
  122.      if( digits.size()== )
  123.      {
  124.          sign = true;
  125.          digits.push_back();
  126.      }
  127.  }
  128.  
  129.  BigInteger::BigInteger(const BigInteger& op2)
  130.  {
  131.      sign = op2.sign;
  132.      digits=op2.digits;
  133.  }
  134.  
  135.  BigInteger BigInteger::operator=(const BigInteger& op2)
  136.  {
  137.      digits = op2.digits;
  138.      sign = op2.sign;
  139.      return (*this);
  140.  }
  141.  
  142.  BigInteger BigInteger::abs() const
  143.  {
  144.      if(sign)  return *this;
  145.      else      return -(*this);
  146.  }
  147.  
  148.  BigInteger BigInteger::pow(int a)
  149.  {
  150.      BigInteger res();
  151.      for(int i=; i<a; i++)
  152.          res*=(*this);
  153.      return res;
  154.  }
  155.  
  156.  //binary operators
  157.  BigInteger operator+=(BigInteger& op1,const BigInteger& op2)
  158.  {
  159.      if( op1.sign == op2.sign )
  160.      {
  161.          //只处理相同的符号的情况，异号的情况给-处理
  162.          vector<char>::iterator iter1;
  163.          vector<char>::const_iterator iter2;
  164.          iter1 = op1.digits.begin();
  165.          iter2 = op2.digits.begin();
  166.          char to_add = ;        //进位
  167.          while ( iter1 != op1.digits.end() && iter2 != op2.digits.end())
  168.          {
  169.              (*iter1) = (*iter1) + (*iter2) + to_add;
  170.              to_add = ((*iter1) > );    // 大于9进一位
  171.              (*iter1) = (*iter1) % ;
  172.              iter1++;
  173.              iter2++;
  174.          }
  175.          while ( iter1 != op1.digits.end() )    //
  176.          {
  177.              (*iter1) = (*iter1) + to_add;
  178.              to_add = ( (*iter1) >  );
  179.              (*iter1) %= ;
  180.              iter1++;
  181.          }
  182.          while ( iter2 != op2.digits.end() )
  183.          {
  184.              char val = (*iter2) + to_add;
  185.              to_add = (val > ) ;
  186.              val %= ;
  187.              op1.digits.push_back(val);
  188.              iter2++;
  189.          }
  190.          if( to_add !=  )
  191.              op1.digits.push_back(to_add);
  192.          return op1;
  193.      }
  194.      else
  195.      {
  196.          if (op1.sign)
  197.              return op1 -= (-op2);
  198.          else
  199.              return op1= op2 - (-op1);
  200.      }
  201.  
  202.  }
  203.  
  204.  BigInteger operator-=(BigInteger& op1,const BigInteger& op2)
  205.  {
  206.      if( op1.sign == op2.sign )
  207.      {
  208.          //只处理相同的符号的情况，异号的情况给+处理
  209.          if(op1.sign)
  210.          {
  211.              if(op1 < op2)  // 2 - 3
  212.                  return  op1=-(op2 - op1);
  213.          }
  214.          else
  215.          {
  216.              if(-op1 > -op2)  // (-3)-(-2) = -(3 - 2)
  217.                  return op1=-((-op1)-(-op2));
  218.              else             // (-2)-(-3) = 3 - 2
  219.                  return op1= (-op2) - (-op1);
  220.          }
  221.          vector<char>::iterator iter1;
  222.          vector<char>::const_iterator iter2;
  223.          iter1 = op1.digits.begin();
  224.          iter2 = op2.digits.begin();
  225.  
  226.          char to_substract = ;  //借位
  227.  
  228.          while ( iter1 != op1.digits.end() && iter2 != op2.digits.end())
  229.          {
  230.              (*iter1) = (*iter1) - (*iter2) - to_substract;
  231.              to_substract = ;
  232.              if( (*iter1) <  )
  233.              {
  234.                  to_substract=;
  235.                  (*iter1) += ;
  236.              }
  237.              iter1++;
  238.              iter2++;
  239.          }
  240.          while ( iter1 != op1.digits.end() )
  241.          {
  242.              (*iter1) = (*iter1) - to_substract;
  243.              to_substract = ;
  244.              if( (*iter1) <  )
  245.              {
  246.                  to_substract=;
  247.                  (*iter1) += ;
  248.              }
  249.              else break;
  250.              iter1++;
  251.          }
  252.          op1.trim();
  253.          return op1;
  254.      }
  255.      else
  256.      {
  257.          if (op1 > BigInteger::ZERO)
  258.              return op1 += (-op2);
  259.          else
  260.              return op1 = -(op2 + (-op1));
  261.      }
  262.  }
  263.  BigInteger operator*=(BigInteger& op1,const BigInteger& op2)
  264.  {
  265.      BigInteger result();
  266.      if (op1 == BigInteger::ZERO || op2==BigInteger::ZERO)
  267.          result = BigInteger::ZERO;
  268.      else
  269.      {
  270.          vector<char>::const_iterator iter2 = op2.digits.begin();
  271.          while( iter2 != op2.digits.end() )
  272.          {
  273.              if(*iter2 != )
  274.              {
  275.                  deque<char> temp(op1.digits.begin() , op1.digits.end());
  276.                  char to_add = ;
  277.                  deque<char>::iterator iter1 = temp.begin();
  278.                  while( iter1 != temp.end() )
  279.                  {
  280.                      (*iter1) *= (*iter2);
  281.                      (*iter1) += to_add;
  282.                      to_add = (*iter1) / ;
  283.                      (*iter1) %= ;
  284.                      iter1++;
  285.                  }
  286.                  if( to_add != )
  287.                      temp.push_back( to_add );
  288.                  int num_of_zeros = iter2 - op2.digits.begin();
  289.                  while(  num_of_zeros--)
  290.                      temp.push_front();
  291.                  BigInteger temp2;
  292.                  temp2.digits.insert( temp2.digits.end() , temp.begin() , temp.end() );
  293.                  temp2.trim();
  294.                  result = result + temp2;
  295.              }
  296.              iter2++;
  297.          }
  298.          result.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
  299.      }
  300.      op1 = result;
  301.      return op1;
  302.  }
  303.  
  304.  BigInteger operator/=(BigInteger& op1 , const BigInteger& op2 ) throw(DividedByZeroException)
  305.  {
  306.      if( op2 == BigInteger::ZERO )
  307.          throw DividedByZeroException();
  308.      BigInteger t1 = op1.abs(), t2 = op2.abs();
  309.      if ( t1 < t2 )
  310.      {
  311.          op1 = BigInteger::ZERO;
  312.          return op1;
  313.      }
  314.      //现在 t1 > t2 > 0
  315.      //只需将 t1/t2的结果交给result就可以了
  316.      deque<char> temp;
  317.      vector<char>::reverse_iterator iter = t1.digits.rbegin();
  318.  
  319.      BigInteger temp2();
  320.      while( iter != t1.digits.rend() )
  321.      {
  322.          temp2 = temp2 * BigInteger::TEN + BigInteger( (int)(*iter) );
  323.          char s = ;
  324.          while( temp2 >= t2 )
  325.          {
  326.              temp2 = temp2 - t2;
  327.              s = s + ;
  328.          }
  329.          temp.push_front( s );
  330.          iter++;
  331.      }
  332.      op1.digits.clear();
  333.      op1.digits.insert( op1.digits.end() , temp.begin() , temp.end() );
  334.      op1.trim();
  335.      op1.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
  336.      return op1;
  337.  }
  338.  
  339.  BigInteger operator%=(BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)
  340.  {
  341.      return op1 -= ((op1 / op2)*op2);
  342.  }
  343.  
  344.  BigInteger operator+(const BigInteger& op1,const BigInteger& op2)
  345.  {
  346.      BigInteger temp(op1);
  347.      temp += op2;
  348.      return temp;
  349.  }
  350.  BigInteger operator-(const BigInteger& op1,const BigInteger& op2)
  351.  {
  352.      BigInteger temp(op1);
  353.      temp -= op2;
  354.      return temp;
  355.  }
  356.  
  357.  BigInteger operator*(const BigInteger& op1,const BigInteger& op2)
  358.  {
  359.      BigInteger temp(op1);
  360.      temp *= op2;
  361.      return temp;
  362.  
  363.  }
  364.  
  365.  BigInteger operator/(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)
  366.  {
  367.      BigInteger temp(op1);
  368.      temp /= op2;
  369.      return temp;
  370.  }
  371.  
  372.  BigInteger operator%(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)
  373.  {
  374.      BigInteger temp(op1);
  375.      temp %= op2;
  376.      return temp;
  377.  }
  378.  
  379.  //uniary operators
  380.  BigInteger operator-(const BigInteger& op)    //negative
  381.  {
  382.      BigInteger temp = BigInteger(op);
  383.      temp.sign = !temp.sign;
  384.      return temp;
  385.  }
  386.  
  387.  BigInteger operator++(BigInteger& op)     //++v
  388.  {
  389.      op += BigInteger::ONE;
  390.      return op;
  391.  }
  392.  
  393.  BigInteger operator++(BigInteger& op,int x)   //v++
  394.  {
  395.      BigInteger temp(op);
  396.      ++op;
  397.      return temp;
  398.  }
  399.  
  400.  BigInteger operator--(BigInteger& op)     //--v
  401.  {
  402.      op -=  BigInteger::ONE;
  403.      return op;
  404.  }
  405.  
  406.  BigInteger operator--(BigInteger& op,int x)   //v--
  407.  {
  408.      BigInteger temp(op);
  409.      --op;
  410.      return temp;
  411.  }
  412.  
  413.  bool operator<(const BigInteger& op1,const BigInteger& op2)
  414.  {
  415.      if( op1.sign != op2.sign )
  416.          return !op1.sign;
  417.      else
  418.      {
  419.          if(op1.digits.size() != op2.digits.size())
  420.              return (op1.sign && op1.digits.size()<op2.digits.size())
  421.                     || (!op1.sign && op1.digits.size()>op2.digits.size());
  422.          vector<char>::const_reverse_iterator iter1,iter2;
  423.          iter1 = op1.digits.rbegin();
  424.          iter2 = op2.digits.rbegin();
  425.          while( iter1 != op1.digits.rend() )
  426.          {
  427.              if(  op1.sign &&  *iter1 < *iter2 ) return true;
  428.              if(  op1.sign &&  *iter1 > *iter2 ) return false;
  429.              if( !op1.sign &&  *iter1 > *iter2 ) return true;
  430.              if( !op1.sign &&  *iter1 < *iter2 ) return false;
  431.              iter1++;
  432.              iter2++;
  433.          }
  434.          return false;
  435.      }
  436.  }
  437.  bool operator==(const BigInteger& op1,const BigInteger& op2)
  438.  {
  439.      if( op1.sign != op2.sign  || op1.digits.size() != op2.digits.size() )
  440.          return false;
  441.      vector<char>::const_iterator iter1,iter2;
  442.      iter1 = op1.digits.begin();
  443.      iter2 = op2.digits.begin();
  444.      while( iter1!= op1.digits.end() )
  445.      {
  446.          if( *iter1 != *iter2 )  return false;
  447.          iter1++;
  448.          iter2++;
  449.      }
  450.      return true;
  451.  }
  452.  
  453.  bool operator!=(const BigInteger& op1,const BigInteger& op2)
  454.  {
  455.      return !(op1==op2);
  456.  }
  457.  
  458.  bool operator>=(const BigInteger& op1,const BigInteger& op2)
  459.  {
  460.      return (op1>op2) || (op1==op2);
  461.  }
  462.  
  463.  bool operator<=(const BigInteger& op1,const BigInteger& op2)
  464.  {
  465.      return (op1<op2) || (op1==op2);
  466.  }
  467.  
  468.  bool operator>(const BigInteger& op1,const BigInteger& op2)
  469.  {
  470.      return !(op1<=op2);
  471.  }
  472.  
  473.  ostream& operator<<(ostream& stream,const BigInteger& val)     //print the BigInteger
  474.  {
  475.      if (!val.sign)
  476.          stream << "-";
  477.      for ( vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++)
  478.          stream << (char)((*iter) + '');
  479.      return stream;
  480.  }
  481.  
  482.  istream& operator>>(istream& stream, BigInteger& val)
  483.  {
  484.      //Input the BigInteger
  485.      string str;
  486.      stream >> str;
  487.      val=BigInteger(str);
  488.      return stream;
  489.  }
  490.  BigInteger a;
  491.  //定义一个大数a

在Hdu上要用G++提交，C++提交会CE，亲测！！！！

大数模板 (C ++)的更多相关文章

  1. bignum 大数模板

    今天无意间看到一个很好的大数模板,能算加.减.乘.除等基本运算,但操作减法的时候只能大数减小数,也不支持负数,如果是两个负数的话去掉符号相加之后再取反就可以了,一正一负比较绝对值大小,然后相减.我借用 ...

  2. c++大数模板

    自己写的大数模板,参考了小白书上的写法,只是实现了加减乘法,不支持负数,浮点数.. 除法还没写o(╯□╰)o以后再慢慢更吧.. 其实除法我用(xie)的(bu)少(lai),乘法写过fft,这模板还是 ...

  3. hdu 5429 Geometric Progression（存个大数模板）

    Problem Description Determine whether a sequence is a Geometric progression or not. In mathematics, ...

  4. ACM大数模板（支持正负整数）

    之前就保留过简陋的几个用外部数组变量实现的简单大数模板,也没有怎么用过,今天就想着整合封装一下,封装成C++的类,以后需要调用的时候也方便得多. 实现了基本的加减乘除和取模运算的操作符重载,大数除以大 ...

  5. 【集训笔记】【大数模板】特殊的数 【Catalan数】【HDOJ1133【HDOJ1134【HDOJ1130

    http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3324 http://blog.csdn.net/xymscau/artic ...

  6. hdu1042（大数模板）

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1042 在网上找了个大数模板方便以后用得到. #include<iostream> #inc ...

  7. 大数模板 poj3982

    1. 这个模板不是自己写的,转载的别人转载的,还没学完c++的我,想写也没有那能力. 这个模板我用在了POJ的一道题上,传送门--POJ3982 一般大数的题,都可用这个模板解决,仅仅须要改动主函数就 ...

  8. Hdu 4762 网络赛 高精度大数模板+概率

    注意题目中的这句话he put the strawberries on the cake randomly one by one,第一次选择草莓其实有N个可能,以某一个草莓为开头,然后顺序的随机摆放, ...

  9. vijos - P1447开关灯泡 (大数模板 + 找规律 + 全然数 + python)

    P1447开关灯泡 Accepted 标签:CSC WorkGroup III[显示标签] 描写叙述 一个房间里有n盏灯泡.一開始都是熄着的,有1到n个时刻.每一个时刻i,我们会将i的倍数的灯泡改变状 ...

随机推荐

  1. 李洪强iOS开发之-实现点击单行View显示和隐藏Cell

    李洪强iOS开发之-实现点击单行View显示和隐藏Cell 实现的效果:  .... ....

  2. chrome自带的调试工具

    由于项目需要加载webgl对浏览器内存压力很大,需要优化内存,网上找了一下资料,极力推荐chrome的开发文档 https://developers.google.cn/web/tools/chrom ...

  3. Session 钝化机制

  4. 0mq

  5. CentOS 7.2 安装Gerrit 2.14.6

    1.环境 本文使用VMWare虚拟机进行实验. 2核CPU,4GB内存,20GB硬盘,IP:192.168.159.131 CentOS 7.2最小安装(CentOS-7-x86_64-Minimal ...

  6. UVA-11082 Matrix Decompressing(有上下界的最大流)

    题目链接: Matrix Decompressing 题意: 给一个矩阵的每行和每列的和,(给的是前i行或者列的和); 矩阵中每个元素的值在1到20之间,找出这样的一个矩阵: 思路: 把它转化成一个二 ...

  7. web自动化测试的自身特点

    1.web页面是出现的元素可能具有不确定性 2.不同操作系统上不同web浏览器之间的兼容性 3.web应用的高并发性和容错性 4.移动设备上web客户端兼容性,旋转下和各种触摸特性

  8. macbook pro 下eclipse配置svn插件

    eclipse中最常使用的SVN插件是subclipse,先到subclipse官网:http://subclipse.tigris.org下载该插件.   如上图,点击“Download and I ...

  9. TCP连接、释放及HTTPS连接流程

    一.建立连接是三次握手 为什么三次握手?前两次握手为了确认服务端能正常收到客户端的请求并愿意应答,后两次握手是为了确认客户端能正常收到服务端的请求并愿意应答.三次握手可以避免意外建立错误连接而导致浪费 ...

  10. bzoj1925地精部落——数学

    题目:https://www.lydsy.com/JudgeOnline/problem.php?id=1925 真是精妙的递推式...好难想到啊: 详见这位的博客:https://www.cnblo ...