快速读入YYDS

经验分享区
1
一般用 cin>>（输入流）会比较慢，因为他要判断数据类型 
#include<iostream>
using namespace std;
int n;
int main(){
	cin>>n;
	return 0;
}
所以数据量大一点时，一般用 scanf() 函数来格式化输入 
#include<iostream>
using namespace std;
int n;
int main(){
	scanf("%d",&n);
	return 0;
}

这种情况我们称之为"卡常"

那如果数据量太大，用 scanf()也超时了呢？

这时候就要用到快速读入了，具体见注释 
#include<iostream>
#include<cstdio>
using namespace std;
int n;
int read(){
	int x=0/*x存数*/,f=1/*f存负数*/;
	char ch=getchar();//先读一个字符
	while(ch<'0'||ch>'9'){//一直读，直到是数字
		if(ch=='-'){//如果读到负号
			f=-1;//就变成负的
		}
		ch=getchar();//不是就继续读
	}
	while(ch>='0'&&ch<='9'){//只要是数字，就继续读
		x=x*10+(ch-'0'/*ASCII码转数字*/);//把ch补到个位
		ch=getchar();//继续读
	}
	return x*f;//x是绝对值,如果f(负数标记)是-1,乘f就是变负数;如果是1,则是正数
}
int main(){
	n=read();
	return 0;
}
2 个赞
2

厉害 :melting_face:

1 个赞
3

我使用的快读快写：

#define LOCAL
using namespace std;
namespace ly {
	namespace IO {
#ifndef LOCAL
		constexpr auto maxn = 1 << 20;
		char in[maxn], out[maxn], *p1 = in, *p2 = in, *p3 = out;
#define getchar() (p1==p2&&(p2=(p1=in)+fread(in,1,maxn,stdin),p1==p2)?EOF:*p1++)
#define flush() (fwrite(out,1,p3-out,stdout))
#define putchar(x) (p3==out+maxn&&(flush(),p3=out),*p3++=(x))
		class Flush {
			public:
				~Flush() {
					flush();
				}
		} _;
#endif
		namespace usr {
			template<typename type>
			inline type read(type &x) {
				x = 0;
				bool flag(0);
				char ch = getchar();
				while (!isdigit(ch)) flag ^= ch == '-', ch = getchar();
				while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
				return flag ? x = -x : x;
			}
			template<typename type>
			inline void write(type x) {
				x < 0 ? x = -x, putchar('-') : 0;
				static short Stack[50], top(0);
				do Stack[++top] = x % 10, x /= 10;
				while (x);
				while (top) putchar(Stack[top--] | 48);
			}
			inline char read(char &x) {
				do x = getchar();
				while (isspace(x));
				return x;
			}
			inline char write(const char &x) {
				return putchar(x);
			}
			inline void read(char *x) {
				static char ch;
				read(ch);
				do *(x++) = ch;
				while (!isspace(ch = getchar()) && ~ch);
			}
			template<typename type>inline void write(type *x) {
				while (*x)putchar(*(x++));
			}
			inline void read(string &x) {
				static char ch;
				read(ch), x.clear();
				do x += ch;
				while (!isspace(ch = getchar()) && ~ch);
			}
			inline void write(const string &x) {
				for (int i = 0, len = x.length(); i < len; ++i)putchar(x[i]);
			}
			template<typename type, typename...T>inline void read(type &x, T&...y) {
				read(x), read(y...);
			}
			template<typename type, typename...T>
			inline void write(const type &x, const T&...y) {
				write(x), putchar(' '), write(y...), sizeof...(y) ^ 1 ? 0 : putchar('\n');
			}
			template<typename type>
			inline void put(const type &x, bool flag = 1) {
				write(x), flag ? putchar('\n') : putchar(' ');
			}
		}
#ifndef LOCAL
	#undef getchar
	#undef flush
	#undef putchar
#endif
	} using namespace IO::usr;
} using namespace ly::IO::usr;

之后使用read()来快读write()来块写
（()内随便变量个数、类型（浮点数不行））
可以

read(int_var,char_var);
read(ULL_var);
write('a',int_var,ULL_var,char_var)
1 个赞
4

太超纲了，不适合蒟蒻食用，还是我的更适合中国蒟蒻体质

1 个赞