分享一个德州扑克的算法 – archy_yu – 博客园

来源: 分享一个德州扑克的算法 – archy_yu – 博客园

德州扑克想必很多人都玩过,当然对于新手需要说明的是,德州指的是德克萨斯州,而不是山东德州。

这几个月一直在做一个德州扑克的服务器,分享下在计算最大牌型,比牌逻辑的算法和洗牌的方法,希望对大家有帮助。

首先我们定义一下Poker类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class Poker
{
    private String tag; // 图片扑克花色的表示(代表的是红桃、黑桃,梅花、方块
    private int num; // 表示扑克牌面的大
    public Poker(String tag, int num)
    {
        this.num = num;
        this.tag = tag;
    }
    public int getNum()
    {
        return num;
    }
    public void setNum(int num)
    {
        this.num = num;
    }
    public void setTag(String tag)
    {
        this.tag = tag;
    }
    public String getTag()
    {
        return tag;
    }
    
    
    public String toString()
    {
        return " tag: " + this.tag +" num: " + this.num;
    }
    
    
}

这里说明下,ABCD代表四种不同的花色,2-16代表不同的牌面,A用14代替,我想不用多解释吧!

首先是洗牌这块,我们奔着不重复造轮子的思想,借用Collections.shuffle(List)接口,去将52张牌打乱顺序,然后随机随机抽取。

首先是,获取每个玩家的最大牌型,即从N张扑克中取出5张最大的,我们从N张牌中抽出5张牌,有N多种算法,这里给出一个算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
private static Map<Integer, List<Poker>> SevenToFiveGroups(List<Poker> map)
    {
        Map<Integer, List<Poker>> group = new HashMap<Integer, List<Poker>>();
        int num = 0;
        for (int a = 0; a < 3; a++)
        {
            for (int b = a + 1; b < 4; b++)
            {
                for (int c = b + 1; c < 5; c++)
                {
                    for (int d = c + 1; d < 6; d++)
                    {
                        for (int e = d + 1; e < 7; e++)
                        {
                            List<Poker> pukeGroup = new ArrayList<Poker>();
                            pukeGroup.add(map.get(a));
                            pukeGroup.add(map.get(b));
                            pukeGroup.add(map.get(c));
                            pukeGroup.add(map.get(d));
                            pukeGroup.add(map.get(e));
                            group.put(num++, pukeGroup);
                        }
                    }
                }
            }
        }
        num = 0;
        return group;
    }

在取得所有可能的组合之后,我们从这些组合中得到最大的一副手牌。为 了得到最大的一副手牌,我们计算每付(五张牌)手牌的大小。首先对这五张牌进行排序,从大到小,手牌的大小为一个Long整形的数,手牌等级占两位(比如 高牌为10,一对为11,二两为12,以此类推),五张扑克,每张扑克的数值占两位,所以手牌的大小是一个12位的整数,

比如图1.2的一副牌

手牌等级第一张牌第二张牌第三张牌第四张牌第五张牌
10A(A)U(B)10(C)9(D)7(C)

图1.2

这副手牌的大小为 101412100907

需要注意的是,在遇到有对子的是情况,无论是两对还是三双,都要进行特殊排 序,葫芦和三双的情况下,要把三个一样的大的牌排到前面,然后再排对子,这样才能保证在比较牌大小的情况下,正确比较出大小。还有就是在遇到A2345这 样的顺子的情况下,要讲A排在最后,因为34567的顺子是比A2345大的。当然这两种情况是属于比较特殊情况,需要特别处理。

对应程序的算法为:

首先计算手牌的等级,如果是顺子或者同花就不用说了,对子三双葫芦起始是相对比较难比较的,这里给出一个算法,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
int Pukelevel = -1;
        int flag = 0;
        for (int i = 0; i < list.size(); i++)
        {
            for (int j = i + 1; j < list.size(); j++)
            {
                if (list.get(i).getNum() == list.get(j).getNum())
                {
                    flag++;
                }
            }
        }
        switch (flag)
        {
        case 6:
                         四条
        case 4:
                         葫芦
        case 3:
            三条
        case 2:
            两队
        case 1:
            一对
        case 0:
            高牌
        }             

this.level即牌型, 就是这样计算出来的,然后就是计算这副手牌的大小了!

1
2
3
4
5
6
7
8
9
10
11
12
13
long lon = 1000000000L * 10;
        this.pkValue = 0L;
        for(int i = 0 ; i < this.list.size() ; i++)
        {
            int interval = 1;
            for(int j = i ; j < this.list.size() - 1 ; j ++)
            {
                interval *= 10;
                interval *= 10;
            }
            this.pkValue += this.list.get(i).getNum() * interval;
        }
        this.pkValue += this.level * lon;

剩下的就是对所有的情况,进行排序;所有玩家比较的时候,也是这样的情况!

希望对大家有帮助。

分享到: 更多 (0)