Naeioi

量子の風
随笔 - 8, 文章 - 0, 评论 - 0, 引用 - 0
数据加载中……

基本数据结构-高精度

    下个月NOIP复试。初三一年奋战中考直升考,OI基本停滞。暑假宅在家里沉静于异世界也没怎么打代码,只帮人调了几个简单的程序,手生疏得很。于是打算用剩下一个月时间复习基本代码,建立一个标准代码库,让自己重新熟悉那些最最经典的算法实现,同时也为日后编码提供方便。
   这个标准代码库我都会亲自编码调试,努力保证正确性,力求简洁易读,注释完整。BUG在所难免,希望大家能在回复中帮助我改进XD.日后会不断更新各个方面(主要是涉及NOI)的基本代码。下面是预计的代码目录。
——————————————————————————————————————————————
1.基本数据结构
   高精
   二分
   哈希(也算查找)
   并查集
   队列、栈
      表达式计算
2.排序、查找
   堆
   快排
   归并排序
   选排、插排、冒排(冒牌………)
   基数排序
3.图论
   宽度、深度优先遍历
   Dijkstra、Floyd
   Prim、Kruskal
   SPFA
   最大流&最小最小费用最大流
4.其他
(未完待补充)
——————————————————————————————————————————————————
高精度模板(无压位)
//高精无压位
/*
Author:naeioi
Prog:C++
Time:11-10-20
*/
#include 
<cstdio>
#include 
<string.h>
//#include <conio.h>
using namespace std; 

const int maxlen=105+1;
#ifndef max
        
#define max(a,b) ((a)>(b)?a:b)
#endif
/*结构说明 
1.len代表实际长度
2.s[]从1开始 逆序存储 
3.默认长度105 
*/
/*注意事项
1.一定要将clear()函数放在赋值函数头,将数据清零
2. 赋值运算符优先级低,跟比较运算符在一起注意打括号
3.基本函数定义形式
   Bign operator *(const Bign &b)const{}
   注意返回Bign以及那两个const防改写 
4. 函数都应写在struct里面
*/

struct Bign{//函数后打//的是二级函数 
       int len,s[maxlen];
       
//函数部分 
       
//初始化
       void clear(){len=1;memset(s,0,sizeof(s));}//必要,赋值前必须清空 
       Bign(){clear();}
       
//赋值
       Bign operator = (const char *a){
            clear();
//只需在此clear(),其他所有赋值函数都要调用它 
            len=strlen(a);
            
for(int i=1;i<=len;i++)
                    s[i]
=a[len-i]-'0';
            
return *this;
       }
       Bign 
operator = (int num){//用sprintf巧妙转化,减少代码量 
            char tmp[maxlen];
            sprintf(tmp,
"%d",num);
            
return *this=tmp;
       }
       
       Bign(
int num){*this=num;}//
       Bign(const char *a){*this=a;}//
       
       
//运算符
       
//c++备注:形参const表示不改变形参,末尾const表示不改变*this.运算返回bign供操作
        Bign operator + (const Bign &b)const{
             Bign c
=*this;
             c.len
=max(len,b.len);
             
for(int i=1;i<=c.len;i++)
                     
if((c.s[i]+=b.s[i]) >= 10){//!!!赋值运算符比比较运算符优先度低!!! 
                        c.s[i+1]+=c.s[i]/10;
                        c.s[i]
%=10;
                     }
             
if(c.s[c.len+1]>0) c.len++;
             
return c;
        }
        Bign 
operator += (const Bign &b){
             
return (*this=*this+b);
        }
//
        Bign operator + (int b)const{
             Bign t
=b;
             
return t+*this;
        }
//
        Bign operator - (const Bign &b)const{//须保证b比*this小 
             Bign c=*this;
             
for(int i=1;i<=len;i++)
                     
if((c.s[i]-=b.s[i]) < 0){
                        c.s[i
+1]--;
                        c.s[i]
+=10;
                     }
             
while(c.s[c.len]==0) c.len--;
             
return c;
        }
        Bign 
operator - (int b)const{
             Bign t
=b;
             
return *this-t;
        }
//
        Bign operator * (const Bign &b)const{
             Bign c;
             c.len
=len+b.len;
             
             
for(int i=1;i<=len;i++)
                     
for(int j=1;j<=b.len;j++)
                             
if((c.s[i+j-1]+=s[i] * b.s[j]) >= 10){
                                c.s[i
+j]+=c.s[i+j-1]/10;
                                c.s[i
+j-1]%=10;
                             }
             
if(c.s[c.len]==0) c.len--;
             
return c;
        }
        Bign 
operator *= (const Bign &b){
             
return (*this=*this*b);
        }
//
        Bign operator / (int b)const{//必须整除(TODO:另用函数实现取余)
             Bign t=*this,c;
             c.len
=len;
             
for(int i=len;i>=1;i--){
                 t.s[i
-1]+=(t.s[i]%b)*10;
                 c.s[i]
=t.s[i]/b;
             }
             
while(c.s[c.len]==0) c.len--;
             
             
//remain=t.s[0];
             return c;
        }
        
int operator % (int b)const{
             Bign t
=*this,c;
             c.len
=len;
             
for(int i=len;i>=2;i--){
                 t.s[i
-1]+=(t.s[i]%b)*10;
                 t.s[i
-1]%=b;//优化防溢出 
             }
             
return t.s[1]%b;
        }
        
//大小比较
        bool operator > (const Bign &b)const{
             
if(len>b.len)
                 
return 1;
             
else if(len<b.len)
                     
return 0;
             
else{
                  
for(int i=len;i>=1;i--)
                      
if(s[i]>b.s[i])
                         
return 1;
                  
return 0;
             }
        } 
        
bool operator > (int b)const{
             Bign t
=b;
             
return *this>t;
        }
//
        
        
//输出并换行 
        void print(){
             
for(int i=len;i>=1;i--)
                     printf(
"%d",s[i]);
             printf(
"\n");
        }
};
//OK

posted on 2011-10-21 20:13 Naeioi Zhu 阅读(283) 评论(0)  编辑 收藏 引用 所属分类: 标准代码库


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理