【算法】雀魂启动（笔试题）

小包最近迷上了一款叫做雀魂的麻将游戏，但是这个游戏规则太复杂，小包玩了几个月了还是输多赢少。

于是生气的小包根据游戏简化了一下规则发明了一种新的麻将，只留下一种花色，并且去除了一些特殊胡牌方式（例如七对子等），具体的规则如下：

总共有36张牌，每张牌是1~9。每个数字4张牌。

你手里有其中的14张牌，如果这14张牌满足如下条件，即算作胡牌14张牌中有2张相同数字的牌，称为雀头（将）。

除去上述2张牌，剩下12张牌可以组成4个顺子或刻子。顺子的意思是递增的连续3个数字牌（例如234,567等），刻子的意思是相同数字的3个数字牌（例如111,777）。

例如：

• 1 1 1 2 2 2 6 6 6 7 7 7 9 9
  可以组成1,2,6,7的4个刻子和9的将，可以胡牌。

• 1 1 1 1 2 2 3 3 5 6 7 7 8 9
  用1做将，组123,123,567,789的四个顺子，可以胡牌。

• 1 1 1 2 2 2 3 3 3 5 6 7 7 9
  无论用1 2 3 7哪个做将，都无法组成胡牌的条件。

现在，小包从36张牌中抽取了13张牌，他想知道在剩下的23张牌中，再取一张牌，取到哪几种数字牌可以胡牌。

输入描述:

输入只有一行，包含13个数字，用空格分隔，每个数字在1~9之间，数据保证同种数字最多出现4次。

输出描述:

输出同样是一行，包含1个或以上的数字。代表他再取到哪些牌可以胡牌。若满足条件的有多种牌，请按从小到大的顺序输出。
若没有满足条件的牌，请输出一个数字0

分析过程

1. 接牌 接收输入参数
2. 码牌 对13个输入参数整理，计算牌池中剩余的各数字的剩余张数
3. 胡牌 遍历牌池 判断接到牌 是否可以凑成胡牌

胡牌的条件 14张牌，每数字牌不大于4张，必须有将，剩下的可以是顺子、刻子像平时打麻将是一样的，当我们发现满足条件时我们会把这些牌扣起来，应为它并不应该我们后面的组牌。
在这里我们这个把满足条件的牌，从待胡牌集合中删除，直到集合为空时，说明符合胡牌条件，如果不为集合空且不能继续按规则删除牌时，说明不符合胡牌条件。

在码牌环节我们对手中的牌进行排序，这样们可以从左到右一次的扣牌：

1. 将是必须存在的，去掉将后剩下的牌数都是3的倍数，因为后面的必须可以凑成 顺子 或者 刻子，所以当前牌张数是不3的倍数，遇到大于第一张牌的数字张数大于等于两个的牌，且剩下的牌可以继续 胡牌，才可以先扣下一对牌；
2. 有意义的牌都扣下了，所以还是从第一张牌进行判断，第一张牌重复且大于等于3张时，扣下这3张牌；
3. 从第一张牌进行判断，第一张牌不重复且和后面存在 可以和第一张连续的数字，扣下这3张牌；
4. 前面三种规则都不满时，说明出现了无用的单牌，就不能胡牌了呀！
   源代码

   package com.company;
   import java.util.*;
   public class Gxs_quehun_3 {
       private void sln() {
           Scanner sc = new Scanner(System.in);
           int[] state = new int[9];
           int[] helpArr = new int[9];
           ArrayList<Integer> res = new ArrayList<>();
           for (int i = 0; i < 13; i++) {
               int num = sc.nextInt();
               state[num - 1]++; // 存储13张牌中，每个的个数。例如，几个1，几个2
           }
           for (int i = 0; i < 9; i++) {
               if (state[i] < 4) {  // 大于4以后，就不用取啦，一个有4张牌
                   int num = i + 1;
                   System.arraycopy(state, 0, helpArr, 0, 9);
                   helpArr[i]++;  //i 代表新加的那个数，让它自加1，也就是从13张牌到了14张
                   if (canHu(helpArr, 14, false))
                       res.add(num);
               }
           }
           if (res.isEmpty()) System.out.println(0);
           else {
               StringBuffer sbf = new StringBuffer();
               sbf.append(res.get(0));
               for (int i = 1; i < res.size(); i++) {
                   sbf.append(" ");
                   sbf.append(res.get(i));
               }
               System.out.println(sbf.toString());
           }
       }
   
       private boolean canHu(int[] arr, int total, boolean hasHead) {
           if (total == 0) return true;
           if (!hasHead) {
               for (int i = 0; i < 9; i++) {
                   if (arr[i] >= 2) {
                       arr[i] -= 2;   //取对子
                       if (canHu(arr, total - 2, true)) return true;  //递归，hasHead经典
                       arr[i] += 2; //如果上一步没有成功，将i的值加回来
                   }
               }
               return false;
           } else {
               for (int i = 0; i < 9; i++) {
                   if (arr[i] > 0) {
                       if (arr[i] >= 3) {
                           arr[i] -= 3;  //刻子 减去3
                           if (canHu(arr, total - 3, true)) return true;  //递归
                           arr[i] += 3;
                       }
                       if (i + 2 < 9 && arr[i + 1] > 0 && arr[i + 2] > 0) { //arr[i+1]>0 表示还有这个牌
                           arr[i]--;
                           arr[i + 1]--;
                           arr[i + 2]--;
                           if (canHu(arr, total - 3, true)) return true;
                           arr[i]++;
                           arr[i + 1]++;
                           arr[i + 2]++;
                       }
                   }
               }
           }
           return false;
       }
   
       public static void main(String[] args) {
           new Gxs_quehun_3().sln();
       }
   }