地主算法之判断牌型

每个游戏都有属于自己的规则，当然地主也不例外，常斗地主的朋友可能知道在斗地主里面一共有13种牌型，你所出的牌必须符合13种的一种才能够出得了牌，这个就叫地主的规则。那么我们下面可以通过一个枚举结构来表示每一种的牌型，在这里我们把错误的牌型也当成是一种牌型。

[cpp] view plain copy print ?

1. enum  CARD_TYPE  
2. {  
3.     SINGLE_CARD =1， //单牌   
4.     DOUBLE_CARD， //对子   
5.     THREE_CARD  ,//3不带   
6.     BOMB_CARD,//炸弹   
7.     THREE_ONE_CARD,//3带1   
8.     THREE_TEO_CARD,//3带2   
9.     BOMB_TWO_CARD,//四个带2张单牌   
10.     BOMB_TWOOO_CARD,//四个带2对   
11.     CONNECT_CARD,//连牌   
12.     COMPANY_CARD,//连队   
13.     AIRCRAFT_CARD,//飞机不带   
14.     AIRCRAFT_SINGLE_CARD,//飞机带单牌   
15.     AIRCRAFT_DOUBLE_CARD,//飞机带对子   
16.     ERROR_CARD      //错误的牌型   
17. };  

enum  CARD_TYPE
{
    SINGLE_CARD =1， //单牌
    DOUBLE_CARD， //对子
    THREE_CARD  ,//3不带
    BOMB_CARD,//炸弹
    THREE_ONE_CARD,//3带1
    THREE_TEO_CARD,//3带2
    BOMB_TWO_CARD,//四个带2张单牌
    BOMB_TWOOO_CARD,//四个带2对
    CONNECT_CARD,//连牌
    COMPANY_CARD,//连队
    AIRCRAFT_CARD,//飞机不带
    AIRCRAFT_SINGLE_CARD,//飞机带单牌
    AIRCRAFT_DOUBLE_CARD,//飞机带对子
    ERROR_CARD      //错误的牌型
};

                 那么在编程中我们该怎么来判断一组牌到底该属于哪一种牌型了？？

               这就是接下来我们将解决的问题，本文中可能有些判断牌型的方法不是很好，如果你有更好的方法，欢迎留言指导！~(@^_^@)~！！

               首先我们可以根据穷举的方式来罗列一下。在我以前写斗地主的时候我是根据出牌的张数来罗列牌型的，下面我也将使用这种方法，因为没有找到什么更好的方法，嘿嘿！！那就让我们开始吧！

牌的张数   可能的牌型

1张牌         单牌

2张牌         对子（排除对鬼，因为这个在出牌中出现的次数比较少）

3张牌        3不带

4张牌       3带一  炸弹

5张牌       连牌，3带1对

6,7,8,9.........

这里我们可以用出牌张数5作为分界线，因为5刚好是连牌的起始数并且出牌张数大于5之后就比较的复杂了。

我们首先定义一个数组来存放即将出牌的牌值。

在判断牌型之前将数组排序，排序规则：如果每张牌出现的次数一样，由小到大，如果不一样就将出现次数比较多的牌放在前面。比如（7,7,3,7)排序之后就变为（7,7,7,3），这样便于我们后面的判断。

出牌张数<5

        我们只需判断第一张和最后一张牌的牌值时候相等（因为我们数组已经按照我们事先的规则排序了），如果相等则直接返回牌的张数，这里牌的张数刚好对应我们前面定义的枚举结构值。如果不相等这里要分情况，当出牌的张数等于4时，判断第一张的牌值是否等于倒数第2张，如果相等我们可以直接返回THREE_ONE_CARD牌型，其余的情况可以直接返回ERROR_CARD 。

[cpp] view plain copy print ?

1. CARD_TYPE   JudgeCardTpye(int * pArray,int lenght)  
2. {  
3.       单牌，对子，3不带,炸弹通用算法  
4.       if(lenght<5) //小于5张牌   
5.       {  
6.         if(intArray[0]==intArray[lengh-1])  
7.         {  
8.             return lengh;  
9.         }  
10.         if (intArray[0]==intArray[lengh-2]&&lengh==4)  
11.         {  
12.             return THREE_ONE_CARD;  
13.         }  
14.        }  

CARD_TYPE   JudgeCardTpye(int * pArray,int lenght)
{
      单牌，对子，3不带,炸弹通用算法
      if(lenght<5) //小于5张牌
      {
		if(intArray[0]==intArray[lengh-1])
		{
			return lengh;
		}
		if (intArray[0]==intArray[lengh-2]&&lengh==4)
		{
			return THREE_ONE_CARD;
		}
       }

出牌张数>=5

当出牌张数大于5张时，所组成的牌型就比较的复杂了，可以有连牌，连对，飞机，4带2等一系列牌型。

我们先来分析一下每种牌型组成的情况

连牌：由所有的单牌组成 

连队：由所有的对子组成

飞机：由3个+对子，或者3个，或者3个+单张

4带2:4个+2张单牌，4个+2对牌，4个+1对牌

写一个计算数组中所有值是否为连续的方法。我们假设这个函数名叫做CheckContinuous，如果全连续返回true，否则返回false

下面是没种牌型的具体检查方法。

连牌牌型：if(CheckContinuous（出牌数组）==true）出牌数组中所有牌的牌值必须小于2

连队牌型：将出牌数组中的对子，挨个抽出，看是否还有剩余的牌，如果有剩余的牌就说明不能组成连队，则进行下面牌型的判断。如果没有剩余的牌，再根据判断连牌的方法来判断。（筛选条件：张数>=6张&&张数%2==0）

飞机和4带2就比较的复杂了，因为这2种牌型不像上面2种那样组成的牌比较单一，这2种牌型可以由很多种牌来组成。

接下来我们就可以定义一个结构体，来记录每种牌（单个，对子，3个，4个）出现的次数。最后我们只要根据结构体中每种牌出现的数量就很容易判断出到底是什么牌了。

struct  CRAD_INDEX

{

vector <int >  single_index;//记录单张的牌

vector<int> doble_index; //记录对子的牌

vector<int >three_index;//记录3张

vector<int> four_index;//记录张

}

飞机牌型：

我们把能组成飞机的所有牌型列举出来： 333444，33344456，3334445566,

通过一个遍历记录方法，上面结构体的值就变成这样了。

333444                     

single_index              空

doble_index               空

three_index               3,4

four_index                  空

33344456                       

single_index             5,6

doble_index              空

three_index               3,4

four_index                 空

3334445566                       

single_index              空

doble_index              5,6

three_index               3,4

four_index                 空

这3种飞机牌型都有一个共同点，three_index 中的数据必须为连续的并且four_index 必须为空。这个也是最开始筛选的条件之一，如果这个条件都不满足则直接返回。

如果上面个条件满足，接下来计算一下牌的数量就OK了

飞机不带：three_index .sziz()*3==出牌的数量&&single_index+doble_index  ==0

飞机带1张 ：three_index .sziz()*3+single_index.size()==出牌的数量&&doble_index.size()==0

飞机带1对：three_index .sziz()*3+doble_index.size()*2==出牌的数量&&single_index.size()==0

同样4带2也可以这样来分析

4带2牌型（牌张数%2==0）

还是像上面一样来列举出具体的牌型来判断

   444423  444422 44442233

4个带单张

 444423

single_index              2,3

doble_index             空

three_index               空

four_index                 4

444422

single_index             空

doble_index             2

three_index               空

four_index                 4

4个带2对

44442233

single_index             空

doble_index             2，3

three_index               空

four_index                 4

首先找出必须满足的条件：four_index .size()必须等于1，并且出牌张数%2==0，并且three_index.size（）==0

如果这个条件不满足则直接进行下面牌型的判断

如果满足就计算牌的张数

4带1

第一种情况： 带2张单牌

（(four_index.size()==1&&single_index.size()==2）||（four_index.size()+single_index.size()*4==出牌的张数））

第二种情况 ：带2对牌

（(four_index.size()==1&&doble_index.size()==1）||（four_index.size()*2+single_index.size()*4==出牌的张数））

4带2对

（(four_index.size()==1&&doble_index.size()==2）||（four_index.size()*2+single_index.size()*4==出牌的张数））

至此所有的牌型就判断完毕了！！如果一副牌上面所有的牌型都不满足则是错误的牌型！！！小弟技术有限，如果你有更好的方法欢迎留言指导。