网络赛用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&#39;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