• 个人简介

    阁楼:

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

    置顶

    image

    OHHHHHHHHH!AK!

    I!AK!IOI!

    天花板

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

    image

    这是个啥啊

    通向主要排名

    通向普及域排名

    通向……我自己?

    十楼

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

    万能的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<1010000001<N<10^{1000000}

    0<N<1010000000<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的。

    洛谷个人账户

    image

    加油!

    六楼

    ……(我要写啥来着)

    没活儿了,咬个打火机吧

    image

    . . . ?

    image

    五楼:

    一个神奇的模板(我怎么知道我为什么要放在这里)

    #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