Botzone斗地主算法的简单思路

最新推荐文章于 2019-04-22 17:23:58 发布
最新推荐文章于 2019-04-22 17:23:58 发布
阅读量4.8k 收藏 19
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40841416/article/details/80549325
版权
本文介绍了采用深搜+评估+特例优化策略在Botzone斗地主比赛中的应用，算法在积分赛中表现出色。尽管已开发了对战平台，但未使用机器学习优化参数。提供算法实现代码和报告PDF，建议阅读算法报告以了解详情。
摘要由CSDN通过智能技术生成

深搜+评估+特例优化

（在积分赛的表现大概处于20名左右的位置。）现在的天梯排名10名左右，不是该版本。

如果可以用机器学习的方法优化参数就好了，虽然开发了对战平台，但并没有用于炼丹。后附实现代码，对战平台及算法报告pdf。

建议先看一看算法报告！

算法报告链接：https://pan.baidu.com/s/119b3MlZfZjXgkZB5cO3A5Q 密码：d1tg

具体算法如下：

// 斗地主（FightTheLandlord）程序
// 深搜策略
// 最后更新于2018-6-3
// 作者：dreamingshao基于zhouhy框架下开发
// 游戏信息：http://www.botzone.org/games#FightTheLandlord

#include <iostream>
#include <set>
#include <string>
#include <cassert>
#include <cstring> // 注意memset是cstring里的
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <exception>
#include "jsoncpp/json.h" // 在平台上，C++编译时默认包含此库
using std::cout;
using std::endl;
using std::vector;
using std::sort;
using std::unique;
using std::set;
using std::string;
using std::time;
using std::srand;
using std::rand;
using std::exception;
constexpr int PLAYER_COUNT = 3;

enum class CardComboType
{
	PASS, // 过
	SINGLE, // 单张
	PAIR, // 对子
	STRAIGHT, // 顺子
	STRAIGHT2, // 双顺
	TRIPLET, // 三条
	TRIPLET1, // 三带一
	TRIPLET2, // 三带二
	BOMB, // 炸弹
	QUADRUPLE2, // 四带二（只）
	QUADRUPLE4, // 四带二（对）
	PLANE, // 飞机
	PLANE1, // 飞机带小翼
	PLANE2, // 飞机带大翼
	SSHUTTLE, // 航天飞机
	SSHUTTLE2, // 航天飞机带小翼
	SSHUTTLE4, // 航天飞机带大翼
	ROCKET, // 火箭
	INVALID // 非法牌型
};

int cardComboScores[] = {
	0, // 过
	1, // 单张
	2, // 对子
	6, // 顺子
	6, // 双顺
	4, // 三条
	4, // 三带一
	4, // 三带二
	10, // 炸弹
	8, // 四带二（只）
	8, // 四带二（对）
	8, // 飞机
	8, // 飞机带小翼
	8, // 飞机带大翼
	10, // 航天飞机（需要特判：二连为10分，多连为20分）
	10, // 航天飞机带小翼
	10, // 航天飞机带大翼
	16, // 火箭
	0 // 非法牌型
};

#ifndef _BOTZONE_ONLINE
string cardComboStrings[] = {
	"PASS",
	"SINGLE",
	"PAIR",
	"STRAIGHT",
	"STRAIGHT2",
	"TRIPLET",
	"TRIPLET1",
	"TRIPLET2",
	"BOMB",
	"QUADRUPLE2",
	"QUADRUPLE4",
	"PLANE",
	"PLANE1",
	"PLANE2",
	"SSHUTTLE",
	"SSHUTTLE2",
	"SSHUTTLE4",
	"ROCKET",
	"INVALID"
};
#endif

// 用0~53这54个整数表示唯一的一张牌
using Card = short;
constexpr Card card_joker = 52;
constexpr Card card_JOKER = 53;

// 除了用0~53这54个整数表示唯一的牌，
// 这里还用另一种序号表示牌的大小（不管花色），以便比较，称作等级（Level）
// 对应关系如下：
// 3 4 5 6 7 8 9 10	J Q K	A	2	小王	大王
// 0 1 2 3 4 5 6 7	8 9 10	11	12	13	14
using Level = short;
constexpr Level MAX_LEVEL = 15;
constexpr Level MAX_STRAIGHT_LEVEL = 11;
constexpr Level level_joker = 13;
constexpr Level level_JOKER = 14;

/**
* 将Card变成Level
*/
constexpr Level card2level(Card card)
{
	return card / 4 + card / 53;
}

// 牌的组合，用于计算牌型
struct CardCombo
{
	// 表示同等级的牌有多少张
	// 会按个数从大到小、等级从大到小排序
	struct CardPack
	{
		Level level;
		short count;

		bool operator< (const CardPack& b) const
		{
			if (count == b.count)
				return level > b.level;
			return count > b.count;
		}
	};
	vector<Card> cards; // 原始的牌，未排序
	vector<CardPack> packs; // 按数目和大小排序的牌种
	CardComboType comboType; // 算出的牌型
	Level comboLevel = 0; // 算出的大小序

						  /**
						  * 检查个数最多的CardPack递减了几个
						  */
	int findMaxSeq() const
	{
		for (unsigned c = 1; c < packs.size(); c++)
			if (packs[c].count != packs[0].count ||
				packs[c].level != packs[c - 1].level - 1)
				return c;
		return packs.size();
	}

	/**
	* 这个牌型最后算总分的时候的权重
	*/
	int getWeight() const
	{
		if (comboType == CardComboType::SSHUTTLE ||
			comboType == CardComboType::SSHUTTLE2 ||
			comboType == CardComboType::SSHUTTLE4)
			return cardComboScores[(int)comboType] + (findMaxSeq() > 2) * 10;
		return cardComboScores[(int)comboType];
	}

	// 创建一个空牌组
	CardCombo() : comboType(CardComboType::PASS) {}

	/**
	* 通过Card（即short）类型的迭代器创建一个牌型
	* 并计算出牌型和大小序等
	* 假设输入没有重复数字（即重复的Card）
	*/
	template <typename CARD_ITERATOR>
	CardCombo(CARD_ITERATOR begin, CARD_ITERATOR end)
	{
		// 特判：空
		if (begin == end)
		{
			comboType = CardComboType::PASS;
			return;
		}

		// 每种牌有多少个
		short counts[MAX_LEVEL + 1] = {};

		// 同种牌的张数（有多少个单张、对子、三条、四条）
		short countOfCount[5] = {};
		cards = vector<Card>(begin, end);
		for (Card c : cards)
			counts[card2level(c)]++;
		for (Level l = 0; l <= MAX_LEVEL; l++)
			if (counts[l])
			{
				packs.push_back(CardPack{ l, counts[l] });
				countOfCount[counts[l]]++;
			}
		sort(packs.begin(), packs.end());

		// 用最多的那种牌总是可以比较大小的
		comboLevel = packs[0].level;

		// 计算牌型
		// 按照 同种牌的张数 有几种 进行分类
		vector<int> kindOfCountOfCount;
		for (int i = 0; i <= 4; i++)
			if (countOfCount[i])
				kindOfCountOfCount.push_back(i);
		sort(kindOfCountOfCount.begin(), kindOfCountOfCount.end());

		int curr, lesser;

		switch (kindOfCountOfCount.size())
		{
		case 1: // 只有一类牌
			curr = countOfCount[kindOfCountOfCount[0]];
			switch (kindOfCountOfCount[0])
			{
			case 1:
				// 只有若干单张
				if (curr == 1)
				{
					comboType = CardComboType::SINGLE;
					return;
				}
				if (curr == 2 && packs[1].level == level_joker)
				{
					comboType = CardComboType::ROCKET;
					return;
				}
				if (curr >= 5 && findMaxSeq() == curr &&
					packs.begin()->level <= MAX_STRAIGHT_LEVEL)
				{
					comboType = CardComboType::STRAIGHT;
					return;
				}
				break;
			case 2:
				// 只有若干对子
				if (curr == 1)
				{
					comboType = CardComboType::PAIR;
					return;
				}
				if (curr >= 3 && findMaxSeq() == curr &&
					packs.begin()->level <= MAX_STRAIGHT_LEVEL)
				{
					comboType = CardComboType::STRAIGHT2;
					return;
				}
				break;
			case 3:
				// 只有若干三条
				if (curr == 1)
				{
					comboType = CardComboType::TRIPLET;
					return;
				}
				if (findMaxSeq() == curr &&
					packs.begin()->level <= MAX_STRAIGHT_LEVEL)
				{
					comboType = CardComboType::PLANE;
					return;
				}
				break;
			case 4:
				// 只有若干四条
				if (curr == 1)
				{
					comboType = CardComboType::BOMB;
					return;
				}
				if (findMaxSeq() == curr &&
					packs.begin()->level <= MAX_STRAIGHT_LEVEL)
				{
					comboType = CardComboType::SSHUTTLE;
					return;
				}
			}
			break;
		case 2: // 有两类牌
			curr = countOfCount[kindOfCountOfCount[1]];
			lesser = countOfCount[kindOfCountOfCount[0]];
			if (kindOfCountOfCount[1] == 3)
			{
				// 三条带？
				if (kindOfCountOfCount[0] == 1)
				{
					// 三带一
					if (curr == 1 && lesser == 1)
					{
						comboType = CardComboType::TRIPLET1;
						return;
					}
					if (findMaxSeq() == curr && lesser == curr &&
						packs.begin()->level <= MAX_STRAIGHT_LEVEL)
					{
						comboType = CardComboType::PLANE1;
						return;
					}
				}
				if (kindOfCountOfCount[0] == 2)
				{
					// 三带二
					if (curr == 1 && lesser == 1)
					{
						comboType = CardComboType::TRIPLET2;
						return;
					}
					if (findMaxSeq() == curr && lesser == curr &&
						packs.begin()->level <= MAX_STRAIGHT_LEVEL)
					{
						comboType = CardComboType::PLANE2;
						return;
					}
				}
			}
			if (kindOfCountOfCount[1] == 4)
			{
				// 四条带？
				if (kindOfCountOfCount[0] == 1)
				{
					// 四条带两只 * n
					if (curr == 1 && lesser == 2)
					{
						comboType = CardComboType::QUADRUPLE2;
						return;
					}
					if (findMaxSeq() == curr && lesser == curr * 2 &&
						packs.begin()->level <= MAX_STRAIGHT_LEVEL)
					{
						comboType = CardComboType::SSHUTTLE2;
						return;
					}
				}
				if (kindOfCountOfCount[0] == 2)
				{
					// 四条带两对 * n
					if (curr == 1 && lesser == 2)
					{
						comboType = CardComboType::QUADRUPLE4;
						return;
					}
					if (findMaxSeq() == curr && lesser == curr * 2 &&
						packs.begin()->level <= MAX_STRAIGHT_LEVEL)
					{
						comboType = CardComboType::SSHUTTLE4;
						return;
					}
				}
			}
		}

		comboType = CardComboType::INVALID;
	}

	/**
	* 判断指定牌组能否大过当前牌组（这个函数不考虑过牌的情况！）
	*/
	bool canBeBeatenBy(const CardCombo& b) const
	{
		if (comboType == CardComboType::INVALID || b.comboType == CardComboType::INVALID)
			return false;
		if (b.comboType == CardComboType::ROCKET)
			return true;
		if (b.comboType == CardComboType::BOMB)
			switch (comboType)
			{
			case CardComboType::ROCKET:
				return false;
			case CardComboType::BOMB:
				return b.comboLevel > comboLevel;
			default:
				return true;
			}
		return b.comboType == comboType && b.cards.size() == cards.size() && b.comboLevel > comboLevel;
	}

	/**
	* 从指定手牌中寻找第一个能大过当前牌组的牌组
	* 如果随便出的话只出第一张
	* 如果不存在则返回一个PASS的牌组
	*/
	template <typename CARD_ITERATOR>
	CardCombo findFirstValid(CARD_ITERATOR begin, CARD_ITERATOR end) const
	{
		if (comboType == CardComboType::PASS) // 如果不需要大过谁，只需要随便出
		{
			CARD_ITERATOR second = begin;
			second++;
			return CardCombo(begin, second); // 那么就出第一张牌……
		}

		// 然后先看一下是不是火箭，是的话就过
		if (comboType == CardComboType::ROCKET)
			return CardCombo();

		// 现在打算从手牌中凑出同牌型的牌
		auto deck = vector<Card>(begin, end); // 手牌
		short counts[MAX_LEVEL + 1] = {};

		unsigned short kindCount = 0;

		// 先数一下手牌里每种牌有多少个
		for (Card c : deck)
			counts[card2level(c)]++;

		// 手牌如果不够用，直接不用凑了，看看能不能炸吧
		if (deck.size() < cards.size())
			goto failure;

		// 再数一下手牌里有多少种牌
		for (short c : counts)
			if (c)
				kindCount++;

		// 否则不断增大当前牌组的主牌，看看能不能找到匹配的牌组
		{
			// 开始增大主牌
			int mainPackCount = findMaxSeq();
			bool isSequential =
				comboType == CardComboType::STRAIGHT ||
				comboType == CardComboType::STRAIGHT2 ||
				comboType == CardCom
最低0.47元/天 解锁文章
Dreaming_shao
关注
斗地主算法之点选牌
棋牌游戏开发
05-15 9285
斗地主算法之点选牌                            -------BY wojiushi3344                                      QQ：513670524               PS:最近找了2个朋友主准备把斗地主游戏重写，由于种种原因今天还没有开始，所以先把基本的算法写一写，为以后写项目做准备。如果你对斗地主游戏比较感兴
斗地主算法
goldDaNiu的博客
06-08 824
https://blog.csdn.net/sm9sun/article/details/70787814
斗地主核心算法
03-09
斗地主的核心相关算法，机器人和出牌提示可以在此基础上继续完善
botzone Tetris2
weixin_30878501的博客
11-28 133
为了证明窝最近没有颓废 （并且为了多骗点访问量 游戏链接：https://botzone.org/game/Tetris2 大概就是先写个估价，然后剪剪枝搜它4步。 #include<iostream> #include<string> #include<cmath> #include<algorithm> ...
斗地主残局算法python
08-27
本项目"斗地主残局算法python"专注于实现一个Python程序，能够接受地主和农民的牌型输入，并自动计算出地主的最佳出牌策略。 首先，我们要理解斗地主的牌型。牌型包括单张、对子、三张、三带一、三带二、顺子、飞机...
斗地主算法思路
zhanghow的博客
01-02 8828
1、扑克牌类的封装 用一个枚举存储牌的大类型（黑红梅方），再用一个枚举存储牌的小类型（A~K,dawang,xaiowang）。 牌的属性：id(0~53)54张牌唯一标识 根据id分别获得牌的大类型与小类型 牌的等级：grade 大王等级最高 对牌排序的时候用到 2、洗牌与发牌算法思路 a.洗牌算法的思路就是，构造54张牌，首先从所有元素中随机选取一个与第
ddz.rar_ddz_java 斗地主_java斗地主_java斗地主算法
最新发布
09-22
斗地主游戏的算法主要包含以下几个部分： 1. **发牌算法**：确保每个玩家得到17张牌，地主额外得到三张底牌。 2. **牌型判断**：识别玩家手中的牌型，如单张、对子、连对、三带一、三带二、顺子、炸弹等。 3. **出...
易语言斗地主算法模块
07-18
易语言斗地主算法模块源码,斗地主算法模块,GetCardType,GetCardValue,GetCardColor,RandCardList,SortCardList,RemoveCardList,GetCardLogicValue,CompareCard,MakeCardData,AnalysebCardData,AnalysebDistributing
C#斗地主算法（绝对精华）
06-30
本算法用C#编写，根据斗地主出牌规则.对玩家出的牌进行检验.判断是否符合出牌规则。
C# 斗地主发牌算法
05-29
需要就下吧,呵呵.请各位高手给我指教 源码使用C#编写,希望能给您帮助
C# 斗地主算法核心代码
11-24
网上发现很多C#学的斗地主算法，看了之后自我感觉很Low，影响效率，就自己写了一套，里面只有核心代码。
简单的斗地主小游戏
09-23
利用GDI和双缓冲技术设计的简单的斗地主AI程序，AI策略是依据百度文库里面介绍的，实现的不是很好。 但是可以作为学习的资料。
C#单机版斗地主源码
11-15
C#单机版斗地主源码，亲测可以运行，可以参考参考，代码写的很好
斗地主算法（3）
记录一下学习笔记和看到值得记录的文章
03-02 4289
前面写完牌型的判断下面写几个后面牌型比较要用的方法 牌型的排序（带花色） function compareFunc(c1, c2) if CardUtils.getValue(c1) == CardUtils.getValue(c2) then return CardUtils.getSuit(c1) > CardUtils.getSuit(c2) end return C
斗地主的概率问题
weixin_33924770的博客
10-22 1571
不少人都爱玩斗地主，牌好了就叫地主，不好就跟着当农民，有时候一手烂牌，总说运气不好，那么运气好有几成几率呢？今天我就来研究研究运气好坏是怎样的概率…… 首先，看看抓到两个王的情况，首先不翻开底牌时,你手里的牌有C{17,54}种情况,其中抓到两个王的情况有C{15,52}种情况,经计算,抓到两个王的概率应该是是C{15,52}/C{17,54}=52!/15!/37!/54!*17!*37!=13...
【原创】一个计算斗地主谁必赢谁必输的程序
hll127的专栏
04-22 6827
这个程序的缘由是看到朋友圈里发布了这么一张图： 我是个斗地主菜鸟啊，反正一时半会是没看出来到底谁能赢，但是我对这类问题倒是很有兴趣，真好我那阵也写过几个类似这种动态规划算法的程序，于是我开发了一个小软件来计算题目所述的情况下到底是谁必赢，而且还可以修改能出什么牌的规则，如下图： 难点是出牌规则这块，不过最后还是克服了，算出来的结果是地主赢，网上搜了一下答案，符合。当然除了程序猿，...
斗地主AI算法——第十七章の总结整理
热门推荐
九日王朝
04-27 1万+
2.0版本的斗地主AI算法在这里就算告一段落了。 **********************完结撒花********************** 不过后续应该还会开发更智能的版本，毕竟当前版本还有很多策略没有加入。 比如说角色位置（地主上家下家打法）、比如说记牌算牌、又比如对于一些残局的分析等等。 斗地主规则看似简单，实际变幻莫测，也包含一些心理上的博弈。而我想做的AI，不一定要做到最牛
斗地主AI算法解析
"斗地主AI算法的详细讲解文档" 斗地主AI算法是一种在计算机科学领域，特别是游戏人工智能中的一个重要研究课题。它涉及到人工智能、博弈论、概率论、搜索算法等多个方面的知识。斗地主是一种三人对战的扑克游戏，AI...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值