阁楼：

众所周知，刷题要挑好的刷，程序要挑短的写，算法要挑快的用，那么人也要挑nb的关注。

置顶

OHHHHHHHHH！AK！

I！AK！IOI！

天花板

为什么天花板在阁楼下面而且就这一个啊啊啊！

这是个啥啊

通向主要排名

通向普及域排名

通向……我自己？

十楼

哎停停停别盖了这楼要塌了！

万能的chatGPT!

好东西!

双击有惊喜哦~~~

当然我相信你不会双击的。

九楼

老师，听我说屑屑你……

$IOI^{AC++^{AC++^{AC++^{AC++}_{WA--}}_{WA--^{AC++}_{WA--}}}_{WA--^{AC++^{AC++}_{WA--}}_{WA--^{AC++}_{WA--}}}}_{WA--^{AC++^{AC++^{AC++}_{WA--}}_{WA--^{AC++}_{WA--}}}_{WA--^{AC++^{AC++}_{WA--}}_{WA--^{AC++}_{WA--}}}}$

二叉IOI树

$1<N<10^{1000000}$

$0<N<10^{-1000000}$

哦豁，完啦。

八楼

论如何把A+B写得如此阴间！

#include<bits/stdc++.h> //万能头文件哦 
using namespace std;
const int N=5;
const int inf=0x3f3f3f3f;
long long a,b,n=3;
long long x[N][N],d[N]; //图与最短路数组的定义 
long long sum[N]; //前缀和数组的定义 
bool vis[N]; //判断最短路数组的定义
//最短路dijkstra写法 
void dijkstra(){
	memset(d,inf,sizeof(d)); //将最短路径设为一个最大即还没判断的值 
	d[1]=0; //特判 
	for(int i=1;i<n;i++){
		long long t=0;
		for(int j=1;j<=n;j++){
			if(!vis[j]&&(t==0||d[j]<d[t])){
				t=j; //缩小路径 
			}
		}
		vis[t]=true;
		for(int j=1;j<=n;j++){
			d[j]=min(d[j],d[t]+x[t][j]);
			//寻找自己身边的最短路径 
		}
	}
}
int main(){
	scanf("%lld%lld",&a,&b); //读入 
	memset(x,inf,sizeof(x)); //同上 
	x[1][2]=a; //付给ab权值 
	x[2][n]=b;
	dijkstra(); //算出最短路 
	for(int i=1;i<=n;i++){
		sum[i]=sum[i-1]+d[i]; //前缀和求区间 
	}
	if(sum[2]>=0){
		sum[2]=0-sum[2];
	}else{
		sum[2]=abs(sum[2]); //将2翻转以便下面做加法 
	}
	printf("%lld",sum[3]+sum[2]); //输出 
}

想要更多？

我为啥要放代码啊直接放链接就行了啊

算了当凑字数了

七楼

本人个人简介：我……什么你不会以为我要给你透露我的个人信息和账户吧，不存在的，那样可是会被JC的。

洛谷个人账户

加油！

六楼

……（我要写啥来着）

没活儿了，咬个打火机吧

. . . ?

五楼：

一个神奇的模板：（我怎么知道我为什么要放在这里）

#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
using namespace std;
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
}

一个菜菜的快读快写：

inline int read(){
    register int x=0,t=1;
    register char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')t=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x*t;
}
inline void write(int x){
    if(x<0){
    	putchar('-');
		x=-x;
	}
    if(x>9)write(x/10);
    putchar(x%10+'0');
}

四楼：

众所周知，oiclass的防御措施不强，很容易被人卡评测。那么我们来假设一下，oiclass三天卡崩一次，那么一周就会卡崩两次，那么一个月大约就会卡崩十次，一个季度大约会卡崩31次，一年大约会卡崩122次，一个世纪大约会卡崩12200次，冥王星公转太阳一周所用的时间大约会卡崩30256次，自地球诞生时开始崩大约会卡崩561200000000次，自宇宙诞生时开始崩大约会卡崩1671400000000次。（雾）

三楼：

我 对 各 模 式 的 评 测 程 度：

ACM：赛前崩溃

（坏了考ACM了不得完蛋）

IOI：赛中崩溃

（这tm题目是洛谷黑题被吧这么坑难）

OI：赛后崩溃

（RE一生之敌）

神奇的评测结果

AC：啊这题目终于过了啊！

WA：没逝，改亿下就……也不行

TLE：这tm到底是什么个思路啊？！

MLE：……算了

CE：你知道为什么变量会重名吗，我不到哇

RE：一定是我数组不够大，再逝亿次……

PC：我怎么知道是那个地方错了！

UKE：我真的谢谢你

OLE：没复制正确是不存在的好吧

二楼

你问我这是什么？我不到哇（

或许这是个【【游戏】】

#include<bits/stdc++.h>
#include<windows.h>
#include<time.h>
using namespace std;
const char Op[4]={'+','-','*','/'};
char input;
int main(){
	srand(time(0));
	printf("FUN USER MATH GAMES!\n");
	printf("<Press Enter to Start!>");
	cin.get(input);
	long long loadt=0;
	for(int i=1;i<=6;i++){
		printf("Loading......%lld%\n",loadt);
		loadt+=20;
		Sleep(1000);
	}
	printf("Please Wait to Start......\n");
	Sleep(1000);
	printf("READY......\n");
	Sleep(1000);
	printf("3!\n");
	Sleep(800);
	printf("2!\n");
	Sleep(800);
	printf("1!\n");
	Sleep(800);
	printf("GO!\n");
	Sleep(500);
	long long fun=rand()%10;
	long long ans;
	if(fun==6){
		while(true){
			printf("ERROR!\n");
		}
	}
	while(true){
		long long a,b,c;
		char op=Op[rand()%4];
		a=rand()%10;
		b=rand()%10;
		switch(op){
			case '+':
				c=a+b;
				printf("%lld+%lld=?\n",a,b);
				scanf("%lld",&ans);
				if(ans==c){
					printf("RIGHT!\n");
					printf("%lld+%lld=%lld!\n\n",a,b,c);
				}else{
					printf("WRONG!\n");
					printf("%lld+%lld=%lld!\n\n",a,b,c);
				}
				break;
			case '-':
				c=a-b;
				printf("%lld-%lld=?\n",a,b);
				scanf("%lld",&ans);
				if(ans==c){
					printf("RIGHT!\n");
					printf("%lld-%lld=%lld!\n\n",a,b,c);
				}else{
					printf("WRONG!\n");
					printf("%lld-%lld=%lld!\n\n",a,b,c);
				}
				break;
			case '*':
				c=a*b;
				printf("%lld*%lld=?\n",a,b);
				scanf("%lld",&ans);
				if(ans==c){
					printf("RIGHT!\n");
					printf("%lld*%lld=%lld!\n\n",a,b,c);
				}else{
					printf("WRONG!\n");
					printf("%lld*%lld=%lld!\n\n",a,b,c);
				}
				break;
			case '/':
				c=a/b;
				printf("%lld/%lld=?\n",a,b);
				printf("<Round Down!>\n");
				scanf("%lld",&ans);
				if(ans==c){
					printf("RIGHT!\n");
					printf("%lld/%lld=%lld!\n\n",a,b,c);
				}else{
					printf("WRONG!\n");
					printf("%lld/%lld=%lld!\n\n",a,b,c);
				}
				break;
		}
	}
}

一楼

额，或许这里没有东西……

但又或许，这……只是想考验一下这建筑牢不牢固？

地 下 逝

我要放什么呢……

给你们推荐亿道题吧……

戳我

宝藏库

或许我真想不到放什么了……

如果你看到这里那么恭喜你看到这里啊，喜欢的话给个支持吧~~~

完美收尾

你不会真以为后面还有吧，不存在的，我真想不出来了qwq