麻将胡牌判定的问题

问题描述：

前面去面试，需要设计一个算法检测麻将是否可以胡牌。简单描述如下：胡牌的规则为，有一个同样的两张牌做将，然后剩下的组成ABC或者AAA的形式。假设有13张牌，都是万字。不存在碰或者杠等特殊情况，判断这13张牌是否可以听牌。如果可以，输出此时作为将的牌和可以听的牌。

实现的代码如下：

package com.rampage.algorithm.base;

import java.util.ArrayList;
import java.util.List;

/**
 * 麻将游戏
 * @author zyq
 *
 */
public class MahjongGame {
    public static void main(String[] args) {
        MahjongGame game = new MahjongGame();
        
        // 可能有两组将的情况下
        int[] arr = {1, 1, 1, 1, 3, 3, 2, 2, 5, 6, 7, 8, 8};
        game.detectHu(arr);
    }
    
    /**
     * 校验是否可以胡牌，并且输出所有胡牌情况下将和听的牌。13张牌的数组，假设都是万（如果包括其他的花色其实道理一样）。胡牌的规则为：有一个同样的两张牌做将，然后剩下的组成ABC或者AAA的形式。
     * @param arr
     */
    private void detectHu(int[] arr) {
        if (arr == null || arr.length != 13) {
            System.out.println("Illegal array for mahjong game!");
            return;
        }
        
        // 定义一个新的数组，存储每一个万出现的次数
        int[] countArr = new int[10];
        for (int i=0; i<arr.length; i++) {
            countArr[arr[i]]++;
        }
        
        // 我们的算法思路是：先依次假设每一个牌作为将，剩下牌的再去判断是否满足ABC的形式。
        List<Hu> possibleHu = new ArrayList<Hu>();    // 存储胡的结果列表
        for (int i=1; i<=9; i++) {
            // 如果对应的万字牌个数小于两个，则不可能做将。这里直接忽略。
            if (countArr[i] < 2) {
                continue;
            }
            
            // 用一个全新的数组，判断数组中的数是否都满足ABC的形式。
            int[] newArr = new int[countArr.length];
            List<Integer> tings = new ArrayList<Integer>();
            
            // 我们可以假设每次听的不同的万字牌，将要胡的万字牌加进去之后，如果剩下的牌满足AAA或者ABC模式，则证明可以听该万字牌
            for (int j=1; j<=9; j++) {
                System.arraycopy(countArr, 0, newArr, 0, newArr.length);
                newArr[i] -= 2;            // 对应做将的万字个数减2
                if (j == i && newArr[j] + 1 > 2) {    // 不能超过4个牌
                    continue;
                } else {
                    if (newArr[j] + 1 > 4) {    // 不能超过4个牌
                        continue;
                    }
                    newArr[j] += 1;        // 假设听该万字牌
                }
                
                if (isABCOrAAAPattern(newArr)) {
                    tings.add(j);
                }
            }
            
            // 当以i为将的时候存在可以听得牌，则证明该将可以胡。将其存入结果列表
            if (!tings.isEmpty()) {
                Hu newOne = new Hu();
                newOne.jiang = i;
                newOne.tings = tings;
                possibleHu.add(newOne);
            }
            
        }
        
        if (possibleHu.isEmpty()) {
            System.out.println("The mahjong could not hu!");
        } else {
            System.out.println("The mahjong could hu!Possible hu method show as below:");
            for (Hu one : possibleHu) {
                System.out.print("Jiang:" + one.jiang + ", ting:");
                for (Integer ting : one.tings) {
                    System.out.print(ting + "|");
                }
                System.out.println();
            }
        }
    }
    
    /**
     * 校验数组是否满足ABC形式
     * @param newArr
     */
    private boolean isABCOrAAAPattern(int[] newArr) {
        for (int i=0; i<newArr.length - 2; i++) {
            // 一旦有3张的情况，必然只能是AAA类型的，其他情况都是ABC类型的
            while (newArr[i] > 0 && newArr[i] != 3) {    
                newArr[i] -= 1;
                if (newArr[i + 1] == 0) {
                    return false;
                } else {
                    newArr[i + 1] -= 1;
                }
                
                if (newArr[i + 2] == 0) {
                    return false;
                } else {
                    newArr[i + 2] -= 1;
                }
            }
        }
        
        // 剩下的如果每个万字牌的个数为0或者3。才表示可以听此牌。
        for (int i=0; i<newArr.length; i++) {
            if (newArr[i] != 0 && newArr[i] != 3) {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * 定义胡牌的情况，将和听的牌
     * @author zyq
     *
     */
    private class Hu {
        private int jiang;
        private List<Integer> tings;    // 可能听的牌不止一张
    }
}

输出的结果如下：

The mahjong could hu!Possible hu method show as below:
Jiang:1, ting:8|
Jiang:8, ting:4|