强力输入挂

普通输入输出外挂，虽然没有强力挂快 但是却更加实用

inline int read(){  
    int k=0,f=1;char ch=getchar();  
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}  
    while(ch>='0'&&ch<='9'){k=k*10+ch-'0';ch=getchar();}  
    return k*f;  
}  
inline void write(int x){if(x>=10)write(x/10);putchar(x%10+'0');}  
inline void writeln(int x){write(x);puts("");}  

版本1

namespace IN
{
const int inBufferSize = 1<<25;
char inBuffer[inBufferSize];
char *inHead = NULL, *inTail = NULL;
inline char Getchar()
{
    if(inHead == inTail)
        inTail=(inHead=inBuffer)+fread(inBuffer, 1, inBufferSize, stdin);
    return *inHead++;
}
}
#define getchar() IN::Getchar()
template <typename T>
inline void scan_ud(T &ret)
{
    char c = getchar();
    ret = 0;
    while (c < '0' || c > '9') c = getchar();
    while (c >= '0' && c <= '9')
        ret = ret * 10 + (c - '0'), c = getchar();
}
scan_ud(t);

版本2

1. struct FastIO  
2. {  
3.     static const int S = 2*100;  
4.     int wpos;  
5.     char wbuf[S];  
6.     FastIO() : wpos(0) {}  
7.     inline int xchar()  
8.     {  
9.         static char buf[S];  
10.         static int len = 0, pos = 0;  
11.         if (pos==len)  
12.             pos = 0, len = fread(buf, 1, S, stdin);  
13.         if (pos==len) exit(0);  
14.         return buf[pos ++];  
15.     }  
16.     inline int xint()  
17.     {  
18.         int s = 1, c = xchar(), x = 0;  
19.         while(c<=32) c = xchar();  
20.         if(c=='-') s = -1, c = xchar();  
21.         for(;'0'<=c && c<='9';c=xchar()) x = x*10+c-'0';  
22.         return x * s;  
23.     }  
24.     ~FastIO()  
25.     {  
26.         if(wpos) fwrite(wbuf, 1, wpos, stdout), wpos = 0;  
27.     }  
28. }io;  
29.     n = io.xint();  

版本三（含强力输出）

原理是将数据一次性全部读入到内存中。

namespace IO {
    const int MT = 10 * 1024 * 1024;  /// 10MB 请注意输入数据的大小！！！
    char IO_BUF[MT];
    int IO_PTR, IO_SZ;
    /// 要记得把这一行添加到main函数第一行！！！
    void begin() {
        IO_PTR = 0;
        IO_SZ = fread (IO_BUF, 1, MT, stdin);
    }
    template<typename T>
    inline bool scan_d (T & t) {
        while (IO_PTR < IO_SZ && IO_BUF[IO_PTR] != '-' && (IO_BUF[IO_PTR] < '0' || IO_BUF[IO_PTR] > '9'))
            IO_PTR ++;
        if (IO_PTR >= IO_SZ) return false;
        bool sgn = false;
        if (IO_BUF[IO_PTR] == '-') sgn = true, IO_PTR ++;
        for (t = 0; IO_PTR < IO_SZ && '0' <= IO_BUF[IO_PTR] && IO_BUF[IO_PTR] <= '9'; IO_PTR ++)
            t = t * 10 + IO_BUF[IO_PTR] - '0';
        if (sgn) t = -t;
        return true;
    }
    inline bool scan_s (char s[]) {
        while (IO_PTR < IO_SZ && (IO_BUF[IO_PTR] == ' ' || IO_BUF[IO_PTR] == '\n') ) IO_PTR ++;
        if (IO_PTR >= IO_SZ) return false;
        int len = 0;
        while (IO_PTR < IO_SZ && IO_BUF[IO_PTR] != ' ' && IO_BUF[IO_PTR] != '\n')
            s[len ++] = IO_BUF[IO_PTR], IO_PTR ++;
        s[len] = '\0';
        return true;
    }
    template<typename T>
    void print(T x) {
        static char s[33], *s1; s1 = s;
        if (!x) *s1++ = '0';
        if (x < 0) putchar('-'), x = -x;
        while(x) *s1++ = (x % 10 + '0'), x /= 10;
        while(s1-- != s) putchar(*s1);
    }
    template<typename T>
    void println(T x) {
        print(x); putchar('\n');
    }
};

适用于正负int / LL / double 的. 

template <class T>
bool scan_d(T &ret)
{
    char c;
    int sgn;
    T bit=0.1;
    if(c=getchar(), c==EOF)
        return 0;
    while(c!='-' && c!='.' && (c<'0' || c>'9'))
        c=getchar();
    sgn=(c=='-')? -1:1;
    ret=(c=='-')? 0:(c-'0');
    while(c=getchar(), c>='0' && c<='9')
        ret=ret*10+(c-'0');
    if(c==' ' || c=='\n')
    {
        ret*=sgn;
        return 1;
    }
    while(c=getchar(), c>='0' && c<='9')
        ret+=(c-'0')*bit, bit/=10;
    ret*=sgn;
    return 1;
}