node.js——麻将算法（五）胡牌算法的一些优化处理方案（有赖子版）

以前有赖子判胡算法

http://blog.csdn.net/sm9sun/article/details/65632646

 

以前的帖子说明了处理赖子的两种方案：枚举代替及插空补缺，并最终选择了枚举遍历方案，因为当初考虑的是通过GetAppointList方法已经会剔除大多数无关联的牌了，且后期大家通过吃碰杠等也会减少手牌，姑且认为n的值为10，因为大多数麻将四个赖子直接胡。所以三个赖子也不过是1000次而已。不过随着后期做的麻将多了，才发现自己真的是图样图森破了，例如涞源的玩法，TM的三张赖子。。。一副牌赖子比普通牌还多。。。我真的是日了狗了

 

我们看枚举法，当优化n已经满足不了我们时，我们只能想办法减少循环的次数，我们看之前的算法，若其牌好可以胡牌，那么指不定在哪个位置就返回true了，最头疼的是他还胡不了，一手不连续的烂牌导致我们跑了所有的情况，针对于这种情况，我们可以在枚举前看看是否存在一张孤立单一的牌，因为若存在一张这种牌，那么他至少就得消耗一张赖子（凑成将），这样我们就能减少一层循环。

 

[javascript]  view plain  copy

 

1. /* 
2. 混牌必须替代的牌，用于剪枝 
3. 当存在一张孤立的牌时，则其至少消耗掉一张混牌 
4. 也存在孤立的牌是混牌的情况，不过此时运算效率已经很快了，不需要特殊处理 
5. 十三幺胡法不适用 
6. */  
7. function HunAppoint_mast(arr, Hun,special)  
8. {  
9.     if (special.H_13one)  
10.     {  
11.         return;  
12.     }  
13.   
14.     if (Hun < 0) {  
15.         return;  
16.     }  
17.     for (var i = 0; i < special.mj_count; i++)  
18.     {  
19.   
20.         if (arr[Hun] == 0)  
21.         {  
22.             return;  
23.         }  
24.        
25.         if (i > 26)  
26.         {  
27.             if (arr[i] == 1)  
28.             {  
29.                 arr[i]++;  
30.                 arr[Hun]--;  
31.             }  
32.         }  
33.         else if (i == 0 || i == 9 || i == 18)                
34.         {  
35.             if (arr[i] == 1 && arr[i + 1] == 0 && arr[i + 2] == 0)  
36.             {  
37.                 arr[i]++;  
38.                 arr[Hun]--;  
39.             }  
40.         }  
41.         else if (i == 8 || i == 17 || i == 26) {  
42.             if (arr[i] == 1 && arr[i - 1] == 0 && arr[i - 2] == 0)     
43.             {  
44.                 arr[i]++;  
45.                 arr[Hun]--;  
46.             }  
47.         }  
48.         else if (i == 1 || i == 10 || i == 19) {  
49.             if (arr[i] ==1 && arr[i - 1] == 0 && arr[i + 1] == 0 && arr[i + 2] == 0)    
50.             {  
51.                 arr[i]++;  
52.                 arr[Hun]--;  
53.             }  
54.         }  
55.         else if (i == 7 || i == 16 || i == 25) {  
56.             if (arr[i] ==1 && arr[i - 1] == 0 && arr[i + 1] == 0  && arr[i - 2] == 0)     
57.             {  
58.                 arr[i]++;  
59.                 arr[Hun]--;  
60.             }  
61.         }  
62.         else {  
63.             if (arr[i] == 1 && arr[i - 1] == 0 && arr[i + 1] == 0 && arr[i - 2] == 0 && arr[i + 2] == 0)    
64.             {  
65.                 arr[i]++;  
66.                 arr[Hun]--;  
67.             }  
68.         }  
69.     }  
70. }  

注：arr为手牌麻将个数数组，Hun为混牌（赖子），special是一些特殊牌型的记录，例如十三幺等

 

 

这样下来我们就可以减少几层循环了。不过仍然解决不了问题，经测试，当赖子高达8个以上时运算速度已经超1s了，游戏体验极差。

 

于是针对于这种情况，我们只能考虑第二种思路———插空补位

 

这种算法顾名思义，当我们处理一些牌的时候发现其无法剔除一组，我们不能像普通胡牌算法那样直接返回false，而是用赖子补上这个位置。最后判断需要的赖子数是否小于等于实际拥有的赖子数即可

 

[javascript]  view plain  copy

 

1.  if (Hun < 0) {  
2.         var Huncount = 0;  
3.     }  
4.     else {  
5.         var Huncount = arr[Hun];  
6.         arr[Hun] = 0;  
7.     }  
8.     var count = 0;  
9.     for (var i = 0; i < arr.length; i++) {  
10.         count += arr[i];  
11.     }  
12.   
13.     if (special.H_7pair && count + Huncount == 14) {  
14.         var needhun = 0;  
15.         for (var i = 0; i < arr.length; i++) {  
16.             var c = arr[i];  
17.             if (c % 2 == 1) {  
18.                 needhun++;  
19.             }  
20.         }  
21.         if (needhun <= Huncount) {  
22.             return true;  
23.         }  
24.   }  
25.     if (special.H_13one && count + Huncount==14) {  
26.         var pairCount = 0;  
27.         var canhu = true;  
28.         var needhun = 0;  
29.         var ones = [0, 8, 9, 17, 18, 26, 27, 28, 29, 30, 31, 32, 33];  
30.         for (var i = 0; i < ones.length; ++i) {  
31.             if (arr[ones[i]] == 2) {  
32.                 pairCount++;  
33.             }  
34.             if (arr[ones[i]] > 2) {  
35.                 canhu = false;  
36.             }  
37.             if (arr[ones[i]] == 0) {  
38.                 needhun++;  
39.             }  
40.         }  
41.         if (pairCount==0)  
42.         {  
43.             pairCount++;  
44.             needhun++;  
45.         }  
46.         if (pairCount == 1 && canhu && needhun <= Huncount) {  
47.             return true;  
48.         }  
49.     }  
50.   
51.     for (var i = 0; i < 4; i++) {  
52.         var needhun = 0;  
53.         for (var j = 0; j < 4; j++) {  
54.             needhun += j == i ? getneedhun(arr, j,false) : getneedhun(arr, j,true);  
55.         }  
56.         if (needhun <= Huncount) {  
57.             return true;  
58.         }  
59.     }  
60.     return false;  

 

 

注：七小对和十三幺特殊处理，若不满足这两种，则计算需要的赖子个数needhun。由于允许有空缺，所以我们无法将其按上一章基本判胡优化方法那样全部分割，不过我们可以分成四组，万筒条风，然后分别计算其某一组作为将的内组（3N+2）及其他三组(3N）需要的赖子和。

getneedhun的参数：（手牌数组，花色，是否已有将）

 

[javascript]  view plain  copy

 

1. var getneedhun = function (old_arr, type, hasjiang) {  
2.         var data = {  
3.             needhun: 0,  
4.             hasjiang: hasjiang  
5.         };  
6.         var arr = old_arr.concat();  
7.         var i, j;  
8.         switch (type)  
9.         {  
10.             case 0: { i = 0; j = 8;break;}  
11.             case 1: { i = 9; j = 17;break;}  
12.             case 2: { i = 18; j = 26;break;}  
13.             case 3: { i = 27; j = 33;break;}  
14.         }  
15.         data=dfs(arr, i, j, data);        
16.         return data.needhun;  
17.     };  

 

 

 

dfs用作来深度遍历数组某段，计算若剔除全部对应的i牌，最小消耗的混牌数，已知剔除有两种方法，顺子剔除del_list和同牌剔除del_same（两个三个一起算）

然后选取一个最优的结果

 

[javascript]  view plain  copy

 

1. var fmin_data = function (data1, data2) {  
2.       return data1.needhun > data2.needhun ? data2 : data1;  
3.   };  

 

 

 

[javascript]  view plain  copy

 

1. var dfs = function (arr, i, j, data) {  
2.        if (i > j) {  
3.            if (!data.hasjiang) {  
4.                data.needhun += 2;  
5.            }  
6.            return data;  
7.        }  
8.   
9.        if (i % 9 == 6 && i < 27 && arr[i + 1]%3 == 1 && arr[i + 2]%3 == 1)//8 9特殊情况，此时应该补个7  
10.        {  
11.            return del_list(arr, i, j, data);  
12.        }  
13.        else if (arr[i] == 0) {  
14.            return dfs(arr, i + 1, j, data);  
15.        }  
16.        else if (i % 9 < 7 && i < 27 && (arr[i + 1] > 0 || arr[i + 2] > 0)) {  
17.            var tmp1 = del_list(arr, i, j, { needhun: data.needhun, hasjiang: data.hasjiang });  
18.            var tmp2 = del_same(arr, i, j, { needhun: data.needhun, hasjiang: data.hasjiang });  
19.            return fmin_data(tmp1, tmp2);  
20.        }  
21.        else { return del_same(arr, i, j, data); }  
22.   
23.   
24.    };  

 

 

 

注：

1.判断条件为i不是风牌且小于等于7，同时arr[i+1],arr[i+2]至少有一个，否则可以只考虑del_same这种策略

2.由于del_list和del_same会影响arr数组及data对象，所以请注意参数传递类型

 

我们先看del_list，即剔除从i开始的三张连续的牌，若有扣除一个，若没有needhun+1，剔除后再通过dfs下一步遍历，注意此时arr[i]不一定为0，所以dfs的i不变

 

 

[javascript]  view plain  copy

 

1. var del_list = function (old_arr, i, j, data) {  
2.     var arr = old_arr.concat();  
3.     for (var k = 0; k < 3;k++)  
4.     {  
5.         if (arr[i + k] > 0)  
6.         {  
7.             arr[i+k]--;  
8.         }  
9.         else  
10.         {  
11.             data.needhun++;  
12.         }  
13.     }  
14.     return dfs(arr, i , j, data);  
15. };  

然后是del_same，这里通过hasjiang判断走到当前时是否存在将，因为若出现多个将牌，那张牌做将都可以，反正赖子要与其他的将组成3N

 

 

[javascript]  view plain  copy

 

1. var del_same = function (old_arr, i, j, data) {  
2.     var arr = old_arr.concat();  
3.     arr[i] %= 3;  
4.     switch (arr[i]) {  
5.         case 0: {  
6.             break;  
7.         }  
8.         case 1: {  
9.             if (data.hasjiang) { data.needhun += 2; }  
10.             else { data.needhun++; data.hasjiang = true; }  
11.             break;  
12.         }  
13.         case 2: {  
14.             if (data.hasjiang) { data.needhun += 1; }  
15.             else { data.hasjiang = true; }  
16.             break;  
17.         }  
18.     }  
19.     arr[i] = 0;  
20.     return dfs(arr, i + 1, j, data);  
21. };  

注：

 

1.getneedhun最后，如果没有将，则消耗两张赖子作为将，因为在这里，arr[i]若存在1张牌或2张牌，我们将其优先做将是会减少一张赖子的代价的。只有arr[i]等于3时我们才直接跳过，若出现131等组合情况，我们也会考虑111拆分后的赖子代价，所以若最后没有将，一定是所有的牌满足3N的赖子代价小于等于1，不存在由于之前没有选将导致后期用两张赖子补将造成非最优解的情况。举个例子 13两张牌，消耗1个赖子作2 然后再用2个赖子作将，共需要3个赖子，而做成11133 或11333也需要3个赖子，并不改变最优解。

2.del_same后当前arr[i]一定为0，故dfs从i+1即可。

 

效率测试截图：

 

八赖子 不能胡

 

 

 

六赖子  不能胡

 

 

一赖子 不能胡

 

 

八赖子 能胡

 

 

六赖子 能胡

 

一赖子 能胡

 

 

无赖子 不能胡

 

 

 

 

注：时间单位为毫秒，为了区分效果，每个样例跑了1W次，其实也不是很精确，因为实际跑的函数调用除了上述算法代码还有其他的处理，所以其实运行时间会更快，这几个测试截图只适用于对比不同牌型不同情况的运行状态而已。我们已知9个赖子一定是可以胡的，所以不考虑七对十三幺的情况下，我们对比没有赖子，一赖子，六赖子，八赖子等几种情况。

1.首先能胡的效率一定很快，因为赖子多时，很有可能在最外层枚举那种花色做将的循环中needhun <= Huncount就满足条件了，直接返回true

2.牌可以组成list的时候越多，效率越慢，这个不难理解，因为如果都是单独的，只考虑del_same就可以了。

3.最复杂的牌即每张牌都要走del_list，然后最后还不能胡

4.赖子越少需要处理的普通牌就越多，即效率越慢。所以究竟是枚举还是插空可以根据赖子个数分治处理。