网络赛用MOD-含读入输出优化模板和几个常用函数

标签：

之前一场比赛被读入优化坑了，一怒之下写了MOD

MOD说明：

加入读入和输出优化，加快了速度

输入输出本地运行添加颜色区分

加入了一些常用函数，随机数范围扩大至0~2^64-1

读入与输出优化实测结果：

与scanf相比

整数类型速度提高一倍左右

浮点型速度提高5~7倍

字符及字符串类型提高1/10 

与printf相比

整数类型速度提高1/5~2倍（数字越少速度越快）左右

浮点型速度不变

字符及字符串类型提高1/10 

下方贴代码

<span style="font-size:12px;">/*****************************THIS IS MOD ****************************************/

/**

吉林大学
Jilin University

Author:     sinianluoye (JLU_LiChuang)
Date:       2015-5-14

网络比赛用MOD

**/

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>

#include<vector>
#include<map>
#include<queue>
#include<set>
#include<string>

#define ll long long
#define ull unsigned long long
#define eps 1e-8
#define ms(x,y) (memset(x,y,sizeof(x)))
#define fr(i,x,y) for(int i=x;i<=y;i++)
#define rfr(i,x,y) for(int i=x;i>=y;i--)
#define sqr(x) ((x)*(x))
#define MP(x,y) make_pair(x,y)
#define PB(x) push_back(x)
#define f1 first
#define f2 second

using namespace std;

/******************************************以下常用函数及常量模板********************************************************/

///**以下常数在需要时启用，不需要时请注释掉**///

///const int INF=0x3f3f3f3f;
///const double D_INF=1e100;
///const double C=0.577215664901532860606;//欧拉常数
///const double pi=3.141592653589793238;//圆周率
///const double e=2.71828182845904523536;//自然对数
///const double fai=1.6180339887;//黄金分割数


template<class T>
T gcd(T a,T b){
  if(!b)
    return a;
  while(b^=a^=b^=a%=b);
  return a;
}

template<class T>
T max(const T& t1,const T& t2,const T& t3)
{
    return max(max(t1,t2),t3);
}
template<class T>
T max(const T& t1,const T& t2,const T& t3,const T& t4)
{
    return max(max(t1,t2),max(t3,t4));
}
ll fpow(ll x,ll y,ll mod=0x7fffffffffffffffll)
{
    ll ret=1;
    while(y)
    {
        if(y&1)
            ret*=x,ret%=mod;
        x*=x;
        x%=mod;
        y>>=1;
    }
    return ret;
}

void ex_gcd(ll a,ll b,ll& x,ll& y)
{
    if(b==0){x=a;y=0;return;}
    ex_gcd(b,a%b,y,x);
    y=y-a/b*x;
}
ll modrev(ll x,ll mod)///乘法逆元
{
    ll x1,x2;
    ex_gcd(x,mod,x1,x2);///mod是模数
    return x1;
}
ull T_rand(){return (ull)(rand());}
ull Rand()///返回 0~2^64-1之间的一个随机数
{
    return (T_rand()<<48)|(T_rand()<<32)|(T_rand()<<16)|T_rand();
}
/******************************************以上常用函数模板********************************************************/


///下方define启用本地读入输出添加颜色，会导致速度变慢，提交时不影响
#ifdef LOCALE_USER_SINIANLUOYE

#include <windows.h>
#define OUTCOL SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE)
#define INCOL SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY |FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
#else
#define OUTCOL
#define INCOL
#endif // LOCALE_USER_SINIANLUOYE

#define DOUBLE_OUTPUT_LENGTH 6
///浮点数输出小数点后位数

/*************************************以下读入优化模板***********************************************/

template<class T>
bool PRE_INPUT_INTENGER(T& ret)                                                                         ///C
{                                                                                                       ///O
    INCOL;                                                                                              ///P
    ret=0;                                                                                              ///R
    char c=getchar();                                                                                   ///I
    if(c==-1)return 0;                                                                                  ///G
    bool f=0;                                                                                           ///H
    while((c<'0'||c>'9')&&(c!=-1)&&(c!='-'))c=getchar();                                                ///T
    if(c=='-'){f=1;c=getchar();}                                                                        ///
    while(c>='0'&&c<='9')ret*=10,ret+=c-'0',c=getchar();                                                ///B
    if(f)ret=-ret;                                                                                      ///Y
    if(c==-1)return 0;                                                                                  ///
    return 1;                                                                                           ///S
}                                                                                                       ///I
                                                                                                        ///N
bool input(int& ret){return PRE_INPUT_INTENGER(ret);}                                                   ///I
bool input(ll& ret){return PRE_INPUT_INTENGER(ret);}                                                    ///A
bool input(ull& ret){return PRE_INPUT_INTENGER(ret);}                                                   ///N
                                                                                                        ///L
template<class T>                                                                                       ///U
bool PRE_INPUT_DOUBLE(T& ret)                                                                           ///O
{                                                                                                       ///Y
    INCOL;                                                                                              ///E
    ret=0;                                                                                              ///︵
    char c=getchar();                                                                                   ///J
    if(c==-1)return 0;                                                                                  ///L
    bool f=0;                                                                                           ///U
    while((c<'0'||c>'9')&&(c!=-1)&&(c!='.')&&(c!='-'))c=getchar();                                      ///
    bool isright=0;                                                                                     ///L
    if(c=='-'){f=1;c=getchar();}                                                                        ///I
    T t=1;                                                                                              ///C
    while((c>='0'&&c<='9')||(c=='.'))                                                                   ///H
    {                                                                                                   ///U
        if(c=='.')                                                                                      ///A
            isright=1;                                                                                  ///N
        else                                                                                            ///G
        {                                                                                               ///︶
            ret*=10,ret+=c-'0';
            if(isright)t*=10;
        }
        c=getchar();
    }
    ret/=t;
    if(f)ret=-ret;
    if(c==-1)return 0;
    return 1;
}

bool input(double& ret){return PRE_INPUT_DOUBLE(ret);}
bool input(float& ret){return PRE_INPUT_DOUBLE(ret);}

bool IS_SPECIAL_CHAR(const char& ret){return (ret==' '||ret=='\n'||ret=='\t'||ret=='\r'||ret=='\v');}
bool input(char& ret)///注意 用input输入char会滤过空格回车换行制表符
{
    INCOL;
    ret=getchar();
    if(ret==-1)return 0;
    while(IS_SPECIAL_CHAR(ret))ret=getchar();
    return ~ret;
}
bool input(char* ret)///注意 用input输入char会滤过空格回车换行制表符
{
    INCOL;
    char c;
    if(!input(c))return 0;
    *ret++=c;
    while(!IS_SPECIAL_CHAR(*(ret-1)))*ret++=getchar();
    *ret=0;
    return 1;
}

template<class T1,class T2>
bool input(T1& t1,T2& t2){return input(t1)&&input(t2);}
template<class T1,class T2,class T3>
bool input(T1& t1,T2& t2,T3& t3){return input(t1)&&input(t2)&&input(t3);}
template<class T1,class T2,class T3,class T4>
bool input(T1& t1,T2& t2,T3& t3,T4& t4){return input(t1)&&input(t2)&&input(t3)&&input(t4);}
template<class T1,class T2,class T3,class T4,class T5>
bool input(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5){return input(t1)&&input(t2)&&input(t3)&&input(t4)&&input(t5);}

/*****************************************以上读入优化模板************************************************/

/*****************************************以下输出优化模板*************************************************/

template<class T>
void PRE_OUTPUT_INTENGER(const T& t)
{
    if(!t){putchar('0');return ;}
    OUTCOL;
    T key=t;
    int tt[25];
    if(key<0)
    {
        putchar('-');
        key=-key;
    }
    int cnt=0;
    while(key)
        tt[cnt++]=key%10,key/=10;
    while(cnt)putchar(tt[--cnt]+'0');
    INCOL;
}

void output(const int& t){PRE_OUTPUT_INTENGER(t);}
void output(const ll& t){PRE_OUTPUT_INTENGER(t);}
void output(const ull& t){PRE_OUTPUT_INTENGER(t);}



template<class T>
void PRE_OUTPUT_DOUBLE(const T& key)
{
    OUTCOL;
    printf("%.DOUBLE_OUTPUT_LENGTHf",key);
    INCOL;
}

void output(const double& t){PRE_OUTPUT_DOUBLE(t);}
void output(const float& t){PRE_OUTPUT_DOUBLE(t);}

void output(const char* ch)
{
    OUTCOL;
    int cnt=0;
    while(ch[cnt])putchar(ch[cnt++]);
    INCOL;
}
void output(const char& c)
{
    OUTCOL;
    putchar(c);
    INCOL;
}

template<class T1,class T2>
void output(const T1& t1,const T2& t2){output(t1);output(t2);}
template<class T1,class T2,class T3>
void output(const T1& t1,const T2& t2,const T3& t3){output(t1);output(t2);output(t3);}
template<class T1,class T2,class T3,class T4>
void output(const T1& t1,const T2& t2,const T3& t3,const T4& t4){output(t1);output(t2);output(t3);output(t4);}
template<class T1,class T2,class T3,class T4,class T5>
void output(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5){output(t1);output(t2);output(t3);output(t4);output(t5);}
template<class T1,class T2,class T3,class T4,class T5,class T6>
void output(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6){output(t1);output(t2);output(t3);output(t4);output(t5);output(t6);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7>
void output(const T1& t1,const T2& t2,const T3& t3,const T4& t4,const T5& t5,const T6& t6,const T7& t7){output(t1);output(t2);output(t3);output(t4);output(t5);output(t6);output(t7);}


/*****************************************以上输出优化模板*************************************************/


/***************************************以下格式化输出模板************************************************/

#define EL putchar('\n')
template<class T>
void printal(T* a,int n)///print a line 在一行中打印数组的0~n-1空格分割结尾换行
{
    for(int i=0;i<n-1;i++)
        output(a[i],' ');
    output(a[n-1],'\n');
}

template<class T>
void printel(T* a,int n)///print every line 在每行中打印数组的0~n-1 每行一个元素
{
    for(int i=0;i<n;i++)
        output(a[i],'\n');
}

/***************************************以上格式化输出模板************************************************/


/**------------------------------------------------------分割线 下边写代码-------------------------------------------------------------**/

#include <ctime>

int main()
{
    int a,b;
    while(input(a,b))output(a+b,'\n');
}
</span>

网络赛用MOD-含读入输出优化模板和几个常用函数

标签：

原文地址：http://blog.csdn.net/sinianluoye/article/details/45740689