首先上模板（不断更新中...）（根据刘汝佳AOAPCII修改）
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <cctype>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <map>
#include <stack>
#include <list>
#include <iomanip>
using namespace std;
///
#define lc o << 1
#define rc o << 1 | 1
#define lson L , M , o << 1
#define rson M + 1 , R , o << 1 | 1
#define PI acos(-1.0)
#define INF 0x7fffffff
#define esp 1e-6
#define maxn 2001 typedef long long ll;
///
struct BigInteger
{
//初始化.
static const int BASE = ;
static const int WIDTH = ;
vector<int> s; int len;
BigInteger(ll num = ) {
*this = num;
}
BigInteger operator = (ll num)
{
s.clear();
do
{
s.push_back(num%BASE);
num /= BASE;
}
while(num > );
return *this;
}
BigInteger operator = (const string& num)
{
s.clear();
int x, len = (num.length() - ) / WIDTH + ;//这里就是把一个“1221434 125432 52526266”这样的大数转换成3个8位int型存入s中 for(int i = ; i < len; i++)
{
int end = num.length() - i*WIDTH;
int start = max(, end-WIDTH);
sscanf(num.substr(start, end-start).c_str(), "%d", &x);
s.push_back(x);
}
return *this;
} //加减乘除
BigInteger operator + (const BigInteger &b) const
{
BigInteger c;
c.s.clear();
for(int i = , g = ; ; ++i)
{
if(!g && i >= s.size() && i >= b.s.size()) break;
int x = g;
if(i < s.size()) x += s[i];
if(i < b.s.size()) x += b.s[i]; c.s.push_back(x % BASE);
g = x / BASE;
}
return c;
} BigInteger operator += (const BigInteger &b)
{
*this = *this + b;
return *this;
} //注意前提：两个数都没有前导零
bool operator < (const BigInteger& b) const
{
if(!s.size() != b.s.size())
return s.size() < b.s.size();
for(int i = s.size()-; i >= ; i--)
if(s[i] != b.s[i])
return s[i] < b.s[i];
return false;//相等
}
bool operator > (const BigInteger& b) const
{
return b < *this;
}
bool operator <= (const BigInteger& b) const
{
return !(b < *this);
}
bool operator >= (const BigInteger& b) const
{
return !(*this < b);
}
bool operator != (const BigInteger& b) const
{
return (b < *this) || (*this < b);
}
bool operator == (const BigInteger& b) const
{
return !(b < *this) && !(*this < b);
}
}; istream & operator >> (istream &in, BigInteger &x)
{
string s;
in >> s;
x = s.c_str();
return in;
} ostream & operator << (ostream &out, const BigInteger &x)
{
out << x.s.back();
for(int i=x.s.size()-;i>=;i--)
{
char buf[];
sprintf(buf,"%08d",x.s[i]);
for(int j=;j<strlen(buf);j++) out<<buf[j];
}
return out;
}
例题：UVA 11375 Matches(高精度 + 递推)
代码如下
tupedef maxn BigInteger f[maxn];
BigInteger ans[maxn];
const int c[]={,,,,,,,,,};
int n; void init()
{
for (int i = ; i <= maxn; i++)
f[i] = ;
f[] = ;
for(int i = ; i <= maxn; i++)
{
for(int j = ; j <= ; j++)
{
if(i+c[j] < maxn && !(i== && j==))
{
f[i+c[j]] += f[i];
}
}
}
ans[]=;
for (int i = ; i <= maxn; i++)
{
ans[i] = ans[i-] + f[i];
}
}
int main()
{
//freopen("out.txt", "w", stdout);
init();
while (cin >> n)
{
if (n >= )
cout << ans[n]+ << endl;
else
cout << ans[n] << endl;
}
return ;
}
超强模板（网络转载）
#include <deque>
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std; class DividedByZeroException {}; class BigInteger
{
private:
vector<char> digits;
bool sign; // true for positive, false for negitive
void trim(); // remove zeros in tail, but if the value is 0, keep only one:)
public:
BigInteger(int); // construct with a int integer
BigInteger(string&) ;
BigInteger();
BigInteger (const BigInteger&);
BigInteger operator=(const BigInteger& op2); BigInteger abs() const;
BigInteger pow(int a); //binary operators friend BigInteger operator+=(BigInteger&,const BigInteger&);
friend BigInteger operator-=(BigInteger&,const BigInteger&);
friend BigInteger operator*=(BigInteger&,const BigInteger&);
friend BigInteger operator/=(BigInteger&,const BigInteger&) throw(DividedByZeroException);
friend BigInteger operator%=(BigInteger&,const BigInteger&) throw(DividedByZeroException); friend BigInteger operator+(const BigInteger&,const BigInteger&);
friend BigInteger operator-(const BigInteger&,const BigInteger&);
friend BigInteger operator*(const BigInteger&,const BigInteger&);
friend BigInteger operator/(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
friend BigInteger operator%(const BigInteger&,const BigInteger&) throw(DividedByZeroException); //uniary operators
friend BigInteger operator-(const BigInteger&); //negative friend BigInteger operator++(BigInteger&); //++v
friend BigInteger operator++(BigInteger&,int); //v++
friend BigInteger operator--(BigInteger&); //--v
friend BigInteger operator--(BigInteger&,int); //v-- friend bool operator>(const BigInteger&,const BigInteger&);
friend bool operator<(const BigInteger&,const BigInteger&);
friend bool operator==(const BigInteger&,const BigInteger&);
friend bool operator!=(const BigInteger&,const BigInteger&);
friend bool operator>=(const BigInteger&,const BigInteger&);
friend bool operator<=(const BigInteger&,const BigInteger&); friend ostream& operator<<(ostream&,const BigInteger&); //print the BigInteger
friend istream& operator>>(istream&, BigInteger&); // input the BigInteger public:
static const BigInteger ZERO;
static const BigInteger ONE;
static const BigInteger TEN;
};
// BigInteger.cpp const BigInteger BigInteger::ZERO=BigInteger();
const BigInteger BigInteger::ONE =BigInteger();
const BigInteger BigInteger::TEN =BigInteger(); BigInteger::BigInteger()
{
sign=true;
} BigInteger::BigInteger(int val){// construct with a int integer
if (val >= )
sign = true;
else{
sign = false;
val *= (-);
}
do{
digits.push_back( (char)(val%) );
val /= ;
} while ( val != );
} BigInteger::BigInteger(string& def){
sign=true;
for ( string::reverse_iterator iter = def.rbegin() ; iter < def.rend(); iter++){
char ch = (*iter);
if (iter == def.rend()-){
if ( ch == '+' )
break;
if(ch == '-' ){
sign = false;
break;
}
}
digits.push_back( (char)((*iter) - '' ) );
}
trim();
} void BigInteger::trim(){
vector<char>::reverse_iterator iter = digits.rbegin();
while(!digits.empty() && (*iter) == ){
digits.pop_back();
iter=digits.rbegin();
}
if( digits.size()== ){
sign = true;
digits.push_back();
}
} BigInteger::BigInteger(const BigInteger& op2){
sign = op2.sign;
digits=op2.digits;
} BigInteger BigInteger::operator=(const BigInteger& op2){
digits = op2.digits;
sign = op2.sign;
return (*this);
} BigInteger BigInteger::abs() const {
if(sign) return *this;
else return -(*this);
} BigInteger BigInteger::pow(int a)
{
BigInteger res();
for(int i=; i<a; i++)
res*=(*this);
return res;
} //binary operators
BigInteger operator+=(BigInteger& op1,const BigInteger& op2){
if( op1.sign == op2.sign ){ //只处理相同的符号的情况，异号的情况给-处理
vector<char>::iterator iter1;
vector<char>::const_iterator iter2;
iter1 = op1.digits.begin();
iter2 = op2.digits.begin();
char to_add = ; //进位
while ( iter1 != op1.digits.end() && iter2 != op2.digits.end()){
(*iter1) = (*iter1) + (*iter2) + to_add;
to_add = ((*iter1) > ); // 大于9进一位
(*iter1) = (*iter1) % ;
iter1++; iter2++;
}
while ( iter1 != op1.digits.end() ){ //
(*iter1) = (*iter1) + to_add;
to_add = ( (*iter1) > );
(*iter1) %= ;
iter1++;
}
while ( iter2 != op2.digits.end() ){
char val = (*iter2) + to_add;
to_add = (val > ) ;
val %= ;
op1.digits.push_back(val);
iter2++;
}
if( to_add != )
op1.digits.push_back(to_add);
return op1;
}
else{
if (op1.sign)
return op1 -= (-op2);
else
return op1= op2 - (-op1);
} } BigInteger operator-=(BigInteger& op1,const BigInteger& op2){
if( op1.sign == op2.sign ){ //只处理相同的符号的情况，异号的情况给+处理
if(op1.sign) {
if(op1 < op2) // 2 - 3
return op1=-(op2 - op1);
}
else {
if(-op1 > -op2) // (-3)-(-2) = -(3 - 2)
return op1=-((-op1)-(-op2));
else // (-2)-(-3) = 3 - 2
return op1= (-op2) - (-op1);
}
vector<char>::iterator iter1;
vector<char>::const_iterator iter2;
iter1 = op1.digits.begin();
iter2 = op2.digits.begin(); char to_substract = ; //借位 while ( iter1 != op1.digits.end() && iter2 != op2.digits.end()){
(*iter1) = (*iter1) - (*iter2) - to_substract;
to_substract = ;
if( (*iter1) < ){
to_substract=;
(*iter1) += ;
}
iter1++;
iter2++;
}
while ( iter1 != op1.digits.end() ){
(*iter1) = (*iter1) - to_substract;
to_substract = ;
if( (*iter1) < ){
to_substract=;
(*iter1) += ;
}
else break;
iter1++;
}
op1.trim();
return op1;
}
else{
if (op1 > BigInteger::ZERO)
return op1 += (-op2);
else
return op1 = -(op2 + (-op1));
}
}
BigInteger operator*=(BigInteger& op1,const BigInteger& op2){
BigInteger result();
if (op1 == BigInteger::ZERO || op2==BigInteger::ZERO)
result = BigInteger::ZERO;
else{
vector<char>::const_iterator iter2 = op2.digits.begin();
while( iter2 != op2.digits.end() ){
if(*iter2 != ){
deque<char> temp(op1.digits.begin() , op1.digits.end());
char to_add = ;
deque<char>::iterator iter1 = temp.begin();
while( iter1 != temp.end() ){
(*iter1) *= (*iter2);
(*iter1) += to_add;
to_add = (*iter1) / ;
(*iter1) %= ;
iter1++;
}
if( to_add != )
temp.push_back( to_add );
int num_of_zeros = iter2 - op2.digits.begin();
while( num_of_zeros--)
temp.push_front();
BigInteger temp2;
temp2.digits.insert( temp2.digits.end() , temp.begin() , temp.end() );
temp2.trim();
result = result + temp2;
}
iter2++;
}
result.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
}
op1 = result;
return op1;
} BigInteger operator/=(BigInteger& op1 , const BigInteger& op2 ) throw(DividedByZeroException) {
if( op2 == BigInteger::ZERO )
throw DividedByZeroException();
BigInteger t1 = op1.abs(), t2 = op2.abs();
if ( t1 < t2 ){
op1 = BigInteger::ZERO;
return op1;
}
//现在 t1 > t2 > 0
//只需将 t1/t2的结果交给result就可以了
deque<char> temp;
vector<char>::reverse_iterator iter = t1.digits.rbegin(); BigInteger temp2();
while( iter != t1.digits.rend() ){
temp2 = temp2 * BigInteger::TEN + BigInteger( (int)(*iter) );
char s = ;
while( temp2 >= t2 ){
temp2 = temp2 - t2;
s = s + ;
}
temp.push_front( s );
iter++;
}
op1.digits.clear();
op1.digits.insert( op1.digits.end() , temp.begin() , temp.end() );
op1.trim();
op1.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
return op1;
} BigInteger operator%=(BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
return op1 -= ((op1 / op2)*op2);
} BigInteger operator+(const BigInteger& op1,const BigInteger& op2){
BigInteger temp(op1);
temp += op2;
return temp;
}
BigInteger operator-(const BigInteger& op1,const BigInteger& op2){
BigInteger temp(op1);
temp -= op2;
return temp;
} BigInteger operator*(const BigInteger& op1,const BigInteger& op2){
BigInteger temp(op1);
temp *= op2;
return temp; } BigInteger operator/(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
BigInteger temp(op1);
temp /= op2;
return temp;
} BigInteger operator%(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
BigInteger temp(op1);
temp %= op2;
return temp;
} //uniary operators
BigInteger operator-(const BigInteger& op){ //negative
BigInteger temp = BigInteger(op);
temp.sign = !temp.sign;
return temp;
} BigInteger operator++(BigInteger& op){ //++v
op += BigInteger::ONE;
return op;
} BigInteger operator++(BigInteger& op,int x){ //v++
BigInteger temp(op);
++op;
return temp;
} BigInteger operator--(BigInteger& op){ //--v
op -= BigInteger::ONE;
return op;
} BigInteger operator--(BigInteger& op,int x){ //v--
BigInteger temp(op);
--op;
return temp;
} bool operator<(const BigInteger& op1,const BigInteger& op2){
if( op1.sign != op2.sign )
return !op1.sign;
else{
if(op1.digits.size() != op2.digits.size())
return (op1.sign && op1.digits.size()<op2.digits.size())
|| (!op1.sign && op1.digits.size()>op2.digits.size());
vector<char>::const_reverse_iterator iter1,iter2;
iter1 = op1.digits.rbegin();iter2 = op2.digits.rbegin();
while( iter1 != op1.digits.rend() ){
if( op1.sign && *iter1 < *iter2 ) return true;
if( op1.sign && *iter1 > *iter2 ) return false;
if( !op1.sign && *iter1 > *iter2 ) return true;
if( !op1.sign && *iter1 < *iter2 ) return false;
iter1++;
iter2++;
}
return false;
}
}
bool operator==(const BigInteger& op1,const BigInteger& op2){
if( op1.sign != op2.sign || op1.digits.size() != op2.digits.size() )
return false;
vector<char>::const_iterator iter1,iter2;
iter1 = op1.digits.begin();
iter2 = op2.digits.begin();
while( iter1!= op1.digits.end() ){
if( *iter1 != *iter2 ) return false;
iter1++;
iter2++;
}
return true;
} bool operator!=(const BigInteger& op1,const BigInteger& op2){
return !(op1==op2);
} bool operator>=(const BigInteger& op1,const BigInteger& op2){
return (op1>op2) || (op1==op2);
} bool operator<=(const BigInteger& op1,const BigInteger& op2){
return (op1<op2) || (op1==op2);
} bool operator>(const BigInteger& op1,const BigInteger& op2){
return !(op1<=op2);
} ostream& operator<<(ostream& stream,const BigInteger& val){ //print the BigInteger
if (!val.sign)
stream << "-";
for ( vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++)
stream << (char)((*iter) + '');
return stream;
} istream& operator>>(istream& stream, BigInteger& val){ //Input the BigInteger
string str;
stream >> str;
val=BigInteger(str);
return stream;
} ////////////////////////////////////////////////////////////