hdu 4392 Maximum Number Of Divisors - c++编程基础

_t));
div(ret.num,ABS(a),t);
memset(ret.num,0,sizeof(bignum_t));
ret.num[0]=1 ;
add(ret.num,t);
return t ;
}
inline bignum&operator++()
{
*this+=1 ;
return*this ;
}
inline bignum&operator--()
{
*this-=1 ;
return*this ;
}
;
inline int operator>(const bignum&a)
{
return sgn>0 (a.sgn>0 comp(num,a.num)>0:1):(sgn<0 (a.sgn<0 comp(num,a.num)<0:0):a.sgn<0);
}
inline int operator>(const int a)
{
return sgn>0 (a>0 comp(num,a)>0:1):(sgn<0 (a<0 comp(num,-a)<0:0):a<0);
}
inline int operator>=(const bignum&a)
{
return sgn>0 (a.sgn>0 comp(num,a.num)>=0:1):(sgn<0 (a.sgn<0 comp(num,a.num)<=0:0):a.sgn<=0);
}
inline int operator>=(const int a)
{
return sgn>0 (a>0 comp(num,a)>=0:1):(sgn<0 (a<0 comp(num,-a)<=0:0):a<=0);
}
inline int operator<(const bignum&a) const
{
return sgn<0 (a.sgn<0 comp(num,a.num)>0:1):(sgn>0 (a.sgn>0 comp(num,a.num)<0:0):a.sgn>0);
}
inline int operator<(const int a)
{
return sgn<0 (a<0 comp(num,-a)>0:1):(sgn>0 (a>0 comp(num,a)<0:0):a>0);
}
inline int operator<=(const bignum&a) const
{
return sgn<0 (a.sgn<0 comp(num,a.num)>=0:1):(sgn>0 (a.sgn>0 comp(num,a.num)<=0:0):a.sgn>=0);
}
inline int operator<=(const int a)
{
return sgn<0 (a<0 comp(num,-a)>=0:1):
(sgn>0 (a>0 comp(num,a)<=0:0):a>=0);
}
inline int operator==(const bignum&a) const
{
return(sgn==a.sgn) !comp(num,a.num):0 ;
}
inline int operator==(const int a)
{
return(sgn*a>=0) !comp(num,ABS(a)):0 ;
}
inline int operator!=(const bignum&a)
{
return(sgn==a.sgn) comp(num,a.num):1 ;
}
inline int operator!=(const int a)
{
return(sgn*a>=0) comp(num,ABS(a)):1 ;
}
inline int operator[](const int a)
{
return digit(num,a);
}
friend inline istream&operator>>(istream&is,bignum&a)
{
read(a.num,a.sgn,is);
return is ;
}
friend inline ostream&operator<<(ostream&os,const bignum&a)
{
if(a.sgn<0)
os<<'-' ;
write(a.num,os);

return os ;
}
friend inline bignum sqrt(const bignum&a)
{
bignum ret ;
bignum_t t ;
memcpy(t,a.num,sizeof(bignum_t));
sqrt(ret.num,t);
ret.sgn=ret.num[0]!=1||ret.num[1];
return ret ;
}
friend inline bignum sqrt(const bignum&a,bignum&b)
{
bignum ret ;
memcpy(b.num,a.num,sizeof(bignum_t));
sqrt(ret.num,b.num);
ret.sgn=ret.num[0]!=1||ret.num[1];
b.sgn=b.num[0]!=1||ret.num[1];
return ret ;
}
inline int length()
{
return :: length(num);
}
inline int zeronum()
{
return :: zeronum(num);
}
inline bignum C(const int m,const int n)
{
combination(num,m,n);
sgn=1 ;
return*this ;
}
inline bignum P(const int m,const int n)
{
permutation(num,m,n);
sgn=1 ;
return*this ;
}
};

struct zs
{
bignum x;
int a[62];
i64 has;
bool operator < (const zs & a) const
{
return x < a.x;
}
}zx;

mapM;
map::iterator mi;
vectorp;
bignum end;

void bfs()
{
M.clear();
end = 1;
for(int i=1;i<=80;i++)
{
end*=10;
}
setq;
memset(zx.a,0,sizeof(zx.a));
zx.x = 1;
zx.has = 1;

bignum x;
x=0;
M[x]=0;
x=1;
M[x]=1;
q.insert(zx);

zs now,to;
i

hdu 4392 Maximum Number Of Divisors(七)