掣电驱雷少年志，揽辔匡时擎浩气，志凌青冥九重天，休甘碌碌随波逝，敢作乾坤鳌首雄，当令寰宇仰英风！

于高山之巅，方见大河奔涌 于群峰之上，更觉长风浩荡

Love what you love!

浩荡百川流，鲸饮未吞海，剑气已横秋。

新丰美酒斗十千，咸阳游侠多少年。相逢意气为君饮，系马高楼垂柳边。 ——王维《少年行》

星依云渚溅溅，露零玉液涓涓，宝砌哀兰剪剪。碧天如练，光摇北斗阑干。 —— 《天净沙 · 星依云渚溅溅》

「真是，如梦似幻呢。」

“怎么？”

「我看见你从开始到现在的一切记忆；看见你，从一次次或欢乐或失落中走来。那些场景在我眼前浮现，像梦，却又那么模糊——我只听见那些声音，只感到那片声音的海洋将我环围… 你听得见吗？」

“当然。毕竟，它们是我的记忆啊。”

「或许，一次生命，便是一场发声的历程吧。我们作为人诞生时的啼哭，便在向世界发出宣告降临的声音；在一次次挑战的过程中，我们向一切阻碍我们的事物唱出不屈的战歌；在日常的点滴中，我们向所珍视之人倾诉内心深处的话语… 这样的声音，这样的感情，是不是就是我们所生存世界的本质呢？」

“或许就是这样吧。纵使一路走来，我们看见了无尽的景色，但只有那些与我们内心共鸣的声音——或来自于自然、或来自于他人的灵魂——才会真正地改变我们自己。”

「是啊… 但愿，在这片声音的海洋里，你不会迷失你的方向。我期许着听见更多，关于你的声音。怀揣着这种信念，向前走下去吧。」

“你也一样。”

We'll see creation come undone

我们会见证自己存在的印记被世界拂去

These bones that bound us will be gone

而那些既有的束缚将不再留存

We'll stir our spirits till we're one

我们会洗涤自己的灵魂直至合为一体

Then soft as shadows we'll become

然后成为掠影，散失在虚无之中

AC=Accepted 通过 Answer Cubi 粗鄙的答案

WA=Wrong Answer 答案错误 Wonderful Answer 优美的答案

TLE=Time Limit Exceed 超出时间限制 Time Limit Enough 时间充裕

OLE=Output Limit Exceed 超出输出限制 Output Limit Enough 输出足够78

MLE=Memory Limit Exceed 超出内存限制 Memory Limit Enough 内存充裕

RE=Runtime Error 程序运行时错误 Runtime Excellent 运行时（过于）优秀

PE=Presentation Error 格式错误 Pretty Excellent 十分优秀

CE=Compile Error 编译错误 Compile Easily 轻松通过编译

UKE=Unknown Error 未知错误 Unbelievable Keeping Excellent 难以置信的保持优秀

出现AC时你需要将你的答案变得更优美才能通过；

而TLE、OLE、MLE、RE经常同时出现，可以给予你少量的额外分数；

PE、CE都能给予你大量的额外分数；

UKE这个标签非常稀有，可以让你直接通过这次比赛并名列前茅。

评测状态

Waiting 评测：评测请求正在等待被评测机抓取

Fetched 评测：评测请求已被评测机抓取，正在准备开始评测

Compiling 评测：正在编译中

Judging 评测：编译成功，正在评测中

Accepted 通过：程序输出完全正确

Wrong Answer 不通过：程序输出与标准答案不一致（不包括行末空格以及文件末空行）

Time Limit Exceeded 不通过：程序运行时间超过了题目限制

Memory Limit Exceeded 不通过：程序运行内存空间超过了题目限制

Runtime Error 不通过：程序运行时错误（如数组越界、被零除、运算溢出、栈溢出、无效指针等）

Compile Error 不通过：编译失败

System Error 错误：系统错误（如果您遇到此问题，请及时在讨论区进行反馈）

Canceled 其他：评测被取消

Unknown Error 其他：未知错误

Ignored 其他：被忽略

暴力出奇迹，骗分过样例。

数学先打表，DP看运气。

暴搜挂着机，打表出省一。

穷举TLE，递推UKE，

模拟MLE，贪心还CE。

想要骗到分，就要有方法。

图论背模板，数论背公式。

动规背方程，高精背代码。

如果都没背，干脆输样例。

模拟定想全，动规定找对。

贪心定证明，二分MLE。

模拟只会猜题意 贪心只能过样例

数学上来先打表 组合数学靠运气

DP一般看规律 计算几何瞎暴力

图论强行套模板 数论只会GCD

递归递推伤不起 搜索茫然TLE

分治做得像枚举 暴力枚举数第一

数据结构干瞪眼 算法建树眼迷离

怒刷水题找信心 考试一来全懵逼

OI赛场码正解 听取WA声一片。

天若有情天亦老 我为暴力续一秒

十年OI一场空 不开long long见祖宗

比赛时节家家雨 OI赛场处处WA

超时皆不会优化 只能等原地爆炸

怎么进队拿国奖?看懂A+B PL

光速快读快写

ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);

光速快速幂：

long long quick_pow(long a,long b){
    long long r=1,k=a;
    while(b){
        if(b&1)r=r*k;
        k*=k;
        b>>=1;
    }
    return r;
}

光速归并排序

void dfs(int l, int r) {
	if(l>=r)return ;
	int mid=(l+r)/2;
	dfs(l,mid);
	dfs(mid+1,r);
	int i=l,j=mid+1,k=l;
	while(i<=mid&&j<=r) {
		if(a[i]>a[j]) {
			t[k++]=a[j++];
		} else t[k++]=a[i++];
	}
	while(i<=mid)t[k++]=a[i++];
	while(j<=r)t[k++]=a[j++];
	for(int sum=l; sum<=r; sum++)a[sum]=t[sum];
}

光速组合数组函数

int C(int n,int m) {
	int p=1,q=1;
	for(int i=n-m+1; i<=n; i++)p*=i;
	for(int i=1; i<=m; i++)q*=i;
	return p/q;
}

光速埃拉托斯特尼质数筛

void found_prime(int n,int m) {
	vis[0]=1;
	vis[1]=1;
	for(int i=2; i<=n; i++) {
		if(!vis[i]) {
			for(int j=i*i; j<=n; j+=i)vis[j]=1;
		}
	}
}

光速质因数分解

void fj(int n) {
	m=0;
	for(int i=2; i<=sqrt(n); i++) {
		if(n%i==0) {
			m+=1;
			p[m]=i;
			c[m]=0;
			n/=i;
			while(n%i==0) {
				m+=1;
			p[m]=i;
				n/=i;
				c[m]=1;
			}
		}
	}
	if(n>1) {
		m+=1;
		p[m]=n;
		c[m]=1;
	}
}

光速gcd

int gcd(int a,int b){
	return b?gcd(b,a%b):a;
}

BFS模板

char s[2000][2000];
int n,m;
queue< pair<int ,int> >q;
int nx[8]={1,-1 ,0,0,-1,-1,1,1},ny[8]={0,0,1,-1,1,-1,-1,1};
int ans=0;
void bfs(){
     while(!q.empty()){
        int x=q.front().first;
        int y=q.front().second;
        q.pop();
        for(int i=0;i<8;i++){
            int a=x+nx[i],b=y+ny[i];
            if(a<1||a>n||b<1||b>m||s[a][b]=='.')continue;
            s[a][b]='.';
            q.push({a,b});
    
        }
  
     }
}

DFS模板

void dfs(int k) {
	if(k>m) {
		bool flag[25]= {0};
		for(int i=1; i<=k; i++) {
			if(f[i]) {
				for(int j=1; j<=a[i][0]; j++)flag[a[i][j]]=1;
			}
		}
		sum++;
		for(int i=1; i<=n; i++) {
			if(flag[i]==0) {
				sum--;
				break;
			}
		}
		return ;
	}
	f[k]=1;
	dfs(k+1);
	f[k]=0;
	dfs(k+1);
}
//此代码用于查找包含1~n的子集个数

组合DFS

void dfs(int k,int num) {
	if( k>m ) {
		for(int i=1; i<=m; i++)
			cout<<s[i]<<" ";
		cout<<endl;
		return ;
	}

	for(int i=num+1; i<=n; i++) {
		if(f[i]==0) {
			f[i]=1;
			s[k] = i;
			dfs(k+1,i);
			f[i]=0;
		}
	}
}

光速斐波那契数列（记忆化搜索）

int a[105];
int fb(int n) {
	if(n==1||n==2) return 1;
	if(a[n]) return a[n];
	else {
		return a[n]=fb(n-1)+fb(n-2);
	}
}

二分查找模板(>=)

//二分查找(>=)： 
int f(int x) {
	int l=1,r=n,mid;
	while(l+1<r) {
		mid=(l+r)/2;
		if(a[mid]>=x)r=mid;
		else l=mid;
	}
	if(a[l]>=x)return l;
	else return r;
}
//STL版： 
lower_bound(a+1,a+1+n,t)-a;

二分查找模板(>)

//二分查找(>)
int f(int x) {
	int l=1,r=n,mid;
	while(l+1<r) {
		mid=(l+r)/2;
		if(a[mid]>x)r=mid;
		else l=mid;
	}
	if(a[l]>x)return l;
	else return r;
}
//STL版
upper_bound(a+1,a+1+n,t)-a;

链表的基本操作

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int n,idx;

//链表的表示
struct Node {
	int value;
	int next;
} a[N];
int head; //head表示头节点

//链表的生成
void gen() {
	//头节点的初始化
	head=0;
	a[head].value=n;
	a[head].next=1;
	//生成链表
	for(int i=1; i<=n; ++i) {
		a[i].value=i;
		a[i].next=i+1;
	}
	a[n].next=0;
	idx=n;
}

//链表的遍历
void run() {
	int now=a[head].next;
	while(now) {
		cout<<a[now].value<<' ';
		now=a[now].next;
	}
	cout<<endl;
}

//链表的删除
void erase(int x) {
	int last=head,now=a[head].next;
	while(now&&a[now].value!=x) last=now,now=a[now].next;
	if(now==0) return;
	a[last].next=a[now].next;
	a[head].value--;
}

//链表的插入,在x的后面加入v
void insert(int x,int v) {
	//查找，定位
	int now=a[head].next;
	while(now&&a[now].value!=x) now=a[now].next;
	if(now==0) return;
	//新节点加上去
	idx++;
	a[idx].value=v;
	a[idx].next=a[now].next;
	a[now].next=idx;
	a[head].value++;
}

int main() {
	n=10;
	gen();
	run();
	erase(3);
	run();
	cout<<a[head].value<<endl;
	erase(11);
	run();
	insert(5,100);
	run();
	cout<<idx<<endl;
	return 0;
}

栈的基本操作

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int stck[N],top;

//入栈
void push(int x) {
	stck[++top]=x;
}

//出栈
void pop() {
	top--;
}

//得到栈顶元素
int get_top() {
	return stck[top];
}

//得到栈大小
int length() {
	return top;
}

//判断栈是否为空
bool empty() {
	return top==0;
}

//STL中栈的基本操作
void run() {
	stack<int>s;
	s.push(1);
	s.push(100);
	s.push(6);
	cout<<s.top()<<endl;
	s.pop();
	cout<<s.top()<<endl;
	cout<<s.size()<<endl;
	cout<<s.empty()<<endl;
	//清空操作
	while(!s.empty()) s.pop();
}

int main() {
	push(1);
	push(100);
	push(6);
	pop();
	cout<<get_top()<<endl;
	cout<<length()<<endl;
	//清空操作
	top=0;
	cout<<"--------------------"<<endl;
	run();
	return 0;
}

队列的基本操作

#include<bits/stdc++.h>
using namespace std;
const int N=110;
//队列的定义 
int q[N],head=1,tail=0;

//入队
void push(int x)
{
	q[++tail]=x;
} 

//出队
void pop()
{
	head++;
} 

//获取队头 
int get_front()
{
	return q[head];
}

//返回队列大小 
int get_size()
{
	return tail-head+1;
}

//判断队列是否为空
bool get_empty() 
{
	return head>tail;
}

void run()
{
	queue<int>q;
	q.push(1);
	q.push(3);
	q.push(6);
	cout<<q.size()<<endl;
	cout<<q.front()<<endl;
	q.pop();
	cout<<q.back()<<endl;
	cout<<q.front()<<endl; 
}

int main()
{
	push(1);
	push(3);
	push(6);
	cout<<get_size()<<endl;
	cout<<get_front()<<endl;
	pop();
	cout<<get_front()<<endl;
	cout<<"----------------------"<<endl;
	run();
	return 0;
}

二分答案模板

int l=1,r=1e9;
    while(l+1<r){
        int mid=(l+r)/2;
        if(check(mid))l=mid;
        else r=mid;
    }
    if(check(l))cout<<l;
    else cout<<r;

结构体排序+友元函数

struct node {
	int a,b;
	friend bool operator <(node x,node y) { //友元函数
		return x.a<y.a;
	}
} s[10005];
//	已经定义了小于号的东西，可以直接sort
//	用法：sort(a+1,a+1+n); 1到n
//	sort(a+l,a+r+1) 表示对区间l到r进行排序

bool my(st a,st b){
  return a.w>b.w;
  //return a.w<b.w;
}
//标准结构体排序

中国象棋中马的方向数组

int nx[8]= {-2,-2 ,2,2,1,1,-1,-1},ny[8]= {-1,1,1,-1,-2,2,-2,2};