• 数据结构与算法-德州扑克算法详解
  • 暖风 发表于 2016/3/5 10:58:00 | 分类标签: 数据结构 算法 德州扑克
  • 这几个月一直在做一个德州扑克的服务器,分享下在计算最大牌型,比牌逻辑的算法和洗牌的方法,希望对大家有帮助。

    首先我们定义一下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的一副牌

    手牌等级

    第一张牌

    第二张牌

    第三张牌

    第四张牌

    第五张牌

    10

    A(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;

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

  • 请您注意

    ·自觉遵守:爱国、守法、自律、真实、文明的原则

    ·尊重网上道德,遵守《全国人大常委会关于维护互联网安全的决定》及中华人民共和国其他各项有关法律法规

    ·严禁发表危害国家安全,破坏民族团结、国家宗教政策和社会稳定,含侮辱、诽谤、教唆、淫秽等内容的作品

    ·承担一切因您的行为而直接或间接导致的民事或刑事法律责任

    ·您在编程中国社区新闻评论发表的作品,本网站有权在网站内保留、转载、引用或者删除

    ·参与本评论即表明您已经阅读并接受上述条款

  • 感谢本文作者
  • 作者头像
  • 昵称:暖风
  • 加入时间:2013/5/17 0:00:00
  • TA的签名
  • 这家伙很懒,虾米都没写
  • +进入TA的空间
  • 以下内容也很赞哦
分享按钮