包含癞子的麻将胡牌算法

记录一下麻将的通用胡牌算法实现，只要满足M x ABC + N x DDD + EE 即可胡牌。

在这里先分析一下最简单的胡牌思路：先找出所有可能的将牌，若除去两张将牌之外的所有牌都能成扑，则可胡牌。

将牌就是公式里唯一的对子EE、扑的意思是一套牌顺子ABC或者刻子DDD。

将牌的查找：遍历每张手牌，若有两张以上相同牌就能作将，或者用一张癞子凑也可。

接下来就只要判断一副牌是否成扑，伪码如下：

1. function isPu = (牌) { // 这里约定传入的牌是有序的、张数是3的倍数  
2.     if (没牌) {  
3.         return true;  
4.     }  
5.     if (若第一张是顺子中的一张) {  
6.         if (isPu(去掉该顺子剩下的牌)) {  
7.             return true;  
8.         }  
9.     }  
10.     if (若第一张是刻子中的一张) {  
11.         if (isPu(去掉该刻子剩下的牌)) {  
12.             return true;  
13.         }  
14.     }  
15.     return false;  
16. }  

只要思路清晰了算法就很简单，为什么只考虑第一张牌？其实函数内部递归调用了每张牌都会计算到的，除非没牌了。下面给出详细代码： 

1. function isPu(cards, laizi) {  
2.     if (cards.length == 0) {  
3.         return true;  
4.     }  
5.     // 若第一张是顺子中的一张  
6.     for (var first = cards[0] - 2; first <= cards[0]; first++) {  
7.         if(first % 10 > 7 || (laizi == 0 && first < cards[0])) {   
8.             // 剪枝：顺子第一张牌不会大于7点、无赖子情况下顺子第一张只能用手上的牌  
9.             continue;  
10.         }  
11.         var shunCount = 0;  
12.         for (var i = 0; i < 3; i++) {  
13.             if (cards.indexOf(first + i) >= 0) {  
14.                 shunCount++;  
15.             }  
16.         }  
17.         if (shunCount == 3 || shunCount + laizi >= 3) {  
18.             // 找到包含第一张牌的顺子  
19.             var puCards = cards.slice();  
20.             var puLaizi = laizi;  
21.             for (var i = 0; i < 3; i++) {  
22.                 var deletePos = puCards.indexOf(first + i);  
23.                 if (deletePos >= 0) {  
24.                     puCards.splice(deletePos, 1);  
25.                 }  
26.                 else {  
27.                     puLaizi--;  
28.                 }  
29.             }  
30.             if (isPu(puCards, puLaizi)) {  
31.                 // 剩下的牌成扑  
32.                 return true;  
33.             }  
34.         }  
35.     }  
36.     // 若第一张是刻子中的一张  
37.     var keziCount = 1;  
38.     var keziCard = cards[0];  
39.     if (cards[1] == keziCard) {  
40.         keziCount++;  
41.     }  
42.     if (cards[2] == keziCard) {  
43.         keziCount++;  
44.     }  
45.     if (keziCount == 3 || keziCount + laizi >= 3) {  
46.         var puCards = cards.slice();  
47.         var puLaizi = laizi;  
48.         for (var i = 0; i < 3; i++) {  
49.             var deletePos = puCards.indexOf(keziCard);  
50.             if (deletePos >= 0) {  
51.                 puCards.splice(deletePos, 1);  
52.             }  
53.             else {  
54.                 puLaizi--;  
55.             }  
56.         }  
57.         if (isPu(puCards, puLaizi)) {  
58.             return true;  
59.         }  
60.     }  
61.     return false;  
62. }  

下面是判断胡牌的函数：

1. function canHuLaizi(cards, laizi) {  
2.     if ((cards.length + laizi + 1) % 3 != 0) {  
3.         // 若牌张数不是2、5、8、11、14则不能胡  
4.         return false;  
5.     }  
6.     // 排序方便胡牌判断  
7.     cards.sort(function(a, b) {  
8.         return a - b;  
9.     })  
10.     // 依次删除一对牌做将，其余牌全部成扑则可胡  
11.     for (var i = 0; i < cards.length; i++) {  
12.         if (i > 0 && cards[i] == cards[i - 1]){  
13.             // 和上一次是同样的牌，避免重复计算  
14.             continue;   
15.         }  
16.         if ((i + 1 < cards.length && cards[i] == cards[i + 1]) || laizi > 0) {  
17.             // 找到对子、或是用一张癞子拼出的对子  
18.             var puCards = cards.slice();  
19.             var puLaizi = laizi;  
20.             puCards.splice(i, 1);  
21.             if (puCards[i] == cards[i]) {  
22.                 puCards.splice(i, 1);  
23.             }  
24.             else {  
25.                 puLaizi--;  
26.             }  
27.             // 删去对子判断剩下的牌是否成扑  
28.             if (isPu(puCards, puLaizi)) {  
29.                 return true;  
30.             }  
31.         }  
32.     }  
33.     if (laizi >= 2 && isPu(cards, laizi - 2)) {  
34.         // 两个癞子做将牌  
35.         return true;  
36.     }  
37.     return false;  
38. }  

这里做一下两个输入参数的说明：

1. // cards：手牌数组，不超过14张牌，每张牌由整数表示如下  
2. // 条：1, 2, 3, 4, 5, 6, 7, 8, 9,  
3. // 万：11, 12, 13, 14, 15, 16, 17, 18, 19,  
4. // 筒：21, 22, 23, 24, 25, 26, 27, 28, 29,  
5. // 东南西北中发白：31, 41, 51, 61, 71, 81, 91,  
6. //   
7. // laizi：癞子数量，用整数表示  

http://xingbinice.iteye.com/blog/2380673