大整数模板

又臭又长系列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';  
        }  
    };