POJ 2325 Persistent Numbers (C++大数类)

Persistent Numbers

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 2825		Accepted: 1370

Description

The multiplicative persistence of a number is defined by Neil Sloane (Neil J.A. Sloane in The Persistence of a Number published in Journal of Recreational Mathematics 6, 1973, pp. 97-98., 1973) as the number of steps to reach a one-digit number when repeatedly multiplying the digits. Example: 
679 -> 378 -> 168 -> 48 -> 32 -> 6.
That is, the persistence of 679 is 6. The persistence of a single digit number is 0. At the time of this writing it is known that there are numbers with the persistence of 11. It is not known whether there are numbers with the persistence of 12 but it is known that if they exists then the smallest of them would have more than 3000 digits. 
The problem that you are to solve here is: what is the smallest number such that the first step of computing its persistence results in the given number?

Input

For each test case there is a single line of input containing a decimal number with up to 1000 digits. A line containing -1 follows the last test case.

Output

For each test case you are to output one line containing one integer number satisfying the condition stated above or a statement saying that there is no such number in the format shown below.

Sample Input

0
1
47
18
49
51
768
-1

Sample Output

10
11
14
17
29
77
There is no such number.
2688

Source

Waterloo local 2003.07.05 

完美的C++大数模板！！！

#include<iostream>

#include<cstring>

#include<cstdio>

#include<iomanip>

#include<algorithm>

using namespace std;

#define MAXN 9999

#define MAXSIZE 10

#define DLEN 4

class BigNum

{

private:

int a[1500];    //可以控制大数的位数

int len;       //大数长度

public:

BigNum(){ len = 1;memset(a,0,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,0,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,0,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,0,sizeof(a));

for(i = 0 ; i < len ; i++)

a = T.a;

}

BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算

{

int i;

len = n.len;

memset(a,0,sizeof(a));

for(i = 0 ; i < len ; i++)

a = n.a;

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-'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);

cout.fill('0');

cout << b.a;

}

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 +=T.a;

if(t.a > MAXN)

{

t.a[i + 1]++;

t.a -=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 < t2.a)

{

j = i + 1;

while(t1.a[j] == 0)

j++;

t1.a[j--]--;

while(j > i)

t1.a[j--] += MAXN;

t1.a += MAXN + 1 - t2.a;

}

else

t1.a -= t2.a;

}

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,j,up;

int temp,temp1;

for(i = 0 ; i < len ; i++)

{

up = 0;

for(j = 0 ; j < T.len ; j++)

{

temp = a * 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 = (a + down * (MAXN + 1)) / b;

down = a + down * (MAXN + 1) - ret.a * 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)% 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;

}

cout << endl;

}

int main()

{

    char str[1500];

    BigNum one(1);

    while(cin>>str)

    {

        int len=strlen(str);

        if(len==2&&str[0]=='-'&&str[1]=='1')

            break;

        else if(len==1)

        {

            cout<<"1"<<str[0]<<endl;

            continue;

        }

        BigNum bg(str);

        int a[2000];

        memset(a,0,sizeof(a));

        int cnt=0;

        for(int i=9;i>=2;i--)

        {

            while(bg%i==0)

            {

                a[cnt++]=i;

                bg=bg/i;

            }

        }

        if(!(bg>one)&&!(one>bg))

        {

            for(int i=cnt-1;i>=0;i--)

            {

                cout<<a;

            }

            cout<<endl;

        }

        else

        {

            cout<<"There is no such number."<<endl;

        }

    }

return 0;

}