大整数模板

又臭又长系列233

嗯,没有写除法,乘法是T(10len^3)级别.....

常数极大

切勿模仿233333

int SYS=10;

class bign
{
	public:
	int v[300];
	int len;
	
	//====================================================
	//INIT
	//====================================================
	
	bign(){ memset(v,0,sizeof(v)); len=1; }
	
	bign(int k)
	{
		memset(v,0,sizeof(v));
		len=0; 
		while(k!=0)
		{ v[len++]=k%SYS; k/=SYS; }
	}
	
	bign(const char*f,int l)
	{
 		memset(v,0,sizeof(v));
 		len=1;
		for( len=0;len<l;len++ )
			v[l-len-1]=( f[len]>='0' && f[len]<='9' ) ? f[len]-'0' : f[len]-'A'+10;
	}
	
	bign(const bign&f)
	{
		len=f.len;
		memcpy(v,f.v,sizeof(v));
	}
	
	bign operator=(bign f)
	{
		memcpy(v,f.v,sizeof(v));
		len=f.len;
		return *this;
	}
	
	//===================================================
	//CALCULATION
	//====================================================
	
	int&operator[](const int&k)
	{ return v[k]; }
	
	
	//==========compare==========
	
	
	bool operator<(bign f)
	{
		if(len!=f.len) return len<f.len;
		for(int i=len-1;i>=0;i--)
		if(v[i]!=f[i]) return v[i]<f[i];
		return false;
	}
	bool operator<=(bign f)
	{
		if(len!=f.len) return len<f.len;
		for(int i=len-1;i>=0;i--)
		if(v[i]!=f[i]) return v[i]<f[i];
		return true;
	}
	
	bool operator>(bign f)
	{ return f<(*this); }
	bool operator>=(bign f)
	{ return f<=(*this); }
	
	bool operator==(bign f)
	{
		if(f.len!=len) return false;
		for(int i=len-1;i>=0;i--)
		if(v[i]!=f[i]) return false;
		return true;
	}
	
	
	//========== add ==========
	
	
	bign operator+(bign f)
	{
		bign c;
		
		c.len=max(len,f.len);
		
		for(int i=0;i<=c.len;i++)
		(c[i]+=v[i]+f[i]) >=SYS ? c[i]-=SYS,++c[i+1] : NULL;
		
		if(c[c.len]!=0) c.len++;
		
		return c;
	}
	
	bign operator+=(bign f)
	{
		len=max(len,f.len);
		
		for(int i=0;i<=len;i++)
		(v[i]+=f[i]) >=SYS ? v[i]-=SYS,++v[i+1] : NULL;
		
		if(v[len]!=0) len++;
		
		return *this;
	}
	
	bign operator+(int f)
	{
		bign c(f);
		return c+(*this);
	}
	
	
	//==========minus==========
	
	bign operator-(bign f) //return absolute.
	{
		if((*this)<f) return f-(*this); //make sure (*this) is larger
		
		bign c;
		c.len=len;
		
		for(int i=0;i<c.len;i++)
		(c[i]+=v[i]-f[i]) <0 ? c[i]+=SYS,--c[i+1] : NULL;
		
		while(c.len>0 && c[c.len]==0) c.len--;
		if(c[c.len]!=0 || c.len==0)c.len++;
		
		return c;
	}
	
	//==========multiply==========
	
	bign operator<<=(int k)
	{
		if(k==0) return *this;
		if(len==1 && v[0]==0) return *this;
		
		for(int i=len-1;i>=0;i--)
		v[i+k]=v[i];
		
		for(int i=0;i<k;i++)
		v[i]=0;
		
		len=len+k;
		
		return *this;
	}
	bign operator<<(int k)
	{
		bign c(*this);
		return (c<<=k);
	}
	
	bign operator>>=(int k)
	{
		if(k==0) return*this;
		
		for(int i=0;i<len-k;i++)
		v[i]=v[i+k];
		
		for(int i=max(0,len-k);i<len;i++)
		v[i]=0;
		
		len=max(1,len-k);
		return *this;
	}
	bign operator>>(int k)
	{
		bign c(*this);
		return (c>>=k);
	}
	
	bign operator*(int f)
	{
		bign c;
		
		int g=0;
		for(int i=0;i<len || g!=0;i++,c.len=i)
			c[i]=v[i]*f+g, g=c[i]/SYS, c[i]=c[i]%SYS ;
		
		while(c[c.len]==0 && c.len>=0 ) c.len--;
		c.len++;
		
		return c;
	}
	
	bign operator*(bign f)
	{
		bign c;
		c.len=len+f.len-1;
		
		for(int i=0;i<len;i++)
		{
			for(int j=0;j<f.len;j++)
				c[i+j]+=v[i]*f[j];
			
			for(int j=0;j<=c.len;j++)
				c[j]>=SYS ? c[j+1]+=c[j]/SYS , c[j]%=SYS : NULL;
		}
		
		for(int i=0;i<=c.len;i++)
		c[i]>=10 ? c[i+1]+=c[i]/SYS , c[i]/=SYS : NULL;
		
		if(c[c.len]!=0) c.len++;
		if(c[c.len]!=0) c.len++;
		
		return c;
	}
	
	//==========divide==========
	bign operator/(int k)
	{
		bign c;
		c.len=-1;
		
		int t=0;
		for(int i=len-1;i>=0;i--)
		{
			t=t*10+v[i];
			if(t/k!=0)
			{
				c[i]=t/k;
				t%=k;
				if(c.len==-1) c.len=i+1;
			}
		}
		
		if(c.len==-1) c.len=1;
		
		return c;
	}
	
	bign operator/(bign f)
	{
		bign c("0",1);
		
		if(f>(*this)) return c;
		
		c.len=-1;
		
		bign h("0",1);
		
		for(int i=len-1;i>=0;i--)
		{
			h=(h*10)+v[i];
			
			while(h>=f) h=h-f,c[i]++;
			
			if(c.len==-1 && c[i]!=0)
			c.len=i+1;
		}
		
		return c;
	}
	
	bign operator%(int k)
	{
		return (*this)-((*this)/k)*k;
	}
	
	bign operator%(bign f)
	{
		return (*this)-(*this)/f*f;
	}
	
	
	
	//====================================================
	//OUTPUT
	//====================================================
	
	void test()
	{
		printf("TEST : %d \n",len);
		printf("NUM: ");
		for(int i=len-1;i>=0;i--)
		printf("%d ",v[i]);
		printf("\n");
	}
	
	
	void output()
	{
		for(int i=len-1;i>=0;i--)
		if(v[i]>=0 && v[i]<=9) printf("%d",v[i]);
		else printf("%c",'A'+v[i]-10);
		
		printf("\n");
	}
	
	void output(int&k)
	{
		k=0;
		int s=1;
		for(int i=0;i<len;s*=SYS,i++)
		k+=s*v[i];
	}
	
	void output(char*f)
	{
		for(int i=0;i<len;i++)
		f[i]=v[i]+'0';
	}
};