MathorCup竞赛优秀论文

评委一评分，签名及备注 队号： 评委三评分，签名及备注 10302 评委二评分，签名及备注 选题： 评委四评分，签名及备注 A:2048 题目：基于Monte Carlo局面评估和UCT博弈树搜索的2048 摘要 本文首先提出Random-Max-Trees算法来实现人工智能的2048。此算法是通过静态评估函数来求得最优解。但是在实现的过程中出现冗余的现象，当移动方格步数过多的时候，好的评估函数却很难找到，使Random-Max-Trees算法效率降低。随后本论文采用Alpha-Beta算法，是前者的一种改进，在搜索结点数一样的情况下,可以使搜索深度达到原来的两倍。在实现的过程中发现Alpha-Beta严重依赖于着法的寻找顺序。只有当程序挑最好的子节来当先搜索，才会接近于实际分枝因子的平方根，也是该算法最好的状态。但是在首先搜索最坏的子节时，Beta截断不会发生，此时该算法就如同Random-Max-Trees一样，效率非常低，也失去Alpha-Beta的优势，也无法试图通过面的搜索来弥补策略上的不足。 本文采用蒙特卡洛评估对以上模型进行了改进。它通过对当前局面下的每个的可选点进行大量的模拟来得出相应的胜负的统计特性，在简单情况下，胜率较高的点就可以认为是较好的点予以选择。由于UCT算法能不断根据之前的结果调整策略，选择优先评估哪一个可下点。所以在蒙特卡洛德基础上运用UCT算法提高收敛速度。可求得概率为100%。 对于第二问，采用归纳法以及概率论量化数值，当方格为4?4时，最大能达到242+1n=131072，如果将方格扩展到N?N个，能达到的最大数为22+1。最后对模型进行评价。 本论文算法是采用JAVA、C++以及MATLAB实现。 关键字：Random-Max-Trees；Alpha-beta；Monte Carlo；UTC；概率论

基于Monte Carlo局面评估和UCT博弈树搜索的2048

1．问题提出

2048是最近一款非常火爆的益智游戏，很多网友自称“一旦玩上它就根本停不下来”。2048游戏的规则很简单：每次控制所有方块向同一个方向运动，两个相同数字的方块撞在一起之后合并成为他们的和，每次操作之后会在空白的方格处随机生成一个2或者4，最终得到一个“2048”的方块就算胜利了。如果16个格子全部填满并且相邻的格子都不相同也就是无法移动的话，那么游戏就会结束。

本文将建立数学模型，解答下列问题：

1. 如何才能达到2048，给出一个通用的模型，并采用完成游戏所需移动次数和成功概率两个指标来验证模型的有效性；

2. 得到2048之后，游戏还可以继续玩，那么最大能达到多大的数值呢？如果将方格扩展到N*N个，能达到的最大数是多少？

2．问题分析

本文首先基于Random-Max-Trees和Alpha-beta剪枝算法来实现人工智能（AI）的2048。本文认为可以把2048游戏看成是一场人类和计算机的博弈，人类控制所有方块向同一个方向移动并合并，计算机则在空白处随机放置一个“2”或“4”的方块。但是在AI的环境下，博弈双方都是计算机，双方都不理性，所以在AI的环境下，选用更加保守的Random-Max-Trees博弈策略比选用Mini-Max-Tree的更加适当。如果把当前格局作为博弈树的父节点，把下一步所有可能的走法所造成的格局作为树的一个子节点，如果继续使用Random-Max-Trees算法，则此算法的效率很不理想，会造成许多不必要的步骤。因为每一个子节后面还有子节，可能的情况很多循环往复，直到2048为止，但是并不是所有的节点都必须搜索完毕，有些节点是不必要的。为了解决这一问题，本文可以采用Alpha-beta剪枝算法。

对于第一问为实现2048的这种情况，蒙特卡洛评估是一个很好的解决方法，它通过对当前局面下的每个的可选点进行大量的模拟来得出相应的胜负的统计特性，在简单情况下，胜率较高的点就可以认为是较好的点予以选择。UCT在蒙特卡洛评估算法的基础上很大的提高了收敛速度，UCT能不断根据之前的结果调整策略，选择优先评估哪一个可下点，基于此策略从而也可以得到第二问的答案。 对于第二问，如何计算出最大值是有条件的，对有随机值的问题，我们需要量化数值，如果考虑随机那么就有不确定性，这会使我们无法接近最大值，所以在最开始就直接规定好，取4来作为加数，因为这是累计的题目，4比2大，所以在有限的范围内，4的总和肯定比2的总和大。规定好数值，开始计算最大值。最大值是2的倍数，通过玩2048已经知道相同的数可以合并形成更大的数，合并一个数需要有两个数的空间，通过这一规律我们可以知道当格子都排满的情况下，还

2

是有可能进行数字的合并的，如果可以进行合并的话，那就又增加一个4，这时又是满格的情况，如果合并过的数再次进行和并又再次产生一个空位，那么以此类推用过可以产生15次空格，那么，这15有同时增加了15次4，通过这些新加入的4，数值会进一步的增加。

3．模型的假设

1) Alpha-Beta有比Minimax搜索算法更加准确的评估函数才能保证那些优秀的

节点不被过早的剪枝；

2) 博弈树较小而可以被完全展开，博弈树叶子节点的价值可以通过胜负关系来确

定，搜索的结果就是最优解； 3) 博弈树很大而不能被完全展开时，博弈树叶子节点的价值可以通过静态评估函

数计算出来，当静态评估函数较为准确时，就可以得到相应的近似最优解；

4．符号说明

D：2048中块数的最大数值 N：无数字块数

I(x): minimax的最小值 Fi(x):定义在R上的实值函数

nXj第j台机器到目前为止的平均收益 :

T?n?第j台机器被测试的次数

:

n:所有机器目前被测试的总次数

5．型建立与求解

5.1. 问题一

5.1.1 Random-Max-Trees算法

Random-Max-Trees是从Minimax算法改变而来。只是加了一个条件，双方都是非理性的条件下，本质还是Minimax。

Minimax的定义

I(x)=ifi?x??F?x?

3

??

minF?x??maxfi?x?,x?Rn,xi?i?m （1.1）

fi?x?,i?1,2,...,m是定义在R上的实值函数。它等价于非线性优化问题

nmin z, （1.2）

s..t fi?x??z?0,

i?1,2,...,m （1.3）

可用求解约束问题的算法求解问题(1.2）-(1.3)，从而得到Minimax问题的

解。

假设在博弈过程中，对方总是选择使得博弈值最小的移动，我方则会选择博弈值最大的移动，对方称为Min，则我方称为Max，且都是非理性的。由于博弈双方是交替移动的，所以博弈树的结点及其父结点分属于我方与对方其中的一个，其种类分属Max和Min。博弈树上的每个结点对应于一个深度，叶结点的深度为0。因此，在任意的结点node，对博弈双方均最优的博弈值为

?Evaluate(note)?MinMax(node)=?MAXseSuccessors(node)(MinMax(s))??MINseSuccessors(node)(MinMax(s))

由此，很自然地得出Random-Max-Trees算法，用来求出满足一些条件的二人零和博弈问题的博弈值。

5.1.2. Alpha-beta剪枝算法

Alpha-beta算法是对Minimax算法的优化，运行效率比Minimax更高，自然也比Random-Max-Trees快。Random-Max-Trees算法在检查整个博弈树，效率非常低的，当步数越来越多的时候，每次搜索更深一层时，树的大小就呈指数式增长，工作量越来越大，存在着2种明显的冗余现象，自然降低了搜索的效率。第1种现象是极大值冗余。在图1-a中，节点A的值应是节点B和节点C的值中之较大者。现在已知节点B的值大于节点D的值。由于节点C的值应是它的诸子节点的值中之极小者，此极小值一定小于等于节点D的值，因此亦一定小于节点B的值，这表明，继续搜索节点C的其他诸子节点E, F,…已没有意义，它们不能做任何贡献，于是把以节点C为根的子树全部剪去。这种优化称为Alpha剪枝。在图1-b是与极大值冗余对偶的现象，称为极小值冗余。节点A的值应是节点B和节点C的值中之较小者。现在已知节点B的值小于节点D的值。由于节点C的值应是它的诸子节点的值中之极大者，此极大值一定大于等于节点D的值，因此也大于节点B的值，这表明，继续搜索节点C的其他诸子节点已没有意义，并可以把以节点C为根的子树全部剪去，这种优化称为Beta剪枝。

而Alpha-beta算法是在众多路线里尽可能选择最好的线路。要想通过检查搜索树的前面几层，并且在叶子结点上用启发式的评价，那么做尽可能深的搜索是很重要的。下面通过比较来进一步了解Random-Max-Trees算法与Alpha-beta剪枝算法的关系。

A. 对于一个Min节点，若能估计出其倒推值的上确界Beta，并且这个Beta

4

值不大于Min的父节点(Max节点)的估计倒推值的下确界Alpha，即Alpha?Beta，则就不必再扩展该Min节点的其余子节点了，因为这些节点的估值对Min父节点的倒推值已无任何影响了，这一过程称为Alpha剪枝。

B. 对于一个Max节点，若能估计出其倒推值的下确界Alpha，并且这个

Alpha值不小于Max的父节点(Min节点)的估计倒推值的上确界Beta，即Alpha?Beta，则就不必再扩展该Max节点的其余子节点了，因为这些节点的估值对Max父节点的倒推值已无任何影响了。这一过程称为Beta剪枝。

C. 一个Max节点的Alpha值等于其后继节点当前最大的最终倒推值，一个

Min节点的Beta值等于其后继节点当前最小的最终倒推值

图1-a 图1-b

采用Alpha-beta剪枝，可以在相同时间内加大Random-Max-Trees的搜索深度，因此可以获得更好的效果。 5.1.3. 问题一模型的建立与求解

1) 本论文对2048游戏进行抽象化表述： 我方：（即游戏玩家）每次可以选择上、下、左、右四个行棋策略中的一种（某些格局会少于四种，因为有些方向不可走）。行棋后方块按照既定逻辑移动及合并，格局转换完成。

对方：（计算机）在当前任意空格子里放置一个方块，方块的数值可以是“2”或“4”。放置新方块后，格局转换完成。

胜利条件：出现某个方块的数值为“2048”。

失败条件：格子全满，且无法向四个方向中任何一个方向移动（均不能触发合并）。

这样分析，于是2048游戏就可化成建立一个模型解决信息对称的双人对弈问题。

2) 评价当前格局的价值

在2048中，除了终局外，中间格局并无非常明显的价值评价指标，因此需要 用一些启发式的指标来评价格局。那些分数高的“好”格局是容易引向胜利的格局，而分低的“坏”格局是容易引向失败的格局。

5

本文采用了如下几个启发式指标，如下：

孤对 立方空 空平选单格格滑择调 数数性的性 字剪枝 解释： (1)单调性

单调性指方块从左到右、从上到下均遵从递增或递减。一般来说，越单调的格局越好。

（2）平滑性

是指每个方块与其直接相邻方块数值的差，其中差越小越平滑。例如2旁边是4就比2旁边是128平滑。一般认为越平滑的格局越好。

（3）空格数

这个很好理解，因为一般来说，空格子越少对玩家越不利。所以我们认为空格越多的格局越好。

（4）孤立空格数

这个指标评价空格被分开的程度，空格越分散则格局越差。 （5）对方选择的剪枝

在这个程序中，除了采用Alpha-beta剪枝外，在Min节点还采用了另一种剪枝，即只考虑对方走出让格局最差的那一步（而实际2048中计算机的选择是随机的），而不是搜索全部对方可能的走法。这是因为对方所有可能的选择为“空格数×2”，如果全部搜索的话会严重限制搜索深度。

3.可以找实验玩家获得数据，再进行因子分析，根据这五种因素对到达2048步数的影响确定权重。

5.1.4. 问题一模型的改进 5.1.4.1蒙特卡罗算法

蒙特卡罗(Monte Carlo)方法也称为随机模拟方法，是一种最优有限的搜索方法。它的基本思想是，为了求解数学、物理、工程技术以及生产管理等方面的问题，首先建立一个概率模型或随机过程，使它的参数等于问题的解:然后通过对模型或过程的观察或抽样试验来计算所求参数的统计特征，最后给出所求解的近似值。

在应用蒙特卡罗方法解决2048问题的过程中，大体上有如下几个内容: 1) 对求解的问题建立简单而又便于实现的概率统计模型，使所求的解恰好是所建

6

立模型的概率分布或数学期望。

2) 根据概率统计模型的特点和计算实践的需要，尽量改进模型，以便减小方差和

降低费用，提高计算效率。 3) 建立对随机变量的抽样方法，其中包括建立产生伪随机数的方法和建立对所遇

到的分布产生随机变量的随机抽样方法。

4) 给出获得所求解的统计估计值及其方差或标准误差的方法。 5.1.4.2 UCT算法(UCB for treesearch)

UCT又名UCB for Tree Search,是上限信心界(Upper confidence bound,UCB)在Tree Search上的应用。UCB策略是为了解决相互独立且收益率不同的因子,获得尽可能大的回报的最佳策略。大致上来说，每一次操作UCB会根据每一个因子目前的平均收益值，加上一个额外的参数，得出本次操作此因子的UCB值，然后根据此值，挑选出拥有最大UCB值的因子，作为本次操作所要选择的因子。其中，所谓额外参数，会随每一台因子被选择的次数增加而相对减少，其目的在于让选择因子时，不过分拘泥于旧有的表现，而可以适度地探索其他因子。

UCB公式的一般型式:

Score?Exploitation?Exploration

在实践中，检定效果较好的一个UCB公式表示如下:

2lognTj(n)Xj? XjTn是第j台机器到目前为止的平均收益，??是第j台机器被测试的次数，

n是所有机器目前被测试的总次数。

Tree Search开始时，UCT会建立一棵Tree，然后: 1) 2) 3) 4)

从根节点开始

利用UCB公式计算每个子节点的UCB值，选择UCB值最高的子节点 若此子节点并非叶节点(从未拜访过的节点)，则由此节点开始，重复(2) 直到遇到叶节点，则计算叶节点的收益值，并依此更新根节点到此一节点路径上的所有收益值

5) 由(1)开始重复，直到时间结束，或达到某一预设次数 6) 由根节点的所有子节点中，选择平均收益值最高者，作为最佳节点，此一节点，

就是UCT的结果。 5.1.4.3 改进的模型

其中

aivw代表第i个因子，i表示第i个因子目前被访问的次数，i表示第i个因

7

子目前获胜的次数，其中i?[1,k]，我们可以知道，胜次数永远受到访问次数的限制。先用

vi?wi并且v?w，这是因为获

v??ivi表示到目前为止所有手臂被访问

vj?v2，，

w??iwi的次数和，表示到目前为所有因子的获胜次数和。显然地，如果则?i?jvi?V?vj?VVvi??vj22，因此有 当利用UCT算法确定究竟哪一个可下点会变成最终的落子点时，总是会选择那个被访问最大次数的可下点。所以，j??1,...,k??i?j利用绝对剪枝条件时，被访问最多次数的节点绝对不可能满足剪枝条件，这样就保证在使用绝对剪枝条件

后，根据访问次数做出的最终决策结果将和使用原始的UCT方法保持一致。

如果存在明显好于其他节点的可下点，总被访问次数可能在没有达到我们预期的总访问次数时就已经有节点的访问次数突破预计访问次数的一半。因此，在加入绝对剪枝条件后，可以提前终止模拟，达到节省时间的作用。 5.1.4.4 模型的验证

分析：移动次数和成功概率两个指标来验证模型的有效性，需要单独提出移动次数和成功概率进行分析，移动次数和成功概率可以通过程序进行实践，程序内部含有移动次数的统计和制定的目标既是移动数值达到2048，自动移至2048是用到了AI，自动的进行实践，AI能够自动且合理的规避无法移至2048的可能，使达到2048成为可能。

证明：

移动次数是通过AI来进行统计，AI会找到最合理的路径，虽然不会是最短的路径，却是最合理的路径。

static inline board_t execute_move(int move, board_t board) { switch(move) {

case 0: /* up*/ return execute_move_0(board); case 1: /* down*/return execute_move_1(board); case 2: /*left*/return execute_move_2(board); case 3: /*right*/return execute_move_3(board); default:return ~0ULL; } }

这是AI的方向移动，switch选择方向，move由别的函数赋值来对AI进行路线的选择，从中找到最合理的路线。

最合理的路线是表示能够在成功合并成2048的前提下分数最高，且路径也少，通过程序的运行能够输出结果：

8

可以从上图的结果中看到，当玩到2048时一共移动了11700步，分数是316700，但是这个结果并不是唯一的，因为每一次开始的数值都是不一样的，那么AI对于不同的情况给出的操作也是不同的，所以这也是答案不唯一的原因。但是通过多次的模拟总结，发现移动的次数是离散的，散点状的分布在10000到15000之间，这个我们可以用函数分部的方式来进行分析。

AI能够100%的运行并成功达到2048，所以这个成功率是100%的。 5.2问题二模型的建立与求解

本文发现2048中每一格都是2n的整数，通过相同2n的数块结合形成2n+1的数块，同时在移动的过程中产生新的数块，包括21和22两种数块，且是随机均等几率的。

形成一个22需要2个21，且需要两个数块来形成一个数块。

形成一个23需要2个22，如果都是22的情况则需要2个数块形成一个数块，同理如给出1个22的情况和2个21的情况同时存在时，需要三个数块形成一个数块。

同理可知24,25直至2n次，可以用2个2n-1来形成。 假设在16格中存在最大数X，且环境最为理想 则假设X=2n

形成一个2n两个2n-1,作为最理想的情况来求解

9

假设已经存在一个2n-1，另一个2n-1便由2个2n-2形成，同时已经存在一个2n-2，那么另一个2n-2由2个2n-3形成，以此类推，我们可以发现每一个2次数级都拥有一个数块，而2048这款游戏有4X4的16个数块，那么我们可以推断出16个数块存在16个不同的数级。因为移动中随机产生的数有2和4，那么我们便独立讨论

当数从21开始，那么最高数值便是21+15=216 2 256 512 8192

当数从22开始，那么最高数值便是22+15=217 4 512 1024 131072

作为理想化的推断，以每次都是4出现的话，可知217为最高数值。 X=2或者4，假定之后一直都是选定的数，作为理想情况。 N为剩下的数块数 D为最大数值 X=4的情况

初始情况为2个2时，可合并成4，此时产生一个4，剩下14个数块 移动生成8，再次产生一个4，剩下一14个数块，D为8 随机移动，产生一个4，剩下13个数块，D为8

再次移动产生4，同时合并4，产生2个8，剩下13个数块，D为8 再次移动产生4，合并产生16，剩下14个数块，D为16 以此类推我们可以发现，当数块为奇数个时必剩下4 D=错误！未找到引用源。

10

4 128 1024 16384 8 64 2048 32768 16 32 4096 65536 8 256 2048 65536 16 128 4096 32768 32 64 8192 16384

if (bestTree == null) { t.weight = it.weight; bestTree = t;

} else {

if (bestTree.weight > it.weight) {

t.weight = it.weight; bestTree = t; }

} } return bestTree; } return tree; } }

% Alpha-beta剪枝算法代码

int AlphaBeta(int depth, int alpha, int beta) {

//如果层数为0或者已达最终状态则返回本步棋的估值 if(depth == 0 || IsGameOver()) return Evaluate(); for(each possible move){ MakeMove();

int val = -AlphaBeta(depth - 1, -beta, -alpha); UnMakeMove(); if(val >= beta){ return val; }

if(val > alpha){ alpha = val; ... } }

return alpha;//返回最好的值 }

%UCT搜索的代码：

Orientation UctPlayer::NextMove(const FullBoard& full_board) const { int mc_count = 0;

while (mc_count < kMonteCarloGameCount) { FullBoard current_node;

16

Orientation orientation = MaxUcbMove(full_board); current_node.Copy(full_board);

current_node.PlayMovingMove(orientation); NewProfit(¤t_node， &mc_count); }

return BestChild(full_board); }

48 /*2048*/

#include #include #include #include #include

int code[4][4]={0,0,0,0, 0,0,0,0, 0,0,0,0,

0,0,0,0};/*游戏中的16个格子*/ int temp[5];/*中间变量*/ int move=0;/*移动次数*/ int score=0;/*分数*/

void print(void)/*显示游戏界面*/ {

int i,j;

system(\清屏*/ printf(\

printf(\ A--LEFT S--DOWN D--RIGHT printf(\ printf(\

printf(\显示横向分隔线*/ for(i=0;i<=3;i++) {

for(j=0;j<=3;j++) {

if(code[i][j]==0) {

printf(\ \显示空格*/ } else {

17

0--EXIT\\n\

printf(\显示数字和分隔线*/ } }

printf(\显示横向分隔线*/ } }

int add(void)/*对中间变量数组进行处理*/ {

int i; int t=0;

int change=0;/*判断数组是否有改变，0不变，1变化*/

do {

for(i=0;i<=3;i++) {

if(temp[i]==0) {

if(temp[i]!=temp[i+1])

change=1;/*当一个0后面不是0时数组改变*/ temp[i]=temp[i+1]; temp[i+1]=0; }

}/*去掉中间的0*/ t++;

}while(t<=3);/*重复多次*/ for(i=1;i<=3;i++) {

if(temp[i]==temp[i-1]) {

if(temp[i]!=0) {

change=1;/*当两个非零相同的数相加时数组改变*/ score=score+temp[i];/*加分*/ }

temp[i-1]=temp[i-1]*2; temp[i]=0; }

}/*把两个相邻的相同的数加起来*/ do {

for(i=0;i<=3;i++)

18

{

if(temp[i]==0) {

temp[i]=temp[i+1]; temp[i+1]=0; }

}/*去掉中间的0*/ t++;

}while(t<=3);/*重复多次*/ return change; }

int main(void) {

int gameover=0;/*判断游戏是否结束，1结束，0继续*/ int i,j;

int change=1;/*判断格子中的数是否改变，0不变*/ char input;

srand((unsigned)time(NULL));/*设置随机数的起点*/ while(gameover==0) {

if(change>=1)/*仅当数发生改变时添加新数*/ {

do {

i=((unsigned)rand())%4; j=((unsigned)rand())%4; }while(code[i][j]!=0);

if(((unsigned)rand())%4==0) {

code[i][j]=4; } else {

code[i][j]=2;/*随机选一个空格填上2或4*/ }

move++;/*增加次数*/ }

print();/*显示*/

input=getch();/*输入方向*/

change=0; switch(input)

19

{

case '0':/*退出*/

printf(\ input=getchar();

if(input=='y'||input=='Y') exit(0); break;

case 'W':

case 'w':/*上*/

for(j=0;j<=3;j++) {

for(i=0;i<=3;i++) {

temp[i]=code[i][j];/*把一列数移到中间变量*/ }

temp[4]=0;

change=change+add(); for(i=0;i<=3;i++) {

code[i][j]=temp[i];/*把处理好的中间变量移回来*/ } }

break;

case 'A':

case 'a':/*左*/

for(i=0;i<=3;i++) {

for(j=0;j<=3;j++) {

temp[j]=code[i][j];/*把一行数移到中间变量*/ }

temp[4]=0;

change=change+add(); for(j=0;j<=3;j++) {

code[i][j]=temp[j];/*把处理好的中间变量移回来*/ } }

break;

case 'S':

20

case 's':/*下*/

for(j=0;j<=3;j++) {

for(i=0;i<=3;i++) {

temp[i]=code[3-i][j];/*把一列数移到中间变量*/ }

temp[4]=0;

change=change+add(); for(i=0;i<=3;i++) {

code[3-i][j]=temp[i];/*把处理好的中间变量移回来*/ } }

break;

case 'D':

case 'd':/*右*/

for(i=0;i<=3;i++) {

for(j=0;j<=3;j++) {

temp[j]=code[i][3-j];/*把一行数移到中间变量*/ }

temp[4]=0;

change=change+add(); for(j=0;j<=3;j++) {

code[i][3-j]=temp[j];/*把处理好的中间变量移回来*/ } }

break; }

gameover=1; for(i=0;i<=3;i++) for(j=0;j<=3;j++) if(code[i][j]==0)

gameover=0;/*所有格子都填满则游戏结束*/

}

printf(\ getch(); return 0; }

21

48 求move的步数以及达到的最大值 /*2048*/

#include #include #include #include #include

int code[4][4]={0,0,0,0, 0,0,0,0, 0,0,0,0,

0,0,0,0};/*游戏中的16个格子*/ int temp[5];/*中间变量*/ int move=0;/*移动次数*/ int score=0;/*分数*/

void print(void)/*显示游戏界面*/ {

int i,j;

system(\清屏*/ printf(\

printf(\ A--LEFT S--DOWN D--RIGHT 0--EXIT\\n\ printf(\ printf(\

printf(\显示横向分隔线*/ for(i=0;i<=3;i++) {

for(j=0;j<=3;j++) {

if(code[i][j]==0) {

printf(\ \显示空格*/ } else {

printf(\显示数字和分隔线*/ } }

printf(\显示横向分隔线*/ } }

int add(void)/*对中间变量数组进行处理*/

22

{

int i; int t=0;

int change=0;/*判断数组是否有改变，0不变，1变化*/

do {

for(i=0;i<=3;i++) {

if(temp[i]==0) {

if(temp[i]!=temp[i+1])

change=1;/*当一个0后面不是0时数组改变*/ temp[i]=temp[i+1]; temp[i+1]=0; }

}/*去掉中间的0*/ t++;

}while(t<=3);/*重复多次*/ for(i=1;i<=3;i++) {

if(temp[i]==temp[i-1]) {

if(temp[i]!=0) {

change=1;/*当两个非零相同的数相加时数组改变*/ score=score+temp[i];/*加分*/ }

temp[i-1]=temp[i-1]*2; temp[i]=0; }

}/*把两个相邻的相同的数加起来*/ do {

for(i=0;i<=3;i++) {

if(temp[i]==0) {

temp[i]=temp[i+1]; temp[i+1]=0; }

}/*去掉中间的0*/ t++;

23

}while(t<=3);/*重复多次*/ return change; }

int main(void) {

int gameover=0;/*判断游戏是否结束，1结束，0继续*/ int i,j;

int change=1;/*判断格子中的数是否改变，0不变*/ char input;

srand((unsigned)time(NULL));/*设置随机数的起点*/ while(gameover==0) {

if(change>=1)/*仅当数发生改变时添加新数*/ {

do {

i=((unsigned)rand())%4; j=((unsigned)rand())%4; }while(code[i][j]!=0);

if(((unsigned)rand())%4==0) {

code[i][j]=4; } else {

code[i][j]=2;/*随机选一个空格填上2或4*/ }

move++;/*增加次数*/ }

print();/*显示*/

input=getch();/*输入方向*/

change=0; switch(input) {

case '0':/*退出*/

printf(\ input=getchar();

if(input=='y'||input=='Y') exit(0); break;

24

case 'W':

case 'w':/*上*/

for(j=0;j<=3;j++) {

for(i=0;i<=3;i++) {

temp[i]=code[i][j];/*把一列数移到中间变量*/ }

temp[4]=0;

change=change+add(); for(i=0;i<=3;i++) {

code[i][j]=temp[i];/*把处理好的中间变量移回来*/ } }

break;

case 'A':

case 'a':/*左*/

for(i=0;i<=3;i++) {

for(j=0;j<=3;j++) {

temp[j]=code[i][j];/*把一行数移到中间变量*/ }

temp[4]=0;

change=change+add(); for(j=0;j<=3;j++) {

code[i][j]=temp[j];/*把处理好的中间变量移回来*/ } }

break;

case 'S':

case 's':/*下*/

for(j=0;j<=3;j++) {

for(i=0;i<=3;i++) {

temp[i]=code[3-i][j];/*把一列数移到中间变量*/ }

temp[4]=0;

25

change=change+add(); for(i=0;i<=3;i++) {

code[3-i][j]=temp[i];/*把处理好的中间变量移回来*/ } }

break;

case 'D':

case 'd':/*右*/

for(i=0;i<=3;i++) {

for(j=0;j<=3;j++) {

temp[j]=code[i][3-j];/*把一行数移到中间变量*/ }

temp[4]=0;

change=change+add(); for(j=0;j<=3;j++) {

code[i][3-j]=temp[j];/*把处理好的中间变量移回来*/ } }

break; }

gameover=1; for(i=0;i<=3;i++) for(j=0;j<=3;j++) if(code[i][j]==0)

gameover=0;/*所有格子都填满则游戏结束*/

}

printf(\ getch(); return 0; }

26

27

28

29

30

本文来源：https://www.bwwdw.com/article/tbhw.html