10月5日 2048

时间：2018-10-06 10:43:55 阅读：139 评论：0 收藏：0 [点我收藏+]

标签：fun nan tput string 分析 end output 数据规模相加

题目描述

此时，Conan却在一旁玩着2048。
这是一个4*4的矩阵，初始全为0。每次一个没有数字的格子中会随机出现一个2或4，每次可以选择上下左右其中一个方向去滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢外，相同数字的方块在靠拢、相撞时会相加。
Conan想看看今天自己运气咋样，于是就闭着眼睛，在屏幕上随便滑来滑去。所以这个模拟的任务就交给你了。过了一会，他然后睁开眼睛，如果游戏没有结束（滑动后如果没有空格子，则游戏结束），请输出矩阵（格式参见样例），否则输出“Game over!”（不包含引号）。

输入

输入第一行包含一个整数N，表示Conan滑了几下。
接下来N 行，x, y, v, f表示第x行与第y列出现数字为v后，Conan滑的方向为f（f为字符，U, D, L, R分别表示向上下左右滑）。
行从上往下1-4标号，列从左往右1-4标号。
数据保证在游戏未结束时，只会在空白区域出现数字。

输出

输出按题目描述。

输入样例复制

8
1 3 4 L
2 3 2 U
2 4 2 R
4 1 2 L
3 4 2 L
3 2 2 D
1 3 4 R
1 3 2 U

输出样例复制

例输出】
0 0 2 8
0 0 0 2
0 0 0 8
0 0 0 0

说明

【数据规模与约定】对于100%的数据满足。

分析

一道纯模拟的题

很多细节要注意

在向右和向上开始循环的点要注意

每行每列两个数之间只能相加一次

代码

  1 #include<iostream>
  2 #include<cstring>
  3 using namespace std;
  4 int map[5][5],flag[5][5];
  5 int fun()
  6 {
  7     for (int i=1;i<=4;i++)
  8       for (int j=1;j<=4;j++)
  9        if (map[i][j]==0)
 10          return 1;
 11     return 0;
 12 }
 13 int main ()
 14 {
 15     int n,a,b,c;
 16     char f;
 17     cin>>n;
 18     for (int i=1;i<=n;i++)
 19     {
 20         cin>>a>>b>>c>>f;
 21         if (fun()==0)z
 22         {
 23             cout<<"Game over!";
 24             return 0;
 25         }
 26         map[a][b]=c;
 27         if (f==‘L‘)
 28         {
 29             memset(flag,0,sizeof(flag));
 30             for (int i=1;i<=4;i++)
 31               for (int j=1;j<=4;j++)
 32               {
 33                   if (map[i][j]==0)
 34                     continue;
 35                   int wz=j;
 36                   for (int k=j-1;k>=1;k--)
 37                 {
 38                     if (map[i][k]==map[i][wz]&&flag[i][k]==0)
 39                     {
 40                         flag[i][k]=1;
 41                         map[i][k]=map[i][wz]*2;
 42                         map[i][wz]=0;
 43                         break;
 44                     }
 45                     if (map[i][k]==0)
 46                     {
 47                         int t=map[i][wz];
 48                         map[i][wz]=0;
 49                         map[i][k]=t;
 50                         wz=k;
 51                         continue;
 52                     }
 53                     break;
 54                 }
 55               }   
 56         }
 57         if (f==‘R‘)
 58         {
 59             memset(flag,0,sizeof(flag));
 60             for (int i=1;i<=4;i++)
 61               for (int j=4;j>=1;j--)
 62               {
 63                   if (map[i][j]==0)
 64                     continue;
 65                   int wz=j;
 66                   for (int k=j+1;k<=4;k++)
 67                 {
 68                     if (map[i][k]==map[i][wz]&&flag[i][k]==0)
 69                     {
 70                         flag[i][k]=1;
 71                         map[i][k]=map[i][wz]*2;
 72                         map[i][wz]=0;
 73                         break;
 74                     }
 75                     if (map[i][k]==0)
 76                     {
 77                         int t=map[i][wz];
 78                         map[i][wz]=0;
 79                         map[i][k]=t;
 80                         wz=k;
 81                         continue;
 82                     }
 83                     break;
 84                 }
 85               }   
 86         }
 87         if (f==‘U‘)
 88         {
 89             memset(flag,0,sizeof(flag));
 90             for (int i=1;i<=4;i++)
 91               for (int j=1;j<=4;j++)
 92               {
 93                   if (map[i][j]==0)
 94                     continue;
 95                   int wz=i;
 96                   for (int k=i-1;k>=1;k--)
 97                 {
 98                     if (map[wz][j]==map[k][j]&&flag[k][j]==0)
 99                     {
100                         flag[k][j]=1;
101                         map[k][j]=map[wz][j]*2;
102                         map[wz][j]=0;
103                         break;
104                     }
105                     if (map[k][j]==0)
106                     {
107                         int t=map[wz][j];
108                         map[wz][j]=0;
109                         map[k][j]=t;
110                         wz=k;
111                         continue;
112                     }  
113                     break;
114                 }
115               }   
116         }
117         if (f==‘D‘)
118         {
119             memset(flag,0,sizeof(flag));
120             for (int i=4;i>=1;i--)
121               for (int j=4;j>=1;j--)
122               {
123                   if (map[i][j]==0)
124                     continue;
125                   int wz=i;
126                   for (int k=i+1;k<=4;k++)
127                 {
128                     if (map[wz][j]==map[k][j]&&flag[k][j]==0)
129                     {
130                         flag[k][j]=1;
131                         map[k][j]=map[wz][j]*2;
132                         map[wz][j]=0;
133                         break;
134                     }
135                     if (map[k][j]==0)
136                     {
137                         int t=map[wz][j];
138                         map[wz][j]=0;
139                         map[k][j]=t;
140                         wz=k;
141                         continue;
142                     }
143                     break;
144                 }
145               }   
146         }
147     }
148     for (int i=1;i<=4;i++)
149         {
150             cout<<map[i][1]<<" "<<map[i][2]<<" "<<map[i][3]<<" "<<map[i][4];
151             cout<<endl;
152         }
153 }