扫雷C++实现

  1 #include <iostream>
  2 #include<fstream>
  3 #include <ctime>
  4 #include <cmath>
  5 #include <stdlib.h>
  6 #include<stdio.h> //时间 //文件
  7 #include <string>
  8 #define random(x)(rand()%x)
  9 using namespace std;
 10 void thunder(int Dif,int Row,int Column,char *USer)
 11 {
 12     int r,c,alls[22][22],backstage[22][22]={0};
 13     srand((int)time(0));
 14     for(r=1;r<=Row;r++)                                      // 生成alls(0~1)1是雷
 15     {
 16         for(c=1;c<=Column;c++)
 17         {
 18             if(random(6)<1)  {alls[r][c]=1;} else{alls[r][c]=0;};
 19         }
 20     };
 21     for(r=0;r<=Row+1;r++)                                //生成 backstage(正确答案)
 22     {
 23         for(int c=0;c<=Column+1;c++)
 24         {
 25             if(alls[r][c]==1)
 26             {
 27                 backstage[r][c]=‘*‘;             //将1变为 *  代表雷
 28             }
 29             else
 30             {
 31                 for(int i=r-1;i<=r+1;i++)             //将0变为数字 (代表周围雷数)
 32                     for(int j=c-1;j<=c+1;j++)
 33                     {
 34
 35                         if(alls[i][j]!=alls[r][c]&&alls[i][j]==1){backstage[r][c]++;};
 36                     }
 37             };  //else 结束
 38         };    // for 结束
 39     };          // for 结束
 40     cout<<"======================*********================================"<<endl;
 41     char surface[22][22];              //生成surface(用户界面)
 42     for(r=0;r<22;r++)                  //全部为零
 43         for(c=0;c<22;c++)
 44         {
 45             surface[r][c]=‘0‘;
 46         }
 47     for(r=1;r<=Row;r++)                 //中间化 #   形成0包围#的形式  (通过数  #-->(*||数字) 的个数  赢的时候停止循环)
 48         for(c=1;c<=Column;c++)
 49         {
 50             surface[r][c]=‘#‘;
 51         }
 52     for(r=1;r<=Row;r++)                      //输出  surface   界面  便于检查
 53     {
 54         for(c=1;c<=Column;c++) {cout<<"  "<<surface[r][c];};
 55         cout<<endl;
 56     };
 57     cout<<"请按格式输入"<<endl
 58         <<"前两个数字为坐标,最后一个数字“1”表示此位置为雷,“0”则表示不是。"<<endl
 59         <<"如:1 3 1  表示一行三列是雷;2 4 0 表示二行四列不是雷"<<endl
 60         <<"提示:当数字周围雷都被扫出时,可再次按要求输入此位置,可得到周围数字。"<<endl;
 61     long  i=10000000L;         //计算时间开始
 62     clock_t start,finish;
 63     double duration;
 64     start=clock();
 65     while(i--);                //计算时间开始
 66     int num=Row*Column;        //计算#号个数
 67     while(num!=0)              //控制 是否点完所有位置
 68     {
 69         int x,y,judge;
 70        cin>>x>>y>>judge;
 71        if(alls[x][y]!=judge)
 72         {
 73             cout<<"you lose!!!"<<endl;
 74             cout<<"The answer is:"<<endl;
 75             for(r=1;r<=Row;r++)                    //输了   输出backstage  显示正确答案
 76                 {
 77                   for(int c=1;c<=Column;c++)
 78                   {
 79                      cout<<"  "<<(char)(backstage[r][c]==42?backstage[r][c]:backstage[r][c]+‘0‘);  //输出backstage
 80                   }
 81                   cout<<endl;
 82                 }
 83             break;
 84         }
 85        else
 86         {
 87             if(alls[x][y]==1)  {if(surface[x][y]==‘#‘){num--;}surface[x][y]=‘@‘; }      // 雷 判断正确 显示“@”;数“#”
 88             else
 89             {
 90                 if(backstage[x][y]!=0)                                                  //  数字 判断正确 显示数字
 91                 {
 92                     if(surface[x][y]==‘#‘){num--; surface[x][y]=backstage[x][y]+‘0‘; }  //   数“#”
 93                    else
 94                     {
 95                         int lei_num=0;
 96                        for(int i=x-1;i<=x+1;i++)                                         //数 数字周围 雷的个数
 97                             for(int j=y-1;j<=y+1;j++)
 98                             {
 99                                 if(surface[i][j]==‘@‘)
100                                lei_num++;
101                             }
102                        if(backstage[x][y]==lei_num)                                   // 看数字周围雷是否全部扫出  提示 显示数字周围
103                         {
104                             for(int i=x-1;i<=x+1;i++)
105                                 for(int j=y-1;j<=y+1;j++)
106                                         if(surface[i][j]==‘#‘)                         //数“#”
107                                         {
108                                             surface[i][j]=backstage[i][j]+‘0‘;
109                                             num--;
110                                         }
111                         }
112                     }
113                 }
114                 else                                                                   // 数字为零时   显示零周围的零
115                 {
116                     if(surface[x][y]==‘#‘){num--;};                                    //数“#”
117                    surface[x][y]=backstage[x][y]+‘0‘;
118                     for(int i=x-1;i<=x+1;i++)                                          //  显示零周围的数字
119                         for(int j=y-1;j<=y+1;j++)
120                             if(surface[i][j]==‘#‘)                                     // 避免 死循环
121                             {
122                                 surface[i][j]=backstage[i][j]+‘0‘;
123                                 num--;                                                 //数“#”
124                             }
125                             for(int k=0;k<20;k++)                                       //最多20层零 (点出最边上的零)
126                             {
127                                 for (int R=1;R<=Row;R++)                                //检查所有零
128                                     for(int C=1;C<=Column;C++)                          //再次显示零周围的数字
129                                     {
130                                         if(surface[R][C]==‘0‘)
131                                         {
132                                             for(int i=R-1;i<=R+1;i++)
133                                                 for(int j=C-1;j<=C+1;j++)
134                                                 {
135                                                     if(surface[i][j]==‘#‘)                         // 避免 死循环 数“#”
136                                                     {
137                                                         surface[i][j]=backstage[i][j]+‘0‘;
138                                                         num--;
139                                                     }
140                                                 }
141                                         }
142                                     } //匹配for 内
143                             } //匹配 for 外
144                 }//匹配else
145             }//匹配else
146         }//匹配els
147         cout<<endl;
148         cout<<"======================*********================================"<<endl;
149         for(r=1;r<=Row;r++)                                                                          //输出界面(已修改)
150         {
151             for(c=1;c<=Column;c++) {cout<<"  "<<surface[r][c];};
152             cout<<endl;
153         };
154     }                                                                                               //匹配while
155     finish=clock();                                                                                //计算时间结束
156     duration=(double)(finish-start)/CLOCKS_PER_SEC;                                                //时间变量
157     if(num==0)                                                                                      //所有
158     {
159         cout<<"              You win!  Congratulations!!                 "<<endl;
160         cout<<"                Your time is: "<<duration<<endl;
161         if(Dif==1)                                                                            //读取 简单扫雷 的存储文件
162         {
163             string Name;
164            string name[6];
165            double Time,rang;
166            double times[6];
167            int i=0;
168            ifstream inf("扫雷 简单.txt");
169            for(i=0;i<5;i++)                                                                    //文件中信息导入到数组里
170             {
171                 inf>>Name;inf>>rang>>Time;
172                name[i]=Name;
173                times[i]=Time;
174             }
175             inf.close();
176             name[5]=USer;                                                                   //本轮玩家信息
177             times[5]=duration;
178            double t1=0;
179            string t2;
180             for(int j=0;j<5;j++)                                                               //冒泡排序法
181             {
182                 for(i=0;i<5-j;i++)
183                 {
184                     if(times[i]>times[i+1])
185                     {
186                         t1=times[i];
187                        times[i]=times[i+1];
188                        times[i+1]=t1;
189                        t2=name[i];
190                        name[i]=name[i+1];
191                        name[i+1]=t2;
192                     }
193                 }
194             }
195             ofstream outf("扫雷 简单.txt");
196            for(i=0;i<5;i++)                                                                   //将前五名玩家信息存储到文件中
197             {
198                 cout<<name[i]<<"    "<<i+1<<"   "<<times[i]<<endl;
199                outf<<name[i]<<"    "<<i+1<<"   "<<times[i]<<endl;
200             }
201            outf.close();
202         }
203         if(Dif==2)                                                                            //读取 一般扫雷 的存储文件
204         {
205             string Name;
206            string name[6];
207            double Time,rang;
208            double times[6];
209            int i=0;
210            ifstream inf("扫雷 一般.txt");
211            for(i=0;i<5;i++)                                                                    //文件中信息导入到数组里
212             {
213                 inf>>Name;inf>>rang>>Time;
214                name[i]=Name;
215                times[i]=Time;
216             }
217             inf.close();
218             name[5]=USer;                                                                   //本轮玩家信息
219             times[5]=duration;
220            double t1=0;
221            string t2;
222             for(int j=0;j<5;j++)                                                               //冒泡排序法
223             {
224                 for(i=0;i<5-j;i++)
225                 {
226                     if(times[i]>times[i+1])
227                     {
228                         t1=times[i];
229                        times[i]=times[i+1];
230                        times[i+1]=t1;
231                        t2=name[i];
232                        name[i]=name[i+1];
233                        name[i+1]=t2;
234                     }
235                 }
236             }
237             ofstream outf("扫雷 一般.txt");
238            for(i=0;i<5;i++)                                                                   //将前五名玩家信息存储到文件中 并输出
239             {
240                 cout<<name[i]<<"    "<<i+1<<"   "<<times[i]<<endl;
241                outf<<name[i]<<"    "<<i+1<<"   "<<times[i]<<endl;
242             }
243            outf.close();
244         }
245         if(Dif==3)                                                                            //读取 困难扫雷 的存储文件
246         {
247             string Name;
248            string name[6];
249            double Time,rang;
250            double times[6];
251            int i=0;
252            ifstream inf("扫雷 困难.txt");
253            for(i=0;i<5;i++)                                                                    //文件中信息导入到数组里
254             {
255                 inf>>Name;inf>>rang>>Time;
256                name[i]=Name;
257                times[i]=Time;
258             }
259             inf.close();
260             name[5]=USer;                                                                   //本轮玩家信息
261             times[5]=duration;
262            double t1=0;
263            string t2;
264             for(int j=0;j<5;j++)                                                               //冒泡排序法
265             {
266                 for(i=0;i<5-j;i++)
267                 {
268                     if(times[i]>times[i+1])
269                     {
270                         t1=times[i];
271                        times[i]=times[i+1];
272                        times[i+1]=t1;
273                        t2=name[i];
274                        name[i]=name[i+1];
275                        name[i+1]=t2;
276                     }
277                 }
278             }
279             ofstream outf("扫雷 困难.txt");
280            for(i=0;i<5;i++)                                                                   //将前五名玩家信息存储到文件中
281             {
282                 cout<<name[i]<<"    "<<i+1<<"   "<<times[i]<<endl;
283                outf<<name[i]<<"    "<<i+1<<"   "<<times[i]<<endl;
284             }
285            outf.close();
286         }
287     }
288 }
289 void scale(int dif,char *User)    //选择难度
290 {
291     int row,column;
292     if(dif==1) {row=3;column=3;}
293     if(dif==2) {row=7;column=7;}
294     if(dif==3)  {row=10;column=10;}
295     cout<<"The scale is: "<<row<<"*"<<column<<endl;
296     thunder(dif,row,column,User);
297 };
298 int main()
299 {
300     int Continue=1;
301     int difficulty;
302     char user[10];
303     cout<<"                       Welcom to the game!                  "<<endl
304         <<"                         请输入用户名!                      "<<endl;
305     cin>>user;
306     while(Continue==1)
307     {
308        cout<<"=======================*******************======================="<<endl
309            <<"                          请选择难度!                        "<<endl
310            <<"                          简单——1                           "<<endl
311            <<"                          一般——2                           "<<endl
312            <<"                          困难——3                           "<<endl;
313        cin>>difficulty;
314        scale(difficulty,user);
315         cout<<"继续游戏——1     结束游戏——0"<<endl;
316         cin>>Continue;
317     }
318     return 0;
319 }
时间: 2024-10-12 10:41:45

扫雷C++实现的相关文章

bzoj1088[SCOI2005]扫雷

bzoj1088[SCOI2005]扫雷 题意: 有一个n×2的棋盘,第一列里面某些格子是雷,而第二列没有雷.由于第一列的雷可能有多种方案满足第二列的信息的限制,求根据第二列的信息第一列雷有多少种摆放方案. 题解: 水题,因为每个第一行的格子可以根据前一个第二行的格子里的信息唯一确定是否有雷,所以只要枚举第一个格子有没有雷就行. 代码: 1 #include <cstdio> 2 #include <cstring> 3 #include <algorithm> 4 #

洛谷P2670 扫雷游戏

题目描述 扫雷游戏是一款十分经典的单机小游戏.在n行m列的雷区中有一些格子含有地雷(称之为地雷格),其他格子不含地雷(称之为非地雷格).玩家翻开一个非地雷格时,该格将会出现一个数字--提示周围格子中有多少个是地雷格.游戏的目标是在不翻出任何地雷格的条件下,找出所有的非地雷格. 现在给出n行m列的雷区中的地雷分布,要求计算出每个非地雷格周围的地雷格数. 注:一个格子的周围格子包括其上.下.左.右.左上.右上.左下.右下八个方向上与之直接相邻的格子. 输入输出格式 输入格式: 输入文件第一行是用一个

Vijos 1193 扫雷 【动态规划】

扫雷 描述 相信大家都玩过扫雷的游戏.那是在一个n*n的矩阵里面有一些雷,要你根据一些信息找出雷来.万圣节到了,"余"任过流行起了一种简单的扫雷游戏,这个游戏规则和扫雷一样,如果某个格子没有雷,那么它里面的数字表示和他8连通的格子里面雷的数目.现在棋盘是n*2的,第一列里某些格子是雷,而第二列没有雷,如:o 1* 2* 3* 2o 2* 2* 2 ('*'代表有雷,'o'代表无雷)由于第一类的雷有可能有多种方案满足第二列的数的限制,你的任务即根据第二列的信息求第一列雷有多少中摆放方案.

VB一键扫雷

XP游戏,扫描内存,然后模拟鼠标点击 Private Sub Command1_Click() Dim lhwnd As Long Dim lpid As Long Dim lRet As Long Dim lhProcess As Long Dim bData(1024) As Byte Dim bXY(8) As Byte Dim x As Long Dim y As Long Dim temp As Long Dim k As Long '其中8F就表示雷,0F表示非雷,当非雷区被点击后如

BZOJ1088 [SCOI2005]扫雷Mine

Description 相信大家都玩过扫雷的游戏.那是在一个n*m的矩阵里面有一些雷,要你根据一些信息找出雷来.万圣节到了 ,“余”人国流行起了一种简单的扫雷游戏,这个游戏规则和扫雷一样,如果某个格子没有雷,那么它里面的数字 表示和它8连通的格子里面雷的数目.现在棋盘是n×2的,第一列里面某些格子是雷,而第二列没有雷,如下图: 由于第一列的雷可能有多种方案满足第二列的数的限制,你的任务即根据第二列的信息确定第一列雷有多少种摆放 方案. Input 第一行为N,第二行有N个数,依次为第二列的格子中

Delphi - XP扫雷外挂制作

技术交流,DH讲解. 本来之前就在写这个文章,还写了War3挂的教程,后来因为一些事就没有弄了.现在过年在家又没有事就继续把这个写完吧.哈哈.不要以为写个挂很容易,要想写个挂肯定要了解游戏呀.我们现在来了解下地雷是怎么产生的?其实只是我自己猜想的,毕竟这个游戏不是我写的...1 用户选择了多大的棋盘,多少地雷后棋盘应该是用一个二维数组来存储的,地雷数肯定是用一个全局变量来存储的.这点儿有异议没有?没有我就继续往下说了...2 生成地雷,肯定是随机的,那么一定会调用Rand函数咯.a.首先判断地雷

c++ 控制台版 扫雷游戏

白天看了一天书看累了,晚上瞅见扫雷游戏,就自己琢磨着做一个呗.想了一会,也没看别人怎么做的,大概1个多小时完成了这个简单版本的扫雷游戏,由于没怎么学过c#,界面的事情可能迟几天再做,明天要回家啦,哈哈! 先说思路,其实挺简单的. (1) 随机生成10个雷,标记到二维数组里,然后计算八个方向的雷的总数记录下来,这是预处理阶段. (2)输入要翻开的位置的坐标,如果是数字直接显示,是空白的话,这里采用bfs即宽度优先搜索解决,搜到最外层是数字(仅一层)时结束,具体详见代码. // 扫雷程序 #incl

迟到的儿童节礼物——小游戏三件套:扫雷,俄罗斯方块,数独

人的事情要么是饿出来了要么就是吃饱了撑出来的 其实写完刚好是在儿童节前两天,本打算作为儿童节礼物送给大家,结果新账号要3天才能发文章到主页,于是拖到了现在...事情是这样开始的:有一天,闲得蛋疼,看见同事在玩扫雷,然后就想着自己做一个,于是花了三天时间写一个自己的扫雷...写完扫雷感觉不过瘾,于是接着又写了俄罗斯方块,一晃又是三天...写完俄罗斯方块之后,觉得事不过三,再来一个,然后选了数独,其实知道这个应该是最有难度的,果然也纠结了三天数独生成算法才勉强写完...好了废话不多说,上图. 1. 

HTML5游戏开发-扫雷及其算法研究

吕蒙曰:士隔三月[1],当刮目相看.所以,在下在这三月中发奋图强,花了约莫8节信息课的时间研究扫雷.呜呼,由于在下才能尚且不足,所以也就只能勉强打过中级难度的吧.不过,一边玩的同时,我还一边对扫雷这个游戏的制做方法构思了一下.所以说,本文中的算法完全是凭借自己对扫雷游戏规则的总结而自行研发出来的,倘若和MS的扫雷玩法有些出入,还望各位看官见谅. [1]出自<孙权劝学>,原文为"士别三日",由于在下这三个月来都不曾发表博客,所以引申到"士隔三月",各位看官