node.js——麻将算法（一）基本判胡

首先带来的就是麻将胡牌、听牌的算法，不过大家都知道，麻将各个地方的规则都不同，所以相关算法也需要作出一定的调整。

先简单说一下本次demo的规则要求把。

1.不计番，也就是没那么多胡法，最后胡了就行。

2.胡牌结构满足4*3+2即可，也就是4套组合（一个组合3张牌）+一个对子，组合可以是顺，也可以是碰。并且不要求必须有碰或者顺，可以是七对

3.有混牌（混牌就是什么都算，相当于癞子），本章demo不会实现，后续应该还会写几篇，敬请关注~

4.牌型有34种，即3*9=27基本牌型外加东南西北中发白7个风牌

 

大概就是这么多了 ，首先说明本章主要算法就是动态规划以及回溯，具体算法介绍可以参考以下博客

http://blog.csdn.net/sm9sun/article/details/53244484   回溯

http://blog.csdn.net/sm9sun/article/details/53240542   DP动态规划

 

另外说明以下代码只是初步的小demo，并未经过大量测试，极有可能出bug，敬请关注后续博客

 

 

废话不多说了，首先，我们要先思考一个问题，就是先算听牌还是先算胡牌？

这个问题很重要。如果你的算法用于听牌（13张），也就是你要返回相应的可以胡的牌的序列然后根据此序列判断接下来是否胡牌。相反，如果你的算法用于胡牌（14张）那么实际你听牌是采取手上的牌+1张枚举所有牌去检查是否可以胡牌。

 

看起来算胡牌的话每次听牌都要进行34次枚举实验或许会浪费时间，但是仔细想想，其实胡牌也有相应的好处，就是可以迅速剪枝掉不符合胡牌的情况。举个例子，如果你手上有1个一万，没二万，听牌算法还要考虑你是否有三万以及三万与后面牌型的关系。而胡牌算法简单粗暴返回一个false即可。

两种算法究竟哪个更好取决于其的剪枝程度，现在我还无法给出确定的结论，不过从我目前的思维来说，我更倾向于胡牌算法。

 

一些定义

 

[javascript] view plain copy
 
  1. /* 
  2. #define  0~8     万 
  3. #define  9~17    饼 
  4. #define  18~26   条 
  5. #define  27      东 
  6. #define  28      南 
  7. #define  29      西 
  8. #define  30      北 
  9. #define  31      中 
  10. #define  32      发 
  11. #define  33      白 
  12.  */  
  13.   
  14.   
  15.   
  16.   
  17.   
  18.   
  19.   
  20. /*组牌信息 
  21. * 采取状态压缩方法，对于每个牌类给出状态（0~4） 
  22. * */  
  23. var Mahjongtiles_info = {  
  24.   
  25.     userID:-1,                   //对应用户ID  
  26.     in_Pai:new Array(34),        //手里的牌序列  
  27.     out_Pai:new Array(34),      //外面的牌序列  
  28.     sum_Pai:new Array(34),      //总和的牌序列  
  29.   
  30. };  
  31.   
  32. /*对局信息*/  
  33.   
  34. var Mahjonggame_info={  
  35.   
  36.     player:Array(4),            //四个用户对应的组排  
  37.     hunPai:-1,                  //混牌  
  38.     zhuangjia:0,               //庄家  
  39.     PaiList:new Array(136),    //麻将队列  
  40.   
  41. };  



 

注：PaiList为麻将队列，其还需初始化以及乱序等功能性函数

 

[javascript] view plain copy
 
  1. /*麻将队列初始化*/  
  2. function Init_List(arr){  
  3.     var index=0;  
  4.     for(var i=0;i<34;++i)  
  5.     {  
  6.         arr[index++]=i;  
  7.         arr[index++]=i;  
  8.         arr[index++]=i;  
  9.         arr[index++]=i;  
  10.     }  
  11. }  
  12.   
  13.   
  14. /*麻将队列乱序*/  
  15. function shuffle_List(arr) {  
  16.     var i = arr.length, t, j;  
  17.     while (i) {  
  18.         j = Math.floor(Math.random() * i--);  
  19.         t = arr[i];  
  20.         arr[i] = arr[j];  
  21.         arr[j] = t;  
  22.     }  
  23. }  



 

那么采用胡牌算法的话，处理听牌就很简单了，枚举所有牌型

 

[javascript] view plain copy
 
  1. /*判断是否可以听*/  
  2. function CanTingPai(arr,TingArr){  
  3.   
  4.     var ret=false;  
  5.     var result=false;  
  6.     for(var i = 0; i < 34; ++i)  
  7.     {  
  8.         // if(arr[i]<4) {             如果该牌玩家已经有4张了 是否还可以听此张 有待商榷  
  9.              arr[i]++;  
  10.              ret = CanHuPai(arr);  
  11.              arr[i]--;  
  12.         // }  
  13.              if(ret)  
  14.              {  
  15.                  result=true;  
  16.                  TingArr.push(i);  
  17.              }  
  18.     }  
  19.    return result;  
  20. }  


注：arr为状态记录的牌型数组，例如：arr[0]=3表示一万有三张

 

 

通过枚举调用CanHuPai函数验证，我们先写出相对简单的七小对胡牌规则进行验证

 

[javascript] view plain copy
 
  1. /*是否为七对*/  
  2. function CanHuPai__7pair(arr){  
  3.   
  4.     var pairCount=0;  
  5.     /*七对*/  
  6.     for(var k in arr) {  
  7.         var c = arr[k];  
  8.         if (c == 2) {  
  9.             pairCount++;  
  10.         }  
  11.         else if (c == 4) {  
  12.             pairCount += 2;  
  13.         }  
  14.         else if( c != 0)   //当c不满足0,2,4情况即有单张出现，直接返回false  
  15.         {  
  16.             return false;  
  17.         }  
  18.   
  19.     }  
  20.   
  21.     if(pairCount==7)  
  22.     {  
  23.         return true;  
  24.     }  
  25.     else  
  26.     {  
  27.         return false;  
  28.     }  
  29. }  

 

[javascript] view plain copy
 
  1. /*判断是否可以胡，枚举几类胡法*/  
  2. function CanHuPai(arr){  
  3.   
  4.     if(CanHuPai__7pair(arr))  
  5.     {  
  6.         return true;  
  7.     }  
  8.     else if(CanHuPai_norm(arr))  
  9.     {  
  10.         return true;  
  11.     }  
  12.     else  
  13.     {  
  14.         return false;  
  15.     }  
  16. }  


由于是初步的demo，先写出七小对和普通牌型的分支。

 

 

input：

 

[javascript] view plain copy
 
  1. function SetTest(arr)  
  2. {  
  3.       
  4.     arr[1]+=2;  
  5.     arr[2]+=2;  
  6.     arr[3]+=2;  
  7.     arr[4]+=2;  
  8.     arr[5]+=4;  
  9.     arr[9]+=1;  
  10.   
  11. }  

 

 

output：

9
true

 

然后是如何算胡牌。

第一步，先剔除对子使其成为3*4牌型。剔除对子的策略：

如果arr[i]==2即一对且其周围无法与其组合成一对顺子那么可以直接把其当成一对进入判胡环节

举个例子，我有两个二万，但是我一万+三万+四万总共不足4个，即无论怎么组合我这两个二万都没办法成为两组顺子

那么我这两个二万只能当做一对了，至于后面能不能胡先不管。

 

而arr[i]>2时则需要考虑 是否可以直接跳过而不进行剔除一对的判断。原理一样

 

比如arr[i]==4即有四个一样的，如果将其中两个剔除，另外两个不足与周围组合成两个顺子，那么显然这四个一样的是不可以拆成2+2的

 

arr[i]==3需要判断周围是否可以满足一个顺子

 

具体代码如下：

 

[javascript] view plain copy
 
  1. /*针对于arr[i]=2情况的剪枝处理*/  
  2. function Cancutpair_2(arr,i){  
  3.   
  4.     if(i>26)    //如果为风牌则直接可以剔除对子  
  5.     {  
  6.         return true;                      //true为可以直接剔除，false为还需回溯  
  7.     }  
  8.   
  9.     else if(i==0||i==9||i==18)         //一万 一饼 一条  
  10.     {  
  11.         if(arr[i+1]>=2&&arr[i+2]>=2) //如果对应的二与三都大等于2  
  12.         {  
  13.             return false;  
  14.         }  
  15.         else  
  16.         {  
  17.             return true;  
  18.         }  
  19.     }  
  20.   
  21.     else if(i==8||i==17||i==26)         //九万 九饼 九条  
  22.     {  
  23.         if(arr[i-1]>=2&&arr[i-2]>=2) //如果对应的七与八都大等于2  
  24.         {  
  25.             return false;  
  26.         }  
  27.         else  
  28.         {  
  29.             return true;  
  30.         }  
  31.     }  
  32.   
  33.     else if(i==1||i==10||i==19)         //二万 二饼 二条  
  34.     {  
  35.         if(arr[i-1]+arr[i+1]+arr[i+2]>=4&&arr[i+1]>=2)  //如果一+三+四大于4且三大于2  
  36.         {  
  37.             return false;  
  38.         }  
  39.         else  
  40.         {  
  41.             return true;  
  42.         }  
  43.     }  
  44.     else if(i==7||i==16||i==25)         //八万 八饼 八条  
  45.     {  
  46.         if(arr[i-1]+arr[i+1]+arr[i-2]>=4&&arr[i-1]>=2)  //如果九+七+六大于4且七大于2  
  47.         {  
  48.             return false;  
  49.         }  
  50.         else  
  51.         {  
  52.             return true;  
  53.         }  
  54.     }  
  55.   
  56.     else if(arr[i-1]+arr[i+1]+arr[i-2]+arr[i+2]>=4)   //如果相邻的两端大于四张牌  
  57.     {  
  58.         return false;  
  59.     }  
  60.     else  
  61.     {  
  62.         return true;  
  63.     }  
  64.   
  65.   
  66. }  
  67.   
  68. /*针对于arr[i]=3情况的剪枝处理，与 Cancutpair_2相反，当相邻牌数小于两张牌，则不可取*/  
  69. function Cancutpair_3(arr,i){  
  70.   
  71.     if(i>26)    //如果为风牌则不可以成为对子  
  72.     {  
  73.         return false;  
  74.     }  
  75.   
  76.     else if(i==0||i==9||i==18)         //一万 一饼 一条  
  77.     {  
  78.         if(arr[i+1]>=1&&arr[i+2]>=1) //如果对应的二与三都大等于1  
  79.         {  
  80.             return true;  
  81.         }  
  82.         else  
  83.         {  
  84.             return false;  
  85.         }  
  86.     }  
  87.   
  88.     else if(i==8||i==17||i==26)         //九万 九饼 九条  
  89.     {  
  90.         if(arr[i-1]>=1&&arr[i-2]>=1) //如果对应的七与八都大等于1  
  91.         {  
  92.             return true;  
  93.         }  
  94.         else  
  95.         {  
  96.             return false;  
  97.         }  
  98.     }  
  99.   
  100.     else if(i==1||i==10||i==19)         //二万 二饼 二条  
  101.     {  
  102.         if(arr[i-1]+arr[i+2]>=1&&arr[i+1]>=1)  //如果一+四大等于1且三大等于1  
  103.         {  
  104.             return true;  
  105.         }  
  106.         else  
  107.         {  
  108.             return false;  
  109.         }  
  110.     }  
  111.     else if(i==7||i==16||i==25)         //八万 八饼 八条  
  112.     {  
  113.         if(arr[i+1]+arr[i-2]>=1&&arr[i-1]>=1)  //如果九+六大等于1且七大等于1  
  114.         {  
  115.             return true;  
  116.         }  
  117.         else  
  118.         {  
  119.             return false;  
  120.         }  
  121.     }  
  122.   
  123.     else if(arr[i-1]+arr[i+1]+arr[i-2]+arr[i+2]>=2)   //如果相邻的两端大于两张牌  
  124.     {  
  125.         return true;  
  126.     }  
  127.     else  
  128.     {  
  129.         return false;  
  130.     }  
  131.   
  132.   
  133. }  
  134.   
  135. /*针对于arr[i]=4情况的剪枝处理，与 Cancutpair_3相似，由于多出来两个，故当相邻牌数小于四张牌，则不可取*/  
  136. function Cancutpair_4(arr,i){  
  137.   
  138.     if(i>26)    //如果为风牌则不可以成为对子  
  139.     {  
  140.         return false;  
  141.     }  
  142.   
  143.     else if(i==0||i==9||i==18)         //一万 一饼 一条  
  144.     {  
  145.         if(arr[i+1]>=2&&arr[i+2]>=2) //如果对应的二与三都大等于2  
  146.         {  
  147.             return true;  
  148.         }  
  149.         else  
  150.         {  
  151.             return false;  
  152.         }  
  153.     }  
  154.   
  155.     else if(i==8||i==17||i==26)         //九万 九饼 九条  
  156.     {  
  157.         if(arr[i-1]>=2&&arr[i-2]>=2) //如果对应的七与八都大等于2  
  158.         {  
  159.             return true;  
  160.         }  
  161.         else  
  162.         {  
  163.             return false;  
  164.         }  
  165.     }  
  166.   
  167.     else if(i==1||i==10||i==19)         //二万 二饼 二条  
  168.     {  
  169.         if(arr[i-1]+arr[i+2]>=2&&arr[i+1]>=2)  //如果一+四大等于2且三大等于2  
  170.         {  
  171.             return true;  
  172.         }  
  173.         else  
  174.         {  
  175.             return false;  
  176.         }  
  177.     }  
  178.     else if(i==7||i==16||i==25)         //八万 八饼 八条  
  179.     {  
  180.         if(arr[i-2]+arr[i+1]>=2&&arr[i-1]>=2)  //如果六+九大等于2且七大等于2  
  181.         {  
  182.             return true;  
  183.         }  
  184.         else  
  185.         {  
  186.             return false;  
  187.         }  
  188.     }  
  189.   
  190.     else if(arr[i-1]+arr[i+1]+arr[i-2]+arr[i+2]>=4)   //如果相邻的两端大等于4  
  191.     {  
  192.         return true;  
  193.     }  
  194.     else  
  195.     {  
  196.         return false;  
  197.     }  



 

 

 

同时，在判断胡牌前，加入剔除对子的调用

 

 

[javascript] view plain copy
 
  1. function CanHuPai_norm(arr){  
  2.   
  3.     var count =0;  //记录手牌总数  
  4.     for(var i = 0; i < 34; ++i) {  
  5.         count += arr[i];  
  6.     }  
  7.   
  8.     /*剔除对子*/  
  9.     var ret=false;  
  10.     for(var i = 0; i < 34; ++i)  
  11.     {  
  12.         if(arr[i]==2)  
  13.         {  
  14.             if (Cancutpair_2(arr, i))  
  15.             {  
  16.                 arr[i] -=2;     //直接剔除  
  17.                 ret = CanHuPai_3N_recursive(arr,count-2,0);  
  18.                 arr[i] +=2;  
  19.                 return ret;  
  20.             }  
  21.             else {  
  22.                 arr[i] -=2;  
  23.                 ret = CanHuPai_3N_recursive(arr,count-2,0);  
  24.                 arr[i] +=2;  
  25.                 if(ret)              //如果满足可以返回，不满足还需要尝试其他的对子  
  26.                 {  
  27.                     return ret;  
  28.                 }  
  29.             }  
  30.         }  
  31.         else if(arr[i]==3)  
  32.         {  
  33.             if (Cancutpair_3(arr, i))  
  34.             {  
  35.                 arr[i] -=2;  
  36.                 ret = CanHuPai_3N_recursive(arr,count-2,0);  
  37.                 arr[i] +=2;  
  38.                 if(ret)  
  39.                 {  
  40.                     return ret;  
  41.                 }  
  42.             }  
  43.         }  
  44.         else if(arr[i]==4)  
  45.         {  
  46.             if (Cancutpair_4(arr, i))  
  47.             {  
  48.                 arr[i] -=2;  
  49.                 ret = CanHuPai_3N_recursive(arr,count-2,0);  
  50.                 arr[i] +=2;  
  51.                 if(ret)  
  52.                 {  
  53.                     return ret;  
  54.                 }  
  55.             }  
  56.         }  
  57.   
  58.     }  
  59.    return ret;  
  60. }  


好了，也就是说接下来我们只剩下一个判断剩下的牌是否可以组成n个组合了，也就是回溯调用的CanHuPai_3N_recursive

 

 

先说明以下参数，function CanHuPai_3N_recursive(arr,count,P)   arr为牌型数组，count为剩余手牌数，count==0时表示可以胡，P代表遍历当前牌ID的下标

也就是说，假设我P=8（九万）就意味着前面的1~8万我都处理了，都是0了，9万就不用进行更多的考虑了，如果9万是1张或者2张或者4张，那么直接返回false（因为对子已经剔除

1张或2张或4张又不可能与其他组合成一组）

 

[javascript] view plain copy
 
  1. /*采取DP动态规划的思想 
  2. *递归尝试消一组牌（3张），当arr所有值即count都为0时，即可以胡牌 
  3. *count为剩余牌数 
  4. * 当遇到冲突时，即不可以胡牌 
  5. * */  
  6. function CanHuPai_3N_recursive(arr,count,P) {  
  7.   
  8.   //  process.stdout.write(arr +'\n'+count+'\n'+P+'\n');  
  9.   
  10.     var ret=false;  
  11.     if(count==0)  
  12.     {  
  13.         return true;  
  14.     }  
  15.   
  16.     if(P>26)        // 风牌只能组成碰  
  17.     {  
  18.         if(arr[P]==3)  
  19.         {  
  20.             ret=CanHuPai_3N_recursive(arr,count-3,P+1);  
  21.             return  ret;  
  22.         }  
  23.         else if(arr[P]==0)  
  24.         {  
  25.             ret=CanHuPai_3N_recursive(arr,count,P+1);  
  26.             return  ret;  
  27.         }  
  28.         else  
  29.         {  
  30.             return false;  
  31.         }  
  32.   
  33.     }  
  34.   
  35.         if(arr[P]==0){                                                //如果没有该牌，直接跳过进行下一张  
  36.              ret=CanHuPai_3N_recursive(arr,count,P+1);  
  37.         }  
  38.         if(arr[P]==1){  
  39.             if(P%9>6)                                                  //如果该牌是八或者九，则无法组合顺，不能胡  
  40.             {  
  41.                 return false;  
  42.             }  
  43.             else if(arr[P+1]>0&&arr[P+2]>0)                         //能组合成顺  
  44.             {  
  45.                 arr[P]--;  
  46.                 arr[P+1]--;  
  47.                 arr[P+2]--;  
  48.                 ret=CanHuPai_3N_recursive(arr,count-3,P+1);  
  49.                 arr[P]++;  
  50.                 arr[P+1]++;  
  51.                 arr[P+2]++;  
  52.             }  
  53.             else                                                    //无法组合顺，不能胡  
  54.             {  
  55.                 return false;  
  56.             }  
  57.         }  
  58.         if(arr[P]==2){                                              //与1同理，组成两对顺  
  59.             if(P%9>6)  
  60.             {  
  61.                 return false;  
  62.             }  
  63.             else if(arr[P+1]>1&&arr[P+2]>1)  
  64.             {  
  65.                 arr[P]-=2;  
  66.                 arr[P+1]-=2;  
  67.                 arr[P+2]-=2;  
  68.                 ret=CanHuPai_3N_recursive(arr,count-6,P+1);  
  69.                 arr[P]+=2;  
  70.                 arr[P+1]+=2;  
  71.                 arr[P+2]+=2;  
  72.             }  
  73.             else  
  74.             {  
  75.                 return false;  
  76.             }  
  77.         }  
  78.         if(arr[P]==3){  
  79.   
  80.             ret=CanHuPai_3N_recursive(arr,count-3,P+1);             //当前需求 三对顺等同于三对碰  
  81.             /* 
  82.             if(P%9>6) 
  83.             { 
  84.                 ret=CanHuPai_3N_recursive(arr,count-3,P+1); 
  85.             } 
  86.             else if(arr[P+1]>2&&arr[P+2]>2) 
  87.             { 
  88.                 arr[P]-=3; 
  89.                 arr[P+1]-=3; 
  90.                 arr[P+2]-=3; 
  91.                 ret=CanHuPai_3N_recursive(arr,count-9,P+1); 
  92.                 arr[P]+=3; 
  93.                 arr[P+1]+=3; 
  94.                 arr[P+2]+=3; 
  95.                 if(!ret) 
  96.                 { 
  97.                     arr[P + 1] += 3; 
  98.                     arr[P + 2] += 3; 
  99.                     ret=CanHuPai_3N_recursive(arr,count-3,P+1); 
  100.                     arr[P + 1] -= 3; 
  101.                     arr[P + 2] -= 3; 
  102.                 } 
  103.             } 
  104.             else 
  105.             { 
  106.                 ret=CanHuPai_3N_recursive(arr,count-3,P+1); 
  107.             } 
  108.             */  
  109.         }  
  110.         if(arr[P]==4) {                                       //如果为四张，则至少有一张与后面组成为顺，剩下的递归，P不变  
  111.             if(P%9>6)  
  112.             {  
  113.                 return false;  
  114.             }  
  115.             else if (arr[P + 1] > 0 && arr[P + 2] > 0) {  
  116.                 arr[P]--;  
  117.                 arr[P + 1]--;  
  118.                 arr[P + 2]--;  
  119.                 ret = CanHuPai_3N_recursive(arr, count - 3, P );  
  120.                 arr[P]++;  
  121.                 arr[P + 1]++;  
  122.                 arr[P + 2]++;  
  123.             }  
  124.             else  
  125.             {  
  126.                 return false;  
  127.             }  
  128.         }  
  129.   
  130.     /* 
  131.     console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'); 
  132.     process.stdout.write(arr +'\n'); 
  133.     console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'); 
  134.     */  
  135.     return ret;  
  136. }  



 

其他测试需要的代码

 

[javascript] view plain copy
 
  1. var start = new Date();  
  2.   
  3. var aMahjongtiles_info=Mahjongtiles_info;  
  4.   
  5. SetArrZero(aMahjongtiles_info.in_Pai);  
  6.   
  7. SetTest(aMahjongtiles_info.in_Pai);  
  8.   
  9. //var ret=CanHuPai(Mahjongtiles_info.in_Pai);  
  10.   
  11.   
  12. //process.stdout.write(aMahjongtiles_info.in_Pai +'\n');  
  13.   
  14. var  Tinglist=new Array();  
  15.   
  16. var ret=CanTingPai(Mahjongtiles_info.in_Pai,Tinglist);  
  17.   
  18. process.stdout.write(Tinglist +'\n');  
  19.   
  20. console.log(ret);  
  21.   
  22. var end = new Date();  
  23.   
  24. console.log(start,end,end-start);  



 

我们做一下测试吧，有一种牌型叫做九莲宝灯，即3个一万，3个九万加上二~八万各一张，其可以听所有的万子。

 

 

input

 

[javascript] view plain copy
 
  1. /*指定测试样例*/  
  2. function SetTest(arr)  
  3. {  
  4.      
  5.     arr[0+9]+=3;  
  6.     arr[1+9]+=1;  
  7.     arr[2+9]+=1;  
  8.     arr[3+9]+=1;  
  9.     arr[4+9]+=1;  
  10.     arr[5+9]+=1;  
  11.     arr[6+9]+=1;  
  12.     arr[7+9]+=1;  
  13.     arr[8+9]+=3;  
  14.   
  15. }  


output

 

9,10,11,12,13,14,15,16,17
true
2017-03-23T12:32:45.654Z 2017-03-23T12:32:45.701Z 47

 

然后我们将其改一下，变成

 

[javascript] view plain copy
 
  1. arr[9+9]+=3;  
  2.   
  3.   
  4.   arr[1+9]+=1;  
  5.   arr[2+9]+=1;  
  6.   arr[3+9]+=1;  
  7.   arr[4+9]+=1;  
  8.   arr[5+9]+=1;  
  9.   arr[6+9]+=1;  
  10.   arr[7+9]+=1;  
  11.   arr[8+9]+=3;  


即一饼变成了一条

 

output

9,10,12,13,15,16
true
2017-03-23T12:33:34.041Z 2017-03-23T12:33:34.086Z 45

 

单吊二五八饼，边一四七饼    三六九饼不胡 答案应该是正确的~

 

 

恩，今天就到这里了，这只是一个初步的demo     代码+思路总共都是今天一天搞的，所以可能会有很多的问题

接下来会做更多剪枝方面的优化、BUG修改。包括混子牌什么的~

 

posted on 2018-06-12 22:19  &大飞  阅读(1360)  评论(0)    收藏  举报

导航