网络赛用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>

时间： 2024-10-22 10:09:10

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

读入输出优化模板

因为是直接调用系统底层所以速度会很快... 1 long long read(){ 2 long long x=0,w=1; 3 char c=0; 4 for (c=getchar();c<'0'||c>'9';c=getchar()) {if (c=='-') w=-1;} 5 for (;c>='0'&&c<='9';c=getchar()) x=(x<<3)+(x<<1)+c-'0'; 6 return x*w; 7 } 读入 1 v

[读入输出优化]4.15正确的打开方式

读入输出优化大概是那种写了不一定有用,但是好歹算是个心理安慰的东西考试题太难不知该从何下手先写个读入输出优化压压惊没啥好讲解的部分,getchar,putchar是最快的读入输出方式剩下的背模版就行提示:名字取个别那么常见的就行 /*代码部分*/ int read(){ int x,f=1; char ch; while (ch=getchar(),ch<48||ch>57) if (ch=='-') f=-f; x=ch-48; while (ch=getchar(),ch>

读入输出优化_C++

当我们考试时遇到大量的读入或者输出时,这些代码会耗费许多运行程序的时间,导致TL 本来 log2n 的算法因为读入被卡成线性的就太不划算了,所以我们这里要采用读入输出优化 getchar 和 putchar 是最快的读入输出方式,变量名尽量用一些不是很常用的,以免冲突 1 #include<cstdio> 2 #include<cstdlib> 3 #include<cstring> 4 #include<cmath> 5 #include<iostr

2019ACM-ICPC沈阳网络赛-C-Dawn-K's water（完全背包模板题）

Dawn-K's water 1000ms 262144K Dawn-K recently discovered a very magical phenomenon in the supermarket of Northeastern University: The large package is not necessarily more expensive than the small package. On this day, Dawn-K came to the supermarket

常用读入\输出优化

本文主要讲述常用的2种读入优化方法. 输出优化很少使用,在此简单提一下:也就是把输出的东西先放进字符串,再一次性puts\printf出去.提升不大,不常用. 首先当然需要先知道,scanf/printf比cin/cout快不少. 读入优化: getchar 使用getchar一个一个读入字符,转化成数字.比scanf快一些. inline int read() { int f=1,x=0;//f是正负的标识 char ch; do { ch=getchar(); if(ch=='-') f=-

c++ 读入优化、输出优化模板

0. 在有些输入数据很多的变态题中,scanf会大大拖慢程序的时间,cin就更慢了,所以就出现了读入优化.其原理就是一个一个字符的读入,输出优化同理,主要使用getchar,putchar函数. 1. int型读入优化(long long的只要把x改成long long型即可): 1 #include<cctype> 2 inline int read() 3 { 4 int x=0,f=0; char ch=0; 5 while(!isdigit(ch)) {f|=ch=='-';ch=ge

HDU 5009 Paint Pearls（西安网络赛C题） dp+离散化+优化

转自:http://blog.csdn.net/accelerator_/article/details/39271751 吐血ac... 11668627 2014-09-16 22:15:24 Accepted 5009 1265MS 1980K 2290 B G++ czy Paint Pearls Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Subm

读入输出优化

代码 #include<iostream>#include<cstdio>#include<cstring>#include<string>#include<algorithm>#include<cctype>#include<cmath>#include<cstdlib>#include<queue>#include<ctime>#include<vector>#inclu

读入/输出优化

void read(int &x) { int f=1;x=0;char s=getchar(); while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();} while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();} x*=f; } void print(int x) { if(x<0)putchar('-'),x=-x; if(x>9)print(x/10); put